@react-native-tvos/virtualized-lists 0.80.1-0 → 0.81.0-0rc3

package/Lists/VirtualizedList.js

@@ -65,6 +65,7 @@ import {
   View,
   findNodeHandle,
 } from 'react-native';
+import * as ReactNativeFeatureFlags from 'react-native/src/private/featureflags/ReactNativeFeatureFlags';
 
 export type {ListRenderItemInfo, ListRenderItem, Separators};
 
@@ -1375,7 +1376,12 @@ class VirtualizedList extends StateSafePureComponent<
 
   _onCellFocusCapture = (cellKey: string) => {
     this._lastFocusedCellKey = cellKey;
-    this._updateCellsToRender();
+    if (ReactNativeFeatureFlags.deferFlatListFocusChangeRenderUpdate()) {
+      // Schedule the cells to render update the same way we handle scroll or layout events.
+      this._scheduleCellsToRenderUpdate();
+    } else {
+      this._updateCellsToRender();
+    }
   };
 
   _onCellUnmount = (cellKey: string) => {

package/Lists/VirtualizedListCellRenderer.js

@@ -19,6 +19,7 @@ import type {
 import {VirtualizedListCellContextProvider} from './VirtualizedListContext.js';
 import invariant from 'invariant';
 import * as React from 'react';
+import {isValidElement} from 'react';
 import {StyleSheet, View} from 'react-native';
 
 export type Props<ItemT> = {
@@ -193,9 +194,7 @@ export default class CellRenderer<ItemT> extends React.PureComponent<
 
     // NOTE: that when this is a sticky header, `onLayout` will get automatically extracted and
     // called explicitly by `ScrollViewStickyHeader`.
-    const itemSeparator: React.Node = React.isValidElement(
-      ItemSeparatorComponent,
-    )
+    const itemSeparator: React.Node = isValidElement(ItemSeparatorComponent)
       ? // $FlowFixMe[incompatible-type]
         ItemSeparatorComponent
       : // $FlowFixMe[incompatible-type]

package/Lists/VirtualizedListContext.js

@@ -8,10 +8,10 @@
  * @format
  */
 
-import typeof VirtualizedList from './VirtualizedList';
+import typeof VirtualizedListT from './VirtualizedList';
 
 import * as React from 'react';
-import {useContext, useMemo} from 'react';
+import {createContext, useContext, useMemo} from 'react';
 
 type Context = $ReadOnly<{
   cellKey: ?string,
@@ -26,16 +26,16 @@ type Context = $ReadOnly<{
     zoomScale: number,
   },
   horizontal: ?boolean,
-  getOutermostParentListRef: () => React.ElementRef<VirtualizedList>,
+  getOutermostParentListRef: () => React.ElementRef<VirtualizedListT>,
   registerAsNestedChild: ({
     cellKey: string,
-    ref: React.ElementRef<VirtualizedList>,
+    ref: React.ElementRef<VirtualizedListT>,
   }) => void,
-  unregisterAsNestedChild: ({ref: React.ElementRef<VirtualizedList>}) => void,
+  unregisterAsNestedChild: ({ref: React.ElementRef<VirtualizedListT>}) => void,
 }>;
 
 export const VirtualizedListContext: React.Context<?Context> =
-  React.createContext(null);
+  createContext(null);
 if (__DEV__) {
   VirtualizedListContext.displayName = 'VirtualizedListContext';
 }

package/Lists/VirtualizedListProps.js

@@ -53,7 +53,7 @@ export type ListRenderItem<ItemT> = (
   info: ListRenderItemInfo<ItemT>,
 ) => React.Node;
 
-type RequiredProps = {
+type RequiredVirtualizedListProps = {
   /**
    * The default accessor functions assume this is an Array<{key: string} | {id: string}> but you can override
    * getItem, getItemCount, and keyExtractor to handle any type of index-based data.
@@ -68,7 +68,7 @@ type RequiredProps = {
    */
   getItemCount: (data: any) => number,
 };
-type OptionalProps = {
+type OptionalVirtualizedListProps = {
   renderItem?: ?ListRenderItem<Item>,
   /**
    * `debug` will turn on extra logging and visual overlays to aid with debugging both usage and
@@ -286,8 +286,8 @@ type OptionalProps = {
 
 export type VirtualizedListProps = {
   ...ScrollViewProps,
-  ...RequiredProps,
-  ...OptionalProps,
+  ...RequiredVirtualizedListProps,
+  ...OptionalVirtualizedListProps,
 };
 
 /**

package/Lists/VirtualizedSectionList.js

@@ -15,18 +15,19 @@ import VirtualizedList from './VirtualizedList';
 import {keyExtractor as defaultKeyExtractor} from './VirtualizeUtils';
 import invariant from 'invariant';
 import * as React from 'react';
+import {useEffect, useState} from 'react';
 
-type DefaultSectionT = {
+type DefaultVirtualizedSectionT = {
   data: any,
   [key: string]: any,
 };
 
-export type SectionData<SectionItemT, SectionT = DefaultSectionT> =
+export type SectionData<SectionItemT, SectionT = DefaultVirtualizedSectionT> =
   | ($ReadOnly<SectionBase<SectionItemT, SectionT>> & SectionT)
   | (SectionBase<SectionItemT, SectionT> & SectionT)
   | SectionT;
 
-export type SectionBase<SectionItemT, SectionT = DefaultSectionT> = {
+export type SectionBase<SectionItemT, SectionT = DefaultVirtualizedSectionT> = {
   /**
    * The data for rendering items in this section.
    */
@@ -54,11 +55,17 @@ export type SectionBase<SectionItemT, SectionT = DefaultSectionT> = {
   ...
 };
 
-type RequiredProps<ItemT, SectionT = DefaultSectionT> = {
+type RequiredVirtualizedSectionListProps<
+  ItemT,
+  SectionT = DefaultVirtualizedSectionT,
+> = {
   sections: $ReadOnlyArray<SectionData<ItemT, SectionT>>,
 };
 
-type OptionalProps<ItemT, SectionT = DefaultSectionT> = {
+type OptionalVirtualizedSectionListProps<
+  ItemT,
+  SectionT = DefaultVirtualizedSectionT,
+> = {
   /**
    * Default renderer for every item in every section.
    */
@@ -99,9 +106,12 @@ type OptionalProps<ItemT, SectionT = DefaultSectionT> = {
   onEndReached?: ?({distanceFromEnd: number, ...}) => void,
 };
 
-export type VirtualizedSectionListProps<ItemT, SectionT = DefaultSectionT> = {
-  ...RequiredProps<ItemT, SectionT>,
-  ...OptionalProps<ItemT, SectionT>,
+export type VirtualizedSectionListProps<
+  ItemT,
+  SectionT = DefaultVirtualizedSectionT,
+> = {
+  ...RequiredVirtualizedSectionListProps<ItemT, SectionT>,
+  ...OptionalVirtualizedSectionListProps<ItemT, SectionT>,
   ...Omit<VirtualizedListProps, 'data' | 'renderItem'>,
 };
 export type ScrollToLocationParamsType = {
@@ -121,7 +131,10 @@ type State = {childProps: VirtualizedListProps, ...};
  */
 class VirtualizedSectionList<
   ItemT,
-  SectionT: SectionBase<ItemT, DefaultSectionT> = DefaultSectionT,
+  SectionT: SectionBase<
+    ItemT,
+    DefaultVirtualizedSectionT,
+  > = DefaultVirtualizedSectionT,
 > extends React.PureComponent<
   VirtualizedSectionListProps<ItemT, SectionT>,
   State,
@@ -509,11 +522,11 @@ function ItemWithSeparator<ItemT>(
   } = props;
 
   const [leadingSeparatorHiglighted, setLeadingSeparatorHighlighted] =
-    React.useState(false);
+    useState(false);
 
-  const [separatorHighlighted, setSeparatorHighlighted] = React.useState(false);
+  const [separatorHighlighted, setSeparatorHighlighted] = useState(false);
 
-  const [leadingSeparatorProps, setLeadingSeparatorProps] = React.useState<
+  const [leadingSeparatorProps, setLeadingSeparatorProps] = useState<
     ItemWithSeparatorCommonProps<ItemT>,
   >({
     leadingItem: props.leadingItem,
@@ -522,7 +535,7 @@ function ItemWithSeparator<ItemT>(
     trailingItem: props.item,
     trailingSection: props.trailingSection,
   });
-  const [separatorProps, setSeparatorProps] = React.useState<
+  const [separatorProps, setSeparatorProps] = useState<
     ItemWithSeparatorCommonProps<ItemT>,
   >({
     leadingItem: props.item,
@@ -532,7 +545,7 @@ function ItemWithSeparator<ItemT>(
     trailingSection: props.trailingSection,
   });
 
-  React.useEffect(() => {
+  useEffect(() => {
     setSelfHighlightCallback(cellKey, setSeparatorHighlighted);
     // $FlowFixMe[incompatible-call]
     setSelfUpdatePropsCallback(cellKey, setSeparatorProps);
@@ -612,7 +625,10 @@ function ItemWithSeparator<ItemT>(
 
 const VirtualizedSectionListComponent = VirtualizedSectionList as component<
   ItemT,
-  SectionT: SectionBase<ItemT, DefaultSectionT> = DefaultSectionT,
+  SectionT: SectionBase<
+    ItemT,
+    DefaultVirtualizedSectionT,
+  > = DefaultVirtualizedSectionT,
 >(
   ref: React.RefSetter<
     interface {

package/Utilities/clamp.js

@@ -4,8 +4,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @format
  * @flow strict
+ * @format
  */
 
 'use strict';

package/Utilities/infoLog.js

@@ -4,8 +4,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @format
  * @flow strict
+ * @format
  */
 
 'use strict';

package/index.js

@@ -4,18 +4,18 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @format
  * @flow
+ * @format
  */
 
 'use strict';
 
-import typeof FillRateHelper from './Lists/FillRateHelper';
-import typeof ViewabilityHelper from './Lists/ViewabilityHelper';
-import typeof VirtualizedList from './Lists/VirtualizedList';
-import type {AnyVirtualizedSectionList} from './Lists/VirtualizedSectionList';
+import typeof FillRateHelperT from './Lists/FillRateHelper';
+import typeof ViewabilityHelperT from './Lists/ViewabilityHelper';
+import typeof VirtualizedListT from './Lists/VirtualizedList';
+import type {AnyVirtualizedSectionList as AnyVirtualizedSectionListT} from './Lists/VirtualizedSectionList';
 
-import {typeof VirtualizedListContextResetter} from './Lists/VirtualizedListContext';
+import {typeof VirtualizedListContextResetter as VirtualizedListContextResetterT} from './Lists/VirtualizedListContext';
 import {keyExtractor} from './Lists/VirtualizeUtils';
 
 export type {
@@ -42,20 +42,20 @@ export type {FillRateInfo} from './Lists/FillRateHelper';
 export default {
   keyExtractor,
 
-  get VirtualizedList(): VirtualizedList {
+  get VirtualizedList(): VirtualizedListT {
     return require('./Lists/VirtualizedList').default;
   },
-  get VirtualizedSectionList(): AnyVirtualizedSectionList {
+  get VirtualizedSectionList(): AnyVirtualizedSectionListT {
     return require('./Lists/VirtualizedSectionList').default;
   },
-  get VirtualizedListContextResetter(): VirtualizedListContextResetter {
+  get VirtualizedListContextResetter(): VirtualizedListContextResetterT {
     const VirtualizedListContext = require('./Lists/VirtualizedListContext');
     return VirtualizedListContext.VirtualizedListContextResetter;
   },
-  get ViewabilityHelper(): ViewabilityHelper {
+  get ViewabilityHelper(): ViewabilityHelperT {
     return require('./Lists/ViewabilityHelper').default;
   },
-  get FillRateHelper(): FillRateHelper {
+  get FillRateHelper(): FillRateHelperT {
     return require('./Lists/FillRateHelper').default;
   },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-tvos/virtualized-lists",
-  "version": "0.80.1-0",
+  "version": "0.81.0-0rc3",
   "description": "Virtualized lists for React Native.",
   "license": "MIT",
   "repository": {
@@ -17,7 +17,7 @@
   ],
   "bugs": "https://github.com/facebook/react-native/issues",
   "engines": {
-    "node": ">=18"
+    "node": ">= 20.19.4"
   },
   "exports": {
     ".": {
@@ -51,7 +51,7 @@
     "react-test-renderer": "19.1.0"
   },
   "peerDependencies": {
-    "@types/react": "^19.0.0",
+    "@types/react": "^19.1.0",
     "react": "*",
     "react-native": "*"
   },

package/types_generated/Lists/CellRenderMask.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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.
+ *
+ * @generated SignedSource<<f61be1758ae0ac5c3b456e1351e93910>>
+ *
+ * This file was translated from Flow by scripts/build-types/index.js.
+ * Original file: packages/virtualized-lists/Lists/CellRenderMask.js
+ */
+
+export type CellRegion = {
+  first: number;
+  last: number;
+  isSpacer: boolean;
+};
+export declare class CellRenderMask {
+  constructor(numCells: number);
+  enumerateRegions(): ReadonlyArray<CellRegion>;
+  addCells(cells: {
+    first: number;
+    last: number;
+  }): void;
+  numCells(): number;
+  equals(other: CellRenderMask): boolean;
+}

package/types_generated/Lists/FillRateHelper.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 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.
+ *
+ * @generated SignedSource<<e813b2d289d62a261179b333cb431e6f>>
+ *
+ * This file was translated from Flow by scripts/build-types/index.js.
+ * Original file: packages/virtualized-lists/Lists/FillRateHelper.js
+ */
+
+import type { CellMetricProps } from "./ListMetricsAggregator";
+import ListMetricsAggregator from "./ListMetricsAggregator";
+export type FillRateInfo = Info;
+declare class Info {
+  any_blank_count: number;
+  any_blank_ms: number;
+  any_blank_speed_sum: number;
+  mostly_blank_count: number;
+  mostly_blank_ms: number;
+  pixels_blank: number;
+  pixels_sampled: number;
+  pixels_scrolled: number;
+  total_time_spent: number;
+  sample_count: number;
+}
+/**
+ * A helper class for detecting when the maximem fill rate of `VirtualizedList` is exceeded.
+ * By default the sampling rate is set to zero and this will do nothing. If you want to collect
+ * samples (e.g. to log them), make sure to call `FillRateHelper.setSampleRate(0.0-1.0)`.
+ *
+ * Listeners and sample rate are global for all `VirtualizedList`s - typical usage will combine with
+ * `SceneTracker.getActiveScene` to determine the context of the events.
+ */
+declare class FillRateHelper {
+  static addListener(callback: ($$PARAM_0$$: FillRateInfo) => void): {
+    remove: () => void;
+  };
+  static setSampleRate(sampleRate: number): void;
+  static setMinSampleCount(minSampleCount: number): void;
+  constructor(listMetrics: ListMetricsAggregator);
+  activate(): void;
+  deactivateAndFlush(): void;
+  computeBlankness(props: Omit<CellMetricProps, keyof {
+    initialNumToRender?: number | undefined;
+  }> & {
+    initialNumToRender?: number | undefined;
+  }, cellsAroundViewport: {
+    first: number;
+    last: number;
+  }, scrollMetrics: {
+    dOffset: number;
+    offset: number;
+    velocity: number;
+    visibleLength: number;
+  }): number;
+  enabled(): boolean;
+}
+export default FillRateHelper;

package/types_generated/Lists/ListMetricsAggregator.d.ts

@@ -0,0 +1,119 @@
+/**
+ * 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.
+ *
+ * @generated SignedSource<<993b116aaf2c8d4835bce3f9a4c6392f>>
+ *
+ * This file was translated from Flow by scripts/build-types/index.js.
+ * Original file: packages/virtualized-lists/Lists/ListMetricsAggregator.js
+ */
+
+import type { VirtualizedListProps } from "./VirtualizedListProps";
+import type { LayoutRectangle } from "react-native";
+export type CellMetrics = {
+  /**
+   * Index of the item in the list
+   */
+  index: number;
+  /**
+   * Length of the cell along the scrolling axis
+   */
+  length: number;
+  /**
+   * Distance between this cell and the start of the list along the scrolling
+   * axis
+   */
+  offset: number;
+  /**
+   * Whether the cell is last known to be mounted
+   */
+  isMounted: boolean;
+};
+export type ListOrientation = {
+  horizontal: boolean;
+  rtl: boolean;
+};
+/**
+ * Subset of VirtualizedList props needed to calculate cell metrics
+ */
+export type CellMetricProps = {
+  data: VirtualizedListProps["data"];
+  getItemCount: VirtualizedListProps["getItemCount"];
+  getItem: VirtualizedListProps["getItem"];
+  getItemLayout?: VirtualizedListProps["getItemLayout"];
+  keyExtractor?: VirtualizedListProps["keyExtractor"];
+};
+/**
+ * Provides an interface to query information about the metrics of a list and its cells.
+ */
+declare class ListMetricsAggregator {
+  /**
+   * Notify the ListMetricsAggregator that a cell has been laid out.
+   *
+   * @returns whether the cell layout has changed since last notification
+   */
+  notifyCellLayout($$PARAM_0$$: {
+    cellIndex: number;
+    cellKey: string;
+    orientation: ListOrientation;
+    layout: LayoutRectangle;
+  }): boolean;
+  /**
+   * Notify ListMetricsAggregator that a cell has been unmounted.
+   */
+  notifyCellUnmounted(cellKey: string): void;
+  /**
+   * Notify ListMetricsAggregator that the lists content container has been laid out.
+   */
+  notifyListContentLayout($$PARAM_0$$: {
+    orientation: ListOrientation;
+    layout: Readonly<{
+      width: number;
+      height: number;
+    }>;
+  }): void;
+  /**
+   * Return the average length of the cells which have been measured
+   */
+  getAverageCellLength(): number;
+  /**
+   * Return the highest measured cell index (or 0 if nothing has been measured
+   * yet)
+   */
+  getHighestMeasuredCellIndex(): number;
+  /**
+   * Returns the exact metrics of a cell if it has already been laid out,
+   * otherwise an estimate based on the average length of previously measured
+   * cells
+   */
+  getCellMetricsApprox(index: number, props: CellMetricProps): CellMetrics;
+  /**
+   * Returns the exact metrics of a cell if it has already been laid out
+   */
+  getCellMetrics(index: number, props: CellMetricProps): null | undefined | CellMetrics;
+  /**
+   * Gets an approximate offset to an item at a given index. Supports
+   * fractional indices.
+   */
+  getCellOffsetApprox(index: number, props: CellMetricProps): number;
+  /**
+   * Returns the length of all ScrollView content along the scrolling axis.
+   */
+  getContentLength(): number;
+  /**
+   * Whether a content length has been observed
+   */
+  hasContentLength(): boolean;
+  /**
+   * Finds the flow-relative offset (e.g. starting from the left in LTR, but
+   * right in RTL) from a layout box.
+   */
+  flowRelativeOffset(layout: LayoutRectangle, referenceContentLength?: null | undefined | number): number;
+  /**
+   * Converts a flow-relative offset to a cartesian offset
+   */
+  cartesianOffset(flowRelativeOffset: number): number;
+}
+export default ListMetricsAggregator;

package/types_generated/Lists/StateSafePureComponent.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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.
+ *
+ * @generated SignedSource<<fb3d702a36fcffc782ea82ce81cf27bd>>
+ *
+ * This file was translated from Flow by scripts/build-types/index.js.
+ * Original file: packages/virtualized-lists/Lists/StateSafePureComponent.js
+ */
+
+import * as React from "react";
+/**
+ * `setState` is called asynchronously, and should not rely on the value of
+ * `this.props` or `this.state`:
+ * https://react.dev/docs/state-and-lifecycle.html#state-updates-may-be-asynchronous
+ *
+ * SafePureComponent adds runtime enforcement, to catch cases where these
+ * variables are read in a state updater function, instead of the ones passed
+ * in.
+ */
+declare class StateSafePureComponent<Props, State extends {}> extends React.PureComponent<Props, State> {
+  constructor(props: Props);
+  setState<K extends keyof State>(partialState: null | undefined | (Pick<State, K> | (($$PARAM_0$$: State, $$PARAM_1$$: Props) => null | undefined | Pick<State, K>)), callback?: () => unknown): void;
+}
+export default StateSafePureComponent;

package/types_generated/Lists/ViewabilityHelper.d.ts

@@ -0,0 +1,100 @@
+/**
+ * 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.
+ *
+ * @generated SignedSource<<c71c6155a6c1167093da67c32c306d07>>
+ *
+ * This file was translated from Flow by scripts/build-types/index.js.
+ * Original file: packages/virtualized-lists/Lists/ViewabilityHelper.js
+ */
+
+import type { CellMetricProps } from "./ListMetricsAggregator";
+import ListMetricsAggregator from "./ListMetricsAggregator";
+export type ViewToken = {
+  item: any;
+  key: string;
+  index: number | undefined;
+  isViewable: boolean;
+  section?: any;
+};
+export type ViewabilityConfigCallbackPair = {
+  viewabilityConfig: ViewabilityConfig;
+  onViewableItemsChanged: (info: {
+    viewableItems: Array<ViewToken>;
+    changed: Array<ViewToken>;
+  }) => void;
+};
+export type ViewabilityConfigCallbackPairs = Array<ViewabilityConfigCallbackPair>;
+export type ViewabilityConfig = Readonly<{
+  /**
+   * 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 {
+  constructor(config?: ViewabilityConfig);
+  /**
+   * Cleanup, e.g. on unmount. Clears any pending timers.
+   */
+  dispose(): void;
+  /**
+   * Determines which items are viewable based on the current metrics and config.
+   */
+  computeViewableItems(props: CellMetricProps, scrollOffset: number, viewportHeight: number, listMetrics: ListMetricsAggregator, renderRange?: {
+    first: number;
+    last: number;
+  }): Array<number>;
+  /**
+   * Figures out which items are viewable and how that has changed from before and calls
+   * `onViewableItemsChanged` as appropriate.
+   */
+  onUpdate(props: CellMetricProps, scrollOffset: number, viewportHeight: number, listMetrics: ListMetricsAggregator, createViewToken: (index: number, isViewable: boolean, props: CellMetricProps) => ViewToken, onViewableItemsChanged: ($$PARAM_0$$: {
+    viewableItems: Array<ViewToken>;
+    changed: Array<ViewToken>;
+  }) => void, renderRange?: {
+    first: number;
+    last: number;
+  }): void;
+  /**
+   * clean-up cached _viewableIndices to evaluate changed items on next update
+   */
+  resetViewableIndices(): void;
+  /**
+   * Records that an interaction has happened even if there has been no scroll.
+   */
+  recordInteraction(): void;
+}
+export default ViewabilityHelper;

package/types_generated/Lists/VirtualizeUtils.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 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.
+ *
+ * @generated SignedSource<<c677afc34af685572670d7d4065a70dc>>
+ *
+ * This file was translated from Flow by scripts/build-types/index.js.
+ * Original file: packages/virtualized-lists/Lists/VirtualizeUtils.js
+ */
+
+import type ListMetricsAggregator from "./ListMetricsAggregator";
+import type { CellMetricProps } from "./ListMetricsAggregator";
+/**
+ * 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 declare function elementsThatOverlapOffsets(offsets: Array<number>, props: CellMetricProps, listMetrics: ListMetricsAggregator, 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.
+ */
+export declare 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.
+ */
+export declare function computeWindowedRenderLimits(props: CellMetricProps, maxToRenderPerBatch: number, windowSize: number, prev: {
+  first: number;
+  last: number;
+}, listMetrics: ListMetricsAggregator, scrollMetrics: {
+  dt: number;
+  offset: number;
+  velocity: number;
+  visibleLength: number;
+  zoomScale: number;
+}): {
+  first: number;
+  last: number;
+};
+export declare function keyExtractor(item: any, index: number): string;

package/types_generated/Lists/VirtualizedList.d.ts

@@ -0,0 +1,116 @@
+/**
+ * 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.
+ *
+ * @generated SignedSource<<8997e25a6b501ab434c0037b6347705b>>
+ *
+ * This file was translated from Flow by scripts/build-types/index.js.
+ * Original file: packages/virtualized-lists/Lists/VirtualizedList.js
+ */
+
+import type { Item, ListRenderItem, ListRenderItemInfo, Separators, VirtualizedListProps } from "./VirtualizedListProps";
+import type { ScrollEvent, ScrollResponderType } from "react-native";
+import { CellRenderMask } from "./CellRenderMask";
+import StateSafePureComponent from "./StateSafePureComponent";
+import { VirtualizedListContext } from "./VirtualizedListContext.js";
+import * as React from "react";
+import { ScrollView } from "react-native";
+export type { ListRenderItemInfo, ListRenderItem, Separators };
+type State = {
+  renderMask: CellRenderMask;
+  cellsAroundViewport: {
+    first: number;
+    last: number;
+  };
+  firstVisibleItemKey: string | undefined;
+  pendingScrollUpdateCount: number;
+};
+/**
+ * Base implementation for the more convenient [`<FlatList>`](https://reactnative.dev/docs/flatlist)
+ * and [`<SectionList>`](https://reactnative.dev/docs/sectionlist) components, which are also better
+ * documented. In general, this should only really be used if you need more flexibility than
+ * `FlatList` provides, e.g. for use with immutable data instead of plain arrays.
+ *
+ * Virtualization massively improves memory consumption and performance of large lists by
+ * maintaining a finite render window of active items and replacing all items outside of the render
+ * window with appropriately sized blank space. The window adapts to scrolling behavior, and items
+ * are rendered incrementally with low-pri (after any running interactions) if they are far from the
+ * visible area, or with hi-pri otherwise to minimize the potential of seeing blank space.
+ *
+ * Some caveats:
+ *
+ * - Internal state is not preserved when content scrolls out of the render window. Make sure all
+ *   your data is captured in the item data or external stores like Flux, Redux, or Relay.
+ * - This is a `PureComponent` which means that it will not re-render if `props` remain shallow-
+ *   equal. Make sure that everything your `renderItem` function depends on is passed as a prop
+ *   (e.g. `extraData`) that is not `===` after updates, otherwise your UI may not update on
+ *   changes. This includes the `data` prop and parent component state.
+ * - In order to constrain memory and enable smooth scrolling, content is rendered asynchronously
+ *   offscreen. This means it's possible to scroll faster than the fill rate ands momentarily see
+ *   blank content. This is a tradeoff that can be adjusted to suit the needs of each application,
+ *   and we are working on improving it behind the scenes.
+ * - By default, the list looks for a `key` or `id` prop on each item and uses that for the React key.
+ *   Alternatively, you can provide a custom `keyExtractor` prop.
+ * - As an effort to remove defaultProps, use helper functions when referencing certain props
+ *
+ */
+declare class VirtualizedList extends StateSafePureComponent<VirtualizedListProps, State> {
+  static contextType: typeof VirtualizedListContext;
+  scrollToEnd(params?: null | undefined | {
+    animated?: boolean | undefined;
+  }): void;
+  scrollToIndex(params: {
+    animated?: boolean | undefined;
+    index: number;
+    viewOffset?: number;
+    viewPosition?: number;
+  }): any;
+  scrollToItem(params: {
+    animated?: boolean | undefined;
+    item: Item;
+    viewOffset?: number;
+    viewPosition?: number;
+  }): void;
+  /**
+   * Scroll to a specific content pixel offset in the list.
+   *
+   * Param `offset` expects the offset to scroll to.
+   * In case of `horizontal` is true, the offset is the x-value,
+   * in any other case the offset is the y-value.
+   *
+   * Param `animated` (`true` by default) defines whether the list
+   * should do an animation while scrolling.
+   */
+  scrollToOffset(params: {
+    animated?: boolean | undefined;
+    offset: number;
+  }): void;
+  recordInteraction(): void;
+  flashScrollIndicators(): void;
+  /**
+   * Provides a handle to the underlying scroll responder.
+   * Note that `this._scrollRef` might not be a `ScrollView`, so we
+   * need to check that it responds to `getScrollResponder` before calling it.
+   */
+  getScrollResponder(): null | undefined | ScrollResponderType;
+  getScrollableNode(): null | undefined | number;
+  getScrollRef(): null | undefined | React.ComponentRef<typeof ScrollView>;
+  setNativeProps(props: Object): void;
+  hasMore(): boolean;
+  state: State;
+  constructor(props: VirtualizedListProps);
+  componentDidMount(): void;
+  componentWillUnmount(): void;
+  static getDerivedStateFromProps(newProps: VirtualizedListProps, prevState: State): State;
+  render(): React.ReactNode;
+  componentDidUpdate(prevProps: VirtualizedListProps): void;
+  measureLayoutRelativeToContainingList(): void;
+  unstable_onScroll(e: Object): void;
+  unstable_onScrollBeginDrag(e: ScrollEvent): void;
+  unstable_onScrollEndDrag(e: ScrollEvent): void;
+  unstable_onMomentumScrollBegin(e: ScrollEvent): void;
+  unstable_onMomentumScrollEnd(e: ScrollEvent): void;
+}
+export default VirtualizedList;

package/types_generated/Lists/VirtualizedListContext.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 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.
+ *
+ * @generated SignedSource<<55bd8debf6bc6068e4368f5b7905b017>>
+ *
+ * This file was translated from Flow by scripts/build-types/index.js.
+ * Original file: packages/virtualized-lists/Lists/VirtualizedListContext.js
+ */
+
+import type $$IMPORT_TYPEOF_1$$ from "./VirtualizedList";
+type VirtualizedListT = typeof $$IMPORT_TYPEOF_1$$;
+import * as React from "react";
+type Context = Readonly<{
+  cellKey: string | undefined;
+  getScrollMetrics: () => {
+    contentLength: number;
+    dOffset: number;
+    dt: number;
+    offset: number;
+    timestamp: number;
+    velocity: number;
+    visibleLength: number;
+    zoomScale: number;
+  };
+  horizontal: boolean | undefined;
+  getOutermostParentListRef: () => React.ComponentRef<VirtualizedListT>;
+  registerAsNestedChild: ($$PARAM_0$$: {
+    cellKey: string;
+    ref: React.ComponentRef<VirtualizedListT>;
+  }) => void;
+  unregisterAsNestedChild: ($$PARAM_0$$: {
+    ref: React.ComponentRef<VirtualizedListT>;
+  }) => void;
+}>;
+export declare const VirtualizedListContext: React.Context<null | undefined | Context>;
+export declare type VirtualizedListContext = typeof VirtualizedListContext;
+/**
+ * Resets the context. Intended for use by portal-like components (e.g. Modal).
+ */
+export declare function VirtualizedListContextResetter($$PARAM_0$$: {
+  children: React.ReactNode;
+}): React.ReactNode;
+/**
+ * Sets the context with memoization. Intended to be used by `VirtualizedList`.
+ */
+export declare function VirtualizedListContextProvider($$PARAM_0$$: {
+  children: React.ReactNode;
+  value: Context;
+}): React.ReactNode;
+/**
+ * Sets the `cellKey`. Intended to be used by `VirtualizedList` for each cell.
+ */
+export declare function VirtualizedListCellContextProvider($$PARAM_0$$: {
+  cellKey: string;
+  children: React.ReactNode;
+}): React.ReactNode;

package/types_generated/Lists/VirtualizedListProps.d.ts

@@ -0,0 +1,275 @@
+/**
+ * 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.
+ *
+ * @generated SignedSource<<fcf224b18f3315e5b84e224781b4eeb1>>
+ *
+ * This file was translated from Flow by scripts/build-types/index.js.
+ * Original file: packages/virtualized-lists/Lists/VirtualizedListProps.js
+ */
+
+import type { ViewabilityConfig, ViewabilityConfigCallbackPair, ViewToken } from "./ViewabilityHelper";
+import type { FocusEvent, LayoutChangeEvent, ScrollViewProps, StyleProp, ViewStyle } from "react-native";
+import * as React from "react";
+export type Item = any;
+export type Separators = {
+  highlight: () => void;
+  unhighlight: () => void;
+  updateProps: (select: "leading" | "trailing", newProps: Object) => void;
+};
+export type ListRenderItemInfo<ItemT> = {
+  item: ItemT;
+  index: number;
+  separators: Separators;
+};
+export type CellRendererProps<ItemT> = Readonly<{
+  cellKey: string;
+  children: React.ReactNode;
+  index: number;
+  item: ItemT;
+  onFocusCapture?: (event: FocusEvent) => void;
+  onLayout?: (event: LayoutChangeEvent) => void;
+  style: StyleProp<ViewStyle>;
+}>;
+export type ListRenderItem<ItemT> = (info: ListRenderItemInfo<ItemT>) => React.ReactNode;
+type RequiredVirtualizedListProps = {
+  /**
+   * The default accessor functions assume this is an Array<{key: string} | {id: string}> but you can override
+   * getItem, getItemCount, and keyExtractor to handle any type of index-based data.
+   */
+  data?: any;
+  /**
+   * A generic accessor for extracting an item from any sort of data blob.
+   */
+  getItem: (data: any, index: number) => Item | undefined;
+  /**
+   * Determines how many items are in the data blob.
+   */
+  getItemCount: (data: any) => number;
+};
+type OptionalVirtualizedListProps = {
+  renderItem?: ListRenderItem<Item> | undefined;
+  /**
+   * `debug` will turn on extra logging and visual overlays to aid with debugging both usage and
+   * implementation, but with a significant perf hit.
+   */
+  debug?: boolean | undefined;
+  /**
+   * DEPRECATED: Virtualization provides significant performance and memory optimizations, but fully
+   * unmounts react instances that are outside of the render window. You should only need to disable
+   * this for debugging purposes. Defaults to false.
+   */
+  disableVirtualization?: boolean | undefined;
+  /**
+   * A marker property for telling the list to re-render (since it implements `PureComponent`). 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;
+  getItemLayout?: (data: any, index: number) => {
+    length: number;
+    offset: number;
+    index: number;
+  };
+  horizontal?: boolean | undefined;
+  /**
+   * How many items to render in the initial batch. This should be enough to fill the screen but not
+   * much more. Note these items will never be unmounted as part of the windowed rendering in order
+   * to improve perceived performance of scroll-to-top actions.
+   */
+  initialNumToRender?: number | undefined;
+  /**
+   * Instead of starting at the top with the first item, start at `initialScrollIndex`. This
+   * disables the "scroll to top" optimization that keeps the first `initialNumToRender` items
+   * always rendered and immediately renders the items starting at this initial index. Requires
+   * `getItemLayout` to be implemented.
+   */
+  initialScrollIndex?: number | undefined;
+  /**
+   * Reverses the direction of scroll. Uses scale transforms of -1.
+   */
+  inverted?: boolean | undefined;
+  keyExtractor?: ((item: Item, index: number) => string) | undefined;
+  /**
+   * CellRendererComponent allows customizing how cells rendered by
+   * `renderItem`/`ListItemComponent` are wrapped when placed into the
+   * underlying ScrollView. This component must accept event handlers which
+   * notify VirtualizedList of changes within the cell.
+   */
+  CellRendererComponent?: React.ComponentType<CellRendererProps<Item>> | undefined;
+  /**
+   * Rendered in between each item, but not at the top or bottom. By default, `highlighted` and
+   * `leadingItem` props are provided. `renderItem` provides `separators.highlight`/`unhighlight`
+   * which will update the `highlighted` prop, but you can also add custom props with
+   * `separators.updateProps`.
+   */
+  ItemSeparatorComponent?: React.ComponentType<any> | undefined;
+  /**
+   * Takes an item from `data` and renders it into the list. Example usage:
+   *
+   *     <FlatList
+   *       ItemSeparatorComponent={Platform.OS !== 'android' && ({highlighted}) => (
+   *         <View style={[style.separator, highlighted && {marginLeft: 0}]} />
+   *       )}
+   *       data={[{title: 'Title Text', key: 'item1'}]}
+   *       ListItemComponent={({item, separators}) => (
+   *         <TouchableHighlight
+   *           onPress={() => this._onPress(item)}
+   *           onShowUnderlay={separators.highlight}
+   *           onHideUnderlay={separators.unhighlight}>
+   *           <View style={{backgroundColor: 'white'}}>
+   *             <Text>{item.title}</Text>
+   *           </View>
+   *         </TouchableHighlight>
+   *       )}
+   *     />
+   *
+   * Provides additional metadata like `index` if you need it, as well as a more generic
+   * `separators.updateProps` function which let's you set whatever props you want to change the
+   * rendering of either the leading separator or trailing separator in case the more common
+   * `highlight` and `unhighlight` (which set the `highlighted: boolean` prop) are insufficient for
+   * your use-case.
+   */
+  ListItemComponent?: (React.ComponentType<any> | React.JSX.Element) | undefined;
+  /**
+   * Rendered when the list is empty. Can be a React Component Class, a render function, or
+   * a rendered element.
+   */
+  ListEmptyComponent?: (React.ComponentType<any> | React.JSX.Element) | undefined;
+  /**
+   * Rendered at the bottom of all the items. Can be a React Component Class, a render function, or
+   * a rendered element.
+   */
+  ListFooterComponent?: (React.ComponentType<any> | React.JSX.Element) | undefined;
+  /**
+   * Styling for internal View for ListFooterComponent
+   */
+  ListFooterComponentStyle?: StyleProp<ViewStyle>;
+  /**
+   * Rendered at the top of all the items. Can be a React Component Class, a render function, or
+   * a rendered element.
+   */
+  ListHeaderComponent?: (React.ComponentType<any> | React.JSX.Element) | undefined;
+  /**
+   * Styling for internal View for ListHeaderComponent
+   */
+  ListHeaderComponentStyle?: StyleProp<ViewStyle>;
+  /**
+   * The maximum number of items to render in each incremental render batch. The more rendered at
+   * once, the better the fill rate, but responsiveness may suffer because rendering content may
+   * interfere with responding to button taps or other interactions.
+   */
+  maxToRenderPerBatch?: number | undefined;
+  /**
+   * Called once when the scroll position gets within within `onEndReachedThreshold`
+   * from the logical end of the list.
+   */
+  onEndReached?: ((info: {
+    distanceFromEnd: number;
+  }) => void) | undefined;
+  /**
+   * How far from the end (in units of visible length of the list) the trailing edge of the
+   * list must be from the end of the content to trigger the `onEndReached` callback.
+   * Thus, a value of 0.5 will trigger `onEndReached` when the end of the content is
+   * within half the visible length of the list.
+   */
+  onEndReachedThreshold?: number | undefined;
+  /**
+   * If provided, a standard RefreshControl will be added for "Pull to Refresh" functionality. Make
+   * sure to also set the `refreshing` prop correctly.
+   */
+  onRefresh?: (() => void) | undefined;
+  /**
+   * Used to handle failures when scrolling to an index that has not been measured yet. Recommended
+   * action is to either compute your own offset and `scrollTo` it, or scroll as far as possible and
+   * then try again after more items have been rendered.
+   */
+  onScrollToIndexFailed?: ((info: {
+    index: number;
+    highestMeasuredFrameIndex: number;
+    averageItemLength: number;
+  }) => void) | undefined;
+  /**
+   * Called once when the scroll position gets within within `onStartReachedThreshold`
+   * from the logical start of the list.
+   */
+  onStartReached?: ((info: {
+    distanceFromStart: number;
+  }) => void) | undefined;
+  /**
+   * How far from the start (in units of visible length of the list) the leading edge of the
+   * list must be from the start of the content to trigger the `onStartReached` callback.
+   * Thus, a value of 0.5 will trigger `onStartReached` when the start of the content is
+   * within half the visible length of the list.
+   */
+  onStartReachedThreshold?: number | undefined;
+  /**
+   * Called when the viewability of rows changes, as defined by the
+   * `viewabilityConfig` prop.
+   */
+  onViewableItemsChanged?: ((info: {
+    viewableItems: Array<ViewToken>;
+    changed: Array<ViewToken>;
+  }) => void) | undefined;
+  persistentScrollbar?: boolean | undefined;
+  /**
+   * Set this when offset is needed for the loading indicator to show correctly.
+   */
+  progressViewOffset?: number;
+  /**
+   * A custom refresh control element. When set, it overrides the default
+   * <RefreshControl> component built internally. The onRefresh and refreshing
+   * props are also ignored. Only works for vertical VirtualizedList.
+   */
+  refreshControl?: React.JSX.Element | undefined;
+  /**
+   * Set this true while waiting for new data from a refresh.
+   */
+  refreshing?: boolean | undefined;
+  /**
+   * Note: may have bugs (missing content) in some circumstances - use at your own risk.
+   *
+   * This may improve scroll performance for large lists.
+   */
+  removeClippedSubviews?: boolean;
+  /**
+   * Render a custom scroll component, e.g. with a differently styled `RefreshControl`.
+   */
+  renderScrollComponent?: (props: ScrollViewProps) => React.JSX.Element;
+  /**
+   * Amount of time between low-pri item render batches, e.g. for rendering items quite a ways off
+   * screen. Similar fill rate/responsiveness tradeoff as `maxToRenderPerBatch`.
+   */
+  updateCellsBatchingPeriod?: number | undefined;
+  /**
+   * See `ViewabilityHelper` for flow type and further documentation.
+   */
+  viewabilityConfig?: ViewabilityConfig;
+  /**
+   * List of ViewabilityConfig/onViewableItemsChanged pairs. A specific onViewableItemsChanged
+   * will be called when its corresponding ViewabilityConfig's conditions are met.
+   */
+  viewabilityConfigCallbackPairs?: Array<ViewabilityConfigCallbackPair>;
+  /**
+   * Determines the maximum number of items rendered outside of the visible area, in units of
+   * visible lengths. So if your list fills the screen, then `windowSize={21}` (the default) will
+   * render the visible screen area plus up to 10 screens above and 10 below the viewport. Reducing
+   * this number will reduce memory consumption and may improve performance, but will increase the
+   * chance that fast scrolling may reveal momentary blank areas of unrendered content.
+   */
+  windowSize?: number | undefined;
+};
+export type VirtualizedListProps = Omit<ScrollViewProps, keyof RequiredVirtualizedListProps | keyof OptionalVirtualizedListProps | keyof {}> & Omit<RequiredVirtualizedListProps, keyof OptionalVirtualizedListProps | keyof {}> & Omit<OptionalVirtualizedListProps, keyof {}> & {};
+/**
+ * Default Props Helper Functions
+ * Use the following helper functions for default values
+ */
+
+export declare function horizontalOrDefault(horizontal: null | undefined | boolean): boolean;
+export declare function initialNumToRenderOrDefault(initialNumToRender: null | undefined | number): number;
+export declare function maxToRenderPerBatchOrDefault(maxToRenderPerBatch: null | undefined | number): number;
+export declare function onStartReachedThresholdOrDefault(onStartReachedThreshold: null | undefined | number): number;
+export declare function onEndReachedThresholdOrDefault(onEndReachedThreshold: null | undefined | number): number;
+export declare function windowSizeOrDefault(windowSize: null | undefined | number): number;

package/types_generated/Lists/VirtualizedSectionList.d.ts

@@ -0,0 +1,113 @@
+/**
+ * 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.
+ *
+ * @generated SignedSource<<ecb7038cddedf7d6444387409ad985d5>>
+ *
+ * This file was translated from Flow by scripts/build-types/index.js.
+ * Original file: packages/virtualized-lists/Lists/VirtualizedSectionList.js
+ */
+
+import type { VirtualizedListProps } from "./VirtualizedListProps";
+import VirtualizedList from "./VirtualizedList";
+import * as React from "react";
+type DefaultVirtualizedSectionT = {
+  data: any;
+  [key: string]: any;
+};
+export type SectionData<SectionItemT, SectionT = DefaultVirtualizedSectionT> = (Readonly<SectionBase<SectionItemT, SectionT>> & SectionT) | (SectionBase<SectionItemT, SectionT> & SectionT) | SectionT;
+export type SectionBase<SectionItemT, SectionT = DefaultVirtualizedSectionT> = {
+  /**
+   * The data for rendering items in this section.
+   */
+  data: ReadonlyArray<SectionItemT>;
+  /**
+   * Optional key to keep track of section re-ordering. If you don't plan on re-ordering sections,
+   * the array index will be used by default.
+   */
+  key?: string;
+  renderItem?: ((info: {
+    item: SectionItemT;
+    index: number;
+    section: SectionData<SectionItemT, SectionT>;
+    separators: {
+      highlight: () => void;
+      unhighlight: () => void;
+      updateProps: (select: "leading" | "trailing", newProps: Object) => void;
+    };
+  }) => null | React.JSX.Element) | undefined;
+  ItemSeparatorComponent?: React.ComponentType<any> | undefined;
+  keyExtractor?: (item: SectionItemT | undefined, index?: number | undefined) => string;
+};
+type RequiredVirtualizedSectionListProps<ItemT, SectionT = DefaultVirtualizedSectionT> = {
+  sections: ReadonlyArray<SectionData<ItemT, SectionT>>;
+};
+type OptionalVirtualizedSectionListProps<ItemT, SectionT = DefaultVirtualizedSectionT> = {
+  /**
+   * Default renderer for every item in every section.
+   */
+  renderItem?: (info: {
+    item: ItemT;
+    index: number;
+    section: SectionT;
+    separators: {
+      highlight: () => void;
+      unhighlight: () => void;
+      updateProps: (select: "leading" | "trailing", newProps: Object) => void;
+    };
+  }) => null | React.ReactNode;
+  /**
+   * Rendered at the top of each section. These stick to the top of the `ScrollView` by default on
+   * iOS. See `stickySectionHeadersEnabled`.
+   */
+  renderSectionHeader?: ((info: {
+    section: SectionT;
+  }) => null | React.ReactNode) | undefined;
+  /**
+   * Rendered at the bottom of each section.
+   */
+  renderSectionFooter?: ((info: {
+    section: SectionT;
+  }) => null | React.ReactNode) | undefined;
+  /**
+   * Rendered at the top and bottom of each section (note this is different from
+   * `ItemSeparatorComponent` which is only rendered between items). These are intended to separate
+   * sections from the headers above and below and typically have the same highlight response as
+   * `ItemSeparatorComponent`. Also receives `highlighted`, `[leading/trailing][Item/Separator]`,
+   * and any custom props from `separators.updateProps`.
+   */
+  SectionSeparatorComponent?: React.ComponentType<any> | undefined;
+  /**
+   * Makes section headers stick to the top of the screen until the next one pushes it off. Only
+   * enabled by default on iOS because that is the platform standard there.
+   */
+  stickySectionHeadersEnabled?: boolean;
+  onEndReached?: (($$PARAM_0$$: {
+    distanceFromEnd: number;
+  }) => void) | undefined;
+};
+export type VirtualizedSectionListProps<ItemT, SectionT = DefaultVirtualizedSectionT> = Omit<RequiredVirtualizedSectionListProps<ItemT, SectionT>, keyof OptionalVirtualizedSectionListProps<ItemT, SectionT> | keyof Omit<VirtualizedListProps, "data" | "renderItem"> | keyof {}> & Omit<OptionalVirtualizedSectionListProps<ItemT, SectionT>, keyof Omit<VirtualizedListProps, "data" | "renderItem"> | keyof {}> & Omit<Omit<VirtualizedListProps, "data" | "renderItem">, keyof {}> & {};
+export type ScrollToLocationParamsType = {
+  animated?: boolean | undefined;
+  itemIndex: number;
+  sectionIndex: number;
+  viewOffset?: number;
+  viewPosition?: number;
+};
+declare const VirtualizedSectionListComponent: <ItemT, SectionT extends SectionBase<ItemT, DefaultVirtualizedSectionT> = DefaultVirtualizedSectionT>(props: Omit<VirtualizedSectionListProps<ItemT, SectionT>, keyof {
+  ref: React.Ref<{
+    getListRef(): VirtualizedList | undefined;
+    scrollToLocation(params: ScrollToLocationParamsType): void;
+  }>;
+}> & {
+  ref: React.Ref<{
+    getListRef(): VirtualizedList | undefined;
+    scrollToLocation(params: ScrollToLocationParamsType): void;
+  }>;
+}) => React.ReactNode;
+declare const $$VirtualizedSectionList: typeof VirtualizedSectionListComponent;
+declare type $$VirtualizedSectionList = typeof $$VirtualizedSectionList;
+export default $$VirtualizedSectionList;
+export type AnyVirtualizedSectionList = typeof VirtualizedSectionListComponent;

package/types_generated/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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.
+ *
+ * @generated SignedSource<<7cfaaf81455a1bf0b07801c4ebd5200c>>
+ *
+ * This file was translated from Flow by scripts/build-types/index.js.
+ * Original file: packages/virtualized-lists/index.js
+ */
+
+import type $$IMPORT_TYPEOF_1$$ from "./Lists/FillRateHelper";
+type FillRateHelperT = typeof $$IMPORT_TYPEOF_1$$;
+import type $$IMPORT_TYPEOF_2$$ from "./Lists/ViewabilityHelper";
+type ViewabilityHelperT = typeof $$IMPORT_TYPEOF_2$$;
+import type $$IMPORT_TYPEOF_3$$ from "./Lists/VirtualizedList";
+type VirtualizedListT = typeof $$IMPORT_TYPEOF_3$$;
+import type { AnyVirtualizedSectionList as AnyVirtualizedSectionListT } from "./Lists/VirtualizedSectionList";
+import { type VirtualizedListContextResetter as $$IMPORT_TYPEOF_4$$ } from "./Lists/VirtualizedListContext";
+type VirtualizedListContextResetterT = typeof $$IMPORT_TYPEOF_4$$;
+import { keyExtractor } from "./Lists/VirtualizeUtils";
+export type { ViewToken, ViewabilityConfig, ViewabilityConfigCallbackPair, ViewabilityConfigCallbackPairs } from "./Lists/ViewabilityHelper";
+export type { CellRendererProps, ListRenderItemInfo, ListRenderItem, Separators, VirtualizedListProps } from "./Lists/VirtualizedListProps";
+export type { VirtualizedSectionListProps, ScrollToLocationParamsType, SectionBase, SectionData } from "./Lists/VirtualizedSectionList";
+export type { FillRateInfo } from "./Lists/FillRateHelper";
+declare const $$index: {
+  keyExtractor: typeof keyExtractor;
+  get VirtualizedList(): VirtualizedListT;
+  get VirtualizedSectionList(): AnyVirtualizedSectionListT;
+  get VirtualizedListContextResetter(): VirtualizedListContextResetterT;
+  get ViewabilityHelper(): ViewabilityHelperT;
+  get FillRateHelper(): FillRateHelperT;
+};
+declare type $$index = typeof $$index;
+export default $$index;