@fluentui/react-virtualizer 9.0.0-alpha.84 → 9.0.0-alpha.85

package/lib/hooks/useVirtualizerMeasure.js

@@ -1,46 +1,62 @@
 import * as React from 'react';
 import { useResizeObserverRef_unstable } from './useResizeObserverRef';
+import { useFluent_unstable as useFluent } from '@fluentui/react-shared-contexts';
 /**
  * React hook that measures virtualized space based on a static size to ensure optimized virtualization length.
  */ export const useStaticVirtualizerMeasure = (virtualizerProps)=>{
-    const { defaultItemSize, direction = 'vertical' } = virtualizerProps;
+    const { defaultItemSize, direction = 'vertical', bufferItems, bufferSize } = virtualizerProps;
     const [state, setState] = React.useState({
         virtualizerLength: 0,
-        bufferSize: 0,
-        bufferItems: 0
+        _bufferSize: 0,
+        _bufferItems: 0
     });
-    const { virtualizerLength, bufferItems, bufferSize } = state;
+    const containerSizeRef = React.useRef(0);
+    const { targetDocument } = useFluent();
+    const { virtualizerLength, _bufferItems, _bufferSize } = state;
     const resizeCallback = React.useCallback((_entries, // TODO: exclude types from this lint rule: https://github.com/microsoft/fluentui/issues/31286
     // eslint-disable-next-line no-restricted-globals
     _observer, scrollRef)=>{
         if (!(scrollRef === null || scrollRef === void 0 ? void 0 : scrollRef.current)) {
             return;
         }
-        const containerSize = direction === 'vertical' ? scrollRef === null || scrollRef === void 0 ? void 0 : scrollRef.current.getBoundingClientRect().height : scrollRef === null || scrollRef === void 0 ? void 0 : scrollRef.current.getBoundingClientRect().width;
+        if (scrollRef.current !== (targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.body)) {
+            // We have a local scroll container
+            containerSizeRef.current = direction === 'vertical' ? scrollRef === null || scrollRef === void 0 ? void 0 : scrollRef.current.getBoundingClientRect().height : scrollRef === null || scrollRef === void 0 ? void 0 : scrollRef.current.getBoundingClientRect().width;
+        } else if (targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.defaultView) {
+            var _targetDocument_defaultView, _targetDocument_defaultView1;
+            // If our scroll ref is the document body, we should check window height
+            containerSizeRef.current = direction === 'vertical' ? targetDocument === null || targetDocument === void 0 ? void 0 : (_targetDocument_defaultView = targetDocument.defaultView) === null || _targetDocument_defaultView === void 0 ? void 0 : _targetDocument_defaultView.innerHeight : targetDocument === null || targetDocument === void 0 ? void 0 : (_targetDocument_defaultView1 = targetDocument.defaultView) === null || _targetDocument_defaultView1 === void 0 ? void 0 : _targetDocument_defaultView1.innerWidth;
+        }
         /*
        * Number of items required to cover viewport.
-       */ const length = Math.ceil(containerSize / defaultItemSize + 1);
+       */ const length = Math.ceil(containerSizeRef.current / defaultItemSize + 1);
         /*
        * Number of items to append at each end, i.e. 'preload' each side before entering view.
-       */ const newBufferItems = Math.max(Math.floor(length / 4), 2);
+       * Minimum: 1
+       */ const newBufferItems = bufferItems !== null && bufferItems !== void 0 ? bufferItems : Math.max(Math.ceil(length / 4), 1);
         /*
        * This is how far we deviate into the bufferItems to detect a redraw.
-       */ const newBufferSize = Math.max(Math.floor(length / 8 * defaultItemSize), 1);
-        const totalLength = length + newBufferItems * 2 + 1;
+       */ const newBufferSize = bufferSize !== null && bufferSize !== void 0 ? bufferSize : Math.max(defaultItemSize / 2.0, 1);
+        const totalLength = length + newBufferItems * 2;
         setState({
             virtualizerLength: totalLength,
-            bufferItems: newBufferItems,
-            bufferSize: newBufferSize
+            _bufferItems: newBufferItems,
+            _bufferSize: newBufferSize
         });
     }, [
+        bufferItems,
+        bufferSize,
         defaultItemSize,
-        direction
+        direction,
+        targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.body,
+        targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.defaultView
     ]);
     const scrollRef = useResizeObserverRef_unstable(resizeCallback);
     return {
         virtualizerLength,
-        bufferItems,
-        bufferSize,
-        scrollRef
+        bufferItems: _bufferItems,
+        bufferSize: _bufferSize,
+        scrollRef,
+        containerSizeRef
     };
 };

package/lib/hooks/useVirtualizerMeasure.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useVirtualizerMeasure.ts"],"sourcesContent":["import * as React from 'react';\nimport { VirtualizerMeasureProps } from './hooks.types';\nimport { useResizeObserverRef_unstable } from './useResizeObserverRef';\n\n/**\n * React hook that measures virtualized space based on a static size to ensure optimized virtualization length.\n */\nexport const useStaticVirtualizerMeasure = <TElement extends HTMLElement>(\n  virtualizerProps: VirtualizerMeasureProps,\n): {\n  virtualizerLength: number;\n  bufferItems: number;\n  bufferSize: number;\n  scrollRef: (instance: TElement | null) => void;\n} => {\n  const { defaultItemSize, direction = 'vertical' } = virtualizerProps;\n\n  const [state, setState] = React.useState({\n    virtualizerLength: 0,\n    bufferSize: 0,\n    bufferItems: 0,\n  });\n\n  const { virtualizerLength, bufferItems, bufferSize } = state;\n\n  const resizeCallback = React.useCallback(\n    (\n      _entries: ResizeObserverEntry[],\n      // TODO: exclude types from this lint rule: https://github.com/microsoft/fluentui/issues/31286\n      // eslint-disable-next-line no-restricted-globals\n      _observer: ResizeObserver,\n      scrollRef?: React.MutableRefObject<HTMLElement | null>,\n    ) => {\n      if (!scrollRef?.current) {\n        return;\n      }\n\n      const containerSize =\n        direction === 'vertical'\n          ? scrollRef?.current.getBoundingClientRect().height\n          : scrollRef?.current.getBoundingClientRect().width;\n\n      /*\n       * Number of items required to cover viewport.\n       */\n      const length = Math.ceil(containerSize / defaultItemSize + 1);\n\n      /*\n       * Number of items to append at each end, i.e. 'preload' each side before entering view.\n       */\n      const newBufferItems = Math.max(Math.floor(length / 4), 2);\n\n      /*\n       * This is how far we deviate into the bufferItems to detect a redraw.\n       */\n      const newBufferSize = Math.max(Math.floor((length / 8) * defaultItemSize), 1);\n\n      const totalLength = length + newBufferItems * 2 + 1;\n\n      setState({\n        virtualizerLength: totalLength,\n        bufferItems: newBufferItems,\n        bufferSize: newBufferSize,\n      });\n    },\n    [defaultItemSize, direction],\n  );\n\n  const scrollRef = useResizeObserverRef_unstable(resizeCallback);\n\n  return {\n    virtualizerLength,\n    bufferItems,\n    bufferSize,\n    scrollRef,\n  };\n};\n"],"names":["React","useResizeObserverRef_unstable","useStaticVirtualizerMeasure","virtualizerProps","defaultItemSize","direction","state","setState","useState","virtualizerLength","bufferSize","bufferItems","resizeCallback","useCallback","_entries","_observer","scrollRef","current","containerSize","getBoundingClientRect","height","width","length","Math","ceil","newBufferItems","max","floor","newBufferSize","totalLength"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,SAASC,6BAA6B,QAAQ,yBAAyB;AAEvE;;CAEC,GACD,OAAO,MAAMC,8BAA8B,CACzCC;IAOA,MAAM,EAAEC,eAAe,EAAEC,YAAY,UAAU,EAAE,GAAGF;IAEpD,MAAM,CAACG,OAAOC,SAAS,GAAGP,MAAMQ,QAAQ,CAAC;QACvCC,mBAAmB;QACnBC,YAAY;QACZC,aAAa;IACf;IAEA,MAAM,EAAEF,iBAAiB,EAAEE,WAAW,EAAED,UAAU,EAAE,GAAGJ;IAEvD,MAAMM,iBAAiBZ,MAAMa,WAAW,CACtC,CACEC,UACA,8FAA8F;IAC9F,iDAAiD;IACjDC,WACAC;QAEA,IAAI,EAACA,sBAAAA,gCAAAA,UAAWC,OAAO,GAAE;YACvB;QACF;QAEA,MAAMC,gBACJb,cAAc,aACVW,sBAAAA,gCAAAA,UAAWC,OAAO,CAACE,qBAAqB,GAAGC,MAAM,GACjDJ,sBAAAA,gCAAAA,UAAWC,OAAO,CAACE,qBAAqB,GAAGE,KAAK;QAEtD;;OAEC,GACD,MAAMC,SAASC,KAAKC,IAAI,CAACN,gBAAgBd,kBAAkB;QAE3D;;OAEC,GACD,MAAMqB,iBAAiBF,KAAKG,GAAG,CAACH,KAAKI,KAAK,CAACL,SAAS,IAAI;QAExD;;OAEC,GACD,MAAMM,gBAAgBL,KAAKG,GAAG,CAACH,KAAKI,KAAK,CAAC,AAACL,SAAS,IAAKlB,kBAAkB;QAE3E,MAAMyB,cAAcP,SAASG,iBAAiB,IAAI;QAElDlB,SAAS;YACPE,mBAAmBoB;YACnBlB,aAAac;YACbf,YAAYkB;QACd;IACF,GACA;QAACxB;QAAiBC;KAAU;IAG9B,MAAMW,YAAYf,8BAA8BW;IAEhD,OAAO;QACLH;QACAE;QACAD;QACAM;IACF;AACF,EAAE"}
+{"version":3,"sources":["useVirtualizerMeasure.ts"],"sourcesContent":["import * as React from 'react';\nimport { VirtualizerMeasureProps } from './hooks.types';\nimport { useResizeObserverRef_unstable } from './useResizeObserverRef';\nimport { useFluent_unstable as useFluent } from '@fluentui/react-shared-contexts';\n\n/**\n * React hook that measures virtualized space based on a static size to ensure optimized virtualization length.\n */\nexport const useStaticVirtualizerMeasure = <TElement extends HTMLElement>(\n  virtualizerProps: VirtualizerMeasureProps,\n): {\n  virtualizerLength: number;\n  bufferItems: number;\n  bufferSize: number;\n  scrollRef: (instance: TElement | null) => void;\n  containerSizeRef: React.MutableRefObject<number>;\n} => {\n  const { defaultItemSize, direction = 'vertical', bufferItems, bufferSize } = virtualizerProps;\n\n  const [state, setState] = React.useState({\n    virtualizerLength: 0,\n    _bufferSize: 0,\n    _bufferItems: 0,\n  });\n\n  const containerSizeRef = React.useRef<number>(0);\n  const { targetDocument } = useFluent();\n\n  const { virtualizerLength, _bufferItems, _bufferSize } = state;\n\n  const resizeCallback = React.useCallback(\n    (\n      _entries: ResizeObserverEntry[],\n      // TODO: exclude types from this lint rule: https://github.com/microsoft/fluentui/issues/31286\n      // eslint-disable-next-line no-restricted-globals\n      _observer: ResizeObserver,\n      scrollRef?: React.MutableRefObject<HTMLElement | null>,\n    ) => {\n      if (!scrollRef?.current) {\n        return;\n      }\n\n      if (scrollRef.current !== targetDocument?.body) {\n        // We have a local scroll container\n        containerSizeRef.current =\n          direction === 'vertical'\n            ? scrollRef?.current.getBoundingClientRect().height\n            : scrollRef?.current.getBoundingClientRect().width;\n      } else if (targetDocument?.defaultView) {\n        // If our scroll ref is the document body, we should check window height\n        containerSizeRef.current =\n          direction === 'vertical' ? targetDocument?.defaultView?.innerHeight : targetDocument?.defaultView?.innerWidth;\n      }\n      /*\n       * Number of items required to cover viewport.\n       */\n      const length = Math.ceil(containerSizeRef.current / defaultItemSize + 1);\n\n      /*\n       * Number of items to append at each end, i.e. 'preload' each side before entering view.\n       * Minimum: 1\n       */\n      const newBufferItems = bufferItems ?? Math.max(Math.ceil(length / 4), 1);\n\n      /*\n       * This is how far we deviate into the bufferItems to detect a redraw.\n       */\n      const newBufferSize = bufferSize ?? Math.max(defaultItemSize / 2.0, 1);\n\n      const totalLength = length + newBufferItems * 2;\n\n      setState({\n        virtualizerLength: totalLength,\n        _bufferItems: newBufferItems,\n        _bufferSize: newBufferSize,\n      });\n    },\n    [bufferItems, bufferSize, defaultItemSize, direction, targetDocument?.body, targetDocument?.defaultView],\n  );\n\n  const scrollRef = useResizeObserverRef_unstable(resizeCallback);\n\n  return {\n    virtualizerLength,\n    bufferItems: _bufferItems,\n    bufferSize: _bufferSize,\n    scrollRef,\n    containerSizeRef,\n  };\n};\n"],"names":["React","useResizeObserverRef_unstable","useFluent_unstable","useFluent","useStaticVirtualizerMeasure","virtualizerProps","defaultItemSize","direction","bufferItems","bufferSize","state","setState","useState","virtualizerLength","_bufferSize","_bufferItems","containerSizeRef","useRef","targetDocument","resizeCallback","useCallback","_entries","_observer","scrollRef","current","body","getBoundingClientRect","height","width","defaultView","innerHeight","innerWidth","length","Math","ceil","newBufferItems","max","newBufferSize","totalLength"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,SAASC,6BAA6B,QAAQ,yBAAyB;AACvE,SAASC,sBAAsBC,SAAS,QAAQ,kCAAkC;AAElF;;CAEC,GACD,OAAO,MAAMC,8BAA8B,CACzCC;IAQA,MAAM,EAAEC,eAAe,EAAEC,YAAY,UAAU,EAAEC,WAAW,EAAEC,UAAU,EAAE,GAAGJ;IAE7E,MAAM,CAACK,OAAOC,SAAS,GAAGX,MAAMY,QAAQ,CAAC;QACvCC,mBAAmB;QACnBC,aAAa;QACbC,cAAc;IAChB;IAEA,MAAMC,mBAAmBhB,MAAMiB,MAAM,CAAS;IAC9C,MAAM,EAAEC,cAAc,EAAE,GAAGf;IAE3B,MAAM,EAAEU,iBAAiB,EAAEE,YAAY,EAAED,WAAW,EAAE,GAAGJ;IAEzD,MAAMS,iBAAiBnB,MAAMoB,WAAW,CACtC,CACEC,UACA,8FAA8F;IAC9F,iDAAiD;IACjDC,WACAC;QAEA,IAAI,EAACA,sBAAAA,gCAAAA,UAAWC,OAAO,GAAE;YACvB;QACF;QAEA,IAAID,UAAUC,OAAO,MAAKN,2BAAAA,qCAAAA,eAAgBO,IAAI,GAAE;YAC9C,mCAAmC;YACnCT,iBAAiBQ,OAAO,GACtBjB,cAAc,aACVgB,sBAAAA,gCAAAA,UAAWC,OAAO,CAACE,qBAAqB,GAAGC,MAAM,GACjDJ,sBAAAA,gCAAAA,UAAWC,OAAO,CAACE,qBAAqB,GAAGE,KAAK;QACxD,OAAO,IAAIV,2BAAAA,qCAAAA,eAAgBW,WAAW,EAAE;gBAGTX,6BAA2CA;YAFxE,wEAAwE;YACxEF,iBAAiBQ,OAAO,GACtBjB,cAAc,aAAaW,2BAAAA,sCAAAA,8BAAAA,eAAgBW,WAAW,cAA3BX,kDAAAA,4BAA6BY,WAAW,GAAGZ,2BAAAA,sCAAAA,+BAAAA,eAAgBW,WAAW,cAA3BX,mDAAAA,6BAA6Ba,UAAU;QACjH;QACA;;OAEC,GACD,MAAMC,SAASC,KAAKC,IAAI,CAAClB,iBAAiBQ,OAAO,GAAGlB,kBAAkB;QAEtE;;;OAGC,GACD,MAAM6B,iBAAiB3B,wBAAAA,yBAAAA,cAAeyB,KAAKG,GAAG,CAACH,KAAKC,IAAI,CAACF,SAAS,IAAI;QAEtE;;OAEC,GACD,MAAMK,gBAAgB5B,uBAAAA,wBAAAA,aAAcwB,KAAKG,GAAG,CAAC9B,kBAAkB,KAAK;QAEpE,MAAMgC,cAAcN,SAASG,iBAAiB;QAE9CxB,SAAS;YACPE,mBAAmByB;YACnBvB,cAAcoB;YACdrB,aAAauB;QACf;IACF,GACA;QAAC7B;QAAaC;QAAYH;QAAiBC;QAAWW,2BAAAA,qCAAAA,eAAgBO,IAAI;QAAEP,2BAAAA,qCAAAA,eAAgBW,WAAW;KAAC;IAG1G,MAAMN,YAAYtB,8BAA8BkB;IAEhD,OAAO;QACLN;QACAL,aAAaO;QACbN,YAAYK;QACZS;QACAP;IACF;AACF,EAAE"}

package/lib/index.js

@@ -1,5 +1,5 @@
 export { Virtualizer, virtualizerClassNames, useVirtualizer_unstable, renderVirtualizer_unstable, useVirtualizerStyles_unstable } from './Virtualizer';
-export { useIntersectionObserver, useStaticVirtualizerMeasure, useDynamicVirtualizerMeasure, useResizeObserverRef_unstable } from './Hooks';
+export { useIntersectionObserver, useStaticVirtualizerMeasure, useDynamicVirtualizerMeasure, useResizeObserverRef_unstable, useMeasureList } from './Hooks';
 export { VirtualizerContextProvider, useVirtualizerContext_unstable, scrollToItemStatic, scrollToItemDynamic } from './Utilities';
 export { VirtualizerScrollView, virtualizerScrollViewClassNames, useVirtualizerScrollView_unstable, renderVirtualizerScrollView_unstable, useVirtualizerScrollViewStyles_unstable } from './VirtualizerScrollView';
 export { VirtualizerScrollViewDynamic, virtualizerScrollViewDynamicClassNames, useVirtualizerScrollViewDynamic_unstable, renderVirtualizerScrollViewDynamic_unstable, useVirtualizerScrollViewDynamicStyles_unstable } from './VirtualizerScrollViewDynamic';

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.ts"],"sourcesContent":["export {\n  Virtualizer,\n  virtualizerClassNames,\n  useVirtualizer_unstable,\n  renderVirtualizer_unstable,\n  useVirtualizerStyles_unstable,\n} from './Virtualizer';\n\nexport type {\n  VirtualizerProps,\n  VirtualizerState,\n  VirtualizerSlots,\n  VirtualizerChildRenderFunction,\n  VirtualizerDataRef,\n} from './Virtualizer';\n\nexport {\n  useIntersectionObserver,\n  useStaticVirtualizerMeasure,\n  useDynamicVirtualizerMeasure,\n  useResizeObserverRef_unstable,\n} from './Hooks';\n\nexport type { ResizeCallbackWithRef, VirtualizerMeasureDynamicProps, VirtualizerMeasureProps } from './Hooks';\n\nexport type { ScrollToItemDynamicParams, ScrollToItemStaticParams, ScrollToInterface } from './Utilities';\n\nexport {\n  VirtualizerContextProvider,\n  useVirtualizerContext_unstable,\n  scrollToItemStatic,\n  scrollToItemDynamic,\n} from './Utilities';\n\nexport type { VirtualizerContextProps } from './Utilities';\n\nexport {\n  VirtualizerScrollView,\n  virtualizerScrollViewClassNames,\n  useVirtualizerScrollView_unstable,\n  renderVirtualizerScrollView_unstable,\n  useVirtualizerScrollViewStyles_unstable,\n} from './VirtualizerScrollView';\n\nexport type {\n  VirtualizerScrollViewProps,\n  VirtualizerScrollViewState,\n  VirtualizerScrollViewSlots,\n} from './VirtualizerScrollView';\n\nexport {\n  VirtualizerScrollViewDynamic,\n  virtualizerScrollViewDynamicClassNames,\n  useVirtualizerScrollViewDynamic_unstable,\n  renderVirtualizerScrollViewDynamic_unstable,\n  useVirtualizerScrollViewDynamicStyles_unstable,\n} from './VirtualizerScrollViewDynamic';\n\nexport type {\n  VirtualizerScrollViewDynamicProps,\n  VirtualizerScrollViewDynamicState,\n  VirtualizerScrollViewDynamicSlots,\n} from './VirtualizerScrollViewDynamic';\n"],"names":["Virtualizer","virtualizerClassNames","useVirtualizer_unstable","renderVirtualizer_unstable","useVirtualizerStyles_unstable","useIntersectionObserver","useStaticVirtualizerMeasure","useDynamicVirtualizerMeasure","useResizeObserverRef_unstable","VirtualizerContextProvider","useVirtualizerContext_unstable","scrollToItemStatic","scrollToItemDynamic","VirtualizerScrollView","virtualizerScrollViewClassNames","useVirtualizerScrollView_unstable","renderVirtualizerScrollView_unstable","useVirtualizerScrollViewStyles_unstable","VirtualizerScrollViewDynamic","virtualizerScrollViewDynamicClassNames","useVirtualizerScrollViewDynamic_unstable","renderVirtualizerScrollViewDynamic_unstable","useVirtualizerScrollViewDynamicStyles_unstable"],"rangeMappings":";;;;","mappings":"AAAA,SACEA,WAAW,EACXC,qBAAqB,EACrBC,uBAAuB,EACvBC,0BAA0B,EAC1BC,6BAA6B,QACxB,gBAAgB;AAUvB,SACEC,uBAAuB,EACvBC,2BAA2B,EAC3BC,4BAA4B,EAC5BC,6BAA6B,QACxB,UAAU;AAMjB,SACEC,0BAA0B,EAC1BC,8BAA8B,EAC9BC,kBAAkB,EAClBC,mBAAmB,QACd,cAAc;AAIrB,SACEC,qBAAqB,EACrBC,+BAA+B,EAC/BC,iCAAiC,EACjCC,oCAAoC,EACpCC,uCAAuC,QAClC,0BAA0B;AAQjC,SACEC,4BAA4B,EAC5BC,sCAAsC,EACtCC,wCAAwC,EACxCC,2CAA2C,EAC3CC,8CAA8C,QACzC,iCAAiC"}
+{"version":3,"sources":["index.ts"],"sourcesContent":["export {\n  Virtualizer,\n  virtualizerClassNames,\n  useVirtualizer_unstable,\n  renderVirtualizer_unstable,\n  useVirtualizerStyles_unstable,\n} from './Virtualizer';\n\nexport type {\n  VirtualizerProps,\n  VirtualizerState,\n  VirtualizerSlots,\n  VirtualizerChildRenderFunction,\n  VirtualizerDataRef,\n} from './Virtualizer';\n\nexport {\n  useIntersectionObserver,\n  useStaticVirtualizerMeasure,\n  useDynamicVirtualizerMeasure,\n  useResizeObserverRef_unstable,\n  useMeasureList,\n} from './Hooks';\n\nexport type {\n  ResizeCallbackWithRef,\n  VirtualizerMeasureDynamicProps,\n  VirtualizerMeasureProps,\n  IndexedResizeCallbackElement,\n} from './Hooks';\n\nexport type { ScrollToItemDynamicParams, ScrollToItemStaticParams, ScrollToInterface } from './Utilities';\n\nexport {\n  VirtualizerContextProvider,\n  useVirtualizerContext_unstable,\n  scrollToItemStatic,\n  scrollToItemDynamic,\n} from './Utilities';\n\nexport type { VirtualizerContextProps, DynamicVirtualizerContextProps } from './Utilities';\n\nexport {\n  VirtualizerScrollView,\n  virtualizerScrollViewClassNames,\n  useVirtualizerScrollView_unstable,\n  renderVirtualizerScrollView_unstable,\n  useVirtualizerScrollViewStyles_unstable,\n} from './VirtualizerScrollView';\n\nexport type {\n  VirtualizerScrollViewProps,\n  VirtualizerScrollViewState,\n  VirtualizerScrollViewSlots,\n} from './VirtualizerScrollView';\n\nexport {\n  VirtualizerScrollViewDynamic,\n  virtualizerScrollViewDynamicClassNames,\n  useVirtualizerScrollViewDynamic_unstable,\n  renderVirtualizerScrollViewDynamic_unstable,\n  useVirtualizerScrollViewDynamicStyles_unstable,\n} from './VirtualizerScrollViewDynamic';\n\nexport type {\n  VirtualizerScrollViewDynamicProps,\n  VirtualizerScrollViewDynamicState,\n  VirtualizerScrollViewDynamicSlots,\n} from './VirtualizerScrollViewDynamic';\n"],"names":["Virtualizer","virtualizerClassNames","useVirtualizer_unstable","renderVirtualizer_unstable","useVirtualizerStyles_unstable","useIntersectionObserver","useStaticVirtualizerMeasure","useDynamicVirtualizerMeasure","useResizeObserverRef_unstable","useMeasureList","VirtualizerContextProvider","useVirtualizerContext_unstable","scrollToItemStatic","scrollToItemDynamic","VirtualizerScrollView","virtualizerScrollViewClassNames","useVirtualizerScrollView_unstable","renderVirtualizerScrollView_unstable","useVirtualizerScrollViewStyles_unstable","VirtualizerScrollViewDynamic","virtualizerScrollViewDynamicClassNames","useVirtualizerScrollViewDynamic_unstable","renderVirtualizerScrollViewDynamic_unstable","useVirtualizerScrollViewDynamicStyles_unstable"],"rangeMappings":";;;;","mappings":"AAAA,SACEA,WAAW,EACXC,qBAAqB,EACrBC,uBAAuB,EACvBC,0BAA0B,EAC1BC,6BAA6B,QACxB,gBAAgB;AAUvB,SACEC,uBAAuB,EACvBC,2BAA2B,EAC3BC,4BAA4B,EAC5BC,6BAA6B,EAC7BC,cAAc,QACT,UAAU;AAWjB,SACEC,0BAA0B,EAC1BC,8BAA8B,EAC9BC,kBAAkB,EAClBC,mBAAmB,QACd,cAAc;AAIrB,SACEC,qBAAqB,EACrBC,+BAA+B,EAC/BC,iCAAiC,EACjCC,oCAAoC,EACpCC,uCAAuC,QAClC,0BAA0B;AAQjC,SACEC,4BAA4B,EAC5BC,sCAAsC,EACtCC,wCAAwC,EACxCC,2CAA2C,EAC3CC,8CAA8C,QACzC,iCAAiC"}

package/lib/utilities/VirtualizerContext/VirtualizerContext.js

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { useMemo, useState } from 'react';
+import { useMemo, useState, useRef } from 'react';
 const VirtualizerContext = React.createContext(undefined);
 export const VirtualizerContextProvider = VirtualizerContext.Provider;
 export const useVirtualizerContext_unstable = ()=>{
@@ -8,26 +8,24 @@ export const useVirtualizerContext_unstable = ()=>{
 export const useVirtualizerContextState_unstable = (passedContext)=>{
     const virtualizerContext = useVirtualizerContext_unstable();
     const [_contextIndex, _setContextIndex] = useState(-1);
+    const [_contextPosition, _setContextPosition] = useState(0);
+    const childProgressiveSizes = useRef([]);
     /* We respect any wrapped providers while also ensuring defaults or passed through
    * Order of usage -> Passed Prop -> Provider Context -> Internal State default
-   */ const _context = useMemo(()=>{
-        var _ref;
-        return (_ref = passedContext !== null && passedContext !== void 0 ? passedContext : virtualizerContext) !== null && _ref !== void 0 ? _ref : {
-            contextIndex: _contextIndex,
-            setContextIndex: _setContextIndex
+   */ const context = useMemo(()=>{
+        var _passedContext_contextIndex, _ref, _passedContext_setContextIndex, _ref1, _passedContext_contextPosition, _ref2, _passedContext_setContextPosition, _ref3;
+        return {
+            contextIndex: (_ref = (_passedContext_contextIndex = passedContext === null || passedContext === void 0 ? void 0 : passedContext.contextIndex) !== null && _passedContext_contextIndex !== void 0 ? _passedContext_contextIndex : virtualizerContext === null || virtualizerContext === void 0 ? void 0 : virtualizerContext.contextIndex) !== null && _ref !== void 0 ? _ref : _contextIndex,
+            setContextIndex: (_ref1 = (_passedContext_setContextIndex = passedContext === null || passedContext === void 0 ? void 0 : passedContext.setContextIndex) !== null && _passedContext_setContextIndex !== void 0 ? _passedContext_setContextIndex : virtualizerContext === null || virtualizerContext === void 0 ? void 0 : virtualizerContext.setContextIndex) !== null && _ref1 !== void 0 ? _ref1 : _setContextIndex,
+            contextPosition: (_ref2 = (_passedContext_contextPosition = passedContext === null || passedContext === void 0 ? void 0 : passedContext.contextPosition) !== null && _passedContext_contextPosition !== void 0 ? _passedContext_contextPosition : virtualizerContext === null || virtualizerContext === void 0 ? void 0 : virtualizerContext.contextPosition) !== null && _ref2 !== void 0 ? _ref2 : _contextPosition,
+            setContextPosition: (_ref3 = (_passedContext_setContextPosition = passedContext === null || passedContext === void 0 ? void 0 : passedContext.setContextPosition) !== null && _passedContext_setContextPosition !== void 0 ? _passedContext_setContextPosition : virtualizerContext === null || virtualizerContext === void 0 ? void 0 : virtualizerContext.setContextPosition) !== null && _ref3 !== void 0 ? _ref3 : _setContextPosition,
+            childProgressiveSizes
         };
     }, [
         _contextIndex,
+        _contextPosition,
         passedContext,
         virtualizerContext
     ]);
-    const context = useMemo(()=>{
-        return {
-            contextIndex: _context.contextIndex,
-            setContextIndex: _context.setContextIndex
-        };
-    }, [
-        _context
-    ]);
     return context;
 };

package/lib/utilities/VirtualizerContext/VirtualizerContext.js.map

@@ -1 +1 @@
-{"version":3,"sources":["VirtualizerContext.ts"],"sourcesContent":["import * as React from 'react';\nimport type { VirtualizerContextProps } from './types';\nimport { useMemo, useState } from 'react';\n\nconst VirtualizerContext = React.createContext<VirtualizerContextProps | undefined>(\n  undefined,\n) as React.Context<VirtualizerContextProps>;\n\nexport const VirtualizerContextProvider = VirtualizerContext.Provider;\n\nexport const useVirtualizerContext_unstable = () => {\n  return React.useContext(VirtualizerContext);\n};\n\nexport const useVirtualizerContextState_unstable = (\n  passedContext?: VirtualizerContextProps,\n): VirtualizerContextProps => {\n  const virtualizerContext = useVirtualizerContext_unstable();\n  const [_contextIndex, _setContextIndex] = useState<number>(-1);\n\n  /* We respect any wrapped providers while also ensuring defaults or passed through\n   * Order of usage -> Passed Prop -> Provider Context -> Internal State default\n   */\n  const _context = useMemo(\n    () => passedContext ?? virtualizerContext ?? { contextIndex: _contextIndex, setContextIndex: _setContextIndex },\n    [_contextIndex, passedContext, virtualizerContext],\n  );\n  const context = useMemo(() => {\n    return { contextIndex: _context.contextIndex, setContextIndex: _context.setContextIndex };\n  }, [_context]);\n\n  return context;\n};\n"],"names":["React","useMemo","useState","VirtualizerContext","createContext","undefined","VirtualizerContextProvider","Provider","useVirtualizerContext_unstable","useContext","useVirtualizerContextState_unstable","passedContext","virtualizerContext","_contextIndex","_setContextIndex","_context","contextIndex","setContextIndex","context"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,SAASC,OAAO,EAAEC,QAAQ,QAAQ,QAAQ;AAE1C,MAAMC,qBAAqBH,MAAMI,aAAa,CAC5CC;AAGF,OAAO,MAAMC,6BAA6BH,mBAAmBI,QAAQ,CAAC;AAEtE,OAAO,MAAMC,iCAAiC;IAC5C,OAAOR,MAAMS,UAAU,CAACN;AAC1B,EAAE;AAEF,OAAO,MAAMO,sCAAsC,CACjDC;IAEA,MAAMC,qBAAqBJ;IAC3B,MAAM,CAACK,eAAeC,iBAAiB,GAAGZ,SAAiB,CAAC;IAE5D;;GAEC,GACD,MAAMa,WAAWd,QACf;YAAMU;eAAAA,CAAAA,OAAAA,0BAAAA,2BAAAA,gBAAiBC,gCAAjBD,kBAAAA,OAAuC;YAAEK,cAAcH;YAAeI,iBAAiBH;QAAiB;IAAA,GAC9G;QAACD;QAAeF;QAAeC;KAAmB;IAEpD,MAAMM,UAAUjB,QAAQ;QACtB,OAAO;YAAEe,cAAcD,SAASC,YAAY;YAAEC,iBAAiBF,SAASE,eAAe;QAAC;IAC1F,GAAG;QAACF;KAAS;IAEb,OAAOG;AACT,EAAE"}
+{"version":3,"sources":["VirtualizerContext.ts"],"sourcesContent":["import * as React from 'react';\nimport type { DynamicVirtualizerContextProps, VirtualizerContextProps } from './types';\nimport { useMemo, useState, useRef } from 'react';\n\nconst VirtualizerContext = React.createContext<VirtualizerContextProps | undefined>(\n  undefined,\n) as React.Context<VirtualizerContextProps>;\n\nexport const VirtualizerContextProvider = VirtualizerContext.Provider;\n\nexport const useVirtualizerContext_unstable = () => {\n  return React.useContext(VirtualizerContext);\n};\n\nexport const useVirtualizerContextState_unstable = (\n  passedContext?: VirtualizerContextProps,\n): DynamicVirtualizerContextProps => {\n  const virtualizerContext = useVirtualizerContext_unstable();\n  const [_contextIndex, _setContextIndex] = useState<number>(-1);\n  const [_contextPosition, _setContextPosition] = useState<number>(0);\n  const childProgressiveSizes = useRef<number[]>([]);\n\n  /* We respect any wrapped providers while also ensuring defaults or passed through\n   * Order of usage -> Passed Prop -> Provider Context -> Internal State default\n   */\n  const context = useMemo(\n    () => ({\n      contextIndex: passedContext?.contextIndex ?? virtualizerContext?.contextIndex ?? _contextIndex,\n      setContextIndex: passedContext?.setContextIndex ?? virtualizerContext?.setContextIndex ?? _setContextIndex,\n      contextPosition: passedContext?.contextPosition ?? virtualizerContext?.contextPosition ?? _contextPosition,\n      setContextPosition:\n        passedContext?.setContextPosition ?? virtualizerContext?.setContextPosition ?? _setContextPosition,\n      childProgressiveSizes,\n    }),\n    [_contextIndex, _contextPosition, passedContext, virtualizerContext],\n  );\n\n  return context;\n};\n"],"names":["React","useMemo","useState","useRef","VirtualizerContext","createContext","undefined","VirtualizerContextProvider","Provider","useVirtualizerContext_unstable","useContext","useVirtualizerContextState_unstable","passedContext","virtualizerContext","_contextIndex","_setContextIndex","_contextPosition","_setContextPosition","childProgressiveSizes","context","contextIndex","setContextIndex","contextPosition","setContextPosition"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,SAASC,OAAO,EAAEC,QAAQ,EAAEC,MAAM,QAAQ,QAAQ;AAElD,MAAMC,qBAAqBJ,MAAMK,aAAa,CAC5CC;AAGF,OAAO,MAAMC,6BAA6BH,mBAAmBI,QAAQ,CAAC;AAEtE,OAAO,MAAMC,iCAAiC;IAC5C,OAAOT,MAAMU,UAAU,CAACN;AAC1B,EAAE;AAEF,OAAO,MAAMO,sCAAsC,CACjDC;IAEA,MAAMC,qBAAqBJ;IAC3B,MAAM,CAACK,eAAeC,iBAAiB,GAAGb,SAAiB,CAAC;IAC5D,MAAM,CAACc,kBAAkBC,oBAAoB,GAAGf,SAAiB;IACjE,MAAMgB,wBAAwBf,OAAiB,EAAE;IAEjD;;GAEC,GACD,MAAMgB,UAAUlB,QACd;YACgBW,6BAAAA,MACGA,gCAAAA,OACAA,gCAAAA,OAEfA,mCAAAA;eALG;YACLQ,cAAcR,CAAAA,OAAAA,CAAAA,8BAAAA,0BAAAA,oCAAAA,cAAeQ,YAAY,cAA3BR,yCAAAA,8BAA+BC,+BAAAA,yCAAAA,mBAAoBO,YAAY,cAA/DR,kBAAAA,OAAmEE;YACjFO,iBAAiBT,CAAAA,QAAAA,CAAAA,iCAAAA,0BAAAA,oCAAAA,cAAeS,eAAe,cAA9BT,4CAAAA,iCAAkCC,+BAAAA,yCAAAA,mBAAoBQ,eAAe,cAArET,mBAAAA,QAAyEG;YAC1FO,iBAAiBV,CAAAA,QAAAA,CAAAA,iCAAAA,0BAAAA,oCAAAA,cAAeU,eAAe,cAA9BV,4CAAAA,iCAAkCC,+BAAAA,yCAAAA,mBAAoBS,eAAe,cAArEV,mBAAAA,QAAyEI;YAC1FO,oBACEX,CAAAA,QAAAA,CAAAA,oCAAAA,0BAAAA,oCAAAA,cAAeW,kBAAkB,cAAjCX,+CAAAA,oCAAqCC,+BAAAA,yCAAAA,mBAAoBU,kBAAkB,cAA3EX,mBAAAA,QAA+EK;YACjFC;QACF;IAAA,GACA;QAACJ;QAAeE;QAAkBJ;QAAeC;KAAmB;IAGtE,OAAOM;AACT,EAAE"}

package/lib/utilities/VirtualizerContext/types.js

@@ -1,3 +1 @@
-/**
- * {@docCategory Virtualizer}
- */ export { };
+import * as React from 'react';

package/lib/utilities/VirtualizerContext/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["types.ts"],"sourcesContent":["/**\n * {@docCategory Virtualizer}\n */\nexport type VirtualizerContextProps = {\n  contextIndex: number;\n  setContextIndex: (index: number) => void;\n};\n"],"names":[],"rangeMappings":";;","mappings":"AAAA;;CAEC,GACD,WAGE"}
+{"version":3,"sources":["types.ts"],"sourcesContent":["import * as React from 'react';\n/**\n * {@docCategory Virtualizer}\n */\nexport type VirtualizerContextProps = {\n  contextIndex: number;\n  setContextIndex: (index: number) => void;\n  /*\n   * These option props are used in dynamic virtualizer\n   */\n  contextPosition?: number;\n  setContextPosition?: (index: number) => void;\n  childProgressiveSizes?: React.MutableRefObject<number[]>;\n};\n\n/**\n * Some props are optional on static virtualizer, but required for dynamic.\n */\nexport type DynamicVirtualizerContextProps = Required<VirtualizerContextProps>;\n"],"names":["React"],"rangeMappings":"","mappings":"AAAA,YAAYA,WAAW,QAAQ"}

package/lib-commonjs/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 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   * Ref for access to internal size knowledge, can be used to measure updates\n   */\n  childSizes: React.MutableRefObject<number[]>;\n  /**\n   * Ref for access to internal progressive size knowledge, can be used to measure updates\n   */\n  childProgressiveSizes: React.MutableRefObject<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  currentIndex: RefObject<number>;\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  // eslint-disable-next-line @nx/workspace-consistent-callback-type -- can't change type of existing callback\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":[],"rangeMappings":";;;;;","mappings":";;;;;iEAAuB"}
+{"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   * Enables the isScrolling property in the child render function\n   * Default: false - to prevent nessecary render function calls\n   */\n  enableScrollLoad?: 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   * Ref for access to internal size knowledge, can be used to measure updates\n   */\n  childSizes: React.MutableRefObject<number[]>;\n  /**\n   * Ref for access to internal progressive size knowledge, can be used to measure updates\n   */\n  childProgressiveSizes: React.MutableRefObject<number[]>;\n};\n\nexport type VirtualizerState = ComponentState<VirtualizerSlots> & VirtualizerConfigState;\n\n/**\n * The main child render method of Virtualization\n * isScrolling will only be enabled when enableScrollLoad is set to true.\n */\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  currentIndex: RefObject<number>;\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 (or 1/3rd for dynamic items) of virtualizerLength.\n   * RECOMMEND: Override this with a consistent value if using a dynamic virtualizer.\n   *\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 virtualizer only renders a few items outside of view.\n   */\n  bufferItems?: number;\n\n  /**\n   * Defaults to half of bufferItems * itemSize size (in pixels).\n   * RECOMMEND: Override this with a consistent minimum item size value if using a dynamic virtualizer.\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   * RECOMMEND: DO NOT PASS THIS IN, as it can cause side effects\n   * when overlapping with other scroll views\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   * Enables the isScrolling property in the child render function\n   * Default: false - to prevent nessecary render function calls\n   */\n  enableScrollLoad?: 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  // eslint-disable-next-line @nx/workspace-consistent-callback-type -- can't change type of existing callback\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  /**\n   * A ref that provides the size of container (vertical - height, horizontal - width), set by a resize observer.\n   * Virtualizer Measure hooks provide a suitable reference.\n   */\n  containerSizeRef: RefObject<number>;\n};\n\nexport type VirtualizerProps = ComponentProps<Partial<VirtualizerSlots>> & VirtualizerConfigProps;\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;iEAAuB"}