npm - @fluentui/react-virtualizer - Versions diffs - 9.0.0-alpha.9 → 9.0.0-alpha.91 - Mend

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

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 (183) hide show

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

	@@ -1 +1 @@
1	- {"version":3,"names":["useIntersectionObserver_1","require","react_1","react_utilities_1","react_dom_1","useVirtualizer_unstable","props","itemSize","numItems","virtualizerLength","children","renderChild","getItemSize","bufferItems","Math","round","bufferSize","floor","intersectionObserverRoot","axis","reversed","onUpdateIndex","onCalculateIndex","virtualizerStartIndex","setVirtualizerStartIndex","useState","beforeElementRef","useRef","afterElementRef","childSizes","Array","childProgressiveSizes","childArray","forceUpdate","useReducer","horizontal","populateSizeArrays","current","length","index","batchUpdateNewIndex","updateChildRows","updateCurrentItemSizes","setObserverList","useIntersectionObserver","entries","observer","measurementPos","bufferCount","latestEntry","sort","entry1","entry2","time","find","entry","intersectionRatio","target","calculateAfter","calculateTotalSize","abs","boundingClientRect","bottom","top","right","left","calculateBefore","max","startIndex","getIndexFromScrollPosition","bufferedIndex","maxIndex","newStartIndex","min","flushSync","root","rootMargin","threshold","findIndexRecursive","scrollPos","lowIndex","highIndex","midpoint","iBefore","iAfter","indexValue","afterIndexValue","beforeIndexValue","getIndexFromSizeArray","lastItemIndex","remainingItems","newIndex","actualIndex","end","i","setBeforeRef","useCallback","element","newList","push","setAfterRef","endIndex","didUpdate","newSize","prevSize","hasInitialized","initializeSizeArray","useEffect","isFullyInitialized","components","before","after","beforeContainer","afterContainer","virtualizedChildren","resolveShorthand","required","defaultProps","ref","role","beforeBufferHeight","afterBufferHeight","totalVirtualizerHeight","exports"],"sources":["../src/packages/react-components/react-virtualizer/src/components/Virtualizer/useVirtualizer.ts"],"sourcesContent":["import { useIntersectionObserver } from '../../hooks/useIntersectionObserver';\nimport type { ReactNode } from 'react';\nimport { useEffect, useRef, useState, useCallback, useReducer } from 'react';\n\nimport type { VirtualizerProps, VirtualizerState } from './Virtualizer.types';\nimport { resolveShorthand } from '@fluentui/react-utilities';\nimport { flushSync } from 'react-dom';\n\nexport function useVirtualizer_unstable(props: VirtualizerProps): VirtualizerState {\n const {\n itemSize,\n numItems,\n virtualizerLength,\n children: renderChild,\n getItemSize,\n bufferItems = Math.round(virtualizerLength / 4.0),\n bufferSize = Math.floor(bufferItems / 2.0) * itemSize,\n intersectionObserverRoot,\n axis = 'vertical',\n reversed = false,\n onUpdateIndex,\n onCalculateIndex,\n } = props;\n\n // Tracks the initial item to start virtualizer at, -1 implies first render cycle\n const [virtualizerStartIndex, setVirtualizerStartIndex] = useState<number>(-1);\n\n // Store ref to before padding element\n const beforeElementRef = useRef<Element \| null>(null);\n\n // Store ref to before padding element\n const afterElementRef = useRef<Element \| null>(null);\n\n // We need to store an array to track dynamic sizes, we can use this to incrementally update changes\n const childSizes = useRef<number[]>(new Array<number>(getItemSize ? numItems : 0));\n\n /* We keep track of the progressive sizing/placement down the list,\n this helps us skip re-calculations unless children/size changes /\n const childProgressiveSizes = useRef<number[]>(new Array<number>(getItemSize ? numItems : 0));\n\n // The internal tracking REF for child array (updates often).\n const childArray = useRef<ReactNode[]>(new Array(virtualizerLength));\n\n // We want to be methodical about updating the render with child reference array\n const forceUpdate = useReducer(() => ({}), {})[1];\n\n const horizontal = axis === 'horizontal';\n\n const populateSizeArrays = () => {\n if (!getItemSize) {\n // Static sizes, never mind!\n return;\n }\n\n if (numItems !== childSizes.current.length) {\n childSizes.current = new Array<number>(numItems);\n }\n\n if (numItems !== childProgressiveSizes.current.length) {\n childProgressiveSizes.current = new Array<number>(numItems);\n }\n\n for (let index = 0; index < numItems; index++) {\n childSizes.current[index] = getItemSize(index);\n\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 batchUpdateNewIndex = (index: number) => {\n // Local updates\n onUpdateIndex?.(index, virtualizerStartIndex);\n updateChildRows(index);\n updateCurrentItemSizes(index);\n\n // State setters\n setVirtualizerStartIndex(index);\n };\n\n // Observe intersections of virtualized components\n const { setObserverList } = useIntersectionObserver(\n (entries: IntersectionObserverEntry[], observer: IntersectionObserver) => {\n / Sanity check - do we even need virtualization? /\n if (virtualizerLength > numItems) {\n if (virtualizerStartIndex !== 0) {\n batchUpdateNewIndex(0);\n }\n // No-op\n return;\n }\n\n / IO initiates this function when needed (bookend entering view) /\n let measurementPos = 0;\n let bufferCount = bufferItems;\n\n // Grab latest entry that is intersecting\n const latestEntry =\n entries.length === 1\n ? entries[0]\n : entries\n .sort((entry1, entry2) => entry2.time - entry1.time)\n .find(entry => {\n return entry.intersectionRatio > 0;\n });\n\n if (!latestEntry) {\n // If we don't find an intersecting area, ignore for now.\n return;\n }\n\n if (latestEntry.target === afterElementRef.current) {\n // We need to inverse the buffer count\n bufferCount = virtualizerLength - bufferItems;\n measurementPos = reversed ? calculateAfter() : calculateTotalSize() - calculateAfter();\n if (!horizontal) {\n if (reversed) {\n // Scrolling 'up' and hit the after element below\n measurementPos -= Math.abs(latestEntry.boundingClientRect.bottom);\n } else if (latestEntry.boundingClientRect.top < 0) {\n // Scrolling 'down' and hit the after element above top: 0\n measurementPos -= latestEntry.boundingClientRect.top;\n }\n } else {\n if (reversed) {\n // Scrolling 'left' and hit the after element\n measurementPos -= Math.abs(latestEntry.boundingClientRect.right);\n } else if (latestEntry.boundingClientRect.left < 0) {\n // Scrolling 'right' and hit the after element\n measurementPos -= latestEntry.boundingClientRect.left;\n }\n }\n } else if (latestEntry.target === beforeElementRef.current) {\n measurementPos = reversed ? calculateTotalSize() - calculateBefore() : calculateBefore();\n if (!horizontal) {\n if (!reversed) {\n measurementPos -= Math.abs(latestEntry.boundingClientRect.bottom);\n } else if (latestEntry.boundingClientRect.top < 0) {\n // Scrolling 'down' in reverse order and hit the before element above top: 0\n measurementPos -= latestEntry.boundingClientRect.top;\n }\n } else {\n if (!reversed) {\n measurementPos -= Math.abs(latestEntry.boundingClientRect.right);\n } else if (latestEntry.boundingClientRect.left < 0) {\n // Scrolling 'left' and hit before element\n measurementPos -= latestEntry.boundingClientRect.left;\n }\n }\n }\n\n if (reversed) {\n // We're reversed, up is down, left is right, invert the scroll measure.\n measurementPos = Math.max(calculateTotalSize() - Math.abs(measurementPos), 0);\n }\n\n // For now lets use hardcoded size to assess current element to paginate on\n const startIndex = getIndexFromScrollPosition(measurementPos);\n let bufferedIndex = Math.max(startIndex - bufferCount, 0);\n\n if (onCalculateIndex) {\n // User has chance to intervene/customize prior to render\n // They may want to normalize this value.\n bufferedIndex = onCalculateIndex(bufferedIndex);\n }\n\n // Safety limits\n const maxIndex = Math.max(numItems - virtualizerLength, 0);\n const newStartIndex = Math.min(Math.max(bufferedIndex, 0), maxIndex);\n\n if (virtualizerStartIndex !== newStartIndex) {\n // We flush sync this and perform an immediate state update\n // due to virtualizerStartIndex invalidation.\n flushSync(() => {\n batchUpdateNewIndex(newStartIndex);\n });\n }\n },\n {\n root: intersectionObserverRoot ? intersectionObserverRoot?.current : null,\n rootMargin: '0px',\n threshold: 0,\n },\n );\n\n const findIndexRecursive = (scrollPos: number, lowIndex: number, highIndex: number): number => {\n if (lowIndex > highIndex) {\n // We shouldn't get here - but no-op the index if we do.\n return virtualizerStartIndex;\n }\n const midpoint = Math.floor((lowIndex + highIndex) / 2);\n const iBefore = Math.max(midpoint - 1, 0);\n const iAfter = Math.min(midpoint + 1, childProgressiveSizes.current.length - 1);\n const indexValue = childProgressiveSizes.current[midpoint];\n const afterIndexValue = childProgressiveSizes.current[iAfter];\n const beforeIndexValue = childProgressiveSizes.current[iBefore];\n if (scrollPos <= afterIndexValue && scrollPos >= beforeIndexValue) {\n / We've found our index - if we are exactly matching before/after index that's ok,\n better to reduce checks if it's right on the boundary. /\n return midpoint;\n }\n\n if (indexValue > scrollPos) {\n return findIndexRecursive(scrollPos, lowIndex, midpoint - 1);\n } else {\n return findIndexRecursive(scrollPos, midpoint + 1, highIndex);\n }\n };\n\n const getIndexFromSizeArray = (scrollPos: number): number => {\n / Quick searches our progressive height array /\n if (\n scrollPos === 0 \|\|\n childProgressiveSizes.current.length === 0 \|\|\n scrollPos <= childProgressiveSizes.current[0]\n ) {\n // Check start\n return 0;\n }\n\n if (scrollPos >= childProgressiveSizes.current[childProgressiveSizes.current.length - 1]) {\n // Check end\n return childProgressiveSizes.current.length - 1;\n }\n\n return findIndexRecursive(scrollPos, 0, childProgressiveSizes.current.length - 1);\n };\n\n const getIndexFromScrollPosition = (scrollPos: number) => {\n if (!getItemSize) {\n return Math.round(scrollPos / itemSize);\n }\n\n return getIndexFromSizeArray(scrollPos);\n };\n\n const calculateTotalSize = () => {\n if (!getItemSize) {\n return itemSize numItems;\n }\n\n // Time for custom size calcs\n return childProgressiveSizes.current[numItems - 1];\n };\n\n const calculateBefore = () => {\n if (!getItemSize) {\n // The missing items from before virtualization starts height\n return virtualizerStartIndex * itemSize;\n }\n\n if (virtualizerStartIndex <= 0) {\n return 0;\n }\n\n // Time for custom size calcs\n return childProgressiveSizes.current[virtualizerStartIndex - 1];\n };\n\n const calculateAfter = () => {\n if (numItems === 0) {\n return 0;\n }\n\n const lastItemIndex = Math.min(virtualizerStartIndex + virtualizerLength, numItems - 1);\n if (!getItemSize) {\n // The missing items from after virtualization ends height\n const remainingItems = numItems - lastItemIndex - 1;\n return remainingItems * itemSize;\n }\n\n // Time for custom size calcs\n return childProgressiveSizes.current[numItems - 1] - childProgressiveSizes.current[lastItemIndex];\n };\n\n const updateChildRows = (newIndex: number) => {\n if (numItems === 0) {\n /* Nothing to virtualize /\n\n return [];\n }\n\n if (childArray.current.length !== numItems) {\n childArray.current = new Array(virtualizerLength);\n }\n const actualIndex = Math.max(newIndex, 0);\n const end = Math.min(actualIndex + virtualizerLength, numItems);\n\n for (let i = actualIndex; i < end; i++) {\n childArray.current[i - actualIndex] = renderChild(i);\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 const updateCurrentItemSizes = (newIndex: number) => {\n if (!getItemSize) {\n // Static sizes, not required.\n return;\n }\n // We should always call our size function on index change (only for the items that will be rendered)\n // This ensures we request the latest data for incoming items in case sizing has changed.\n const endIndex = Math.min(newIndex + virtualizerLength, numItems);\n const startIndex = Math.max(newIndex, 0);\n\n let didUpdate = false;\n for (let i = startIndex; i < endIndex; i++) {\n const newSize = getItemSize(i);\n if (newSize !== childSizes.current[i]) {\n childSizes.current[i] = newSize;\n didUpdate = true;\n }\n }\n\n if (didUpdate) {\n // Update our progressive size array\n for (let i = startIndex; i < numItems; i++) {\n const prevSize = i > 0 ? childProgressiveSizes.current[i - 1] : 0;\n childProgressiveSizes.current[i] = prevSize + childSizes.current[i];\n }\n }\n };\n\n // Initialize the size array before first render.\n const hasInitialized = useRef<boolean>(false);\n const initializeSizeArray = () => {\n if (hasInitialized.current === false) {\n hasInitialized.current = true;\n populateSizeArrays();\n }\n };\n\n // Initialization on mount - update array index to 0 (ready state).\n // Only fire on mount (no deps).\n useEffect(() => {\n if (virtualizerStartIndex < 0) {\n batchUpdateNewIndex(0);\n }\n // eslint-disable-next-line react-hooks/exhaustive-deps\n }, []);\n\n // If the user passes in an updated renderChild function - update current children\n useEffect(() => {\n if (virtualizerStartIndex >= 0) {\n updateChildRows(virtualizerStartIndex);\n forceUpdate();\n }\n // eslint-disable-next-line react-hooks/exhaustive-deps\n }, [renderChild]);\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 const isFullyInitialized = hasInitialized.current && virtualizerStartIndex >= 0;\n return {\n components: {\n before: 'div',\n after: 'div',\n beforeContainer: 'div',\n afterContainer: 'div',\n },\n virtualizedChildren: childArray.current,\n before: resolveShorthand(props.before, {\n required: true,\n defaultProps: {\n ref: setBeforeRef,\n role: 'none',\n },\n }),\n after: resolveShorthand(props.after, {\n required: true,\n defaultProps: {\n ref: setAfterRef,\n role: 'none',\n },\n }),\n beforeContainer: resolveShorthand(props.beforeContainer, {\n required: true,\n defaultProps: {\n role: 'none',\n },\n }),\n afterContainer: resolveShorthand(props.afterContainer, {\n required: true,\n defaultProps: {\n role: 'none',\n },\n }),\n beforeBufferHeight: isFullyInitialized ? calculateBefore() : 0,\n afterBufferHeight: isFullyInitialized ? calculateAfter() : 0,\n totalVirtualizerHeight: isFullyInitialized ? calculateTotalSize() : virtualizerLength itemSize,\n virtualizerStartIndex,\n axis,\n bufferSize,\n reversed,\n };\n}\n"],"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":["useVirtualizer_unstable","props","itemSize","numItems","virtualizerLength","children","renderChild","getItemSize","bufferItems","Math","round","bufferSize","floor","axis","reversed","virtualizerContext","onRenderedFlaggedIndex","imperativeVirtualizerRef","containerSizeRef","scrollViewRef","enableScrollLoad","updateScrollPosition","gap","_virtualizerContext","useVirtualizerContextState_unstable","actualIndexRef","React","useRef","contextIndex","flaggedIndex","actualIndex","current","setActualIndex","useCallback","index","setContextIndex","beforeElementRef","afterElementRef","childSizes","Array","childProgressiveSizes","childArray","populateSizeArrays","length","_gap","isScrolling","setIsScrolling","useState","setScrollTimer","clearScrollTimer","useTimeout","scrollCounter","initializeScrollingTimer","INIT_SCROLL_FLAG_REQ","INIT_SCROLL_FLAG_DELAY","useEffect","updateChildRows","newIndex","_actualIndex","max","end","min","i","updateCurrentItemSizes","endIndex","startIndex","didUpdate","newSize","prevSize","batchUpdateNewIndex","findIndexRecursive","scrollPos","lowIndex","highIndex","midpoint","iBefore","iAfter","indexValue","afterIndexValue","beforeIndexValue","getIndexFromSizeArray","getIndexFromScrollPosition","calculateTotalSize","calculateBefore","currentIndex","calculateAfter","lastItemIndex","remainingItems","setObserverList","useIntersectionObserver","entries","observer","sortedEntries","sort","entry1","entry2","time","latestEntry","find","entry","isIntersecting","calculateOverBuffer","measurementPos","target","overflowAmount","intersectionRect","height","width","hOverflow","boundingClientRect","top","hOverflowReversed","bottom","wOverflow","left","wOverflowReversed","right","widthOverflow","heightOverflow","additionalOverflow","maxIndex","newStartIndex","flushSync","root","rootMargin","threshold","setBeforeRef","element","newList","push","setAfterRef","hasInitialized","initializeSizeArray","useImperativeHandle","progressiveSizes","nodeSizes","setFlaggedIndex","forceUpdate","useReducer","maxCompare","isFullyInitialized","components","before","after","beforeContainer","afterContainer","virtualizedChildren","slot","always","defaultProps","ref","role","elementType","beforeBufferHeight","afterBufferHeight","totalVirtualizerHeight","virtualizerStartIndex"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib-commonjs/components/Virtualizer/useVirtualizerStyles.styles.js ADDED Viewed

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    useVirtualizerStyles_unstable: function() {
+        return useVirtualizerStyles_unstable;
+    },
+    virtualizerClassNames: function() {
+        return virtualizerClassNames;
+    }
+});
+const _react = require("@griffel/react");
+const virtualizerClassName = 'fui-Virtualizer';
+const virtualizerClassNames = {
+    before: `${virtualizerClassName}__before`,
+    beforeContainer: `${virtualizerClassName}__beforeContainer`,
+    after: `${virtualizerClassName}__after`,
+    afterContainer: `${virtualizerClassName}__afterContainer`
+};
+const useStyles = /*#__PURE__*/ (0, _react.__styles)({
+    base: {
+        mc9l5x: "ftgm304",
+        Bkecrkj: "f1aehjj5"
+    },
+    relative: {
+        qhf8xq: "f10pi13n"
+    },
+    horizontal: {
+        sshi5w: "fan4evk"
+    },
+    vertical: {
+        Bf4jedk: "f11qra4b"
+    }
+}, {
+    d: [
+        ".ftgm304{display:block;}",
+        ".f1aehjj5{pointer-events:none;}",
+        ".f10pi13n{position:relative;}",
+        ".fan4evk{min-height:100%;}",
+        ".f11qra4b{min-width:100%;}"
+    ]
+});
+const useVirtualizerStyles_unstable = (state)=>{
+    'use no memo';
+    const styles = useStyles();
+    const { reversed, axis, beforeBufferHeight, afterBufferHeight, bufferSize } = state;
+    const horizontal = axis === 'horizontal';
+    state.before.className = (0, _react.mergeClasses)(virtualizerClassNames.before, styles.base, styles.relative, horizontal ? styles.horizontal : styles.vertical, state.before.className);
+    state.after.className = (0, _react.mergeClasses)(virtualizerClassNames.after, styles.base, styles.relative, horizontal ? styles.horizontal : styles.vertical, state.after.className);
+    state.beforeContainer.className = (0, _react.mergeClasses)(virtualizerClassNames.beforeContainer, styles.base, horizontal ? styles.horizontal : styles.vertical, state.beforeContainer.className);
+    state.afterContainer.className = (0, _react.mergeClasses)(virtualizerClassNames.afterContainer, styles.base, horizontal ? styles.horizontal : styles.vertical, state.afterContainer.className);
+    const beforeHeightPx = beforeBufferHeight + 'px';
+    const afterHeightPx = afterBufferHeight + 'px';
+    const beforeBufferHeightPx = beforeBufferHeight + bufferSize + 'px';
+    const afterBufferHeightPx = afterBufferHeight + bufferSize + 'px';
+    const bufferPx = bufferSize + 'px';
+    const beforeBuffer = {
+        // Column
+        ...!reversed && !horizontal && {
+            marginBottom: `-${bufferPx}`
+        },
+        // Column-Reverse
+        ...reversed && !horizontal && {
+            marginTop: `-${bufferPx}`
+        },
+        // Row
+        ...!reversed && horizontal && {
+            marginRight: `-${bufferPx}`
+        },
+        // Row-Reverse
+        ...reversed && horizontal && {
+            marginLeft: `-${bufferPx}`
+        }
+    };
+    const afterBuffer = {
+        // Column
+        ...!reversed && !horizontal && {
+            marginTop: `-${bufferPx}`
+        },
+        // Column-Reverse
+        ...reversed && !horizontal && {
+            marginBottom: `-${bufferPx}`
+        },
+        // Row
+        ...!reversed && horizontal && {
+            marginLeft: `-${bufferPx}`
+        },
+        // Row-Reverse
+        ...reversed && horizontal && {
+            marginRight: `-${bufferPx}`
+        }
+    };
+    state.before.style = {
+        height: horizontal ? '100%' : beforeBufferHeightPx,
+        width: horizontal ? beforeBufferHeightPx : '100%',
+        ...beforeBuffer,
+        ...state.before.style
+    };
+    state.beforeContainer.style = {
+        height: horizontal ? 'auto' : beforeHeightPx,
+        width: horizontal ? beforeHeightPx : 'auto',
+        ...state.beforeContainer.style
+    };
+    state.after.style = {
+        height: horizontal ? '100%' : afterBufferHeightPx,
+        width: horizontal ? afterBufferHeightPx : '100%',
+        ...afterBuffer,
+        ...state.after.style
+    };
+    state.afterContainer.style = {
+        height: horizontal ? 'auto' : afterHeightPx,
+        width: horizontal ? afterHeightPx : 'auto',
+        ...state.afterContainer.style
+    };
+    return state;
+};

package/lib-commonjs/components/Virtualizer/useVirtualizerStyles.styles.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"sources":["useVirtualizerStyles.styles.js"],"sourcesContent":["import { makeStyles, mergeClasses } from '@griffel/react';\nconst virtualizerClassName = 'fui-Virtualizer';\nexport const virtualizerClassNames = {\n before: `${virtualizerClassName}__before`,\n beforeContainer: `${virtualizerClassName}__beforeContainer`,\n after: `${virtualizerClassName}__after`,\n afterContainer: `${virtualizerClassName}__afterContainer`\n};\nconst useStyles = makeStyles({\n base: {\n display: 'block',\n pointerEvents: 'none'\n },\n relative: {\n position: 'relative'\n },\n horizontal: {\n minHeight: '100%'\n },\n vertical: {\n minWidth: '100%'\n }\n});\n/**\n * Apply styling to the Virtualizer states\n */ export const useVirtualizerStyles_unstable = (state)=>{\n 'use no memo';\n const styles = useStyles();\n const { reversed, axis, beforeBufferHeight, afterBufferHeight, bufferSize } = state;\n const horizontal = axis === 'horizontal';\n state.before.className = mergeClasses(virtualizerClassNames.before, styles.base, styles.relative, horizontal ? styles.horizontal : styles.vertical, state.before.className);\n state.after.className = mergeClasses(virtualizerClassNames.after, styles.base, styles.relative, horizontal ? styles.horizontal : styles.vertical, state.after.className);\n state.beforeContainer.className = mergeClasses(virtualizerClassNames.beforeContainer, styles.base, horizontal ? styles.horizontal : styles.vertical, state.beforeContainer.className);\n state.afterContainer.className = mergeClasses(virtualizerClassNames.afterContainer, styles.base, horizontal ? styles.horizontal : styles.vertical, state.afterContainer.className);\n const beforeHeightPx = beforeBufferHeight + 'px';\n const afterHeightPx = afterBufferHeight + 'px';\n const beforeBufferHeightPx = beforeBufferHeight + bufferSize + 'px';\n const afterBufferHeightPx = afterBufferHeight + bufferSize + 'px';\n const bufferPx = bufferSize + 'px';\n const beforeBuffer = {\n // Column\n ...!reversed && !horizontal && {\n marginBottom: `-${bufferPx}`\n },\n // Column-Reverse\n ...reversed && !horizontal && {\n marginTop: `-${bufferPx}`\n },\n // Row\n ...!reversed && horizontal && {\n marginRight: `-${bufferPx}`\n },\n // Row-Reverse\n ...reversed && horizontal && {\n marginLeft: `-${bufferPx}`\n }\n };\n const afterBuffer = {\n // Column\n ...!reversed && !horizontal && {\n marginTop: `-${bufferPx}`\n },\n // Column-Reverse\n ...reversed && !horizontal && {\n marginBottom: `-${bufferPx}`\n },\n // Row\n ...!reversed && horizontal && {\n marginLeft: `-${bufferPx}`\n },\n // Row-Reverse\n ...reversed && horizontal && {\n marginRight: `-${bufferPx}`\n }\n };\n state.before.style = {\n height: horizontal ? '100%' : beforeBufferHeightPx,\n width: horizontal ? beforeBufferHeightPx : '100%',\n ...beforeBuffer,\n ...state.before.style\n };\n state.beforeContainer.style = {\n height: horizontal ? 'auto' : beforeHeightPx,\n width: horizontal ? beforeHeightPx : 'auto',\n ...state.beforeContainer.style\n };\n state.after.style = {\n height: horizontal ? '100%' : afterBufferHeightPx,\n width: horizontal ? afterBufferHeightPx : '100%',\n ...afterBuffer,\n ...state.after.style\n };\n state.afterContainer.style = {\n height: horizontal ? 'auto' : afterHeightPx,\n width: horizontal ? afterHeightPx : 'auto',\n ...state.afterContainer.style\n };\n return state;\n};\n"],"names":["useVirtualizerStyles_unstable","virtualizerClassNames","virtualizerClassName","before","beforeContainer","after","afterContainer","useStyles","__styles","base","mc9l5x","Bkecrkj","relative","qhf8xq","horizontal","sshi5w","vertical","Bf4jedk","d","state","styles","reversed","axis","beforeBufferHeight","afterBufferHeight","bufferSize","className","mergeClasses","beforeHeightPx","afterHeightPx","beforeBufferHeightPx","afterBufferHeightPx","bufferPx","beforeBuffer","marginBottom","marginTop","marginRight","marginLeft","afterBuffer","style","height","width"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib-commonjs/components/VirtualizerScrollView/VirtualizerScrollView.js ADDED Viewed

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "VirtualizerScrollView", {
+    enumerable: true,
+    get: function() {
+        return VirtualizerScrollView;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _useVirtualizerScrollView = require("./useVirtualizerScrollView");
+const _renderVirtualizerScrollView = require("./renderVirtualizerScrollView");
+const _useVirtualizerScrollViewStylesstyles = require("./useVirtualizerScrollViewStyles.styles");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const VirtualizerScrollView = (props)=>{
+    const state = (0, _useVirtualizerScrollView.useVirtualizerScrollView_unstable)(props);
+    (0, _useVirtualizerScrollViewStylesstyles.useVirtualizerScrollViewStyles_unstable)(state);
+    return (0, _renderVirtualizerScrollView.renderVirtualizerScrollView_unstable)(state);
+};
+VirtualizerScrollView.displayName = 'VirtualizerScrollView';

package/lib-commonjs/components/VirtualizerScrollView/VirtualizerScrollView.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"sources":["../src/components/VirtualizerScrollView/VirtualizerScrollView.ts"],"sourcesContent":["import type { VirtualizerScrollViewProps } from './VirtualizerScrollView.types';\nimport { useVirtualizerScrollView_unstable } from './useVirtualizerScrollView';\nimport { renderVirtualizerScrollView_unstable } from './renderVirtualizerScrollView';\nimport { useVirtualizerScrollViewStyles_unstable } from './useVirtualizerScrollViewStyles.styles';\nimport * as React from 'react';\n\n/**\n * Virtualizer ScrollView\n */\n\nexport const VirtualizerScrollView: React.FC<VirtualizerScrollViewProps> = (props: VirtualizerScrollViewProps) => {\n const state = useVirtualizerScrollView_unstable(props);\n\n useVirtualizerScrollViewStyles_unstable(state);\n\n return renderVirtualizerScrollView_unstable(state);\n};\n\nVirtualizerScrollView.displayName = 'VirtualizerScrollView';\n"],"names":["VirtualizerScrollView","props","state","useVirtualizerScrollView_unstable","useVirtualizerScrollViewStyles_unstable","renderVirtualizerScrollView_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAUaA;;;eAAAA;;;;0CATqC;6CACG;sDACG;iEACjC;AAMhB,MAAMA,wBAA8D,CAACC;IAC1E,MAAMC,QAAQC,IAAAA,2DAAAA,EAAkCF;IAEhDG,IAAAA,6EAAAA,EAAwCF;IAExC,OAAOG,IAAAA,iEAAAA,EAAqCH;AAC9C;AAEAF,sBAAsBM,WAAW,GAAG"}

package/lib-commonjs/components/VirtualizerScrollView/VirtualizerScrollView.types.js ADDED Viewed

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

package/lib-commonjs/components/VirtualizerScrollView/VirtualizerScrollView.types.js.map ADDED Viewed

@@ -0,0 +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":[],"rangeMappings":";;;;;","mappings":";;;;;iEAAuB"}

package/lib-commonjs/components/VirtualizerScrollView/index.js ADDED Viewed

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    VirtualizerScrollView: function() {
+        return _VirtualizerScrollView.VirtualizerScrollView;
+    },
+    renderVirtualizerScrollView_unstable: function() {
+        return _renderVirtualizerScrollView.renderVirtualizerScrollView_unstable;
+    },
+    useVirtualizerScrollViewStyles_unstable: function() {
+        return _useVirtualizerScrollViewStylesstyles.useVirtualizerScrollViewStyles_unstable;
+    },
+    useVirtualizerScrollView_unstable: function() {
+        return _useVirtualizerScrollView.useVirtualizerScrollView_unstable;
+    },
+    virtualizerScrollViewClassNames: function() {
+        return _useVirtualizerScrollViewStylesstyles.virtualizerScrollViewClassNames;
+    }
+});
+const _VirtualizerScrollView = require("./VirtualizerScrollView");
+const _useVirtualizerScrollView = require("./useVirtualizerScrollView");
+const _renderVirtualizerScrollView = require("./renderVirtualizerScrollView");
+const _useVirtualizerScrollViewStylesstyles = require("./useVirtualizerScrollViewStyles.styles");

package/lib-commonjs/components/VirtualizerScrollView/index.js.map ADDED Viewed

@@ -0,0 +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","renderVirtualizerScrollView_unstable","useVirtualizerScrollViewStyles_unstable","useVirtualizerScrollView_unstable","virtualizerScrollViewClassNames"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,qBAAqB;eAArBA,4CAAqB;;IAOrBC,oCAAoC;eAApCA,iEAAoC;;IAE3CC,uCAAuC;eAAvCA,6EAAuC;;IAHhCC,iCAAiC;eAAjCA,2DAAiC;;IAIxCC,+BAA+B;eAA/BA,qEAA+B;;;uCAVK;0CAMY;6CACG;sDAI9C"}

package/lib-commonjs/components/VirtualizerScrollView/renderVirtualizerScrollView.js ADDED Viewed

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

package/lib-commonjs/components/VirtualizerScrollView/renderVirtualizerScrollView.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"sources":["../src/components/VirtualizerScrollView/renderVirtualizerScrollView.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\n\nimport type { VirtualizerScrollViewSlots, VirtualizerScrollViewState } from './VirtualizerScrollView.types';\n\nimport { assertSlots } from '@fluentui/react-utilities';\nimport { renderVirtualizer_unstable } from '../Virtualizer/renderVirtualizer';\n\nexport const renderVirtualizerScrollView_unstable = (state: VirtualizerScrollViewState) => {\n assertSlots<VirtualizerScrollViewSlots>(state);\n\n return <state.container>{renderVirtualizer_unstable(state)}</state.container>;\n};\n"],"names":["renderVirtualizerScrollView_unstable","state","assertSlots","_jsx","container","renderVirtualizer_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;","mappings":";;;;+BAQaA;;;eAAAA;;;4BAPb;gCAI4B;mCACe;AAEpC,MAAMA,uCAAuC,CAACC;IACnDC,IAAAA,2BAAAA,EAAwCD;IAExC,OAAA,WAAA,GAAOE,IAAAA,eAAA,EAACF,MAAMG,SAAS,EAAA;kBAAEC,IAAAA,6CAAAA,EAA2BJ;;AACtD"}

package/lib-commonjs/components/VirtualizerScrollView/useVirtualizerScrollView.js ADDED Viewed

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useVirtualizerScrollView_unstable", {
+    enumerable: true,
+    get: function() {
+        return useVirtualizerScrollView_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
+const _useVirtualizer = require("../Virtualizer/useVirtualizer");
+const _Hooks = require("../../Hooks");
+const _Utilities = require("../../Utilities");
+const _useStaticPagination = require("../../hooks/useStaticPagination");
+function useVirtualizerScrollView_unstable(props) {
+    const { imperativeRef, itemSize, numItems, axis = 'vertical', reversed, enablePagination = false } = props;
+    var _props_axis;
+    const { virtualizerLength, bufferItems, bufferSize, scrollRef, containerSizeRef } = (0, _Hooks.useStaticVirtualizerMeasure)({
+        defaultItemSize: props.itemSize,
+        direction: (_props_axis = props.axis) !== null && _props_axis !== void 0 ? _props_axis : 'vertical'
+    });
+    // Store the virtualizer length as a ref for imperative ref access
+    const virtualizerLengthRef = _react.useRef(virtualizerLength);
+    if (virtualizerLengthRef.current !== virtualizerLength) {
+        virtualizerLengthRef.current = virtualizerLength;
+    }
+    const paginationRef = (0, _useStaticPagination.useStaticVirtualizerPagination)({
+        axis,
+        itemSize
+    }, enablePagination);
+    const scrollViewRef = (0, _reactutilities.useMergedRefs)(props.scrollViewRef, scrollRef, paginationRef);
+    const imperativeVirtualizerRef = _react.useRef(null);
+    const scrollCallbackRef = _react.useRef(null);
+    _react.useImperativeHandle(imperativeRef, ()=>{
+        var _imperativeVirtualizerRef_current;
+        return {
+            scrollTo (index, behavior = 'auto', callback) {
+                var _imperativeVirtualizerRef_current;
+                scrollCallbackRef.current = callback !== null && callback !== void 0 ? callback : null;
+                (_imperativeVirtualizerRef_current = imperativeVirtualizerRef.current) === null || _imperativeVirtualizerRef_current === void 0 ? void 0 : _imperativeVirtualizerRef_current.setFlaggedIndex(index);
+                (0, _Utilities.scrollToItemStatic)({
+                    index,
+                    itemSize,
+                    totalItems: numItems,
+                    scrollViewRef,
+                    axis,
+                    reversed,
+                    behavior
+                });
+            },
+            currentIndex: (_imperativeVirtualizerRef_current = imperativeVirtualizerRef.current) === null || _imperativeVirtualizerRef_current === void 0 ? void 0 : _imperativeVirtualizerRef_current.currentIndex,
+            virtualizerLength: virtualizerLengthRef
+        };
+    }, [
+        axis,
+        scrollViewRef,
+        itemSize,
+        numItems,
+        reversed
+    ]);
+    const handleRenderedIndex = (index)=>{
+        if (scrollCallbackRef.current) {
+            scrollCallbackRef.current(index);
+        }
+    };
+    const virtualizerState = (0, _useVirtualizer.useVirtualizer_unstable)({
+        ...props,
+        virtualizerLength,
+        bufferItems,
+        bufferSize,
+        onRenderedFlaggedIndex: handleRenderedIndex,
+        imperativeVirtualizerRef,
+        containerSizeRef
+    });
+    return {
+        ...virtualizerState,
+        components: {
+            ...virtualizerState.components,
+            container: 'div'
+        },
+        container: _reactutilities.slot.always(props.container, {
+            defaultProps: {
+                ref: scrollViewRef
+            },
+            elementType: 'div'
+        })
+    };
+}

package/lib-commonjs/components/VirtualizerScrollView/useVirtualizerScrollView.js.map ADDED Viewed

@@ -0,0 +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":["useVirtualizerScrollView_unstable","props","imperativeRef","itemSize","numItems","axis","reversed","enablePagination","virtualizerLength","bufferItems","bufferSize","scrollRef","containerSizeRef","useStaticVirtualizerMeasure","defaultItemSize","direction","virtualizerLengthRef","React","useRef","current","paginationRef","useStaticVirtualizerPagination","scrollViewRef","useMergedRefs","imperativeVirtualizerRef","scrollCallbackRef","useImperativeHandle","scrollTo","index","behavior","callback","setFlaggedIndex","scrollToItemStatic","totalItems","currentIndex","handleRenderedIndex","virtualizerState","useVirtualizer_unstable","onRenderedFlaggedIndex","components","container","slot","always","defaultProps","ref","elementType"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BASgBA;;;eAAAA;;;;iEATO;gCACa;gCACI;uBAEI;2BACT;qCAEY;AAExC,SAASA,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,GAAGC,IAAAA,kCAAAA,EAA4B;QAC9GC,iBAAiBb,MAAME,QAAQ;QAC/BY,WAAWd,CAAAA,cAAAA,MAAMI,IAAI,AAAJA,MAAI,QAAVJ,gBAAAA,KAAAA,IAAAA,cAAc;IAC3B;IAEA,kEAAkE;IAClE,MAAMe,uBAAuBC,OAAMC,MAAM,CAASV;IAClD,IAAIQ,qBAAqBG,OAAO,KAAKX,mBAAmB;QACtDQ,qBAAqBG,OAAO,GAAGX;IACjC;IAEA,MAAMY,gBAAgBC,IAAAA,mDAAAA,EAA+B;QAAEhB;QAAMF;IAAS,GAAGI;IACzE,MAAMe,gBAAgBC,IAAAA,6BAAAA,EAActB,MAAMqB,aAAa,EAAEX,WAAWS;IACpE,MAAMI,2BAA2BP,OAAMC,MAAM,CAA4B;IACzE,MAAMO,oBAAoBR,OAAMC,MAAM,CAAmC;IAEzED,OAAMS,mBAAmB,CACvBxB,eACA;YAekBsB;QAdhB,OAAO;YACLG,UAASC,KAAa,EAAEC,WAAW,MAAM,EAAEC,QAA+C;oBAExFN;gBADAC,kBAAkBN,OAAO,GAAGW,aAAAA,QAAAA,aAAAA,KAAAA,IAAAA,WAAY;gBACxCN,CAAAA,oCAAAA,yBAAyBL,OAAO,AAAPA,MAAO,QAAhCK,sCAAAA,KAAAA,IAAAA,KAAAA,IAAAA,kCAAkCO,eAAe,CAACH;gBAClDI,IAAAA,6BAAAA,EAAmB;oBACjBJ;oBACAzB;oBACA8B,YAAY7B;oBACZkB;oBACAjB;oBACAC;oBACAuB;gBACF;YACF;YACAK,cAAY,AAAEV,CAAAA,oCAAAA,yBAAyBL,OAAO,AAAPA,MAAO,QAAhCK,sCAAAA,KAAAA,IAAAA,KAAAA,IAAAA,kCAAkCU,YAAY;YAC5D1B,mBAAmBQ;QACrB;IACF,GACA;QAACX;QAAMiB;QAAenB;QAAUC;QAAUE;KAAS;IAGrD,MAAM6B,sBAAsB,CAACP;QAC3B,IAAIH,kBAAkBN,OAAO,EAAE;YAC7BM,kBAAkBN,OAAO,CAACS;QAC5B;IACF;IAEA,MAAMQ,mBAAmBC,IAAAA,uCAAAA,EAAwB;QAC/C,GAAGpC,KAAK;QACRO;QACAC;QACAC;QACA4B,wBAAwBH;QACxBX;QACAZ;IACF;IAEA,OAAO;QACL,GAAGwB,gBAAgB;QACnBG,YAAY;YACV,GAAGH,iBAAiBG,UAAU;YAC9BC,WAAW;QACb;QACAA,WAAWC,oBAAAA,CAAKC,MAAM,CAACzC,MAAMuC,SAAS,EAAE;YACtCG,cAAc;gBACZC,KAAKtB;YACP;YACAuB,aAAa;QACf;IACF;AACF"}

package/lib-commonjs/components/VirtualizerScrollView/useVirtualizerScrollViewStyles.styles.js ADDED Viewed

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

package/lib-commonjs/components/VirtualizerScrollView/useVirtualizerScrollViewStyles.styles.js.map ADDED Viewed

@@ -0,0 +1 @@

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

package/lib-commonjs/components/VirtualizerScrollViewDynamic/VirtualizerScrollViewDynamic.js ADDED Viewed

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "VirtualizerScrollViewDynamic", {
+    enumerable: true,
+    get: function() {
+        return VirtualizerScrollViewDynamic;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _useVirtualizerScrollViewDynamic = require("./useVirtualizerScrollViewDynamic");
+const _renderVirtualizerScrollViewDynamic = require("./renderVirtualizerScrollViewDynamic");
+const _useVirtualizerScrollViewDynamicStylesstyles = require("./useVirtualizerScrollViewDynamicStyles.styles");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const VirtualizerScrollViewDynamic = (props, context)=>{
+    const state = (0, _useVirtualizerScrollViewDynamic.useVirtualizerScrollViewDynamic_unstable)(props);
+    (0, _useVirtualizerScrollViewDynamicStylesstyles.useVirtualizerScrollViewDynamicStyles_unstable)(state);
+    return (0, _renderVirtualizerScrollViewDynamic.renderVirtualizerScrollViewDynamic_unstable)(state);
+};
+VirtualizerScrollViewDynamic.displayName = 'VirtualizerScrollViewDynamic';