react-native-windows 0.71.8 → 0.72.0-preview.1

package/Libraries/Lists/SectionList.d.ts

@@ -11,7 +11,7 @@ import type * as React from 'react';
 import type {
   ListRenderItemInfo,
   VirtualizedListWithoutRenderItemProps,
-} from './VirtualizedList';
+} from '@react-native/virtualized-lists';
 import type {
   ScrollView,
   ScrollViewProps,
@@ -75,7 +75,7 @@ export interface SectionListProps<ItemT, SectionT = DefaultSectionT>
    * If any of your `renderItem`, Header, Footer, etc. functions depend on anything outside of the `data` prop,
    * stick it here and treat it immutably.
    */
-  extraData?: any;
+  extraData?: any | undefined;
 
   /**
    * `getItemLayout` is an optional optimization that lets us skip measurement of dynamic
@@ -210,10 +210,9 @@ export interface SectionListScrollParams {
   viewPosition?: number | undefined;
 }
 
-export class SectionList<
-  ItemT = any,
-  SectionT = DefaultSectionT,
-> extends React.Component<SectionListProps<ItemT, SectionT>> {
+export abstract class SectionListComponent<
+  Props,
+> extends React.Component<Props> {
   /**
    * Scrolls to the item at the specified sectionIndex and itemIndex (within the section)
    * positioned in the viewable area such that viewPosition 0 places it at the top
@@ -246,6 +245,11 @@ export class SectionList<
   getScrollableNode(): NodeHandle | undefined;
 }
 
+export class SectionList<
+  ItemT = any,
+  SectionT = DefaultSectionT,
+> extends SectionListComponent<SectionListProps<ItemT, SectionT>> {}
+
 /* This definition is deprecated because it extends the wrong base type */
 export interface SectionListStatic<ItemT, SectionT = DefaultSectionT>
   extends React.ComponentClass<SectionListProps<ItemT, SectionT>> {

package/Libraries/Lists/SectionList.js

@@ -12,13 +12,13 @@
 
 import type {ScrollResponderType} from '../Components/ScrollView/ScrollView';
 import type {
-  Props as VirtualizedSectionListProps,
   ScrollToLocationParamsType,
   SectionBase as _SectionBase,
-} from './VirtualizedSectionList';
+  VirtualizedSectionListProps,
+} from '@react-native/virtualized-lists';
 
 import Platform from '../Utilities/Platform';
-import VirtualizedSectionList from './VirtualizedSectionList';
+import {VirtualizedSectionList} from '@react-native/virtualized-lists';
 import * as React from 'react';
 
 type Item = any;
@@ -248,7 +248,9 @@ export default class SectionList<
         {...restProps}
         stickySectionHeadersEnabled={stickySectionHeadersEnabled}
         ref={this._captureRef}
+        // $FlowFixMe[missing-local-annot]
         getItemCount={items => items.length}
+        // $FlowFixMe[missing-local-annot]
         getItem={(items, index) => items[index]}
       />
     );

package/Libraries/Lists/SectionListModern.js

@@ -12,14 +12,14 @@
 
 import type {ScrollResponderType} from '../Components/ScrollView/ScrollView';
 import type {
-  Props as VirtualizedSectionListProps,
   ScrollToLocationParamsType,
   SectionBase as _SectionBase,
-} from './VirtualizedSectionList';
+  VirtualizedSectionListProps,
+} from '@react-native/virtualized-lists';
 import type {AbstractComponent, Element, ElementRef} from 'react';
 
 import Platform from '../Utilities/Platform';
-import VirtualizedSectionList from './VirtualizedSectionList';
+import {VirtualizedSectionList} from '@react-native/virtualized-lists';
 import React, {forwardRef, useImperativeHandle, useRef} from 'react';
 
 type Item = any;

package/Libraries/Lists/ViewabilityHelper.js

@@ -10,351 +10,15 @@
 
 'use strict';
 
-import type {FrameMetricProps} from './VirtualizedListProps';
+export type {
+  ViewToken,
+  ViewabilityConfig,
+  ViewabilityConfigCallbackPair,
+} from '@react-native/virtualized-lists';
 
-const invariant = require('invariant');
+import {typeof ViewabilityHelper as ViewabilityHelperType} from '@react-native/virtualized-lists';
 
-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
- */
-class ViewabilityHelper {
-  _config: ViewabilityConfig;
-  _hasInteracted: boolean = false;
-  _timers: Set<number> = new Set();
-  _viewableIndices: Array<number> = [];
-  _viewableItems: Map<string, ViewToken> = new Map();
-
-  constructor(
-    config: ViewabilityConfig = {viewAreaCoveragePercentThreshold: 0},
-  ) {
-    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: FrameMetricProps,
-    scrollOffset: number,
-    viewportHeight: number,
-    getFrameMetrics: (
-      index: number,
-      props: FrameMetricProps,
-    ) => ?{
-      length: number,
-      offset: number,
-      ...
-    },
-    // Optional optimization to reduce the scan size
-    renderRange?: {
-      first: number,
-      last: number,
-      ...
-    },
-  ): Array<number> {
-    const itemCount = props.getItemCount(props.data);
-    const {itemVisiblePercentThreshold, viewAreaCoveragePercentThreshold} =
-      this._config;
-    const viewAreaMode = viewAreaCoveragePercentThreshold != null;
-    const viewablePercentThreshold = viewAreaMode
-      ? viewAreaCoveragePercentThreshold
-      : itemVisiblePercentThreshold;
-    invariant(
-      viewablePercentThreshold != null &&
-        (itemVisiblePercentThreshold != null) !==
-          (viewAreaCoveragePercentThreshold != null),
-      'Must set exactly one of itemVisiblePercentThreshold or viewAreaCoveragePercentThreshold',
-    );
-    const viewableIndices = [];
-    if (itemCount === 0) {
-      return viewableIndices;
-    }
-    let firstVisible = -1;
-    const {first, last} = renderRange || {first: 0, last: itemCount - 1};
-    if (last >= itemCount) {
-      console.warn(
-        'Invalid render range computing viewability ' +
-          JSON.stringify({renderRange, itemCount}),
-      );
-      return [];
-    }
-    for (let idx = first; idx <= last; idx++) {
-      const metrics = getFrameMetrics(idx, props);
-      if (!metrics) {
-        continue;
-      }
-      const top = metrics.offset - scrollOffset;
-      const 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: 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,
-    // Optional optimization to reduce the scan size
-    renderRange?: {
-      first: number,
-      last: number,
-      ...
-    },
-  ): void {
-    const itemCount = props.getItemCount(props.data);
-    if (
-      (this._config.waitForInteraction && !this._hasInteracted) ||
-      itemCount === 0 ||
-      !getFrameMetrics(0, props)
-    ) {
-      return;
-    }
-    let viewableIndices: Array<number> = [];
-    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) {
-      const handle: TimeoutID = 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: FrameMetricProps,
-    viewableIndicesToCheck: Array<number>,
-    onViewableItemsChanged: ({
-      changed: Array<ViewToken>,
-      viewableItems: Array<ViewToken>,
-      ...
-    }) => void,
-    createViewToken: (
-      index: number,
-      isViewable: boolean,
-      props: FrameMetricProps,
-    ) => ViewToken,
-  ) {
-    // Filter out indices that have gone out of view since this call was scheduled.
-    viewableIndicesToCheck = viewableIndicesToCheck.filter(ii =>
-      this._viewableIndices.includes(ii),
-    );
-    const prevItems = this._viewableItems;
-    const nextItems = new Map(
-      viewableIndicesToCheck.map(ii => {
-        const viewable = createViewToken(ii, true, props);
-        return [viewable.key, viewable];
-      }),
-    );
-
-    const changed = [];
-    for (const [key, viewable] of nextItems) {
-      if (!prevItems.has(key)) {
-        changed.push(viewable);
-      }
-    }
-    for (const [key, viewable] of prevItems) {
-      if (!nextItems.has(key)) {
-        changed.push({...viewable, isViewable: false});
-      }
-    }
-    if (changed.length > 0) {
-      this._viewableItems = nextItems;
-      onViewableItemsChanged({
-        viewableItems: Array.from(nextItems.values()),
-        changed,
-        viewabilityConfig: this._config,
-      });
-    }
-  }
-}
-
-function _isViewable(
-  viewAreaMode: boolean,
-  viewablePercentThreshold: number,
-  top: number,
-  bottom: number,
-  viewportHeight: number,
-  itemLength: number,
-): boolean {
-  if (_isEntirelyVisible(top, bottom, viewportHeight)) {
-    return true;
-  } else {
-    const pixels = _getPixelsVisible(top, bottom, viewportHeight);
-    const percent =
-      100 * (viewAreaMode ? pixels / viewportHeight : pixels / itemLength);
-    return percent >= viewablePercentThreshold;
-  }
-}
-
-function _getPixelsVisible(
-  top: number,
-  bottom: number,
-  viewportHeight: number,
-): number {
-  const visibleHeight = Math.min(bottom, viewportHeight) - Math.max(top, 0);
-  return Math.max(0, visibleHeight);
-}
-
-function _isEntirelyVisible(
-  top: number,
-  bottom: number,
-  viewportHeight: number,
-): boolean {
-  return top >= 0 && bottom <= viewportHeight && bottom > top;
-}
+const ViewabilityHelper: ViewabilityHelperType =
+  require('@react-native/virtualized-lists').ViewabilityHelper;
 
 module.exports = ViewabilityHelper;

package/Libraries/Lists/VirtualizeUtils.js

@@ -10,249 +10,9 @@
 
 'use strict';
 
-import type {FrameMetricProps} from './VirtualizedListProps';
+import {typeof keyExtractor as KeyExtractorType} from '@react-native/virtualized-lists';
 
-/**
- * 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: Array<number>,
-  props: FrameMetricProps,
-  getFrameMetrics: (
-    index: number,
-    props: FrameMetricProps,
-  ) => {
-    length: number,
-    offset: number,
-    ...
-  },
-  zoomScale: number = 1,
-): Array<number> {
-  const itemCount = props.getItemCount(props.data);
-  const result = [];
-  for (let offsetIndex = 0; offsetIndex < offsets.length; offsetIndex++) {
-    const currentOffset = offsets[offsetIndex];
-    let left = 0;
-    let right = itemCount - 1;
-
-    while (left <= right) {
-      // eslint-disable-next-line no-bitwise
-      const mid = left + ((right - left) >>> 1);
-      const frame = getFrameMetrics(mid, props);
-      const scaledOffsetStart = frame.offset * zoomScale;
-      const 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: {
-    first: number,
-    last: number,
-    ...
-  },
-  next: {
-    first: number,
-    last: number,
-    ...
-  },
-): number {
-  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: 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,
-} {
-  const itemCount = props.getItemCount(props.data);
-  if (itemCount === 0) {
-    return {first: 0, last: -1};
-  }
-  const {offset, velocity, visibleLength, zoomScale = 1} = scrollMetrics;
-
-  // 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.
-  const visibleBegin = Math.max(0, offset);
-  const visibleEnd = visibleBegin + visibleLength;
-  const overscanLength = (windowSize - 1) * visibleLength;
-
-  // Considering velocity seems to introduce more churn than it's worth.
-  const leadFactor = 0.5; // Math.max(0, Math.min(1, velocity / 25 + 0.5));
-
-  const fillPreference =
-    velocity > 1 ? 'after' : velocity < -1 ? 'before' : 'none';
-
-  const overscanBegin = Math.max(
-    0,
-    visibleBegin - (1 - leadFactor) * overscanLength,
-  );
-  const overscanEnd = Math.max(0, visibleEnd + leadFactor * overscanLength);
-
-  const 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.
-  let [overscanFirst, first, last, overscanLast] = elementsThatOverlapOffsets(
-    [overscanBegin, visibleBegin, visibleEnd, overscanEnd],
-    props,
-    getFrameMetricsApprox,
-    zoomScale,
-  );
-  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;
-  const 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.
-  let newCellCount = newRangeCount(prev, visible);
-
-  while (true) {
-    if (first <= overscanFirst && last >= overscanLast) {
-      // If we fill the entire overscan range, we're done.
-      break;
-    }
-    const maxNewCells = newCellCount >= maxToRenderPerBatch;
-    const firstWillAddMore = first <= prev.first || first > prev.last;
-    const firstShouldIncrement =
-      first > overscanFirst && (!maxNewCells || !firstWillAddMore);
-    const lastWillAddMore = last >= prev.last || last < prev.first;
-    const 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};
-}
+const keyExtractor: KeyExtractorType =
+  require('@react-native/virtualized-lists').keyExtractor;
 
-export function keyExtractor(item: any, index: number): string {
-  if (typeof item === 'object' && item?.key != null) {
-    return item.key;
-  }
-  if (typeof item === 'object' && item?.id != null) {
-    return item.id;
-  }
-  return String(index);
-}
+module.exports = {keyExtractor};