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

package/CHANGELOG.md

@@ -1,12 +1,21 @@
 # Change Log - @fluentui/react-virtualizer
 
-This log was last generated on Wed, 22 Jan 2025 13:55:24 GMT and should not be manually modified.
+This log was last generated on Fri, 07 Feb 2025 10:40:53 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## [9.0.0-alpha.92](https://github.com/microsoft/fluentui/tree/@fluentui/react-virtualizer_v9.0.0-alpha.92)
+
+Fri, 07 Feb 2025 10:40:53 GMT 
+[Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-virtualizer_v9.0.0-alpha.91..@fluentui/react-virtualizer_v9.0.0-alpha.92)
+
+### Changes
+
+- fix: Fix regression of child render function update ([PR #33788](https://github.com/microsoft/fluentui/pull/33788) by mifraser@microsoft.com)
+
 ## [9.0.0-alpha.91](https://github.com/microsoft/fluentui/tree/@fluentui/react-virtualizer_v9.0.0-alpha.91)
 
-Wed, 22 Jan 2025 13:55:24 GMT 
+Wed, 22 Jan 2025 14:00:13 GMT 
 [Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-virtualizer_v9.0.0-alpha.90..@fluentui/react-virtualizer_v9.0.0-alpha.91)
 
 ### Changes

package/lib/components/Virtualizer/useVirtualizer.js

@@ -64,6 +64,8 @@ export function useVirtualizer_unstable(props) {
     const initializeScrollingTimer = React.useCallback(()=>{
         if (!enableScrollLoad) {
             // Disabled by default for reduction of render callbacks
+            setIsScrolling(false);
+            clearScrollTimer();
             return;
         }
         /*
@@ -431,16 +433,14 @@ export function useVirtualizer_unstable(props) {
     }, []);
     /*
    * forceUpdate:
-   * We only want to trigger this when scrollLoading is enabled and set to false,
+   * We only want to trigger this when child render or scroll loading changes,
    * it will force re-render all children elements
    */ const forceUpdate = React.useReducer(()=>({}), {})[1];
     // If the user passes in an updated renderChild function - update current children
     React.useEffect(()=>{
         if (actualIndex >= 0) {
             updateChildRows(actualIndex);
-            if (enableScrollLoad && !isScrolling) {
-                forceUpdate();
-            }
+            forceUpdate();
         }
     // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [

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

@@ -1 +1 @@
-{"version":3,"sources":["../src/components/Virtualizer/useVirtualizer.ts"],"sourcesContent":["import * as React from 'react';\nimport type { VirtualizerProps, VirtualizerState } from './Virtualizer.types';\n\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    updateScrollPosition,\n    gap = 0,\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 = React.useRef<number>(_virtualizerContext.contextIndex);\n\n  const flaggedIndex = React.useRef<number | null>(null);\n  const actualIndex = _virtualizerContext.contextIndex;\n\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 = React.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 = React.useRef<HTMLElement | null>(null);\n\n  // Store ref to before padding element\n  const afterElementRef = React.useRef<HTMLElement | 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 = React.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 = React.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 = React.useRef<React.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      const _gap = index < numItems - 1 ? gap : 0;\n      childSizes.current[index] = getItemSize(index) + _gap;\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] = React.useState<boolean>(false);\n  const [setScrollTimer, clearScrollTimer] = useTimeout();\n  const scrollCounter = React.useRef<number>(0);\n\n  const initializeScrollingTimer = React.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  React.useEffect(() => {\n    initializeScrollingTimer();\n  }, [actualIndex, initializeScrollingTimer]);\n\n  const updateChildRows = React.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 = React.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 _gap = i < numItems - 1 ? gap : 0;\n        const newSize = getItemSize(i) + _gap;\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, gap],\n  );\n\n  const batchUpdateNewIndex = React.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 = React.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 = React.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 = React.useCallback(\n    (scrollPos: number) => {\n      if (!getItemSize) {\n        return Math.round(scrollPos / (itemSize + gap));\n      }\n\n      return getIndexFromSizeArray(scrollPos);\n    },\n    [getIndexFromSizeArray, getItemSize, itemSize, gap],\n  );\n\n  const calculateTotalSize = React.useCallback(() => {\n    if (!getItemSize) {\n      return (itemSize + gap) * numItems;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[numItems - 1];\n  }, [getItemSize, itemSize, numItems, gap]);\n\n  const calculateBefore = React.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 + gap);\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, gap]);\n\n  const calculateAfter = React.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 + gap) - gap;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[numItems - 1] - childProgressiveSizes.current[lastItemIndex - 1];\n  }, [actualIndex, getItemSize, itemSize, numItems, virtualizerLength, gap]);\n\n  // Observe intersections of virtualized components\n  const { setObserverList } = useIntersectionObserver(\n    React.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        if (entries.length === 0) {\n          // No entries found, return.\n          return;\n        }\n        // Find the latest entry that is intersecting\n        const sortedEntries = entries.sort((entry1, entry2) => entry2.time - entry1.time);\n        const latestEntry = sortedEntries.find(entry => {\n          return entry.isIntersecting;\n        });\n\n        if (!latestEntry) {\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\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\n            // Minus from original before position\n            measurementPos -= overflowAmount;\n            // Ignore buffer size (IO offset)\n            measurementPos += bufferSize;\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        flushSync(() => {\n          // Callback to allow measure functions to check virtualizer length\n          if (newStartIndex + virtualizerLength >= numItems && actualIndex + virtualizerLength >= numItems) {\n            // We've already hit the end, no need to update state.\n            return;\n          }\n          updateScrollPosition?.(measurementPos);\n          if (actualIndex !== newStartIndex) {\n            batchUpdateNewIndex(newStartIndex);\n          }\n        });\n      },\n      [\n        actualIndex,\n        virtualizerLength,\n        axis,\n        reversed,\n        numItems,\n        bufferSize,\n        bufferItems,\n        containerSizeRef,\n        updateScrollPosition,\n        batchUpdateNewIndex,\n        calculateAfter,\n        calculateBefore,\n        calculateTotalSize,\n        getIndexFromScrollPosition,\n        updateCurrentItemSizes,\n      ],\n    ),\n    {\n      root: scrollViewRef ? scrollViewRef?.current : null,\n      rootMargin: '0px',\n      threshold: 0,\n    },\n  );\n\n  const setBeforeRef = React.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 = React.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 = React.useRef<boolean>(false);\n  const initializeSizeArray = () => {\n    if (hasInitialized.current === false) {\n      hasInitialized.current = true;\n      populateSizeArrays();\n    }\n  };\n\n  React.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  React.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 = React.useReducer(() => ({}), {})[1];\n  // If the user passes in an updated renderChild function - update current children\n  React.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  React.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, gap]);\n\n  // Effect to check flag index on updates\n  React.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":["React","useIntersectionObserver","useVirtualizerContextState_unstable","slot","useTimeout","flushSync","useVirtualizer_unstable","props","itemSize","numItems","virtualizerLength","children","renderChild","getItemSize","bufferItems","Math","round","bufferSize","floor","axis","reversed","virtualizerContext","onRenderedFlaggedIndex","imperativeVirtualizerRef","containerSizeRef","scrollViewRef","enableScrollLoad","updateScrollPosition","gap","_virtualizerContext","actualIndexRef","useRef","contextIndex","flaggedIndex","actualIndex","current","setActualIndex","useCallback","index","setContextIndex","beforeElementRef","afterElementRef","childSizes","Array","childProgressiveSizes","childArray","populateSizeArrays","length","_gap","isScrolling","setIsScrolling","useState","setScrollTimer","clearScrollTimer","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","entries","observer","sortedEntries","sort","entry1","entry2","time","latestEntry","find","entry","isIntersecting","calculateOverBuffer","measurementPos","target","overflowAmount","intersectionRect","height","width","hOverflow","boundingClientRect","top","hOverflowReversed","bottom","wOverflow","left","wOverflowReversed","right","widthOverflow","heightOverflow","additionalOverflow","maxIndex","newStartIndex","root","rootMargin","threshold","setBeforeRef","element","newList","push","setAfterRef","hasInitialized","initializeSizeArray","useImperativeHandle","progressiveSizes","nodeSizes","setFlaggedIndex","forceUpdate","useReducer","maxCompare","isFullyInitialized","components","before","after","beforeContainer","afterContainer","virtualizedChildren","always","defaultProps","ref","role","elementType","beforeBufferHeight","afterBufferHeight","totalVirtualizerHeight","virtualizerStartIndex"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../src/components/Virtualizer/useVirtualizer.ts"],"sourcesContent":["import * as React from 'react';\nimport type { VirtualizerProps, VirtualizerState } from './Virtualizer.types';\n\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    updateScrollPosition,\n    gap = 0,\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 = React.useRef<number>(_virtualizerContext.contextIndex);\n\n  const flaggedIndex = React.useRef<number | null>(null);\n  const actualIndex = _virtualizerContext.contextIndex;\n\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 = React.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 = React.useRef<HTMLElement | null>(null);\n\n  // Store ref to before padding element\n  const afterElementRef = React.useRef<HTMLElement | 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 = React.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 = React.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 = React.useRef<React.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      const _gap = index < numItems - 1 ? gap : 0;\n      childSizes.current[index] = getItemSize(index) + _gap;\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] = React.useState<boolean>(false);\n  const [setScrollTimer, clearScrollTimer] = useTimeout();\n  const scrollCounter = React.useRef<number>(0);\n\n  const initializeScrollingTimer = React.useCallback(() => {\n    if (!enableScrollLoad) {\n      // Disabled by default for reduction of render callbacks\n      setIsScrolling(false);\n      clearScrollTimer();\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  React.useEffect(() => {\n    initializeScrollingTimer();\n  }, [actualIndex, initializeScrollingTimer]);\n\n  const updateChildRows = React.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 = React.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 _gap = i < numItems - 1 ? gap : 0;\n        const newSize = getItemSize(i) + _gap;\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, gap],\n  );\n\n  const batchUpdateNewIndex = React.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 = React.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 = React.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 = React.useCallback(\n    (scrollPos: number) => {\n      if (!getItemSize) {\n        return Math.round(scrollPos / (itemSize + gap));\n      }\n\n      return getIndexFromSizeArray(scrollPos);\n    },\n    [getIndexFromSizeArray, getItemSize, itemSize, gap],\n  );\n\n  const calculateTotalSize = React.useCallback(() => {\n    if (!getItemSize) {\n      return (itemSize + gap) * numItems;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[numItems - 1];\n  }, [getItemSize, itemSize, numItems, gap]);\n\n  const calculateBefore = React.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 + gap);\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, gap]);\n\n  const calculateAfter = React.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 + gap) - gap;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[numItems - 1] - childProgressiveSizes.current[lastItemIndex - 1];\n  }, [actualIndex, getItemSize, itemSize, numItems, virtualizerLength, gap]);\n\n  // Observe intersections of virtualized components\n  const { setObserverList } = useIntersectionObserver(\n    React.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        if (entries.length === 0) {\n          // No entries found, return.\n          return;\n        }\n        // Find the latest entry that is intersecting\n        const sortedEntries = entries.sort((entry1, entry2) => entry2.time - entry1.time);\n        const latestEntry = sortedEntries.find(entry => {\n          return entry.isIntersecting;\n        });\n\n        if (!latestEntry) {\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\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\n            // Minus from original before position\n            measurementPos -= overflowAmount;\n            // Ignore buffer size (IO offset)\n            measurementPos += bufferSize;\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        flushSync(() => {\n          // Callback to allow measure functions to check virtualizer length\n          if (newStartIndex + virtualizerLength >= numItems && actualIndex + virtualizerLength >= numItems) {\n            // We've already hit the end, no need to update state.\n            return;\n          }\n          updateScrollPosition?.(measurementPos);\n          if (actualIndex !== newStartIndex) {\n            batchUpdateNewIndex(newStartIndex);\n          }\n        });\n      },\n      [\n        actualIndex,\n        virtualizerLength,\n        axis,\n        reversed,\n        numItems,\n        bufferSize,\n        bufferItems,\n        containerSizeRef,\n        updateScrollPosition,\n        batchUpdateNewIndex,\n        calculateAfter,\n        calculateBefore,\n        calculateTotalSize,\n        getIndexFromScrollPosition,\n        updateCurrentItemSizes,\n      ],\n    ),\n    {\n      root: scrollViewRef ? scrollViewRef?.current : null,\n      rootMargin: '0px',\n      threshold: 0,\n    },\n  );\n\n  const setBeforeRef = React.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 = React.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 = React.useRef<boolean>(false);\n  const initializeSizeArray = () => {\n    if (hasInitialized.current === false) {\n      hasInitialized.current = true;\n      populateSizeArrays();\n    }\n  };\n\n  React.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  React.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 child render or scroll loading changes,\n   * it will force re-render all children elements\n   */\n  const forceUpdate = React.useReducer(() => ({}), {})[1];\n  // If the user passes in an updated renderChild function - update current children\n  React.useEffect(() => {\n    if (actualIndex >= 0) {\n      updateChildRows(actualIndex);\n      forceUpdate();\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [renderChild, isScrolling]);\n\n  React.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, gap]);\n\n  // Effect to check flag index on updates\n  React.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":["React","useIntersectionObserver","useVirtualizerContextState_unstable","slot","useTimeout","flushSync","useVirtualizer_unstable","props","itemSize","numItems","virtualizerLength","children","renderChild","getItemSize","bufferItems","Math","round","bufferSize","floor","axis","reversed","virtualizerContext","onRenderedFlaggedIndex","imperativeVirtualizerRef","containerSizeRef","scrollViewRef","enableScrollLoad","updateScrollPosition","gap","_virtualizerContext","actualIndexRef","useRef","contextIndex","flaggedIndex","actualIndex","current","setActualIndex","useCallback","index","setContextIndex","beforeElementRef","afterElementRef","childSizes","Array","childProgressiveSizes","childArray","populateSizeArrays","length","_gap","isScrolling","setIsScrolling","useState","setScrollTimer","clearScrollTimer","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","entries","observer","sortedEntries","sort","entry1","entry2","time","latestEntry","find","entry","isIntersecting","calculateOverBuffer","measurementPos","target","overflowAmount","intersectionRect","height","width","hOverflow","boundingClientRect","top","hOverflowReversed","bottom","wOverflow","left","wOverflowReversed","right","widthOverflow","heightOverflow","additionalOverflow","maxIndex","newStartIndex","root","rootMargin","threshold","setBeforeRef","element","newList","push","setAfterRef","hasInitialized","initializeSizeArray","useImperativeHandle","progressiveSizes","nodeSizes","setFlaggedIndex","forceUpdate","useReducer","maxCompare","isFullyInitialized","components","before","after","beforeContainer","afterContainer","virtualizedChildren","always","defaultProps","ref","role","elementType","beforeBufferHeight","afterBufferHeight","totalVirtualizerHeight","virtualizerStartIndex"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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

@@ -75,6 +75,8 @@ function useVirtualizer_unstable(props) {
     const initializeScrollingTimer = _react.useCallback(()=>{
         if (!enableScrollLoad) {
             // Disabled by default for reduction of render callbacks
+            setIsScrolling(false);
+            clearScrollTimer();
             return;
         }
         /*
@@ -441,16 +443,14 @@ function useVirtualizer_unstable(props) {
     }, []);
     /*
    * forceUpdate:
-   * We only want to trigger this when scrollLoading is enabled and set to false,
+   * We only want to trigger this when child render or scroll loading changes,
    * it will force re-render all children elements
    */ const forceUpdate = _react.useReducer(()=>({}), {})[1];
     // If the user passes in an updated renderChild function - update current children
     _react.useEffect(()=>{
         if (actualIndex >= 0) {
             updateChildRows(actualIndex);
-            if (enableScrollLoad && !isScrolling) {
-                forceUpdate();
-            }
+            forceUpdate();
         }
     // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [

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

@@ -1 +1 @@
-{"version":3,"sources":["../src/components/Virtualizer/useVirtualizer.ts"],"sourcesContent":["import * as React from 'react';\nimport type { VirtualizerProps, VirtualizerState } from './Virtualizer.types';\n\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    updateScrollPosition,\n    gap = 0,\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 = React.useRef<number>(_virtualizerContext.contextIndex);\n\n  const flaggedIndex = React.useRef<number | null>(null);\n  const actualIndex = _virtualizerContext.contextIndex;\n\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 = React.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 = React.useRef<HTMLElement | null>(null);\n\n  // Store ref to before padding element\n  const afterElementRef = React.useRef<HTMLElement | 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 = React.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 = React.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 = React.useRef<React.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      const _gap = index < numItems - 1 ? gap : 0;\n      childSizes.current[index] = getItemSize(index) + _gap;\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] = React.useState<boolean>(false);\n  const [setScrollTimer, clearScrollTimer] = useTimeout();\n  const scrollCounter = React.useRef<number>(0);\n\n  const initializeScrollingTimer = React.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  React.useEffect(() => {\n    initializeScrollingTimer();\n  }, [actualIndex, initializeScrollingTimer]);\n\n  const updateChildRows = React.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 = React.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 _gap = i < numItems - 1 ? gap : 0;\n        const newSize = getItemSize(i) + _gap;\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, gap],\n  );\n\n  const batchUpdateNewIndex = React.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 = React.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 = React.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 = React.useCallback(\n    (scrollPos: number) => {\n      if (!getItemSize) {\n        return Math.round(scrollPos / (itemSize + gap));\n      }\n\n      return getIndexFromSizeArray(scrollPos);\n    },\n    [getIndexFromSizeArray, getItemSize, itemSize, gap],\n  );\n\n  const calculateTotalSize = React.useCallback(() => {\n    if (!getItemSize) {\n      return (itemSize + gap) * numItems;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[numItems - 1];\n  }, [getItemSize, itemSize, numItems, gap]);\n\n  const calculateBefore = React.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 + gap);\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, gap]);\n\n  const calculateAfter = React.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 + gap) - gap;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[numItems - 1] - childProgressiveSizes.current[lastItemIndex - 1];\n  }, [actualIndex, getItemSize, itemSize, numItems, virtualizerLength, gap]);\n\n  // Observe intersections of virtualized components\n  const { setObserverList } = useIntersectionObserver(\n    React.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        if (entries.length === 0) {\n          // No entries found, return.\n          return;\n        }\n        // Find the latest entry that is intersecting\n        const sortedEntries = entries.sort((entry1, entry2) => entry2.time - entry1.time);\n        const latestEntry = sortedEntries.find(entry => {\n          return entry.isIntersecting;\n        });\n\n        if (!latestEntry) {\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\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\n            // Minus from original before position\n            measurementPos -= overflowAmount;\n            // Ignore buffer size (IO offset)\n            measurementPos += bufferSize;\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        flushSync(() => {\n          // Callback to allow measure functions to check virtualizer length\n          if (newStartIndex + virtualizerLength >= numItems && actualIndex + virtualizerLength >= numItems) {\n            // We've already hit the end, no need to update state.\n            return;\n          }\n          updateScrollPosition?.(measurementPos);\n          if (actualIndex !== newStartIndex) {\n            batchUpdateNewIndex(newStartIndex);\n          }\n        });\n      },\n      [\n        actualIndex,\n        virtualizerLength,\n        axis,\n        reversed,\n        numItems,\n        bufferSize,\n        bufferItems,\n        containerSizeRef,\n        updateScrollPosition,\n        batchUpdateNewIndex,\n        calculateAfter,\n        calculateBefore,\n        calculateTotalSize,\n        getIndexFromScrollPosition,\n        updateCurrentItemSizes,\n      ],\n    ),\n    {\n      root: scrollViewRef ? scrollViewRef?.current : null,\n      rootMargin: '0px',\n      threshold: 0,\n    },\n  );\n\n  const setBeforeRef = React.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 = React.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 = React.useRef<boolean>(false);\n  const initializeSizeArray = () => {\n    if (hasInitialized.current === false) {\n      hasInitialized.current = true;\n      populateSizeArrays();\n    }\n  };\n\n  React.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  React.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 = React.useReducer(() => ({}), {})[1];\n  // If the user passes in an updated renderChild function - update current children\n  React.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  React.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, gap]);\n\n  // Effect to check flag index on updates\n  React.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","updateScrollPosition","gap","_virtualizerContext","useVirtualizerContextState_unstable","actualIndexRef","React","useRef","contextIndex","flaggedIndex","actualIndex","current","setActualIndex","useCallback","index","setContextIndex","beforeElementRef","afterElementRef","childSizes","Array","childProgressiveSizes","childArray","populateSizeArrays","length","_gap","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","sortedEntries","sort","entry1","entry2","time","latestEntry","find","entry","isIntersecting","calculateOverBuffer","measurementPos","target","overflowAmount","intersectionRect","height","width","hOverflow","boundingClientRect","top","hOverflowReversed","bottom","wOverflow","left","wOverflowReversed","right","widthOverflow","heightOverflow","additionalOverflow","maxIndex","newStartIndex","flushSync","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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"}
+{"version":3,"sources":["../src/components/Virtualizer/useVirtualizer.ts"],"sourcesContent":["import * as React from 'react';\nimport type { VirtualizerProps, VirtualizerState } from './Virtualizer.types';\n\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    updateScrollPosition,\n    gap = 0,\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 = React.useRef<number>(_virtualizerContext.contextIndex);\n\n  const flaggedIndex = React.useRef<number | null>(null);\n  const actualIndex = _virtualizerContext.contextIndex;\n\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 = React.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 = React.useRef<HTMLElement | null>(null);\n\n  // Store ref to before padding element\n  const afterElementRef = React.useRef<HTMLElement | 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 = React.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 = React.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 = React.useRef<React.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      const _gap = index < numItems - 1 ? gap : 0;\n      childSizes.current[index] = getItemSize(index) + _gap;\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] = React.useState<boolean>(false);\n  const [setScrollTimer, clearScrollTimer] = useTimeout();\n  const scrollCounter = React.useRef<number>(0);\n\n  const initializeScrollingTimer = React.useCallback(() => {\n    if (!enableScrollLoad) {\n      // Disabled by default for reduction of render callbacks\n      setIsScrolling(false);\n      clearScrollTimer();\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  React.useEffect(() => {\n    initializeScrollingTimer();\n  }, [actualIndex, initializeScrollingTimer]);\n\n  const updateChildRows = React.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 = React.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 _gap = i < numItems - 1 ? gap : 0;\n        const newSize = getItemSize(i) + _gap;\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, gap],\n  );\n\n  const batchUpdateNewIndex = React.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 = React.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 = React.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 = React.useCallback(\n    (scrollPos: number) => {\n      if (!getItemSize) {\n        return Math.round(scrollPos / (itemSize + gap));\n      }\n\n      return getIndexFromSizeArray(scrollPos);\n    },\n    [getIndexFromSizeArray, getItemSize, itemSize, gap],\n  );\n\n  const calculateTotalSize = React.useCallback(() => {\n    if (!getItemSize) {\n      return (itemSize + gap) * numItems;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[numItems - 1];\n  }, [getItemSize, itemSize, numItems, gap]);\n\n  const calculateBefore = React.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 + gap);\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, gap]);\n\n  const calculateAfter = React.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 + gap) - gap;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[numItems - 1] - childProgressiveSizes.current[lastItemIndex - 1];\n  }, [actualIndex, getItemSize, itemSize, numItems, virtualizerLength, gap]);\n\n  // Observe intersections of virtualized components\n  const { setObserverList } = useIntersectionObserver(\n    React.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        if (entries.length === 0) {\n          // No entries found, return.\n          return;\n        }\n        // Find the latest entry that is intersecting\n        const sortedEntries = entries.sort((entry1, entry2) => entry2.time - entry1.time);\n        const latestEntry = sortedEntries.find(entry => {\n          return entry.isIntersecting;\n        });\n\n        if (!latestEntry) {\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\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\n            // Minus from original before position\n            measurementPos -= overflowAmount;\n            // Ignore buffer size (IO offset)\n            measurementPos += bufferSize;\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        flushSync(() => {\n          // Callback to allow measure functions to check virtualizer length\n          if (newStartIndex + virtualizerLength >= numItems && actualIndex + virtualizerLength >= numItems) {\n            // We've already hit the end, no need to update state.\n            return;\n          }\n          updateScrollPosition?.(measurementPos);\n          if (actualIndex !== newStartIndex) {\n            batchUpdateNewIndex(newStartIndex);\n          }\n        });\n      },\n      [\n        actualIndex,\n        virtualizerLength,\n        axis,\n        reversed,\n        numItems,\n        bufferSize,\n        bufferItems,\n        containerSizeRef,\n        updateScrollPosition,\n        batchUpdateNewIndex,\n        calculateAfter,\n        calculateBefore,\n        calculateTotalSize,\n        getIndexFromScrollPosition,\n        updateCurrentItemSizes,\n      ],\n    ),\n    {\n      root: scrollViewRef ? scrollViewRef?.current : null,\n      rootMargin: '0px',\n      threshold: 0,\n    },\n  );\n\n  const setBeforeRef = React.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 = React.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 = React.useRef<boolean>(false);\n  const initializeSizeArray = () => {\n    if (hasInitialized.current === false) {\n      hasInitialized.current = true;\n      populateSizeArrays();\n    }\n  };\n\n  React.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  React.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 child render or scroll loading changes,\n   * it will force re-render all children elements\n   */\n  const forceUpdate = React.useReducer(() => ({}), {})[1];\n  // If the user passes in an updated renderChild function - update current children\n  React.useEffect(() => {\n    if (actualIndex >= 0) {\n      updateChildRows(actualIndex);\n      forceUpdate();\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [renderChild, isScrolling]);\n\n  React.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, gap]);\n\n  // Effect to check flag index on updates\n  React.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","updateScrollPosition","gap","_virtualizerContext","useVirtualizerContextState_unstable","actualIndexRef","React","useRef","contextIndex","flaggedIndex","actualIndex","current","setActualIndex","useCallback","index","setContextIndex","beforeElementRef","afterElementRef","childSizes","Array","childProgressiveSizes","childArray","populateSizeArrays","length","_gap","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","sortedEntries","sort","entry1","entry2","time","latestEntry","find","entry","isIntersecting","calculateOverBuffer","measurementPos","target","overflowAmount","intersectionRect","height","width","hOverflow","boundingClientRect","top","hOverflowReversed","bottom","wOverflow","left","wOverflowReversed","right","widthOverflow","heightOverflow","additionalOverflow","maxIndex","newStartIndex","flushSync","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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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluentui/react-virtualizer",
-  "version": "9.0.0-alpha.91",
+  "version": "9.0.0-alpha.92",
   "description": "Generic and composable virtualizer framework built on browser intersection observer",
   "main": "lib-commonjs/index.js",
   "module": "lib/index.js",