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

package/lib-commonjs/components/Virtualizer/useVirtualizer.js

@@ -10,21 +10,27 @@ Object.defineProperty(exports, "useVirtualizer_unstable", {
 });
 const _react = require("react");
 const _useIntersectionObserver = require("../../hooks/useIntersectionObserver");
-const _reactdom = require("react-dom");
 const _Utilities = require("../../Utilities");
 const _reactutilities = require("@fluentui/react-utilities");
+const _reactdom = require("react-dom");
 function useVirtualizer_unstable(props) {
     'use no memo';
-    const { itemSize, numItems, virtualizerLength, children: renderChild, getItemSize, bufferItems = Math.round(virtualizerLength / 4.0), bufferSize = Math.floor(bufferItems / 2.0) * itemSize, scrollViewRef, axis = 'vertical', reversed = false, virtualizerContext, onRenderedFlaggedIndex, imperativeVirtualizerRef } = props;
+    const { itemSize, numItems, virtualizerLength, children: renderChild, getItemSize, bufferItems = Math.round(virtualizerLength / 4.0), bufferSize = Math.floor(bufferItems / 2.0) * itemSize, axis = 'vertical', reversed = false, virtualizerContext, onRenderedFlaggedIndex, imperativeVirtualizerRef, containerSizeRef, scrollViewRef, enableScrollLoad } = props;
     /* The context is optional, it's useful for injecting additional index logic, or performing uniform state updates*/ const _virtualizerContext = (0, _Utilities.useVirtualizerContextState_unstable)(virtualizerContext);
     // We use this ref as a constant source to access the virtualizer's state imperatively
     const actualIndexRef = (0, _react.useRef)(_virtualizerContext.contextIndex);
-    if (actualIndexRef.current !== _virtualizerContext.contextIndex) {
-        actualIndexRef.current = _virtualizerContext.contextIndex;
-    }
     const flaggedIndex = (0, _react.useRef)(null);
     const actualIndex = _virtualizerContext.contextIndex;
-    const setActualIndex = _virtualizerContext.setContextIndex;
+    // Just in case our ref gets out of date vs the context during a re-render
+    if (_virtualizerContext.contextIndex !== actualIndexRef.current) {
+        actualIndexRef.current = _virtualizerContext.contextIndex;
+    }
+    const setActualIndex = (0, _react.useCallback)((index)=>{
+        actualIndexRef.current = index;
+        _virtualizerContext.setContextIndex(index);
+    }, [
+        _virtualizerContext
+    ]);
     // Store ref to before padding element
     const beforeElementRef = (0, _react.useRef)(null);
     // Store ref to before padding element
@@ -33,11 +39,11 @@ function useVirtualizer_unstable(props) {
     const childSizes = (0, _react.useRef)(new Array(getItemSize ? numItems : 0));
     /* We keep track of the progressive sizing/placement down the list,
   this helps us skip re-calculations unless children/size changes */ const childProgressiveSizes = (0, _react.useRef)(new Array(getItemSize ? numItems : 0));
+    if (virtualizerContext === null || virtualizerContext === void 0 ? void 0 : virtualizerContext.childProgressiveSizes) {
+        virtualizerContext.childProgressiveSizes.current = childProgressiveSizes.current;
+    }
     // The internal tracking REF for child array (updates often).
     const childArray = (0, _react.useRef)(new Array(virtualizerLength));
-    // We want to be methodical about updating the render with child reference array
-    const forceUpdate = (0, _react.useReducer)(()=>({}), {})[1];
-    const horizontal = axis === 'horizontal';
     const populateSizeArrays = ()=>{
         if (!getItemSize) {
             // Static sizes, never mind!
@@ -48,6 +54,9 @@ function useVirtualizer_unstable(props) {
         }
         if (numItems !== childProgressiveSizes.current.length) {
             childProgressiveSizes.current = new Array(numItems);
+            if (virtualizerContext === null || virtualizerContext === void 0 ? void 0 : virtualizerContext.childProgressiveSizes) {
+                virtualizerContext.childProgressiveSizes.current = childProgressiveSizes.current;
+            }
         }
         for(let index = 0; index < numItems; index++){
             childSizes.current[index] = getItemSize(index);
@@ -62,6 +71,10 @@ function useVirtualizer_unstable(props) {
     const [setScrollTimer, clearScrollTimer] = (0, _reactutilities.useTimeout)();
     const scrollCounter = (0, _react.useRef)(0);
     const initializeScrollingTimer = (0, _react.useCallback)(()=>{
+        if (!enableScrollLoad) {
+            // Disabled by default for reduction of render callbacks
+            return;
+        }
         /*
      * This can be considered the 'velocity' required to start 'isScrolling'
      * INIT_SCROLL_FLAG_REQ: Number of renders required to activate isScrolling
@@ -80,7 +93,8 @@ function useVirtualizer_unstable(props) {
         }, INIT_SCROLL_FLAG_DELAY);
     }, [
         clearScrollTimer,
-        setScrollTimer
+        setScrollTimer,
+        enableScrollLoad
     ]);
     (0, _react.useEffect)(()=>{
         initializeScrollingTimer();
@@ -88,97 +102,66 @@ function useVirtualizer_unstable(props) {
         actualIndex,
         initializeScrollingTimer
     ]);
-    const batchUpdateNewIndex = (index)=>{
-        // Local updates
-        updateChildRows(index);
-        updateCurrentItemSizes(index);
-        // Set before 'setActualIndex' call
-        // If it changes before render, or injected via context, re-render will update ref.
-        actualIndexRef.current = index;
-        // State setters
-        setActualIndex(index);
-    };
-    // Observe intersections of virtualized components
-    const { setObserverList } = (0, _useIntersectionObserver.useIntersectionObserver)(// eslint-disable-next-line no-restricted-globals
-    (entries, observer)=>{
-        /* Sanity check - do we even need virtualization? */ if (virtualizerLength > numItems) {
-            if (actualIndex !== 0) {
-                batchUpdateNewIndex(0);
-            }
-            // No-op
-            return;
+    const updateChildRows = (0, _react.useCallback)((newIndex)=>{
+        if (numItems === 0) {
+            /* Nothing to virtualize */ return;
         }
-        /* IO initiates this function when needed (bookend entering view) */ let measurementPos = 0;
-        let bufferCount = bufferItems;
-        // Grab latest entry that is intersecting
-        const latestEntry = entries.length === 1 ? entries[0] : entries.sort((entry1, entry2)=>entry2.time - entry1.time).find((entry)=>{
-            return entry.intersectionRatio > 0;
-        });
-        if (!latestEntry) {
-            // If we don't find an intersecting area, ignore for now.
+        /*
+        We reset the array every time to ensure children are re-rendered
+        This function should only be called when update is nessecary
+       */ childArray.current = new Array(virtualizerLength);
+        const _actualIndex = Math.max(newIndex, 0);
+        const end = Math.min(_actualIndex + virtualizerLength, numItems);
+        for(let i = _actualIndex; i < end; i++){
+            childArray.current[i - _actualIndex] = renderChild(i, isScrolling);
+        }
+    }, [
+        isScrolling,
+        numItems,
+        renderChild,
+        virtualizerLength
+    ]);
+    const updateCurrentItemSizes = (0, _react.useCallback)((newIndex)=>{
+        if (!getItemSize) {
+            // Static sizes, not required.
             return;
         }
-        if (latestEntry.target === afterElementRef.current) {
-            // We need to inverse the buffer count
-            bufferCount = virtualizerLength - bufferItems;
-            measurementPos = reversed ? calculateAfter() : calculateTotalSize() - calculateAfter();
-            if (!horizontal) {
-                if (reversed) {
-                    // Scrolling 'up' and hit the after element below
-                    measurementPos -= Math.abs(latestEntry.boundingClientRect.bottom);
-                } else if (latestEntry.boundingClientRect.top < 0) {
-                    // Scrolling 'down' and hit the after element above top: 0
-                    measurementPos -= latestEntry.boundingClientRect.top;
-                }
-            } else {
-                if (reversed) {
-                    // Scrolling 'left' and hit the after element
-                    measurementPos -= Math.abs(latestEntry.boundingClientRect.right);
-                } else if (latestEntry.boundingClientRect.left < 0) {
-                    // Scrolling 'right' and hit the after element
-                    measurementPos -= latestEntry.boundingClientRect.left;
-                }
-            }
-        } else if (latestEntry.target === beforeElementRef.current) {
-            measurementPos = reversed ? calculateTotalSize() - calculateBefore() : calculateBefore();
-            if (!horizontal) {
-                if (!reversed) {
-                    measurementPos -= Math.abs(latestEntry.boundingClientRect.bottom);
-                } else if (latestEntry.boundingClientRect.top < 0) {
-                    // Scrolling 'down' in reverse order and hit the before element above top: 0
-                    measurementPos -= latestEntry.boundingClientRect.top;
-                }
-            } else {
-                if (!reversed) {
-                    measurementPos -= Math.abs(latestEntry.boundingClientRect.right);
-                } else if (latestEntry.boundingClientRect.left < 0) {
-                    // Scrolling 'left' and hit before element
-                    measurementPos -= latestEntry.boundingClientRect.left;
-                }
+        // We should always call our size function on index change (only for the items that will be rendered)
+        // This ensures we request the latest data for incoming items in case sizing has changed.
+        const endIndex = Math.min(newIndex + virtualizerLength, numItems);
+        const startIndex = Math.max(newIndex, 0);
+        let didUpdate = false;
+        for(let i = startIndex; i < endIndex; i++){
+            const newSize = getItemSize(i);
+            if (newSize !== childSizes.current[i]) {
+                childSizes.current[i] = newSize;
+                didUpdate = true;
             }
         }
-        if (reversed) {
-            // We're reversed, up is down, left is right, invert the scroll measure.
-            measurementPos = Math.max(calculateTotalSize() - Math.abs(measurementPos), 0);
-        }
-        // For now lets use hardcoded size to assess current element to paginate on
-        const startIndex = getIndexFromScrollPosition(measurementPos);
-        const bufferedIndex = Math.max(startIndex - bufferCount, 0);
-        // Safety limits
-        const maxIndex = Math.max(numItems - virtualizerLength, 0);
-        const newStartIndex = Math.min(Math.max(bufferedIndex, 0), maxIndex);
-        if (actualIndex !== newStartIndex) {
-            // We flush sync this and perform an immediate state update
-            (0, _reactdom.flushSync)(()=>{
-                batchUpdateNewIndex(newStartIndex);
-            });
+        if (didUpdate) {
+            // Update our progressive size array
+            for(let i = startIndex; i < numItems; i++){
+                const prevSize = i > 0 ? childProgressiveSizes.current[i - 1] : 0;
+                childProgressiveSizes.current[i] = prevSize + childSizes.current[i];
+            }
         }
-    }, {
-        root: scrollViewRef ? scrollViewRef === null || scrollViewRef === void 0 ? void 0 : scrollViewRef.current : null,
-        rootMargin: '0px',
-        threshold: 0
-    });
-    const findIndexRecursive = (scrollPos, lowIndex, highIndex)=>{
+    }, [
+        getItemSize,
+        numItems,
+        virtualizerLength
+    ]);
+    const batchUpdateNewIndex = (0, _react.useCallback)((index)=>{
+        // Local updates
+        updateChildRows(index);
+        updateCurrentItemSizes(index);
+        // State setters
+        setActualIndex(index);
+    }, [
+        setActualIndex,
+        updateChildRows,
+        updateCurrentItemSizes
+    ]);
+    const findIndexRecursive = (0, _react.useCallback)((scrollPos, lowIndex, highIndex)=>{
         if (lowIndex > highIndex) {
             // We shouldn't get here - but no-op the index if we do.
             return actualIndex;
@@ -198,8 +181,10 @@ function useVirtualizer_unstable(props) {
         } else {
             return findIndexRecursive(scrollPos, midpoint + 1, highIndex);
         }
-    };
-    const getIndexFromSizeArray = (scrollPos)=>{
+    }, [
+        actualIndex
+    ]);
+    const getIndexFromSizeArray = (0, _react.useCallback)((scrollPos)=>{
         /* Quick searches our progressive height array */ if (scrollPos === 0 || childProgressiveSizes.current.length === 0 || scrollPos <= childProgressiveSizes.current[0]) {
             // Check start
             return 0;
@@ -209,13 +194,19 @@ function useVirtualizer_unstable(props) {
             return childProgressiveSizes.current.length - 1;
         }
         return findIndexRecursive(scrollPos, 0, childProgressiveSizes.current.length - 1);
-    };
-    const getIndexFromScrollPosition = (scrollPos)=>{
+    }, [
+        findIndexRecursive
+    ]);
+    const getIndexFromScrollPosition = (0, _react.useCallback)((scrollPos)=>{
         if (!getItemSize) {
             return Math.round(scrollPos / itemSize);
         }
         return getIndexFromSizeArray(scrollPos);
-    };
+    }, [
+        getIndexFromSizeArray,
+        getItemSize,
+        itemSize
+    ]);
     const calculateTotalSize = (0, _react.useCallback)(()=>{
         if (!getItemSize) {
             return itemSize * numItems;
@@ -263,25 +254,117 @@ function useVirtualizer_unstable(props) {
         numItems,
         virtualizerLength
     ]);
-    const updateChildRows = (0, _react.useCallback)((newIndex)=>{
-        if (numItems === 0) {
-            /* Nothing to virtualize */ return;
+    // Observe intersections of virtualized components
+    const { setObserverList } = (0, _useIntersectionObserver.useIntersectionObserver)((0, _react.useCallback)(// eslint-disable-next-line no-restricted-globals
+    (entries, observer)=>{
+        /* Sanity check - do we even need virtualization? */ if (virtualizerLength > numItems) {
+            if (actualIndex !== 0) {
+                batchUpdateNewIndex(0);
+            }
+            // No-op
+            return;
         }
-        /*
-        We reset the array every time to ensure children are re-rendered
-        This function should only be called when update is nessecary
-       */ childArray.current = new Array(virtualizerLength);
-        const _actualIndex = Math.max(newIndex, 0);
-        const end = Math.min(_actualIndex + virtualizerLength, numItems);
-        for(let i = _actualIndex; i < end; i++){
-            childArray.current[i - _actualIndex] = renderChild(i, isScrolling);
+        // Grab latest entry that is intersecting
+        const latestEntry = entries.length === 1 ? entries[0] : entries.sort((entry1, entry2)=>entry2.time - entry1.time).find((entry)=>{
+            return entry.intersectionRatio > 0;
+        });
+        if (!latestEntry || !latestEntry.isIntersecting) {
+            // If we don't find an intersecting area, ignore for now.
+            return;
         }
+        // We have to be sure our item sizes are up to date with current indexed ref before calculation
+        // Check if we still need
+        updateCurrentItemSizes(actualIndexRef.current);
+        const calculateOverBuffer = ()=>{
+            /**
+           * We avoid using the scroll ref scrollTop, it may be incorrect
+           * as virtualization may exist within a scroll view with other elements
+           * The benefit of using IO is that we can detect relative scrolls,
+           * so any items can be placed around the virtualizer in the scroll view
+           */ let measurementPos = 0;
+            if (latestEntry.target === afterElementRef.current) {
+                // Get after buffers position
+                measurementPos = calculateTotalSize() - calculateAfter();
+                // Get exact intersection position based on overflow size (how far into IO did we scroll?)
+                const overflowAmount = axis === 'vertical' ? latestEntry.intersectionRect.height : latestEntry.intersectionRect.width;
+                // Add to original after position
+                measurementPos += overflowAmount;
+                // Ignore buffer size (IO offset)
+                measurementPos -= bufferSize;
+                var _containerSizeRef_current;
+                // we hit the after buffer and detected the end of view, we need to find the start index.
+                measurementPos -= (_containerSizeRef_current = containerSizeRef.current) !== null && _containerSizeRef_current !== void 0 ? _containerSizeRef_current : 0;
+                // Calculate how far past the window bounds we are (this will be zero if IO is within window)
+                const hOverflow = latestEntry.boundingClientRect.top - latestEntry.intersectionRect.top;
+                const hOverflowReversed = latestEntry.boundingClientRect.bottom - latestEntry.intersectionRect.bottom;
+                const wOverflow = latestEntry.boundingClientRect.left - latestEntry.intersectionRect.left;
+                const wOverflowReversed = latestEntry.boundingClientRect.right - latestEntry.intersectionRect.right;
+                const widthOverflow = reversed ? wOverflowReversed : wOverflow;
+                const heightOverflow = reversed ? hOverflowReversed : hOverflow;
+                const additionalOverflow = axis === 'vertical' ? heightOverflow : widthOverflow;
+                if (reversed) {
+                    measurementPos += additionalOverflow;
+                } else {
+                    measurementPos -= additionalOverflow;
+                }
+            } else if (latestEntry.target === beforeElementRef.current) {
+                // Get before buffers position
+                measurementPos = calculateBefore();
+                // Get exact intersection position based on overflow size (how far into window did we scroll IO?)
+                const overflowAmount = axis === 'vertical' ? latestEntry.intersectionRect.height : latestEntry.intersectionRect.width;
+                // Minus from original before position
+                measurementPos -= overflowAmount;
+                // Ignore buffer size (IO offset)
+                measurementPos += bufferSize;
+                // Calculate how far past the window bounds we are (this will be zero if IO is within window)
+                const hOverflow = latestEntry.boundingClientRect.bottom - latestEntry.intersectionRect.bottom;
+                const hOverflowReversed = latestEntry.boundingClientRect.top - latestEntry.intersectionRect.top;
+                const wOverflow = latestEntry.boundingClientRect.right - latestEntry.intersectionRect.right;
+                const wOverflowReversed = latestEntry.boundingClientRect.left - latestEntry.intersectionRect.left;
+                const widthOverflow = reversed ? wOverflowReversed : wOverflow;
+                const heightOverflow = reversed ? hOverflowReversed : hOverflow;
+                const additionalOverflow = axis === 'vertical' ? heightOverflow : widthOverflow;
+                if (reversed) {
+                    measurementPos += additionalOverflow;
+                } else {
+                    measurementPos -= additionalOverflow;
+                }
+            }
+            return measurementPos;
+        };
+        // Get exact relative 'scrollTop' via IO values
+        const measurementPos = calculateOverBuffer();
+        const maxIndex = Math.max(numItems - virtualizerLength, 0);
+        const startIndex = getIndexFromScrollPosition(measurementPos) - bufferItems;
+        // Safety limits
+        const newStartIndex = Math.min(Math.max(startIndex, 0), maxIndex);
+        (0, _reactdom.flushSync)(()=>{
+            _virtualizerContext.setContextPosition(measurementPos);
+            if (actualIndex !== newStartIndex) {
+                batchUpdateNewIndex(newStartIndex);
+            }
+        });
     }, [
-        isScrolling,
+        _virtualizerContext,
+        actualIndex,
+        axis,
+        batchUpdateNewIndex,
+        bufferItems,
+        bufferSize,
+        calculateAfter,
+        calculateBefore,
+        calculateTotalSize,
+        containerSizeRef,
+        getIndexFromScrollPosition,
         numItems,
-        renderChild,
+        reversed,
+        updateCurrentItemSizes,
         virtualizerLength
-    ]);
+    ]), {
+        root: scrollViewRef ? scrollViewRef === null || scrollViewRef === void 0 ? void 0 : scrollViewRef.current : null,
+        rootMargin: '0px',
+        threshold: 0
+    });
     const setBeforeRef = (0, _react.useCallback)((element)=>{
         if (!element || beforeElementRef.current === element) {
             return;
@@ -312,31 +395,6 @@ function useVirtualizer_unstable(props) {
     }, [
         setObserverList
     ]);
-    const updateCurrentItemSizes = (newIndex)=>{
-        if (!getItemSize) {
-            // Static sizes, not required.
-            return;
-        }
-        // We should always call our size function on index change (only for the items that will be rendered)
-        // This ensures we request the latest data for incoming items in case sizing has changed.
-        const endIndex = Math.min(newIndex + virtualizerLength, numItems);
-        const startIndex = Math.max(newIndex, 0);
-        let didUpdate = false;
-        for(let i = startIndex; i < endIndex; i++){
-            const newSize = getItemSize(i);
-            if (newSize !== childSizes.current[i]) {
-                childSizes.current[i] = newSize;
-                didUpdate = true;
-            }
-        }
-        if (didUpdate) {
-            // Update our progressive size array
-            for(let i = startIndex; i < numItems; i++){
-                const prevSize = i > 0 ? childProgressiveSizes.current[i - 1] : 0;
-                childProgressiveSizes.current[i] = prevSize + childSizes.current[i];
-            }
-        }
-    };
     // Initialize the size array before first render.
     const hasInitialized = (0, _react.useRef)(false);
     const initializeSizeArray = ()=>{
@@ -364,16 +422,23 @@ function useVirtualizer_unstable(props) {
         }
     // eslint-disable-next-line react-hooks/exhaustive-deps
     }, []);
+    /*
+   * forceUpdate:
+   * We only want to trigger this when scrollLoading is enabled and set to false,
+   * it will force re-render all children elements
+   */ const forceUpdate = (0, _react.useReducer)(()=>({}), {})[1];
     // If the user passes in an updated renderChild function - update current children
     (0, _react.useEffect)(()=>{
         if (actualIndex >= 0) {
             updateChildRows(actualIndex);
-            forceUpdate();
+            if (enableScrollLoad && !isScrolling) {
+                forceUpdate();
+            }
         }
     // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [
         renderChild,
-        updateChildRows
+        isScrolling
     ]);
     (0, _react.useEffect)(()=>{
         // Ensure we repopulate if getItemSize callback changes

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

@@ -1 +1 @@
-{"version":3,"sources":["useVirtualizer.ts"],"sourcesContent":["import type { ReactNode } from 'react';\nimport type { VirtualizerProps, VirtualizerState } from './Virtualizer.types';\n\nimport { useEffect, useRef, useCallback, useReducer, useImperativeHandle, useState } from 'react';\nimport { useIntersectionObserver } from '../../hooks/useIntersectionObserver';\nimport { flushSync } from 'react-dom';\nimport { useVirtualizerContextState_unstable } from '../../Utilities';\nimport { slot, useTimeout } from '@fluentui/react-utilities';\n\nexport function useVirtualizer_unstable(props: VirtualizerProps): VirtualizerState {\n  'use no memo';\n\n  const {\n    itemSize,\n    numItems,\n    virtualizerLength,\n    children: renderChild,\n    getItemSize,\n    bufferItems = Math.round(virtualizerLength / 4.0),\n    bufferSize = Math.floor(bufferItems / 2.0) * itemSize,\n    scrollViewRef,\n    axis = 'vertical',\n    reversed = false,\n    virtualizerContext,\n    onRenderedFlaggedIndex,\n    imperativeVirtualizerRef,\n  } = props;\n\n  /* The context is optional, it's useful for injecting additional index logic, or performing uniform state updates*/\n  const _virtualizerContext = useVirtualizerContextState_unstable(virtualizerContext);\n\n  // We use this ref as a constant source to access the virtualizer's state imperatively\n  const actualIndexRef = useRef<number>(_virtualizerContext.contextIndex);\n  if (actualIndexRef.current !== _virtualizerContext.contextIndex) {\n    actualIndexRef.current = _virtualizerContext.contextIndex;\n  }\n  const flaggedIndex = useRef<number | null>(null);\n\n  const actualIndex = _virtualizerContext.contextIndex;\n  const setActualIndex = _virtualizerContext.setContextIndex;\n\n  // Store ref to before padding element\n  const beforeElementRef = useRef<Element | null>(null);\n\n  // Store ref to before padding element\n  const afterElementRef = useRef<Element | null>(null);\n\n  // We need to store an array to track dynamic sizes, we can use this to incrementally update changes\n  const childSizes = useRef<number[]>(new Array<number>(getItemSize ? numItems : 0));\n\n  /* We keep track of the progressive sizing/placement down the list,\n  this helps us skip re-calculations unless children/size changes */\n  const childProgressiveSizes = useRef<number[]>(new Array<number>(getItemSize ? numItems : 0));\n\n  // The internal tracking REF for child array (updates often).\n  const childArray = useRef<ReactNode[]>(new Array(virtualizerLength));\n\n  // We want to be methodical about updating the render with child reference array\n  const forceUpdate = useReducer(() => ({}), {})[1];\n\n  const horizontal = axis === 'horizontal';\n\n  const populateSizeArrays = () => {\n    if (!getItemSize) {\n      // Static sizes, never mind!\n      return;\n    }\n\n    if (numItems !== childSizes.current.length) {\n      childSizes.current = new Array<number>(numItems);\n    }\n\n    if (numItems !== childProgressiveSizes.current.length) {\n      childProgressiveSizes.current = new Array<number>(numItems);\n    }\n\n    for (let index = 0; index < numItems; index++) {\n      childSizes.current[index] = getItemSize(index);\n      if (index === 0) {\n        childProgressiveSizes.current[index] = childSizes.current[index];\n      } else {\n        childProgressiveSizes.current[index] = childProgressiveSizes.current[index - 1] + childSizes.current[index];\n      }\n    }\n  };\n\n  const [isScrolling, setIsScrolling] = useState<boolean>(false);\n  const [setScrollTimer, clearScrollTimer] = useTimeout();\n  const scrollCounter = useRef<number>(0);\n\n  const initializeScrollingTimer = useCallback(() => {\n    /*\n     * This can be considered the 'velocity' required to start 'isScrolling'\n     * INIT_SCROLL_FLAG_REQ: Number of renders required to activate isScrolling\n     * INIT_SCROLL_FLAG_DELAY: Amount of time (ms) before current number of renders is reset\n     *  - Maybe we should let users customize these in the future.\n     */\n    const INIT_SCROLL_FLAG_REQ = 10;\n    const INIT_SCROLL_FLAG_DELAY = 100;\n\n    scrollCounter.current++;\n    if (scrollCounter.current >= INIT_SCROLL_FLAG_REQ) {\n      setIsScrolling(true);\n    }\n    clearScrollTimer();\n    setScrollTimer(() => {\n      setIsScrolling(false);\n      scrollCounter.current = 0;\n    }, INIT_SCROLL_FLAG_DELAY);\n  }, [clearScrollTimer, setScrollTimer]);\n\n  useEffect(() => {\n    initializeScrollingTimer();\n  }, [actualIndex, initializeScrollingTimer]);\n\n  const batchUpdateNewIndex = (index: number) => {\n    // Local updates\n    updateChildRows(index);\n    updateCurrentItemSizes(index);\n\n    // Set before 'setActualIndex' call\n    // If it changes before render, or injected via context, re-render will update ref.\n    actualIndexRef.current = index;\n\n    // State setters\n    setActualIndex(index);\n  };\n\n  // Observe intersections of virtualized components\n  const { setObserverList } = useIntersectionObserver(\n    // TODO: exclude types from this lint rule: https://github.com/microsoft/fluentui/issues/31286\n    // eslint-disable-next-line no-restricted-globals\n    (entries: IntersectionObserverEntry[], observer: IntersectionObserver) => {\n      /* Sanity check - do we even need virtualization? */\n      if (virtualizerLength > numItems) {\n        if (actualIndex !== 0) {\n          batchUpdateNewIndex(0);\n        }\n        // No-op\n        return;\n      }\n\n      /* IO initiates this function when needed (bookend entering view) */\n      let measurementPos = 0;\n      let bufferCount = bufferItems;\n\n      // Grab latest entry that is intersecting\n      const latestEntry =\n        entries.length === 1\n          ? entries[0]\n          : entries\n              .sort((entry1, entry2) => entry2.time - entry1.time)\n              .find(entry => {\n                return entry.intersectionRatio > 0;\n              });\n\n      if (!latestEntry) {\n        // If we don't find an intersecting area, ignore for now.\n        return;\n      }\n\n      if (latestEntry.target === afterElementRef.current) {\n        // We need to inverse the buffer count\n        bufferCount = virtualizerLength - bufferItems;\n        measurementPos = reversed ? calculateAfter() : calculateTotalSize() - calculateAfter();\n        if (!horizontal) {\n          if (reversed) {\n            // Scrolling 'up' and hit the after element below\n            measurementPos -= Math.abs(latestEntry.boundingClientRect.bottom);\n          } else if (latestEntry.boundingClientRect.top < 0) {\n            // Scrolling 'down' and hit the after element above top: 0\n            measurementPos -= latestEntry.boundingClientRect.top;\n          }\n        } else {\n          if (reversed) {\n            // Scrolling 'left' and hit the after element\n            measurementPos -= Math.abs(latestEntry.boundingClientRect.right);\n          } else if (latestEntry.boundingClientRect.left < 0) {\n            // Scrolling 'right' and hit the after element\n            measurementPos -= latestEntry.boundingClientRect.left;\n          }\n        }\n      } else if (latestEntry.target === beforeElementRef.current) {\n        measurementPos = reversed ? calculateTotalSize() - calculateBefore() : calculateBefore();\n        if (!horizontal) {\n          if (!reversed) {\n            measurementPos -= Math.abs(latestEntry.boundingClientRect.bottom);\n          } else if (latestEntry.boundingClientRect.top < 0) {\n            // Scrolling 'down' in reverse order and hit the before element above top: 0\n            measurementPos -= latestEntry.boundingClientRect.top;\n          }\n        } else {\n          if (!reversed) {\n            measurementPos -= Math.abs(latestEntry.boundingClientRect.right);\n          } else if (latestEntry.boundingClientRect.left < 0) {\n            // Scrolling 'left' and hit before element\n            measurementPos -= latestEntry.boundingClientRect.left;\n          }\n        }\n      }\n\n      if (reversed) {\n        // We're reversed, up is down, left is right, invert the scroll measure.\n        measurementPos = Math.max(calculateTotalSize() - Math.abs(measurementPos), 0);\n      }\n\n      // For now lets use hardcoded size to assess current element to paginate on\n      const startIndex = getIndexFromScrollPosition(measurementPos);\n      const bufferedIndex = Math.max(startIndex - bufferCount, 0);\n\n      // Safety limits\n      const maxIndex = Math.max(numItems - virtualizerLength, 0);\n      const newStartIndex = Math.min(Math.max(bufferedIndex, 0), maxIndex);\n\n      if (actualIndex !== newStartIndex) {\n        // We flush sync this and perform an immediate state update\n        flushSync(() => {\n          batchUpdateNewIndex(newStartIndex);\n        });\n      }\n    },\n    {\n      root: scrollViewRef ? scrollViewRef?.current : null,\n      rootMargin: '0px',\n      threshold: 0,\n    },\n  );\n\n  const findIndexRecursive = (scrollPos: number, lowIndex: number, highIndex: number): number => {\n    if (lowIndex > highIndex) {\n      // We shouldn't get here - but no-op the index if we do.\n      return actualIndex;\n    }\n    const midpoint = Math.floor((lowIndex + highIndex) / 2);\n    const iBefore = Math.max(midpoint - 1, 0);\n    const iAfter = Math.min(midpoint + 1, childProgressiveSizes.current.length - 1);\n    const indexValue = childProgressiveSizes.current[midpoint];\n    const afterIndexValue = childProgressiveSizes.current[iAfter];\n    const beforeIndexValue = childProgressiveSizes.current[iBefore];\n    if (scrollPos <= afterIndexValue && scrollPos >= beforeIndexValue) {\n      /* We've found our index - if we are exactly matching before/after index that's ok,\n      better to reduce checks if it's right on the boundary. */\n      return midpoint;\n    }\n\n    if (indexValue > scrollPos) {\n      return findIndexRecursive(scrollPos, lowIndex, midpoint - 1);\n    } else {\n      return findIndexRecursive(scrollPos, midpoint + 1, highIndex);\n    }\n  };\n\n  const getIndexFromSizeArray = (scrollPos: number): number => {\n    /* Quick searches our progressive height array */\n    if (\n      scrollPos === 0 ||\n      childProgressiveSizes.current.length === 0 ||\n      scrollPos <= childProgressiveSizes.current[0]\n    ) {\n      // Check start\n      return 0;\n    }\n\n    if (scrollPos >= childProgressiveSizes.current[childProgressiveSizes.current.length - 1]) {\n      // Check end\n      return childProgressiveSizes.current.length - 1;\n    }\n\n    return findIndexRecursive(scrollPos, 0, childProgressiveSizes.current.length - 1);\n  };\n\n  const getIndexFromScrollPosition = (scrollPos: number) => {\n    if (!getItemSize) {\n      return Math.round(scrollPos / itemSize);\n    }\n\n    return getIndexFromSizeArray(scrollPos);\n  };\n\n  const calculateTotalSize = useCallback(() => {\n    if (!getItemSize) {\n      return itemSize * numItems;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[numItems - 1];\n  }, [getItemSize, itemSize, numItems]);\n\n  const calculateBefore = useCallback(() => {\n    const currentIndex = Math.min(actualIndex, numItems - 1);\n\n    if (!getItemSize) {\n      // The missing items from before virtualization starts height\n      return currentIndex * itemSize;\n    }\n\n    if (currentIndex <= 0) {\n      return 0;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[currentIndex - 1];\n  }, [actualIndex, getItemSize, itemSize, numItems]);\n\n  const calculateAfter = useCallback(() => {\n    if (numItems === 0 || actualIndex + virtualizerLength >= numItems) {\n      return 0;\n    }\n\n    const lastItemIndex = Math.min(actualIndex + virtualizerLength, numItems);\n    if (!getItemSize) {\n      // The missing items from after virtualization ends height\n      const remainingItems = numItems - lastItemIndex;\n      return remainingItems * itemSize;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[numItems - 1] - childProgressiveSizes.current[lastItemIndex - 1];\n  }, [actualIndex, getItemSize, itemSize, numItems, virtualizerLength]);\n\n  const updateChildRows = useCallback(\n    (newIndex: number) => {\n      if (numItems === 0) {\n        /* Nothing to virtualize */\n        return;\n      }\n\n      /*\n        We reset the array every time to ensure children are re-rendered\n        This function should only be called when update is nessecary\n       */\n      childArray.current = new Array(virtualizerLength);\n      const _actualIndex = Math.max(newIndex, 0);\n      const end = Math.min(_actualIndex + virtualizerLength, numItems);\n      for (let i = _actualIndex; i < end; i++) {\n        childArray.current[i - _actualIndex] = renderChild(i, isScrolling);\n      }\n    },\n    [isScrolling, numItems, renderChild, virtualizerLength],\n  );\n\n  const setBeforeRef = useCallback(\n    (element: HTMLDivElement) => {\n      if (!element || beforeElementRef.current === element) {\n        return;\n      }\n      beforeElementRef.current = element;\n      const newList = [];\n\n      newList.push(beforeElementRef.current);\n\n      if (afterElementRef.current) {\n        newList.push(afterElementRef.current);\n      }\n\n      // Ensure we update array if before element changed\n      setObserverList(newList);\n    },\n    [setObserverList],\n  );\n\n  const setAfterRef = useCallback(\n    (element: HTMLDivElement) => {\n      if (!element || afterElementRef.current === element) {\n        return;\n      }\n      afterElementRef.current = element;\n      const newList = [];\n\n      if (beforeElementRef.current) {\n        newList.push(beforeElementRef.current);\n      }\n\n      newList.push(afterElementRef.current);\n\n      // Ensure we update array if after element changed\n      setObserverList(newList);\n    },\n    [setObserverList],\n  );\n\n  const updateCurrentItemSizes = (newIndex: number) => {\n    if (!getItemSize) {\n      // Static sizes, not required.\n      return;\n    }\n    // We should always call our size function on index change (only for the items that will be rendered)\n    // This ensures we request the latest data for incoming items in case sizing has changed.\n    const endIndex = Math.min(newIndex + virtualizerLength, numItems);\n    const startIndex = Math.max(newIndex, 0);\n\n    let didUpdate = false;\n    for (let i = startIndex; i < endIndex; i++) {\n      const newSize = getItemSize(i);\n      if (newSize !== childSizes.current[i]) {\n        childSizes.current[i] = newSize;\n        didUpdate = true;\n      }\n    }\n\n    if (didUpdate) {\n      // Update our progressive size array\n      for (let i = startIndex; i < numItems; i++) {\n        const prevSize = i > 0 ? childProgressiveSizes.current[i - 1] : 0;\n        childProgressiveSizes.current[i] = prevSize + childSizes.current[i];\n      }\n    }\n  };\n\n  // Initialize the size array before first render.\n  const hasInitialized = useRef<boolean>(false);\n  const initializeSizeArray = () => {\n    if (hasInitialized.current === false) {\n      hasInitialized.current = true;\n      populateSizeArrays();\n    }\n  };\n\n  useImperativeHandle(\n    imperativeVirtualizerRef,\n    () => {\n      return {\n        progressiveSizes: childProgressiveSizes,\n        nodeSizes: childSizes,\n        setFlaggedIndex: (index: number | null) => (flaggedIndex.current = index),\n        currentIndex: actualIndexRef,\n      };\n    },\n    [childProgressiveSizes, childSizes],\n  );\n\n  // Initialization on mount - update array index to 0 (ready state).\n  // Only fire on mount (no deps).\n  useEffect(() => {\n    if (actualIndex < 0) {\n      batchUpdateNewIndex(0);\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  // If the user passes in an updated renderChild function - update current children\n  useEffect(() => {\n    if (actualIndex >= 0) {\n      updateChildRows(actualIndex);\n      forceUpdate();\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [renderChild, updateChildRows]);\n\n  useEffect(() => {\n    // Ensure we repopulate if getItemSize callback changes\n    populateSizeArrays();\n\n    // We only run this effect on getItemSize change (recalc dynamic sizes)\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [getItemSize]);\n\n  // Effect to check flag index on updates\n  useEffect(() => {\n    if (!onRenderedFlaggedIndex || flaggedIndex.current === null) {\n      return;\n    }\n    if (actualIndex <= flaggedIndex.current && actualIndex + virtualizerLength >= flaggedIndex.current) {\n      onRenderedFlaggedIndex(flaggedIndex.current);\n      flaggedIndex.current = null;\n    }\n  }, [actualIndex, onRenderedFlaggedIndex, virtualizerLength]);\n\n  // Ensure we have run through and updated the whole size list array at least once.\n  initializeSizeArray();\n\n  if (getItemSize && (numItems !== childSizes.current.length || numItems !== childProgressiveSizes.current.length)) {\n    // Child length mismatch, repopulate size arrays.\n    populateSizeArrays();\n  }\n\n  // Ensure we recalc if virtualizer length changes\n  const maxCompare = Math.min(virtualizerLength, numItems);\n  if (childArray.current.length !== maxCompare && actualIndex + childArray.current.length < numItems) {\n    updateChildRows(actualIndex);\n  }\n\n  const isFullyInitialized = hasInitialized.current && actualIndex >= 0;\n  return {\n    components: {\n      before: 'div',\n      after: 'div',\n      beforeContainer: 'div',\n      afterContainer: 'div',\n    },\n    virtualizedChildren: childArray.current,\n    before: slot.always(props.before, {\n      defaultProps: {\n        ref: setBeforeRef,\n        role: 'none',\n      },\n      elementType: 'div',\n    }),\n    after: slot.always(props.after, {\n      defaultProps: {\n        ref: setAfterRef,\n        role: 'none',\n      },\n      elementType: 'div',\n    }),\n    beforeContainer: slot.always(props.beforeContainer, {\n      defaultProps: {\n        role: 'none',\n      },\n      elementType: 'div',\n    }),\n    afterContainer: slot.always(props.afterContainer, {\n      defaultProps: {\n        role: 'none',\n      },\n      elementType: 'div',\n    }),\n    beforeBufferHeight: isFullyInitialized ? calculateBefore() : 0,\n    afterBufferHeight: isFullyInitialized ? calculateAfter() : 0,\n    totalVirtualizerHeight: isFullyInitialized ? calculateTotalSize() : virtualizerLength * itemSize,\n    virtualizerStartIndex: actualIndex,\n    axis,\n    bufferSize,\n    reversed,\n    childSizes,\n    childProgressiveSizes,\n  };\n}\n"],"names":["useVirtualizer_unstable","props","itemSize","numItems","virtualizerLength","children","renderChild","getItemSize","bufferItems","Math","round","bufferSize","floor","scrollViewRef","axis","reversed","virtualizerContext","onRenderedFlaggedIndex","imperativeVirtualizerRef","_virtualizerContext","useVirtualizerContextState_unstable","actualIndexRef","useRef","contextIndex","current","flaggedIndex","actualIndex","setActualIndex","setContextIndex","beforeElementRef","afterElementRef","childSizes","Array","childProgressiveSizes","childArray","forceUpdate","useReducer","horizontal","populateSizeArrays","length","index","isScrolling","setIsScrolling","useState","setScrollTimer","clearScrollTimer","useTimeout","scrollCounter","initializeScrollingTimer","useCallback","INIT_SCROLL_FLAG_REQ","INIT_SCROLL_FLAG_DELAY","useEffect","batchUpdateNewIndex","updateChildRows","updateCurrentItemSizes","setObserverList","useIntersectionObserver","entries","observer","measurementPos","bufferCount","latestEntry","sort","entry1","entry2","time","find","entry","intersectionRatio","target","calculateAfter","calculateTotalSize","abs","boundingClientRect","bottom","top","right","left","calculateBefore","max","startIndex","getIndexFromScrollPosition","bufferedIndex","maxIndex","newStartIndex","min","flushSync","root","rootMargin","threshold","findIndexRecursive","scrollPos","lowIndex","highIndex","midpoint","iBefore","iAfter","indexValue","afterIndexValue","beforeIndexValue","getIndexFromSizeArray","currentIndex","lastItemIndex","remainingItems","newIndex","_actualIndex","end","i","setBeforeRef","element","newList","push","setAfterRef","endIndex","didUpdate","newSize","prevSize","hasInitialized","initializeSizeArray","useImperativeHandle","progressiveSizes","nodeSizes","setFlaggedIndex","maxCompare","isFullyInitialized","components","before","after","beforeContainer","afterContainer","virtualizedChildren","slot","always","defaultProps","ref","role","elementType","beforeBufferHeight","afterBufferHeight","totalVirtualizerHeight","virtualizerStartIndex"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["useVirtualizer.ts"],"sourcesContent":["import type { ReactNode } from 'react';\nimport type { VirtualizerProps, VirtualizerState } from './Virtualizer.types';\n\nimport { useEffect, useRef, useCallback, useImperativeHandle, useState, useReducer } from 'react';\nimport { useIntersectionObserver } from '../../hooks/useIntersectionObserver';\nimport { useVirtualizerContextState_unstable } from '../../Utilities';\nimport { slot, useTimeout } from '@fluentui/react-utilities';\nimport { flushSync } from 'react-dom';\n\nexport function useVirtualizer_unstable(props: VirtualizerProps): VirtualizerState {\n  'use no memo';\n\n  const {\n    itemSize,\n    numItems,\n    virtualizerLength,\n    children: renderChild,\n    getItemSize,\n    bufferItems = Math.round(virtualizerLength / 4.0),\n    bufferSize = Math.floor(bufferItems / 2.0) * itemSize,\n    axis = 'vertical',\n    reversed = false,\n    virtualizerContext,\n    onRenderedFlaggedIndex,\n    imperativeVirtualizerRef,\n    containerSizeRef,\n    scrollViewRef,\n    enableScrollLoad,\n  } = props;\n\n  /* The context is optional, it's useful for injecting additional index logic, or performing uniform state updates*/\n  const _virtualizerContext = useVirtualizerContextState_unstable(virtualizerContext);\n\n  // We use this ref as a constant source to access the virtualizer's state imperatively\n  const actualIndexRef = useRef<number>(_virtualizerContext.contextIndex);\n  const flaggedIndex = useRef<number | null>(null);\n\n  const actualIndex = _virtualizerContext.contextIndex;\n  // Just in case our ref gets out of date vs the context during a re-render\n  if (_virtualizerContext.contextIndex !== actualIndexRef.current) {\n    actualIndexRef.current = _virtualizerContext.contextIndex;\n  }\n  const setActualIndex = useCallback(\n    (index: number) => {\n      actualIndexRef.current = index;\n      _virtualizerContext.setContextIndex(index);\n    },\n    [_virtualizerContext],\n  );\n\n  // Store ref to before padding element\n  const beforeElementRef = useRef<Element | null>(null);\n\n  // Store ref to before padding element\n  const afterElementRef = useRef<Element | null>(null);\n\n  // We need to store an array to track dynamic sizes, we can use this to incrementally update changes\n  const childSizes = useRef<number[]>(new Array<number>(getItemSize ? numItems : 0));\n\n  /* We keep track of the progressive sizing/placement down the list,\n  this helps us skip re-calculations unless children/size changes */\n  const childProgressiveSizes = useRef<number[]>(new Array<number>(getItemSize ? numItems : 0));\n  if (virtualizerContext?.childProgressiveSizes) {\n    virtualizerContext.childProgressiveSizes.current = childProgressiveSizes.current;\n  }\n\n  // The internal tracking REF for child array (updates often).\n  const childArray = useRef<ReactNode[]>(new Array(virtualizerLength));\n\n  const populateSizeArrays = () => {\n    if (!getItemSize) {\n      // Static sizes, never mind!\n      return;\n    }\n\n    if (numItems !== childSizes.current.length) {\n      childSizes.current = new Array<number>(numItems);\n    }\n\n    if (numItems !== childProgressiveSizes.current.length) {\n      childProgressiveSizes.current = new Array<number>(numItems);\n      if (virtualizerContext?.childProgressiveSizes) {\n        virtualizerContext.childProgressiveSizes.current = childProgressiveSizes.current;\n      }\n    }\n\n    for (let index = 0; index < numItems; index++) {\n      childSizes.current[index] = getItemSize(index);\n      if (index === 0) {\n        childProgressiveSizes.current[index] = childSizes.current[index];\n      } else {\n        childProgressiveSizes.current[index] = childProgressiveSizes.current[index - 1] + childSizes.current[index];\n      }\n    }\n  };\n\n  const [isScrolling, setIsScrolling] = useState<boolean>(false);\n  const [setScrollTimer, clearScrollTimer] = useTimeout();\n  const scrollCounter = useRef<number>(0);\n\n  const initializeScrollingTimer = useCallback(() => {\n    if (!enableScrollLoad) {\n      // Disabled by default for reduction of render callbacks\n      return;\n    }\n    /*\n     * This can be considered the 'velocity' required to start 'isScrolling'\n     * INIT_SCROLL_FLAG_REQ: Number of renders required to activate isScrolling\n     * INIT_SCROLL_FLAG_DELAY: Amount of time (ms) before current number of renders is reset\n     *  - Maybe we should let users customize these in the future.\n     */\n    const INIT_SCROLL_FLAG_REQ = 10;\n    const INIT_SCROLL_FLAG_DELAY = 100;\n\n    scrollCounter.current++;\n    if (scrollCounter.current >= INIT_SCROLL_FLAG_REQ) {\n      setIsScrolling(true);\n    }\n    clearScrollTimer();\n    setScrollTimer(() => {\n      setIsScrolling(false);\n      scrollCounter.current = 0;\n    }, INIT_SCROLL_FLAG_DELAY);\n  }, [clearScrollTimer, setScrollTimer, enableScrollLoad]);\n\n  useEffect(() => {\n    initializeScrollingTimer();\n  }, [actualIndex, initializeScrollingTimer]);\n\n  const updateChildRows = useCallback(\n    (newIndex: number) => {\n      if (numItems === 0) {\n        /* Nothing to virtualize */\n        return;\n      }\n\n      /*\n        We reset the array every time to ensure children are re-rendered\n        This function should only be called when update is nessecary\n       */\n      childArray.current = new Array(virtualizerLength);\n      const _actualIndex = Math.max(newIndex, 0);\n      const end = Math.min(_actualIndex + virtualizerLength, numItems);\n      for (let i = _actualIndex; i < end; i++) {\n        childArray.current[i - _actualIndex] = renderChild(i, isScrolling);\n      }\n    },\n    [isScrolling, numItems, renderChild, virtualizerLength],\n  );\n\n  const updateCurrentItemSizes = useCallback(\n    (newIndex: number) => {\n      if (!getItemSize) {\n        // Static sizes, not required.\n        return;\n      }\n      // We should always call our size function on index change (only for the items that will be rendered)\n      // This ensures we request the latest data for incoming items in case sizing has changed.\n      const endIndex = Math.min(newIndex + virtualizerLength, numItems);\n      const startIndex = Math.max(newIndex, 0);\n\n      let didUpdate = false;\n      for (let i = startIndex; i < endIndex; i++) {\n        const newSize = getItemSize(i);\n        if (newSize !== childSizes.current[i]) {\n          childSizes.current[i] = newSize;\n          didUpdate = true;\n        }\n      }\n\n      if (didUpdate) {\n        // Update our progressive size array\n        for (let i = startIndex; i < numItems; i++) {\n          const prevSize = i > 0 ? childProgressiveSizes.current[i - 1] : 0;\n          childProgressiveSizes.current[i] = prevSize + childSizes.current[i];\n        }\n      }\n    },\n    [getItemSize, numItems, virtualizerLength],\n  );\n\n  const batchUpdateNewIndex = useCallback(\n    (index: number) => {\n      // Local updates\n      updateChildRows(index);\n      updateCurrentItemSizes(index);\n\n      // State setters\n      setActualIndex(index);\n    },\n    [setActualIndex, updateChildRows, updateCurrentItemSizes],\n  );\n\n  const findIndexRecursive = useCallback(\n    (scrollPos: number, lowIndex: number, highIndex: number): number => {\n      if (lowIndex > highIndex) {\n        // We shouldn't get here - but no-op the index if we do.\n        return actualIndex;\n      }\n      const midpoint = Math.floor((lowIndex + highIndex) / 2);\n      const iBefore = Math.max(midpoint - 1, 0);\n      const iAfter = Math.min(midpoint + 1, childProgressiveSizes.current.length - 1);\n      const indexValue = childProgressiveSizes.current[midpoint];\n      const afterIndexValue = childProgressiveSizes.current[iAfter];\n      const beforeIndexValue = childProgressiveSizes.current[iBefore];\n      if (scrollPos <= afterIndexValue && scrollPos >= beforeIndexValue) {\n        /* We've found our index - if we are exactly matching before/after index that's ok,\n      better to reduce checks if it's right on the boundary. */\n        return midpoint;\n      }\n\n      if (indexValue > scrollPos) {\n        return findIndexRecursive(scrollPos, lowIndex, midpoint - 1);\n      } else {\n        return findIndexRecursive(scrollPos, midpoint + 1, highIndex);\n      }\n    },\n    [actualIndex],\n  );\n\n  const getIndexFromSizeArray = useCallback(\n    (scrollPos: number): number => {\n      /* Quick searches our progressive height array */\n      if (\n        scrollPos === 0 ||\n        childProgressiveSizes.current.length === 0 ||\n        scrollPos <= childProgressiveSizes.current[0]\n      ) {\n        // Check start\n        return 0;\n      }\n\n      if (scrollPos >= childProgressiveSizes.current[childProgressiveSizes.current.length - 1]) {\n        // Check end\n        return childProgressiveSizes.current.length - 1;\n      }\n\n      return findIndexRecursive(scrollPos, 0, childProgressiveSizes.current.length - 1);\n    },\n    [findIndexRecursive],\n  );\n  const getIndexFromScrollPosition = useCallback(\n    (scrollPos: number) => {\n      if (!getItemSize) {\n        return Math.round(scrollPos / itemSize);\n      }\n\n      return getIndexFromSizeArray(scrollPos);\n    },\n    [getIndexFromSizeArray, getItemSize, itemSize],\n  );\n\n  const calculateTotalSize = useCallback(() => {\n    if (!getItemSize) {\n      return itemSize * numItems;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[numItems - 1];\n  }, [getItemSize, itemSize, numItems]);\n\n  const calculateBefore = useCallback(() => {\n    const currentIndex = Math.min(actualIndex, numItems - 1);\n\n    if (!getItemSize) {\n      // The missing items from before virtualization starts height\n      return currentIndex * itemSize;\n    }\n\n    if (currentIndex <= 0) {\n      return 0;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[currentIndex - 1];\n  }, [actualIndex, getItemSize, itemSize, numItems]);\n\n  const calculateAfter = useCallback(() => {\n    if (numItems === 0 || actualIndex + virtualizerLength >= numItems) {\n      return 0;\n    }\n\n    const lastItemIndex = Math.min(actualIndex + virtualizerLength, numItems);\n    if (!getItemSize) {\n      // The missing items from after virtualization ends height\n      const remainingItems = numItems - lastItemIndex;\n      return remainingItems * itemSize;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[numItems - 1] - childProgressiveSizes.current[lastItemIndex - 1];\n  }, [actualIndex, getItemSize, itemSize, numItems, virtualizerLength]);\n\n  // Observe intersections of virtualized components\n  const { setObserverList } = useIntersectionObserver(\n    useCallback(\n      // TODO: exclude types from this lint rule: https://github.com/microsoft/fluentui/issues/31286\n      // eslint-disable-next-line no-restricted-globals\n      (entries: IntersectionObserverEntry[], observer: IntersectionObserver) => {\n        /* Sanity check - do we even need virtualization? */\n        if (virtualizerLength > numItems) {\n          if (actualIndex !== 0) {\n            batchUpdateNewIndex(0);\n          }\n          // No-op\n          return;\n        }\n\n        // Grab latest entry that is intersecting\n        const latestEntry =\n          entries.length === 1\n            ? entries[0]\n            : entries\n                .sort((entry1, entry2) => entry2.time - entry1.time)\n                .find(entry => {\n                  return entry.intersectionRatio > 0;\n                });\n\n        if (!latestEntry || !latestEntry.isIntersecting) {\n          // If we don't find an intersecting area, ignore for now.\n          return;\n        }\n\n        // We have to be sure our item sizes are up to date with current indexed ref before calculation\n        // Check if we still need\n        updateCurrentItemSizes(actualIndexRef.current);\n\n        const calculateOverBuffer = (): number => {\n          /**\n           * We avoid using the scroll ref scrollTop, it may be incorrect\n           * as virtualization may exist within a scroll view with other elements\n           * The benefit of using IO is that we can detect relative scrolls,\n           * so any items can be placed around the virtualizer in the scroll view\n           */\n          let measurementPos = 0;\n          if (latestEntry.target === afterElementRef.current) {\n            // Get after buffers position\n            measurementPos = calculateTotalSize() - calculateAfter();\n\n            // Get exact intersection position based on overflow size (how far into IO did we scroll?)\n            const overflowAmount =\n              axis === 'vertical' ? latestEntry.intersectionRect.height : latestEntry.intersectionRect.width;\n            // Add to original after position\n            measurementPos += overflowAmount;\n            // Ignore buffer size (IO offset)\n            measurementPos -= bufferSize;\n            // we hit the after buffer and detected the end of view, we need to find the start index.\n            measurementPos -= containerSizeRef.current ?? 0;\n\n            // Calculate how far past the window bounds we are (this will be zero if IO is within window)\n            const hOverflow = latestEntry.boundingClientRect.top - latestEntry.intersectionRect.top;\n            const hOverflowReversed = latestEntry.boundingClientRect.bottom - latestEntry.intersectionRect.bottom;\n            const wOverflow = latestEntry.boundingClientRect.left - latestEntry.intersectionRect.left;\n            const wOverflowReversed = latestEntry.boundingClientRect.right - latestEntry.intersectionRect.right;\n            const widthOverflow = reversed ? wOverflowReversed : wOverflow;\n            const heightOverflow = reversed ? hOverflowReversed : hOverflow;\n            const additionalOverflow = axis === 'vertical' ? heightOverflow : widthOverflow;\n\n            if (reversed) {\n              measurementPos += additionalOverflow;\n            } else {\n              measurementPos -= additionalOverflow;\n            }\n          } else if (latestEntry.target === beforeElementRef.current) {\n            // Get before buffers position\n            measurementPos = calculateBefore();\n            // Get exact intersection position based on overflow size (how far into window did we scroll IO?)\n            const overflowAmount =\n              axis === 'vertical' ? latestEntry.intersectionRect.height : latestEntry.intersectionRect.width;\n            // Minus from original before position\n            measurementPos -= overflowAmount;\n            // Ignore buffer size (IO offset)\n            measurementPos += bufferSize;\n\n            // Calculate how far past the window bounds we are (this will be zero if IO is within window)\n            const hOverflow = latestEntry.boundingClientRect.bottom - latestEntry.intersectionRect.bottom;\n            const hOverflowReversed = latestEntry.boundingClientRect.top - latestEntry.intersectionRect.top;\n            const wOverflow = latestEntry.boundingClientRect.right - latestEntry.intersectionRect.right;\n            const wOverflowReversed = latestEntry.boundingClientRect.left - latestEntry.intersectionRect.left;\n            const widthOverflow = reversed ? wOverflowReversed : wOverflow;\n            const heightOverflow = reversed ? hOverflowReversed : hOverflow;\n            const additionalOverflow = axis === 'vertical' ? heightOverflow : widthOverflow;\n\n            if (reversed) {\n              measurementPos += additionalOverflow;\n            } else {\n              measurementPos -= additionalOverflow;\n            }\n          }\n\n          return measurementPos;\n        };\n\n        // Get exact relative 'scrollTop' via IO values\n        const measurementPos = calculateOverBuffer();\n\n        const maxIndex = Math.max(numItems - virtualizerLength, 0);\n\n        const startIndex = getIndexFromScrollPosition(measurementPos) - bufferItems;\n\n        // Safety limits\n        const newStartIndex = Math.min(Math.max(startIndex, 0), maxIndex);\n\n        flushSync(() => {\n          _virtualizerContext.setContextPosition(measurementPos);\n          if (actualIndex !== newStartIndex) {\n            batchUpdateNewIndex(newStartIndex);\n          }\n        });\n      },\n      [\n        _virtualizerContext,\n        actualIndex,\n        axis,\n        batchUpdateNewIndex,\n        bufferItems,\n        bufferSize,\n        calculateAfter,\n        calculateBefore,\n        calculateTotalSize,\n        containerSizeRef,\n        getIndexFromScrollPosition,\n        numItems,\n        reversed,\n        updateCurrentItemSizes,\n        virtualizerLength,\n      ],\n    ),\n    {\n      root: scrollViewRef ? scrollViewRef?.current : null,\n      rootMargin: '0px',\n      threshold: 0,\n    },\n  );\n\n  const setBeforeRef = useCallback(\n    (element: HTMLDivElement) => {\n      if (!element || beforeElementRef.current === element) {\n        return;\n      }\n      beforeElementRef.current = element;\n      const newList = [];\n\n      newList.push(beforeElementRef.current);\n\n      if (afterElementRef.current) {\n        newList.push(afterElementRef.current);\n      }\n\n      // Ensure we update array if before element changed\n      setObserverList(newList);\n    },\n    [setObserverList],\n  );\n\n  const setAfterRef = useCallback(\n    (element: HTMLDivElement) => {\n      if (!element || afterElementRef.current === element) {\n        return;\n      }\n      afterElementRef.current = element;\n      const newList = [];\n\n      if (beforeElementRef.current) {\n        newList.push(beforeElementRef.current);\n      }\n\n      newList.push(afterElementRef.current);\n\n      // Ensure we update array if after element changed\n      setObserverList(newList);\n    },\n    [setObserverList],\n  );\n\n  // Initialize the size array before first render.\n  const hasInitialized = useRef<boolean>(false);\n  const initializeSizeArray = () => {\n    if (hasInitialized.current === false) {\n      hasInitialized.current = true;\n      populateSizeArrays();\n    }\n  };\n\n  useImperativeHandle(\n    imperativeVirtualizerRef,\n    () => {\n      return {\n        progressiveSizes: childProgressiveSizes,\n        nodeSizes: childSizes,\n        setFlaggedIndex: (index: number | null) => (flaggedIndex.current = index),\n        currentIndex: actualIndexRef,\n      };\n    },\n    [childProgressiveSizes, childSizes],\n  );\n\n  // Initialization on mount - update array index to 0 (ready state).\n  // Only fire on mount (no deps).\n  useEffect(() => {\n    if (actualIndex < 0) {\n      batchUpdateNewIndex(0);\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  /*\n   * forceUpdate:\n   * We only want to trigger this when scrollLoading is enabled and set to false,\n   * it will force re-render all children elements\n   */\n  const forceUpdate = useReducer(() => ({}), {})[1];\n  // If the user passes in an updated renderChild function - update current children\n  useEffect(() => {\n    if (actualIndex >= 0) {\n      updateChildRows(actualIndex);\n      if (enableScrollLoad && !isScrolling) {\n        forceUpdate();\n      }\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [renderChild, isScrolling]);\n\n  useEffect(() => {\n    // Ensure we repopulate if getItemSize callback changes\n    populateSizeArrays();\n\n    // We only run this effect on getItemSize change (recalc dynamic sizes)\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [getItemSize]);\n\n  // Effect to check flag index on updates\n  useEffect(() => {\n    if (!onRenderedFlaggedIndex || flaggedIndex.current === null) {\n      return;\n    }\n    if (actualIndex <= flaggedIndex.current && actualIndex + virtualizerLength >= flaggedIndex.current) {\n      onRenderedFlaggedIndex(flaggedIndex.current);\n      flaggedIndex.current = null;\n    }\n  }, [actualIndex, onRenderedFlaggedIndex, virtualizerLength]);\n\n  // Ensure we have run through and updated the whole size list array at least once.\n  initializeSizeArray();\n\n  if (getItemSize && (numItems !== childSizes.current.length || numItems !== childProgressiveSizes.current.length)) {\n    // Child length mismatch, repopulate size arrays.\n    populateSizeArrays();\n  }\n\n  // Ensure we recalc if virtualizer length changes\n  const maxCompare = Math.min(virtualizerLength, numItems);\n  if (childArray.current.length !== maxCompare && actualIndex + childArray.current.length < numItems) {\n    updateChildRows(actualIndex);\n  }\n\n  const isFullyInitialized = hasInitialized.current && actualIndex >= 0;\n  return {\n    components: {\n      before: 'div',\n      after: 'div',\n      beforeContainer: 'div',\n      afterContainer: 'div',\n    },\n    virtualizedChildren: childArray.current,\n    before: slot.always(props.before, {\n      defaultProps: {\n        ref: setBeforeRef,\n        role: 'none',\n      },\n      elementType: 'div',\n    }),\n    after: slot.always(props.after, {\n      defaultProps: {\n        ref: setAfterRef,\n        role: 'none',\n      },\n      elementType: 'div',\n    }),\n    beforeContainer: slot.always(props.beforeContainer, {\n      defaultProps: {\n        role: 'none',\n      },\n      elementType: 'div',\n    }),\n    afterContainer: slot.always(props.afterContainer, {\n      defaultProps: {\n        role: 'none',\n      },\n      elementType: 'div',\n    }),\n    beforeBufferHeight: isFullyInitialized ? calculateBefore() : 0,\n    afterBufferHeight: isFullyInitialized ? calculateAfter() : 0,\n    totalVirtualizerHeight: isFullyInitialized ? calculateTotalSize() : virtualizerLength * itemSize,\n    virtualizerStartIndex: actualIndex,\n    axis,\n    bufferSize,\n    reversed,\n    childSizes,\n    childProgressiveSizes,\n  };\n}\n"],"names":["useVirtualizer_unstable","props","itemSize","numItems","virtualizerLength","children","renderChild","getItemSize","bufferItems","Math","round","bufferSize","floor","axis","reversed","virtualizerContext","onRenderedFlaggedIndex","imperativeVirtualizerRef","containerSizeRef","scrollViewRef","enableScrollLoad","_virtualizerContext","useVirtualizerContextState_unstable","actualIndexRef","useRef","contextIndex","flaggedIndex","actualIndex","current","setActualIndex","useCallback","index","setContextIndex","beforeElementRef","afterElementRef","childSizes","Array","childProgressiveSizes","childArray","populateSizeArrays","length","isScrolling","setIsScrolling","useState","setScrollTimer","clearScrollTimer","useTimeout","scrollCounter","initializeScrollingTimer","INIT_SCROLL_FLAG_REQ","INIT_SCROLL_FLAG_DELAY","useEffect","updateChildRows","newIndex","_actualIndex","max","end","min","i","updateCurrentItemSizes","endIndex","startIndex","didUpdate","newSize","prevSize","batchUpdateNewIndex","findIndexRecursive","scrollPos","lowIndex","highIndex","midpoint","iBefore","iAfter","indexValue","afterIndexValue","beforeIndexValue","getIndexFromSizeArray","getIndexFromScrollPosition","calculateTotalSize","calculateBefore","currentIndex","calculateAfter","lastItemIndex","remainingItems","setObserverList","useIntersectionObserver","entries","observer","latestEntry","sort","entry1","entry2","time","find","entry","intersectionRatio","isIntersecting","calculateOverBuffer","measurementPos","target","overflowAmount","intersectionRect","height","width","hOverflow","boundingClientRect","top","hOverflowReversed","bottom","wOverflow","left","wOverflowReversed","right","widthOverflow","heightOverflow","additionalOverflow","maxIndex","newStartIndex","flushSync","setContextPosition","root","rootMargin","threshold","setBeforeRef","element","newList","push","setAfterRef","hasInitialized","initializeSizeArray","useImperativeHandle","progressiveSizes","nodeSizes","setFlaggedIndex","forceUpdate","useReducer","maxCompare","isFullyInitialized","components","before","after","beforeContainer","afterContainer","virtualizedChildren","slot","always","defaultProps","ref","role","elementType","beforeBufferHeight","afterBufferHeight","totalVirtualizerHeight","virtualizerStartIndex"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}