@fluentui/react-virtualizer 9.0.0-alpha.75 → 9.0.0-alpha.76

package/CHANGELOG.md

@@ -1,12 +1,21 @@
 # Change Log - @fluentui/react-virtualizer
 
-This log was last generated on Tue, 23 Apr 2024 08:12:12 GMT and should not be manually modified.
+This log was last generated on Thu, 02 May 2024 11:31:37 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## [9.0.0-alpha.76](https://github.com/microsoft/fluentui/tree/@fluentui/react-virtualizer_v9.0.0-alpha.76)
+
+Thu, 02 May 2024 11:31:37 GMT 
+[Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-virtualizer_v9.0.0-alpha.75..@fluentui/react-virtualizer_v9.0.0-alpha.76)
+
+### Changes
+
+- Fix: Use Fluent hooks for IO and timeout functionality ([PR #31250](https://github.com/microsoft/fluentui/pull/31250) by mifraser@microsoft.com)
+
 ## [9.0.0-alpha.75](https://github.com/microsoft/fluentui/tree/@fluentui/react-virtualizer_v9.0.0-alpha.75)
 
-Tue, 23 Apr 2024 08:12:12 GMT 
+Tue, 23 Apr 2024 08:17:49 GMT 
 [Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-virtualizer_v9.0.0-alpha.74..@fluentui/react-virtualizer_v9.0.0-alpha.75)
 
 ### Changes

package/lib/components/Virtualizer/useVirtualizer.js

@@ -2,7 +2,7 @@ import { useEffect, useRef, useCallback, useReducer, useImperativeHandle, useSta
 import { useIntersectionObserver } from '../../hooks/useIntersectionObserver';
 import { flushSync } from 'react-dom';
 import { useVirtualizerContextState_unstable } from '../../Utilities';
-import { slot } from '@fluentui/react-utilities';
+import { slot, useTimeout } from '@fluentui/react-utilities';
 export function useVirtualizer_unstable(props) {
     const { itemSize, numItems, virtualizerLength, children: renderChild, getItemSize, bufferItems = Math.round(virtualizerLength / 4.0), bufferSize = Math.floor(bufferItems / 2.0) * itemSize, scrollViewRef, axis = 'vertical', reversed = false, virtualizerContext, onRenderedFlaggedIndex, imperativeVirtualizerRef } = props;
     /* The context is optional, it's useful for injecting additional index logic, or performing uniform state updates*/ const _virtualizerContext = useVirtualizerContextState_unstable(virtualizerContext);
@@ -48,9 +48,9 @@ export function useVirtualizer_unstable(props) {
         }
     };
     const [isScrolling, setIsScrolling] = useState(false);
-    const scrollTimer = useRef();
+    const [setScrollTimer, clearScrollTimer] = useTimeout();
     const scrollCounter = useRef(0);
-    const initializeScrollingTimer = ()=>{
+    const initializeScrollingTimer = useCallback(()=>{
         /*
      * This can be considered the 'velocity' required to start 'isScrolling'
      * INIT_SCROLL_FLAG_REQ: Number of renders required to activate isScrolling
@@ -62,18 +62,20 @@ export function useVirtualizer_unstable(props) {
         if (scrollCounter.current >= INIT_SCROLL_FLAG_REQ) {
             setIsScrolling(true);
         }
-        if (scrollTimer.current) {
-            clearTimeout(scrollTimer.current);
-        }
-        scrollTimer.current = setTimeout(()=>{
+        clearScrollTimer();
+        setScrollTimer(()=>{
             setIsScrolling(false);
             scrollCounter.current = 0;
         }, INIT_SCROLL_FLAG_DELAY);
-    };
+    }, [
+        clearScrollTimer,
+        setScrollTimer
+    ]);
     useEffect(()=>{
         initializeScrollingTimer();
     }, [
-        actualIndex
+        actualIndex,
+        initializeScrollingTimer
     ]);
     const batchUpdateNewIndex = (index)=>{
         // Local updates

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

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

package/lib/hooks/useDynamicPagination.js

@@ -1,5 +1,6 @@
 import * as React from 'react';
 import { useRef } from 'react';
+import { useTimeout } from '@fluentui/react-utilities';
 /**
  * Optional hook that will enable pagination on the virtualizer so that it 'autoscrolls' to an items exact position
  * Sizes are dynamic so we require a progressive sizing array (passed in from Dynamic virtualizer hooks)
@@ -7,7 +8,7 @@ import { useRef } from 'react';
  * All VirtualizerDynamicPaginationProps can be grabbed from dynamic Virtualizer hooks externally and passed in
  */ export const useDynamicVirtualizerPagination = (virtualizerProps, paginationEnabled = true)=>{
     const { axis = 'vertical', currentIndex, progressiveItemSizes, virtualizerLength } = virtualizerProps;
-    const timeoutRef = useRef(null);
+    const [setScrollTimer, clearScrollTimer] = useTimeout();
     const lastScrollPos = useRef(-1);
     const lastIndexScrolled = useRef(-1);
     const scrollContainer = React.useRef(null);
@@ -15,9 +16,7 @@ import { useRef } from 'react';
         if (scrollContainer.current) {
             scrollContainer.current.removeEventListener('scroll', onScroll);
             scrollContainer.current = null;
-            if (timeoutRef.current) {
-                clearTimeout(timeoutRef.current);
-            }
+            clearScrollTimer();
         }
     };
     React.useEffect(()=>{
@@ -94,12 +93,12 @@ import { useRef } from 'react';
     /**
    * On scroll timer that will continuously delay callback until scrolling stops
    */ const onScroll = React.useCallback((event)=>{
-        if (timeoutRef.current) {
-            clearTimeout(timeoutRef.current);
-        }
-        timeoutRef.current = setTimeout(onScrollEnd, 100);
+        clearScrollTimer();
+        setScrollTimer(onScrollEnd, 100);
     }, [
-        onScrollEnd
+        onScrollEnd,
+        clearScrollTimer,
+        setScrollTimer
     ]);
     /**
    * Pagination ref will ensure we attach listeners to containers on change

package/lib/hooks/useDynamicPagination.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useDynamicPagination.ts"],"sourcesContent":["import * as React from 'react';\nimport { VirtualizerDynamicPaginationProps } from './hooks.types';\nimport { useRef } from 'react';\n\n/**\n * Optional hook that will enable pagination on the virtualizer so that it 'autoscrolls' to an items exact position\n * Sizes are dynamic so we require a progressive sizing array (passed in from Dynamic virtualizer hooks)\n * On short scrolls, we will go at minimum to the next/previous item so that arrow pagination works\n * All VirtualizerDynamicPaginationProps can be grabbed from dynamic Virtualizer hooks externally and passed in\n */\nexport const useDynamicVirtualizerPagination = (\n  virtualizerProps: VirtualizerDynamicPaginationProps,\n  paginationEnabled: Boolean = true,\n) => {\n  const { axis = 'vertical', currentIndex, progressiveItemSizes, virtualizerLength } = virtualizerProps;\n\n  const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);\n  const lastScrollPos = useRef<number>(-1);\n  const lastIndexScrolled = useRef<number>(-1);\n\n  const scrollContainer = React.useRef<HTMLElement | null>(null);\n\n  const clearListeners = () => {\n    if (scrollContainer.current) {\n      scrollContainer.current.removeEventListener('scroll', onScroll);\n      scrollContainer.current = null;\n      if (timeoutRef.current) {\n        clearTimeout(timeoutRef.current);\n      }\n    }\n  };\n\n  React.useEffect(() => {\n    return () => {\n      clearListeners();\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  /**\n   * Handle scroll stop event and paginate to the closest item\n   * If the closest item is the same as the previous scroll end\n   * we paginate to the next/previous one based on direction\n   *\n   * Users/Virtualizer-Hooks must pass in a cumulative array of sizes\n   * This prevents the need to recalculate and ensures size arrays are synced externally\n   */\n  const onScrollEnd = React.useCallback(() => {\n    if (!scrollContainer.current || !paginationEnabled || !progressiveItemSizes?.current) {\n      // No container found\n      return;\n    }\n\n    const currentScrollPos = Math.round(\n      axis === 'vertical' ? scrollContainer.current.scrollTop : scrollContainer.current.scrollLeft,\n    );\n    let closestItemPos = 0;\n    let closestItem = 0;\n    const endItem = Math.min(currentIndex + virtualizerLength, progressiveItemSizes.current.length);\n\n    for (let i = currentIndex; i < endItem - 1; i++) {\n      if (\n        currentScrollPos <= progressiveItemSizes.current[i + 1] &&\n        currentScrollPos >= progressiveItemSizes.current[i]\n      ) {\n        // Found our in between position\n        const distanceToPrev = Math.abs(currentScrollPos - progressiveItemSizes.current[i]);\n        const distanceToNext = Math.abs(progressiveItemSizes.current[i + 1] - currentScrollPos);\n        if (distanceToPrev < distanceToNext) {\n          closestItem = i;\n        } else {\n          closestItem = i + 1;\n        }\n        break;\n      }\n    }\n\n    let nextItem;\n    if (Math.round(closestItem - lastIndexScrolled.current) === 0) {\n      // Special case for go to next/previous with minimum amount of scroll needed\n      const nextTarget = lastScrollPos.current < currentScrollPos ? 1 : -1;\n      // This will also handle a case where we scrolled to the exact correct position (noop)\n      const isSecondaryScroll = Math.round(lastScrollPos.current - currentScrollPos) === 0;\n      const posMod = isSecondaryScroll ? 0 : nextTarget;\n      nextItem = closestItem + posMod;\n    } else {\n      // Pagination for anything else can just jump to the closest!\n      nextItem = closestItem;\n    }\n\n    // Safeguard nextItem\n    nextItem = Math.min(Math.max(0, nextItem), progressiveItemSizes.current.length);\n    closestItemPos = progressiveItemSizes.current[nextItem];\n\n    if (axis === 'vertical') {\n      scrollContainer.current.scrollTo({ top: closestItemPos, behavior: 'smooth' });\n    } else {\n      scrollContainer.current.scrollTo({ left: closestItemPos, behavior: 'smooth' });\n    }\n    lastScrollPos.current = progressiveItemSizes.current[nextItem];\n    lastIndexScrolled.current = nextItem;\n  }, [paginationEnabled, currentIndex, scrollContainer, virtualizerLength, axis, progressiveItemSizes]);\n\n  /**\n   * On scroll timer that will continuously delay callback until scrolling stops\n   */\n  const onScroll = React.useCallback(\n    event => {\n      if (timeoutRef.current) {\n        clearTimeout(timeoutRef.current);\n      }\n      timeoutRef.current = setTimeout(onScrollEnd, 100);\n    },\n    [onScrollEnd],\n  );\n\n  /**\n   * Pagination ref will ensure we attach listeners to containers on change\n   * It is returned from hook and merged into the scroll container externally\n   */\n  const paginationRef = React.useCallback(\n    (instance: HTMLElement | HTMLDivElement | null) => {\n      if (!paginationEnabled) {\n        clearListeners();\n        scrollContainer.current = null;\n        return;\n      }\n      if (scrollContainer.current !== instance) {\n        clearListeners();\n\n        scrollContainer.current = instance;\n        if (scrollContainer.current) {\n          scrollContainer.current.addEventListener('scroll', onScroll);\n        }\n      }\n    },\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [onScroll, onScrollEnd, paginationEnabled],\n  );\n\n  return paginationRef;\n};\n"],"names":["React","useRef","useDynamicVirtualizerPagination","virtualizerProps","paginationEnabled","axis","currentIndex","progressiveItemSizes","virtualizerLength","timeoutRef","lastScrollPos","lastIndexScrolled","scrollContainer","clearListeners","current","removeEventListener","onScroll","clearTimeout","useEffect","onScrollEnd","useCallback","currentScrollPos","Math","round","scrollTop","scrollLeft","closestItemPos","closestItem","endItem","min","length","i","distanceToPrev","abs","distanceToNext","nextItem","nextTarget","isSecondaryScroll","posMod","max","scrollTo","top","behavior","left","event","setTimeout","paginationRef","instance","addEventListener"],"mappings":"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"}
+{"version":3,"sources":["useDynamicPagination.ts"],"sourcesContent":["import * as React from 'react';\nimport { VirtualizerDynamicPaginationProps } from './hooks.types';\nimport { useRef } from 'react';\nimport { useTimeout } from '@fluentui/react-utilities';\n\n/**\n * Optional hook that will enable pagination on the virtualizer so that it 'autoscrolls' to an items exact position\n * Sizes are dynamic so we require a progressive sizing array (passed in from Dynamic virtualizer hooks)\n * On short scrolls, we will go at minimum to the next/previous item so that arrow pagination works\n * All VirtualizerDynamicPaginationProps can be grabbed from dynamic Virtualizer hooks externally and passed in\n */\nexport const useDynamicVirtualizerPagination = (\n  virtualizerProps: VirtualizerDynamicPaginationProps,\n  paginationEnabled: Boolean = true,\n) => {\n  const { axis = 'vertical', currentIndex, progressiveItemSizes, virtualizerLength } = virtualizerProps;\n\n  const [setScrollTimer, clearScrollTimer] = useTimeout();\n  const lastScrollPos = useRef<number>(-1);\n  const lastIndexScrolled = useRef<number>(-1);\n\n  const scrollContainer = React.useRef<HTMLElement | null>(null);\n\n  const clearListeners = () => {\n    if (scrollContainer.current) {\n      scrollContainer.current.removeEventListener('scroll', onScroll);\n      scrollContainer.current = null;\n      clearScrollTimer();\n    }\n  };\n\n  React.useEffect(() => {\n    return () => {\n      clearListeners();\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  /**\n   * Handle scroll stop event and paginate to the closest item\n   * If the closest item is the same as the previous scroll end\n   * we paginate to the next/previous one based on direction\n   *\n   * Users/Virtualizer-Hooks must pass in a cumulative array of sizes\n   * This prevents the need to recalculate and ensures size arrays are synced externally\n   */\n  const onScrollEnd = React.useCallback(() => {\n    if (!scrollContainer.current || !paginationEnabled || !progressiveItemSizes?.current) {\n      // No container found\n      return;\n    }\n\n    const currentScrollPos = Math.round(\n      axis === 'vertical' ? scrollContainer.current.scrollTop : scrollContainer.current.scrollLeft,\n    );\n    let closestItemPos = 0;\n    let closestItem = 0;\n    const endItem = Math.min(currentIndex + virtualizerLength, progressiveItemSizes.current.length);\n\n    for (let i = currentIndex; i < endItem - 1; i++) {\n      if (\n        currentScrollPos <= progressiveItemSizes.current[i + 1] &&\n        currentScrollPos >= progressiveItemSizes.current[i]\n      ) {\n        // Found our in between position\n        const distanceToPrev = Math.abs(currentScrollPos - progressiveItemSizes.current[i]);\n        const distanceToNext = Math.abs(progressiveItemSizes.current[i + 1] - currentScrollPos);\n        if (distanceToPrev < distanceToNext) {\n          closestItem = i;\n        } else {\n          closestItem = i + 1;\n        }\n        break;\n      }\n    }\n\n    let nextItem;\n    if (Math.round(closestItem - lastIndexScrolled.current) === 0) {\n      // Special case for go to next/previous with minimum amount of scroll needed\n      const nextTarget = lastScrollPos.current < currentScrollPos ? 1 : -1;\n      // This will also handle a case where we scrolled to the exact correct position (noop)\n      const isSecondaryScroll = Math.round(lastScrollPos.current - currentScrollPos) === 0;\n      const posMod = isSecondaryScroll ? 0 : nextTarget;\n      nextItem = closestItem + posMod;\n    } else {\n      // Pagination for anything else can just jump to the closest!\n      nextItem = closestItem;\n    }\n\n    // Safeguard nextItem\n    nextItem = Math.min(Math.max(0, nextItem), progressiveItemSizes.current.length);\n    closestItemPos = progressiveItemSizes.current[nextItem];\n\n    if (axis === 'vertical') {\n      scrollContainer.current.scrollTo({ top: closestItemPos, behavior: 'smooth' });\n    } else {\n      scrollContainer.current.scrollTo({ left: closestItemPos, behavior: 'smooth' });\n    }\n    lastScrollPos.current = progressiveItemSizes.current[nextItem];\n    lastIndexScrolled.current = nextItem;\n  }, [paginationEnabled, currentIndex, scrollContainer, virtualizerLength, axis, progressiveItemSizes]);\n\n  /**\n   * On scroll timer that will continuously delay callback until scrolling stops\n   */\n  const onScroll = React.useCallback(\n    event => {\n      clearScrollTimer();\n      setScrollTimer(onScrollEnd, 100);\n    },\n    [onScrollEnd, clearScrollTimer, setScrollTimer],\n  );\n\n  /**\n   * Pagination ref will ensure we attach listeners to containers on change\n   * It is returned from hook and merged into the scroll container externally\n   */\n  const paginationRef = React.useCallback(\n    (instance: HTMLElement | HTMLDivElement | null) => {\n      if (!paginationEnabled) {\n        clearListeners();\n        scrollContainer.current = null;\n        return;\n      }\n      if (scrollContainer.current !== instance) {\n        clearListeners();\n\n        scrollContainer.current = instance;\n        if (scrollContainer.current) {\n          scrollContainer.current.addEventListener('scroll', onScroll);\n        }\n      }\n    },\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [onScroll, onScrollEnd, paginationEnabled],\n  );\n\n  return paginationRef;\n};\n"],"names":["React","useRef","useTimeout","useDynamicVirtualizerPagination","virtualizerProps","paginationEnabled","axis","currentIndex","progressiveItemSizes","virtualizerLength","setScrollTimer","clearScrollTimer","lastScrollPos","lastIndexScrolled","scrollContainer","clearListeners","current","removeEventListener","onScroll","useEffect","onScrollEnd","useCallback","currentScrollPos","Math","round","scrollTop","scrollLeft","closestItemPos","closestItem","endItem","min","length","i","distanceToPrev","abs","distanceToNext","nextItem","nextTarget","isSecondaryScroll","posMod","max","scrollTo","top","behavior","left","event","paginationRef","instance","addEventListener"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,SAASC,MAAM,QAAQ,QAAQ;AAC/B,SAASC,UAAU,QAAQ,4BAA4B;AAEvD;;;;;CAKC,GACD,OAAO,MAAMC,kCAAkC,CAC7CC,kBACAC,oBAA6B,IAAI;IAEjC,MAAM,EAAEC,OAAO,UAAU,EAAEC,YAAY,EAAEC,oBAAoB,EAAEC,iBAAiB,EAAE,GAAGL;IAErF,MAAM,CAACM,gBAAgBC,iBAAiB,GAAGT;IAC3C,MAAMU,gBAAgBX,OAAe,CAAC;IACtC,MAAMY,oBAAoBZ,OAAe,CAAC;IAE1C,MAAMa,kBAAkBd,MAAMC,MAAM,CAAqB;IAEzD,MAAMc,iBAAiB;QACrB,IAAID,gBAAgBE,OAAO,EAAE;YAC3BF,gBAAgBE,OAAO,CAACC,mBAAmB,CAAC,UAAUC;YACtDJ,gBAAgBE,OAAO,GAAG;YAC1BL;QACF;IACF;IAEAX,MAAMmB,SAAS,CAAC;QACd,OAAO;YACLJ;QACF;IACA,uDAAuD;IACzD,GAAG,EAAE;IAEL;;;;;;;GAOC,GACD,MAAMK,cAAcpB,MAAMqB,WAAW,CAAC;QACpC,IAAI,CAACP,gBAAgBE,OAAO,IAAI,CAACX,qBAAqB,EAACG,iCAAAA,2CAAAA,qBAAsBQ,OAAO,GAAE;YACpF,qBAAqB;YACrB;QACF;QAEA,MAAMM,mBAAmBC,KAAKC,KAAK,CACjClB,SAAS,aAAaQ,gBAAgBE,OAAO,CAACS,SAAS,GAAGX,gBAAgBE,OAAO,CAACU,UAAU;QAE9F,IAAIC,iBAAiB;QACrB,IAAIC,cAAc;QAClB,MAAMC,UAAUN,KAAKO,GAAG,CAACvB,eAAeE,mBAAmBD,qBAAqBQ,OAAO,CAACe,MAAM;QAE9F,IAAK,IAAIC,IAAIzB,cAAcyB,IAAIH,UAAU,GAAGG,IAAK;YAC/C,IACEV,oBAAoBd,qBAAqBQ,OAAO,CAACgB,IAAI,EAAE,IACvDV,oBAAoBd,qBAAqBQ,OAAO,CAACgB,EAAE,EACnD;gBACA,gCAAgC;gBAChC,MAAMC,iBAAiBV,KAAKW,GAAG,CAACZ,mBAAmBd,qBAAqBQ,OAAO,CAACgB,EAAE;gBAClF,MAAMG,iBAAiBZ,KAAKW,GAAG,CAAC1B,qBAAqBQ,OAAO,CAACgB,IAAI,EAAE,GAAGV;gBACtE,IAAIW,iBAAiBE,gBAAgB;oBACnCP,cAAcI;gBAChB,OAAO;oBACLJ,cAAcI,IAAI;gBACpB;gBACA;YACF;QACF;QAEA,IAAII;QACJ,IAAIb,KAAKC,KAAK,CAACI,cAAcf,kBAAkBG,OAAO,MAAM,GAAG;YAC7D,4EAA4E;YAC5E,MAAMqB,aAAazB,cAAcI,OAAO,GAAGM,mBAAmB,IAAI,CAAC;YACnE,sFAAsF;YACtF,MAAMgB,oBAAoBf,KAAKC,KAAK,CAACZ,cAAcI,OAAO,GAAGM,sBAAsB;YACnF,MAAMiB,SAASD,oBAAoB,IAAID;YACvCD,WAAWR,cAAcW;QAC3B,OAAO;YACL,6DAA6D;YAC7DH,WAAWR;QACb;QAEA,qBAAqB;QACrBQ,WAAWb,KAAKO,GAAG,CAACP,KAAKiB,GAAG,CAAC,GAAGJ,WAAW5B,qBAAqBQ,OAAO,CAACe,MAAM;QAC9EJ,iBAAiBnB,qBAAqBQ,OAAO,CAACoB,SAAS;QAEvD,IAAI9B,SAAS,YAAY;YACvBQ,gBAAgBE,OAAO,CAACyB,QAAQ,CAAC;gBAAEC,KAAKf;gBAAgBgB,UAAU;YAAS;QAC7E,OAAO;YACL7B,gBAAgBE,OAAO,CAACyB,QAAQ,CAAC;gBAAEG,MAAMjB;gBAAgBgB,UAAU;YAAS;QAC9E;QACA/B,cAAcI,OAAO,GAAGR,qBAAqBQ,OAAO,CAACoB,SAAS;QAC9DvB,kBAAkBG,OAAO,GAAGoB;IAC9B,GAAG;QAAC/B;QAAmBE;QAAcO;QAAiBL;QAAmBH;QAAME;KAAqB;IAEpG;;GAEC,GACD,MAAMU,WAAWlB,MAAMqB,WAAW,CAChCwB,CAAAA;QACElC;QACAD,eAAeU,aAAa;IAC9B,GACA;QAACA;QAAaT;QAAkBD;KAAe;IAGjD;;;GAGC,GACD,MAAMoC,gBAAgB9C,MAAMqB,WAAW,CACrC,CAAC0B;QACC,IAAI,CAAC1C,mBAAmB;YACtBU;YACAD,gBAAgBE,OAAO,GAAG;YAC1B;QACF;QACA,IAAIF,gBAAgBE,OAAO,KAAK+B,UAAU;YACxChC;YAEAD,gBAAgBE,OAAO,GAAG+B;YAC1B,IAAIjC,gBAAgBE,OAAO,EAAE;gBAC3BF,gBAAgBE,OAAO,CAACgC,gBAAgB,CAAC,UAAU9B;YACrD;QACF;IACF,GACA,uDAAuD;IACvD;QAACA;QAAUE;QAAaf;KAAkB;IAG5C,OAAOyC;AACT,EAAE"}

package/lib/hooks/useIntersectionObserver.js

@@ -75,11 +75,14 @@ import { useMutationObserver } from './useMutationObserver';
     // Observer elements in passed in list and clean up previous list
     // This effect is only triggered when observerList is updated
     useIsomorphicLayoutEffect(()=>{
-        observer.current = new IntersectionObserver(callback, {
+        const win = targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.defaultView;
+        if (!win) {
+            return;
+        }
+        observer.current = new win.IntersectionObserver(callback, {
             ...observerInit,
             rootMargin: getRTLRootMargin(ltrRootMargin.current, observerInit === null || observerInit === void 0 ? void 0 : observerInit.root)
         });
-        observer.current = new IntersectionObserver(callback, observerInit);
         // If we have an instance of IO and a list with elements, observer the elements
         if (observer.current && observerList && observerList.length > 0) {
             observerList.forEach((element)=>{
@@ -96,7 +99,8 @@ import { useMutationObserver } from './useMutationObserver';
     }, [
         observerList,
         observerInit,
-        callback
+        callback,
+        targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.defaultView
     ]);
     // Do not use internally, we need to track external settings only here
     const setObserverInitExternal = useCallback((newInit)=>{

package/lib/hooks/useIntersectionObserver.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useIntersectionObserver.ts"],"sourcesContent":["import type { Dispatch, MutableRefObject, SetStateAction } from 'react';\nimport * as React from 'react';\nimport { useIsomorphicLayoutEffect } from '@fluentui/react-utilities';\nimport { useFluent_unstable as useFluent } from '@fluentui/react-shared-contexts';\n\nconst { useCallback, useState, useRef } = React;\nimport { useMutationObserver } from './useMutationObserver';\n\n/**\n * This function will take the rootMargin and flip the sides if we are in RTL based on the computed reading direction of the target element.\n * @param ltrRootMargin the margin to be processed and flipped if required\n * @param target target element that will have its current reading direction determined\n * @returns the corrected rootMargin (if it was necessary to correct)\n */\nexport const getRTLRootMargin = (ltrRootMargin: string, target?: Element | Document | null | undefined): string => {\n  if (target) {\n    // get the computed dir for the target element\n    const newDir = getComputedStyle(target as Element).direction;\n\n    // If we're in rtl reading direction, we might need to flip the margins on the left/right sides\n    if (newDir === 'rtl') {\n      let newMargin = ltrRootMargin;\n      const splitMargins = ltrRootMargin.split(' ');\n\n      // We only need to do this if we get four values, otherwise the sides are equal and don't require flipping.\n      if (splitMargins.length === 4) {\n        newMargin = `${splitMargins[0]} ${splitMargins[3]} ${splitMargins[2]} ${splitMargins[1]}`;\n      }\n\n      return newMargin;\n    } else {\n      return ltrRootMargin;\n    }\n  }\n\n  return ltrRootMargin;\n};\n\n/**\n * React hook that allows easy usage of the browser API IntersectionObserver within React\n * @param callback - A function called when the percentage of the target element is visible crosses a threshold.\n * @param options - An optional object which customizes the observer. If options isn't specified, the observer uses the\n * document's viewport as the root, with no margin, and a 0% threshold (meaning that even a one-pixel change is\n * enough to trigger a callback).\n * @returns An array containing a callback to update the list of Elements the observer should listen to, a callback to\n * update the init options of the IntersectionObserver and a ref to the IntersectionObserver instance itself.\n */\n\nexport const useIntersectionObserver = (\n  callback: IntersectionObserverCallback,\n  options?: IntersectionObserverInit,\n): {\n  setObserverList: Dispatch<SetStateAction<Element[] | undefined>>;\n  setObserverInit: (newInit: IntersectionObserverInit | undefined) => void;\n  observer: MutableRefObject<IntersectionObserver | undefined>;\n} => {\n  const observer = useRef<IntersectionObserver>();\n  const [observerList, setObserverList] = useState<Element[]>();\n  const { targetDocument } = useFluent();\n\n  // set the initial init with corrected margins based on the observed root's calculated reading direction.\n  const [observerInit, setObserverInit] = useState<IntersectionObserverInit | undefined>(\n    options && {\n      ...options,\n      rootMargin: getRTLRootMargin(options.rootMargin ?? '0px', options.root as Element),\n    },\n  );\n\n  // We have to assume that any values passed in for rootMargin by the consuming app are ltr values. As such we will store the ltr value.\n  const ltrRootMargin = useRef<string>(options?.rootMargin ?? '0px');\n\n  // Callback function to execute when mutations are observed\n  const mutationObserverCallback: MutationCallback = useCallback(\n    mutationList => {\n      for (const mutation of mutationList) {\n        // Ensuring that the right attribute is being observed and that the root is within the tree of the element being mutated.\n        if (\n          mutation.type === 'attributes' &&\n          mutation.attributeName === 'dir' &&\n          options?.root &&\n          mutation.target.contains(options?.root)\n        ) {\n          setObserverInit({\n            ...observerInit,\n            rootMargin: getRTLRootMargin(ltrRootMargin.current, observerInit?.root),\n          });\n        }\n      }\n    },\n    [ltrRootMargin, observerInit, options?.root],\n  );\n\n  // Mutation observer for dir attribute changes in the document\n  useMutationObserver(targetDocument, mutationObserverCallback, {\n    attributes: true,\n    subtree: true,\n    attributeFilter: ['dir'],\n  });\n\n  // Observer elements in passed in list and clean up previous list\n  // This effect is only triggered when observerList is updated\n  useIsomorphicLayoutEffect(() => {\n    observer.current = new IntersectionObserver(callback, {\n      ...observerInit,\n      rootMargin: getRTLRootMargin(ltrRootMargin.current, observerInit?.root),\n    });\n\n    observer.current = new IntersectionObserver(callback, observerInit);\n\n    // If we have an instance of IO and a list with elements, observer the elements\n    if (observer.current && observerList && observerList.length > 0) {\n      observerList.forEach(element => {\n        observer.current?.observe(element);\n      });\n    }\n\n    // clean up previous elements being listened to\n    return () => {\n      if (observer.current) {\n        observer.current.disconnect();\n      }\n    };\n  }, [observerList, observerInit, callback]);\n\n  // Do not use internally, we need to track external settings only here\n  const setObserverInitExternal = useCallback(\n    (newInit: IntersectionObserverInit | undefined) => {\n      // Since we know this is coming from consumers, we can store this value as LTR somewhat safely.\n      ltrRootMargin.current = newInit?.rootMargin ?? '0px';\n\n      // Call the internal setter to update the value and ensure if our calculated direction is rtl, we flip the margin\n      setObserverInit({\n        ...newInit,\n        rootMargin: getRTLRootMargin(ltrRootMargin.current, newInit?.root as Element),\n      });\n    },\n    [ltrRootMargin, setObserverInit],\n  );\n\n  return { setObserverList, setObserverInit: setObserverInitExternal, observer };\n};\n"],"names":["React","useIsomorphicLayoutEffect","useFluent_unstable","useFluent","useCallback","useState","useRef","useMutationObserver","getRTLRootMargin","ltrRootMargin","target","newDir","getComputedStyle","direction","newMargin","splitMargins","split","length","useIntersectionObserver","callback","options","observer","observerList","setObserverList","targetDocument","observerInit","setObserverInit","rootMargin","root","mutationObserverCallback","mutationList","mutation","type","attributeName","contains","current","attributes","subtree","attributeFilter","IntersectionObserver","forEach","element","observe","disconnect","setObserverInitExternal","newInit"],"mappings":"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"}
+{"version":3,"sources":["useIntersectionObserver.ts"],"sourcesContent":["import type { Dispatch, MutableRefObject, SetStateAction } from 'react';\nimport * as React from 'react';\nimport { useIsomorphicLayoutEffect } from '@fluentui/react-utilities';\nimport { useFluent_unstable as useFluent } from '@fluentui/react-shared-contexts';\n\nconst { useCallback, useState, useRef } = React;\nimport { useMutationObserver } from './useMutationObserver';\n\n/**\n * This function will take the rootMargin and flip the sides if we are in RTL based on the computed reading direction of the target element.\n * @param ltrRootMargin the margin to be processed and flipped if required\n * @param target target element that will have its current reading direction determined\n * @returns the corrected rootMargin (if it was necessary to correct)\n */\nexport const getRTLRootMargin = (ltrRootMargin: string, target?: Element | Document | null | undefined): string => {\n  if (target) {\n    // get the computed dir for the target element\n    const newDir = getComputedStyle(target as Element).direction;\n\n    // If we're in rtl reading direction, we might need to flip the margins on the left/right sides\n    if (newDir === 'rtl') {\n      let newMargin = ltrRootMargin;\n      const splitMargins = ltrRootMargin.split(' ');\n\n      // We only need to do this if we get four values, otherwise the sides are equal and don't require flipping.\n      if (splitMargins.length === 4) {\n        newMargin = `${splitMargins[0]} ${splitMargins[3]} ${splitMargins[2]} ${splitMargins[1]}`;\n      }\n\n      return newMargin;\n    } else {\n      return ltrRootMargin;\n    }\n  }\n\n  return ltrRootMargin;\n};\n\n/**\n * React hook that allows easy usage of the browser API IntersectionObserver within React\n * @param callback - A function called when the percentage of the target element is visible crosses a threshold.\n * @param options - An optional object which customizes the observer. If options isn't specified, the observer uses the\n * document's viewport as the root, with no margin, and a 0% threshold (meaning that even a one-pixel change is\n * enough to trigger a callback).\n * @returns An array containing a callback to update the list of Elements the observer should listen to, a callback to\n * update the init options of the IntersectionObserver and a ref to the IntersectionObserver instance itself.\n */\n\nexport const useIntersectionObserver = (\n  callback: IntersectionObserverCallback,\n  options?: IntersectionObserverInit,\n): {\n  setObserverList: Dispatch<SetStateAction<Element[] | undefined>>;\n  setObserverInit: (newInit: IntersectionObserverInit | undefined) => void;\n  observer: MutableRefObject<IntersectionObserver | undefined>;\n} => {\n  const observer = useRef<IntersectionObserver>();\n  const [observerList, setObserverList] = useState<Element[]>();\n  const { targetDocument } = useFluent();\n\n  // set the initial init with corrected margins based on the observed root's calculated reading direction.\n  const [observerInit, setObserverInit] = useState<IntersectionObserverInit | undefined>(\n    options && {\n      ...options,\n      rootMargin: getRTLRootMargin(options.rootMargin ?? '0px', options.root as Element),\n    },\n  );\n\n  // We have to assume that any values passed in for rootMargin by the consuming app are ltr values. As such we will store the ltr value.\n  const ltrRootMargin = useRef<string>(options?.rootMargin ?? '0px');\n\n  // Callback function to execute when mutations are observed\n  const mutationObserverCallback: MutationCallback = useCallback(\n    mutationList => {\n      for (const mutation of mutationList) {\n        // Ensuring that the right attribute is being observed and that the root is within the tree of the element being mutated.\n        if (\n          mutation.type === 'attributes' &&\n          mutation.attributeName === 'dir' &&\n          options?.root &&\n          mutation.target.contains(options?.root)\n        ) {\n          setObserverInit({\n            ...observerInit,\n            rootMargin: getRTLRootMargin(ltrRootMargin.current, observerInit?.root),\n          });\n        }\n      }\n    },\n    [ltrRootMargin, observerInit, options?.root],\n  );\n\n  // Mutation observer for dir attribute changes in the document\n  useMutationObserver(targetDocument, mutationObserverCallback, {\n    attributes: true,\n    subtree: true,\n    attributeFilter: ['dir'],\n  });\n\n  // Observer elements in passed in list and clean up previous list\n  // This effect is only triggered when observerList is updated\n  useIsomorphicLayoutEffect(() => {\n    const win = targetDocument?.defaultView;\n    if (!win) {\n      return;\n    }\n\n    observer.current = new win.IntersectionObserver(callback, {\n      ...observerInit,\n      rootMargin: getRTLRootMargin(ltrRootMargin.current, observerInit?.root),\n    });\n\n    // If we have an instance of IO and a list with elements, observer the elements\n    if (observer.current && observerList && observerList.length > 0) {\n      observerList.forEach(element => {\n        observer.current?.observe(element);\n      });\n    }\n\n    // clean up previous elements being listened to\n    return () => {\n      if (observer.current) {\n        observer.current.disconnect();\n      }\n    };\n  }, [observerList, observerInit, callback, targetDocument?.defaultView]);\n\n  // Do not use internally, we need to track external settings only here\n  const setObserverInitExternal = useCallback(\n    (newInit: IntersectionObserverInit | undefined) => {\n      // Since we know this is coming from consumers, we can store this value as LTR somewhat safely.\n      ltrRootMargin.current = newInit?.rootMargin ?? '0px';\n\n      // Call the internal setter to update the value and ensure if our calculated direction is rtl, we flip the margin\n      setObserverInit({\n        ...newInit,\n        rootMargin: getRTLRootMargin(ltrRootMargin.current, newInit?.root as Element),\n      });\n    },\n    [ltrRootMargin, setObserverInit],\n  );\n\n  return { setObserverList, setObserverInit: setObserverInitExternal, observer };\n};\n"],"names":["React","useIsomorphicLayoutEffect","useFluent_unstable","useFluent","useCallback","useState","useRef","useMutationObserver","getRTLRootMargin","ltrRootMargin","target","newDir","getComputedStyle","direction","newMargin","splitMargins","split","length","useIntersectionObserver","callback","options","observer","observerList","setObserverList","targetDocument","observerInit","setObserverInit","rootMargin","root","mutationObserverCallback","mutationList","mutation","type","attributeName","contains","current","attributes","subtree","attributeFilter","win","defaultView","IntersectionObserver","forEach","element","observe","disconnect","setObserverInitExternal","newInit"],"mappings":"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"}

package/lib/hooks/useStaticPagination.js

@@ -1,5 +1,6 @@
 import * as React from 'react';
 import { useRef } from 'react';
+import { useTimeout } from '@fluentui/react-utilities';
 /**
  * Optional hook that will enable pagination on the virtualizer so that it 'autoscrolls' to an items exact position
  * Sizes are uniform/static, we round to the nearest item on long scrolls
@@ -7,7 +8,7 @@ import { useRef } from 'react';
  * All VirtualizerStaticPaginationProps can be grabbed from Virtualizer hooks externally and passed in
  */ export const useStaticVirtualizerPagination = (virtualizerProps, paginationEnabled = true)=>{
     const { itemSize, axis = 'vertical' } = virtualizerProps;
-    const timeoutRef = useRef(null);
+    const [setScrollTimer, clearScrollTimer] = useTimeout();
     const lastScrollPos = useRef(0);
     const lastIndexScrolled = useRef(0);
     const scrollContainer = React.useRef(null);
@@ -15,9 +16,7 @@ import { useRef } from 'react';
         if (scrollContainer.current) {
             scrollContainer.current.removeEventListener('scroll', onScroll);
             scrollContainer.current = null;
-            if (timeoutRef.current) {
-                clearTimeout(timeoutRef.current);
-            }
+            clearScrollTimer();
         }
     };
     React.useEffect(()=>{
@@ -70,12 +69,12 @@ import { useRef } from 'react';
     /**
    * On scroll timer that will continuously delay callback until scrolling stops
    */ const onScroll = React.useCallback((event)=>{
-        if (timeoutRef.current) {
-            clearTimeout(timeoutRef.current);
-        }
-        timeoutRef.current = setTimeout(onScrollEnd, 100);
+        clearScrollTimer();
+        setScrollTimer(onScrollEnd, 100);
     }, [
-        onScrollEnd
+        onScrollEnd,
+        clearScrollTimer,
+        setScrollTimer
     ]);
     /**
    * Pagination ref will ensure we attach listeners to containers on change

package/lib/hooks/useStaticPagination.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useStaticPagination.ts"],"sourcesContent":["import * as React from 'react';\nimport { VirtualizerStaticPaginationProps } from './hooks.types';\nimport { useRef } from 'react';\n\n/**\n * Optional hook that will enable pagination on the virtualizer so that it 'autoscrolls' to an items exact position\n * Sizes are uniform/static, we round to the nearest item on long scrolls\n * On short scrolls, we will go at minimum to the next/previous item so that arrow pagination works\n * All VirtualizerStaticPaginationProps can be grabbed from Virtualizer hooks externally and passed in\n */\nexport const useStaticVirtualizerPagination = (\n  virtualizerProps: VirtualizerStaticPaginationProps,\n  paginationEnabled: Boolean = true,\n) => {\n  const { itemSize, axis = 'vertical' } = virtualizerProps;\n\n  const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);\n  const lastScrollPos = useRef<number>(0);\n  const lastIndexScrolled = useRef<number>(0);\n\n  const scrollContainer = React.useRef<HTMLElement | null>(null);\n\n  const clearListeners = () => {\n    if (scrollContainer.current) {\n      scrollContainer.current.removeEventListener('scroll', onScroll);\n\n      scrollContainer.current = null;\n      if (timeoutRef.current) {\n        clearTimeout(timeoutRef.current);\n      }\n    }\n  };\n\n  React.useEffect(() => {\n    return () => {\n      clearListeners();\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  /**\n   * Handle scroll stop event and paginate to the closest item\n   * If the closest item is the same as the previous scroll end\n   * we paginate to the next/previous one based on direction\n   */\n  const onScrollEnd = React.useCallback(() => {\n    if (!scrollContainer.current || !paginationEnabled) {\n      // No container found\n      return;\n    }\n\n    const currentScrollPos = Math.round(\n      axis === 'vertical' ? scrollContainer.current.scrollTop : scrollContainer.current.scrollLeft,\n    );\n    const closestItem = Math.round(currentScrollPos / itemSize);\n\n    let nextItem = 0;\n    if (Math.round(closestItem - lastIndexScrolled.current) === 0) {\n      // Special case for go to next/previous with minimum amount of scroll needed\n      const nextTarget = lastScrollPos.current < currentScrollPos ? 1 : -1;\n      const isSecondaryScroll = lastScrollPos.current === currentScrollPos;\n      const posMod = isSecondaryScroll ? 0 : nextTarget;\n\n      nextItem = closestItem + posMod;\n    } else {\n      // Pagination for anything else can just jump to the closest!\n      nextItem = closestItem;\n    }\n\n    const nextItemPos = nextItem * itemSize;\n\n    if (axis === 'vertical') {\n      scrollContainer.current.scrollTo({ top: nextItemPos, behavior: 'smooth' });\n    } else {\n      scrollContainer.current.scrollTo({ left: nextItemPos, behavior: 'smooth' });\n    }\n    lastScrollPos.current = nextItemPos;\n    lastIndexScrolled.current = nextItem;\n  }, [paginationEnabled, axis, itemSize]);\n\n  /**\n   * On scroll timer that will continuously delay callback until scrolling stops\n   */\n  const onScroll = React.useCallback(\n    event => {\n      if (timeoutRef.current) {\n        clearTimeout(timeoutRef.current);\n      }\n      timeoutRef.current = setTimeout(onScrollEnd, 100);\n    },\n    [onScrollEnd],\n  );\n\n  /**\n   * Pagination ref will ensure we attach listeners to containers on change\n   * It is returned from hook and merged into the scroll container externally\n   */\n  const paginationRef = React.useCallback(\n    (instance: HTMLElement | HTMLDivElement | null) => {\n      if (!paginationEnabled) {\n        clearListeners();\n        scrollContainer.current = null;\n        return;\n      }\n      if (scrollContainer.current !== instance) {\n        clearListeners();\n\n        scrollContainer.current = instance;\n        if (scrollContainer.current) {\n          scrollContainer.current.addEventListener('scroll', onScroll);\n        }\n      }\n    },\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [onScroll, onScrollEnd, paginationEnabled],\n  );\n\n  return paginationRef;\n};\n"],"names":["React","useRef","useStaticVirtualizerPagination","virtualizerProps","paginationEnabled","itemSize","axis","timeoutRef","lastScrollPos","lastIndexScrolled","scrollContainer","clearListeners","current","removeEventListener","onScroll","clearTimeout","useEffect","onScrollEnd","useCallback","currentScrollPos","Math","round","scrollTop","scrollLeft","closestItem","nextItem","nextTarget","isSecondaryScroll","posMod","nextItemPos","scrollTo","top","behavior","left","event","setTimeout","paginationRef","instance","addEventListener"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,SAASC,MAAM,QAAQ,QAAQ;AAE/B;;;;;CAKC,GACD,OAAO,MAAMC,iCAAiC,CAC5CC,kBACAC,oBAA6B,IAAI;IAEjC,MAAM,EAAEC,QAAQ,EAAEC,OAAO,UAAU,EAAE,GAAGH;IAExC,MAAMI,aAAaN,OAA6C;IAChE,MAAMO,gBAAgBP,OAAe;IACrC,MAAMQ,oBAAoBR,OAAe;IAEzC,MAAMS,kBAAkBV,MAAMC,MAAM,CAAqB;IAEzD,MAAMU,iBAAiB;QACrB,IAAID,gBAAgBE,OAAO,EAAE;YAC3BF,gBAAgBE,OAAO,CAACC,mBAAmB,CAAC,UAAUC;YAEtDJ,gBAAgBE,OAAO,GAAG;YAC1B,IAAIL,WAAWK,OAAO,EAAE;gBACtBG,aAAaR,WAAWK,OAAO;YACjC;QACF;IACF;IAEAZ,MAAMgB,SAAS,CAAC;QACd,OAAO;YACLL;QACF;IACA,uDAAuD;IACzD,GAAG,EAAE;IAEL;;;;GAIC,GACD,MAAMM,cAAcjB,MAAMkB,WAAW,CAAC;QACpC,IAAI,CAACR,gBAAgBE,OAAO,IAAI,CAACR,mBAAmB;YAClD,qBAAqB;YACrB;QACF;QAEA,MAAMe,mBAAmBC,KAAKC,KAAK,CACjCf,SAAS,aAAaI,gBAAgBE,OAAO,CAACU,SAAS,GAAGZ,gBAAgBE,OAAO,CAACW,UAAU;QAE9F,MAAMC,cAAcJ,KAAKC,KAAK,CAACF,mBAAmBd;QAElD,IAAIoB,WAAW;QACf,IAAIL,KAAKC,KAAK,CAACG,cAAcf,kBAAkBG,OAAO,MAAM,GAAG;YAC7D,4EAA4E;YAC5E,MAAMc,aAAalB,cAAcI,OAAO,GAAGO,mBAAmB,IAAI,CAAC;YACnE,MAAMQ,oBAAoBnB,cAAcI,OAAO,KAAKO;YACpD,MAAMS,SAASD,oBAAoB,IAAID;YAEvCD,WAAWD,cAAcI;QAC3B,OAAO;YACL,6DAA6D;YAC7DH,WAAWD;QACb;QAEA,MAAMK,cAAcJ,WAAWpB;QAE/B,IAAIC,SAAS,YAAY;YACvBI,gBAAgBE,OAAO,CAACkB,QAAQ,CAAC;gBAAEC,KAAKF;gBAAaG,UAAU;YAAS;QAC1E,OAAO;YACLtB,gBAAgBE,OAAO,CAACkB,QAAQ,CAAC;gBAAEG,MAAMJ;gBAAaG,UAAU;YAAS;QAC3E;QACAxB,cAAcI,OAAO,GAAGiB;QACxBpB,kBAAkBG,OAAO,GAAGa;IAC9B,GAAG;QAACrB;QAAmBE;QAAMD;KAAS;IAEtC;;GAEC,GACD,MAAMS,WAAWd,MAAMkB,WAAW,CAChCgB,CAAAA;QACE,IAAI3B,WAAWK,OAAO,EAAE;YACtBG,aAAaR,WAAWK,OAAO;QACjC;QACAL,WAAWK,OAAO,GAAGuB,WAAWlB,aAAa;IAC/C,GACA;QAACA;KAAY;IAGf;;;GAGC,GACD,MAAMmB,gBAAgBpC,MAAMkB,WAAW,CACrC,CAACmB;QACC,IAAI,CAACjC,mBAAmB;YACtBO;YACAD,gBAAgBE,OAAO,GAAG;YAC1B;QACF;QACA,IAAIF,gBAAgBE,OAAO,KAAKyB,UAAU;YACxC1B;YAEAD,gBAAgBE,OAAO,GAAGyB;YAC1B,IAAI3B,gBAAgBE,OAAO,EAAE;gBAC3BF,gBAAgBE,OAAO,CAAC0B,gBAAgB,CAAC,UAAUxB;YACrD;QACF;IACF,GACA,uDAAuD;IACvD;QAACA;QAAUG;QAAab;KAAkB;IAG5C,OAAOgC;AACT,EAAE"}
+{"version":3,"sources":["useStaticPagination.ts"],"sourcesContent":["import * as React from 'react';\nimport { VirtualizerStaticPaginationProps } from './hooks.types';\nimport { useRef } from 'react';\nimport { useTimeout } from '@fluentui/react-utilities';\n\n/**\n * Optional hook that will enable pagination on the virtualizer so that it 'autoscrolls' to an items exact position\n * Sizes are uniform/static, we round to the nearest item on long scrolls\n * On short scrolls, we will go at minimum to the next/previous item so that arrow pagination works\n * All VirtualizerStaticPaginationProps can be grabbed from Virtualizer hooks externally and passed in\n */\nexport const useStaticVirtualizerPagination = (\n  virtualizerProps: VirtualizerStaticPaginationProps,\n  paginationEnabled: Boolean = true,\n) => {\n  const { itemSize, axis = 'vertical' } = virtualizerProps;\n\n  const [setScrollTimer, clearScrollTimer] = useTimeout();\n  const lastScrollPos = useRef<number>(0);\n  const lastIndexScrolled = useRef<number>(0);\n\n  const scrollContainer = React.useRef<HTMLElement | null>(null);\n\n  const clearListeners = () => {\n    if (scrollContainer.current) {\n      scrollContainer.current.removeEventListener('scroll', onScroll);\n\n      scrollContainer.current = null;\n      clearScrollTimer();\n    }\n  };\n\n  React.useEffect(() => {\n    return () => {\n      clearListeners();\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  /**\n   * Handle scroll stop event and paginate to the closest item\n   * If the closest item is the same as the previous scroll end\n   * we paginate to the next/previous one based on direction\n   */\n  const onScrollEnd = React.useCallback(() => {\n    if (!scrollContainer.current || !paginationEnabled) {\n      // No container found\n      return;\n    }\n\n    const currentScrollPos = Math.round(\n      axis === 'vertical' ? scrollContainer.current.scrollTop : scrollContainer.current.scrollLeft,\n    );\n    const closestItem = Math.round(currentScrollPos / itemSize);\n\n    let nextItem = 0;\n    if (Math.round(closestItem - lastIndexScrolled.current) === 0) {\n      // Special case for go to next/previous with minimum amount of scroll needed\n      const nextTarget = lastScrollPos.current < currentScrollPos ? 1 : -1;\n      const isSecondaryScroll = lastScrollPos.current === currentScrollPos;\n      const posMod = isSecondaryScroll ? 0 : nextTarget;\n\n      nextItem = closestItem + posMod;\n    } else {\n      // Pagination for anything else can just jump to the closest!\n      nextItem = closestItem;\n    }\n\n    const nextItemPos = nextItem * itemSize;\n\n    if (axis === 'vertical') {\n      scrollContainer.current.scrollTo({ top: nextItemPos, behavior: 'smooth' });\n    } else {\n      scrollContainer.current.scrollTo({ left: nextItemPos, behavior: 'smooth' });\n    }\n    lastScrollPos.current = nextItemPos;\n    lastIndexScrolled.current = nextItem;\n  }, [paginationEnabled, axis, itemSize]);\n\n  /**\n   * On scroll timer that will continuously delay callback until scrolling stops\n   */\n  const onScroll = React.useCallback(\n    event => {\n      clearScrollTimer();\n      setScrollTimer(onScrollEnd, 100);\n    },\n    [onScrollEnd, clearScrollTimer, setScrollTimer],\n  );\n\n  /**\n   * Pagination ref will ensure we attach listeners to containers on change\n   * It is returned from hook and merged into the scroll container externally\n   */\n  const paginationRef = React.useCallback(\n    (instance: HTMLElement | HTMLDivElement | null) => {\n      if (!paginationEnabled) {\n        clearListeners();\n        scrollContainer.current = null;\n        return;\n      }\n      if (scrollContainer.current !== instance) {\n        clearListeners();\n\n        scrollContainer.current = instance;\n        if (scrollContainer.current) {\n          scrollContainer.current.addEventListener('scroll', onScroll);\n        }\n      }\n    },\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [onScroll, onScrollEnd, paginationEnabled],\n  );\n\n  return paginationRef;\n};\n"],"names":["React","useRef","useTimeout","useStaticVirtualizerPagination","virtualizerProps","paginationEnabled","itemSize","axis","setScrollTimer","clearScrollTimer","lastScrollPos","lastIndexScrolled","scrollContainer","clearListeners","current","removeEventListener","onScroll","useEffect","onScrollEnd","useCallback","currentScrollPos","Math","round","scrollTop","scrollLeft","closestItem","nextItem","nextTarget","isSecondaryScroll","posMod","nextItemPos","scrollTo","top","behavior","left","event","paginationRef","instance","addEventListener"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,SAASC,MAAM,QAAQ,QAAQ;AAC/B,SAASC,UAAU,QAAQ,4BAA4B;AAEvD;;;;;CAKC,GACD,OAAO,MAAMC,iCAAiC,CAC5CC,kBACAC,oBAA6B,IAAI;IAEjC,MAAM,EAAEC,QAAQ,EAAEC,OAAO,UAAU,EAAE,GAAGH;IAExC,MAAM,CAACI,gBAAgBC,iBAAiB,GAAGP;IAC3C,MAAMQ,gBAAgBT,OAAe;IACrC,MAAMU,oBAAoBV,OAAe;IAEzC,MAAMW,kBAAkBZ,MAAMC,MAAM,CAAqB;IAEzD,MAAMY,iBAAiB;QACrB,IAAID,gBAAgBE,OAAO,EAAE;YAC3BF,gBAAgBE,OAAO,CAACC,mBAAmB,CAAC,UAAUC;YAEtDJ,gBAAgBE,OAAO,GAAG;YAC1BL;QACF;IACF;IAEAT,MAAMiB,SAAS,CAAC;QACd,OAAO;YACLJ;QACF;IACA,uDAAuD;IACzD,GAAG,EAAE;IAEL;;;;GAIC,GACD,MAAMK,cAAclB,MAAMmB,WAAW,CAAC;QACpC,IAAI,CAACP,gBAAgBE,OAAO,IAAI,CAACT,mBAAmB;YAClD,qBAAqB;YACrB;QACF;QAEA,MAAMe,mBAAmBC,KAAKC,KAAK,CACjCf,SAAS,aAAaK,gBAAgBE,OAAO,CAACS,SAAS,GAAGX,gBAAgBE,OAAO,CAACU,UAAU;QAE9F,MAAMC,cAAcJ,KAAKC,KAAK,CAACF,mBAAmBd;QAElD,IAAIoB,WAAW;QACf,IAAIL,KAAKC,KAAK,CAACG,cAAcd,kBAAkBG,OAAO,MAAM,GAAG;YAC7D,4EAA4E;YAC5E,MAAMa,aAAajB,cAAcI,OAAO,GAAGM,mBAAmB,IAAI,CAAC;YACnE,MAAMQ,oBAAoBlB,cAAcI,OAAO,KAAKM;YACpD,MAAMS,SAASD,oBAAoB,IAAID;YAEvCD,WAAWD,cAAcI;QAC3B,OAAO;YACL,6DAA6D;YAC7DH,WAAWD;QACb;QAEA,MAAMK,cAAcJ,WAAWpB;QAE/B,IAAIC,SAAS,YAAY;YACvBK,gBAAgBE,OAAO,CAACiB,QAAQ,CAAC;gBAAEC,KAAKF;gBAAaG,UAAU;YAAS;QAC1E,OAAO;YACLrB,gBAAgBE,OAAO,CAACiB,QAAQ,CAAC;gBAAEG,MAAMJ;gBAAaG,UAAU;YAAS;QAC3E;QACAvB,cAAcI,OAAO,GAAGgB;QACxBnB,kBAAkBG,OAAO,GAAGY;IAC9B,GAAG;QAACrB;QAAmBE;QAAMD;KAAS;IAEtC;;GAEC,GACD,MAAMU,WAAWhB,MAAMmB,WAAW,CAChCgB,CAAAA;QACE1B;QACAD,eAAeU,aAAa;IAC9B,GACA;QAACA;QAAaT;QAAkBD;KAAe;IAGjD;;;GAGC,GACD,MAAM4B,gBAAgBpC,MAAMmB,WAAW,CACrC,CAACkB;QACC,IAAI,CAAChC,mBAAmB;YACtBQ;YACAD,gBAAgBE,OAAO,GAAG;YAC1B;QACF;QACA,IAAIF,gBAAgBE,OAAO,KAAKuB,UAAU;YACxCxB;YAEAD,gBAAgBE,OAAO,GAAGuB;YAC1B,IAAIzB,gBAAgBE,OAAO,EAAE;gBAC3BF,gBAAgBE,OAAO,CAACwB,gBAAgB,CAAC,UAAUtB;YACrD;QACF;IACF,GACA,uDAAuD;IACvD;QAACA;QAAUE;QAAab;KAAkB;IAG5C,OAAO+B;AACT,EAAE"}

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

@@ -58,9 +58,9 @@ function useVirtualizer_unstable(props) {
         }
     };
     const [isScrolling, setIsScrolling] = (0, _react.useState)(false);
-    const scrollTimer = (0, _react.useRef)();
+    const [setScrollTimer, clearScrollTimer] = (0, _reactutilities.useTimeout)();
     const scrollCounter = (0, _react.useRef)(0);
-    const initializeScrollingTimer = ()=>{
+    const initializeScrollingTimer = (0, _react.useCallback)(()=>{
         /*
      * This can be considered the 'velocity' required to start 'isScrolling'
      * INIT_SCROLL_FLAG_REQ: Number of renders required to activate isScrolling
@@ -72,18 +72,20 @@ function useVirtualizer_unstable(props) {
         if (scrollCounter.current >= INIT_SCROLL_FLAG_REQ) {
             setIsScrolling(true);
         }
-        if (scrollTimer.current) {
-            clearTimeout(scrollTimer.current);
-        }
-        scrollTimer.current = setTimeout(()=>{
+        clearScrollTimer();
+        setScrollTimer(()=>{
             setIsScrolling(false);
             scrollCounter.current = 0;
         }, INIT_SCROLL_FLAG_DELAY);
-    };
+    }, [
+        clearScrollTimer,
+        setScrollTimer
+    ]);
     (0, _react.useEffect)(()=>{
         initializeScrollingTimer();
     }, [
-        actualIndex
+        actualIndex,
+        initializeScrollingTimer
     ]);
     const batchUpdateNewIndex = (index)=>{
         // Local updates

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

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

package/lib-commonjs/hooks/useDynamicPagination.js

@@ -10,9 +10,10 @@ Object.defineProperty(exports, "useDynamicVirtualizerPagination", {
 });
 const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
 const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
 const useDynamicVirtualizerPagination = (virtualizerProps, paginationEnabled = true)=>{
     const { axis = 'vertical', currentIndex, progressiveItemSizes, virtualizerLength } = virtualizerProps;
-    const timeoutRef = (0, _react.useRef)(null);
+    const [setScrollTimer, clearScrollTimer] = (0, _reactutilities.useTimeout)();
     const lastScrollPos = (0, _react.useRef)(-1);
     const lastIndexScrolled = (0, _react.useRef)(-1);
     const scrollContainer = _react.useRef(null);
@@ -20,9 +21,7 @@ const useDynamicVirtualizerPagination = (virtualizerProps, paginationEnabled = t
         if (scrollContainer.current) {
             scrollContainer.current.removeEventListener('scroll', onScroll);
             scrollContainer.current = null;
-            if (timeoutRef.current) {
-                clearTimeout(timeoutRef.current);
-            }
+            clearScrollTimer();
         }
     };
     _react.useEffect(()=>{
@@ -99,12 +98,12 @@ const useDynamicVirtualizerPagination = (virtualizerProps, paginationEnabled = t
     /**
    * On scroll timer that will continuously delay callback until scrolling stops
    */ const onScroll = _react.useCallback((event)=>{
-        if (timeoutRef.current) {
-            clearTimeout(timeoutRef.current);
-        }
-        timeoutRef.current = setTimeout(onScrollEnd, 100);
+        clearScrollTimer();
+        setScrollTimer(onScrollEnd, 100);
     }, [
-        onScrollEnd
+        onScrollEnd,
+        clearScrollTimer,
+        setScrollTimer
     ]);
     /**
    * Pagination ref will ensure we attach listeners to containers on change

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

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

package/lib-commonjs/hooks/useIntersectionObserver.js

@@ -81,11 +81,14 @@ const useIntersectionObserver = (callback, options)=>{
     // Observer elements in passed in list and clean up previous list
     // This effect is only triggered when observerList is updated
     (0, _reactutilities.useIsomorphicLayoutEffect)(()=>{
-        observer.current = new IntersectionObserver(callback, {
+        const win = targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.defaultView;
+        if (!win) {
+            return;
+        }
+        observer.current = new win.IntersectionObserver(callback, {
             ...observerInit,
             rootMargin: getRTLRootMargin(ltrRootMargin.current, observerInit === null || observerInit === void 0 ? void 0 : observerInit.root)
         });
-        observer.current = new IntersectionObserver(callback, observerInit);
         // If we have an instance of IO and a list with elements, observer the elements
         if (observer.current && observerList && observerList.length > 0) {
             observerList.forEach((element)=>{
@@ -102,7 +105,8 @@ const useIntersectionObserver = (callback, options)=>{
     }, [
         observerList,
         observerInit,
-        callback
+        callback,
+        targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.defaultView
     ]);
     // Do not use internally, we need to track external settings only here
     const setObserverInitExternal = useCallback((newInit)=>{

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

@@ -1 +1 @@
-{"version":3,"sources":["useIntersectionObserver.js"],"sourcesContent":["import * as React from 'react';\nimport { useIsomorphicLayoutEffect } from '@fluentui/react-utilities';\nimport { useFluent_unstable as useFluent } from '@fluentui/react-shared-contexts';\nconst { useCallback, useState, useRef } = React;\nimport { useMutationObserver } from './useMutationObserver';\n/**\n * This function will take the rootMargin and flip the sides if we are in RTL based on the computed reading direction of the target element.\n * @param ltrRootMargin the margin to be processed and flipped if required\n * @param target target element that will have its current reading direction determined\n * @returns the corrected rootMargin (if it was necessary to correct)\n */ export const getRTLRootMargin = (ltrRootMargin, target)=>{\n    if (target) {\n        // get the computed dir for the target element\n        const newDir = getComputedStyle(target).direction;\n        // If we're in rtl reading direction, we might need to flip the margins on the left/right sides\n        if (newDir === 'rtl') {\n            let newMargin = ltrRootMargin;\n            const splitMargins = ltrRootMargin.split(' ');\n            // We only need to do this if we get four values, otherwise the sides are equal and don't require flipping.\n            if (splitMargins.length === 4) {\n                newMargin = `${splitMargins[0]} ${splitMargins[3]} ${splitMargins[2]} ${splitMargins[1]}`;\n            }\n            return newMargin;\n        } else {\n            return ltrRootMargin;\n        }\n    }\n    return ltrRootMargin;\n};\n/**\n * React hook that allows easy usage of the browser API IntersectionObserver within React\n * @param callback - A function called when the percentage of the target element is visible crosses a threshold.\n * @param options - An optional object which customizes the observer. If options isn't specified, the observer uses the\n * document's viewport as the root, with no margin, and a 0% threshold (meaning that even a one-pixel change is\n * enough to trigger a callback).\n * @returns An array containing a callback to update the list of Elements the observer should listen to, a callback to\n * update the init options of the IntersectionObserver and a ref to the IntersectionObserver instance itself.\n */ export const useIntersectionObserver = (callback, options)=>{\n    const observer = useRef();\n    const [observerList, setObserverList] = useState();\n    const { targetDocument } = useFluent();\n    var _options_rootMargin;\n    // set the initial init with corrected margins based on the observed root's calculated reading direction.\n    const [observerInit, setObserverInit] = useState(options && {\n        ...options,\n        rootMargin: getRTLRootMargin((_options_rootMargin = options.rootMargin) !== null && _options_rootMargin !== void 0 ? _options_rootMargin : '0px', options.root)\n    });\n    var _options_rootMargin1;\n    // We have to assume that any values passed in for rootMargin by the consuming app are ltr values. As such we will store the ltr value.\n    const ltrRootMargin = useRef((_options_rootMargin1 = options === null || options === void 0 ? void 0 : options.rootMargin) !== null && _options_rootMargin1 !== void 0 ? _options_rootMargin1 : '0px');\n    // Callback function to execute when mutations are observed\n    const mutationObserverCallback = useCallback((mutationList)=>{\n        for (const mutation of mutationList){\n            // Ensuring that the right attribute is being observed and that the root is within the tree of the element being mutated.\n            if (mutation.type === 'attributes' && mutation.attributeName === 'dir' && (options === null || options === void 0 ? void 0 : options.root) && mutation.target.contains(options === null || options === void 0 ? void 0 : options.root)) {\n                setObserverInit({\n                    ...observerInit,\n                    rootMargin: getRTLRootMargin(ltrRootMargin.current, observerInit === null || observerInit === void 0 ? void 0 : observerInit.root)\n                });\n            }\n        }\n    }, [\n        ltrRootMargin,\n        observerInit,\n        options === null || options === void 0 ? void 0 : options.root\n    ]);\n    // Mutation observer for dir attribute changes in the document\n    useMutationObserver(targetDocument, mutationObserverCallback, {\n        attributes: true,\n        subtree: true,\n        attributeFilter: [\n            'dir'\n        ]\n    });\n    // Observer elements in passed in list and clean up previous list\n    // This effect is only triggered when observerList is updated\n    useIsomorphicLayoutEffect(()=>{\n        observer.current = new IntersectionObserver(callback, {\n            ...observerInit,\n            rootMargin: getRTLRootMargin(ltrRootMargin.current, observerInit === null || observerInit === void 0 ? void 0 : observerInit.root)\n        });\n        observer.current = new IntersectionObserver(callback, observerInit);\n        // If we have an instance of IO and a list with elements, observer the elements\n        if (observer.current && observerList && observerList.length > 0) {\n            observerList.forEach((element)=>{\n                var _observer_current;\n                (_observer_current = observer.current) === null || _observer_current === void 0 ? void 0 : _observer_current.observe(element);\n            });\n        }\n        // clean up previous elements being listened to\n        return ()=>{\n            if (observer.current) {\n                observer.current.disconnect();\n            }\n        };\n    }, [\n        observerList,\n        observerInit,\n        callback\n    ]);\n    // Do not use internally, we need to track external settings only here\n    const setObserverInitExternal = useCallback((newInit)=>{\n        var _newInit_rootMargin;\n        // Since we know this is coming from consumers, we can store this value as LTR somewhat safely.\n        ltrRootMargin.current = (_newInit_rootMargin = newInit === null || newInit === void 0 ? void 0 : newInit.rootMargin) !== null && _newInit_rootMargin !== void 0 ? _newInit_rootMargin : '0px';\n        // Call the internal setter to update the value and ensure if our calculated direction is rtl, we flip the margin\n        setObserverInit({\n            ...newInit,\n            rootMargin: getRTLRootMargin(ltrRootMargin.current, newInit === null || newInit === void 0 ? void 0 : newInit.root)\n        });\n    }, [\n        ltrRootMargin,\n        setObserverInit\n    ]);\n    return {\n        setObserverList,\n        setObserverInit: setObserverInitExternal,\n        observer\n    };\n};\n"],"names":["getRTLRootMargin","useIntersectionObserver","useCallback","useState","useRef","React","ltrRootMargin","target","newDir","getComputedStyle","direction","newMargin","splitMargins","split","length","callback","options","observer","observerList","setObserverList","targetDocument","useFluent","_options_rootMargin","observerInit","setObserverInit","rootMargin","root","_options_rootMargin1","mutationObserverCallback","mutationList","mutation","type","attributeName","contains","current","useMutationObserver","attributes","subtree","attributeFilter","useIsomorphicLayoutEffect","IntersectionObserver","forEach","element","_observer_current","observe","disconnect","setObserverInitExternal","newInit","_newInit_rootMargin"],"mappings":"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"}
+{"version":3,"sources":["useIntersectionObserver.js"],"sourcesContent":["import * as React from 'react';\nimport { useIsomorphicLayoutEffect } from '@fluentui/react-utilities';\nimport { useFluent_unstable as useFluent } from '@fluentui/react-shared-contexts';\nconst { useCallback, useState, useRef } = React;\nimport { useMutationObserver } from './useMutationObserver';\n/**\n * This function will take the rootMargin and flip the sides if we are in RTL based on the computed reading direction of the target element.\n * @param ltrRootMargin the margin to be processed and flipped if required\n * @param target target element that will have its current reading direction determined\n * @returns the corrected rootMargin (if it was necessary to correct)\n */ export const getRTLRootMargin = (ltrRootMargin, target)=>{\n    if (target) {\n        // get the computed dir for the target element\n        const newDir = getComputedStyle(target).direction;\n        // If we're in rtl reading direction, we might need to flip the margins on the left/right sides\n        if (newDir === 'rtl') {\n            let newMargin = ltrRootMargin;\n            const splitMargins = ltrRootMargin.split(' ');\n            // We only need to do this if we get four values, otherwise the sides are equal and don't require flipping.\n            if (splitMargins.length === 4) {\n                newMargin = `${splitMargins[0]} ${splitMargins[3]} ${splitMargins[2]} ${splitMargins[1]}`;\n            }\n            return newMargin;\n        } else {\n            return ltrRootMargin;\n        }\n    }\n    return ltrRootMargin;\n};\n/**\n * React hook that allows easy usage of the browser API IntersectionObserver within React\n * @param callback - A function called when the percentage of the target element is visible crosses a threshold.\n * @param options - An optional object which customizes the observer. If options isn't specified, the observer uses the\n * document's viewport as the root, with no margin, and a 0% threshold (meaning that even a one-pixel change is\n * enough to trigger a callback).\n * @returns An array containing a callback to update the list of Elements the observer should listen to, a callback to\n * update the init options of the IntersectionObserver and a ref to the IntersectionObserver instance itself.\n */ export const useIntersectionObserver = (callback, options)=>{\n    const observer = useRef();\n    const [observerList, setObserverList] = useState();\n    const { targetDocument } = useFluent();\n    var _options_rootMargin;\n    // set the initial init with corrected margins based on the observed root's calculated reading direction.\n    const [observerInit, setObserverInit] = useState(options && {\n        ...options,\n        rootMargin: getRTLRootMargin((_options_rootMargin = options.rootMargin) !== null && _options_rootMargin !== void 0 ? _options_rootMargin : '0px', options.root)\n    });\n    var _options_rootMargin1;\n    // We have to assume that any values passed in for rootMargin by the consuming app are ltr values. As such we will store the ltr value.\n    const ltrRootMargin = useRef((_options_rootMargin1 = options === null || options === void 0 ? void 0 : options.rootMargin) !== null && _options_rootMargin1 !== void 0 ? _options_rootMargin1 : '0px');\n    // Callback function to execute when mutations are observed\n    const mutationObserverCallback = useCallback((mutationList)=>{\n        for (const mutation of mutationList){\n            // Ensuring that the right attribute is being observed and that the root is within the tree of the element being mutated.\n            if (mutation.type === 'attributes' && mutation.attributeName === 'dir' && (options === null || options === void 0 ? void 0 : options.root) && mutation.target.contains(options === null || options === void 0 ? void 0 : options.root)) {\n                setObserverInit({\n                    ...observerInit,\n                    rootMargin: getRTLRootMargin(ltrRootMargin.current, observerInit === null || observerInit === void 0 ? void 0 : observerInit.root)\n                });\n            }\n        }\n    }, [\n        ltrRootMargin,\n        observerInit,\n        options === null || options === void 0 ? void 0 : options.root\n    ]);\n    // Mutation observer for dir attribute changes in the document\n    useMutationObserver(targetDocument, mutationObserverCallback, {\n        attributes: true,\n        subtree: true,\n        attributeFilter: [\n            'dir'\n        ]\n    });\n    // Observer elements in passed in list and clean up previous list\n    // This effect is only triggered when observerList is updated\n    useIsomorphicLayoutEffect(()=>{\n        const win = targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.defaultView;\n        if (!win) {\n            return;\n        }\n        observer.current = new win.IntersectionObserver(callback, {\n            ...observerInit,\n            rootMargin: getRTLRootMargin(ltrRootMargin.current, observerInit === null || observerInit === void 0 ? void 0 : observerInit.root)\n        });\n        // If we have an instance of IO and a list with elements, observer the elements\n        if (observer.current && observerList && observerList.length > 0) {\n            observerList.forEach((element)=>{\n                var _observer_current;\n                (_observer_current = observer.current) === null || _observer_current === void 0 ? void 0 : _observer_current.observe(element);\n            });\n        }\n        // clean up previous elements being listened to\n        return ()=>{\n            if (observer.current) {\n                observer.current.disconnect();\n            }\n        };\n    }, [\n        observerList,\n        observerInit,\n        callback,\n        targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.defaultView\n    ]);\n    // Do not use internally, we need to track external settings only here\n    const setObserverInitExternal = useCallback((newInit)=>{\n        var _newInit_rootMargin;\n        // Since we know this is coming from consumers, we can store this value as LTR somewhat safely.\n        ltrRootMargin.current = (_newInit_rootMargin = newInit === null || newInit === void 0 ? void 0 : newInit.rootMargin) !== null && _newInit_rootMargin !== void 0 ? _newInit_rootMargin : '0px';\n        // Call the internal setter to update the value and ensure if our calculated direction is rtl, we flip the margin\n        setObserverInit({\n            ...newInit,\n            rootMargin: getRTLRootMargin(ltrRootMargin.current, newInit === null || newInit === void 0 ? void 0 : newInit.root)\n        });\n    }, [\n        ltrRootMargin,\n        setObserverInit\n    ]);\n    return {\n        setObserverList,\n        setObserverInit: setObserverInitExternal,\n        observer\n    };\n};\n"],"names":["getRTLRootMargin","useIntersectionObserver","useCallback","useState","useRef","React","ltrRootMargin","target","newDir","getComputedStyle","direction","newMargin","splitMargins","split","length","callback","options","observer","observerList","setObserverList","targetDocument","useFluent","_options_rootMargin","observerInit","setObserverInit","rootMargin","root","_options_rootMargin1","mutationObserverCallback","mutationList","mutation","type","attributeName","contains","current","useMutationObserver","attributes","subtree","attributeFilter","useIsomorphicLayoutEffect","win","defaultView","IntersectionObserver","forEach","element","_observer_current","observe","disconnect","setObserverInitExternal","newInit","_newInit_rootMargin"],"mappings":"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"}

package/lib-commonjs/hooks/useStaticPagination.js

@@ -10,9 +10,10 @@ Object.defineProperty(exports, "useStaticVirtualizerPagination", {
 });
 const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
 const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
 const useStaticVirtualizerPagination = (virtualizerProps, paginationEnabled = true)=>{
     const { itemSize, axis = 'vertical' } = virtualizerProps;
-    const timeoutRef = (0, _react.useRef)(null);
+    const [setScrollTimer, clearScrollTimer] = (0, _reactutilities.useTimeout)();
     const lastScrollPos = (0, _react.useRef)(0);
     const lastIndexScrolled = (0, _react.useRef)(0);
     const scrollContainer = _react.useRef(null);
@@ -20,9 +21,7 @@ const useStaticVirtualizerPagination = (virtualizerProps, paginationEnabled = tr
         if (scrollContainer.current) {
             scrollContainer.current.removeEventListener('scroll', onScroll);
             scrollContainer.current = null;
-            if (timeoutRef.current) {
-                clearTimeout(timeoutRef.current);
-            }
+            clearScrollTimer();
         }
     };
     _react.useEffect(()=>{
@@ -75,12 +74,12 @@ const useStaticVirtualizerPagination = (virtualizerProps, paginationEnabled = tr
     /**
    * On scroll timer that will continuously delay callback until scrolling stops
    */ const onScroll = _react.useCallback((event)=>{
-        if (timeoutRef.current) {
-            clearTimeout(timeoutRef.current);
-        }
-        timeoutRef.current = setTimeout(onScrollEnd, 100);
+        clearScrollTimer();
+        setScrollTimer(onScrollEnd, 100);
     }, [
-        onScrollEnd
+        onScrollEnd,
+        clearScrollTimer,
+        setScrollTimer
     ]);
     /**
    * Pagination ref will ensure we attach listeners to containers on change

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

@@ -1 +1 @@
-{"version":3,"sources":["useStaticPagination.js"],"sourcesContent":["import * as React from 'react';\nimport { useRef } from 'react';\n/**\n * Optional hook that will enable pagination on the virtualizer so that it 'autoscrolls' to an items exact position\n * Sizes are uniform/static, we round to the nearest item on long scrolls\n * On short scrolls, we will go at minimum to the next/previous item so that arrow pagination works\n * All VirtualizerStaticPaginationProps can be grabbed from Virtualizer hooks externally and passed in\n */ export const useStaticVirtualizerPagination = (virtualizerProps, paginationEnabled = true)=>{\n    const { itemSize, axis = 'vertical' } = virtualizerProps;\n    const timeoutRef = useRef(null);\n    const lastScrollPos = useRef(0);\n    const lastIndexScrolled = useRef(0);\n    const scrollContainer = React.useRef(null);\n    const clearListeners = ()=>{\n        if (scrollContainer.current) {\n            scrollContainer.current.removeEventListener('scroll', onScroll);\n            scrollContainer.current = null;\n            if (timeoutRef.current) {\n                clearTimeout(timeoutRef.current);\n            }\n        }\n    };\n    React.useEffect(()=>{\n        return ()=>{\n            clearListeners();\n        };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, []);\n    /**\n   * Handle scroll stop event and paginate to the closest item\n   * If the closest item is the same as the previous scroll end\n   * we paginate to the next/previous one based on direction\n   */ const onScrollEnd = React.useCallback(()=>{\n        if (!scrollContainer.current || !paginationEnabled) {\n            // No container found\n            return;\n        }\n        const currentScrollPos = Math.round(axis === 'vertical' ? scrollContainer.current.scrollTop : scrollContainer.current.scrollLeft);\n        const closestItem = Math.round(currentScrollPos / itemSize);\n        let nextItem = 0;\n        if (Math.round(closestItem - lastIndexScrolled.current) === 0) {\n            // Special case for go to next/previous with minimum amount of scroll needed\n            const nextTarget = lastScrollPos.current < currentScrollPos ? 1 : -1;\n            const isSecondaryScroll = lastScrollPos.current === currentScrollPos;\n            const posMod = isSecondaryScroll ? 0 : nextTarget;\n            nextItem = closestItem + posMod;\n        } else {\n            // Pagination for anything else can just jump to the closest!\n            nextItem = closestItem;\n        }\n        const nextItemPos = nextItem * itemSize;\n        if (axis === 'vertical') {\n            scrollContainer.current.scrollTo({\n                top: nextItemPos,\n                behavior: 'smooth'\n            });\n        } else {\n            scrollContainer.current.scrollTo({\n                left: nextItemPos,\n                behavior: 'smooth'\n            });\n        }\n        lastScrollPos.current = nextItemPos;\n        lastIndexScrolled.current = nextItem;\n    }, [\n        paginationEnabled,\n        axis,\n        itemSize\n    ]);\n    /**\n   * On scroll timer that will continuously delay callback until scrolling stops\n   */ const onScroll = React.useCallback((event)=>{\n        if (timeoutRef.current) {\n            clearTimeout(timeoutRef.current);\n        }\n        timeoutRef.current = setTimeout(onScrollEnd, 100);\n    }, [\n        onScrollEnd\n    ]);\n    /**\n   * Pagination ref will ensure we attach listeners to containers on change\n   * It is returned from hook and merged into the scroll container externally\n   */ const paginationRef = React.useCallback((instance)=>{\n        if (!paginationEnabled) {\n            clearListeners();\n            scrollContainer.current = null;\n            return;\n        }\n        if (scrollContainer.current !== instance) {\n            clearListeners();\n            scrollContainer.current = instance;\n            if (scrollContainer.current) {\n                scrollContainer.current.addEventListener('scroll', onScroll);\n            }\n        }\n    }, // eslint-disable-next-line react-hooks/exhaustive-deps\n    [\n        onScroll,\n        onScrollEnd,\n        paginationEnabled\n    ]);\n    return paginationRef;\n};\n"],"names":["useStaticVirtualizerPagination","virtualizerProps","paginationEnabled","itemSize","axis","timeoutRef","useRef","lastScrollPos","lastIndexScrolled","scrollContainer","React","clearListeners","current","removeEventListener","onScroll","clearTimeout","useEffect","onScrollEnd","useCallback","currentScrollPos","Math","round","scrollTop","scrollLeft","closestItem","nextItem","nextTarget","isSecondaryScroll","posMod","nextItemPos","scrollTo","top","behavior","left","event","setTimeout","paginationRef","instance","addEventListener"],"mappings":";;;;+BAOiBA;;;eAAAA;;;;iEAPM;AAOZ,MAAMA,iCAAiC,CAACC,kBAAkBC,oBAAoB,IAAI;IACzF,MAAM,EAAEC,QAAQ,EAAEC,OAAO,UAAU,EAAE,GAAGH;IACxC,MAAMI,aAAaC,IAAAA,aAAM,EAAC;IAC1B,MAAMC,gBAAgBD,IAAAA,aAAM,EAAC;IAC7B,MAAME,oBAAoBF,IAAAA,aAAM,EAAC;IACjC,MAAMG,kBAAkBC,OAAMJ,MAAM,CAAC;IACrC,MAAMK,iBAAiB;QACnB,IAAIF,gBAAgBG,OAAO,EAAE;YACzBH,gBAAgBG,OAAO,CAACC,mBAAmB,CAAC,UAAUC;YACtDL,gBAAgBG,OAAO,GAAG;YAC1B,IAAIP,WAAWO,OAAO,EAAE;gBACpBG,aAAaV,WAAWO,OAAO;YACnC;QACJ;IACJ;IACAF,OAAMM,SAAS,CAAC;QACZ,OAAO;YACHL;QACJ;IACJ,uDAAuD;IACvD,GAAG,EAAE;IACL;;;;GAID,GAAG,MAAMM,cAAcP,OAAMQ,WAAW,CAAC;QACpC,IAAI,CAACT,gBAAgBG,OAAO,IAAI,CAACV,mBAAmB;YAChD,qBAAqB;YACrB;QACJ;QACA,MAAMiB,mBAAmBC,KAAKC,KAAK,CAACjB,SAAS,aAAaK,gBAAgBG,OAAO,CAACU,SAAS,GAAGb,gBAAgBG,OAAO,CAACW,UAAU;QAChI,MAAMC,cAAcJ,KAAKC,KAAK,CAACF,mBAAmBhB;QAClD,IAAIsB,WAAW;QACf,IAAIL,KAAKC,KAAK,CAACG,cAAchB,kBAAkBI,OAAO,MAAM,GAAG;YAC3D,4EAA4E;YAC5E,MAAMc,aAAanB,cAAcK,OAAO,GAAGO,mBAAmB,IAAI,CAAC;YACnE,MAAMQ,oBAAoBpB,cAAcK,OAAO,KAAKO;YACpD,MAAMS,SAASD,oBAAoB,IAAID;YACvCD,WAAWD,cAAcI;QAC7B,OAAO;YACH,6DAA6D;YAC7DH,WAAWD;QACf;QACA,MAAMK,cAAcJ,WAAWtB;QAC/B,IAAIC,SAAS,YAAY;YACrBK,gBAAgBG,OAAO,CAACkB,QAAQ,CAAC;gBAC7BC,KAAKF;gBACLG,UAAU;YACd;QACJ,OAAO;YACHvB,gBAAgBG,OAAO,CAACkB,QAAQ,CAAC;gBAC7BG,MAAMJ;gBACNG,UAAU;YACd;QACJ;QACAzB,cAAcK,OAAO,GAAGiB;QACxBrB,kBAAkBI,OAAO,GAAGa;IAChC,GAAG;QACCvB;QACAE;QACAD;KACH;IACD;;GAED,GAAG,MAAMW,WAAWJ,OAAMQ,WAAW,CAAC,CAACgB;QAClC,IAAI7B,WAAWO,OAAO,EAAE;YACpBG,aAAaV,WAAWO,OAAO;QACnC;QACAP,WAAWO,OAAO,GAAGuB,WAAWlB,aAAa;IACjD,GAAG;QACCA;KACH;IACD;;;GAGD,GAAG,MAAMmB,gBAAgB1B,OAAMQ,WAAW,CAAC,CAACmB;QACvC,IAAI,CAACnC,mBAAmB;YACpBS;YACAF,gBAAgBG,OAAO,GAAG;YAC1B;QACJ;QACA,IAAIH,gBAAgBG,OAAO,KAAKyB,UAAU;YACtC1B;YACAF,gBAAgBG,OAAO,GAAGyB;YAC1B,IAAI5B,gBAAgBG,OAAO,EAAE;gBACzBH,gBAAgBG,OAAO,CAAC0B,gBAAgB,CAAC,UAAUxB;YACvD;QACJ;IACJ,GACA;QACIA;QACAG;QACAf;KACH;IACD,OAAOkC;AACX"}
+{"version":3,"sources":["useStaticPagination.js"],"sourcesContent":["import * as React from 'react';\nimport { useRef } from 'react';\nimport { useTimeout } from '@fluentui/react-utilities';\n/**\n * Optional hook that will enable pagination on the virtualizer so that it 'autoscrolls' to an items exact position\n * Sizes are uniform/static, we round to the nearest item on long scrolls\n * On short scrolls, we will go at minimum to the next/previous item so that arrow pagination works\n * All VirtualizerStaticPaginationProps can be grabbed from Virtualizer hooks externally and passed in\n */ export const useStaticVirtualizerPagination = (virtualizerProps, paginationEnabled = true)=>{\n    const { itemSize, axis = 'vertical' } = virtualizerProps;\n    const [setScrollTimer, clearScrollTimer] = useTimeout();\n    const lastScrollPos = useRef(0);\n    const lastIndexScrolled = useRef(0);\n    const scrollContainer = React.useRef(null);\n    const clearListeners = ()=>{\n        if (scrollContainer.current) {\n            scrollContainer.current.removeEventListener('scroll', onScroll);\n            scrollContainer.current = null;\n            clearScrollTimer();\n        }\n    };\n    React.useEffect(()=>{\n        return ()=>{\n            clearListeners();\n        };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, []);\n    /**\n   * Handle scroll stop event and paginate to the closest item\n   * If the closest item is the same as the previous scroll end\n   * we paginate to the next/previous one based on direction\n   */ const onScrollEnd = React.useCallback(()=>{\n        if (!scrollContainer.current || !paginationEnabled) {\n            // No container found\n            return;\n        }\n        const currentScrollPos = Math.round(axis === 'vertical' ? scrollContainer.current.scrollTop : scrollContainer.current.scrollLeft);\n        const closestItem = Math.round(currentScrollPos / itemSize);\n        let nextItem = 0;\n        if (Math.round(closestItem - lastIndexScrolled.current) === 0) {\n            // Special case for go to next/previous with minimum amount of scroll needed\n            const nextTarget = lastScrollPos.current < currentScrollPos ? 1 : -1;\n            const isSecondaryScroll = lastScrollPos.current === currentScrollPos;\n            const posMod = isSecondaryScroll ? 0 : nextTarget;\n            nextItem = closestItem + posMod;\n        } else {\n            // Pagination for anything else can just jump to the closest!\n            nextItem = closestItem;\n        }\n        const nextItemPos = nextItem * itemSize;\n        if (axis === 'vertical') {\n            scrollContainer.current.scrollTo({\n                top: nextItemPos,\n                behavior: 'smooth'\n            });\n        } else {\n            scrollContainer.current.scrollTo({\n                left: nextItemPos,\n                behavior: 'smooth'\n            });\n        }\n        lastScrollPos.current = nextItemPos;\n        lastIndexScrolled.current = nextItem;\n    }, [\n        paginationEnabled,\n        axis,\n        itemSize\n    ]);\n    /**\n   * On scroll timer that will continuously delay callback until scrolling stops\n   */ const onScroll = React.useCallback((event)=>{\n        clearScrollTimer();\n        setScrollTimer(onScrollEnd, 100);\n    }, [\n        onScrollEnd,\n        clearScrollTimer,\n        setScrollTimer\n    ]);\n    /**\n   * Pagination ref will ensure we attach listeners to containers on change\n   * It is returned from hook and merged into the scroll container externally\n   */ const paginationRef = React.useCallback((instance)=>{\n        if (!paginationEnabled) {\n            clearListeners();\n            scrollContainer.current = null;\n            return;\n        }\n        if (scrollContainer.current !== instance) {\n            clearListeners();\n            scrollContainer.current = instance;\n            if (scrollContainer.current) {\n                scrollContainer.current.addEventListener('scroll', onScroll);\n            }\n        }\n    }, // eslint-disable-next-line react-hooks/exhaustive-deps\n    [\n        onScroll,\n        onScrollEnd,\n        paginationEnabled\n    ]);\n    return paginationRef;\n};\n"],"names":["useStaticVirtualizerPagination","virtualizerProps","paginationEnabled","itemSize","axis","setScrollTimer","clearScrollTimer","useTimeout","lastScrollPos","useRef","lastIndexScrolled","scrollContainer","React","clearListeners","current","removeEventListener","onScroll","useEffect","onScrollEnd","useCallback","currentScrollPos","Math","round","scrollTop","scrollLeft","closestItem","nextItem","nextTarget","isSecondaryScroll","posMod","nextItemPos","scrollTo","top","behavior","left","event","paginationRef","instance","addEventListener"],"mappings":";;;;+BAQiBA;;;eAAAA;;;;iEARM;gCAEI;AAMhB,MAAMA,iCAAiC,CAACC,kBAAkBC,oBAAoB,IAAI;IACzF,MAAM,EAAEC,QAAQ,EAAEC,OAAO,UAAU,EAAE,GAAGH;IACxC,MAAM,CAACI,gBAAgBC,iBAAiB,GAAGC,IAAAA,0BAAU;IACrD,MAAMC,gBAAgBC,IAAAA,aAAM,EAAC;IAC7B,MAAMC,oBAAoBD,IAAAA,aAAM,EAAC;IACjC,MAAME,kBAAkBC,OAAMH,MAAM,CAAC;IACrC,MAAMI,iBAAiB;QACnB,IAAIF,gBAAgBG,OAAO,EAAE;YACzBH,gBAAgBG,OAAO,CAACC,mBAAmB,CAAC,UAAUC;YACtDL,gBAAgBG,OAAO,GAAG;YAC1BR;QACJ;IACJ;IACAM,OAAMK,SAAS,CAAC;QACZ,OAAO;YACHJ;QACJ;IACJ,uDAAuD;IACvD,GAAG,EAAE;IACL;;;;GAID,GAAG,MAAMK,cAAcN,OAAMO,WAAW,CAAC;QACpC,IAAI,CAACR,gBAAgBG,OAAO,IAAI,CAACZ,mBAAmB;YAChD,qBAAqB;YACrB;QACJ;QACA,MAAMkB,mBAAmBC,KAAKC,KAAK,CAAClB,SAAS,aAAaO,gBAAgBG,OAAO,CAACS,SAAS,GAAGZ,gBAAgBG,OAAO,CAACU,UAAU;QAChI,MAAMC,cAAcJ,KAAKC,KAAK,CAACF,mBAAmBjB;QAClD,IAAIuB,WAAW;QACf,IAAIL,KAAKC,KAAK,CAACG,cAAcf,kBAAkBI,OAAO,MAAM,GAAG;YAC3D,4EAA4E;YAC5E,MAAMa,aAAanB,cAAcM,OAAO,GAAGM,mBAAmB,IAAI,CAAC;YACnE,MAAMQ,oBAAoBpB,cAAcM,OAAO,KAAKM;YACpD,MAAMS,SAASD,oBAAoB,IAAID;YACvCD,WAAWD,cAAcI;QAC7B,OAAO;YACH,6DAA6D;YAC7DH,WAAWD;QACf;QACA,MAAMK,cAAcJ,WAAWvB;QAC/B,IAAIC,SAAS,YAAY;YACrBO,gBAAgBG,OAAO,CAACiB,QAAQ,CAAC;gBAC7BC,KAAKF;gBACLG,UAAU;YACd;QACJ,OAAO;YACHtB,gBAAgBG,OAAO,CAACiB,QAAQ,CAAC;gBAC7BG,MAAMJ;gBACNG,UAAU;YACd;QACJ;QACAzB,cAAcM,OAAO,GAAGgB;QACxBpB,kBAAkBI,OAAO,GAAGY;IAChC,GAAG;QACCxB;QACAE;QACAD;KACH;IACD;;GAED,GAAG,MAAMa,WAAWJ,OAAMO,WAAW,CAAC,CAACgB;QAClC7B;QACAD,eAAea,aAAa;IAChC,GAAG;QACCA;QACAZ;QACAD;KACH;IACD;;;GAGD,GAAG,MAAM+B,gBAAgBxB,OAAMO,WAAW,CAAC,CAACkB;QACvC,IAAI,CAACnC,mBAAmB;YACpBW;YACAF,gBAAgBG,OAAO,GAAG;YAC1B;QACJ;QACA,IAAIH,gBAAgBG,OAAO,KAAKuB,UAAU;YACtCxB;YACAF,gBAAgBG,OAAO,GAAGuB;YAC1B,IAAI1B,gBAAgBG,OAAO,EAAE;gBACzBH,gBAAgBG,OAAO,CAACwB,gBAAgB,CAAC,UAAUtB;YACvD;QACJ;IACJ,GACA;QACIA;QACAE;QACAhB;KACH;IACD,OAAOkC;AACX"}

package/package.json

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