@fluentui/react-virtualizer 9.0.0-alpha.22 → 9.0.0-alpha.24

package/CHANGELOG.json

@@ -2,7 +2,67 @@
   "name": "@fluentui/react-virtualizer",
   "entries": [
     {
-      "date": "Wed, 31 May 2023 06:43:06 GMT",
+      "date": "Mon, 26 Jun 2023 09:51:06 GMT",
+      "tag": "@fluentui/react-virtualizer_v9.0.0-alpha.24",
+      "version": "9.0.0-alpha.24",
+      "comments": {
+        "prerelease": [
+          {
+            "author": "beachball",
+            "package": "@fluentui/react-virtualizer",
+            "comment": "Bump @fluentui/react-jsx-runtime to v9.0.0-alpha.8",
+            "commit": "025ea2c9c6fb2184e67505081a7a307e95c6c009"
+          },
+          {
+            "author": "beachball",
+            "package": "@fluentui/react-virtualizer",
+            "comment": "Bump @fluentui/react-utilities to v9.9.4",
+            "commit": "025ea2c9c6fb2184e67505081a7a307e95c6c009"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Tue, 20 Jun 2023 12:39:06 GMT",
+      "tag": "@fluentui/react-virtualizer_v9.0.0-alpha.23",
+      "version": "9.0.0-alpha.23",
+      "comments": {
+        "prerelease": [
+          {
+            "author": "mifraser@microsoft.com",
+            "package": "@fluentui/react-virtualizer",
+            "commit": "ab901891c51f8bd5d1a5099e66011c9c84372566",
+            "comment": "feature: Add scrollTo index hook and callbacks, isScrolling flag"
+          },
+          {
+            "author": "martinhochel@microsoft.com",
+            "package": "@fluentui/react-virtualizer",
+            "commit": "cf6b94ba6559236150bc1f1814b023607edaeb20",
+            "comment": "chore: migrate to ts 4.7 which wont emit undefined anymore for optional arguments"
+          },
+          {
+            "author": "beachball",
+            "package": "@fluentui/react-virtualizer",
+            "comment": "Bump @fluentui/react-jsx-runtime to v9.0.0-alpha.7",
+            "commit": "81c9b35e0830297b2aca2cece2ae67b3899c4647"
+          },
+          {
+            "author": "beachball",
+            "package": "@fluentui/react-virtualizer",
+            "comment": "Bump @fluentui/react-utilities to v9.9.3",
+            "commit": "81c9b35e0830297b2aca2cece2ae67b3899c4647"
+          },
+          {
+            "author": "beachball",
+            "package": "@fluentui/react-virtualizer",
+            "comment": "Bump @fluentui/react-conformance-griffel to v9.0.0-beta.23",
+            "commit": "81c9b35e0830297b2aca2cece2ae67b3899c4647"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Wed, 31 May 2023 06:46:23 GMT",
       "tag": "@fluentui/react-virtualizer_v9.0.0-alpha.22",
       "version": "9.0.0-alpha.22",
       "comments": {

package/CHANGELOG.md

@@ -1,12 +1,35 @@
 # Change Log - @fluentui/react-virtualizer
 
-This log was last generated on Wed, 31 May 2023 06:43:06 GMT and should not be manually modified.
+This log was last generated on Mon, 26 Jun 2023 09:51:06 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## [9.0.0-alpha.24](https://github.com/microsoft/fluentui/tree/@fluentui/react-virtualizer_v9.0.0-alpha.24)
+
+Mon, 26 Jun 2023 09:51:06 GMT 
+[Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-virtualizer_v9.0.0-alpha.23..@fluentui/react-virtualizer_v9.0.0-alpha.24)
+
+### Changes
+
+- Bump @fluentui/react-jsx-runtime to v9.0.0-alpha.8 ([PR #28307](https://github.com/microsoft/fluentui/pull/28307) by beachball)
+- Bump @fluentui/react-utilities to v9.9.4 ([PR #28307](https://github.com/microsoft/fluentui/pull/28307) by beachball)
+
+## [9.0.0-alpha.23](https://github.com/microsoft/fluentui/tree/@fluentui/react-virtualizer_v9.0.0-alpha.23)
+
+Tue, 20 Jun 2023 12:39:06 GMT 
+[Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-virtualizer_v9.0.0-alpha.22..@fluentui/react-virtualizer_v9.0.0-alpha.23)
+
+### Changes
+
+- feature: Add scrollTo index hook and callbacks, isScrolling flag ([PR #27864](https://github.com/microsoft/fluentui/pull/27864) by mifraser@microsoft.com)
+- chore: migrate to ts 4.7 which wont emit undefined anymore for optional arguments ([PR #28067](https://github.com/microsoft/fluentui/pull/28067) by martinhochel@microsoft.com)
+- Bump @fluentui/react-jsx-runtime to v9.0.0-alpha.7 ([PR #28229](https://github.com/microsoft/fluentui/pull/28229) by beachball)
+- Bump @fluentui/react-utilities to v9.9.3 ([PR #28229](https://github.com/microsoft/fluentui/pull/28229) by beachball)
+- Bump @fluentui/react-conformance-griffel to v9.0.0-beta.23 ([PR #28229](https://github.com/microsoft/fluentui/pull/28229) by beachball)
+
 ## [9.0.0-alpha.22](https://github.com/microsoft/fluentui/tree/@fluentui/react-virtualizer_v9.0.0-alpha.22)
 
-Wed, 31 May 2023 06:43:06 GMT 
+Wed, 31 May 2023 06:46:23 GMT 
 [Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-virtualizer_v9.0.0-alpha.21..@fluentui/react-virtualizer_v9.0.0-alpha.22)
 
 ### Changes

package/dist/index.d.ts

@@ -1,11 +1,12 @@
-import { ComponentProps } from '@fluentui/react-utilities';
-import { ComponentState } from '@fluentui/react-utilities';
+import type { ComponentProps } from '@fluentui/react-utilities';
+import type { ComponentState } from '@fluentui/react-utilities';
 import type { Dispatch } from 'react';
 import type { FC } from 'react';
 import { MutableRefObject } from 'react';
 import * as React_2 from 'react';
+import type { RefObject } from 'react';
 import type { SetStateAction } from 'react';
-import { Slot } from '@fluentui/react-utilities';
+import type { Slot } from '@fluentui/react-utilities';
 import type { SlotClassNames } from '@fluentui/react-utilities';
 
 export declare const renderVirtualizer_unstable: (state: VirtualizerState) => JSX.Element;
@@ -22,6 +23,34 @@ export declare interface ResizeCallbackWithRef {
     (entries: ResizeObserverEntry[], observer: ResizeObserver, scrollRef?: MutableRefObject<HTMLElement | null>): void;
 }
 
+export declare type ScrollToInterface = {
+    scrollTo: (index: number, behavior?: ScrollBehavior, callback?: (index: number) => void) => void;
+};
+
+export declare const scrollToItemDynamic: (params: ScrollToItemDynamicParams) => void;
+
+export declare type ScrollToItemDynamicParams = {
+    index: number;
+    itemSizes: RefObject<number[]>;
+    totalSize: number;
+    scrollViewRef: RefObject<HTMLDivElement>;
+    axis?: 'horizontal' | 'vertical';
+    reversed?: boolean;
+    behavior?: ScrollBehavior;
+};
+
+export declare const scrollToItemStatic: (params: ScrollToItemStaticParams) => void;
+
+export declare type ScrollToItemStaticParams = {
+    index: number;
+    itemSize: number;
+    totalItems: number;
+    scrollViewRef: RefObject<HTMLDivElement>;
+    axis?: 'horizontal' | 'vertical';
+    reversed?: boolean;
+    behavior?: ScrollBehavior;
+};
+
 /**
  * React hook that measures virtualized space dynamically to ensure optimized virtualization length.
  */
@@ -41,7 +70,7 @@ export declare const useDynamicVirtualizerMeasure: <TElement extends HTMLElement
  * @returns An array containing a callback to update the list of Elements the observer should listen to, a callback to
  * update the init options of the IntersectionObserver and a ref to the IntersectionObserver instance itself.
  */
-export declare const useIntersectionObserver: (callback: IntersectionObserverCallback, options?: IntersectionObserverInit | undefined) => {
+export declare const useIntersectionObserver: (callback: IntersectionObserverCallback, options?: IntersectionObserverInit) => {
     setObserverList: Dispatch<SetStateAction<Element[] | undefined>>;
     setObserverInit: Dispatch<SetStateAction<IntersectionObserverInit | undefined>>;
     observer: MutableRefObject<IntersectionObserver | undefined>;
@@ -92,7 +121,7 @@ export declare const useVirtualizerStyles_unstable: (state: VirtualizerState) =>
  */
 export declare const Virtualizer: FC<VirtualizerProps>;
 
-export declare type VirtualizerChildRenderFunction = (index: number) => React_2.ReactNode;
+export declare type VirtualizerChildRenderFunction = (index: number, isScrolling: boolean) => React_2.ReactNode;
 
 export declare const virtualizerClassNames: SlotClassNames<VirtualizerSlots>;
 
@@ -161,6 +190,15 @@ declare type VirtualizerConfigProps = {
      * Virtualizer context can be passed as a prop for extended class use
      */
     virtualizerContext?: VirtualizerContextProps;
+    /**
+     * Callback for notifying when a flagged index has been rendered
+     */
+    onRenderedFlaggedIndex?: (index: number) => void;
+    flaggedIndex?: MutableRefObject<number | null>;
+    /**
+     * Imperative ref contains our scrollTo index functionality for user control.
+     */
+    imperativeVirtualizerRef?: RefObject<VirtualizerDataRef>;
 };
 
 declare type VirtualizerConfigState = {
@@ -210,6 +248,12 @@ export declare type VirtualizerContextProps = {
 
 export declare const VirtualizerContextProvider: React_2.Provider<VirtualizerContextProps>;
 
+export declare type VirtualizerDataRef = {
+    progressiveSizes: RefObject<number[]>;
+    nodeSizes: RefObject<number[]>;
+    setFlaggedIndex: (index: number | null) => void;
+};
+
 export declare type VirtualizerMeasureDynamicProps = {
     defaultItemSize: number;
     currentIndex: number;
@@ -239,7 +283,7 @@ export declare const VirtualizerScrollViewDynamic: React_2.FC<VirtualizerScrollV
 
 export declare const virtualizerScrollViewDynamicClassNames: SlotClassNames<VirtualizerScrollViewDynamicSlots>;
 
-export declare type VirtualizerScrollViewDynamicProps = ComponentProps<Partial<VirtualizerScrollViewDynamicSlots>> & Partial<Omit<VirtualizerConfigProps, 'itemSize' | 'numItems' | 'getItemSize' | 'children'>> & {
+export declare type VirtualizerScrollViewDynamicProps = ComponentProps<Partial<VirtualizerScrollViewDynamicSlots>> & Partial<Omit<VirtualizerConfigProps, 'itemSize' | 'numItems' | 'getItemSize' | 'children' | 'flagIndex'>> & {
     /**
      * Set as the minimum item size.
      * Axis: 'vertical' = Height
@@ -261,13 +305,17 @@ export declare type VirtualizerScrollViewDynamicProps = ComponentProps<Partial<V
      * Will act as a row or column indexer depending on Virtualizer settings.
      */
     children: VirtualizerChildRenderFunction;
+    /**
+     * Imperative ref contains our scrollTo index functionality for user control.
+     */
+    imperativeRef?: RefObject<ScrollToInterface>;
 };
 
 export declare type VirtualizerScrollViewDynamicSlots = VirtualizerScrollViewSlots;
 
 export declare type VirtualizerScrollViewDynamicState = ComponentState<VirtualizerScrollViewDynamicSlots> & VirtualizerConfigState;
 
-export declare type VirtualizerScrollViewProps = ComponentProps<Partial<VirtualizerScrollViewSlots>> & Partial<Omit<VirtualizerConfigProps, 'itemSize' | 'numItems' | 'getItemSize' | 'children'>> & {
+export declare type VirtualizerScrollViewProps = ComponentProps<Partial<VirtualizerScrollViewSlots>> & Partial<Omit<VirtualizerConfigProps, 'itemSize' | 'numItems' | 'getItemSize' | 'children' | 'flagIndex' | 'imperativeVirtualizerRef'>> & {
     /**
      * Virtualizer item size in pixels - static.
      * Axis: 'vertical' = Height
@@ -284,6 +332,10 @@ export declare type VirtualizerScrollViewProps = ComponentProps<Partial<Virtuali
      * Will act as a row or column indexer depending on Virtualizer settings.
      */
     children: VirtualizerChildRenderFunction;
+    /**
+     * Imperative ref contains our scrollTo index functionality for user control.
+     */
+    imperativeRef?: RefObject<ScrollToInterface>;
 };
 
 export declare type VirtualizerScrollViewSlots = VirtualizerSlots & {

package/lib/components/Virtualizer/Virtualizer.types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["Virtualizer.types.ts"],"sourcesContent":["import * as React from 'react';\nimport type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\nimport { VirtualizerContextProps } from '../../Utilities';\n\nexport type VirtualizerSlots = {\n  /**\n   * The intersection observed 'before' element will detect when scrolling towards the beginning.\n   */\n  before: NonNullable<Slot<'div', 'td'>>;\n  /**\n   * A block place holding whitespace at the beginning of current DOM children.\n   */\n  beforeContainer: NonNullable<Slot<'div', 'tr'>>;\n  /**\n   * The intersection observed 'after' element will detect when scrolling towards the end.\n   */\n  after: NonNullable<Slot<'div', 'td'>>;\n  /**\n   * A block place holding whitespace after the end of current DOM children.\n   */\n  afterContainer: NonNullable<Slot<'div', 'tr'>>;\n};\n\nexport type VirtualizerConfigState = {\n  /**\n   * The current virtualized array of children to show in the DOM.\n   */\n  virtualizedChildren: React.ReactNode[];\n  /**\n   * The current start index for the virtualizer, all previous index's will be removed from DOM.\n   */\n  virtualizerStartIndex: number;\n  /**\n   * Current buffer height required at beginning of array.\n   */\n  afterBufferHeight: number;\n  /**\n   * Current buffer height required at end of array.\n   */\n  beforeBufferHeight: number;\n  /**\n   * The total current height of the scrollView/child content.\n   */\n  totalVirtualizerHeight: number;\n  /**\n   * The scroll direction\n   * @default vertical\n   */\n  axis?: 'vertical' | 'horizontal';\n  /**\n   * Tells the virtualizer to measure in the reverse direction (for column-reverse order etc.)\n   */\n  reversed?: boolean;\n  /**\n   * Pixel size of intersection observers and how much they 'cross over' into the bufferItems index.\n   * Minimum 1px.\n   */\n  bufferSize: number;\n};\n\nexport type VirtualizerState = ComponentState<VirtualizerSlots> & VirtualizerConfigState;\n\n// Virtualizer render function to procedurally generate children elements as rows or columns via index.\n// Q: Use generic typing and passing through object data or a simple index system?\nexport type VirtualizerChildRenderFunction = (index: number) => React.ReactNode;\n\nexport type VirtualizerConfigProps = {\n  /**\n   * Child render function.\n   * Iteratively called to return current virtualizer DOM children.\n   * Will act as a row or column indexer depending on Virtualizer settings.\n   * Can be used dynamically.\n   */\n  children: VirtualizerChildRenderFunction;\n\n  /**\n   * Default cell size to use if no custom callback provided.\n   * If implementing `getItemSize` this should be the initial and ideally minimum cell size.\n   */\n  itemSize: number;\n\n  /**\n   * The total number of items to be virtualized.\n   */\n  numItems: number;\n\n  /**\n   * Number of children to render in the DOM during virtualization.\n   * Constraints:\n   * - Large enough that the items rendered in DOM cover the viewport\n   *   and intersection observer buffers (buffersize) at both ends.\n   */\n  virtualizerLength: number;\n\n  /**\n   * Defaults to 1/4th of virtualizerLength.\n   * Controls the number of elements rendered before the current index entering the virtualized viewport.\n   * Constraints:\n   * - Large enough to cover bufferSize (prevents buffers intersecting into the viewport during rest state).\n   * - Small enough that the end buffer and end index (start index + virtualizerLength) is not within viewport at rest.\n   */\n  bufferItems?: number;\n\n  /**\n   * Defaults to half of bufferItems size (in pixels).\n   * The length (in pixels) before the end/start DOM index where the virtualizer recalculation will be triggered.\n   * Increasing this reduces whitespace on ultra-fast scroll, as additional elements\n   * are buffered to appear while virtualization recalculates.\n   * Constraints:\n   * - At least 1px - although this will only trigger the recalculation after bookends (whitespace) enter viewport.\n   * - BufferSize must be smaller than bufferItems pixel size, as it prevents bookends entering viewport at rest.\n   */\n  bufferSize?: number;\n\n  /**\n   * Enables users to override the intersectionObserverRoot.\n   */\n  scrollViewRef?: React.MutableRefObject<HTMLElement | null>;\n\n  /**\n   * The scroll direction\n   * @default vertical\n   */\n  axis?: 'vertical' | 'horizontal';\n\n  /**\n   * Tells the virtualizer to measure in the reverse direction (for column-reverse order etc.)\n   * This value should be flipped in RTL implementation (TBD whether automate RTL).\n   */\n  reversed?: boolean;\n\n  /**\n   * Callback for acquiring size of individual items\n   * @param index - the index of the requested size's child\n   */\n  getItemSize?: (index: number) => number;\n\n  /**\n   * Virtualizer context can be passed as a prop for extended class use\n   */\n  virtualizerContext?: VirtualizerContextProps;\n};\n\nexport type VirtualizerProps = ComponentProps<Partial<VirtualizerSlots>> & VirtualizerConfigProps;\n"],"names":["React"],"mappings":"AAAA,YAAYA,WAAW,QAAQ"}
+{"version":3,"sources":["Virtualizer.types.ts"],"sourcesContent":["import * as React from 'react';\nimport type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\nimport type { VirtualizerContextProps } from '../../Utilities';\nimport type { RefObject, MutableRefObject } from 'react';\n\nexport type VirtualizerSlots = {\n  /**\n   * The intersection observed 'before' element will detect when scrolling towards the beginning.\n   */\n  before: NonNullable<Slot<'div', 'td'>>;\n  /**\n   * A block place holding whitespace at the beginning of current DOM children.\n   */\n  beforeContainer: NonNullable<Slot<'div', 'tr'>>;\n  /**\n   * The intersection observed 'after' element will detect when scrolling towards the end.\n   */\n  after: NonNullable<Slot<'div', 'td'>>;\n  /**\n   * A block place holding whitespace after the end of current DOM children.\n   */\n  afterContainer: NonNullable<Slot<'div', 'tr'>>;\n};\n\nexport type VirtualizerConfigState = {\n  /**\n   * The current virtualized array of children to show in the DOM.\n   */\n  virtualizedChildren: React.ReactNode[];\n  /**\n   * The current start index for the virtualizer, all previous index's will be removed from DOM.\n   */\n  virtualizerStartIndex: number;\n  /**\n   * Current buffer height required at beginning of array.\n   */\n  afterBufferHeight: number;\n  /**\n   * Current buffer height required at end of array.\n   */\n  beforeBufferHeight: number;\n  /**\n   * The total current height of the scrollView/child content.\n   */\n  totalVirtualizerHeight: number;\n  /**\n   * The scroll direction\n   * @default vertical\n   */\n  axis?: 'vertical' | 'horizontal';\n  /**\n   * Tells the virtualizer to measure in the reverse direction (for column-reverse order etc.)\n   */\n  reversed?: boolean;\n  /**\n   * Pixel size of intersection observers and how much they 'cross over' into the bufferItems index.\n   * Minimum 1px.\n   */\n  bufferSize: number;\n};\n\nexport type VirtualizerState = ComponentState<VirtualizerSlots> & VirtualizerConfigState;\n\n// Virtualizer render function to procedurally generate children elements as rows or columns via index.\n// Q: Use generic typing and passing through object data or a simple index system?\nexport type VirtualizerChildRenderFunction = (index: number, isScrolling: boolean) => React.ReactNode;\n\nexport type VirtualizerDataRef = {\n  progressiveSizes: RefObject<number[]>;\n  nodeSizes: RefObject<number[]>;\n  setFlaggedIndex: (index: number | null) => void;\n};\n\nexport type VirtualizerConfigProps = {\n  /**\n   * Child render function.\n   * Iteratively called to return current virtualizer DOM children.\n   * Will act as a row or column indexer depending on Virtualizer settings.\n   * Can be used dynamically.\n   */\n  children: VirtualizerChildRenderFunction;\n\n  /**\n   * Default cell size to use if no custom callback provided.\n   * If implementing `getItemSize` this should be the initial and ideally minimum cell size.\n   */\n  itemSize: number;\n\n  /**\n   * The total number of items to be virtualized.\n   */\n  numItems: number;\n\n  /**\n   * Number of children to render in the DOM during virtualization.\n   * Constraints:\n   * - Large enough that the items rendered in DOM cover the viewport\n   *   and intersection observer buffers (buffersize) at both ends.\n   */\n  virtualizerLength: number;\n\n  /**\n   * Defaults to 1/4th of virtualizerLength.\n   * Controls the number of elements rendered before the current index entering the virtualized viewport.\n   * Constraints:\n   * - Large enough to cover bufferSize (prevents buffers intersecting into the viewport during rest state).\n   * - Small enough that the end buffer and end index (start index + virtualizerLength) is not within viewport at rest.\n   */\n  bufferItems?: number;\n\n  /**\n   * Defaults to half of bufferItems size (in pixels).\n   * The length (in pixels) before the end/start DOM index where the virtualizer recalculation will be triggered.\n   * Increasing this reduces whitespace on ultra-fast scroll, as additional elements\n   * are buffered to appear while virtualization recalculates.\n   * Constraints:\n   * - At least 1px - although this will only trigger the recalculation after bookends (whitespace) enter viewport.\n   * - BufferSize must be smaller than bufferItems pixel size, as it prevents bookends entering viewport at rest.\n   */\n  bufferSize?: number;\n\n  /**\n   * Enables users to override the intersectionObserverRoot.\n   */\n  scrollViewRef?: React.MutableRefObject<HTMLElement | null>;\n\n  /**\n   * The scroll direction\n   * @default vertical\n   */\n  axis?: 'vertical' | 'horizontal';\n\n  /**\n   * Tells the virtualizer to measure in the reverse direction (for column-reverse order etc.)\n   * This value should be flipped in RTL implementation (TBD whether automate RTL).\n   */\n  reversed?: boolean;\n\n  /**\n   * Callback for acquiring size of individual items\n   * @param index - the index of the requested size's child\n   */\n  getItemSize?: (index: number) => number;\n\n  /**\n   * Virtualizer context can be passed as a prop for extended class use\n   */\n  virtualizerContext?: VirtualizerContextProps;\n\n  /**\n   * Callback for notifying when a flagged index has been rendered\n   */\n  onRenderedFlaggedIndex?: (index: number) => void;\n\n  /*\n   * Callback for notifying when a flagged index has been rendered\n   */\n  flaggedIndex?: MutableRefObject<number | null>;\n\n  /**\n   * Imperative ref contains our scrollTo index functionality for user control.\n   */\n  imperativeVirtualizerRef?: RefObject<VirtualizerDataRef>;\n};\n\nexport type VirtualizerProps = ComponentProps<Partial<VirtualizerSlots>> & VirtualizerConfigProps;\n"],"names":["React"],"mappings":"AAAA,YAAYA,WAAW,QAAQ"}

package/lib/components/Virtualizer/renderVirtualizer.js.map

@@ -1 +1 @@
-{"version":3,"sources":["renderVirtualizer.tsx"],"sourcesContent":["/** @jsxRuntime classic */\n/** @jsx createElement */\n\nimport * as React from 'react';\nimport { createElement } from '@fluentui/react-jsx-runtime';\nimport { getSlotsNext } from '@fluentui/react-utilities';\nimport { VirtualizerSlots, VirtualizerState } from './Virtualizer.types';\nimport { ReactNode } from 'react';\n\nexport const renderVirtualizer_unstable = (state: VirtualizerState) => {\n  const { slots, slotProps } = getSlotsNext<VirtualizerSlots>(state);\n\n  return (\n    <React.Fragment>\n      {/* The 'before' bookend to hold items in place and detect scroll previous */}\n      <slots.beforeContainer {...slotProps.beforeContainer}>\n        <slots.before {...slotProps.before} />\n      </slots.beforeContainer>\n      {/* The reduced list of non-virtualized children to be rendered */}\n      {state.virtualizedChildren}\n      {/* The 'after' bookend to hold items in place and detect scroll next */}\n      <slots.afterContainer {...slotProps.afterContainer}>\n        <slots.after {...slotProps.after} />\n      </slots.afterContainer>\n    </React.Fragment>\n  );\n};\n\nexport const renderVirtualizerChildPlaceholder = (child: ReactNode, index: number) => {\n  return (\n    <React.Suspense key={`fui-virtualizer-placeholder-${index}`} fallback={null}>\n      {child}\n    </React.Suspense>\n  );\n};\n"],"names":["React","createElement","getSlotsNext","renderVirtualizer_unstable","state","slots","slotProps","Fragment","beforeContainer","before","virtualizedChildren","afterContainer","after","renderVirtualizerChildPlaceholder","child","index","Suspense","key","fallback"],"mappings":"AAAA,wBAAwB,GACxB,uBAAuB,GAEvB,YAAYA,WAAW,QAAQ;AAC/B,SAASC,aAAa,QAAQ,8BAA8B;AAC5D,SAASC,YAAY,QAAQ,4BAA4B;AAIzD,OAAO,MAAMC,6BAA6B,CAACC,QAA4B;IACrE,MAAM,EAAEC,MAAK,EAAEC,UAAS,EAAE,GAAGJ,aAA+BE;IAE5D,qBACE,AAZJ,cAYKJ,MAAMO,QAAQ,sBAEb,AAdN,cAcOF,MAAMG,eAAe,EAAKF,UAAUE,eAAe,gBAClD,AAfR,cAeSH,MAAMI,MAAM,EAAKH,UAAUG,MAAM,IAGnCL,MAAMM,mBAAmB,gBAE1B,AApBN,cAoBOL,MAAMM,cAAc,EAAKL,UAAUK,cAAc,gBAChD,AArBR,cAqBSN,MAAMO,KAAK,EAAKN,UAAUM,KAAK;AAIxC,EAAE;AAEF,OAAO,MAAMC,oCAAoC,CAACC,OAAkBC,QAAkB;IACpF,qBACE,AA7BJ,cA6BKf,MAAMgB,QAAQ;QAACC,KAAK,CAAC,4BAA4B,EAAEF,MAAM,CAAC;QAAEG,UAAU,IAAI;OACxEJ;AAGP,EAAE"}
+{"version":3,"sources":["renderVirtualizer.tsx"],"sourcesContent":["/** @jsxRuntime classic */\n/** @jsx createElement */\n\nimport * as React from 'react';\nimport type { VirtualizerSlots, VirtualizerState } from './Virtualizer.types';\nimport type { ReactNode } from 'react';\n\nimport { createElement } from '@fluentui/react-jsx-runtime';\nimport { getSlotsNext } from '@fluentui/react-utilities';\n\nexport const renderVirtualizer_unstable = (state: VirtualizerState) => {\n  const { slots, slotProps } = getSlotsNext<VirtualizerSlots>(state);\n\n  return (\n    <React.Fragment>\n      {/* The 'before' bookend to hold items in place and detect scroll previous */}\n      <slots.beforeContainer {...slotProps.beforeContainer}>\n        <slots.before {...slotProps.before} />\n      </slots.beforeContainer>\n      {/* The reduced list of non-virtualized children to be rendered */}\n      {state.virtualizedChildren}\n      {/* The 'after' bookend to hold items in place and detect scroll next */}\n      <slots.afterContainer {...slotProps.afterContainer}>\n        <slots.after {...slotProps.after} />\n      </slots.afterContainer>\n    </React.Fragment>\n  );\n};\n\nexport const renderVirtualizerChildPlaceholder = (child: ReactNode, index: number) => {\n  return (\n    <React.Suspense key={`fui-virtualizer-placeholder-${index}`} fallback={null}>\n      {child}\n    </React.Suspense>\n  );\n};\n"],"names":["React","createElement","getSlotsNext","renderVirtualizer_unstable","state","slots","slotProps","Fragment","beforeContainer","before","virtualizedChildren","afterContainer","after","renderVirtualizerChildPlaceholder","child","index","Suspense","key","fallback"],"mappings":"AAAA,wBAAwB,GACxB,uBAAuB,GAEvB,YAAYA,WAAW,QAAQ;AAI/B,SAASC,aAAa,QAAQ,8BAA8B;AAC5D,SAASC,YAAY,QAAQ,4BAA4B;AAEzD,OAAO,MAAMC,6BAA6B,CAACC,QAA4B;IACrE,MAAM,EAAEC,MAAK,EAAEC,UAAS,EAAE,GAAGJ,aAA+BE;IAE5D,qBACE,AAbJ,cAaKJ,MAAMO,QAAQ,sBAEb,AAfN,cAeOF,MAAMG,eAAe,EAAKF,UAAUE,eAAe,gBAClD,AAhBR,cAgBSH,MAAMI,MAAM,EAAKH,UAAUG,MAAM,IAGnCL,MAAMM,mBAAmB,gBAE1B,AArBN,cAqBOL,MAAMM,cAAc,EAAKL,UAAUK,cAAc,gBAChD,AAtBR,cAsBSN,MAAMO,KAAK,EAAKN,UAAUM,KAAK;AAIxC,EAAE;AAEF,OAAO,MAAMC,oCAAoC,CAACC,OAAkBC,QAAkB;IACpF,qBACE,AA9BJ,cA8BKf,MAAMgB,QAAQ;QAACC,KAAK,CAAC,4BAA4B,EAAEF,MAAM,CAAC;QAAEG,UAAU,IAAI;OACxEJ;AAGP,EAAE"}

package/lib/components/Virtualizer/useVirtualizer.js

@@ -1,12 +1,13 @@
+import { useEffect, useRef, useCallback, useReducer, useImperativeHandle, useState } from 'react';
 import { useIntersectionObserver } from '../../hooks/useIntersectionObserver';
-import { useEffect, useRef, useCallback, useReducer } from 'react';
 import { resolveShorthand } from '@fluentui/react-utilities';
 import { flushSync } from 'react-dom';
 import { useVirtualizerContextState_unstable } from '../../Utilities';
 import { renderVirtualizerChildPlaceholder } from './renderVirtualizer';
 export function useVirtualizer_unstable(props) {
-    const { itemSize , numItems , virtualizerLength , children: renderChild , getItemSize , bufferItems =Math.round(virtualizerLength / 4.0) , bufferSize =Math.floor(bufferItems / 2.0) * itemSize , scrollViewRef , axis ='vertical' , reversed =false , virtualizerContext  } = props;
+    const { itemSize , numItems , virtualizerLength , children: renderChild , getItemSize , bufferItems =Math.round(virtualizerLength / 4.0) , bufferSize =Math.floor(bufferItems / 2.0) * itemSize , scrollViewRef , axis ='vertical' , reversed =false , virtualizerContext , onRenderedFlaggedIndex , imperativeVirtualizerRef  } = props;
     /* The context is optional, it's useful for injecting additional index logic, or performing uniform state updates*/ const _virtualizerContext = useVirtualizerContextState_unstable(virtualizerContext);
+    const flaggedIndex = useRef(null);
     const actualIndex = _virtualizerContext.contextIndex;
     const setActualIndex = _virtualizerContext.setContextIndex;
     // Store ref to before padding element
@@ -42,6 +43,34 @@ export function useVirtualizer_unstable(props) {
             }
         }
     };
+    const [isScrolling, setIsScrolling] = useState(false);
+    const scrollTimer = useRef();
+    const scrollCounter = useRef(0);
+    const initializeScrollingTimer = ()=>{
+        /*
+     * This can be considered the 'velocity' required to start 'isScrolling'
+     * INIT_SCROLL_FLAG_REQ: Number of renders required to activate isScrolling
+     * INIT_SCROLL_FLAG_DELAY: Amount of time (ms) before current number of renders is reset
+     *  - Maybe we should let users customize these in the future.
+     */ const INIT_SCROLL_FLAG_REQ = 10;
+        const INIT_SCROLL_FLAG_DELAY = 100;
+        scrollCounter.current++;
+        if (scrollCounter.current >= INIT_SCROLL_FLAG_REQ) {
+            setIsScrolling(true);
+        }
+        if (scrollTimer.current) {
+            clearTimeout(scrollTimer.current);
+        }
+        scrollTimer.current = setTimeout(()=>{
+            setIsScrolling(false);
+            scrollCounter.current = 0;
+        }, INIT_SCROLL_FLAG_DELAY);
+    };
+    useEffect(()=>{
+        initializeScrollingTimer();
+    }, [
+        actualIndex
+    ]);
     const batchUpdateNewIndex = (index)=>{
         // Local updates
         updateChildRows(index);
@@ -166,14 +195,18 @@ export function useVirtualizer_unstable(props) {
         }
         return getIndexFromSizeArray(scrollPos);
     };
-    const calculateTotalSize = ()=>{
+    const calculateTotalSize = useCallback(()=>{
         if (!getItemSize) {
             return itemSize * numItems;
         }
         // Time for custom size calcs
         return childProgressiveSizes.current[numItems - 1];
-    };
-    const calculateBefore = ()=>{
+    }, [
+        getItemSize,
+        itemSize,
+        numItems
+    ]);
+    const calculateBefore = useCallback(()=>{
         const currentIndex = Math.min(actualIndex, numItems);
         if (!getItemSize) {
             // The missing items from before virtualization starts height
@@ -184,8 +217,13 @@ export function useVirtualizer_unstable(props) {
         }
         // Time for custom size calcs
         return childProgressiveSizes.current[currentIndex - 1];
-    };
-    const calculateAfter = ()=>{
+    }, [
+        actualIndex,
+        getItemSize,
+        itemSize,
+        numItems
+    ]);
+    const calculateAfter = useCallback(()=>{
         if (numItems === 0) {
             return 0;
         }
@@ -197,20 +235,28 @@ export function useVirtualizer_unstable(props) {
         }
         // Time for custom size calcs
         return childProgressiveSizes.current[numItems - 1] - childProgressiveSizes.current[lastItemIndex];
-    };
+    }, [
+        actualIndex,
+        getItemSize,
+        itemSize,
+        numItems,
+        virtualizerLength
+    ]);
     const updateChildRows = useCallback((newIndex)=>{
         if (numItems === 0) {
-            /* Nothing to virtualize */ return [];
-        }
-        if (childArray.current.length !== numItems) {
-            childArray.current = new Array(virtualizerLength);
+            /* Nothing to virtualize */ return;
         }
+        /*
+        We reset the array every time to ensure children are re-rendered
+        This function should only be called when update is nessecary
+       */ childArray.current = new Array(virtualizerLength);
         const _actualIndex = Math.max(newIndex, 0);
         const end = Math.min(_actualIndex + virtualizerLength, numItems);
         for(let i = _actualIndex; i < end; i++){
-            childArray.current[i - _actualIndex] = renderVirtualizerChildPlaceholder(renderChild(i), i);
+            childArray.current[i - _actualIndex] = renderVirtualizerChildPlaceholder(renderChild(i, isScrolling), i);
         }
     }, [
+        isScrolling,
         numItems,
         renderChild,
         virtualizerLength
@@ -278,6 +324,16 @@ export function useVirtualizer_unstable(props) {
             populateSizeArrays();
         }
     };
+    useImperativeHandle(imperativeVirtualizerRef, ()=>{
+        return {
+            progressiveSizes: childProgressiveSizes,
+            nodeSizes: childSizes,
+            setFlaggedIndex: (index)=>flaggedIndex.current = index
+        };
+    }, [
+        childProgressiveSizes,
+        childSizes
+    ]);
     // Initialization on mount - update array index to 0 (ready state).
     // Only fire on mount (no deps).
     useEffect(()=>{
@@ -305,6 +361,20 @@ export function useVirtualizer_unstable(props) {
     }, [
         getItemSize
     ]);
+    // Effect to check flag index on updates
+    useEffect(()=>{
+        if (!onRenderedFlaggedIndex || flaggedIndex.current === null) {
+            return;
+        }
+        if (actualIndex <= flaggedIndex.current && actualIndex + virtualizerLength >= flaggedIndex.current) {
+            onRenderedFlaggedIndex(flaggedIndex.current);
+            flaggedIndex.current = null;
+        }
+    }, [
+        actualIndex,
+        onRenderedFlaggedIndex,
+        virtualizerLength
+    ]);
     // Ensure we have run through and updated the whole size list array at least once.
     initializeSizeArray();
     if (getItemSize && (numItems !== childSizes.current.length || numItems !== childProgressiveSizes.current.length)) {

package/lib/components/Virtualizer/useVirtualizer.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useVirtualizer.ts"],"sourcesContent":["import { useIntersectionObserver } from '../../hooks/useIntersectionObserver';\nimport type { ReactNode } from 'react';\nimport { useEffect, useRef, useCallback, useReducer } from 'react';\n\nimport type { VirtualizerProps, VirtualizerState } from './Virtualizer.types';\nimport { resolveShorthand } from '@fluentui/react-utilities';\nimport { flushSync } from 'react-dom';\n\nimport { useVirtualizerContextState_unstable } from '../../Utilities';\nimport { renderVirtualizerChildPlaceholder } from './renderVirtualizer';\n\nexport function useVirtualizer_unstable(props: VirtualizerProps): VirtualizerState {\n  const {\n    itemSize,\n    numItems,\n    virtualizerLength,\n    children: renderChild,\n    getItemSize,\n    bufferItems = Math.round(virtualizerLength / 4.0),\n    bufferSize = Math.floor(bufferItems / 2.0) * itemSize,\n    scrollViewRef,\n    axis = 'vertical',\n    reversed = false,\n    virtualizerContext,\n  } = props;\n\n  /* The context is optional, it's useful for injecting additional index logic, or performing uniform state updates*/\n  const _virtualizerContext = useVirtualizerContextState_unstable(virtualizerContext);\n\n  const actualIndex = _virtualizerContext.contextIndex;\n  const setActualIndex = _virtualizerContext.setContextIndex;\n\n  // Store ref to before padding element\n  const beforeElementRef = useRef<Element | null>(null);\n\n  // Store ref to before padding element\n  const afterElementRef = useRef<Element | null>(null);\n\n  // We need to store an array to track dynamic sizes, we can use this to incrementally update changes\n  const childSizes = useRef<number[]>(new Array<number>(getItemSize ? numItems : 0));\n\n  /* We keep track of the progressive sizing/placement down the list,\n  this helps us skip re-calculations unless children/size changes */\n  const childProgressiveSizes = useRef<number[]>(new Array<number>(getItemSize ? numItems : 0));\n\n  // The internal tracking REF for child array (updates often).\n  const childArray = useRef<ReactNode[]>(new Array(virtualizerLength));\n\n  // We want to be methodical about updating the render with child reference array\n  const forceUpdate = useReducer(() => ({}), {})[1];\n\n  const horizontal = axis === 'horizontal';\n\n  const populateSizeArrays = () => {\n    if (!getItemSize) {\n      // Static sizes, never mind!\n      return;\n    }\n\n    if (numItems !== childSizes.current.length) {\n      childSizes.current = new Array<number>(numItems);\n    }\n\n    if (numItems !== childProgressiveSizes.current.length) {\n      childProgressiveSizes.current = new Array<number>(numItems);\n    }\n\n    for (let index = 0; index < numItems; index++) {\n      childSizes.current[index] = getItemSize(index);\n      if (index === 0) {\n        childProgressiveSizes.current[index] = childSizes.current[index];\n      } else {\n        childProgressiveSizes.current[index] = childProgressiveSizes.current[index - 1] + childSizes.current[index];\n      }\n    }\n  };\n\n  const batchUpdateNewIndex = (index: number) => {\n    // Local updates\n    updateChildRows(index);\n    updateCurrentItemSizes(index);\n\n    // State setters\n    setActualIndex(index);\n  };\n\n  // Observe intersections of virtualized components\n  const { setObserverList } = useIntersectionObserver(\n    (entries: IntersectionObserverEntry[], observer: IntersectionObserver) => {\n      /* Sanity check - do we even need virtualization? */\n      if (virtualizerLength > numItems) {\n        if (actualIndex !== 0) {\n          batchUpdateNewIndex(0);\n        }\n        // No-op\n        return;\n      }\n\n      /* IO initiates this function when needed (bookend entering view) */\n      let measurementPos = 0;\n      let bufferCount = bufferItems;\n\n      // Grab latest entry that is intersecting\n      const latestEntry =\n        entries.length === 1\n          ? entries[0]\n          : entries\n              .sort((entry1, entry2) => entry2.time - entry1.time)\n              .find(entry => {\n                return entry.intersectionRatio > 0;\n              });\n\n      if (!latestEntry) {\n        // If we don't find an intersecting area, ignore for now.\n        return;\n      }\n\n      if (latestEntry.target === afterElementRef.current) {\n        // We need to inverse the buffer count\n        bufferCount = virtualizerLength - bufferItems;\n        measurementPos = reversed ? calculateAfter() : calculateTotalSize() - calculateAfter();\n        if (!horizontal) {\n          if (reversed) {\n            // Scrolling 'up' and hit the after element below\n            measurementPos -= Math.abs(latestEntry.boundingClientRect.bottom);\n          } else if (latestEntry.boundingClientRect.top < 0) {\n            // Scrolling 'down' and hit the after element above top: 0\n            measurementPos -= latestEntry.boundingClientRect.top;\n          }\n        } else {\n          if (reversed) {\n            // Scrolling 'left' and hit the after element\n            measurementPos -= Math.abs(latestEntry.boundingClientRect.right);\n          } else if (latestEntry.boundingClientRect.left < 0) {\n            // Scrolling 'right' and hit the after element\n            measurementPos -= latestEntry.boundingClientRect.left;\n          }\n        }\n      } else if (latestEntry.target === beforeElementRef.current) {\n        measurementPos = reversed ? calculateTotalSize() - calculateBefore() : calculateBefore();\n        if (!horizontal) {\n          if (!reversed) {\n            measurementPos -= Math.abs(latestEntry.boundingClientRect.bottom);\n          } else if (latestEntry.boundingClientRect.top < 0) {\n            // Scrolling 'down' in reverse order and hit the before element above top: 0\n            measurementPos -= latestEntry.boundingClientRect.top;\n          }\n        } else {\n          if (!reversed) {\n            measurementPos -= Math.abs(latestEntry.boundingClientRect.right);\n          } else if (latestEntry.boundingClientRect.left < 0) {\n            // Scrolling 'left' and hit before element\n            measurementPos -= latestEntry.boundingClientRect.left;\n          }\n        }\n      }\n\n      if (reversed) {\n        // We're reversed, up is down, left is right, invert the scroll measure.\n        measurementPos = Math.max(calculateTotalSize() - Math.abs(measurementPos), 0);\n      }\n\n      // For now lets use hardcoded size to assess current element to paginate on\n      const startIndex = getIndexFromScrollPosition(measurementPos);\n      const bufferedIndex = Math.max(startIndex - bufferCount, 0);\n\n      // Safety limits\n      const maxIndex = Math.max(numItems - virtualizerLength, 0);\n      const newStartIndex = Math.min(Math.max(bufferedIndex, 0), maxIndex);\n\n      if (actualIndex !== newStartIndex) {\n        // We flush sync this and perform an immediate state update\n        flushSync(() => {\n          batchUpdateNewIndex(newStartIndex);\n        });\n      }\n    },\n    {\n      root: scrollViewRef ? scrollViewRef?.current : null,\n      rootMargin: '0px',\n      threshold: 0,\n    },\n  );\n\n  const findIndexRecursive = (scrollPos: number, lowIndex: number, highIndex: number): number => {\n    if (lowIndex > highIndex) {\n      // We shouldn't get here - but no-op the index if we do.\n      return actualIndex;\n    }\n    const midpoint = Math.floor((lowIndex + highIndex) / 2);\n    const iBefore = Math.max(midpoint - 1, 0);\n    const iAfter = Math.min(midpoint + 1, childProgressiveSizes.current.length - 1);\n    const indexValue = childProgressiveSizes.current[midpoint];\n    const afterIndexValue = childProgressiveSizes.current[iAfter];\n    const beforeIndexValue = childProgressiveSizes.current[iBefore];\n    if (scrollPos <= afterIndexValue && scrollPos >= beforeIndexValue) {\n      /* We've found our index - if we are exactly matching before/after index that's ok,\n      better to reduce checks if it's right on the boundary. */\n      return midpoint;\n    }\n\n    if (indexValue > scrollPos) {\n      return findIndexRecursive(scrollPos, lowIndex, midpoint - 1);\n    } else {\n      return findIndexRecursive(scrollPos, midpoint + 1, highIndex);\n    }\n  };\n\n  const getIndexFromSizeArray = (scrollPos: number): number => {\n    /* Quick searches our progressive height array */\n    if (\n      scrollPos === 0 ||\n      childProgressiveSizes.current.length === 0 ||\n      scrollPos <= childProgressiveSizes.current[0]\n    ) {\n      // Check start\n      return 0;\n    }\n\n    if (scrollPos >= childProgressiveSizes.current[childProgressiveSizes.current.length - 1]) {\n      // Check end\n      return childProgressiveSizes.current.length - 1;\n    }\n\n    return findIndexRecursive(scrollPos, 0, childProgressiveSizes.current.length - 1);\n  };\n\n  const getIndexFromScrollPosition = (scrollPos: number) => {\n    if (!getItemSize) {\n      return Math.round(scrollPos / itemSize);\n    }\n\n    return getIndexFromSizeArray(scrollPos);\n  };\n\n  const calculateTotalSize = () => {\n    if (!getItemSize) {\n      return itemSize * numItems;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[numItems - 1];\n  };\n\n  const calculateBefore = () => {\n    const currentIndex = Math.min(actualIndex, numItems);\n\n    if (!getItemSize) {\n      // The missing items from before virtualization starts height\n      return currentIndex * itemSize;\n    }\n\n    if (currentIndex <= 0) {\n      return 0;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[currentIndex - 1];\n  };\n\n  const calculateAfter = () => {\n    if (numItems === 0) {\n      return 0;\n    }\n\n    const lastItemIndex = Math.min(actualIndex + virtualizerLength, numItems - 1);\n    if (!getItemSize) {\n      // The missing items from after virtualization ends height\n      const remainingItems = numItems - lastItemIndex - 1;\n      return remainingItems * itemSize;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[numItems - 1] - childProgressiveSizes.current[lastItemIndex];\n  };\n\n  const updateChildRows = useCallback(\n    (newIndex: number) => {\n      if (numItems === 0) {\n        /* Nothing to virtualize */\n\n        return [];\n      }\n\n      if (childArray.current.length !== numItems) {\n        childArray.current = new Array(virtualizerLength);\n      }\n      const _actualIndex = Math.max(newIndex, 0);\n      const end = Math.min(_actualIndex + virtualizerLength, numItems);\n\n      for (let i = _actualIndex; i < end; i++) {\n        childArray.current[i - _actualIndex] = renderVirtualizerChildPlaceholder(renderChild(i), i);\n      }\n    },\n    [numItems, renderChild, virtualizerLength],\n  );\n\n  const setBeforeRef = useCallback(\n    (element: HTMLDivElement) => {\n      if (!element || beforeElementRef.current === element) {\n        return;\n      }\n      beforeElementRef.current = element;\n      const newList = [];\n\n      newList.push(beforeElementRef.current);\n\n      if (afterElementRef.current) {\n        newList.push(afterElementRef.current);\n      }\n\n      // Ensure we update array if before element changed\n      setObserverList(newList);\n    },\n    [setObserverList],\n  );\n\n  const setAfterRef = useCallback(\n    (element: HTMLDivElement) => {\n      if (!element || afterElementRef.current === element) {\n        return;\n      }\n      afterElementRef.current = element;\n      const newList = [];\n\n      if (beforeElementRef.current) {\n        newList.push(beforeElementRef.current);\n      }\n\n      newList.push(afterElementRef.current);\n\n      // Ensure we update array if after element changed\n      setObserverList(newList);\n    },\n    [setObserverList],\n  );\n\n  const updateCurrentItemSizes = (newIndex: number) => {\n    if (!getItemSize) {\n      // Static sizes, not required.\n      return;\n    }\n    // We should always call our size function on index change (only for the items that will be rendered)\n    // This ensures we request the latest data for incoming items in case sizing has changed.\n    const endIndex = Math.min(newIndex + virtualizerLength, numItems);\n    const startIndex = Math.max(newIndex, 0);\n\n    let didUpdate = false;\n    for (let i = startIndex; i < endIndex; i++) {\n      const newSize = getItemSize(i);\n      if (newSize !== childSizes.current[i]) {\n        childSizes.current[i] = newSize;\n        didUpdate = true;\n      }\n    }\n\n    if (didUpdate) {\n      // Update our progressive size array\n      for (let i = startIndex; i < numItems; i++) {\n        const prevSize = i > 0 ? childProgressiveSizes.current[i - 1] : 0;\n        childProgressiveSizes.current[i] = prevSize + childSizes.current[i];\n      }\n    }\n  };\n\n  // Initialize the size array before first render.\n  const hasInitialized = useRef<boolean>(false);\n  const initializeSizeArray = () => {\n    if (hasInitialized.current === false) {\n      hasInitialized.current = true;\n      populateSizeArrays();\n    }\n  };\n\n  // Initialization on mount - update array index to 0 (ready state).\n  // Only fire on mount (no deps).\n  useEffect(() => {\n    if (actualIndex < 0) {\n      batchUpdateNewIndex(0);\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  // If the user passes in an updated renderChild function - update current children\n  useEffect(() => {\n    if (actualIndex >= 0) {\n      updateChildRows(actualIndex);\n      forceUpdate();\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [renderChild, updateChildRows]);\n\n  useEffect(() => {\n    // Ensure we repopulate if getItemSize callback changes\n    populateSizeArrays();\n\n    // We only run this effect on getItemSize change (recalc dynamic sizes)\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [getItemSize]);\n\n  // Ensure we have run through and updated the whole size list array at least once.\n  initializeSizeArray();\n\n  if (getItemSize && (numItems !== childSizes.current.length || numItems !== childProgressiveSizes.current.length)) {\n    // Child length mismatch, repopulate size arrays.\n    populateSizeArrays();\n  }\n\n  // Ensure we recalc if virtualizer length changes\n  const maxCompare = Math.min(virtualizerLength, numItems);\n  if (childArray.current.length !== maxCompare && actualIndex + childArray.current.length < numItems) {\n    updateChildRows(actualIndex);\n  }\n\n  const isFullyInitialized = hasInitialized.current && actualIndex >= 0;\n  return {\n    components: {\n      before: 'div',\n      after: 'div',\n      beforeContainer: 'div',\n      afterContainer: 'div',\n    },\n    virtualizedChildren: childArray.current,\n    before: resolveShorthand(props.before, {\n      required: true,\n      defaultProps: {\n        ref: setBeforeRef,\n        role: 'none',\n      },\n    }),\n    after: resolveShorthand(props.after, {\n      required: true,\n      defaultProps: {\n        ref: setAfterRef,\n        role: 'none',\n      },\n    }),\n    beforeContainer: resolveShorthand(props.beforeContainer, {\n      required: true,\n      defaultProps: {\n        role: 'none',\n      },\n    }),\n    afterContainer: resolveShorthand(props.afterContainer, {\n      required: true,\n      defaultProps: {\n        role: 'none',\n      },\n    }),\n    beforeBufferHeight: isFullyInitialized ? calculateBefore() : 0,\n    afterBufferHeight: isFullyInitialized ? calculateAfter() : 0,\n    totalVirtualizerHeight: isFullyInitialized ? calculateTotalSize() : virtualizerLength * itemSize,\n    virtualizerStartIndex: actualIndex,\n    axis,\n    bufferSize,\n    reversed,\n  };\n}\n"],"names":["useIntersectionObserver","useEffect","useRef","useCallback","useReducer","resolveShorthand","flushSync","useVirtualizerContextState_unstable","renderVirtualizerChildPlaceholder","useVirtualizer_unstable","props","itemSize","numItems","virtualizerLength","children","renderChild","getItemSize","bufferItems","Math","round","bufferSize","floor","scrollViewRef","axis","reversed","virtualizerContext","_virtualizerContext","actualIndex","contextIndex","setActualIndex","setContextIndex","beforeElementRef","afterElementRef","childSizes","Array","childProgressiveSizes","childArray","forceUpdate","horizontal","populateSizeArrays","current","length","index","batchUpdateNewIndex","updateChildRows","updateCurrentItemSizes","setObserverList","entries","observer","measurementPos","bufferCount","latestEntry","sort","entry1","entry2","time","find","entry","intersectionRatio","target","calculateAfter","calculateTotalSize","abs","boundingClientRect","bottom","top","right","left","calculateBefore","max","startIndex","getIndexFromScrollPosition","bufferedIndex","maxIndex","newStartIndex","min","root","rootMargin","threshold","findIndexRecursive","scrollPos","lowIndex","highIndex","midpoint","iBefore","iAfter","indexValue","afterIndexValue","beforeIndexValue","getIndexFromSizeArray","currentIndex","lastItemIndex","remainingItems","newIndex","_actualIndex","end","i","setBeforeRef","element","newList","push","setAfterRef","endIndex","didUpdate","newSize","prevSize","hasInitialized","initializeSizeArray","maxCompare","isFullyInitialized","components","before","after","beforeContainer","afterContainer","virtualizedChildren","required","defaultProps","ref","role","beforeBufferHeight","afterBufferHeight","totalVirtualizerHeight","virtualizerStartIndex"],"mappings":"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"}
+{"version":3,"sources":["useVirtualizer.ts"],"sourcesContent":["import type { ReactNode } from 'react';\nimport type { VirtualizerProps, VirtualizerState } from './Virtualizer.types';\n\nimport { useEffect, useRef, useCallback, useReducer, useImperativeHandle, useState } from 'react';\nimport { useIntersectionObserver } from '../../hooks/useIntersectionObserver';\nimport { resolveShorthand } from '@fluentui/react-utilities';\nimport { flushSync } from 'react-dom';\nimport { useVirtualizerContextState_unstable } from '../../Utilities';\nimport { renderVirtualizerChildPlaceholder } from './renderVirtualizer';\n\nexport function useVirtualizer_unstable(props: VirtualizerProps): VirtualizerState {\n  const {\n    itemSize,\n    numItems,\n    virtualizerLength,\n    children: renderChild,\n    getItemSize,\n    bufferItems = Math.round(virtualizerLength / 4.0),\n    bufferSize = Math.floor(bufferItems / 2.0) * itemSize,\n    scrollViewRef,\n    axis = 'vertical',\n    reversed = false,\n    virtualizerContext,\n    onRenderedFlaggedIndex,\n    imperativeVirtualizerRef,\n  } = props;\n\n  /* The context is optional, it's useful for injecting additional index logic, or performing uniform state updates*/\n  const _virtualizerContext = useVirtualizerContextState_unstable(virtualizerContext);\n\n  const flaggedIndex = useRef<number | null>(null);\n\n  const actualIndex = _virtualizerContext.contextIndex;\n  const setActualIndex = _virtualizerContext.setContextIndex;\n\n  // Store ref to before padding element\n  const beforeElementRef = useRef<Element | null>(null);\n\n  // Store ref to before padding element\n  const afterElementRef = useRef<Element | null>(null);\n\n  // We need to store an array to track dynamic sizes, we can use this to incrementally update changes\n  const childSizes = useRef<number[]>(new Array<number>(getItemSize ? numItems : 0));\n\n  /* We keep track of the progressive sizing/placement down the list,\n  this helps us skip re-calculations unless children/size changes */\n  const childProgressiveSizes = useRef<number[]>(new Array<number>(getItemSize ? numItems : 0));\n\n  // The internal tracking REF for child array (updates often).\n  const childArray = useRef<ReactNode[]>(new Array(virtualizerLength));\n\n  // We want to be methodical about updating the render with child reference array\n  const forceUpdate = useReducer(() => ({}), {})[1];\n\n  const horizontal = axis === 'horizontal';\n\n  const populateSizeArrays = () => {\n    if (!getItemSize) {\n      // Static sizes, never mind!\n      return;\n    }\n\n    if (numItems !== childSizes.current.length) {\n      childSizes.current = new Array<number>(numItems);\n    }\n\n    if (numItems !== childProgressiveSizes.current.length) {\n      childProgressiveSizes.current = new Array<number>(numItems);\n    }\n\n    for (let index = 0; index < numItems; index++) {\n      childSizes.current[index] = getItemSize(index);\n      if (index === 0) {\n        childProgressiveSizes.current[index] = childSizes.current[index];\n      } else {\n        childProgressiveSizes.current[index] = childProgressiveSizes.current[index - 1] + childSizes.current[index];\n      }\n    }\n  };\n\n  const [isScrolling, setIsScrolling] = useState<boolean>(false);\n  const scrollTimer = useRef<ReturnType<typeof setTimeout> | null>();\n  const scrollCounter = useRef<number>(0);\n\n  const initializeScrollingTimer = () => {\n    /*\n     * This can be considered the 'velocity' required to start 'isScrolling'\n     * INIT_SCROLL_FLAG_REQ: Number of renders required to activate isScrolling\n     * INIT_SCROLL_FLAG_DELAY: Amount of time (ms) before current number of renders is reset\n     *  - Maybe we should let users customize these in the future.\n     */\n    const INIT_SCROLL_FLAG_REQ = 10;\n    const INIT_SCROLL_FLAG_DELAY = 100;\n\n    scrollCounter.current++;\n    if (scrollCounter.current >= INIT_SCROLL_FLAG_REQ) {\n      setIsScrolling(true);\n    }\n    if (scrollTimer.current) {\n      clearTimeout(scrollTimer.current);\n    }\n    scrollTimer.current = setTimeout(() => {\n      setIsScrolling(false);\n      scrollCounter.current = 0;\n    }, INIT_SCROLL_FLAG_DELAY);\n  };\n\n  useEffect(() => {\n    initializeScrollingTimer();\n  }, [actualIndex]);\n\n  const batchUpdateNewIndex = (index: number) => {\n    // Local updates\n    updateChildRows(index);\n    updateCurrentItemSizes(index);\n\n    // State setters\n    setActualIndex(index);\n  };\n\n  // Observe intersections of virtualized components\n  const { setObserverList } = useIntersectionObserver(\n    (entries: IntersectionObserverEntry[], observer: IntersectionObserver) => {\n      /* Sanity check - do we even need virtualization? */\n      if (virtualizerLength > numItems) {\n        if (actualIndex !== 0) {\n          batchUpdateNewIndex(0);\n        }\n        // No-op\n        return;\n      }\n\n      /* IO initiates this function when needed (bookend entering view) */\n      let measurementPos = 0;\n      let bufferCount = bufferItems;\n\n      // Grab latest entry that is intersecting\n      const latestEntry =\n        entries.length === 1\n          ? entries[0]\n          : entries\n              .sort((entry1, entry2) => entry2.time - entry1.time)\n              .find(entry => {\n                return entry.intersectionRatio > 0;\n              });\n\n      if (!latestEntry) {\n        // If we don't find an intersecting area, ignore for now.\n        return;\n      }\n\n      if (latestEntry.target === afterElementRef.current) {\n        // We need to inverse the buffer count\n        bufferCount = virtualizerLength - bufferItems;\n        measurementPos = reversed ? calculateAfter() : calculateTotalSize() - calculateAfter();\n        if (!horizontal) {\n          if (reversed) {\n            // Scrolling 'up' and hit the after element below\n            measurementPos -= Math.abs(latestEntry.boundingClientRect.bottom);\n          } else if (latestEntry.boundingClientRect.top < 0) {\n            // Scrolling 'down' and hit the after element above top: 0\n            measurementPos -= latestEntry.boundingClientRect.top;\n          }\n        } else {\n          if (reversed) {\n            // Scrolling 'left' and hit the after element\n            measurementPos -= Math.abs(latestEntry.boundingClientRect.right);\n          } else if (latestEntry.boundingClientRect.left < 0) {\n            // Scrolling 'right' and hit the after element\n            measurementPos -= latestEntry.boundingClientRect.left;\n          }\n        }\n      } else if (latestEntry.target === beforeElementRef.current) {\n        measurementPos = reversed ? calculateTotalSize() - calculateBefore() : calculateBefore();\n        if (!horizontal) {\n          if (!reversed) {\n            measurementPos -= Math.abs(latestEntry.boundingClientRect.bottom);\n          } else if (latestEntry.boundingClientRect.top < 0) {\n            // Scrolling 'down' in reverse order and hit the before element above top: 0\n            measurementPos -= latestEntry.boundingClientRect.top;\n          }\n        } else {\n          if (!reversed) {\n            measurementPos -= Math.abs(latestEntry.boundingClientRect.right);\n          } else if (latestEntry.boundingClientRect.left < 0) {\n            // Scrolling 'left' and hit before element\n            measurementPos -= latestEntry.boundingClientRect.left;\n          }\n        }\n      }\n\n      if (reversed) {\n        // We're reversed, up is down, left is right, invert the scroll measure.\n        measurementPos = Math.max(calculateTotalSize() - Math.abs(measurementPos), 0);\n      }\n\n      // For now lets use hardcoded size to assess current element to paginate on\n      const startIndex = getIndexFromScrollPosition(measurementPos);\n      const bufferedIndex = Math.max(startIndex - bufferCount, 0);\n\n      // Safety limits\n      const maxIndex = Math.max(numItems - virtualizerLength, 0);\n      const newStartIndex = Math.min(Math.max(bufferedIndex, 0), maxIndex);\n\n      if (actualIndex !== newStartIndex) {\n        // We flush sync this and perform an immediate state update\n        flushSync(() => {\n          batchUpdateNewIndex(newStartIndex);\n        });\n      }\n    },\n    {\n      root: scrollViewRef ? scrollViewRef?.current : null,\n      rootMargin: '0px',\n      threshold: 0,\n    },\n  );\n\n  const findIndexRecursive = (scrollPos: number, lowIndex: number, highIndex: number): number => {\n    if (lowIndex > highIndex) {\n      // We shouldn't get here - but no-op the index if we do.\n      return actualIndex;\n    }\n    const midpoint = Math.floor((lowIndex + highIndex) / 2);\n    const iBefore = Math.max(midpoint - 1, 0);\n    const iAfter = Math.min(midpoint + 1, childProgressiveSizes.current.length - 1);\n    const indexValue = childProgressiveSizes.current[midpoint];\n    const afterIndexValue = childProgressiveSizes.current[iAfter];\n    const beforeIndexValue = childProgressiveSizes.current[iBefore];\n    if (scrollPos <= afterIndexValue && scrollPos >= beforeIndexValue) {\n      /* We've found our index - if we are exactly matching before/after index that's ok,\n      better to reduce checks if it's right on the boundary. */\n      return midpoint;\n    }\n\n    if (indexValue > scrollPos) {\n      return findIndexRecursive(scrollPos, lowIndex, midpoint - 1);\n    } else {\n      return findIndexRecursive(scrollPos, midpoint + 1, highIndex);\n    }\n  };\n\n  const getIndexFromSizeArray = (scrollPos: number): number => {\n    /* Quick searches our progressive height array */\n    if (\n      scrollPos === 0 ||\n      childProgressiveSizes.current.length === 0 ||\n      scrollPos <= childProgressiveSizes.current[0]\n    ) {\n      // Check start\n      return 0;\n    }\n\n    if (scrollPos >= childProgressiveSizes.current[childProgressiveSizes.current.length - 1]) {\n      // Check end\n      return childProgressiveSizes.current.length - 1;\n    }\n\n    return findIndexRecursive(scrollPos, 0, childProgressiveSizes.current.length - 1);\n  };\n\n  const getIndexFromScrollPosition = (scrollPos: number) => {\n    if (!getItemSize) {\n      return Math.round(scrollPos / itemSize);\n    }\n\n    return getIndexFromSizeArray(scrollPos);\n  };\n\n  const calculateTotalSize = useCallback(() => {\n    if (!getItemSize) {\n      return itemSize * numItems;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[numItems - 1];\n  }, [getItemSize, itemSize, numItems]);\n\n  const calculateBefore = useCallback(() => {\n    const currentIndex = Math.min(actualIndex, numItems);\n\n    if (!getItemSize) {\n      // The missing items from before virtualization starts height\n      return currentIndex * itemSize;\n    }\n\n    if (currentIndex <= 0) {\n      return 0;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[currentIndex - 1];\n  }, [actualIndex, getItemSize, itemSize, numItems]);\n\n  const calculateAfter = useCallback(() => {\n    if (numItems === 0) {\n      return 0;\n    }\n\n    const lastItemIndex = Math.min(actualIndex + virtualizerLength, numItems - 1);\n    if (!getItemSize) {\n      // The missing items from after virtualization ends height\n      const remainingItems = numItems - lastItemIndex - 1;\n      return remainingItems * itemSize;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[numItems - 1] - childProgressiveSizes.current[lastItemIndex];\n  }, [actualIndex, getItemSize, itemSize, numItems, virtualizerLength]);\n\n  const updateChildRows = useCallback(\n    (newIndex: number) => {\n      if (numItems === 0) {\n        /* Nothing to virtualize */\n        return;\n      }\n\n      /*\n        We reset the array every time to ensure children are re-rendered\n        This function should only be called when update is nessecary\n       */\n      childArray.current = new Array(virtualizerLength);\n      const _actualIndex = Math.max(newIndex, 0);\n      const end = Math.min(_actualIndex + virtualizerLength, numItems);\n      for (let i = _actualIndex; i < end; i++) {\n        childArray.current[i - _actualIndex] = renderVirtualizerChildPlaceholder(renderChild(i, isScrolling), i);\n      }\n    },\n    [isScrolling, numItems, renderChild, virtualizerLength],\n  );\n\n  const setBeforeRef = useCallback(\n    (element: HTMLDivElement) => {\n      if (!element || beforeElementRef.current === element) {\n        return;\n      }\n      beforeElementRef.current = element;\n      const newList = [];\n\n      newList.push(beforeElementRef.current);\n\n      if (afterElementRef.current) {\n        newList.push(afterElementRef.current);\n      }\n\n      // Ensure we update array if before element changed\n      setObserverList(newList);\n    },\n    [setObserverList],\n  );\n\n  const setAfterRef = useCallback(\n    (element: HTMLDivElement) => {\n      if (!element || afterElementRef.current === element) {\n        return;\n      }\n      afterElementRef.current = element;\n      const newList = [];\n\n      if (beforeElementRef.current) {\n        newList.push(beforeElementRef.current);\n      }\n\n      newList.push(afterElementRef.current);\n\n      // Ensure we update array if after element changed\n      setObserverList(newList);\n    },\n    [setObserverList],\n  );\n\n  const updateCurrentItemSizes = (newIndex: number) => {\n    if (!getItemSize) {\n      // Static sizes, not required.\n      return;\n    }\n    // We should always call our size function on index change (only for the items that will be rendered)\n    // This ensures we request the latest data for incoming items in case sizing has changed.\n    const endIndex = Math.min(newIndex + virtualizerLength, numItems);\n    const startIndex = Math.max(newIndex, 0);\n\n    let didUpdate = false;\n    for (let i = startIndex; i < endIndex; i++) {\n      const newSize = getItemSize(i);\n      if (newSize !== childSizes.current[i]) {\n        childSizes.current[i] = newSize;\n        didUpdate = true;\n      }\n    }\n\n    if (didUpdate) {\n      // Update our progressive size array\n      for (let i = startIndex; i < numItems; i++) {\n        const prevSize = i > 0 ? childProgressiveSizes.current[i - 1] : 0;\n        childProgressiveSizes.current[i] = prevSize + childSizes.current[i];\n      }\n    }\n  };\n\n  // Initialize the size array before first render.\n  const hasInitialized = useRef<boolean>(false);\n  const initializeSizeArray = () => {\n    if (hasInitialized.current === false) {\n      hasInitialized.current = true;\n      populateSizeArrays();\n    }\n  };\n\n  useImperativeHandle(\n    imperativeVirtualizerRef,\n    () => {\n      return {\n        progressiveSizes: childProgressiveSizes,\n        nodeSizes: childSizes,\n        setFlaggedIndex: (index: number | null) => (flaggedIndex.current = index),\n      };\n    },\n    [childProgressiveSizes, childSizes],\n  );\n\n  // Initialization on mount - update array index to 0 (ready state).\n  // Only fire on mount (no deps).\n  useEffect(() => {\n    if (actualIndex < 0) {\n      batchUpdateNewIndex(0);\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  // If the user passes in an updated renderChild function - update current children\n  useEffect(() => {\n    if (actualIndex >= 0) {\n      updateChildRows(actualIndex);\n      forceUpdate();\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [renderChild, updateChildRows]);\n\n  useEffect(() => {\n    // Ensure we repopulate if getItemSize callback changes\n    populateSizeArrays();\n\n    // We only run this effect on getItemSize change (recalc dynamic sizes)\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [getItemSize]);\n\n  // Effect to check flag index on updates\n  useEffect(() => {\n    if (!onRenderedFlaggedIndex || flaggedIndex.current === null) {\n      return;\n    }\n    if (actualIndex <= flaggedIndex.current && actualIndex + virtualizerLength >= flaggedIndex.current) {\n      onRenderedFlaggedIndex(flaggedIndex.current);\n      flaggedIndex.current = null;\n    }\n  }, [actualIndex, onRenderedFlaggedIndex, virtualizerLength]);\n\n  // Ensure we have run through and updated the whole size list array at least once.\n  initializeSizeArray();\n\n  if (getItemSize && (numItems !== childSizes.current.length || numItems !== childProgressiveSizes.current.length)) {\n    // Child length mismatch, repopulate size arrays.\n    populateSizeArrays();\n  }\n\n  // Ensure we recalc if virtualizer length changes\n  const maxCompare = Math.min(virtualizerLength, numItems);\n  if (childArray.current.length !== maxCompare && actualIndex + childArray.current.length < numItems) {\n    updateChildRows(actualIndex);\n  }\n\n  const isFullyInitialized = hasInitialized.current && actualIndex >= 0;\n  return {\n    components: {\n      before: 'div',\n      after: 'div',\n      beforeContainer: 'div',\n      afterContainer: 'div',\n    },\n    virtualizedChildren: childArray.current,\n    before: resolveShorthand(props.before, {\n      required: true,\n      defaultProps: {\n        ref: setBeforeRef,\n        role: 'none',\n      },\n    }),\n    after: resolveShorthand(props.after, {\n      required: true,\n      defaultProps: {\n        ref: setAfterRef,\n        role: 'none',\n      },\n    }),\n    beforeContainer: resolveShorthand(props.beforeContainer, {\n      required: true,\n      defaultProps: {\n        role: 'none',\n      },\n    }),\n    afterContainer: resolveShorthand(props.afterContainer, {\n      required: true,\n      defaultProps: {\n        role: 'none',\n      },\n    }),\n    beforeBufferHeight: isFullyInitialized ? calculateBefore() : 0,\n    afterBufferHeight: isFullyInitialized ? calculateAfter() : 0,\n    totalVirtualizerHeight: isFullyInitialized ? calculateTotalSize() : virtualizerLength * itemSize,\n    virtualizerStartIndex: actualIndex,\n    axis,\n    bufferSize,\n    reversed,\n  };\n}\n"],"names":["useEffect","useRef","useCallback","useReducer","useImperativeHandle","useState","useIntersectionObserver","resolveShorthand","flushSync","useVirtualizerContextState_unstable","renderVirtualizerChildPlaceholder","useVirtualizer_unstable","props","itemSize","numItems","virtualizerLength","children","renderChild","getItemSize","bufferItems","Math","round","bufferSize","floor","scrollViewRef","axis","reversed","virtualizerContext","onRenderedFlaggedIndex","imperativeVirtualizerRef","_virtualizerContext","flaggedIndex","actualIndex","contextIndex","setActualIndex","setContextIndex","beforeElementRef","afterElementRef","childSizes","Array","childProgressiveSizes","childArray","forceUpdate","horizontal","populateSizeArrays","current","length","index","isScrolling","setIsScrolling","scrollTimer","scrollCounter","initializeScrollingTimer","INIT_SCROLL_FLAG_REQ","INIT_SCROLL_FLAG_DELAY","clearTimeout","setTimeout","batchUpdateNewIndex","updateChildRows","updateCurrentItemSizes","setObserverList","entries","observer","measurementPos","bufferCount","latestEntry","sort","entry1","entry2","time","find","entry","intersectionRatio","target","calculateAfter","calculateTotalSize","abs","boundingClientRect","bottom","top","right","left","calculateBefore","max","startIndex","getIndexFromScrollPosition","bufferedIndex","maxIndex","newStartIndex","min","root","rootMargin","threshold","findIndexRecursive","scrollPos","lowIndex","highIndex","midpoint","iBefore","iAfter","indexValue","afterIndexValue","beforeIndexValue","getIndexFromSizeArray","currentIndex","lastItemIndex","remainingItems","newIndex","_actualIndex","end","i","setBeforeRef","element","newList","push","setAfterRef","endIndex","didUpdate","newSize","prevSize","hasInitialized","initializeSizeArray","progressiveSizes","nodeSizes","setFlaggedIndex","maxCompare","isFullyInitialized","components","before","after","beforeContainer","afterContainer","virtualizedChildren","required","defaultProps","ref","role","beforeBufferHeight","afterBufferHeight","totalVirtualizerHeight","virtualizerStartIndex"],"mappings":"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"}

package/lib/components/VirtualizerScrollView/VirtualizerScrollView.js.map

@@ -1 +1 @@
-{"version":3,"sources":["VirtualizerScrollView.ts"],"sourcesContent":["import { VirtualizerScrollViewProps } from './VirtualizerScrollView.types';\nimport { useVirtualizerScrollView_unstable } from './useVirtualizerScrollView';\nimport { renderVirtualizerScrollView_unstable } from './renderVirtualizerScrollView';\nimport { useVirtualizerScrollViewStyles_unstable } from './useVirtualizerScrollViewStyles.styles';\nimport * as React from 'react';\n\n/**\n * Virtualizer ScrollView\n */\n\nexport const VirtualizerScrollView: React.FC<VirtualizerScrollViewProps> = (props: VirtualizerScrollViewProps) => {\n  const state = useVirtualizerScrollView_unstable(props);\n\n  useVirtualizerScrollViewStyles_unstable(state);\n\n  return renderVirtualizerScrollView_unstable(state);\n};\n\nVirtualizerScrollView.displayName = 'VirtualizerScrollView';\n"],"names":["useVirtualizerScrollView_unstable","renderVirtualizerScrollView_unstable","useVirtualizerScrollViewStyles_unstable","React","VirtualizerScrollView","props","state","displayName"],"mappings":"AACA,SAASA,iCAAiC,QAAQ,6BAA6B;AAC/E,SAASC,oCAAoC,QAAQ,gCAAgC;AACrF,SAASC,uCAAuC,QAAQ,0CAA0C;AAClG,YAAYC,WAAW,QAAQ;AAE/B;;CAEC,GAED,OAAO,MAAMC,wBAA8D,CAACC,QAAsC;IAChH,MAAMC,QAAQN,kCAAkCK;IAEhDH,wCAAwCI;IAExC,OAAOL,qCAAqCK;AAC9C,EAAE;AAEFF,sBAAsBG,WAAW,GAAG"}
+{"version":3,"sources":["VirtualizerScrollView.ts"],"sourcesContent":["import type { VirtualizerScrollViewProps } from './VirtualizerScrollView.types';\nimport { useVirtualizerScrollView_unstable } from './useVirtualizerScrollView';\nimport { renderVirtualizerScrollView_unstable } from './renderVirtualizerScrollView';\nimport { useVirtualizerScrollViewStyles_unstable } from './useVirtualizerScrollViewStyles.styles';\nimport * as React from 'react';\n\n/**\n * Virtualizer ScrollView\n */\n\nexport const VirtualizerScrollView: React.FC<VirtualizerScrollViewProps> = (props: VirtualizerScrollViewProps) => {\n  const state = useVirtualizerScrollView_unstable(props);\n\n  useVirtualizerScrollViewStyles_unstable(state);\n\n  return renderVirtualizerScrollView_unstable(state);\n};\n\nVirtualizerScrollView.displayName = 'VirtualizerScrollView';\n"],"names":["useVirtualizerScrollView_unstable","renderVirtualizerScrollView_unstable","useVirtualizerScrollViewStyles_unstable","React","VirtualizerScrollView","props","state","displayName"],"mappings":"AACA,SAASA,iCAAiC,QAAQ,6BAA6B;AAC/E,SAASC,oCAAoC,QAAQ,gCAAgC;AACrF,SAASC,uCAAuC,QAAQ,0CAA0C;AAClG,YAAYC,WAAW,QAAQ;AAE/B;;CAEC,GAED,OAAO,MAAMC,wBAA8D,CAACC,QAAsC;IAChH,MAAMC,QAAQN,kCAAkCK;IAEhDH,wCAAwCI;IAExC,OAAOL,qCAAqCK;AAC9C,EAAE;AAEFF,sBAAsBG,WAAW,GAAG"}

package/lib/components/VirtualizerScrollView/VirtualizerScrollView.types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["VirtualizerScrollView.types.ts"],"sourcesContent":["import { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\nimport {\n  VirtualizerSlots,\n  VirtualizerConfigProps,\n  VirtualizerConfigState,\n  VirtualizerChildRenderFunction,\n} from '../Virtualizer/Virtualizer.types';\n\nexport type VirtualizerScrollViewSlots = VirtualizerSlots & {\n  /**\n   * The root container that provides embedded scrolling.\n   */\n  container: NonNullable<Slot<'div'>>;\n};\n\nexport type VirtualizerScrollViewProps = ComponentProps<Partial<VirtualizerScrollViewSlots>> &\n  Partial<Omit<VirtualizerConfigProps, 'itemSize' | 'numItems' | 'getItemSize' | 'children'>> & {\n    /**\n     * Virtualizer item size in pixels - static.\n     * Axis: 'vertical' = Height\n     * Axis: 'horizontal' = Width\n     */\n    itemSize: number;\n    /**\n     * The total number of items to be virtualized.\n     */\n    numItems: number;\n    /**\n     * Child render function.\n     * Iteratively called to return current virtualizer DOM children.\n     * Will act as a row or column indexer depending on Virtualizer settings.\n     */\n    children: VirtualizerChildRenderFunction;\n  };\n\nexport type VirtualizerScrollViewState = ComponentState<VirtualizerScrollViewSlots> & VirtualizerConfigState;\n"],"names":[],"mappings":"AAAA,WAmC6G"}
+{"version":3,"sources":["VirtualizerScrollView.types.ts"],"sourcesContent":["import type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\nimport type {\n  VirtualizerSlots,\n  VirtualizerConfigProps,\n  VirtualizerConfigState,\n  VirtualizerChildRenderFunction,\n} from '../Virtualizer/Virtualizer.types';\nimport type { ScrollToInterface } from '../../Utilities';\nimport type { RefObject } from 'react';\n\nexport type VirtualizerScrollViewSlots = VirtualizerSlots & {\n  /**\n   * The root container that provides embedded scrolling.\n   */\n  container: NonNullable<Slot<'div'>>;\n};\n\nexport type VirtualizerScrollViewProps = ComponentProps<Partial<VirtualizerScrollViewSlots>> &\n  Partial<\n    Omit<\n      VirtualizerConfigProps,\n      'itemSize' | 'numItems' | 'getItemSize' | 'children' | 'flagIndex' | 'imperativeVirtualizerRef'\n    >\n  > & {\n    /**\n     * Virtualizer item size in pixels - static.\n     * Axis: 'vertical' = Height\n     * Axis: 'horizontal' = Width\n     */\n    itemSize: number;\n    /**\n     * The total number of items to be virtualized.\n     */\n    numItems: number;\n    /**\n     * Child render function.\n     * Iteratively called to return current virtualizer DOM children.\n     * Will act as a row or column indexer depending on Virtualizer settings.\n     */\n    children: VirtualizerChildRenderFunction;\n    /**\n     * Imperative ref contains our scrollTo index functionality for user control.\n     */\n    imperativeRef?: RefObject<ScrollToInterface>;\n  };\n\nexport type VirtualizerScrollViewState = ComponentState<VirtualizerScrollViewSlots> & VirtualizerConfigState;\n"],"names":[],"mappings":"AAAA,WA8C6G"}

package/lib/components/VirtualizerScrollView/renderVirtualizerScrollView.js.map

@@ -1 +1 @@
-{"version":3,"sources":["renderVirtualizerScrollView.tsx"],"sourcesContent":["/** @jsxRuntime classic */\n/** @jsx createElement */\n\nimport { createElement } from '@fluentui/react-jsx-runtime';\n\nimport { getSlotsNext } from '@fluentui/react-utilities';\nimport { VirtualizerScrollViewSlots, VirtualizerScrollViewState } from './VirtualizerScrollView.types';\nimport { renderVirtualizer_unstable } from '../Virtualizer/renderVirtualizer';\n\nexport const renderVirtualizerScrollView_unstable = (state: VirtualizerScrollViewState) => {\n  const { slots, slotProps } = getSlotsNext<VirtualizerScrollViewSlots>(state);\n\n  return <slots.container {...slotProps.container}>{renderVirtualizer_unstable(state)}</slots.container>;\n};\n"],"names":["createElement","getSlotsNext","renderVirtualizer_unstable","renderVirtualizerScrollView_unstable","state","slots","slotProps","container"],"mappings":"AAAA,wBAAwB,GACxB,uBAAuB,GAEvB,SAASA,aAAa,QAAQ,8BAA8B;AAE5D,SAASC,YAAY,QAAQ,4BAA4B;AAEzD,SAASC,0BAA0B,QAAQ,mCAAmC;AAE9E,OAAO,MAAMC,uCAAuC,CAACC,QAAsC;IACzF,MAAM,EAAEC,MAAK,EAAEC,UAAS,EAAE,GAAGL,aAAyCG;IAEtE,qBAAO,AAXT,cAWUC,MAAME,SAAS,EAAKD,UAAUC,SAAS,EAAGL,2BAA2BE;AAC/E,EAAE"}
+{"version":3,"sources":["renderVirtualizerScrollView.tsx"],"sourcesContent":["/** @jsxRuntime classic */\n/** @jsx createElement */\n\nimport { createElement } from '@fluentui/react-jsx-runtime';\n\nimport type { VirtualizerScrollViewSlots, VirtualizerScrollViewState } from './VirtualizerScrollView.types';\n\nimport { getSlotsNext } from '@fluentui/react-utilities';\nimport { renderVirtualizer_unstable } from '../Virtualizer/renderVirtualizer';\n\nexport const renderVirtualizerScrollView_unstable = (state: VirtualizerScrollViewState) => {\n  const { slots, slotProps } = getSlotsNext<VirtualizerScrollViewSlots>(state);\n\n  return <slots.container {...slotProps.container}>{renderVirtualizer_unstable(state)}</slots.container>;\n};\n"],"names":["createElement","getSlotsNext","renderVirtualizer_unstable","renderVirtualizerScrollView_unstable","state","slots","slotProps","container"],"mappings":"AAAA,wBAAwB,GACxB,uBAAuB,GAEvB,SAASA,aAAa,QAAQ,8BAA8B;AAI5D,SAASC,YAAY,QAAQ,4BAA4B;AACzD,SAASC,0BAA0B,QAAQ,mCAAmC;AAE9E,OAAO,MAAMC,uCAAuC,CAACC,QAAsC;IACzF,MAAM,EAAEC,MAAK,EAAEC,UAAS,EAAE,GAAGL,aAAyCG;IAEtE,qBAAO,AAZT,cAYUC,MAAME,SAAS,EAAKD,UAAUC,SAAS,EAAGL,2BAA2BE;AAC/E,EAAE"}