列表与滚动

self.transactionQueue.transactionCompleted = { [weak self] in
    if let strongSelf = self {
        strongSelf.updateVisibleItemRange()
    }
}
self.scroller.alwaysBounceVertical = true
self.scroller.contentSize = CGSize(width: 0.0, height: infiniteScrollSize * 2.0)
self.scroller.isHidden = true
self.scroller.delegate = self.wrappedScrollViewDelegate
self.scroller.scrollsToTop = false
self.view.addSubview(self.scroller)
self.scroller.panGestureRecognizer.cancelsTouchesInView = true
self.view.addGestureRecognizer(self.scroller.panGestureRecognizer)
// ...
self.transactionOffset += -deltaY
self.enqueueUpdateVisibleItems(synchronous: false)
for itemNode in self.itemNodes {
    itemNode.updateFrame(itemNode.frame.offsetBy(dx: 0.0, dy: -deltaY),
        within: self.visibleSize)
}

if topItemFound && bottomItemFound {
    self.scroller.contentSize = CGSize(width: self.visibleSize.width, height: completeHeight)
    self.lastContentOffset = CGPoint(x: 0.0, y: -topItemEdge + self.tempTopInset)
    self.scroller.contentOffset = self.lastContentOffset
} else if topItemFound {
    self.scroller.contentSize = CGSize(width: self.visibleSize.width,
        height: infiniteScrollSize * 2.0)
    self.lastContentOffset = CGPoint(x: 0.0, y: -topItemEdge + self.tempTopInset)
    if self.scroller.contentOffset != self.lastContentOffset {
        self.scroller.contentOffset = self.lastContentOffset
    }
    self.lastContentOffset = self.scroller.contentOffset
} else if bottomItemFound {
    self.scroller.contentSize = CGSize(width: self.visibleSize.width,
        height: infiniteScrollSize * 2.0)
    self.lastContentOffset = CGPoint(x: 0.0,
        y: infiniteScrollSize * 2.0 - bottomItemEdge)
    self.scroller.contentOffset = self.lastContentOffset
}

self.usesCoreListBackend = useCoreListBackend
self.listView = ChatHistoryListNodeImpl.makeListView(
    rotated: rotated,
    useCoreListBackend: useCoreListBackend
)
super.init()
let _ = self.view
self.addSubnode(self.listView)
if rotated {
    self.transform = CATransform3DMakeRotation(
        CGFloat(Double.pi), 0.0, 0.0, 1.0)
}
// ...
public required init(rotated: Bool) {
    super.init(layerBacked: false, rotated: rotated)
    if rotated {
        self.transform = CATransform3DMakeRotation(
            CGFloat.pi, 0.0, 0.0, 1.0)
    }
}

public func addTransaction(_ transaction: @escaping ListViewTransaction) {
    precondition(Thread.isMainThread)
    let beginTransaction = self.transactions.count == 0
    self.transactions.append(transaction)
    if beginTransaction {
        transaction({ [weak self] in
            precondition(Thread.isMainThread)
            if Thread.isMainThread {
                if let strongSelf = self {
                    strongSelf.endTransaction()
                }
            } else {
                Queue.mainQueue().async {
                    if let strongSelf = self {
                        strongSelf.endTransaction()
                    }
                }
            }
        })
    } else {
        assert(true)
    }
}

item.updateNode(async: { f in
    if synchronous {
        f()
    } else {
        self.async(f)
    }
}, node: {
    assert(Queue.mainQueue().isCurrent())
    return previousNode.syncWith({ $0 })
}, params: params, neighbors: neighbors, animation: updateAnimation,
completion: { (layout, apply) in
    if Thread.isMainThread {
        if synchronous {
            completion(previousNode, layout, {
                return (nil, { info in
                    assert(Queue.mainQueue().isCurrent())
                    previousNode.with({ $0.index = index; $0.appliedNeighbors = neighbors })
                    apply(info)
                })
            })
        } else {
            self.async {

private func enqueueUpdateVisibleItems(synchronous: Bool) {
    if !self.enqueuedUpdateVisibleItems {
        self.enqueuedUpdateVisibleItems = true
        self.transactionQueue.addTransaction({ [weak self] completion in
            if let strongSelf = self {
                strongSelf.transactionOffset = 0.0
                strongSelf.updateVisibleItemsTransaction(synchronous: synchronous, completion: {
                    var repeatUpdate = false
                    if let strongSelf = self {
                        repeatUpdate = abs(strongSelf.transactionOffset) > 0.00001
                        strongSelf.transactionOffset = 0.0
                        strongSelf.enqueuedUpdateVisibleItems = false
                    }
                    completion()
                    if repeatUpdate {
                        strongSelf.enqueueUpdateVisibleItems(synchronous: false)
                    }
                })
            }
        })
    }
}

} else if let (stationaryIndex, stationaryOffset) = self.stationaryOffset {
    for node in self.nodes {
        if node.index == stationaryIndex {
            let offset = stationaryOffset - node.frame.minY
            if abs(offset) > CGFloat.ulpOfOne {
                for i in 0 ..< self.nodes.count {
                    var frame = self.nodes[i].frame
                    frame = frame.offsetBy(dx: 0.0, dy: offset)
                    self.nodes[i].frame = frame
                }
            }
            break
        }
    }
}

mutating func removeNodeAtIndex(_ index: Int,
    direction: ListViewItemOperationDirectionHint?, animated: Bool,
    operations: inout [ListViewStateOperation]) {
    let node = self.nodes[index]
    if case let .Node(_, _, referenceNode, _) = node {
        let nodeFrame = node.frame
        self.nodes.remove(at: index)
        let offsetDirection: ListViewInsertionOffsetDirection
        if let direction = direction {
            offsetDirection = ListViewInsertionOffsetDirection(direction)
        } else {
            if nodeFrame.maxY < self.itemOffsetInsets.top + CGFloat.ulpOfOne {
                offsetDirection = .Down
            } else {
                offsetDirection = .Up
            }
        }
        operations.append(.Remove(index: index, offsetDirection: offsetDirection))
        if let referenceNode = referenceNode, animated {
            self.nodes.insert(.Placeholder(frame: nodeFrame), at: index)
            operations.append(.InsertDisappearingPlaceholder(
                index: index, referenceNode: referenceNode,
                offsetDirection: offsetDirection.inverted()))

var requestUpdateVisibleItems = false
var index = 0
while index < self.itemNodes.count {
    let itemNode = self.itemNodes[index]
    let previousApparentHeight = itemNode.apparentHeight
    var invertOffsetDirection = false
    if itemNode.animate(timestamp: timestamp,
        invertOffsetDirection: &invertOffsetDirection) {
        continueAnimations = true
    }
    let updatedApparentHeight = itemNode.apparentHeight
    let apparentHeightDelta = updatedApparentHeight - previousApparentHeight
    if abs(apparentHeightDelta) > CGFloat.ulpOfOne {
        itemNode.updateFrame(itemNode.frame, within: self.visibleSize)
        let visualInsets = self.dynamicVisualInsets?() ?? self.visualInsets ?? self.insets
        if itemNode.apparentFrame.maxY <= visualInsets.top {
            offsetRanges.offset(IndexRange(first: 0, last: index),
                offset: -apparentHeightDelta)

let animation: CABasicAnimation
let animationCurve: ContainedViewLayoutTransitionCurve
let animationDuration: Double
switch updateSizeAndInsets.curve {
case let .Spring(duration):
    headerNodesTransition = (.animated(duration: duration, curve: .spring),
        false, -completeOffset)
    animationCurve = .spring
    let springAnimation = makeSpringAnimation("sublayerTransform", duration: duration)
    springAnimation.fromValue = NSValue(caTransform3D:
        CATransform3DMakeTranslation(0.0, -completeOffset, 0.0))
    springAnimation.toValue = NSValue(caTransform3D: CATransform3DIdentity)
    springAnimation.isRemovedOnCompletion = true
    let k = Float(UIView.animationDurationFactor())
    var speed: Float = 1.0
    if k != 0 && k != 1 {
        speed = Float(1.0) / k
    }
    if !duration.isZero {
        springAnimation.speed = speed * Float(springAnimation.duration / duration)
    }
    animationDuration = duration
    springAnimation.isAdditive = true
    animation = springAnimation

mutating func removeInvisibleNodes(_ operations: inout [ListViewStateOperation]) {
    var i = 0
    var visibleItemNodeHeight: CGFloat = 0.0
    while i < self.nodes.count {
        visibleItemNodeHeight += self.nodes[i].frame.height
        i += 1
    }
    if visibleItemNodeHeight > (self.visibleSize.height + self.invisibleInset
        + self.invisibleInset) {
        i = self.nodes.count - 1
        while i >= 0 {
            let itemNode = self.nodes[i]
            let frame = itemNode.frame
            if frame.maxY < -self.invisibleInset
                || frame.origin.y > self.visibleSize.height + self.invisibleInset {
                operations.append(.Remove(index: i,
                    offsetDirection: frame.maxY < -self.invisibleInset ? .Down : .Up))
                self.nodes.remove(at: i)
            }
            i -= 1
        }
    }
}

var stickLocationDistanceFactor: CGFloat = 0.0
var stickLocationDistance: CGFloat
switch item.stickDirection {
case .top:
    naturalY = lowerBound
    if item.isSticky {
        headerFrame = CGRect(origin: CGPoint(x: 0.0,
            y: min(max(upperDisplayBound, upperBound), lowerBound - itemHeaderHeight)),
            size: CGSize(width: self.visibleSize.width, height: itemHeaderHeight))
    } else {
        headerFrame = CGRect(origin: CGPoint(x: 0.0,
            y: min(upperBound, lowerBound - itemHeaderHeight)),
            size: CGSize(width: self.visibleSize.width, height: itemHeaderHeight))
    }
    stickLocationDistance = headerFrame.minY - upperBound
    stickLocationDistanceFactor = max(0.0,
        min(1.0, stickLocationDistance / itemHeaderHeight))
case .topEdge:
    naturalY = lowerBound
    headerFrame = CGRect(origin: CGPoint(x: 0.0,
        y: min(max(upperDisplayBound, upperBoundEdge - itemHeaderHeight),
            lowerBound - itemHeaderHeight)),
        size: CGSize(width: self.visibleSize.width, height: itemHeaderHeight))

let averageRangeItemHeight: CGFloat = 44.0
var upperItemsHeight = floor(averageRangeItemHeight
    * CGFloat(scrollingIndicatorState.topItem.index))
var approximateContentHeight = CGFloat(scrollingIndicatorState.itemCount)
    * averageRangeItemHeight
if scrollingIndicatorState.topItem.index >= 0
    && self.items[scrollingIndicatorState.topItem.index].approximateHeight.isZero {
    upperItemsHeight -= averageRangeItemHeight
    approximateContentHeight -= averageRangeItemHeight
}
var convertedTopBoundary: CGFloat
if scrollingIndicatorState.topItem.offset < self.insets.top {
    convertedTopBoundary = (scrollingIndicatorState.topItem.offset
        - scrollingIndicatorState.insets.top) * averageRangeItemHeight
        / scrollingIndicatorState.topItem.height
} else {
    convertedTopBoundary = scrollingIndicatorState.topItem.offset
        - scrollingIndicatorState.insets.top
}
convertedTopBoundary -= upperItemsHeight
let approximateOffset = -convertedTopBoundary
var convertedBottomBoundary: CGFloat = 0.0
if scrollingIndicatorState.bottomItem.offset
    > self.visibleSize.height - self.insets.bottom {

public func transferVelocity(_ velocity: CGFloat) {
    self.decelerationAnimator?.isPaused = true
    let startTime = CACurrentMediaTime()
    let decelerationRate: CGFloat = 0.998
    self.scroller.forceDecelerating = true
    self.decelerationAnimator = ConstantDisplayLinkAnimator(update: { [weak self] in
        guard let strongSelf = self else {
            return
        }
        let t = CACurrentMediaTime() - startTime
        var currentVelocity = velocity * 15.0
            * CGFloat(pow(Double(decelerationRate), 1000.0 * t))
        strongSelf.accumulatedTransferVelocityOffset += currentVelocity
        let signFactor: CGFloat = strongSelf.accumulatedTransferVelocityOffset >= 0.0 ? 1.0 : -1.0
        let remainder = abs(strongSelf.accumulatedTransferVelocityOffset)
            .remainder(dividingBy: UIScreenPixel)
        var currentOffset = strongSelf.scroller.contentOffset
        let addedDela = strongSelf.accumulatedTransferVelocityOffset - remainder * signFactor
        currentOffset.y += addedDela
        strongSelf.accumulatedTransferVelocityOffset -= addedDela

private class GridNodeScrollerLayer: CALayer {
    override func setNeedsDisplay() {
    }
}
public class GridNodeScrollerView: UIScrollView {
    override public class var layerClass: AnyClass {
        return GridNodeScrollerLayer.self
    }
    override public init(frame: CGRect) {
        super.init(frame: frame)
        if #available(iOSApplicationExtension 11.0, iOS 11.0, *) {
            self.contentInsetAdjustmentBehavior = .never
        }
    }
    required public init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    override public func touchesShouldCancel(in view: UIView) -> Bool {
        return true
    }
}

let lowerDisplayBound = contentOffset.y - self.gridLayout.insets.top
    - self.gridLayout.preloadSize
let upperDisplayBound = contentOffset.y + self.gridLayout.insets.bottom
    + self.gridLayout.size.height + self.gridLayout.preloadSize
var presentationItems: [GridNodePresentationItem] = []
var validSections = Set<WrappedGridSection>()
for item in self.itemLayout.items {
    if item.frame.maxY < lowerDisplayBound {
        continue
    }
    if item.frame.minY > upperDisplayBound {
        break
    }
    presentationItems.append(item)
    if self.floatingSections {
        if let section = self.items[item.index].section {
            validSections.insert(WrappedGridSection(section))
        }
    }
}
var presentationSections: [GridNodePresentationSection] = []
for section in self.itemLayout.sections {

if saveItemFrames {
    var itemFrames: [WrappedGridItemNode: CGRect] = [:]
    let contentOffset = self.scrollView.contentOffset
    for (_, itemNode) in self.itemNodes {
        itemFrames[WrappedGridItemNode(node: itemNode)] = itemNode.frame
            .offsetBy(dx: 0.0, dy: -contentOffset.y)
    }
    for (_, sectionNode) in self.sectionNodes {
        itemFrames[WrappedGridItemNode(node: sectionNode)] = sectionNode.frame
            .offsetBy(dx: 0.0, dy: -contentOffset.y)
    }
    for itemNode in removedNodes {
        itemFrames[WrappedGridItemNode(node: itemNode)] = itemNode.frame
            .offsetBy(dx: 0.0, dy: -contentOffset.y)
    }
    previousItemFrames = itemFrames
}
if let offset = offset {
    // `timingFunction` 与 `mediaTimingFunction` 来自 `curve`。
    for (index, itemNode) in self.itemNodes where existingItemIndices.contains(index) {
        itemNode.layer.animatePosition(from: CGPoint(x: 0.0, y: offset),
            to: CGPoint(), duration: duration, timingFunction: timingFunction,
            mediaTimingFunction: mediaTimingFunction, additive: true)
    }
}

case let .balanced(idealHeight):
    var weights: [Int] = []
    for item in self.items {
        weights.append(Int(item.aspectRatio * 100))
    }
    var totalItemSize: CGFloat = 0.0
    for i in 0 ..< self.items.count {
        totalItemSize += self.items[i].aspectRatio * idealHeight
    }
    let numberOfRows = max(Int(round(totalItemSize / gridLayout.size.width)), 1)
    let partition = linearPartitionForWeights(weights,
        numberOfPartitions:numberOfRows)
    var i = 0
    var offset = CGPoint(x: 0.0, y: 0.0)

if !items.items.isEmpty {
    let visibleBounds = self.scrollView.bounds
    let visibleRange = layout.visibleItemRange(for: visibleBounds, count: items.count)
    for index in visibleRange.minIndex ... visibleRange.maxIndex {
        if items.item(at: index) == nil {
            let closestHole = items.closestHole(to: index)
            var closestAnchor: HoleAnchor?
            /*if let closestItem = items.closestItem(at: index), let closestHole = closestHole {
                if abs(closestItem.index - index) < abs(closestHole.index - index) {
                    closestAnchor = closestItem.holeAnchor
                } else {
                    closestAnchor = closestHole
                }
            } else if let closestItem = closestItem {
                closestAnchor = closestItem.holeAnchor
            } else if let closestHole = closestHole {*/
                closestAnchor = closestHole
            //}
            if let closestAnchor = closestAnchor {
                self.maybeLoadHoleAnchor(closestAnchor, .toLower)
            }
            break
        }
    }
}

let itemLayer: VisibleItem
if let current = self.visibleItems[item.id] {
    itemLayer = current
    updateLayers.append((itemLayer, index))
} else {
    itemLayer = VisibleItem(
        layer: items.itemBinding.createLayer(item: item),
        view: items.itemBinding.createView()
    )
    itemLayer.layer?.masksToBounds = true
    self.visibleItems[item.id] = itemLayer
    bindItems.append(item)
    bindLayers.append(itemLayer)
    if let layer = itemLayer.layer {
        if let reorderingItem = self.reorderingItem,
            let visibleReorderingItem = self.visibleItems[reorderingItem.id] {
            self.scrollView.layer.insertSublayer(layer,
                below: visibleReorderingItem.layer)
        } else {
            self.scrollView.layer.addSublayer(layer)
        }
    } else if let view = itemLayer.view {
        self.scrollView.addSubview(view)
    }
}

if let image = self.image {
    layer.contents = image.cgImage
    let shiftedContentsRect = CGRect(
        origin: CGPoint(x: 0.0, y: frame.minY / containerSize.height),
        size: CGSize(width: 1.0, height: frame.height / containerSize.height)
    )
    layer.contentsRect = shiftedContentsRect
    if layer.animation(forKey: "shimmer") == nil {
        let animation = CABasicAnimation(keyPath: "contentsRect.origin.y")
        animation.fromValue = 1.0 as NSNumber
        animation.toValue = -1.0 as NSNumber
        animation.isAdditive = true
        animation.repeatCount = .infinity
        animation.duration = 0.8
        animation.beginTime = layer.convertTime(1.0, from: nil)
        layer.add(animation, forKey: "shimmer")
    }
}

let listSize: CGSize
let listInsets: UIEdgeInsets
switch component.direction {
case .vertical:
    self.listNode.transform = CATransform3DIdentity
    listSize = CGSize(width: availableSize.width, height: availableSize.height)
    listInsets = component.insets
case .horizontal:
    self.listNode.transform = CATransform3DMakeRotation(
        -CGFloat.pi / 2.0, 0.0, 0.0, 1.0)
    listSize = CGSize(width: availableSize.height, height: availableSize.width)
    listInsets = UIEdgeInsets(top: component.insets.left,
        left: component.insets.top, bottom: component.insets.right,
        right: component.insets.bottom)
}

private static func swizzleSetContentOffset() {
    let sel = NSSelectorFromString("setContentOffset:")
    guard let method = class_getInstanceMethod(UIScrollView.self, sel) else { return }
    typealias Fn = @convention(c) (AnyObject, Selector, CGPoint) -> Void
    let original = unsafeBitCast(method_getImplementation(method), to: Fn.self)
    let block: @convention(block) (AnyObject, CGPoint) -> Void = { obj, offset in
        CaptureSink.current?.recordOffsetWrite(offset, from: obj)
        original(obj, sel, offset)
    }
    method_setImplementation(method, imp_implementationWithBlock(block))
}
private static func swizzleRubberBand() {
    let sel = NSSelectorFromString("_rubberBandOffsetForOffset:maxOffset:minOffset:range:outside:")
    guard let method = class_getInstanceMethod(UIScrollView.self, sel) else { return }
    typealias Fn = @convention(c) (AnyObject, Selector, CGFloat, CGFloat, CGFloat,
        CGFloat, UnsafeMutablePointer<ObjCBool>?) -> CGFloat
    let original = unsafeBitCast(method_getImplementation(method), to: Fn.self)
    let block: @convention(block) (AnyObject, CGFloat, CGFloat, CGFloat, CGFloat,
        UnsafeMutablePointer<ObjCBool>?) -> CGFloat = {
        obj, offset, maxOff, minOff, range, outside in
        let out = original(obj, sel, offset, maxOff, minOff, range, outside)
        CaptureSink.current?.recordRubberBand(
            .init(offset: offset, min: minOff, max: maxOff, range: range, out: out), from: obj)
        return out
    }