npm - @fluentui/react-virtualizer - Versions diffs - 9.0.0-alpha.87 → 9.0.0-alpha.89 - Mend

@fluentui/react-virtualizer 9.0.0-alpha.87 → 9.0.0-alpha.89

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (107) hide show

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

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

package/lib/components/VirtualizerScrollView/VirtualizerScrollView.types.js CHANGED Viewed

	@@ -1 +1 @@
1	- ~~export~~ { };
1	+ import * as React from 'react';

package/lib/components/VirtualizerScrollView/VirtualizerScrollView.types.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["../src/components/VirtualizerScrollView/VirtualizerScrollView.types.ts"],"sourcesContent":["import type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\nimport type {\n VirtualizerSlots,\n VirtualizerConfigProps,\n VirtualizerConfigState,\n VirtualizerChildRenderFunction,\n} from '../Virtualizer/Virtualizer.types';\nimport type { ScrollToInterface } from '../../Utilities';\~~nimport type { RefObject } from 'react';\~~n\nexport type VirtualizerScrollViewSlots = VirtualizerSlots & {\n /*\n The root container that provides embedded scrolling.\n /\n container: NonNullable<Slot<'div'>>;\n};\n\nexport type VirtualizerScrollViewProps = ComponentProps<Partial<VirtualizerScrollViewSlots>> &\n Partial<\n Omit<\n VirtualizerConfigProps,\n 'itemSize' \| 'numItems' \| 'getItemSize' \| 'children' \| 'flagIndex' \| 'imperativeVirtualizerRef'\n >\n > & {\n /\n Virtualizer item size in pixels - static.\n * Axis: 'vertical' = Height\n * Axis: 'horizontal' = Width\n /\n itemSize: number;\n /\n The total number of items to be virtualized.\n /\n numItems: number;\n /\n Child render function.\n * Iteratively called to return current virtualizer DOM children.\n * Will act as a row or column indexer depending on Virtualizer settings.\n /\n children: VirtualizerChildRenderFunction;\n /\n Imperative ref contains our scrollTo index functionality for user control.\n /\n imperativeRef?: RefObject<ScrollToInterface>;\n /\n Imperative ref contains our scrollTo index functionality for user control.\n */\n enablePagination?: boolean;\n };\n\nexport type VirtualizerScrollViewState = ComponentState<VirtualizerScrollViewSlots> & VirtualizerConfigState;\n"],"names":[],"rangeMappings":"","mappings":"~~AAkDA~~,~~WAA6G~~"}
1	+ {"version":3,"sources":["../src/components/VirtualizerScrollView/VirtualizerScrollView.types.ts"],"sourcesContent":["import * as React from 'react';\nimport type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\nimport type {\n VirtualizerSlots,\n VirtualizerConfigProps,\n VirtualizerConfigState,\n VirtualizerChildRenderFunction,\n} from '../Virtualizer/Virtualizer.types';\nimport type { ScrollToInterface } from '../../Utilities';\n\nexport type VirtualizerScrollViewSlots = VirtualizerSlots & {\n /*\n The root container that provides embedded scrolling.\n /\n container: NonNullable<Slot<'div'>>;\n};\n\nexport type VirtualizerScrollViewProps = ComponentProps<Partial<VirtualizerScrollViewSlots>> &\n Partial<\n Omit<\n VirtualizerConfigProps,\n 'itemSize' \| 'numItems' \| 'getItemSize' \| 'children' \| 'flagIndex' \| 'imperativeVirtualizerRef'\n >\n > & {\n /\n Virtualizer item size in pixels - static.\n * Axis: 'vertical' = Height\n * Axis: 'horizontal' = Width\n /\n itemSize: number;\n /\n The total number of items to be virtualized.\n /\n numItems: number;\n /\n Child render function.\n * Iteratively called to return current virtualizer DOM children.\n * Will act as a row or column indexer depending on Virtualizer settings.\n /\n children: VirtualizerChildRenderFunction;\n /\n Imperative ref contains our scrollTo index functionality for user control.\n /\n imperativeRef?: React.RefObject<ScrollToInterface>;\n /\n Imperative ref contains our scrollTo index functionality for user control.\n */\n enablePagination?: boolean;\n };\n\nexport type VirtualizerScrollViewState = ComponentState<VirtualizerScrollViewSlots> & VirtualizerConfigState;\n"],"names":["React"],"rangeMappings":"","mappings":"AAAA,YAAYA,WAAW,QAAQ"}

package/lib/components/VirtualizerScrollView/index.js CHANGED Viewed

@@ -1,5 +1,4 @@
-export * from './VirtualizerScrollView';
-export * from './VirtualizerScrollView.types';
-export * from './useVirtualizerScrollView';
-export * from './renderVirtualizerScrollView';
-export * from './useVirtualizerScrollViewStyles.styles';
+export { VirtualizerScrollView } from './VirtualizerScrollView';
+export { useVirtualizerScrollView_unstable } from './useVirtualizerScrollView';
+export { renderVirtualizerScrollView_unstable } from './renderVirtualizerScrollView';
+export { useVirtualizerScrollViewStyles_unstable, virtualizerScrollViewClassNames } from './useVirtualizerScrollViewStyles.styles';

package/lib/components/VirtualizerScrollView/index.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["../src/components/VirtualizerScrollView/index.ts"],"sourcesContent":["export * from './VirtualizerScrollView';\nexport * from './VirtualizerScrollView.types';\nexport * from './useVirtualizerScrollView';\nexport * from './renderVirtualizerScrollView';\nexport * from './useVirtualizerScrollViewStyles.styles';\n"],"names":[],"rangeMappings":"~~;;;;~~","mappings":"AAAA,~~cAAc~~,0BAA0B;~~AACxC~~,~~cAAc~~,~~gCAAgC;AAC9C~~,~~cAAc~~,6BAA6B;~~AAC3C~~,~~cAAc~~,gCAAgC;~~AAC9C~~,~~cAAc~~,0CAA0C"}
1	+ {"version":3,"sources":["../src/components/VirtualizerScrollView/index.ts"],"sourcesContent":["export { VirtualizerScrollView } from './VirtualizerScrollView';\nexport type {\n VirtualizerScrollViewProps,\n VirtualizerScrollViewSlots,\n VirtualizerScrollViewState,\n} from './VirtualizerScrollView.types';\nexport { useVirtualizerScrollView_unstable } from './useVirtualizerScrollView';\nexport { renderVirtualizerScrollView_unstable } from './renderVirtualizerScrollView';\nexport {\n useVirtualizerScrollViewStyles_unstable,\n virtualizerScrollViewClassNames,\n} from './useVirtualizerScrollViewStyles.styles';\n"],"names":["VirtualizerScrollView","useVirtualizerScrollView_unstable","renderVirtualizerScrollView_unstable","useVirtualizerScrollViewStyles_unstable","virtualizerScrollViewClassNames"],"rangeMappings":";;;","mappings":"AAAA,SAASA,qBAAqB,QAAQ,0BAA0B;AAMhE,SAASC,iCAAiC,QAAQ,6BAA6B;AAC/E,SAASC,oCAAoC,QAAQ,gCAAgC;AACrF,SACEC,uCAAuC,EACvCC,+BAA+B,QAC1B,0CAA0C"}

package/lib/components/VirtualizerScrollView/useVirtualizerScrollView.js CHANGED Viewed

@@ -2,7 +2,6 @@ import * as React from 'react';
 import { slot, useMergedRefs } from '@fluentui/react-utilities';
 import { useVirtualizer_unstable } from '../Virtualizer/useVirtualizer';
 import { useStaticVirtualizerMeasure } from '../../Hooks';
-import { useImperativeHandle } from 'react';
 import { scrollToItemStatic } from '../../Utilities';
 import { useStaticVirtualizerPagination } from '../../hooks/useStaticPagination';
 export function useVirtualizerScrollView_unstable(props) {
@@ -24,7 +23,7 @@ export function useVirtualizerScrollView_unstable(props) {
     const scrollViewRef = useMergedRefs(props.scrollViewRef, scrollRef, paginationRef);
     const imperativeVirtualizerRef = React.useRef(null);
     const scrollCallbackRef = React.useRef(null);
-    useImperativeHandle(imperativeRef, ()=>{
+    React.useImperativeHandle(imperativeRef, ()=>{
         var _imperativeVirtualizerRef_current;
         return {
             scrollTo (index, behavior = 'auto', callback) {

package/lib/components/VirtualizerScrollView/useVirtualizerScrollView.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["../src/components/VirtualizerScrollView/useVirtualizerScrollView.ts"],"sourcesContent":["import * as React from 'react';\nimport { slot, useMergedRefs } from '@fluentui/react-utilities';\nimport { useVirtualizer_unstable } from '../Virtualizer/useVirtualizer';\nimport type { VirtualizerScrollViewProps, VirtualizerScrollViewState } from './VirtualizerScrollView.types';\nimport { useStaticVirtualizerMeasure } from '../../Hooks';\nimport { ~~useImperativeHandle } from 'react';\nimport {~~ scrollToItemStatic } from '../../Utilities';\nimport type { VirtualizerDataRef } from '../Virtualizer/Virtualizer.types';\nimport { useStaticVirtualizerPagination } from '../../hooks/useStaticPagination';\n\nexport function useVirtualizerScrollView_unstable(props: VirtualizerScrollViewProps): VirtualizerScrollViewState {\n const { imperativeRef, itemSize, numItems, axis = 'vertical', reversed, enablePagination = false } = props;\n const { virtualizerLength, bufferItems, bufferSize, scrollRef, containerSizeRef } = useStaticVirtualizerMeasure({\n defaultItemSize: props.itemSize,\n direction: props.axis ?? 'vertical',\n });\n\n // Store the virtualizer length as a ref for imperative ref access\n const virtualizerLengthRef = React.useRef<number>(virtualizerLength);\n if (virtualizerLengthRef.current !== virtualizerLength) {\n virtualizerLengthRef.current = virtualizerLength;\n }\n\n const paginationRef = useStaticVirtualizerPagination({ axis, itemSize }, enablePagination);\n const scrollViewRef = useMergedRefs(props.scrollViewRef, scrollRef, paginationRef) as React.RefObject<HTMLDivElement>;\n const imperativeVirtualizerRef = React.useRef<VirtualizerDataRef \| null>(null);\n const scrollCallbackRef = React.useRef<null \| ((index: number) => void)>(null);\n\n useImperativeHandle(\n imperativeRef,\n () => {\n return {\n scrollTo(index: number, behavior = 'auto', callback: ((index: number) => void) \| undefined) {\n scrollCallbackRef.current = callback ?? null;\n imperativeVirtualizerRef.current?.setFlaggedIndex(index);\n scrollToItemStatic({\n index,\n itemSize,\n totalItems: numItems,\n scrollViewRef,\n axis,\n reversed,\n behavior,\n });\n },\n currentIndex: imperativeVirtualizerRef.current?.currentIndex,\n virtualizerLength: virtualizerLengthRef,\n };\n },\n [axis, scrollViewRef, itemSize, numItems, reversed],\n );\n\n const handleRenderedIndex = (index: number) => {\n if (scrollCallbackRef.current) {\n scrollCallbackRef.current(index);\n }\n };\n\n const virtualizerState = useVirtualizer_unstable({\n ...props,\n virtualizerLength,\n bufferItems,\n bufferSize,\n onRenderedFlaggedIndex: handleRenderedIndex,\n imperativeVirtualizerRef,\n containerSizeRef,\n });\n\n return {\n ...virtualizerState,\n components: {\n ...virtualizerState.components,\n container: 'div',\n },\n container: slot.always(props.container, {\n defaultProps: {\n ref: scrollViewRef as React.RefObject<HTMLDivElement>,\n },\n elementType: 'div',\n }),\n };\n}\n"],"names":["React","slot","useMergedRefs","useVirtualizer_unstable","useStaticVirtualizerMeasure","~~useImperativeHandle","~~scrollToItemStatic","useStaticVirtualizerPagination","useVirtualizerScrollView_unstable","props","imperativeRef","itemSize","numItems","axis","reversed","enablePagination","virtualizerLength","bufferItems","bufferSize","scrollRef","containerSizeRef","defaultItemSize","direction","virtualizerLengthRef","useRef","current","paginationRef","scrollViewRef","imperativeVirtualizerRef","scrollCallbackRef","scrollTo","index","behavior","callback","setFlaggedIndex","totalItems","currentIndex","handleRenderedIndex","virtualizerState","onRenderedFlaggedIndex","components","container","always","defaultProps","ref","elementType"],"rangeMappings":"~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~","mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,IAAI,EAAEC,aAAa,QAAQ,4BAA4B;AAChE,SAASC,uBAAuB,QAAQ,gCAAgC;AAExE,SAASC,2BAA2B,QAAQ,cAAc;AAC1D,SAASC,~~mBAAmB,QAAQ,QAAQ;AAC5C,SAASC,~~kBAAkB,QAAQ,kBAAkB;AAErD,SAASC,8BAA8B,QAAQ,kCAAkC;AAEjF,OAAO,SAASC,kCAAkCC,KAAiC;IACjF,MAAM,EAAEC,aAAa,EAAEC,QAAQ,EAAEC,QAAQ,EAAEC,OAAO,UAAU,EAAEC,QAAQ,EAAEC,mBAAmB,KAAK,EAAE,GAAGN;QAGxFA;IAFb,MAAM,EAAEO,iBAAiB,EAAEC,WAAW,EAAEC,UAAU,EAAEC,SAAS,EAAEC,gBAAgB,EAAE,~~GAAGhB~~,4BAA4B;~~QAC9GiB~~,iBAAiBZ,MAAME,QAAQ;QAC/BW,WAAWb,CAAAA,cAAAA,MAAMI,IAAI,cAAVJ,yBAAAA,cAAc;IAC3B;IAEA,kEAAkE;IAClE,MAAMc,~~uBAAuBvB~~,~~MAAMwB~~,MAAM,CAASR;IAClD,IAAIO,qBAAqBE,OAAO,KAAKT,mBAAmB;QACtDO,qBAAqBE,OAAO,GAAGT;IACjC;IAEA,MAAMU,gBAAgBnB,+BAA+B;QAAEM;QAAMF;IAAS,GAAGI;IACzE,MAAMY,~~gBAAgBzB~~,~~cAAcO~~,MAAMkB,aAAa,EAAER,WAAWO;IACpE,MAAME,~~2BAA2B5B~~,~~MAAMwB~~,MAAM,CAA4B;IACzE,MAAMK,~~oBAAoB7B~~,~~MAAMwB~~,MAAM,CAAmC;~~IAEzEnB~~,~~oBACEK~~,eACA;YAekBkB;QAdhB,OAAO;~~YACLE~~,UAASC,KAAa,EAAEC,WAAW,MAAM,EAAEC,QAA+C;~~oBAExFL~~;gBADAC,kBAAkBJ,OAAO,~~GAAGQ~~,qBAAAA,sBAAAA,WAAY;~~iBACxCL~~,oCAAAA,yBAAyBH,OAAO,cAAhCG,wDAAAA,~~kCAAkCM~~,eAAe,CAACH;~~gBAClDzB~~,mBAAmB;~~oBACjByB~~;~~oBACApB~~;~~oBACAwB~~,~~YAAYvB~~;oBACZe;oBACAd;oBACAC;~~oBACAkB~~;gBACF;YACF;YACAI,YAAY,~~GAAER~~,oCAAAA,yBAAyBH,OAAO,cAAhCG,wDAAAA,~~kCAAkCQ~~,YAAY;~~YAC5DpB~~,mBAAmBO;QACrB;IACF,GACA;QAACV;QAAMc;QAAehB;QAAUC;QAAUE;KAAS;IAGrD,~~MAAMuB~~,sBAAsB,CAACN;QAC3B,~~IAAIF~~,kBAAkBJ,OAAO,EAAE;YAC7BI,kBAAkBJ,OAAO,~~CAACM~~;QAC5B;IACF;IAEA,MAAMO,mBAAmBnC,wBAAwB;QAC/C,~~GAAGM~~,KAAK;QACRO;QACAC;QACAC;~~QACAqB~~,wBAAwBF;~~QACxBT~~;QACAR;IACF;IAEA,OAAO;QACL,~~GAAGkB~~,gBAAgB;QACnBE,YAAY;YACV,GAAGF,iBAAiBE,UAAU;YAC9BC,WAAW;QACb;QACAA,WAAWxC,KAAKyC,MAAM,~~CAACjC~~,~~MAAMgC~~,SAAS,EAAE;YACtCE,cAAc;gBACZC,~~KAAKjB~~;YACP;~~YACAkB~~,aAAa;QACf;IACF;AACF"}
1	+ {"version":3,"sources":["../src/components/VirtualizerScrollView/useVirtualizerScrollView.ts"],"sourcesContent":["import * as React from 'react';\nimport { slot, useMergedRefs } from '@fluentui/react-utilities';\nimport { useVirtualizer_unstable } from '../Virtualizer/useVirtualizer';\nimport type { VirtualizerScrollViewProps, VirtualizerScrollViewState } from './VirtualizerScrollView.types';\nimport { useStaticVirtualizerMeasure } from '../../Hooks';\nimport { scrollToItemStatic } from '../../Utilities';\nimport type { VirtualizerDataRef } from '../Virtualizer/Virtualizer.types';\nimport { useStaticVirtualizerPagination } from '../../hooks/useStaticPagination';\n\nexport function useVirtualizerScrollView_unstable(props: VirtualizerScrollViewProps): VirtualizerScrollViewState {\n const { imperativeRef, itemSize, numItems, axis = 'vertical', reversed, enablePagination = false } = props;\n const { virtualizerLength, bufferItems, bufferSize, scrollRef, containerSizeRef } = useStaticVirtualizerMeasure({\n defaultItemSize: props.itemSize,\n direction: props.axis ?? 'vertical',\n });\n\n // Store the virtualizer length as a ref for imperative ref access\n const virtualizerLengthRef = React.useRef<number>(virtualizerLength);\n if (virtualizerLengthRef.current !== virtualizerLength) {\n virtualizerLengthRef.current = virtualizerLength;\n }\n\n const paginationRef = useStaticVirtualizerPagination({ axis, itemSize }, enablePagination);\n const scrollViewRef = useMergedRefs(props.scrollViewRef, scrollRef, paginationRef) as React.RefObject<HTMLDivElement>;\n const imperativeVirtualizerRef = React.useRef<VirtualizerDataRef \| null>(null);\n const scrollCallbackRef = React.useRef<null \| ((index: number) => void)>(null);\n\n React.useImperativeHandle(\n imperativeRef,\n () => {\n return {\n scrollTo(index: number, behavior = 'auto', callback: ((index: number) => void) \| undefined) {\n scrollCallbackRef.current = callback ?? null;\n imperativeVirtualizerRef.current?.setFlaggedIndex(index);\n scrollToItemStatic({\n index,\n itemSize,\n totalItems: numItems,\n scrollViewRef,\n axis,\n reversed,\n behavior,\n });\n },\n currentIndex: imperativeVirtualizerRef.current?.currentIndex,\n virtualizerLength: virtualizerLengthRef,\n };\n },\n [axis, scrollViewRef, itemSize, numItems, reversed],\n );\n\n const handleRenderedIndex = (index: number) => {\n if (scrollCallbackRef.current) {\n scrollCallbackRef.current(index);\n }\n };\n\n const virtualizerState = useVirtualizer_unstable({\n ...props,\n virtualizerLength,\n bufferItems,\n bufferSize,\n onRenderedFlaggedIndex: handleRenderedIndex,\n imperativeVirtualizerRef,\n containerSizeRef,\n });\n\n return {\n ...virtualizerState,\n components: {\n ...virtualizerState.components,\n container: 'div',\n },\n container: slot.always(props.container, {\n defaultProps: {\n ref: scrollViewRef as React.RefObject<HTMLDivElement>,\n },\n elementType: 'div',\n }),\n };\n}\n"],"names":["React","slot","useMergedRefs","useVirtualizer_unstable","useStaticVirtualizerMeasure","scrollToItemStatic","useStaticVirtualizerPagination","useVirtualizerScrollView_unstable","props","imperativeRef","itemSize","numItems","axis","reversed","enablePagination","virtualizerLength","bufferItems","bufferSize","scrollRef","containerSizeRef","defaultItemSize","direction","virtualizerLengthRef","useRef","current","paginationRef","scrollViewRef","imperativeVirtualizerRef","scrollCallbackRef","useImperativeHandle","scrollTo","index","behavior","callback","setFlaggedIndex","totalItems","currentIndex","handleRenderedIndex","virtualizerState","onRenderedFlaggedIndex","components","container","always","defaultProps","ref","elementType"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,IAAI,EAAEC,aAAa,QAAQ,4BAA4B;AAChE,SAASC,uBAAuB,QAAQ,gCAAgC;AAExE,SAASC,2BAA2B,QAAQ,cAAc;AAC1D,SAASC,kBAAkB,QAAQ,kBAAkB;AAErD,SAASC,8BAA8B,QAAQ,kCAAkC;AAEjF,OAAO,SAASC,kCAAkCC,KAAiC;IACjF,MAAM,EAAEC,aAAa,EAAEC,QAAQ,EAAEC,QAAQ,EAAEC,OAAO,UAAU,EAAEC,QAAQ,EAAEC,mBAAmB,KAAK,EAAE,GAAGN;QAGxFA;IAFb,MAAM,EAAEO,iBAAiB,EAAEC,WAAW,EAAEC,UAAU,EAAEC,SAAS,EAAEC,gBAAgB,EAAE,GAAGf,4BAA4B;QAC9GgB,iBAAiBZ,MAAME,QAAQ;QAC/BW,WAAWb,CAAAA,cAAAA,MAAMI,IAAI,cAAVJ,yBAAAA,cAAc;IAC3B;IAEA,kEAAkE;IAClE,MAAMc,uBAAuBtB,MAAMuB,MAAM,CAASR;IAClD,IAAIO,qBAAqBE,OAAO,KAAKT,mBAAmB;QACtDO,qBAAqBE,OAAO,GAAGT;IACjC;IAEA,MAAMU,gBAAgBnB,+BAA+B;QAAEM;QAAMF;IAAS,GAAGI;IACzE,MAAMY,gBAAgBxB,cAAcM,MAAMkB,aAAa,EAAER,WAAWO;IACpE,MAAME,2BAA2B3B,MAAMuB,MAAM,CAA4B;IACzE,MAAMK,oBAAoB5B,MAAMuB,MAAM,CAAmC;IAEzEvB,MAAM6B,mBAAmB,CACvBpB,eACA;YAekBkB;QAdhB,OAAO;YACLG,UAASC,KAAa,EAAEC,WAAW,MAAM,EAAEC,QAA+C;oBAExFN;gBADAC,kBAAkBJ,OAAO,GAAGS,qBAAAA,sBAAAA,WAAY;iBACxCN,oCAAAA,yBAAyBH,OAAO,cAAhCG,wDAAAA,kCAAkCO,eAAe,CAACH;gBAClD1B,mBAAmB;oBACjB0B;oBACArB;oBACAyB,YAAYxB;oBACZe;oBACAd;oBACAC;oBACAmB;gBACF;YACF;YACAI,YAAY,GAAET,oCAAAA,yBAAyBH,OAAO,cAAhCG,wDAAAA,kCAAkCS,YAAY;YAC5DrB,mBAAmBO;QACrB;IACF,GACA;QAACV;QAAMc;QAAehB;QAAUC;QAAUE;KAAS;IAGrD,MAAMwB,sBAAsB,CAACN;QAC3B,IAAIH,kBAAkBJ,OAAO,EAAE;YAC7BI,kBAAkBJ,OAAO,CAACO;QAC5B;IACF;IAEA,MAAMO,mBAAmBnC,wBAAwB;QAC/C,GAAGK,KAAK;QACRO;QACAC;QACAC;QACAsB,wBAAwBF;QACxBV;QACAR;IACF;IAEA,OAAO;QACL,GAAGmB,gBAAgB;QACnBE,YAAY;YACV,GAAGF,iBAAiBE,UAAU;YAC9BC,WAAW;QACb;QACAA,WAAWxC,KAAKyC,MAAM,CAAClC,MAAMiC,SAAS,EAAE;YACtCE,cAAc;gBACZC,KAAKlB;YACP;YACAmB,aAAa;QACf;IACF;AACF"}

package/lib/components/VirtualizerScrollViewDynamic/VirtualizerScrollViewDynamic.types.js CHANGED Viewed

	@@ -1 +1 @@
1	- ~~export~~ { };
1	+ import * as React from 'react';

package/lib/components/VirtualizerScrollViewDynamic/VirtualizerScrollViewDynamic.types.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["../src/components/VirtualizerScrollViewDynamic/VirtualizerScrollViewDynamic.types.ts"],"sourcesContent":["import type { ComponentProps, ComponentState } from '@fluentui/react-utilities';\nimport type {\n VirtualizerConfigProps,\n VirtualizerConfigState,\n VirtualizerChildRenderFunction,\n} from '../Virtualizer/Virtualizer.types';\n\nimport type { VirtualizerScrollViewSlots } from '../VirtualizerScrollView/VirtualizerScrollView.types';\nimport type { ~~RefObject } from 'react';\nimport type {~~ DynamicVirtualizerContextProps, ScrollToInterface } from '../../Utilities';\n\nexport type VirtualizerScrollViewDynamicSlots = VirtualizerScrollViewSlots;\n\nexport type VirtualizerScrollViewDynamicProps = ComponentProps<Partial<VirtualizerScrollViewDynamicSlots>> &\n Partial<\n Omit<\n VirtualizerConfigProps,\n 'itemSize' \| 'numItems' \| 'getItemSize' \| 'children' \| 'flagIndex' \| 'virtualizerContext'\n >\n > & {\n /*\n Set as the minimum item size.\n * Axis: 'vertical' = Height\n * Axis: 'horizontal' = Width\n /\n itemSize: number;\n /\n Callback for acquiring size of individual items\n * @param index - the index of the requested size's child\n * If undefined, Virtualizer will auto-measure by default (performance tradeoff)\n /\n getItemSize?: (index: number) => number;\n /\n The total number of items to be virtualized.\n /\n numItems: number;\n /\n Child render function.\n * Iteratively called to return current virtualizer DOM children.\n * Will act as a row or column indexer depending on Virtualizer settings.\n /\n children: VirtualizerChildRenderFunction;\n /\n Imperative ref contains our scrollTo index functionality for user control.\n /\n imperativeRef?: RefObject<ScrollToInterface>;\n /\n Imperative ref contains our scrollTo index functionality for user control.\n /\n enablePagination?: boolean;\n /\n Enables override of dynamic virtualizer context if required.\n */\n virtualizerContext?: DynamicVirtualizerContextProps;\n };\n\nexport type VirtualizerScrollViewDynamicState = ComponentState<VirtualizerScrollViewDynamicSlots> &\n VirtualizerConfigState;\n"],"names":[],"rangeMappings":"","mappings":"~~AAwDA~~,~~WACyB~~"}
1	+ {"version":3,"sources":["../src/components/VirtualizerScrollViewDynamic/VirtualizerScrollViewDynamic.types.ts"],"sourcesContent":["import * as React from 'react';\nimport type { ComponentProps, ComponentState } from '@fluentui/react-utilities';\nimport type {\n VirtualizerConfigProps,\n VirtualizerConfigState,\n VirtualizerChildRenderFunction,\n} from '../Virtualizer/Virtualizer.types';\n\nimport type { VirtualizerScrollViewSlots } from '../VirtualizerScrollView/VirtualizerScrollView.types';\nimport type { DynamicVirtualizerContextProps, ScrollToInterface } from '../../Utilities';\n\nexport type VirtualizerScrollViewDynamicSlots = VirtualizerScrollViewSlots;\n\nexport type VirtualizerScrollViewDynamicProps = ComponentProps<Partial<VirtualizerScrollViewDynamicSlots>> &\n Partial<\n Omit<\n VirtualizerConfigProps,\n 'itemSize' \| 'numItems' \| 'getItemSize' \| 'children' \| 'flagIndex' \| 'virtualizerContext'\n >\n > & {\n /*\n Set as the minimum item size.\n * Axis: 'vertical' = Height\n * Axis: 'horizontal' = Width\n /\n itemSize: number;\n /\n Callback for acquiring size of individual items\n * @param index - the index of the requested size's child\n * If undefined, Virtualizer will auto-measure by default (performance tradeoff)\n /\n getItemSize?: (index: number) => number;\n /\n The total number of items to be virtualized.\n /\n numItems: number;\n /\n Child render function.\n * Iteratively called to return current virtualizer DOM children.\n * Will act as a row or column indexer depending on Virtualizer settings.\n /\n children: VirtualizerChildRenderFunction;\n /\n Imperative ref contains our scrollTo index functionality for user control.\n /\n imperativeRef?: React.RefObject<ScrollToInterface>;\n /\n Imperative ref contains our scrollTo index functionality for user control.\n /\n enablePagination?: boolean;\n /\n Enables override of dynamic virtualizer context if required.\n */\n virtualizerContext?: DynamicVirtualizerContextProps;\n };\n\nexport type VirtualizerScrollViewDynamicState = ComponentState<VirtualizerScrollViewDynamicSlots> &\n VirtualizerConfigState;\n"],"names":["React"],"rangeMappings":"","mappings":"AAAA,YAAYA,WAAW,QAAQ"}

package/lib/components/VirtualizerScrollViewDynamic/index.js CHANGED Viewed

@@ -1,5 +1,4 @@
-export * from './VirtualizerScrollViewDynamic';
-export * from './VirtualizerScrollViewDynamic.types';
-export * from './useVirtualizerScrollViewDynamic';
-export * from './renderVirtualizerScrollViewDynamic';
-export * from './useVirtualizerScrollViewDynamicStyles.styles';
+export { VirtualizerScrollViewDynamic } from './VirtualizerScrollViewDynamic';
+export { useVirtualizerScrollViewDynamic_unstable } from './useVirtualizerScrollViewDynamic';
+export { renderVirtualizerScrollViewDynamic_unstable } from './renderVirtualizerScrollViewDynamic';
+export { useVirtualizerScrollViewDynamicStyles_unstable, virtualizerScrollViewDynamicClassNames } from './useVirtualizerScrollViewDynamicStyles.styles';

package/lib/components/VirtualizerScrollViewDynamic/index.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["../src/components/VirtualizerScrollViewDynamic/index.ts"],"sourcesContent":["export * from './VirtualizerScrollViewDynamic';\nexport * from './VirtualizerScrollViewDynamic.types';\nexport * from './useVirtualizerScrollViewDynamic';\nexport * from './renderVirtualizerScrollViewDynamic';\nexport * from './useVirtualizerScrollViewDynamicStyles.styles';\n"],"names":[],"rangeMappings":"~~;;;;~~","mappings":"AAAA,~~cAAc~~,iCAAiC;~~AAC/C~~,~~cAAc~~,~~uCAAuC;AACrD~~,~~cAAc~~,oCAAoC;~~AAClD~~,~~cAAc~~,uCAAuC;~~AACrD~~,~~cAAc~~,iDAAiD"}
1	+ {"version":3,"sources":["../src/components/VirtualizerScrollViewDynamic/index.ts"],"sourcesContent":["export { VirtualizerScrollViewDynamic } from './VirtualizerScrollViewDynamic';\nexport type {\n VirtualizerScrollViewDynamicProps,\n VirtualizerScrollViewDynamicSlots,\n VirtualizerScrollViewDynamicState,\n} from './VirtualizerScrollViewDynamic.types';\nexport { useVirtualizerScrollViewDynamic_unstable } from './useVirtualizerScrollViewDynamic';\nexport { renderVirtualizerScrollViewDynamic_unstable } from './renderVirtualizerScrollViewDynamic';\nexport {\n useVirtualizerScrollViewDynamicStyles_unstable,\n virtualizerScrollViewDynamicClassNames,\n} from './useVirtualizerScrollViewDynamicStyles.styles';\n"],"names":["VirtualizerScrollViewDynamic","useVirtualizerScrollViewDynamic_unstable","renderVirtualizerScrollViewDynamic_unstable","useVirtualizerScrollViewDynamicStyles_unstable","virtualizerScrollViewDynamicClassNames"],"rangeMappings":";;;","mappings":"AAAA,SAASA,4BAA4B,QAAQ,iCAAiC;AAM9E,SAASC,wCAAwC,QAAQ,oCAAoC;AAC7F,SAASC,2CAA2C,QAAQ,uCAAuC;AACnG,SACEC,8CAA8C,EAC9CC,sCAAsC,QACjC,iDAAiD"}

package/lib/components/VirtualizerScrollViewDynamic/useVirtualizerScrollViewDynamic.js CHANGED Viewed

@@ -3,7 +3,6 @@ import { slot, useMergedRefs } from '@fluentui/react-utilities';
 import { useVirtualizer_unstable } from '../Virtualizer/useVirtualizer';
 import { useDynamicVirtualizerMeasure } from '../../Hooks';
 import { useVirtualizerContextState_unstable, scrollToItemDynamic } from '../../Utilities';
-import { useImperativeHandle, useState } from 'react';
 import { useMeasureList } from '../../hooks/useMeasureList';
 import { useDynamicVirtualizerPagination } from '../../hooks/useDynamicPagination';
 export function useVirtualizerScrollViewDynamic_unstable(props) {
@@ -13,7 +12,7 @@ export function useVirtualizerScrollViewDynamic_unstable(props) {
     const { imperativeRef, axis = 'vertical', reversed, imperativeVirtualizerRef, enablePagination = false, bufferItems: _bufferItems, bufferSize: _bufferSize } = props;
     let sizeTrackingArray = React.useRef(new Array(props.numItems).fill(props.itemSize));
     // This lets us trigger updates when a size change occurs.
-    const [sizeUpdateCount, setSizeUpdateCount] = useState(0);
+    const [sizeUpdateCount, setSizeUpdateCount] = React.useState(0);
     const getChildSizeAuto = React.useCallback((index)=>{
         if (sizeTrackingArray.current.length <= index || sizeTrackingArray.current[index] <= 0) {
             // Default size for initial state or untracked
@@ -53,7 +52,7 @@ export function useVirtualizerScrollViewDynamic_unstable(props) {
     }
     const scrollViewRef = useMergedRefs(props.scrollViewRef, scrollRef, paginationRef);
     const scrollCallbackRef = React.useRef(null);
-    useImperativeHandle(imperativeRef, ()=>{
+    React.useImperativeHandle(imperativeRef, ()=>{
         var _imperativeVirtualizerRef_current;
         return {
             scrollTo (index, behavior = 'auto', callback) {

package/lib/components/VirtualizerScrollViewDynamic/useVirtualizerScrollViewDynamic.js.map CHANGED Viewed

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

package/lib/hooks/hooks.types.js CHANGED Viewed

@@ -1,4 +1 @@
-/**
- * Additional direct Ref prevents reading old resize entry data
- * Backwards compatible with ResizeObserverCallback if preferred
- */ export { };
+import * as React from 'react';

package/lib/hooks/hooks.types.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["../src/hooks/hooks.types.ts"],"sourcesContent":["import { ~~MutableRefObject,~~ ~~RefObject~~ } from 'react';\nimport { DynamicVirtualizerContextProps } from '../Utilities';\n\nexport type VirtualizerMeasureProps = {\n defaultItemSize: number;\n direction?: 'vertical' \| 'horizontal';\n\n /*\n Override recommended number of buffer items\n /\n bufferItems?: number;\n\n /\n Override recommended buffer size (px)\n /\n bufferSize?: number;\n};\n\nexport type VirtualizerMeasureDynamicProps = {\n defaultItemSize: number;\n virtualizerContext: DynamicVirtualizerContextProps;\n numItems: number;\n getItemSize: (index: number) => number;\n direction?: 'vertical' \| 'horizontal';\n\n /\n Override recommended number of buffer items\n /\n bufferItems?: number;\n\n /\n Override recommended buffer size (px)\n /\n bufferSize?: number;\n};\n\nexport type VirtualizerStaticPaginationProps = {\n itemSize: number;\n axis?: 'vertical' \| 'horizontal';\n};\n\n/\n Props to be passed into dynamic virtualization hooks\n * All props can be acquired from useVirtualizer hooks themselves and passed in\n /\nexport type VirtualizerDynamicPaginationProps = {\n /\n An array that tracks the sizing of each item in virtualizer cumulatively\n /\n progressiveItemSizes: RefObject<number[]> \| undefined;\n /\n The current starting index of the virtualizer's DOM elements\n /\n currentIndex: number;\n /\n The axis we should paginate on (should match virtualizer's axis)\n /\n axis?: 'vertical' \| 'horizontal';\n /\n The current length of Virtualizer's actual DOM elements\n /\n virtualizerLength: number;\n};\n\n/\n Additional direct Ref prevents reading old resize entry data\n * Backwards compatible with ResizeObserverCallback if preferred\n */\nexport interface ResizeCallbackWithRef {\n (\n entries: ResizeObserverEntry[],\n // TODO: exclude types from this lint rule: https://github.com/microsoft/fluentui/issues/31286\n // eslint-disable-next-line no-restricted-globals\n observer: ResizeObserver,\n scrollRef?: MutableRefObject<HTMLElement \| null>,\n ): void;\n}\n"],"names":[],"rangeMappings":"~~;;;~~","mappings":"~~AAgEA;;;CAGC~~,~~GACD~~,~~WAQC~~"}
1	+ {"version":3,"sources":["../src/hooks/hooks.types.ts"],"sourcesContent":["import * as React from 'react';\nimport { DynamicVirtualizerContextProps } from '../Utilities';\n\nexport type VirtualizerMeasureProps = {\n defaultItemSize: number;\n direction?: 'vertical' \| 'horizontal';\n\n /*\n Override recommended number of buffer items\n /\n bufferItems?: number;\n\n /\n Override recommended buffer size (px)\n /\n bufferSize?: number;\n};\n\nexport type VirtualizerMeasureDynamicProps = {\n defaultItemSize: number;\n virtualizerContext: DynamicVirtualizerContextProps;\n numItems: number;\n getItemSize: (index: number) => number;\n direction?: 'vertical' \| 'horizontal';\n\n /\n Override recommended number of buffer items\n /\n bufferItems?: number;\n\n /\n Override recommended buffer size (px)\n /\n bufferSize?: number;\n};\n\nexport type VirtualizerStaticPaginationProps = {\n itemSize: number;\n axis?: 'vertical' \| 'horizontal';\n};\n\n/\n Props to be passed into dynamic virtualization hooks\n * All props can be acquired from useVirtualizer hooks themselves and passed in\n /\nexport type VirtualizerDynamicPaginationProps = {\n /\n An array that tracks the sizing of each item in virtualizer cumulatively\n /\n progressiveItemSizes: React.RefObject<number[]> \| undefined;\n /\n The current starting index of the virtualizer's DOM elements\n /\n currentIndex: number;\n /\n The axis we should paginate on (should match virtualizer's axis)\n /\n axis?: 'vertical' \| 'horizontal';\n /\n The current length of Virtualizer's actual DOM elements\n /\n virtualizerLength: number;\n};\n\n/\n Additional direct Ref prevents reading old resize entry data\n * Backwards compatible with ResizeObserverCallback if preferred\n */\nexport interface ResizeCallbackWithRef {\n (\n entries: ResizeObserverEntry[],\n // TODO: exclude types from this lint rule: https://github.com/microsoft/fluentui/issues/31286\n // eslint-disable-next-line no-restricted-globals\n observer: ResizeObserver,\n scrollRef?: React.MutableRefObject<HTMLElement \| null>,\n ): void;\n}\n"],"names":["React"],"rangeMappings":"","mappings":"AAAA,YAAYA,WAAW,QAAQ"}

package/lib/hooks/index.js CHANGED Viewed

@@ -1,6 +1,5 @@
-export * from './useIntersectionObserver';
-export * from './useVirtualizerMeasure';
-export * from './useDynamicVirtualizerMeasure';
-export * from './useResizeObserverRef';
-export * from './hooks.types';
-export * from './useMeasureList';
+export { getRTLRootMargin, useIntersectionObserver } from './useIntersectionObserver';
+export { useStaticVirtualizerMeasure } from './useVirtualizerMeasure';
+export { useDynamicVirtualizerMeasure } from './useDynamicVirtualizerMeasure';
+export { useResizeObserverRef_unstable } from './useResizeObserverRef';
+export { createResizeObserverFromDocument, useMeasureList } from './useMeasureList';

package/lib/hooks/index.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["../src/hooks/index.ts"],"sourcesContent":["export * from './useIntersectionObserver';\nexport * from './useVirtualizerMeasure';\nexport * from './useDynamicVirtualizerMeasure';\nexport * from './useResizeObserverRef';\nexport * from './hooks.types';\nexport * from './useMeasureList';\n"],"names":[],"rangeMappings":"~~;;;;;~~","mappings":"AAAA,~~cAAc~~,4BAA4B;~~AAC1C~~,~~cAAc~~,0BAA0B;~~AACxC~~,~~cAAc~~,iCAAiC;~~AAC/C~~,~~cAAc~~,yBAAyB;~~AACvC~~,~~cAAc~~,~~gBAAgB;AAC9B~~,cAAc,mBAAmB"}
1	+ {"version":3,"sources":["../src/hooks/index.ts"],"sourcesContent":["export { getRTLRootMargin, useIntersectionObserver } from './useIntersectionObserver';\nexport { useStaticVirtualizerMeasure } from './useVirtualizerMeasure';\nexport { useDynamicVirtualizerMeasure } from './useDynamicVirtualizerMeasure';\nexport { useResizeObserverRef_unstable } from './useResizeObserverRef';\nexport type {\n ResizeCallbackWithRef,\n VirtualizerDynamicPaginationProps,\n VirtualizerMeasureDynamicProps,\n VirtualizerMeasureProps,\n VirtualizerStaticPaginationProps,\n} from './hooks.types';\nexport type { IndexedResizeCallbackElement } from './useMeasureList';\nexport { createResizeObserverFromDocument, useMeasureList } from './useMeasureList';\n"],"names":["getRTLRootMargin","useIntersectionObserver","useStaticVirtualizerMeasure","useDynamicVirtualizerMeasure","useResizeObserverRef_unstable","createResizeObserverFromDocument","useMeasureList"],"rangeMappings":";;;;","mappings":"AAAA,SAASA,gBAAgB,EAAEC,uBAAuB,QAAQ,4BAA4B;AACtF,SAASC,2BAA2B,QAAQ,0BAA0B;AACtE,SAASC,4BAA4B,QAAQ,iCAAiC;AAC9E,SAASC,6BAA6B,QAAQ,yBAAyB;AASvE,SAASC,gCAAgC,EAAEC,cAAc,QAAQ,mBAAmB"}

package/lib/hooks/useDynamicPagination.js CHANGED Viewed

@@ -1,5 +1,4 @@
 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
@@ -10,8 +9,8 @@ import { useTimeout } from '@fluentui/react-utilities';
     'use no memo';
     const { axis = 'vertical', currentIndex, progressiveItemSizes, virtualizerLength } = virtualizerProps;
     const [setScrollTimer, clearScrollTimer] = useTimeout();
-    const lastScrollPos = useRef(-1);
-    const lastIndexScrolled = useRef(-1);
+    const lastScrollPos = React.useRef(-1);
+    const lastIndexScrolled = React.useRef(-1);
     const scrollContainer = React.useRef(null);
     const clearListeners = ()=>{
         if (scrollContainer.current) {

package/lib/hooks/useDynamicPagination.js.map CHANGED Viewed

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

package/lib/hooks/useIntersectionObserver.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["../src/hooks/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 = (\n ltrRootMargin: string,\n target?: Element \| Document \| null \| undefined,\n win?: Window \| null,\n): string => {\n if (target && win) {\n // get the computed dir for the target element\n const newDir = win.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 // TODO: exclude types from this lint rule: https://github.com/microsoft/fluentui/issues/31286\n // eslint-disable-next-line no-restricted-globals\n observer: MutableRefObject<IntersectionObserver \| undefined>;\n} => {\n 'use no memo';\n\n // TODO: exclude types from this lint rule: https://github.com/microsoft/fluentui/issues/31286\n // eslint-disable-next-line no-restricted-globals\n const observer = useRef<IntersectionObserver>();\n const [observerList, setObserverList] = useState<Element[]>();\n const { targetDocument } = useFluent();\n const win = targetDocument?.defaultView;\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, win),\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, win),\n });\n }\n }\n },\n [ltrRootMargin, observerInit, options?.root, win],\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 if (!win) {\n return;\n }\n\n observer.current = new win.IntersectionObserver(callback, {\n ...observerInit,\n rootMargin: getRTLRootMargin(ltrRootMargin.current, observerInit?.root, win),\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, win]);\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, win),\n });\n },\n [ltrRootMargin, setObserverInit, win],\n );\n\n return { setObserverList, setObserverInit: setObserverInitExternal, observer };\n};\n"],"names":["React","useIsomorphicLayoutEffect","useFluent_unstable","useFluent","useCallback","useState","useRef","useMutationObserver","getRTLRootMargin","ltrRootMargin","target","win","newDir","getComputedStyle","direction","newMargin","splitMargins","split","length","useIntersectionObserver","callback","options","observer","observerList","setObserverList","targetDocument","defaultView","observerInit","setObserverInit","rootMargin","root","mutationObserverCallback","mutationList","mutation","type","attributeName","contains","current","attributes","subtree","attributeFilter","IntersectionObserver","forEach","element","observe","disconnect","setObserverInitExternal","newInit"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"~~AACA~~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"}
1	+ {"version":3,"sources":["../src/hooks/useIntersectionObserver.ts"],"sourcesContent":["import * 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 = (\n ltrRootMargin: string,\n target?: Element \| Document \| null \| undefined,\n win?: Window \| null,\n): string => {\n if (target && win) {\n // get the computed dir for the target element\n const newDir = win.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: React.Dispatch<React.SetStateAction<Element[] \| undefined>>;\n setObserverInit: (newInit: IntersectionObserverInit \| undefined) => void;\n // TODO: exclude types from this lint rule: https://github.com/microsoft/fluentui/issues/31286\n // eslint-disable-next-line no-restricted-globals\n observer: React.MutableRefObject<IntersectionObserver \| undefined>;\n} => {\n 'use no memo';\n\n // TODO: exclude types from this lint rule: https://github.com/microsoft/fluentui/issues/31286\n // eslint-disable-next-line no-restricted-globals\n const observer = useRef<IntersectionObserver>();\n const [observerList, setObserverList] = useState<Element[]>();\n const { targetDocument } = useFluent();\n const win = targetDocument?.defaultView;\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, win),\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, win),\n });\n }\n }\n },\n [ltrRootMargin, observerInit, options?.root, win],\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 if (!win) {\n return;\n }\n\n observer.current = new win.IntersectionObserver(callback, {\n ...observerInit,\n rootMargin: getRTLRootMargin(ltrRootMargin.current, observerInit?.root, win),\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, win]);\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, win),\n });\n },\n [ltrRootMargin, setObserverInit, win],\n );\n\n return { setObserverList, setObserverInit: setObserverInitExternal, observer };\n};\n"],"names":["React","useIsomorphicLayoutEffect","useFluent_unstable","useFluent","useCallback","useState","useRef","useMutationObserver","getRTLRootMargin","ltrRootMargin","target","win","newDir","getComputedStyle","direction","newMargin","splitMargins","split","length","useIntersectionObserver","callback","options","observer","observerList","setObserverList","targetDocument","defaultView","observerInit","setObserverInit","rootMargin","root","mutationObserverCallback","mutationList","mutation","type","attributeName","contains","current","attributes","subtree","attributeFilter","IntersectionObserver","forEach","element","observe","disconnect","setObserverInitExternal","newInit"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}