@hps1978/react-native-web-tv 0.21.2-tv.0

package/dist/vendor/react-native/ViewabilityHelper/index.js

@@ -0,0 +1,206 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import _createForOfIteratorHelperLoose from "@babel/runtime/helpers/createForOfIteratorHelperLoose";
+import invariant from 'fbjs/lib/invariant';
+/**
+ * A Utility class for calculating viewable items based on current metrics like scroll position and
+ * layout.
+ *
+ * An item is said to be in a "viewable" state when any of the following
+ * is true for longer than `minimumViewTime` milliseconds (after an interaction if `waitForInteraction`
+ * is true):
+ *
+ * - Occupying >= `viewAreaCoveragePercentThreshold` of the view area XOR fraction of the item
+ *   visible in the view area >= `itemVisiblePercentThreshold`.
+ * - Entirely visible on screen
+ */
+class ViewabilityHelper {
+  constructor(config) {
+    if (config === void 0) {
+      config = {
+        viewAreaCoveragePercentThreshold: 0
+      };
+    }
+    this._hasInteracted = false;
+    this._timers = new Set();
+    this._viewableIndices = [];
+    this._viewableItems = new Map();
+    this._config = config;
+  }
+
+  /**
+   * Cleanup, e.g. on unmount. Clears any pending timers.
+   */
+  dispose() {
+    /* $FlowFixMe[incompatible-call] (>=0.63.0 site=react_native_fb) This
+     * comment suppresses an error found when Flow v0.63 was deployed. To see
+     * the error delete this comment and run Flow. */
+    this._timers.forEach(clearTimeout);
+  }
+
+  /**
+   * Determines which items are viewable based on the current metrics and config.
+   */
+  computeViewableItems(props, scrollOffset, viewportHeight, getFrameMetrics,
+  // Optional optimization to reduce the scan size
+  renderRange) {
+    var itemCount = props.getItemCount(props.data);
+    var _this$_config = this._config,
+      itemVisiblePercentThreshold = _this$_config.itemVisiblePercentThreshold,
+      viewAreaCoveragePercentThreshold = _this$_config.viewAreaCoveragePercentThreshold;
+    var viewAreaMode = viewAreaCoveragePercentThreshold != null;
+    var viewablePercentThreshold = viewAreaMode ? viewAreaCoveragePercentThreshold : itemVisiblePercentThreshold;
+    invariant(viewablePercentThreshold != null && itemVisiblePercentThreshold != null !== (viewAreaCoveragePercentThreshold != null), 'Must set exactly one of itemVisiblePercentThreshold or viewAreaCoveragePercentThreshold');
+    var viewableIndices = [];
+    if (itemCount === 0) {
+      return viewableIndices;
+    }
+    var firstVisible = -1;
+    var _ref = renderRange || {
+        first: 0,
+        last: itemCount - 1
+      },
+      first = _ref.first,
+      last = _ref.last;
+    if (last >= itemCount) {
+      console.warn('Invalid render range computing viewability ' + JSON.stringify({
+        renderRange,
+        itemCount
+      }));
+      return [];
+    }
+    for (var idx = first; idx <= last; idx++) {
+      var metrics = getFrameMetrics(idx, props);
+      if (!metrics) {
+        continue;
+      }
+      var top = metrics.offset - scrollOffset;
+      var bottom = top + metrics.length;
+      if (top < viewportHeight && bottom > 0) {
+        firstVisible = idx;
+        if (_isViewable(viewAreaMode, viewablePercentThreshold, top, bottom, viewportHeight, metrics.length)) {
+          viewableIndices.push(idx);
+        }
+      } else if (firstVisible >= 0) {
+        break;
+      }
+    }
+    return viewableIndices;
+  }
+
+  /**
+   * Figures out which items are viewable and how that has changed from before and calls
+   * `onViewableItemsChanged` as appropriate.
+   */
+  onUpdate(props, scrollOffset, viewportHeight, getFrameMetrics, createViewToken, onViewableItemsChanged,
+  // Optional optimization to reduce the scan size
+  renderRange) {
+    var itemCount = props.getItemCount(props.data);
+    if (this._config.waitForInteraction && !this._hasInteracted || itemCount === 0 || !getFrameMetrics(0, props)) {
+      return;
+    }
+    var viewableIndices = [];
+    if (itemCount) {
+      viewableIndices = this.computeViewableItems(props, scrollOffset, viewportHeight, getFrameMetrics, renderRange);
+    }
+    if (this._viewableIndices.length === viewableIndices.length && this._viewableIndices.every((v, ii) => v === viewableIndices[ii])) {
+      // We might get a lot of scroll events where visibility doesn't change and we don't want to do
+      // extra work in those cases.
+      return;
+    }
+    this._viewableIndices = viewableIndices;
+    if (this._config.minimumViewTime) {
+      var handle = setTimeout(() => {
+        /* $FlowFixMe[incompatible-call] (>=0.63.0 site=react_native_fb) This
+         * comment suppresses an error found when Flow v0.63 was deployed. To
+         * see the error delete this comment and run Flow. */
+        this._timers.delete(handle);
+        this._onUpdateSync(props, viewableIndices, onViewableItemsChanged, createViewToken);
+      }, this._config.minimumViewTime);
+      /* $FlowFixMe[incompatible-call] (>=0.63.0 site=react_native_fb) This
+       * comment suppresses an error found when Flow v0.63 was deployed. To see
+       * the error delete this comment and run Flow. */
+      this._timers.add(handle);
+    } else {
+      this._onUpdateSync(props, viewableIndices, onViewableItemsChanged, createViewToken);
+    }
+  }
+
+  /**
+   * clean-up cached _viewableIndices to evaluate changed items on next update
+   */
+  resetViewableIndices() {
+    this._viewableIndices = [];
+  }
+
+  /**
+   * Records that an interaction has happened even if there has been no scroll.
+   */
+  recordInteraction() {
+    this._hasInteracted = true;
+  }
+  _onUpdateSync(props, viewableIndicesToCheck, onViewableItemsChanged, createViewToken) {
+    // Filter out indices that have gone out of view since this call was scheduled.
+    viewableIndicesToCheck = viewableIndicesToCheck.filter(ii => this._viewableIndices.includes(ii));
+    var prevItems = this._viewableItems;
+    var nextItems = new Map(viewableIndicesToCheck.map(ii => {
+      var viewable = createViewToken(ii, true, props);
+      return [viewable.key, viewable];
+    }));
+    var changed = [];
+    for (var _iterator = _createForOfIteratorHelperLoose(nextItems), _step; !(_step = _iterator()).done;) {
+      var _step$value = _step.value,
+        key = _step$value[0],
+        viewable = _step$value[1];
+      if (!prevItems.has(key)) {
+        changed.push(viewable);
+      }
+    }
+    for (var _iterator2 = _createForOfIteratorHelperLoose(prevItems), _step2; !(_step2 = _iterator2()).done;) {
+      var _step2$value = _step2.value,
+        _key = _step2$value[0],
+        _viewable = _step2$value[1];
+      if (!nextItems.has(_key)) {
+        changed.push(_objectSpread(_objectSpread({}, _viewable), {}, {
+          isViewable: false
+        }));
+      }
+    }
+    if (changed.length > 0) {
+      this._viewableItems = nextItems;
+      onViewableItemsChanged({
+        viewableItems: Array.from(nextItems.values()),
+        changed,
+        viewabilityConfig: this._config
+      });
+    }
+  }
+}
+function _isViewable(viewAreaMode, viewablePercentThreshold, top, bottom, viewportHeight, itemLength) {
+  if (_isEntirelyVisible(top, bottom, viewportHeight)) {
+    return true;
+  } else {
+    var pixels = _getPixelsVisible(top, bottom, viewportHeight);
+    var percent = 100 * (viewAreaMode ? pixels / viewportHeight : pixels / itemLength);
+    return percent >= viewablePercentThreshold;
+  }
+}
+function _getPixelsVisible(top, bottom, viewportHeight) {
+  var visibleHeight = Math.min(bottom, viewportHeight) - Math.max(top, 0);
+  return Math.max(0, visibleHeight);
+}
+function _isEntirelyVisible(top, bottom, viewportHeight) {
+  return top >= 0 && bottom <= viewportHeight && bottom > top;
+}
+export default ViewabilityHelper;

package/dist/vendor/react-native/ViewabilityHelper/index.js.flow

@@ -0,0 +1,111 @@
+/**
+ * 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.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+import type { FrameMetricProps } from '../VirtualizedList/VirtualizedListProps';
+import invariant from 'fbjs/lib/invariant';
+export type ViewToken = {
+  item: any,
+  key: string,
+  index: ?number,
+  isViewable: boolean,
+  section?: any,
+  ...
+};
+export type ViewabilityConfigCallbackPair = {
+  viewabilityConfig: ViewabilityConfig,
+  onViewableItemsChanged: (info: {
+    viewableItems: Array<ViewToken>,
+    changed: Array<ViewToken>,
+    ...
+  }) => void,
+  ...
+};
+export type ViewabilityConfig = {|
+  /**
+   * Minimum amount of time (in milliseconds) that an item must be physically viewable before the
+   * viewability callback will be fired. A high number means that scrolling through content without
+   * stopping will not mark the content as viewable.
+   */
+  minimumViewTime?: number,
+  /**
+   * Percent of viewport that must be covered for a partially occluded item to count as
+   * "viewable", 0-100. Fully visible items are always considered viewable. A value of 0 means
+   * that a single pixel in the viewport makes the item viewable, and a value of 100 means that
+   * an item must be either entirely visible or cover the entire viewport to count as viewable.
+   */
+  viewAreaCoveragePercentThreshold?: number,
+  /**
+   * Similar to `viewAreaPercentThreshold`, but considers the percent of the item that is visible,
+   * rather than the fraction of the viewable area it covers.
+   */
+  itemVisiblePercentThreshold?: number,
+  /**
+   * Nothing is considered viewable until the user scrolls or `recordInteraction` is called after
+   * render.
+   */
+  waitForInteraction?: boolean,
+|};
+
+/**
+ * A Utility class for calculating viewable items based on current metrics like scroll position and
+ * layout.
+ *
+ * An item is said to be in a "viewable" state when any of the following
+ * is true for longer than `minimumViewTime` milliseconds (after an interaction if `waitForInteraction`
+ * is true):
+ *
+ * - Occupying >= `viewAreaCoveragePercentThreshold` of the view area XOR fraction of the item
+ *   visible in the view area >= `itemVisiblePercentThreshold`.
+ * - Entirely visible on screen
+ */
+declare class ViewabilityHelper {
+  _config: ViewabilityConfig,
+  _hasInteracted: boolean,
+  _timers: Set<number>,
+  _viewableIndices: Array<number>,
+  _viewableItems: Map<string, ViewToken>,
+  constructor(config: ViewabilityConfig): any,
+  dispose(): any,
+  computeViewableItems(props: FrameMetricProps, scrollOffset: number, viewportHeight: number, getFrameMetrics: (index: number, props: FrameMetricProps) => ?{
+    length: number,
+    offset: number,
+    ...
+  }, renderRange?: {
+    first: number,
+    last: number,
+    ...
+  }): Array<number>,
+  onUpdate(props: FrameMetricProps, scrollOffset: number, viewportHeight: number, getFrameMetrics: (index: number, props: FrameMetricProps) => ?{
+    length: number,
+    offset: number,
+    ...
+  }, createViewToken: (index: number, isViewable: boolean, props: FrameMetricProps) => ViewToken, onViewableItemsChanged: ({
+    viewableItems: Array<ViewToken>,
+    changed: Array<ViewToken>,
+    ...
+  }) => void, renderRange?: {
+    first: number,
+    last: number,
+    ...
+  }): void,
+  resetViewableIndices(): any,
+  recordInteraction(): any,
+  _onUpdateSync(props: FrameMetricProps, viewableIndicesToCheck: Array<number>, onViewableItemsChanged: ({
+    changed: Array<ViewToken>,
+    viewableItems: Array<ViewToken>,
+    ...
+  }) => void, createViewToken: (index: number, isViewable: boolean, props: FrameMetricProps) => ViewToken): any,
+}
+declare function _isViewable(viewAreaMode: boolean, viewablePercentThreshold: number, top: number, bottom: number, viewportHeight: number, itemLength: number): boolean;
+declare function _getPixelsVisible(top: number, bottom: number, viewportHeight: number): number;
+declare function _isEntirelyVisible(top: number, bottom: number, viewportHeight: number): boolean;
+export default ViewabilityHelper;

package/dist/vendor/react-native/VirtualizeUtils/index.js

@@ -0,0 +1,175 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+/**
+ * Used to find the indices of the frames that overlap the given offsets. Useful for finding the
+ * items that bound different windows of content, such as the visible area or the buffered overscan
+ * area.
+ */
+export function elementsThatOverlapOffsets(offsets, props, getFrameMetrics, zoomScale) {
+  if (zoomScale === void 0) {
+    zoomScale = 1;
+  }
+  var itemCount = props.getItemCount(props.data);
+  var result = [];
+  for (var offsetIndex = 0; offsetIndex < offsets.length; offsetIndex++) {
+    var currentOffset = offsets[offsetIndex];
+    var left = 0;
+    var right = itemCount - 1;
+    while (left <= right) {
+      // eslint-disable-next-line no-bitwise
+      var mid = left + (right - left >>> 1);
+      var frame = getFrameMetrics(mid, props);
+      var scaledOffsetStart = frame.offset * zoomScale;
+      var scaledOffsetEnd = (frame.offset + frame.length) * zoomScale;
+
+      // We want the first frame that contains the offset, with inclusive bounds. Thus, for the
+      // first frame the scaledOffsetStart is inclusive, while for other frames it is exclusive.
+      if (mid === 0 && currentOffset < scaledOffsetStart || mid !== 0 && currentOffset <= scaledOffsetStart) {
+        right = mid - 1;
+      } else if (currentOffset > scaledOffsetEnd) {
+        left = mid + 1;
+      } else {
+        result[offsetIndex] = mid;
+        break;
+      }
+    }
+  }
+  return result;
+}
+
+/**
+ * Computes the number of elements in the `next` range that are new compared to the `prev` range.
+ * Handy for calculating how many new items will be rendered when the render window changes so we
+ * can restrict the number of new items render at once so that content can appear on the screen
+ * faster.
+ */
+export function newRangeCount(prev, next) {
+  return next.last - next.first + 1 - Math.max(0, 1 + Math.min(next.last, prev.last) - Math.max(next.first, prev.first));
+}
+
+/**
+ * Custom logic for determining which items should be rendered given the current frame and scroll
+ * metrics, as well as the previous render state. The algorithm may evolve over time, but generally
+ * prioritizes the visible area first, then expands that with overscan regions ahead and behind,
+ * biased in the direction of scroll.
+ */
+export function computeWindowedRenderLimits(props, maxToRenderPerBatch, windowSize, prev, getFrameMetricsApprox, scrollMetrics) {
+  var itemCount = props.getItemCount(props.data);
+  if (itemCount === 0) {
+    return {
+      first: 0,
+      last: -1
+    };
+  }
+  var offset = scrollMetrics.offset,
+    velocity = scrollMetrics.velocity,
+    visibleLength = scrollMetrics.visibleLength,
+    _scrollMetrics$zoomSc = scrollMetrics.zoomScale,
+    zoomScale = _scrollMetrics$zoomSc === void 0 ? 1 : _scrollMetrics$zoomSc;
+
+  // Start with visible area, then compute maximum overscan region by expanding from there, biased
+  // in the direction of scroll. Total overscan area is capped, which should cap memory consumption
+  // too.
+  var visibleBegin = Math.max(0, offset);
+  var visibleEnd = visibleBegin + visibleLength;
+  var overscanLength = (windowSize - 1) * visibleLength;
+
+  // Considering velocity seems to introduce more churn than it's worth.
+  var leadFactor = 0.5; // Math.max(0, Math.min(1, velocity / 25 + 0.5));
+
+  var fillPreference = velocity > 1 ? 'after' : velocity < -1 ? 'before' : 'none';
+  var overscanBegin = Math.max(0, visibleBegin - (1 - leadFactor) * overscanLength);
+  var overscanEnd = Math.max(0, visibleEnd + leadFactor * overscanLength);
+  var lastItemOffset = getFrameMetricsApprox(itemCount - 1, props).offset * zoomScale;
+  if (lastItemOffset < overscanBegin) {
+    // Entire list is before our overscan window
+    return {
+      first: Math.max(0, itemCount - 1 - maxToRenderPerBatch),
+      last: itemCount - 1
+    };
+  }
+
+  // Find the indices that correspond to the items at the render boundaries we're targeting.
+  var _elementsThatOverlapO = elementsThatOverlapOffsets([overscanBegin, visibleBegin, visibleEnd, overscanEnd], props, getFrameMetricsApprox, zoomScale),
+    overscanFirst = _elementsThatOverlapO[0],
+    first = _elementsThatOverlapO[1],
+    last = _elementsThatOverlapO[2],
+    overscanLast = _elementsThatOverlapO[3];
+  overscanFirst = overscanFirst == null ? 0 : overscanFirst;
+  first = first == null ? Math.max(0, overscanFirst) : first;
+  overscanLast = overscanLast == null ? itemCount - 1 : overscanLast;
+  last = last == null ? Math.min(overscanLast, first + maxToRenderPerBatch - 1) : last;
+  var visible = {
+    first,
+    last
+  };
+
+  // We want to limit the number of new cells we're rendering per batch so that we can fill the
+  // content on the screen quickly. If we rendered the entire overscan window at once, the user
+  // could be staring at white space for a long time waiting for a bunch of offscreen content to
+  // render.
+  var newCellCount = newRangeCount(prev, visible);
+  while (true) {
+    if (first <= overscanFirst && last >= overscanLast) {
+      // If we fill the entire overscan range, we're done.
+      break;
+    }
+    var maxNewCells = newCellCount >= maxToRenderPerBatch;
+    var firstWillAddMore = first <= prev.first || first > prev.last;
+    var firstShouldIncrement = first > overscanFirst && (!maxNewCells || !firstWillAddMore);
+    var lastWillAddMore = last >= prev.last || last < prev.first;
+    var lastShouldIncrement = last < overscanLast && (!maxNewCells || !lastWillAddMore);
+    if (maxNewCells && !firstShouldIncrement && !lastShouldIncrement) {
+      // We only want to stop if we've hit maxNewCells AND we cannot increment first or last
+      // without rendering new items. This let's us preserve as many already rendered items as
+      // possible, reducing render churn and keeping the rendered overscan range as large as
+      // possible.
+      break;
+    }
+    if (firstShouldIncrement && !(fillPreference === 'after' && lastShouldIncrement && lastWillAddMore)) {
+      if (firstWillAddMore) {
+        newCellCount++;
+      }
+      first--;
+    }
+    if (lastShouldIncrement && !(fillPreference === 'before' && firstShouldIncrement && firstWillAddMore)) {
+      if (lastWillAddMore) {
+        newCellCount++;
+      }
+      last++;
+    }
+  }
+  if (!(last >= first && first >= 0 && last < itemCount && first >= overscanFirst && last <= overscanLast && first <= visible.first && last >= visible.last)) {
+    throw new Error('Bad window calculation ' + JSON.stringify({
+      first,
+      last,
+      itemCount,
+      overscanFirst,
+      overscanLast,
+      visible
+    }));
+  }
+  return {
+    first,
+    last
+  };
+}
+export function keyExtractor(item, index) {
+  if (typeof item === 'object' && (item == null ? void 0 : item.key) != null) {
+    return item.key;
+  }
+  if (typeof item === 'object' && (item == null ? void 0 : item.id) != null) {
+    return item.id;
+  }
+  return String(index);
+}

package/dist/vendor/react-native/VirtualizeUtils/index.js.flow

@@ -0,0 +1,64 @@
+/**
+ * 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.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+import type { FrameMetricProps } from '../VirtualizedList/VirtualizedListProps';
+
+/**
+ * Used to find the indices of the frames that overlap the given offsets. Useful for finding the
+ * items that bound different windows of content, such as the visible area or the buffered overscan
+ * area.
+ */
+declare export function elementsThatOverlapOffsets(offsets: Array<number>, props: FrameMetricProps, getFrameMetrics: (index: number, props: FrameMetricProps) => {
+  length: number,
+  offset: number,
+  ...
+}, zoomScale: number): Array<number>;
+/**
+ * Computes the number of elements in the `next` range that are new compared to the `prev` range.
+ * Handy for calculating how many new items will be rendered when the render window changes so we
+ * can restrict the number of new items render at once so that content can appear on the screen
+ * faster.
+ */
+declare export function newRangeCount(prev: {
+  first: number,
+  last: number,
+  ...
+}, next: {
+  first: number,
+  last: number,
+  ...
+}): number;
+/**
+ * Custom logic for determining which items should be rendered given the current frame and scroll
+ * metrics, as well as the previous render state. The algorithm may evolve over time, but generally
+ * prioritizes the visible area first, then expands that with overscan regions ahead and behind,
+ * biased in the direction of scroll.
+ */
+declare export function computeWindowedRenderLimits(props: FrameMetricProps, maxToRenderPerBatch: number, windowSize: number, prev: {
+  first: number,
+  last: number,
+}, getFrameMetricsApprox: (index: number, props: FrameMetricProps) => {
+  length: number,
+  offset: number,
+  ...
+}, scrollMetrics: {
+  dt: number,
+  offset: number,
+  velocity: number,
+  visibleLength: number,
+  zoomScale: number,
+  ...
+}): {
+  first: number,
+  last: number,
+};
+declare export function keyExtractor(item: any, index: number): string;

package/dist/vendor/react-native/VirtualizedList/CellRenderMask.js

@@ -0,0 +1,106 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+/**
+ * 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
+ */
+
+import invariant from 'fbjs/lib/invariant';
+export class CellRenderMask {
+  constructor(numCells) {
+    invariant(numCells >= 0, 'CellRenderMask must contain a non-negative number os cells');
+    this._numCells = numCells;
+    if (numCells === 0) {
+      this._regions = [];
+    } else {
+      this._regions = [{
+        first: 0,
+        last: numCells - 1,
+        isSpacer: true
+      }];
+    }
+  }
+  enumerateRegions() {
+    return this._regions;
+  }
+  addCells(cells) {
+    invariant(cells.first >= 0 && cells.first < this._numCells && cells.last >= -1 && cells.last < this._numCells && cells.last >= cells.first - 1, 'CellRenderMask.addCells called with invalid cell range');
+
+    // VirtualizedList uses inclusive ranges, where zero-count states are
+    // possible. E.g. [0, -1] for no cells, starting at 0.
+    if (cells.last < cells.first) {
+      return;
+    }
+    var _this$_findRegion = this._findRegion(cells.first),
+      firstIntersect = _this$_findRegion[0],
+      firstIntersectIdx = _this$_findRegion[1];
+    var _this$_findRegion2 = this._findRegion(cells.last),
+      lastIntersect = _this$_findRegion2[0],
+      lastIntersectIdx = _this$_findRegion2[1];
+
+    // Fast-path if the cells to add are already all present in the mask. We
+    // will otherwise need to do some mutation.
+    if (firstIntersectIdx === lastIntersectIdx && !firstIntersect.isSpacer) {
+      return;
+    }
+
+    // We need to replace the existing covered regions with 1-3 new regions
+    // depending whether we need to split spacers out of overlapping regions.
+    var newLeadRegion = [];
+    var newTailRegion = [];
+    var newMainRegion = _objectSpread(_objectSpread({}, cells), {}, {
+      isSpacer: false
+    });
+    if (firstIntersect.first < newMainRegion.first) {
+      if (firstIntersect.isSpacer) {
+        newLeadRegion.push({
+          first: firstIntersect.first,
+          last: newMainRegion.first - 1,
+          isSpacer: true
+        });
+      } else {
+        newMainRegion.first = firstIntersect.first;
+      }
+    }
+    if (lastIntersect.last > newMainRegion.last) {
+      if (lastIntersect.isSpacer) {
+        newTailRegion.push({
+          first: newMainRegion.last + 1,
+          last: lastIntersect.last,
+          isSpacer: true
+        });
+      } else {
+        newMainRegion.last = lastIntersect.last;
+      }
+    }
+    var replacementRegions = [...newLeadRegion, newMainRegion, ...newTailRegion];
+    var numRegionsToDelete = lastIntersectIdx - firstIntersectIdx + 1;
+    this._regions.splice(firstIntersectIdx, numRegionsToDelete, ...replacementRegions);
+  }
+  numCells() {
+    return this._numCells;
+  }
+  equals(other) {
+    return this._numCells === other._numCells && this._regions.length === other._regions.length && this._regions.every((region, i) => region.first === other._regions[i].first && region.last === other._regions[i].last && region.isSpacer === other._regions[i].isSpacer);
+  }
+  _findRegion(cellIdx) {
+    var firstIdx = 0;
+    var lastIdx = this._regions.length - 1;
+    while (firstIdx <= lastIdx) {
+      var middleIdx = Math.floor((firstIdx + lastIdx) / 2);
+      var middleRegion = this._regions[middleIdx];
+      if (cellIdx >= middleRegion.first && cellIdx <= middleRegion.last) {
+        return [middleRegion, middleIdx];
+      } else if (cellIdx < middleRegion.first) {
+        lastIdx = middleIdx - 1;
+      } else if (cellIdx > middleRegion.last) {
+        firstIdx = middleIdx + 1;
+      }
+    }
+    invariant(false, "A region was not found containing cellIdx " + cellIdx);
+  }
+}

package/dist/vendor/react-native/VirtualizedList/CellRenderMask.js.flow

@@ -0,0 +1,29 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+import invariant from 'fbjs/lib/invariant';
+export type CellRegion = {
+  first: number,
+  last: number,
+  isSpacer: boolean,
+};
+declare export class CellRenderMask {
+  _numCells: number,
+  _regions: Array<CellRegion>,
+  constructor(numCells: number): any,
+  enumerateRegions(): $ReadOnlyArray<CellRegion>,
+  addCells(cells: {
+    first: number,
+    last: number,
+  }): void,
+  numCells(): number,
+  equals(other: CellRenderMask): boolean,
+  _findRegion(cellIdx: number): [CellRegion, number],
+}