Initial commit

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/Virtualizer/Virtualizer.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Virtualizer", {
+    enumerable: true,
+    get: function() {
+        return Virtualizer;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useVirtualizerStylesstyles = require("./useVirtualizerStyles.styles");
+const _useVirtualizer = require("./useVirtualizer");
+const _renderVirtualizer = require("./renderVirtualizer");
+const Virtualizer = (props)=>{
+    const state = (0, _useVirtualizer.useVirtualizer_unstable)(props);
+    (0, _useVirtualizerStylesstyles.useVirtualizerStyles_unstable)(state);
+    return (0, _renderVirtualizer.renderVirtualizer_unstable)(state);
+};
+Virtualizer.displayName = 'Virtualizer';

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/Virtualizer/Virtualizer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Virtualizer/Virtualizer.ts"],"sourcesContent":["import * as React from 'react';\nimport type { VirtualizerProps } from './Virtualizer.types';\nimport { useVirtualizerStyles_unstable } from './useVirtualizerStyles.styles';\nimport { useVirtualizer_unstable } from './useVirtualizer';\nimport { renderVirtualizer_unstable } from './renderVirtualizer';\n\n/**\n * Virtualizer pseudo-component, this functional wrapper\n * provides a simple interface for reducing the total number\n * of elements rendered at one time in large lists.\n */\nexport const Virtualizer: React.FC<VirtualizerProps> = (props: VirtualizerProps) => {\n  const state = useVirtualizer_unstable(props);\n  useVirtualizerStyles_unstable(state);\n\n  return renderVirtualizer_unstable(state);\n};\n\nVirtualizer.displayName = 'Virtualizer';\n"],"names":["Virtualizer","props","state","useVirtualizer_unstable","useVirtualizerStyles_unstable","renderVirtualizer_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAWaA;;;eAAAA;;;;iEAXU;4CAEuB;gCACN;mCACG;AAOpC,MAAMA,cAA0C,CAACC;IACtD,MAAMC,QAAQC,IAAAA,uCAAAA,EAAwBF;IACtCG,IAAAA,yDAAAA,EAA8BF;IAE9B,OAAOG,IAAAA,6CAAAA,EAA2BH;AACpC;AAEAF,YAAYM,WAAW,GAAG"}

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/Virtualizer/Virtualizer.types.js

@@ -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"));

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/Virtualizer/index.js

@@ -0,0 +1,34 @@
+"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, {
+    Virtualizer: function() {
+        return _Virtualizer.Virtualizer;
+    },
+    renderVirtualizerChildPlaceholder: function() {
+        return _renderVirtualizer.renderVirtualizerChildPlaceholder;
+    },
+    renderVirtualizer_unstable: function() {
+        return _renderVirtualizer.renderVirtualizer_unstable;
+    },
+    useVirtualizerStyles_unstable: function() {
+        return _useVirtualizerStylesstyles.useVirtualizerStyles_unstable;
+    },
+    useVirtualizer_unstable: function() {
+        return _useVirtualizer.useVirtualizer_unstable;
+    },
+    virtualizerClassNames: function() {
+        return _useVirtualizerStylesstyles.virtualizerClassNames;
+    }
+});
+const _Virtualizer = require("./Virtualizer");
+const _useVirtualizer = require("./useVirtualizer");
+const _renderVirtualizer = require("./renderVirtualizer");
+const _useVirtualizerStylesstyles = require("./useVirtualizerStyles.styles");

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/Virtualizer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Virtualizer/index.ts"],"sourcesContent":["export { Virtualizer } from './Virtualizer';\nexport type {\n  VirtualizerChildRenderFunction,\n  VirtualizerConfigProps,\n  VirtualizerConfigState,\n  VirtualizerDataRef,\n  VirtualizerProps,\n  VirtualizerSlots,\n  VirtualizerState,\n} from './Virtualizer.types';\nexport { useVirtualizer_unstable } from './useVirtualizer';\nexport { renderVirtualizerChildPlaceholder, renderVirtualizer_unstable } from './renderVirtualizer';\nexport { useVirtualizerStyles_unstable, virtualizerClassNames } from './useVirtualizerStyles.styles';\n"],"names":["Virtualizer","renderVirtualizerChildPlaceholder","renderVirtualizer_unstable","useVirtualizerStyles_unstable","useVirtualizer_unstable","virtualizerClassNames"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,WAAW;eAAXA,wBAAW;;IAWXC,iCAAiC;eAAjCA,oDAAiC;;IAAEC,0BAA0B;eAA1BA,6CAA0B;;IAC7DC,6BAA6B;eAA7BA,yDAA6B;;IAF7BC,uBAAuB;eAAvBA,uCAAuB;;IAEQC,qBAAqB;eAArBA,iDAAqB;;;6BAZjC;gCAUY;mCACsC;4CACT"}

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/Virtualizer/renderVirtualizer.js

@@ -0,0 +1,42 @@
+"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, {
+    renderVirtualizerChildPlaceholder: function() {
+        return renderVirtualizerChildPlaceholder;
+    },
+    renderVirtualizer_unstable: function() {
+        return renderVirtualizer_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _jsxruntime = require("@fluentui/react-jsx-runtime/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
+const renderVirtualizer_unstable = (state)=>{
+    (0, _reactutilities.assertSlots)(state);
+    return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_react.Fragment, {
+        children: [
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(state.beforeContainer, {
+                children: /*#__PURE__*/ (0, _jsxruntime.jsx)(state.before, {})
+            }),
+            state.virtualizedChildren,
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(state.afterContainer, {
+                children: /*#__PURE__*/ (0, _jsxruntime.jsx)(state.after, {})
+            })
+        ]
+    });
+};
+const renderVirtualizerChildPlaceholder = (child, index)=>{
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_react.Suspense, {
+        fallback: null,
+        children: child
+    }, `fui-virtualizer-placeholder-${index}`);
+};

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/Virtualizer/renderVirtualizer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Virtualizer/renderVirtualizer.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\n\nimport * as React from 'react';\nimport type { VirtualizerSlots, VirtualizerState } from './Virtualizer.types';\n\nimport { assertSlots } from '@fluentui/react-utilities';\n\nexport const renderVirtualizer_unstable = (state: VirtualizerState) => {\n  assertSlots<VirtualizerSlots>(state);\n  return (\n    <React.Fragment>\n      {/* The 'before' bookend to hold items in place and detect scroll previous */}\n      <state.beforeContainer>\n        <state.before />\n      </state.beforeContainer>\n      {/* The reduced list of non-virtualized children to be rendered */}\n      {state.virtualizedChildren}\n      {/* The 'after' bookend to hold items in place and detect scroll next */}\n      <state.afterContainer>\n        <state.after />\n      </state.afterContainer>\n    </React.Fragment>\n  );\n};\n\nexport const renderVirtualizerChildPlaceholder = (child: React.ReactNode, index: number) => {\n  return (\n    <React.Suspense key={`fui-virtualizer-placeholder-${index}`} fallback={null}>\n      {child}\n    </React.Suspense>\n  );\n};\n"],"names":["renderVirtualizerChildPlaceholder","renderVirtualizer_unstable","state","assertSlots","_jsxs","React","Fragment","_jsx","beforeContainer","before","virtualizedChildren","afterContainer","after","child","index","Suspense","fallback"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IA0BaA,iCAAAA;eAAAA;;IAlBAC,0BAAAA;eAAAA;;;;4BAPb;iEAEuB;gCAGK;AAErB,MAAMA,6BAA6B,CAACC;IACzCC,IAAAA,2BAAAA,EAA8BD;IAC9B,OAAA,WAAA,GACEE,IAAAA,gBAAA,EAACC,OAAMC,QAAQ,EAAA;;0BAEbC,IAAAA,eAAA,EAACL,MAAMM,eAAe,EAAA;0BACpB,WAAA,GAAAD,IAAAA,eAAA,EAACL,MAAMO,MAAM,EAAA,CAAA;;YAGdP,MAAMQ,mBAAmB;0BAE1BH,IAAAA,eAAA,EAACL,MAAMS,cAAc,EAAA;0BACnB,WAAA,GAAAJ,IAAAA,eAAA,EAACL,MAAMU,KAAK,EAAA,CAAA;;;;AAIpB;AAEO,MAAMZ,oCAAoC,CAACa,OAAwBC;IACxE,OAAA,WAAA,GACEP,IAAAA,eAAA,EAACF,OAAMU,QAAQ,EAAA;QAA8CC,UAAU;kBACpEH;OADkB,CAAC,4BAA4B,EAAEC,MAAM,CAAC;AAI/D"}

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/Virtualizer/useVirtualizer.js

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

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/Virtualizer/useVirtualizerStyles.styles.js

@@ -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;
+};

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollView/VirtualizerScrollView.js

@@ -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';

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollView/VirtualizerScrollView.js.map

@@ -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"}

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollView/VirtualizerScrollView.types.js

@@ -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"));

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollView/VirtualizerScrollView.types.js.map

@@ -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"}

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollView/index.js

@@ -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");

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollView/index.js.map

@@ -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"}

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollView/renderVirtualizerScrollView.js

@@ -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)
+    });
+};

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollView/renderVirtualizerScrollView.js.map

@@ -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"}

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollView/useVirtualizerScrollView.js

@@ -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'
+        })
+    };
+}

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollView/useVirtualizerScrollViewStyles.styles.js

@@ -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;
+};

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollView/useVirtualizerScrollViewStyles.styles.js.map

@@ -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"}

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollViewDynamic/VirtualizerScrollViewDynamic.js

@@ -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';

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollViewDynamic/VirtualizerScrollViewDynamic.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/VirtualizerScrollViewDynamic/VirtualizerScrollViewDynamic.ts"],"sourcesContent":["import type { VirtualizerScrollViewDynamicProps } from './VirtualizerScrollViewDynamic.types';\nimport { useVirtualizerScrollViewDynamic_unstable } from './useVirtualizerScrollViewDynamic';\nimport { renderVirtualizerScrollViewDynamic_unstable } from './renderVirtualizerScrollViewDynamic';\nimport { useVirtualizerScrollViewDynamicStyles_unstable } from './useVirtualizerScrollViewDynamicStyles.styles';\nimport * as React from 'react';\nimport type { VirtualizerContextProps } from '../../Utilities';\n\n/**\n * Virtualizer ScrollView\n */\n\nexport const VirtualizerScrollViewDynamic: React.FC<VirtualizerScrollViewDynamicProps> = (\n  props: VirtualizerScrollViewDynamicProps,\n  context: React.Context<VirtualizerContextProps>,\n) => {\n  const state = useVirtualizerScrollViewDynamic_unstable(props);\n\n  useVirtualizerScrollViewDynamicStyles_unstable(state);\n\n  return renderVirtualizerScrollViewDynamic_unstable(state);\n};\n\nVirtualizerScrollViewDynamic.displayName = 'VirtualizerScrollViewDynamic';\n"],"names":["VirtualizerScrollViewDynamic","props","context","state","useVirtualizerScrollViewDynamic_unstable","useVirtualizerScrollViewDynamicStyles_unstable","renderVirtualizerScrollViewDynamic_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAWaA;;;eAAAA;;;;iDAV4C;oDACG;6DACG;iEACxC;AAOhB,MAAMA,+BAA4E,CACvFC,OACAC;IAEA,MAAMC,QAAQC,IAAAA,yEAAAA,EAAyCH;IAEvDI,IAAAA,2FAAAA,EAA+CF;IAE/C,OAAOG,IAAAA,+EAAAA,EAA4CH;AACrD;AAEAH,6BAA6BO,WAAW,GAAG"}

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollViewDynamic/VirtualizerScrollViewDynamic.types.js

@@ -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"));

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollViewDynamic/VirtualizerScrollViewDynamic.types.js.map

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

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollViewDynamic/index.js

@@ -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, {
+    VirtualizerScrollViewDynamic: function() {
+        return _VirtualizerScrollViewDynamic.VirtualizerScrollViewDynamic;
+    },
+    renderVirtualizerScrollViewDynamic_unstable: function() {
+        return _renderVirtualizerScrollViewDynamic.renderVirtualizerScrollViewDynamic_unstable;
+    },
+    useVirtualizerScrollViewDynamicStyles_unstable: function() {
+        return _useVirtualizerScrollViewDynamicStylesstyles.useVirtualizerScrollViewDynamicStyles_unstable;
+    },
+    useVirtualizerScrollViewDynamic_unstable: function() {
+        return _useVirtualizerScrollViewDynamic.useVirtualizerScrollViewDynamic_unstable;
+    },
+    virtualizerScrollViewDynamicClassNames: function() {
+        return _useVirtualizerScrollViewDynamicStylesstyles.virtualizerScrollViewDynamicClassNames;
+    }
+});
+const _VirtualizerScrollViewDynamic = require("./VirtualizerScrollViewDynamic");
+const _useVirtualizerScrollViewDynamic = require("./useVirtualizerScrollViewDynamic");
+const _renderVirtualizerScrollViewDynamic = require("./renderVirtualizerScrollViewDynamic");
+const _useVirtualizerScrollViewDynamicStylesstyles = require("./useVirtualizerScrollViewDynamicStyles.styles");

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollViewDynamic/index.js.map

@@ -0,0 +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","renderVirtualizerScrollViewDynamic_unstable","useVirtualizerScrollViewDynamicStyles_unstable","useVirtualizerScrollViewDynamic_unstable","virtualizerScrollViewDynamicClassNames"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,4BAA4B;eAA5BA,0DAA4B;;IAO5BC,2CAA2C;eAA3CA,+EAA2C;;IAElDC,8CAA8C;eAA9CA,2FAA8C;;IAHvCC,wCAAwC;eAAxCA,yEAAwC;;IAI/CC,sCAAsC;eAAtCA,mFAAsC;;;8CAVK;iDAMY;oDACG;6DAIrD"}

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollViewDynamic/renderVirtualizerScrollViewDynamic.js

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

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollViewDynamic/renderVirtualizerScrollViewDynamic.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/VirtualizerScrollViewDynamic/renderVirtualizerScrollViewDynamic.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\nimport { assertSlots } from '@fluentui/react-utilities';\nimport {\n  VirtualizerScrollViewDynamicSlots,\n  VirtualizerScrollViewDynamicState,\n} from './VirtualizerScrollViewDynamic.types';\nimport { renderVirtualizer_unstable } from '../Virtualizer/renderVirtualizer';\n\nexport const renderVirtualizerScrollViewDynamic_unstable = (state: VirtualizerScrollViewDynamicState) => {\n  assertSlots<VirtualizerScrollViewDynamicSlots>(state);\n  return <state.container>{renderVirtualizer_unstable(state)}</state.container>;\n};\n"],"names":["renderVirtualizerScrollViewDynamic_unstable","state","assertSlots","_jsx","container","renderVirtualizer_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;","mappings":";;;;+BASaA;;;eAAAA;;;4BARb;gCAC4B;mCAKe;AAEpC,MAAMA,8CAA8C,CAACC;IAC1DC,IAAAA,2BAAAA,EAA+CD;IAC/C,OAAA,WAAA,GAAOE,IAAAA,eAAA,EAACF,MAAMG,SAAS,EAAA;kBAAEC,IAAAA,6CAAAA,EAA2BJ;;AACtD"}

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollViewDynamic/useVirtualizerScrollViewDynamic.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useVirtualizerScrollViewDynamic_unstable", {
+    enumerable: true,
+    get: function() {
+        return useVirtualizerScrollViewDynamic_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 _useMeasureList = require("../../hooks/useMeasureList");
+const _useDynamicPagination = require("../../hooks/useDynamicPagination");
+function useVirtualizerScrollViewDynamic_unstable(props) {
+    'use no memo';
+    var _imperativeVirtualizerRef_current;
+    const contextState = (0, _Utilities.useVirtualizerContextState_unstable)(props.virtualizerContext);
+    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] = _react.useState(0);
+    const getChildSizeAuto = _react.useCallback((index)=>{
+        if (sizeTrackingArray.current.length <= index || sizeTrackingArray.current[index] <= 0) {
+            // Default size for initial state or untracked
+            return props.itemSize;
+        }
+        /* Required to be defined prior to our measure function
+       * we use a sizing array ref that we will update post-render
+       */ return sizeTrackingArray.current[index];
+    }, [
+        sizeTrackingArray,
+        props.itemSize,
+        sizeUpdateCount
+    ]);
+    var _props_axis, _props_getItemSize;
+    const { virtualizerLength, bufferItems, bufferSize, scrollRef, containerSizeRef, updateScrollPosition } = (0, _Hooks.useDynamicVirtualizerMeasure)({
+        defaultItemSize: props.itemSize,
+        direction: (_props_axis = props.axis) !== null && _props_axis !== void 0 ? _props_axis : 'vertical',
+        getItemSize: (_props_getItemSize = props.getItemSize) !== null && _props_getItemSize !== void 0 ? _props_getItemSize : getChildSizeAuto,
+        virtualizerContext: contextState,
+        numItems: props.numItems,
+        bufferItems: _bufferItems,
+        bufferSize: _bufferSize
+    });
+    const _imperativeVirtualizerRef = (0, _reactutilities.useMergedRefs)(_react.useRef(null), imperativeVirtualizerRef);
+    var _contextState_contextIndex;
+    const paginationRef = (0, _useDynamicPagination.useDynamicVirtualizerPagination)({
+        axis,
+        progressiveItemSizes: (_imperativeVirtualizerRef_current = _imperativeVirtualizerRef.current) === null || _imperativeVirtualizerRef_current === void 0 ? void 0 : _imperativeVirtualizerRef_current.progressiveSizes,
+        virtualizerLength,
+        currentIndex: (_contextState_contextIndex = contextState === null || contextState === void 0 ? void 0 : contextState.contextIndex) !== null && _contextState_contextIndex !== void 0 ? _contextState_contextIndex : 0
+    }, enablePagination);
+    // Store the virtualizer length as a ref for imperative ref access
+    const virtualizerLengthRef = _react.useRef(virtualizerLength);
+    if (virtualizerLengthRef.current !== virtualizerLength) {
+        virtualizerLengthRef.current = virtualizerLength;
+    }
+    const scrollViewRef = (0, _reactutilities.useMergedRefs)(props.scrollViewRef, scrollRef, paginationRef);
+    const scrollCallbackRef = _react.useRef(null);
+    _react.useImperativeHandle(imperativeRef, ()=>{
+        var _imperativeVirtualizerRef_current;
+        return {
+            scrollTo (index, behavior = 'auto', callback) {
+                scrollCallbackRef.current = callback !== null && callback !== void 0 ? callback : null;
+                if (_imperativeVirtualizerRef.current) {
+                    var _imperativeVirtualizerRef_current;
+                    const progressiveSizes = _imperativeVirtualizerRef.current.progressiveSizes.current;
+                    const totalSize = progressiveSizes && (progressiveSizes === null || progressiveSizes === void 0 ? void 0 : progressiveSizes.length) > 0 ? progressiveSizes[Math.max(progressiveSizes.length - 1, 0)] : 0;
+                    _imperativeVirtualizerRef.current.setFlaggedIndex(index);
+                    (0, _Utilities.scrollToItemDynamic)({
+                        index,
+                        itemSizes: (_imperativeVirtualizerRef_current = _imperativeVirtualizerRef.current) === null || _imperativeVirtualizerRef_current === void 0 ? void 0 : _imperativeVirtualizerRef_current.nodeSizes,
+                        totalSize,
+                        scrollViewRef: scrollViewRef,
+                        axis,
+                        reversed,
+                        behavior
+                    });
+                }
+            },
+            currentIndex: (_imperativeVirtualizerRef_current = _imperativeVirtualizerRef.current) === null || _imperativeVirtualizerRef_current === void 0 ? void 0 : _imperativeVirtualizerRef_current.currentIndex,
+            virtualizerLength: virtualizerLengthRef
+        };
+    }, [
+        axis,
+        scrollViewRef,
+        reversed,
+        _imperativeVirtualizerRef
+    ]);
+    const handleRenderedIndex = (index)=>{
+        if (scrollCallbackRef.current) {
+            scrollCallbackRef.current(index);
+        }
+    };
+    var _props_getItemSize1;
+    const virtualizerState = (0, _useVirtualizer.useVirtualizer_unstable)({
+        ...props,
+        getItemSize: (_props_getItemSize1 = props.getItemSize) !== null && _props_getItemSize1 !== void 0 ? _props_getItemSize1 : getChildSizeAuto,
+        virtualizerLength,
+        bufferItems,
+        bufferSize,
+        virtualizerContext: contextState,
+        imperativeVirtualizerRef: _imperativeVirtualizerRef,
+        onRenderedFlaggedIndex: handleRenderedIndex,
+        containerSizeRef,
+        scrollViewRef,
+        updateScrollPosition
+    });
+    const measureObject = (0, _useMeasureList.useMeasureList)(virtualizerState.virtualizerStartIndex, virtualizerLength, props.numItems, props.itemSize);
+    if (enablePagination && measureObject.sizeUpdateCount !== sizeUpdateCount) {
+        /* This enables us to let callback know that the sizes have been updated
+    triggers a re-render but is only required on pagination (else index change handles) */ setSizeUpdateCount(measureObject.sizeUpdateCount);
+    }
+    if (axis === 'horizontal') {
+        sizeTrackingArray = measureObject.widthArray;
+    } else {
+        sizeTrackingArray = measureObject.heightArray;
+    }
+    if (!props.getItemSize) {
+        // Auto-measuring is required
+        _react.Children.map(virtualizerState.virtualizedChildren, (child, index)=>{
+            if (/*#__PURE__*/ _react.isValidElement(child)) {
+                virtualizerState.virtualizedChildren[index] = /*#__PURE__*/ _react.createElement(child.type, {
+                    ...child.props,
+                    key: child.key,
+                    ref: (element)=>{
+                        if (child.hasOwnProperty('ref')) {
+                            // We must access this from the child directly, not props (forward ref).
+                            // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+                            const localRef = child === null || child === void 0 ? void 0 : child.ref;
+                            if (typeof localRef === 'function') {
+                                localRef(element);
+                            } else if (localRef) {
+                                localRef.current = element;
+                            }
+                        }
+                        // Call the auto-measure ref attachment.
+                        measureObject.createIndexedRef(index)(element);
+                    }
+                });
+            }
+        });
+    }
+    return {
+        ...virtualizerState,
+        components: {
+            ...virtualizerState.components,
+            container: 'div'
+        },
+        container: _reactutilities.slot.always(props.container, {
+            defaultProps: {
+                ref: scrollViewRef
+            },
+            elementType: 'div'
+        })
+    };
+}

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollViewDynamic/useVirtualizerScrollViewDynamicStyles.styles.js

@@ -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, {
+    useVirtualizerScrollViewDynamicStyles_unstable: function() {
+        return useVirtualizerScrollViewDynamicStyles_unstable;
+    },
+    virtualizerScrollViewDynamicClassNames: function() {
+        return virtualizerScrollViewDynamicClassNames;
+    }
+});
+const _useVirtualizerStylesstyles = require("../Virtualizer/useVirtualizerStyles.styles");
+const _react = require("@griffel/react");
+const virtualizerScrollViewDynamicClassName = 'fui-Virtualizer-Scroll-View-Dynamic';
+const virtualizerScrollViewDynamicClassNames = {
+    ..._useVirtualizerStylesstyles.virtualizerClassNames,
+    container: `${virtualizerScrollViewDynamicClassName}__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 useVirtualizerScrollViewDynamicStyles_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)(virtualizerScrollViewDynamicClassNames.container, styles.base, containerStyle, state.container.className);
+    return state;
+};

node_modules/@fluentui/react-virtualizer/lib-commonjs/components/VirtualizerScrollViewDynamic/useVirtualizerScrollViewDynamicStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useVirtualizerScrollViewDynamicStyles.styles.js"],"sourcesContent":["import { useVirtualizerStyles_unstable, virtualizerClassNames } from '../Virtualizer/useVirtualizerStyles.styles';\nimport { makeStyles, mergeClasses } from '@griffel/react';\nconst virtualizerScrollViewDynamicClassName = 'fui-Virtualizer-Scroll-View-Dynamic';\nexport const virtualizerScrollViewDynamicClassNames = {\n    ...virtualizerClassNames,\n    container: `${virtualizerScrollViewDynamicClassName}__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 useVirtualizerScrollViewDynamicStyles_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(virtualizerScrollViewDynamicClassNames.container, styles.base, containerStyle, state.container.className);\n    return state;\n};\n"],"names":["useVirtualizerScrollViewDynamicStyles_unstable","virtualizerScrollViewDynamicClassNames","virtualizerScrollViewDynamicClassName","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,8CAA8C;eAA9CA;;IA7BJC,sCAAsC;eAAtCA;;;4CAHwD;uBAC5B;AACzC,MAAMC,wCAAwC;AACvC,MAAMD,yCAAyC;IAClD,GAAGE,iDAAqB;IACxBC,WAAW,CAAA,EAAGF,sCAAqC,WAAA,CAAA;AACvD;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,iDAAkDmB,CAAAA;IAC/D;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,uCAAuCG,SAAS,EAAEgB,OAAOb,IAAI,EAAEe,gBAAgBH,MAAMf,SAAS,CAACqB,SAAS;IACjJ,OAAON;AACX"}