@shopify/flash-list 1.0.1

package/dist/viewability/ViewabilityManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ViewabilityManager.js","sourceRoot":"","sources":["../../src/viewability/ViewabilityManager.ts"],"names":[],"mappings":"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"}

package/ios/RNFlashList.xcodeproj/project.pbxproj

@@ -0,0 +1,3 @@
+// This file is necessary because of the `react-native` CLI autolinking feature that adds a module based on whether this file exists
+// as per [this](https://github.com/react-native-community/cli/issues/1054) issue.
+// To edit a native iOS module, you should use the Xcode project in the `fixture` folder.

package/ios/RNFlashList.xcodeproj/project.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+</Workspace>

package/ios/Sources/AutoLayoutView.swift

@@ -0,0 +1,218 @@
+import Foundation
+import UIKit
+
+
+/// Container for all RecyclerListView children. This will automatically remove all gaps and overlaps for GridLayouts with flexible spans.
+/// Note: This cannot work for masonry layouts i.e, pinterest like layout
+@objc class AutoLayoutView: UIView {
+    @objc(onBlankAreaEvent)
+    var onBlankAreaEvent: RCTDirectEventBlock?
+
+    @objc func setHorizontal(_ horizontal: Bool) {
+        self.horizontal = horizontal
+    }
+
+    @objc func setScrollOffset(_ scrollOffset: Int) {
+        self.scrollOffset = CGFloat(scrollOffset)
+    }
+
+    @objc func setWindowSize(_ windowSize: Int) {
+        self.windowSize = CGFloat(windowSize)
+    }
+
+    @objc func setRenderAheadOffset(_ renderAheadOffset: Int) {
+        self.renderAheadOffset = CGFloat(renderAheadOffset)
+    }
+
+    @objc func setEnableInstrumentation(_ enableInstrumentation: Bool) {
+        self.enableInstrumentation = enableInstrumentation
+    }
+
+    @objc func setDisableAutoLayout(_ disableAutoLayout: Bool) {
+        self.disableAutoLayout = disableAutoLayout
+    }
+
+    private var horizontal = false
+    private var scrollOffset: CGFloat = 0
+    private var windowSize: CGFloat = 0
+    private var renderAheadOffset: CGFloat = 0
+    private var enableInstrumentation = false
+    private var disableAutoLayout = false
+
+    /// Tracks where the last pixel is drawn in the visible window
+    private var lastMaxBound: CGFloat = 0
+    /// Tracks where first pixel is drawn in the visible window
+    private var lastMinBound: CGFloat = 0
+
+    override func layoutSubviews() {
+        fixLayout()
+        super.layoutSubviews()
+
+        let scrollView = sequence(first: self, next: { $0.superview }).first(where: { $0 is UIScrollView })
+        guard enableInstrumentation, let scrollView = scrollView as? UIScrollView else { return }
+
+        let scrollContainerSize = horizontal ? scrollView.frame.width : scrollView.frame.height
+        let currentScrollOffset = horizontal ? scrollView.contentOffset.x : scrollView.contentOffset.y
+        let startOffset = horizontal ? frame.minX : frame.minY
+        let endOffset = horizontal ? frame.maxX : frame.maxY
+        let distanceFromWindowStart = max(startOffset - currentScrollOffset, 0)
+        let distanceFromWindowEnd = max(currentScrollOffset + scrollContainerSize - endOffset, 0)
+
+        let (blankOffsetStart, blankOffsetEnd) = computeBlankFromGivenOffset(
+            currentScrollOffset - startOffset,
+            filledBoundMin: lastMinBound,
+            filledBoundMax: lastMaxBound,
+            renderAheadOffset: renderAheadOffset,
+            windowSize: windowSize,
+            distanceFromWindowStart: distanceFromWindowStart,
+            distanceFromWindowEnd: distanceFromWindowEnd
+        )
+
+        onBlankAreaEvent?(
+            [
+                "offsetStart": blankOffsetStart,
+                "offsetEnd": blankOffsetEnd,
+            ]
+        )
+    }
+
+    /// Sorts views by index and then invokes clearGaps which does the correction.
+    /// Performance: Sort is needed. Given relatively low number of views in RecyclerListView render tree this should be a non issue.
+    private func fixLayout() {
+        guard
+            subviews.count > 1,
+            // Fixing layout during animation can interfere with it.
+            layer.animationKeys()?.isEmpty ?? true,
+            !disableAutoLayout
+        else { return }
+        let cellContainers = subviews
+            .compactMap { subview -> CellContainer? in
+                if let cellContainer = subview as? CellContainer {
+                    return cellContainer
+                } else {
+                    assertionFailure("CellRendererComponent outer view should always be CellContainer. Learn more here: https://shopify.github.io/flash-list/docs/usage#cellrenderercomponent.")
+                    return nil
+                }
+            }
+            .sorted(by: { $0.index < $1.index })
+        clearGaps(for: cellContainers)
+    }
+
+    /// Checks for overlaps or gaps between adjacent items and then applies a correction.
+    /// Performance: RecyclerListView renders very small number of views and this is not going to trigger multiple layouts on the iOS side.
+    private func clearGaps(for cellContainers: [CellContainer]) {
+        var maxBound: CGFloat = 0
+        var minBound: CGFloat = CGFloat(Int.max)
+        var maxBoundNextCell: CGFloat = 0
+        let correctedScrollOffset = scrollOffset - (horizontal ? frame.minX : frame.minY)
+
+        cellContainers.indices.dropLast().forEach { index in
+            let cellContainer = cellContainers[index]
+            let cellTop = cellContainer.frame.minY
+            let cellBottom = cellContainer.frame.maxY
+            let cellLeft = cellContainer.frame.minX
+            let cellRight = cellContainer.frame.maxX
+
+            let nextCell = cellContainers[index + 1]
+            let nextCellTop = nextCell.frame.minY
+            let nextCellBottom = nextCell.frame.maxY
+            let nextCellLeft = nextCell.frame.minX
+            let nextCellRight = nextCell.frame.maxX
+
+
+            guard
+                isWithinBounds(
+                    cellContainer,
+                    scrollOffset: correctedScrollOffset,
+                    renderAheadOffset: renderAheadOffset,
+                    windowSize: windowSize,
+                    isHorizontal: horizontal
+                )
+            else { return }
+            let isNextCellVisible = isWithinBounds(
+                nextCell,
+                scrollOffset: correctedScrollOffset,
+                renderAheadOffset: renderAheadOffset,
+                windowSize: windowSize,
+                isHorizontal: horizontal
+            )
+
+            if horizontal {
+                maxBound = max(maxBound, cellRight)
+                minBound = min(minBound, cellLeft)
+                maxBoundNextCell = maxBound
+                if cellTop < nextCellTop {
+                    if cellBottom != nextCellTop {
+                        nextCell.frame.origin.y = cellBottom
+                    }
+                    if cellLeft != nextCellLeft {
+                        nextCell.frame.origin.x = cellLeft
+                    }
+                } else {
+                    nextCell.frame.origin.x = maxBound
+                }
+                if isNextCellVisible {
+                    maxBoundNextCell = max(maxBound, nextCellRight)
+                }
+            } else {
+                maxBound = max(maxBound, cellBottom)
+                minBound = min(minBound, cellTop)
+                maxBoundNextCell = maxBound
+                if cellLeft < nextCellLeft {
+                    if cellRight != nextCellLeft {
+                        nextCell.frame.origin.x = cellRight
+                    }
+                    if cellTop != nextCellTop {
+                        nextCell.frame.origin.y = cellTop
+                    }
+                } else {
+                    nextCell.frame.origin.y = maxBound
+                }
+                if isNextCellVisible {
+                    maxBoundNextCell = max(maxBound, nextCellBottom)
+                }
+            }
+        }
+
+        lastMaxBound = maxBoundNextCell
+        lastMinBound = minBound
+    }
+
+    func computeBlankFromGivenOffset(
+        _ actualScrollOffset: CGFloat,
+        filledBoundMin: CGFloat,
+        filledBoundMax: CGFloat,
+        renderAheadOffset: CGFloat,
+        windowSize: CGFloat,
+        distanceFromWindowStart: CGFloat,
+        distanceFromWindowEnd: CGFloat
+    ) -> (
+        offsetStart: CGFloat,
+        offsetEnd: CGFloat
+    ) {
+        let blankOffsetStart = filledBoundMin - actualScrollOffset - distanceFromWindowStart
+
+        let blankOffsetEnd = actualScrollOffset + windowSize - renderAheadOffset - filledBoundMax - distanceFromWindowEnd
+
+        return (blankOffsetStart, blankOffsetEnd)
+    }
+
+    /// It's important to avoid correcting views outside the render window. An item that isn't being recycled might still remain in the view tree. If views outside get considered then gaps between unused items will cause algorithm to fail.
+    func isWithinBounds(
+        _ cellContainer: CellContainer,
+        scrollOffset: CGFloat,
+        renderAheadOffset: CGFloat,
+        windowSize: CGFloat,
+        isHorizontal: Bool
+    ) -> Bool {
+        let boundsStart = scrollOffset - renderAheadOffset
+        let boundsEnd = scrollOffset + windowSize
+        let cellFrame = cellContainer.frame
+
+        if isHorizontal {
+            return (cellFrame.minX >= boundsStart || cellFrame.maxX >= boundsStart) && (cellFrame.minX <= boundsEnd || cellFrame.maxX <= boundsEnd)
+        } else {
+            return (cellFrame.minY >= boundsStart || cellFrame.maxY >= boundsStart) && (cellFrame.minY <= boundsEnd || cellFrame.maxY <= boundsEnd)
+        }
+    }
+}

package/ios/Sources/AutoLayoutViewManager.m

@@ -0,0 +1,14 @@
+#import <Foundation/Foundation.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(AutoLayoutViewManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(horizontal, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(scrollOffset, NSInteger)
+RCT_EXPORT_VIEW_PROPERTY(windowSize, NSInteger)
+RCT_EXPORT_VIEW_PROPERTY(renderAheadOffset, NSInteger)
+RCT_EXPORT_VIEW_PROPERTY(enableInstrumentation, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(disableAutoLayout, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(onBlankAreaEvent, RCTDirectEventBlock)
+
+@end

package/ios/Sources/AutoLayoutViewManager.swift

@@ -0,0 +1,12 @@
+import Foundation
+
+@objc(AutoLayoutViewManager)
+class AutoLayoutViewManager: RCTViewManager {
+    override func view() -> UIView! {
+        return AutoLayoutView()
+    }
+    
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+}

package/ios/Sources/CellContainer.swift

@@ -0,0 +1,9 @@
+import Foundation
+
+@objc class CellContainer: UIView {
+    var index: Int = -1
+    
+    @objc func setIndex(_ index: Int) {
+        self.index = index
+    }
+}

package/ios/Sources/CellContainerManager.m

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(CellContainerManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(index, NSInteger)
+
+@end

package/ios/Sources/CellContainerManager.swift

@@ -0,0 +1,12 @@
+import Foundation
+
+@objc(CellContainerManager)
+class CellContainerManager: RCTViewManager {  
+    override func view() -> UIView! {
+        return CellContainer()
+    }
+    
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+}

package/ios/Sources/FlatListPro-Bridging-Header.h

@@ -0,0 +1,8 @@
+#ifndef FlatListPro_Bridging_Header_h
+#define FlatListPro_Bridging_Header_h
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <React/RCTViewManager.h>
+
+#endif /* FlatListPro_Bridging_Header_h */

package/ios/Tests/AutoLayoutViewTests.swift

@@ -0,0 +1,113 @@
+import XCTest
+@testable import RNFlashList
+
+class AutoLayoutViewTests: XCTestCase {
+    var autoLayoutView: AutoLayoutView!
+    var testCell: CellContainer!
+    let cellHeight: CGFloat = 50
+    let windowSize: CGFloat = 500
+
+    override func setUp() {
+        super.setUp()
+        autoLayoutView = AutoLayoutView()
+        testCell = CellContainer()
+    }
+
+    func testIsWithinBoundsVerticalListScrollToBottom() {
+        testCell.frame = CGRect(x: 0, y: 0, width: cellHeight, height: cellHeight)
+        // Top left corner of the screen
+        XCTAssertTrue(autoLayoutView.isWithinBounds(testCell,
+                                                    scrollOffset: 0,
+                                                    renderAheadOffset: 0,
+                                                    windowSize: windowSize,
+                                                    isHorizontal: false))
+
+        // Partly visible
+        XCTAssertTrue(autoLayoutView.isWithinBounds(testCell,
+                                                    scrollOffset: 25,
+                                                    renderAheadOffset: 0,
+                                                    windowSize: windowSize,
+                                                    isHorizontal: false))
+
+        // Above visible
+        XCTAssertFalse(autoLayoutView.isWithinBounds(testCell,
+                                                     scrollOffset: 100,
+                                                     renderAheadOffset: 0,
+                                                     windowSize: windowSize,
+                                                     isHorizontal: false))
+    }
+
+    func testIsWithinBoundsVerticalListScrollToTop() {
+        testCell.frame = CGRect(x: 0, y: windowSize - cellHeight, width: cellHeight, height: cellHeight)
+        // Bottom left corner of the screen
+        XCTAssertTrue(autoLayoutView.isWithinBounds(testCell,
+                                                    scrollOffset: 0,
+                                                    renderAheadOffset: 0,
+                                                    windowSize: windowSize,
+                                                    isHorizontal: false))
+
+        // Partly visible
+        XCTAssertTrue(autoLayoutView.isWithinBounds(testCell,
+                                                    scrollOffset: -25,
+                                                    renderAheadOffset: 0,
+                                                    windowSize: windowSize,
+                                                    isHorizontal: false))
+
+        // Below visible
+        XCTAssertFalse(autoLayoutView.isWithinBounds(testCell,
+                                                     scrollOffset: -100,
+                                                     renderAheadOffset: 0,
+                                                     windowSize: windowSize,
+                                                     isHorizontal: false))
+    }
+
+    func testIsWithinBoundsHorizontalListScrollToLeft() {
+        testCell.frame = CGRect(x: 0, y: 0, width: cellHeight, height: cellHeight)
+        // Top left corner of the screen
+        XCTAssertTrue(autoLayoutView.isWithinBounds(testCell,
+                                                    scrollOffset: 0,
+                                                    renderAheadOffset: 0,
+                                                    windowSize: windowSize,
+                                                    isHorizontal: true))
+
+        // Partly visible
+        XCTAssertTrue(autoLayoutView.isWithinBounds(testCell,
+                                                    scrollOffset: 25,
+                                                    renderAheadOffset: 0,
+                                                    windowSize: windowSize,
+                                                    isHorizontal: true))
+
+        // Hidden
+        XCTAssertFalse(autoLayoutView.isWithinBounds(testCell,
+                                                     scrollOffset: 100,
+                                                     renderAheadOffset: 0,
+                                                     windowSize: windowSize,
+                                                     isHorizontal: true))
+    }
+
+    func testIsWithinBoundsHorizontalListScrollToRight() {
+        testCell.frame = CGRect(x: windowSize - cellHeight, y: 0, width: cellHeight, height: cellHeight)
+        // Bottom left corner of the screen
+        XCTAssertTrue(autoLayoutView.isWithinBounds(testCell,
+                                                    scrollOffset: 0,
+                                                    renderAheadOffset: 0,
+                                                    windowSize: windowSize,
+                                                    isHorizontal: true))
+
+        // Partly visible
+        XCTAssertTrue(autoLayoutView.isWithinBounds(testCell,
+                                                    scrollOffset: -25,
+                                                    renderAheadOffset: 0,
+                                                    windowSize: windowSize,
+                                                    isHorizontal: true))
+
+        testCell.frame = CGRect(x: windowSize + cellHeight, y: 0, width: cellHeight, height: cellHeight)
+        // Hidden
+        XCTAssertFalse(autoLayoutView.isWithinBounds(testCell,
+                                                     scrollOffset: 0,
+                                                     renderAheadOffset: 0,
+                                                     windowSize: windowSize,
+                                                     isHorizontal: true))
+    }
+
+}

package/jestSetup.js

@@ -0,0 +1,15 @@
+jest.mock("@shopify/flash-list", () => {
+  const ActualFlashList = jest.requireActual("@shopify/flash-list").FlashList;
+  class MockFlashList extends ActualFlashList {
+    componentDidMount() {
+      super.componentDidMount();
+      this.rlvRef?._scrollComponent?._scrollViewRef?.props.onLayout({
+        nativeEvent: { layout: { height: 900, width: 400 } },
+      });
+    }
+  }
+  return {
+    ...jest.requireActual("@shopify/flash-list"),
+    FlashList: MockFlashList,
+  };
+});

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@shopify/flash-list",
+  "version": "1.0.1",
+  "keywords": [
+    "react-native"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "@shopify:registry": "https://registry.npmjs.org/"
+  },
+  "description": "FlashList is a more performant FlatList replacement",
+  "author": "shopify",
+  "license": "MIT",
+  "homepage": "https://reimagined-fiesta-030d04f7.pages.github.io",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "up": "/opt/dev/bin/dev up && bundle install && yarn fixture-up && yarn e2e-up && yarn build && yarn fixture-web-up",
+    "fixture-web-up": "cd fixture/web-app && yarn && cd ../../",
+    "fixture-up": "cd fixture && yarn && cd ios && bundle exec pod install && cd ../../",
+    "e2e-up": "cd fixture/ios && brew tap wix/brew && brew install applesimutils && cd ../../",
+    "start": "cd fixture && react-native start",
+    "test": "jest",
+    "lint": "yarn eslint . --ext .ts,.tsx",
+    "lint:fix": "yarn eslint . --ext .ts,.tsx --fix",
+    "build": "tsc -b",
+    "e2e:build:android": "detox build -c android.emu.release",
+    "run-ios": "cd fixture && yarn react-native run-ios && yarn build --watch",
+    "ri": "yarn run-ios",
+    "run-android": "cd fixture && yarn react-native run-android && yarn build --watch",
+    "ra": "yarn run-android",
+    "run-e2e-ios": "cd fixture && yarn e2e:build:ios && yarn e2e:test:ios",
+    "rei": "yarn run-e2e-ios",
+    "run-e2e-android": "cd fixture && yarn e2e:build:android && yarn e2e:test:android",
+    "rea": "yarn run-e2e-android",
+    "run-web": "cd fixture/web-app && yarn web",
+    "rw": "yarn run-web",
+    "predeploy:website": "sh ./build_website.sh",
+    "deploy:website": "gh-pages -d website/_site"
+  },
+  "peerDependencies": {
+    "@babel/runtime": "*",
+    "react": "*",
+    "react-native": "*"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.18.5",
+    "@babel/runtime": "^7.18.3",
+    "@quilted/react-testing": "^0.5.14",
+    "@react-native-community/eslint-config": "^3.0.0",
+    "@shopify/eslint-plugin": "^41.3.1",
+    "@types/jest": "^28.1.3",
+    "@types/react-native": "0.67.6",
+    "babel-jest": "^28.1.1",
+    "enhanced-resolve": "^5.9.3",
+    "eslint": "8.18.0",
+    "gh-pages": "^3.2.3",
+    "jest": "^28.1.1",
+    "metro-react-native-babel-preset": "^0.71.1",
+    "react": "17.0.2",
+    "react-native": "0.68.1",
+    "typescript": "^4.7.4"
+  },
+  "files": [
+    "android",
+    "ios",
+    "dist",
+    "RNFlashList.podspec",
+    "src",
+    "jestSetup.js"
+  ],
+  "dependencies": {
+    "recyclerlistview": "3.3.0-beta.2"
+  }
+}

package/src/AnimatedFlashList.ts

@@ -0,0 +1,11 @@
+import { Animated } from "react-native";
+
+import FlashList from "./FlashList";
+import { FlashListProps } from "./FlashListProps";
+
+const AnimatedFlashList =
+  Animated.createAnimatedComponent<React.ComponentType<FlashListProps<any>>>(
+    FlashList
+  );
+
+export default AnimatedFlashList;