@hanzogui/react-native-web-lite 2.0.0-rc.41-hanzoai.5

package/src/vendor/react-native/VirtualizedList/VirtualizedListContext.jsx

@@ -0,0 +1,96 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @format
+ */
+
+import { VirtualizedList } from '../VirtualizedList'
+
+import * as React from 'react'
+import { useContext, useMemo } from 'react'
+
+const __DEV__ = process.env.NODE_ENV !== 'production'
+
+const defaultContext = {
+  cellKey: null,
+  getScrollMetrics: () => ({
+    contentLength: 0,
+    dOffset: 0,
+    dt: 0,
+    offset: 0,
+    timestamp: 0,
+    velocity: 0,
+    visibleLength: 0,
+    zoomScale: 1,
+  }),
+  horizontal: false,
+  getOutermostParentListRef: () => null,
+  registerAsNestedChild: (params) => {},
+  unregisterAsNestedChild: (params) => {},
+}
+
+export const VirtualizedListContext = React.createContext(null)
+if (__DEV__) {
+  VirtualizedListContext.displayName = 'VirtualizedListContext'
+}
+
+/**
+ * Resets the context. Intended for use by portal-like components (e.g. Modal).
+ */
+export function VirtualizedListContextResetter({ children }) {
+  return (
+    <VirtualizedListContext.Provider value={null}>
+      {children}
+    </VirtualizedListContext.Provider>
+  )
+}
+
+/**
+ * Sets the context with memoization. Intended to be used by `VirtualizedList`.
+ */
+export function VirtualizedListContextProvider({ children, value }) {
+  // Avoid setting a newly created context object if the values are identical.
+  const context = useMemo(
+    () => ({
+      cellKey: null,
+      getScrollMetrics: value.getScrollMetrics,
+      horizontal: value.horizontal,
+      getOutermostParentListRef: value.getOutermostParentListRef,
+      registerAsNestedChild: value.registerAsNestedChild,
+      unregisterAsNestedChild: value.unregisterAsNestedChild,
+    }),
+    [
+      value.getScrollMetrics,
+      value.horizontal,
+      value.getOutermostParentListRef,
+      value.registerAsNestedChild,
+      value.unregisterAsNestedChild,
+    ]
+  )
+  return (
+    <VirtualizedListContext.Provider value={context}>
+      {children}
+    </VirtualizedListContext.Provider>
+  )
+}
+
+/**
+ * Sets the `cellKey`. Intended to be used by `VirtualizedList` for each cell.
+ */
+export function VirtualizedListCellContextProvider({ cellKey, children }) {
+  // Avoid setting a newly created context object if the values are identical.
+  const currContext = useContext(VirtualizedListContext)
+  const context = useMemo(
+    () => (currContext == null ? null : { ...currContext, cellKey }),
+    [currContext, cellKey]
+  )
+  return (
+    <VirtualizedListContext.Provider value={context}>
+      {children}
+    </VirtualizedListContext.Provider>
+  )
+}

package/src/vendor/react-native/VirtualizedList/VirtualizedListProps.js

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+export const defaultVirtualizedListProps = {
+  debug: false,
+  disableVirtualization: false,
+  extraData: null,
+  getItemLayout: null,
+  horizontal: false,
+  initialNumToRender: 10,
+  initialScrollIndex: null,
+  inverted: false,
+  keyExtractor: null,
+  CellRendererComponent: null,
+  ItemSeparatorComponent: null,
+  ListItemComponent: null,
+  ListEmptyComponent: null,
+  ListFooterComponent: null,
+  ListFooterComponentStyle: null,
+  ListHeaderComponent: null,
+  ListHeaderComponentStyle: null,
+  maxToRenderPerBatch: 10,
+  onEndReached: null,
+  onEndReachedThreshold: 2,
+  onRefresh: null,
+  onScrollToIndexFailed: null,
+  onStartReached: null,
+  onStartReachedThreshold: 2,
+  onViewableItemsChanged: null,
+  persistentScrollbar: false,
+  progressViewOffset: 0,
+  refreshControl: null,
+  refreshing: false,
+  removeClippedSubviews: false,
+  renderScrollComponent: null,
+  updateCellsBatchingPeriod: 50,
+  viewabilityConfig: null,
+  viewabilityConfigCallbackPairs: null,
+  windowSize: 21,
+}
+
+export default defaultVirtualizedListProps

package/src/vendor/react-native/VirtualizedList/index.jsx

@@ -0,0 +1,378 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { invariant } from '@hanzogui/react-native-web-internals'
+import { ScrollView } from '../../../ScrollView'
+import { RefreshControl } from '../../../RefreshControl'
+
+import { Batchinator } from '../Batchinator'
+import { ChildListCollection } from './ChildListCollection'
+import { FillRateHelper } from '../FillRateHelper'
+import { StateSafePureComponent } from './StateSafePureComponent'
+import { ViewabilityHelper } from '../ViewabilityHelper'
+import { CellRenderer } from './VirtualizedListCellRenderer'
+import { VirtualizedListContext } from './VirtualizedListContext'
+
+const __DEV__ = process.env.NODE_ENV !== 'production'
+
+const ON_EDGE_REACHED_EPSILON = 0.001
+
+let _usedIndexForKey = false
+let _keylessItemComponentName = ''
+
+const defaultViewabilityConfig = {
+  viewabilityHelper: null,
+  onViewableItemsChanged: null,
+}
+
+const defaultRenderMask = {
+  renderMask: null,
+  cellsAroundViewport: { first: 0, last: 0 },
+}
+
+// Default Props Helper Functions
+function horizontalOrDefault(horizontal) {
+  return horizontal ?? false
+}
+
+function initialNumToRenderOrDefault(initialNumToRender) {
+  return initialNumToRender ?? 10
+}
+
+function maxToRenderPerBatchOrDefault(maxToRenderPerBatch) {
+  return maxToRenderPerBatch ?? 10
+}
+
+function onStartReachedThresholdOrDefault(onStartReachedThreshold) {
+  return onStartReachedThreshold ?? 2
+}
+
+function onEndReachedThresholdOrDefault(onEndReachedThreshold) {
+  return onEndReachedThreshold ?? 2
+}
+
+function getScrollingThreshold(threshold, visibleLength) {
+  return (threshold * visibleLength) / 2
+}
+
+function scrollEventThrottleOrDefault(scrollEventThrottle) {
+  return scrollEventThrottle ?? 50
+}
+
+function windowSizeOrDefault(windowSize) {
+  return windowSize ?? 21
+}
+
+function findLastWhere(arr, predicate) {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (predicate(arr[i])) {
+      return arr[i]
+    }
+  }
+  return null
+}
+
+class VirtualizedList extends StateSafePureComponent {
+  static contextType = VirtualizedListContext
+
+  constructor(props) {
+    super(props)
+    this._nestedChildLists = new ChildListCollection()
+    this._viewabilityTuples = []
+    this._scrollMetrics = {
+      contentLength: 0,
+      dOffset: 0,
+      dt: 10,
+      offset: 0,
+      timestamp: 0,
+      velocity: 0,
+      visibleLength: 0,
+    }
+    this._highestMeasuredFrameIndex = 0
+    this._headerLength = 0
+    this._footerLength = 0
+    this._averageCellLength = 0
+    this._hasWarned = {}
+    this._fillRateHelper = new FillRateHelper(this._getFrameMetrics)
+    this._updateCellsToRenderBatcher = new Batchinator(
+      this._updateCellsToRender,
+      this.props.updateCellsBatchingPeriod ?? 50
+    )
+
+    if (this.props.viewabilityConfig && this.props.onViewableItemsChanged) {
+      this._viewabilityTuples.push({
+        viewabilityHelper: new ViewabilityHelper(this.props.viewabilityConfig),
+        onViewableItemsChanged: this.props.onViewableItemsChanged,
+      })
+    }
+  }
+
+  scrollToEnd(params) {
+    const animated = params ? params.animated : true
+    const veryLast = this.props.getItemCount(this.props.data) - 1
+    if (veryLast < 0) {
+      return
+    }
+    const frame = this.__getFrameMetricsApprox(veryLast, this.props)
+    const offset = Math.max(
+      0,
+      frame.offset + frame.length + this._footerLength - this._scrollMetrics.visibleLength
+    )
+
+    if (this._scrollRef == null) {
+      return
+    }
+
+    if (this._scrollRef.scrollTo == null) {
+      console.warn(
+        'No scrollTo method provided. This may be because you have two nested ' +
+          'VirtualizedLists with the same orientation, or because you are ' +
+          'using a custom component that does not implement scrollTo.'
+      )
+      return
+    }
+
+    this._scrollRef.scrollTo(
+      horizontalOrDefault(this.props.horizontal)
+        ? { x: offset, animated }
+        : { y: offset, animated }
+    )
+  }
+
+  scrollToIndex(params) {
+    const { data, horizontal, getItemCount, getItemLayout, onScrollToIndexFailed } =
+      this.props
+    const { animated, index, viewOffset, viewPosition } = params
+    invariant(
+      index >= 0,
+      `scrollToIndex out of range: requested index ${index} but minimum is 0`
+    )
+    invariant(
+      getItemCount(data) >= 1,
+      `scrollToIndex out of range: item length ${getItemCount(data)} but minimum is 1`
+    )
+    invariant(
+      index < getItemCount(data),
+      `scrollToIndex out of range: requested index ${index} is out of 0 to ${
+        getItemCount(data) - 1
+      }`
+    )
+    if (!getItemLayout && index > this._highestMeasuredFrameIndex) {
+      invariant(
+        !!onScrollToIndexFailed,
+        'scrollToIndex should be used in conjunction with getItemLayout or onScrollToIndexFailed, ' +
+          'otherwise there is no way to know the location of offscreen indices or handle failures.'
+      )
+      onScrollToIndexFailed({
+        averageItemLength: this._averageCellLength,
+        highestMeasuredFrameIndex: this._highestMeasuredFrameIndex,
+        index,
+      })
+      return
+    }
+    const frame = this.__getFrameMetricsApprox(Math.floor(index), this.props)
+    const offset =
+      Math.max(
+        0,
+        this._getOffsetApprox(index, this.props) -
+          (viewPosition || 0) * (this._scrollMetrics.visibleLength - frame.length)
+      ) - (viewOffset || 0)
+
+    if (this._scrollRef == null) {
+      return
+    }
+
+    this._scrollRef.scrollTo(
+      horizontalOrDefault(horizontal) ? { x: offset, animated } : { y: offset, animated }
+    )
+  }
+
+  scrollToItem(params) {
+    const { data, getItem, getItemCount, horizontal, onScrollToIndexFailed } = this.props
+    const { animated, item, viewPosition, viewOffset } = params
+    const index = this.props.data.indexOf(item)
+    if (index !== -1) {
+      this.scrollToIndex({
+        animated,
+        index,
+        viewOffset,
+        viewPosition,
+      })
+    } else {
+      const itemCount = getItemCount(data)
+      for (let i = 0; i < itemCount; i++) {
+        if (getItem(data, i) === item) {
+          this.scrollToIndex({
+            animated,
+            index: i,
+            viewOffset,
+            viewPosition,
+          })
+          break
+        }
+      }
+    }
+  }
+
+  scrollToOffset(params) {
+    const { animated, offset } = params
+    if (this._scrollRef == null) {
+      return
+    }
+    this._scrollRef.scrollTo(
+      horizontalOrDefault(this.props.horizontal)
+        ? { x: offset, animated }
+        : { y: offset, animated }
+    )
+  }
+
+  recordInteraction() {
+    this._nestedChildLists.forEach((childList) => {
+      childList.recordInteraction()
+    })
+    this._viewabilityTuples.forEach((viewabilityTuple) => {
+      viewabilityTuple.viewabilityHelper.recordInteraction()
+    })
+  }
+
+  flashScrollIndicators() {
+    if (this._scrollRef && this._scrollRef.flashScrollIndicators) {
+      this._scrollRef.flashScrollIndicators()
+    }
+  }
+
+  getScrollResponder() {
+    if (this._scrollRef && this._scrollRef.getScrollResponder) {
+      return this._scrollRef.getScrollResponder()
+    }
+  }
+
+  getScrollableNode() {
+    if (this._scrollRef && this._scrollRef.getScrollableNode) {
+      return this._scrollRef.getScrollableNode()
+    }
+  }
+
+  getScrollRef() {
+    return this._scrollRef
+  }
+
+  setNativeProps(props) {
+    if (this._scrollRef) {
+      this._scrollRef.setNativeProps(props)
+    }
+  }
+
+  render() {
+    const {
+      ListEmptyComponent,
+      ListFooterComponent,
+      ListHeaderComponent,
+      data,
+      debug,
+      disableVirtualization,
+      getItem,
+      getItemCount,
+      getItemLayout,
+      horizontal,
+      keyExtractor,
+      numColumns,
+      onEndReached,
+      onEndReachedThreshold,
+      onLayout,
+      onRefresh,
+      onScroll,
+      onScrollBeginDrag,
+      onScrollEndDrag,
+      onMomentumScrollBegin,
+      onMomentumScrollEnd,
+      onStartReached,
+      onStartReachedThreshold,
+      onViewableItemsChanged,
+      refreshing,
+      removeClippedSubviews,
+      renderItem,
+      viewabilityConfig,
+      viewabilityConfigCallbackPairs,
+      ...restProps
+    } = this.props
+
+    const itemCount = getItemCount(data)
+
+    if (itemCount === 0) {
+      return ListEmptyComponent ? <ListEmptyComponent /> : null
+    }
+
+    return (
+      <ScrollView
+        {...restProps}
+        ref={this._captureRef}
+        onContentSizeChange={this._onContentSizeChange}
+        onLayout={this._onLayout}
+        onScroll={this._onScroll}
+        refreshControl={
+          onRefresh && <RefreshControl refreshing={refreshing} onRefresh={onRefresh} />
+        }
+        scrollEventThrottle={scrollEventThrottleOrDefault(this.props.scrollEventThrottle)}
+        removeClippedSubviews={removeClippedSubviews}
+      >
+        {this._renderChildren()}
+      </ScrollView>
+    )
+  }
+
+  _renderChildren() {
+    const { data, getItem, getItemCount, renderItem } = this.props
+    const items = []
+
+    for (let i = 0; i < getItemCount(data); i++) {
+      const item = getItem(data, i)
+      items.push(
+        <CellRenderer
+          key={this.props.keyExtractor ? this.props.keyExtractor(item, i) : i}
+          cellKey={String(i)}
+          index={i}
+          item={item}
+          renderItem={renderItem}
+        />
+      )
+    }
+
+    return items
+  }
+
+  _captureRef = (ref) => {
+    this._scrollRef = ref
+  }
+
+  _onContentSizeChange = (width, height) => {
+    // Handle content size changes
+  }
+
+  _onLayout = (event) => {
+    // Handle layout changes
+  }
+
+  _onScroll = (event) => {
+    // Handle scroll events
+  }
+
+  __getFrameMetricsApprox(index, props) {
+    const frame = {
+      length: this._averageCellLength,
+      offset: this._averageCellLength * index,
+    }
+    return frame
+  }
+
+  _getOffsetApprox(index, props) {
+    return this.__getFrameMetricsApprox(index, props).offset
+  }
+}
+
+export { VirtualizedList }
+export default VirtualizedList

package/src/vendor/react-native/VirtualizedSectionList/index.jsx

@@ -0,0 +1,149 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { VirtualizedList } from '../VirtualizedList'
+import * as React from 'react'
+
+const defaultProps = {
+  data: [],
+  key: null,
+  renderItem: null,
+  ItemSeparatorComponent: null,
+  keyExtractor: null,
+}
+
+class VirtualizedSectionList extends React.PureComponent {
+  scrollToLocation(params) {
+    let index = params.itemIndex
+    for (let i = 0; i < params.sectionIndex; i++) {
+      index += this.props.getItemCount(this.props.sections[i].data) + 2
+    }
+    let viewOffset = params.viewOffset || 0
+    if (this._listRef == null) {
+      return
+    }
+    if (params.itemIndex > 0 && this.props.stickySectionHeadersEnabled) {
+      const frame = this._listRef.__getFrameMetricsApprox(
+        index - params.itemIndex,
+        this._listRef.props
+      )
+      viewOffset += frame.length
+    }
+    const toIndexParams = {
+      ...params,
+      viewOffset,
+      index,
+    }
+    this._listRef.scrollToIndex(toIndexParams)
+  }
+
+  getListRef() {
+    return this._listRef
+  }
+
+  render() {
+    const {
+      ItemSeparatorComponent,
+      SectionSeparatorComponent,
+      renderItem: _renderItem,
+      renderSectionFooter,
+      renderSectionHeader,
+      sections: _sections,
+      stickySectionHeadersEnabled,
+      ...passThroughProps
+    } = this.props
+
+    const listHeaderOffset = this.props.ListHeaderComponent ? 1 : 0
+
+    const stickyHeaderIndices = this.props.stickySectionHeadersEnabled ? [] : undefined
+
+    let itemCount = 0
+    for (const section of this.props.sections) {
+      if (stickyHeaderIndices != null) {
+        stickyHeaderIndices.push(itemCount + listHeaderOffset)
+      }
+
+      itemCount += 2
+      itemCount += this.props.getItemCount(section.data)
+    }
+    const renderItem = this._renderItem(itemCount)
+
+    return (
+      <VirtualizedList
+        {...passThroughProps}
+        keyExtractor={this._keyExtractor}
+        stickyHeaderIndices={stickyHeaderIndices}
+        renderItem={renderItem}
+        data={this.props.sections}
+        getItem={(sections, index) => this._getItem(this.props, sections, index)}
+        getItemCount={() => itemCount}
+        onViewableItemsChanged={
+          this.props.onViewableItemsChanged ? this._onViewableItemsChanged : undefined
+        }
+        ref={this._captureRef}
+      />
+    )
+  }
+
+  _getItem(props, sections, index) {
+    if (!sections) {
+      return null
+    }
+    let itemIdx = index - 1
+    for (let i = 0; i < sections.length; i++) {
+      const section = sections[i]
+      const sectionData = section.data
+      const itemCount = props.getItemCount(sectionData)
+      if (itemIdx === -1 || itemIdx === itemCount) {
+        return section
+      } else if (itemIdx < itemCount) {
+        return props.getItem(sectionData, itemIdx)
+      } else {
+        itemIdx -= itemCount + 2
+      }
+    }
+    return null
+  }
+
+  _keyExtractor = (item, index) => {
+    const keyExtractor = this.props.keyExtractor || this._defaultKeyExtractor
+    return keyExtractor(item, index)
+  }
+
+  _defaultKeyExtractor = (item, index) => {
+    return item.key != null ? item.key : String(index)
+  }
+
+  _captureRef = (ref) => {
+    this._listRef = ref
+  }
+
+  _renderItem = (itemCount) => {
+    return ({ item, index }) => {
+      if (index === 0 || index === itemCount - 1) {
+        return null
+      }
+      const renderItem = this.props.renderItem || this._defaultRenderItem
+      return renderItem({ item, index, section: item })
+    }
+  }
+
+  _defaultRenderItem = ({ item }) => {
+    return null
+  }
+
+  _onViewableItemsChanged = (info) => {
+    if (this.props.onViewableItemsChanged) {
+      this.props.onViewableItemsChanged(info)
+    }
+  }
+}
+
+VirtualizedSectionList.defaultProps = defaultProps
+
+export { VirtualizedSectionList }
+export default VirtualizedSectionList