@fluentui/react-virtualizer 9.0.0-alpha.9 → 9.0.0-alpha.91

package/lib-commonjs/components/VirtualizerScrollViewDynamic/VirtualizerScrollViewDynamic.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/VirtualizerScrollViewDynamic/VirtualizerScrollViewDynamic.ts"],"sourcesContent":["import type { VirtualizerScrollViewDynamicProps } from './VirtualizerScrollViewDynamic.types';\nimport { useVirtualizerScrollViewDynamic_unstable } from './useVirtualizerScrollViewDynamic';\nimport { renderVirtualizerScrollViewDynamic_unstable } from './renderVirtualizerScrollViewDynamic';\nimport { useVirtualizerScrollViewDynamicStyles_unstable } from './useVirtualizerScrollViewDynamicStyles.styles';\nimport * as React from 'react';\nimport type { VirtualizerContextProps } from '../../Utilities';\n\n/**\n * Virtualizer ScrollView\n */\n\nexport const VirtualizerScrollViewDynamic: React.FC<VirtualizerScrollViewDynamicProps> = (\n  props: VirtualizerScrollViewDynamicProps,\n  context: React.Context<VirtualizerContextProps>,\n) => {\n  const state = useVirtualizerScrollViewDynamic_unstable(props);\n\n  useVirtualizerScrollViewDynamicStyles_unstable(state);\n\n  return renderVirtualizerScrollViewDynamic_unstable(state);\n};\n\nVirtualizerScrollViewDynamic.displayName = 'VirtualizerScrollViewDynamic';\n"],"names":["VirtualizerScrollViewDynamic","props","context","state","useVirtualizerScrollViewDynamic_unstable","useVirtualizerScrollViewDynamicStyles_unstable","renderVirtualizerScrollViewDynamic_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAWaA;;;eAAAA;;;;iDAV4C;oDACG;6DACG;iEACxC;AAOhB,MAAMA,+BAA4E,CACvFC,OACAC;IAEA,MAAMC,QAAQC,IAAAA,yEAAAA,EAAyCH;IAEvDI,IAAAA,2FAAAA,EAA+CF;IAE/C,OAAOG,IAAAA,+EAAAA,EAA4CH;AACrD;AAEAH,6BAA6BO,WAAW,GAAG"}

package/lib-commonjs/components/VirtualizerScrollViewDynamic/VirtualizerScrollViewDynamic.types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));

package/lib-commonjs/components/VirtualizerScrollViewDynamic/VirtualizerScrollViewDynamic.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/VirtualizerScrollViewDynamic/VirtualizerScrollViewDynamic.types.ts"],"sourcesContent":["import * as React from 'react';\nimport type { ComponentProps, ComponentState } from '@fluentui/react-utilities';\nimport type {\n  VirtualizerConfigProps,\n  VirtualizerConfigState,\n  VirtualizerChildRenderFunction,\n} from '../Virtualizer/Virtualizer.types';\n\nimport type { VirtualizerScrollViewSlots } from '../VirtualizerScrollView/VirtualizerScrollView.types';\nimport type { DynamicVirtualizerContextProps, ScrollToInterface } from '../../Utilities';\n\nexport type VirtualizerScrollViewDynamicSlots = VirtualizerScrollViewSlots;\n\nexport type VirtualizerScrollViewDynamicProps = ComponentProps<Partial<VirtualizerScrollViewDynamicSlots>> &\n  Partial<\n    Omit<\n      VirtualizerConfigProps,\n      'itemSize' | 'numItems' | 'getItemSize' | 'children' | 'flagIndex' | 'virtualizerContext'\n    >\n  > & {\n    /**\n     * Set as the minimum item size.\n     * Axis: 'vertical' = Height\n     * Axis: 'horizontal' = Width\n     */\n    itemSize: number;\n    /**\n     * Callback for acquiring size of individual items\n     * @param index - the index of the requested size's child\n     * If undefined, Virtualizer will auto-measure by default (performance tradeoff)\n     */\n    getItemSize?: (index: number) => 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?: React.RefObject<ScrollToInterface>;\n    /**\n     * Imperative ref contains our scrollTo index functionality for user control.\n     */\n    enablePagination?: boolean;\n    /**\n     * Enables override of dynamic virtualizer context if required.\n     */\n    virtualizerContext?: DynamicVirtualizerContextProps;\n  };\n\nexport type VirtualizerScrollViewDynamicState = ComponentState<VirtualizerScrollViewDynamicSlots> &\n  VirtualizerConfigState;\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;iEAAuB"}

package/lib-commonjs/components/VirtualizerScrollViewDynamic/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    VirtualizerScrollViewDynamic: function() {
+        return _VirtualizerScrollViewDynamic.VirtualizerScrollViewDynamic;
+    },
+    renderVirtualizerScrollViewDynamic_unstable: function() {
+        return _renderVirtualizerScrollViewDynamic.renderVirtualizerScrollViewDynamic_unstable;
+    },
+    useVirtualizerScrollViewDynamicStyles_unstable: function() {
+        return _useVirtualizerScrollViewDynamicStylesstyles.useVirtualizerScrollViewDynamicStyles_unstable;
+    },
+    useVirtualizerScrollViewDynamic_unstable: function() {
+        return _useVirtualizerScrollViewDynamic.useVirtualizerScrollViewDynamic_unstable;
+    },
+    virtualizerScrollViewDynamicClassNames: function() {
+        return _useVirtualizerScrollViewDynamicStylesstyles.virtualizerScrollViewDynamicClassNames;
+    }
+});
+const _VirtualizerScrollViewDynamic = require("./VirtualizerScrollViewDynamic");
+const _useVirtualizerScrollViewDynamic = require("./useVirtualizerScrollViewDynamic");
+const _renderVirtualizerScrollViewDynamic = require("./renderVirtualizerScrollViewDynamic");
+const _useVirtualizerScrollViewDynamicStylesstyles = require("./useVirtualizerScrollViewDynamicStyles.styles");

package/lib-commonjs/components/VirtualizerScrollViewDynamic/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/VirtualizerScrollViewDynamic/index.ts"],"sourcesContent":["export { VirtualizerScrollViewDynamic } from './VirtualizerScrollViewDynamic';\nexport type {\n  VirtualizerScrollViewDynamicProps,\n  VirtualizerScrollViewDynamicSlots,\n  VirtualizerScrollViewDynamicState,\n} from './VirtualizerScrollViewDynamic.types';\nexport { useVirtualizerScrollViewDynamic_unstable } from './useVirtualizerScrollViewDynamic';\nexport { renderVirtualizerScrollViewDynamic_unstable } from './renderVirtualizerScrollViewDynamic';\nexport {\n  useVirtualizerScrollViewDynamicStyles_unstable,\n  virtualizerScrollViewDynamicClassNames,\n} from './useVirtualizerScrollViewDynamicStyles.styles';\n"],"names":["VirtualizerScrollViewDynamic","renderVirtualizerScrollViewDynamic_unstable","useVirtualizerScrollViewDynamicStyles_unstable","useVirtualizerScrollViewDynamic_unstable","virtualizerScrollViewDynamicClassNames"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,4BAA4B;eAA5BA,0DAA4B;;IAO5BC,2CAA2C;eAA3CA,+EAA2C;;IAElDC,8CAA8C;eAA9CA,2FAA8C;;IAHvCC,wCAAwC;eAAxCA,yEAAwC;;IAI/CC,sCAAsC;eAAtCA,mFAAsC;;;8CAVK;iDAMY;oDACG;6DAIrD"}

package/lib-commonjs/components/VirtualizerScrollViewDynamic/renderVirtualizerScrollViewDynamic.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderVirtualizerScrollViewDynamic_unstable", {
+    enumerable: true,
+    get: function() {
+        return renderVirtualizerScrollViewDynamic_unstable;
+    }
+});
+const _jsxruntime = require("@fluentui/react-jsx-runtime/jsx-runtime");
+const _reactutilities = require("@fluentui/react-utilities");
+const _renderVirtualizer = require("../Virtualizer/renderVirtualizer");
+const renderVirtualizerScrollViewDynamic_unstable = (state)=>{
+    (0, _reactutilities.assertSlots)(state);
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(state.container, {
+        children: (0, _renderVirtualizer.renderVirtualizer_unstable)(state)
+    });
+};

package/lib-commonjs/components/VirtualizerScrollViewDynamic/renderVirtualizerScrollViewDynamic.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/VirtualizerScrollViewDynamic/renderVirtualizerScrollViewDynamic.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\nimport { assertSlots } from '@fluentui/react-utilities';\nimport {\n  VirtualizerScrollViewDynamicSlots,\n  VirtualizerScrollViewDynamicState,\n} from './VirtualizerScrollViewDynamic.types';\nimport { renderVirtualizer_unstable } from '../Virtualizer/renderVirtualizer';\n\nexport const renderVirtualizerScrollViewDynamic_unstable = (state: VirtualizerScrollViewDynamicState) => {\n  assertSlots<VirtualizerScrollViewDynamicSlots>(state);\n  return <state.container>{renderVirtualizer_unstable(state)}</state.container>;\n};\n"],"names":["renderVirtualizerScrollViewDynamic_unstable","state","assertSlots","_jsx","container","renderVirtualizer_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;","mappings":";;;;+BASaA;;;eAAAA;;;4BARb;gCAC4B;mCAKe;AAEpC,MAAMA,8CAA8C,CAACC;IAC1DC,IAAAA,2BAAAA,EAA+CD;IAC/C,OAAA,WAAA,GAAOE,IAAAA,eAAA,EAACF,MAAMG,SAAS,EAAA;kBAAEC,IAAAA,6CAAAA,EAA2BJ;;AACtD"}

package/lib-commonjs/components/VirtualizerScrollViewDynamic/useVirtualizerScrollViewDynamic.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useVirtualizerScrollViewDynamic_unstable", {
+    enumerable: true,
+    get: function() {
+        return useVirtualizerScrollViewDynamic_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
+const _useVirtualizer = require("../Virtualizer/useVirtualizer");
+const _Hooks = require("../../Hooks");
+const _Utilities = require("../../Utilities");
+const _useMeasureList = require("../../hooks/useMeasureList");
+const _useDynamicPagination = require("../../hooks/useDynamicPagination");
+function useVirtualizerScrollViewDynamic_unstable(props) {
+    'use no memo';
+    var _imperativeVirtualizerRef_current;
+    const contextState = (0, _Utilities.useVirtualizerContextState_unstable)(props.virtualizerContext);
+    const { imperativeRef, axis = 'vertical', reversed, imperativeVirtualizerRef, enablePagination = false, bufferItems: _bufferItems, bufferSize: _bufferSize } = props;
+    let sizeTrackingArray = _react.useRef(new Array(props.numItems).fill(props.itemSize));
+    // This lets us trigger updates when a size change occurs.
+    const [sizeUpdateCount, setSizeUpdateCount] = _react.useState(0);
+    const getChildSizeAuto = _react.useCallback((index)=>{
+        if (sizeTrackingArray.current.length <= index || sizeTrackingArray.current[index] <= 0) {
+            // Default size for initial state or untracked
+            return props.itemSize;
+        }
+        /* Required to be defined prior to our measure function
+       * we use a sizing array ref that we will update post-render
+       */ return sizeTrackingArray.current[index];
+    }, [
+        sizeTrackingArray,
+        props.itemSize,
+        sizeUpdateCount
+    ]);
+    var _props_axis, _props_getItemSize;
+    const { virtualizerLength, bufferItems, bufferSize, scrollRef, containerSizeRef, updateScrollPosition } = (0, _Hooks.useDynamicVirtualizerMeasure)({
+        defaultItemSize: props.itemSize,
+        direction: (_props_axis = props.axis) !== null && _props_axis !== void 0 ? _props_axis : 'vertical',
+        getItemSize: (_props_getItemSize = props.getItemSize) !== null && _props_getItemSize !== void 0 ? _props_getItemSize : getChildSizeAuto,
+        virtualizerContext: contextState,
+        numItems: props.numItems,
+        bufferItems: _bufferItems,
+        bufferSize: _bufferSize
+    });
+    const _imperativeVirtualizerRef = (0, _reactutilities.useMergedRefs)(_react.useRef(null), imperativeVirtualizerRef);
+    var _contextState_contextIndex;
+    const paginationRef = (0, _useDynamicPagination.useDynamicVirtualizerPagination)({
+        axis,
+        progressiveItemSizes: (_imperativeVirtualizerRef_current = _imperativeVirtualizerRef.current) === null || _imperativeVirtualizerRef_current === void 0 ? void 0 : _imperativeVirtualizerRef_current.progressiveSizes,
+        virtualizerLength,
+        currentIndex: (_contextState_contextIndex = contextState === null || contextState === void 0 ? void 0 : contextState.contextIndex) !== null && _contextState_contextIndex !== void 0 ? _contextState_contextIndex : 0
+    }, enablePagination);
+    // Store the virtualizer length as a ref for imperative ref access
+    const virtualizerLengthRef = _react.useRef(virtualizerLength);
+    if (virtualizerLengthRef.current !== virtualizerLength) {
+        virtualizerLengthRef.current = virtualizerLength;
+    }
+    const scrollViewRef = (0, _reactutilities.useMergedRefs)(props.scrollViewRef, scrollRef, paginationRef);
+    const scrollCallbackRef = _react.useRef(null);
+    _react.useImperativeHandle(imperativeRef, ()=>{
+        var _imperativeVirtualizerRef_current;
+        return {
+            scrollTo (index, behavior = 'auto', callback) {
+                scrollCallbackRef.current = callback !== null && callback !== void 0 ? callback : null;
+                if (_imperativeVirtualizerRef.current) {
+                    var _imperativeVirtualizerRef_current;
+                    const progressiveSizes = _imperativeVirtualizerRef.current.progressiveSizes.current;
+                    const totalSize = progressiveSizes && (progressiveSizes === null || progressiveSizes === void 0 ? void 0 : progressiveSizes.length) > 0 ? progressiveSizes[Math.max(progressiveSizes.length - 1, 0)] : 0;
+                    _imperativeVirtualizerRef.current.setFlaggedIndex(index);
+                    (0, _Utilities.scrollToItemDynamic)({
+                        index,
+                        itemSizes: (_imperativeVirtualizerRef_current = _imperativeVirtualizerRef.current) === null || _imperativeVirtualizerRef_current === void 0 ? void 0 : _imperativeVirtualizerRef_current.nodeSizes,
+                        totalSize,
+                        scrollViewRef: scrollViewRef,
+                        axis,
+                        reversed,
+                        behavior
+                    });
+                }
+            },
+            currentIndex: (_imperativeVirtualizerRef_current = _imperativeVirtualizerRef.current) === null || _imperativeVirtualizerRef_current === void 0 ? void 0 : _imperativeVirtualizerRef_current.currentIndex,
+            virtualizerLength: virtualizerLengthRef
+        };
+    }, [
+        axis,
+        scrollViewRef,
+        reversed,
+        _imperativeVirtualizerRef
+    ]);
+    const handleRenderedIndex = (index)=>{
+        if (scrollCallbackRef.current) {
+            scrollCallbackRef.current(index);
+        }
+    };
+    var _props_getItemSize1;
+    const virtualizerState = (0, _useVirtualizer.useVirtualizer_unstable)({
+        ...props,
+        getItemSize: (_props_getItemSize1 = props.getItemSize) !== null && _props_getItemSize1 !== void 0 ? _props_getItemSize1 : getChildSizeAuto,
+        virtualizerLength,
+        bufferItems,
+        bufferSize,
+        virtualizerContext: contextState,
+        imperativeVirtualizerRef: _imperativeVirtualizerRef,
+        onRenderedFlaggedIndex: handleRenderedIndex,
+        containerSizeRef,
+        scrollViewRef,
+        updateScrollPosition
+    });
+    const measureObject = (0, _useMeasureList.useMeasureList)(virtualizerState.virtualizerStartIndex, virtualizerLength, props.numItems, props.itemSize);
+    if (enablePagination && measureObject.sizeUpdateCount !== sizeUpdateCount) {
+        /* This enables us to let callback know that the sizes have been updated
+    triggers a re-render but is only required on pagination (else index change handles) */ setSizeUpdateCount(measureObject.sizeUpdateCount);
+    }
+    if (axis === 'horizontal') {
+        sizeTrackingArray = measureObject.widthArray;
+    } else {
+        sizeTrackingArray = measureObject.heightArray;
+    }
+    if (!props.getItemSize) {
+        // Auto-measuring is required
+        _react.Children.map(virtualizerState.virtualizedChildren, (child, index)=>{
+            if (/*#__PURE__*/ _react.isValidElement(child)) {
+                virtualizerState.virtualizedChildren[index] = /*#__PURE__*/ _react.createElement(child.type, {
+                    ...child.props,
+                    key: child.key,
+                    ref: (element)=>{
+                        if (child.hasOwnProperty('ref')) {
+                            // We must access this from the child directly, not props (forward ref).
+                            // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+                            const localRef = child === null || child === void 0 ? void 0 : child.ref;
+                            if (typeof localRef === 'function') {
+                                localRef(element);
+                            } else if (localRef) {
+                                localRef.current = element;
+                            }
+                        }
+                        // Call the auto-measure ref attachment.
+                        measureObject.createIndexedRef(index)(element);
+                    }
+                });
+            }
+        });
+    }
+    return {
+        ...virtualizerState,
+        components: {
+            ...virtualizerState.components,
+            container: 'div'
+        },
+        container: _reactutilities.slot.always(props.container, {
+            defaultProps: {
+                ref: scrollViewRef
+            },
+            elementType: 'div'
+        })
+    };
+}

package/lib-commonjs/components/VirtualizerScrollViewDynamic/useVirtualizerScrollViewDynamic.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/VirtualizerScrollViewDynamic/useVirtualizerScrollViewDynamic.tsx"],"sourcesContent":["import * as React from 'react';\nimport { slot, useMergedRefs } from '@fluentui/react-utilities';\nimport { useVirtualizer_unstable } from '../Virtualizer/useVirtualizer';\nimport type {\n  VirtualizerScrollViewDynamicProps,\n  VirtualizerScrollViewDynamicState,\n} from './VirtualizerScrollViewDynamic.types';\nimport { useDynamicVirtualizerMeasure } from '../../Hooks';\nimport { useVirtualizerContextState_unstable, scrollToItemDynamic } from '../../Utilities';\nimport type { VirtualizerDataRef } from '../Virtualizer/Virtualizer.types';\nimport { useMeasureList } from '../../hooks/useMeasureList';\nimport type { IndexedResizeCallbackElement } from '../../hooks/useMeasureList';\nimport { useDynamicVirtualizerPagination } from '../../hooks/useDynamicPagination';\n\nexport function useVirtualizerScrollViewDynamic_unstable(\n  props: VirtualizerScrollViewDynamicProps,\n): VirtualizerScrollViewDynamicState {\n  'use no memo';\n\n  const contextState = useVirtualizerContextState_unstable(props.virtualizerContext);\n  const {\n    imperativeRef,\n    axis = 'vertical',\n    reversed,\n    imperativeVirtualizerRef,\n    enablePagination = false,\n    bufferItems: _bufferItems,\n    bufferSize: _bufferSize,\n  } = props;\n\n  let sizeTrackingArray = React.useRef<number[]>(new Array(props.numItems).fill(props.itemSize));\n\n  // This lets us trigger updates when a size change occurs.\n  const [sizeUpdateCount, setSizeUpdateCount] = React.useState(0);\n\n  const getChildSizeAuto = React.useCallback(\n    (index: number) => {\n      if (sizeTrackingArray.current.length <= index || sizeTrackingArray.current[index] <= 0) {\n        // Default size for initial state or untracked\n        return props.itemSize;\n      }\n      /* Required to be defined prior to our measure function\n       * we use a sizing array ref that we will update post-render\n       */\n      return sizeTrackingArray.current[index];\n    },\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [sizeTrackingArray, props.itemSize, sizeUpdateCount],\n  );\n\n  const { virtualizerLength, bufferItems, bufferSize, scrollRef, containerSizeRef, updateScrollPosition } =\n    useDynamicVirtualizerMeasure({\n      defaultItemSize: props.itemSize,\n      direction: props.axis ?? 'vertical',\n      getItemSize: props.getItemSize ?? getChildSizeAuto,\n      virtualizerContext: contextState,\n      numItems: props.numItems,\n      bufferItems: _bufferItems,\n      bufferSize: _bufferSize,\n    });\n\n  const _imperativeVirtualizerRef = useMergedRefs(React.useRef<VirtualizerDataRef>(null), imperativeVirtualizerRef);\n\n  const paginationRef = useDynamicVirtualizerPagination(\n    {\n      axis,\n      progressiveItemSizes: _imperativeVirtualizerRef.current?.progressiveSizes,\n      virtualizerLength,\n      currentIndex: contextState?.contextIndex ?? 0,\n    },\n    enablePagination,\n  );\n\n  // Store the virtualizer length as a ref for imperative ref access\n  const virtualizerLengthRef = React.useRef<number>(virtualizerLength);\n  if (virtualizerLengthRef.current !== virtualizerLength) {\n    virtualizerLengthRef.current = virtualizerLength;\n  }\n  const scrollViewRef = useMergedRefs(props.scrollViewRef, scrollRef, paginationRef);\n  const scrollCallbackRef = React.useRef<null | ((index: number) => void)>(null);\n\n  React.useImperativeHandle(\n    imperativeRef,\n    () => {\n      return {\n        scrollTo(index: number, behavior = 'auto', callback: undefined | ((index: number) => void)) {\n          scrollCallbackRef.current = callback ?? null;\n          if (_imperativeVirtualizerRef.current) {\n            const progressiveSizes = _imperativeVirtualizerRef.current.progressiveSizes.current;\n            const totalSize =\n              progressiveSizes && progressiveSizes?.length > 0\n                ? progressiveSizes[Math.max(progressiveSizes.length - 1, 0)]\n                : 0;\n\n            _imperativeVirtualizerRef.current.setFlaggedIndex(index);\n            scrollToItemDynamic({\n              index,\n              itemSizes: _imperativeVirtualizerRef.current?.nodeSizes,\n              totalSize,\n              scrollViewRef: scrollViewRef as React.RefObject<HTMLDivElement>,\n              axis,\n              reversed,\n              behavior,\n            });\n          }\n        },\n        currentIndex: _imperativeVirtualizerRef.current?.currentIndex,\n        virtualizerLength: virtualizerLengthRef,\n      };\n    },\n    [axis, scrollViewRef, reversed, _imperativeVirtualizerRef],\n  );\n\n  const handleRenderedIndex = (index: number) => {\n    if (scrollCallbackRef.current) {\n      scrollCallbackRef.current(index);\n    }\n  };\n\n  const virtualizerState = useVirtualizer_unstable({\n    ...props,\n    getItemSize: props.getItemSize ?? getChildSizeAuto,\n    virtualizerLength,\n    bufferItems,\n    bufferSize,\n    virtualizerContext: contextState,\n    imperativeVirtualizerRef: _imperativeVirtualizerRef,\n    onRenderedFlaggedIndex: handleRenderedIndex,\n    containerSizeRef,\n    scrollViewRef,\n    updateScrollPosition,\n  });\n\n  const measureObject = useMeasureList(\n    virtualizerState.virtualizerStartIndex,\n    virtualizerLength,\n    props.numItems,\n    props.itemSize,\n  );\n\n  if (enablePagination && measureObject.sizeUpdateCount !== sizeUpdateCount) {\n    /* This enables us to let callback know that the sizes have been updated\n    triggers a re-render but is only required on pagination (else index change handles) */\n    setSizeUpdateCount(measureObject.sizeUpdateCount);\n  }\n\n  if (axis === 'horizontal') {\n    sizeTrackingArray = measureObject.widthArray;\n  } else {\n    sizeTrackingArray = measureObject.heightArray;\n  }\n\n  if (!props.getItemSize) {\n    // Auto-measuring is required\n    React.Children.map(virtualizerState.virtualizedChildren, (child, index) => {\n      if (React.isValidElement(child)) {\n        virtualizerState.virtualizedChildren[index] = (\n          <child.type\n            {...child.props}\n            key={child.key}\n            ref={(element: HTMLElement & IndexedResizeCallbackElement) => {\n              if (child.hasOwnProperty('ref')) {\n                // We must access this from the child directly, not props (forward ref).\n                // eslint-disable-next-line  @typescript-eslint/no-explicit-any\n                const localRef = (child as any)?.ref;\n\n                if (typeof localRef === 'function') {\n                  localRef(element);\n                } else if (localRef) {\n                  localRef.current = element;\n                }\n              }\n\n              // Call the auto-measure ref attachment.\n              measureObject.createIndexedRef(index)(element);\n            }}\n          />\n        );\n      }\n    });\n  }\n\n  return {\n    ...virtualizerState,\n    components: {\n      ...virtualizerState.components,\n      container: 'div',\n    },\n    container: slot.always(props.container, {\n      defaultProps: {\n        ref: scrollViewRef,\n      },\n      elementType: 'div',\n    }),\n  };\n}\n"],"names":["useVirtualizerScrollViewDynamic_unstable","props","_imperativeVirtualizerRef","contextState","useVirtualizerContextState_unstable","virtualizerContext","imperativeRef","axis","reversed","imperativeVirtualizerRef","enablePagination","bufferItems","_bufferItems","bufferSize","_bufferSize","sizeTrackingArray","React","useRef","Array","numItems","fill","itemSize","sizeUpdateCount","setSizeUpdateCount","useState","getChildSizeAuto","useCallback","index","current","length","virtualizerLength","scrollRef","containerSizeRef","updateScrollPosition","useDynamicVirtualizerMeasure","defaultItemSize","direction","getItemSize","useMergedRefs","paginationRef","useDynamicVirtualizerPagination","progressiveItemSizes","progressiveSizes","currentIndex","contextIndex","virtualizerLengthRef","scrollViewRef","scrollCallbackRef","useImperativeHandle","scrollTo","behavior","callback","totalSize","Math","max","setFlaggedIndex","scrollToItemDynamic","itemSizes","nodeSizes","handleRenderedIndex","virtualizerState","useVirtualizer_unstable","onRenderedFlaggedIndex","measureObject","useMeasureList","virtualizerStartIndex","widthArray","heightArray","Children","map","virtualizedChildren","child","isValidElement","createElement","type","key","ref","element","hasOwnProperty","localRef","createIndexedRef","components","container","slot","always","defaultProps","elementType"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib-commonjs/components/VirtualizerScrollViewDynamic/useVirtualizerScrollViewDynamicStyles.styles.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    useVirtualizerScrollViewDynamicStyles_unstable: function() {
+        return useVirtualizerScrollViewDynamicStyles_unstable;
+    },
+    virtualizerScrollViewDynamicClassNames: function() {
+        return virtualizerScrollViewDynamicClassNames;
+    }
+});
+const _useVirtualizerStylesstyles = require("../Virtualizer/useVirtualizerStyles.styles");
+const _react = require("@griffel/react");
+const virtualizerScrollViewDynamicClassName = 'fui-Virtualizer-Scroll-View-Dynamic';
+const virtualizerScrollViewDynamicClassNames = {
+    ..._useVirtualizerStylesstyles.virtualizerClassNames,
+    container: `${virtualizerScrollViewDynamicClassName}__container`
+};
+const useStyles = /*#__PURE__*/ (0, _react.__styles)({
+    base: {
+        mc9l5x: "f22iagw",
+        a9b677: "fly5x3f",
+        Bqenvij: "f1l02sjl"
+    },
+    vertical: {
+        Beiy3e4: "f1vx9l62",
+        Bmxbyg5: "f5zp4f"
+    },
+    horizontal: {
+        Beiy3e4: "f1063pyq",
+        B68tc82: "f1oy3dpc"
+    },
+    verticalReversed: {
+        Beiy3e4: "f1gkdon0",
+        Bmxbyg5: "f5zp4f"
+    },
+    horizontalReversed: {
+        Beiy3e4: "f1oztnx0",
+        B68tc82: "f1oy3dpc"
+    }
+}, {
+    d: [
+        ".f22iagw{display:flex;}",
+        ".fly5x3f{width:100%;}",
+        ".f1l02sjl{height:100%;}",
+        ".f1vx9l62{flex-direction:column;}",
+        ".f5zp4f{overflow-y:auto;}",
+        ".f1063pyq{flex-direction:row;}",
+        ".f1oy3dpc{overflow-x:auto;}",
+        ".f1gkdon0{flex-direction:column-reverse;}",
+        ".f1oztnx0{flex-direction:row-reverse;}"
+    ]
+});
+const useVirtualizerScrollViewDynamicStyles_unstable = (state)=>{
+    'use no memo';
+    const styles = useStyles();
+    // Default virtualizer styles base
+    (0, _useVirtualizerStylesstyles.useVirtualizerStyles_unstable)(state);
+    const containerStyle = state.axis === 'horizontal' ? state.reversed ? styles.horizontalReversed : styles.horizontal : state.reversed ? styles.verticalReversed : styles.vertical;
+    // Add container styles
+    state.container.className = (0, _react.mergeClasses)(virtualizerScrollViewDynamicClassNames.container, styles.base, containerStyle, state.container.className);
+    return state;
+};

package/lib-commonjs/components/VirtualizerScrollViewDynamic/useVirtualizerScrollViewDynamicStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useVirtualizerScrollViewDynamicStyles.styles.js"],"sourcesContent":["import { useVirtualizerStyles_unstable, virtualizerClassNames } from '../Virtualizer/useVirtualizerStyles.styles';\nimport { makeStyles, mergeClasses } from '@griffel/react';\nconst virtualizerScrollViewDynamicClassName = 'fui-Virtualizer-Scroll-View-Dynamic';\nexport const virtualizerScrollViewDynamicClassNames = {\n    ...virtualizerClassNames,\n    container: `${virtualizerScrollViewDynamicClassName}__container`\n};\nconst useStyles = makeStyles({\n    base: {\n        display: 'flex',\n        width: '100%',\n        height: '100%'\n    },\n    vertical: {\n        flexDirection: 'column',\n        overflowY: 'auto'\n    },\n    horizontal: {\n        flexDirection: 'row',\n        overflowX: 'auto'\n    },\n    verticalReversed: {\n        flexDirection: 'column-reverse',\n        overflowY: 'auto'\n    },\n    horizontalReversed: {\n        flexDirection: 'row-reverse',\n        overflowX: 'auto'\n    }\n});\n/**\n * Apply styling to the Virtualizer states\n */ export const useVirtualizerScrollViewDynamicStyles_unstable = (state)=>{\n    'use no memo';\n    const styles = useStyles();\n    // Default virtualizer styles base\n    useVirtualizerStyles_unstable(state);\n    const containerStyle = state.axis === 'horizontal' ? state.reversed ? styles.horizontalReversed : styles.horizontal : state.reversed ? styles.verticalReversed : styles.vertical;\n    // Add container styles\n    state.container.className = mergeClasses(virtualizerScrollViewDynamicClassNames.container, styles.base, containerStyle, state.container.className);\n    return state;\n};\n"],"names":["useVirtualizerScrollViewDynamicStyles_unstable","virtualizerScrollViewDynamicClassNames","virtualizerScrollViewDynamicClassName","virtualizerClassNames","container","useStyles","__styles","base","mc9l5x","a9b677","Bqenvij","vertical","Beiy3e4","Bmxbyg5","horizontal","B68tc82","verticalReversed","horizontalReversed","d","state","styles","useVirtualizerStyles_unstable","containerStyle","axis","reversed","className","mergeClasses"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAgCiBA,8CAA8C;eAA9CA;;IA7BJC,sCAAsC;eAAtCA;;;4CAHwD;uBAC5B;AACzC,MAAMC,wCAAwC;AACvC,MAAMD,yCAAyC;IAClD,GAAGE,iDAAqB;IACxBC,WAAW,CAAA,EAAGF,sCAAqC,WAAA,CAAA;AACvD;AACA,MAAMG,YAAS,WAAA,GAAGC,IAAAA,eAAA,EAAA;IAAAC,MAAA;QAAAC,QAAA;QAAAC,QAAA;QAAAC,SAAA;IAAA;IAAAC,UAAA;QAAAC,SAAA;QAAAC,SAAA;IAAA;IAAAC,YAAA;QAAAF,SAAA;QAAAG,SAAA;IAAA;IAAAC,kBAAA;QAAAJ,SAAA;QAAAC,SAAA;IAAA;IAAAI,oBAAA;QAAAL,SAAA;QAAAG,SAAA;IAAA;AAAA,GAAA;IAAAG,GAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;KAAA;AAAA;AAyBP,MAAMlB,iDAAkDmB,CAAAA;IAC/D;IACA,MAAMC,SAASf;IACf,kCAAA;IACAgB,IAAAA,yDAA6B,EAACF;IAC9B,MAAMG,iBAAiBH,MAAMI,IAAI,KAAK,eAAeJ,MAAMK,QAAQ,GAAGJ,OAAOH,kBAAkB,GAAGG,OAAON,UAAU,GAAGK,MAAMK,QAAQ,GAAGJ,OAAOJ,gBAAgB,GAAGI,OAAOT,QAAQ;IAChL,uBAAA;IACAQ,MAAMf,SAAS,CAACqB,SAAS,GAAGC,IAAAA,mBAAY,EAACzB,uCAAuCG,SAAS,EAAEgB,OAAOb,IAAI,EAAEe,gBAAgBH,MAAMf,SAAS,CAACqB,SAAS;IACjJ,OAAON;AACX"}

package/lib-commonjs/hooks/hooks.types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));

package/lib-commonjs/hooks/hooks.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/hooks/hooks.types.ts"],"sourcesContent":["import * as React from 'react';\nimport { DynamicVirtualizerContextProps } from '../Utilities';\n\nexport type VirtualizerMeasureProps = {\n  defaultItemSize: number;\n  direction?: 'vertical' | 'horizontal';\n\n  /**\n   * Override recommended number of buffer items\n   */\n  bufferItems?: number;\n\n  /**\n   * Override recommended buffer size (px)\n   */\n  bufferSize?: number;\n};\n\nexport type VirtualizerMeasureDynamicProps = {\n  defaultItemSize: number;\n  virtualizerContext: DynamicVirtualizerContextProps;\n  numItems: number;\n  getItemSize: (index: number) => number;\n  direction?: 'vertical' | 'horizontal';\n\n  /**\n   * Override recommended number of buffer items\n   */\n  bufferItems?: number;\n\n  /**\n   * Override recommended buffer size (px)\n   */\n  bufferSize?: number;\n};\n\nexport type VirtualizerStaticPaginationProps = {\n  itemSize: number;\n  axis?: 'vertical' | 'horizontal';\n};\n\n/**\n * Props to be passed into dynamic virtualization hooks\n * All props can be acquired from useVirtualizer hooks themselves and passed in\n */\nexport type VirtualizerDynamicPaginationProps = {\n  /**\n   * An array that tracks the sizing of each item in virtualizer cumulatively\n   */\n  progressiveItemSizes: React.RefObject<number[]> | undefined;\n  /**\n   * The current starting index of the virtualizer's DOM elements\n   */\n  currentIndex: number;\n  /**\n   * The axis we should paginate on (should match virtualizer's axis)\n   */\n  axis?: 'vertical' | 'horizontal';\n  /**\n   * The current length of Virtualizer's actual DOM elements\n   */\n  virtualizerLength: number;\n};\n\n/**\n * Additional direct Ref prevents reading old resize entry data\n * Backwards compatible with ResizeObserverCallback if preferred\n */\nexport interface ResizeCallbackWithRef {\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  ): void;\n}\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;iEAAuB"}

package/lib-commonjs/hooks/index.js

@@ -1,8 +1,38 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-const tslib_1 = /*#__PURE__*/require("tslib");
-tslib_1.__exportStar(require("./useIntersectionObserver"), exports);
-//# sourceMappingURL=index.js.map
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createResizeObserverFromDocument: function() {
+        return _useMeasureList.createResizeObserverFromDocument;
+    },
+    getRTLRootMargin: function() {
+        return _useIntersectionObserver.getRTLRootMargin;
+    },
+    useDynamicVirtualizerMeasure: function() {
+        return _useDynamicVirtualizerMeasure.useDynamicVirtualizerMeasure;
+    },
+    useIntersectionObserver: function() {
+        return _useIntersectionObserver.useIntersectionObserver;
+    },
+    useMeasureList: function() {
+        return _useMeasureList.useMeasureList;
+    },
+    useResizeObserverRef_unstable: function() {
+        return _useResizeObserverRef.useResizeObserverRef_unstable;
+    },
+    useStaticVirtualizerMeasure: function() {
+        return _useVirtualizerMeasure.useStaticVirtualizerMeasure;
+    }
+});
+const _useIntersectionObserver = require("./useIntersectionObserver");
+const _useVirtualizerMeasure = require("./useVirtualizerMeasure");
+const _useDynamicVirtualizerMeasure = require("./useDynamicVirtualizerMeasure");
+const _useResizeObserverRef = require("./useResizeObserverRef");
+const _useMeasureList = require("./useMeasureList");

package/lib-commonjs/hooks/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["tslib_1","__exportStar","require","exports"],"sources":["../src/packages/react-components/react-virtualizer/src/hooks/index.ts"],"sourcesContent":["export * from './useIntersectionObserver';\n"],"mappings":";;;;;;AAAAA,OAAA,CAAAC,YAAA,CAAAC,OAAA,+BAAAC,OAAA"}
+{"version":3,"sources":["../src/hooks/index.ts"],"sourcesContent":["export { getRTLRootMargin, useIntersectionObserver } from './useIntersectionObserver';\nexport { useStaticVirtualizerMeasure } from './useVirtualizerMeasure';\nexport { useDynamicVirtualizerMeasure } from './useDynamicVirtualizerMeasure';\nexport { useResizeObserverRef_unstable } from './useResizeObserverRef';\nexport type {\n  ResizeCallbackWithRef,\n  VirtualizerDynamicPaginationProps,\n  VirtualizerMeasureDynamicProps,\n  VirtualizerMeasureProps,\n  VirtualizerStaticPaginationProps,\n} from './hooks.types';\nexport type { IndexedResizeCallbackElement } from './useMeasureList';\nexport { createResizeObserverFromDocument, useMeasureList } from './useMeasureList';\n"],"names":["createResizeObserverFromDocument","getRTLRootMargin","useDynamicVirtualizerMeasure","useIntersectionObserver","useMeasureList","useResizeObserverRef_unstable","useStaticVirtualizerMeasure"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAYSA,gCAAgC;eAAhCA,gDAAgC;;IAZhCC,gBAAgB;eAAhBA,yCAAgB;;IAEhBC,4BAA4B;eAA5BA,0DAA4B;;IAFVC,uBAAuB;eAAvBA,gDAAuB;;IAYPC,cAAc;eAAdA,8BAAc;;IAThDC,6BAA6B;eAA7BA,mDAA6B;;IAF7BC,2BAA2B;eAA3BA,kDAA2B;;;yCADsB;uCACd;8CACC;sCACC;gCASmB"}

package/lib-commonjs/hooks/useDynamicPagination.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useDynamicVirtualizerPagination", {
+    enumerable: true,
+    get: function() {
+        return useDynamicVirtualizerPagination;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
+const useDynamicVirtualizerPagination = (virtualizerProps, paginationEnabled = true)=>{
+    'use no memo';
+    const { axis = 'vertical', currentIndex, progressiveItemSizes, virtualizerLength } = virtualizerProps;
+    const [setScrollTimer, clearScrollTimer] = (0, _reactutilities.useTimeout)();
+    const lastScrollPos = _react.useRef(-1);
+    const lastIndexScrolled = _react.useRef(-1);
+    const scrollContainer = _react.useRef(null);
+    const clearListeners = ()=>{
+        if (scrollContainer.current) {
+            scrollContainer.current.removeEventListener('scroll', onScroll);
+            scrollContainer.current = null;
+            clearScrollTimer();
+        }
+    };
+    _react.useEffect(()=>{
+        return ()=>{
+            clearListeners();
+        };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    /**
+   * Handle scroll stop event and paginate to the closest item
+   * If the closest item is the same as the previous scroll end
+   * we paginate to the next/previous one based on direction
+   *
+   * Users/Virtualizer-Hooks must pass in a cumulative array of sizes
+   * This prevents the need to recalculate and ensures size arrays are synced externally
+   */ const onScrollEnd = _react.useCallback(()=>{
+        if (!scrollContainer.current || !paginationEnabled || !(progressiveItemSizes === null || progressiveItemSizes === void 0 ? void 0 : progressiveItemSizes.current)) {
+            // No container found
+            return;
+        }
+        const currentScrollPos = Math.round(axis === 'vertical' ? scrollContainer.current.scrollTop : scrollContainer.current.scrollLeft);
+        let closestItemPos = 0;
+        let closestItem = 0;
+        const endItem = Math.min(currentIndex + virtualizerLength, progressiveItemSizes.current.length);
+        for(let i = currentIndex; i < endItem - 1; i++){
+            if (currentScrollPos <= progressiveItemSizes.current[i + 1] && currentScrollPos >= progressiveItemSizes.current[i]) {
+                // Found our in between position
+                const distanceToPrev = Math.abs(currentScrollPos - progressiveItemSizes.current[i]);
+                const distanceToNext = Math.abs(progressiveItemSizes.current[i + 1] - currentScrollPos);
+                if (distanceToPrev < distanceToNext) {
+                    closestItem = i;
+                } else {
+                    closestItem = i + 1;
+                }
+                break;
+            }
+        }
+        let nextItem;
+        if (Math.round(closestItem - lastIndexScrolled.current) === 0) {
+            // Special case for go to next/previous with minimum amount of scroll needed
+            const nextTarget = lastScrollPos.current < currentScrollPos ? 1 : -1;
+            // This will also handle a case where we scrolled to the exact correct position (noop)
+            const isSecondaryScroll = Math.round(lastScrollPos.current - currentScrollPos) === 0;
+            const posMod = isSecondaryScroll ? 0 : nextTarget;
+            nextItem = closestItem + posMod;
+        } else {
+            // Pagination for anything else can just jump to the closest!
+            nextItem = closestItem;
+        }
+        // Safeguard nextItem
+        nextItem = Math.min(Math.max(0, nextItem), progressiveItemSizes.current.length);
+        closestItemPos = progressiveItemSizes.current[nextItem];
+        if (axis === 'vertical') {
+            scrollContainer.current.scrollTo({
+                top: closestItemPos,
+                behavior: 'smooth'
+            });
+        } else {
+            scrollContainer.current.scrollTo({
+                left: closestItemPos,
+                behavior: 'smooth'
+            });
+        }
+        lastScrollPos.current = progressiveItemSizes.current[nextItem];
+        lastIndexScrolled.current = nextItem;
+    }, [
+        paginationEnabled,
+        currentIndex,
+        scrollContainer,
+        virtualizerLength,
+        axis,
+        progressiveItemSizes
+    ]);
+    /**
+   * On scroll timer that will continuously delay callback until scrolling stops
+   */ const onScroll = _react.useCallback((event)=>{
+        clearScrollTimer();
+        setScrollTimer(onScrollEnd, 100);
+    }, [
+        onScrollEnd,
+        clearScrollTimer,
+        setScrollTimer
+    ]);
+    /**
+   * Pagination ref will ensure we attach listeners to containers on change
+   * It is returned from hook and merged into the scroll container externally
+   */ const paginationRef = _react.useCallback((instance)=>{
+        if (!paginationEnabled) {
+            clearListeners();
+            scrollContainer.current = null;
+            return;
+        }
+        if (scrollContainer.current !== instance) {
+            clearListeners();
+            scrollContainer.current = instance;
+            if (scrollContainer.current) {
+                scrollContainer.current.addEventListener('scroll', onScroll);
+            }
+        }
+    }, [
+        onScroll,
+        onScrollEnd,
+        paginationEnabled
+    ]);
+    return paginationRef;
+};

package/lib-commonjs/hooks/useDynamicPagination.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/hooks/useDynamicPagination.ts"],"sourcesContent":["import * as React from 'react';\nimport { VirtualizerDynamicPaginationProps } from './hooks.types';\nimport { useTimeout } from '@fluentui/react-utilities';\n\n/**\n * Optional hook that will enable pagination on the virtualizer so that it 'autoscrolls' to an items exact position\n * Sizes are dynamic so we require a progressive sizing array (passed in from Dynamic virtualizer hooks)\n * On short scrolls, we will go at minimum to the next/previous item so that arrow pagination works\n * All VirtualizerDynamicPaginationProps can be grabbed from dynamic Virtualizer hooks externally and passed in\n */\nexport const useDynamicVirtualizerPagination = (\n  virtualizerProps: VirtualizerDynamicPaginationProps,\n  paginationEnabled: Boolean = true,\n) => {\n  'use no memo';\n\n  const { axis = 'vertical', currentIndex, progressiveItemSizes, virtualizerLength } = virtualizerProps;\n\n  const [setScrollTimer, clearScrollTimer] = useTimeout();\n  const lastScrollPos = React.useRef<number>(-1);\n  const lastIndexScrolled = React.useRef<number>(-1);\n\n  const scrollContainer = React.useRef<HTMLElement | null>(null);\n\n  const clearListeners = () => {\n    if (scrollContainer.current) {\n      scrollContainer.current.removeEventListener('scroll', onScroll);\n      scrollContainer.current = null;\n      clearScrollTimer();\n    }\n  };\n\n  React.useEffect(() => {\n    return () => {\n      clearListeners();\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  /**\n   * Handle scroll stop event and paginate to the closest item\n   * If the closest item is the same as the previous scroll end\n   * we paginate to the next/previous one based on direction\n   *\n   * Users/Virtualizer-Hooks must pass in a cumulative array of sizes\n   * This prevents the need to recalculate and ensures size arrays are synced externally\n   */\n  const onScrollEnd = React.useCallback(() => {\n    if (!scrollContainer.current || !paginationEnabled || !progressiveItemSizes?.current) {\n      // No container found\n      return;\n    }\n\n    const currentScrollPos = Math.round(\n      axis === 'vertical' ? scrollContainer.current.scrollTop : scrollContainer.current.scrollLeft,\n    );\n    let closestItemPos = 0;\n    let closestItem = 0;\n    const endItem = Math.min(currentIndex + virtualizerLength, progressiveItemSizes.current.length);\n\n    for (let i = currentIndex; i < endItem - 1; i++) {\n      if (\n        currentScrollPos <= progressiveItemSizes.current[i + 1] &&\n        currentScrollPos >= progressiveItemSizes.current[i]\n      ) {\n        // Found our in between position\n        const distanceToPrev = Math.abs(currentScrollPos - progressiveItemSizes.current[i]);\n        const distanceToNext = Math.abs(progressiveItemSizes.current[i + 1] - currentScrollPos);\n        if (distanceToPrev < distanceToNext) {\n          closestItem = i;\n        } else {\n          closestItem = i + 1;\n        }\n        break;\n      }\n    }\n\n    let nextItem;\n    if (Math.round(closestItem - lastIndexScrolled.current) === 0) {\n      // Special case for go to next/previous with minimum amount of scroll needed\n      const nextTarget = lastScrollPos.current < currentScrollPos ? 1 : -1;\n      // This will also handle a case where we scrolled to the exact correct position (noop)\n      const isSecondaryScroll = Math.round(lastScrollPos.current - currentScrollPos) === 0;\n      const posMod = isSecondaryScroll ? 0 : nextTarget;\n      nextItem = closestItem + posMod;\n    } else {\n      // Pagination for anything else can just jump to the closest!\n      nextItem = closestItem;\n    }\n\n    // Safeguard nextItem\n    nextItem = Math.min(Math.max(0, nextItem), progressiveItemSizes.current.length);\n    closestItemPos = progressiveItemSizes.current[nextItem];\n\n    if (axis === 'vertical') {\n      scrollContainer.current.scrollTo({ top: closestItemPos, behavior: 'smooth' });\n    } else {\n      scrollContainer.current.scrollTo({ left: closestItemPos, behavior: 'smooth' });\n    }\n    lastScrollPos.current = progressiveItemSizes.current[nextItem];\n    lastIndexScrolled.current = nextItem;\n  }, [paginationEnabled, currentIndex, scrollContainer, virtualizerLength, axis, progressiveItemSizes]);\n\n  /**\n   * On scroll timer that will continuously delay callback until scrolling stops\n   */\n  const onScroll = React.useCallback(\n    event => {\n      clearScrollTimer();\n      setScrollTimer(onScrollEnd, 100);\n    },\n    [onScrollEnd, clearScrollTimer, setScrollTimer],\n  );\n\n  /**\n   * Pagination ref will ensure we attach listeners to containers on change\n   * It is returned from hook and merged into the scroll container externally\n   */\n  const paginationRef = React.useCallback(\n    (instance: HTMLElement | HTMLDivElement | null) => {\n      if (!paginationEnabled) {\n        clearListeners();\n        scrollContainer.current = null;\n        return;\n      }\n      if (scrollContainer.current !== instance) {\n        clearListeners();\n\n        scrollContainer.current = instance;\n        if (scrollContainer.current) {\n          scrollContainer.current.addEventListener('scroll', onScroll);\n        }\n      }\n    },\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [onScroll, onScrollEnd, paginationEnabled],\n  );\n\n  return paginationRef;\n};\n"],"names":["useDynamicVirtualizerPagination","virtualizerProps","paginationEnabled","axis","currentIndex","progressiveItemSizes","virtualizerLength","setScrollTimer","clearScrollTimer","useTimeout","lastScrollPos","React","useRef","lastIndexScrolled","scrollContainer","clearListeners","current","removeEventListener","onScroll","useEffect","onScrollEnd","useCallback","currentScrollPos","Math","round","scrollTop","scrollLeft","closestItemPos","closestItem","endItem","min","length","i","distanceToPrev","abs","distanceToNext","nextItem","nextTarget","isSecondaryScroll","posMod","max","scrollTo","top","behavior","left","event","paginationRef","instance","addEventListener"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}