@fluentui/react-virtualizer 9.0.0-alpha.86 → 9.0.0-alpha.88

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

@@ -8,6 +8,8 @@ Object.defineProperty(exports, "Virtualizer", {
         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");

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

@@ -1 +1 @@
-{"version":3,"sources":["Virtualizer.ts"],"sourcesContent":["import type { VirtualizerProps } from './Virtualizer.types';\nimport { useVirtualizerStyles_unstable } from './useVirtualizerStyles.styles';\nimport { useVirtualizer_unstable } from './useVirtualizer';\nimport { renderVirtualizer_unstable } from './renderVirtualizer';\nimport type { FC } from 'react';\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: 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;;;4CAViC;gCACN;mCACG;AAQpC,MAAMA,cAAoC,CAACC;IAChD,MAAMC,QAAQC,IAAAA,uCAAAA,EAAwBF;IACtCG,IAAAA,yDAAAA,EAA8BF;IAE9B,OAAOG,IAAAA,6CAAAA,EAA2BH;AACpC;AAEAF,YAAYM,WAAW,GAAG"}
+{"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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["Virtualizer.types.ts"],"sourcesContent":["import * as React from 'react';\nimport type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\nimport type { VirtualizerContextProps } from '../../Utilities';\nimport type { RefObject, MutableRefObject } from 'react';\n\nexport type VirtualizerSlots = {\n  /**\n   * The intersection observed 'before' element will detect when scrolling towards the beginning.\n   */\n  before: NonNullable<Slot<'div', 'td'>>;\n  /**\n   * A block place holding whitespace at the beginning of current DOM children.\n   */\n  beforeContainer: NonNullable<Slot<'div', 'tr'>>;\n  /**\n   * The intersection observed 'after' element will detect when scrolling towards the end.\n   */\n  after: NonNullable<Slot<'div', 'td'>>;\n  /**\n   * A block place holding whitespace after the end of current DOM children.\n   */\n  afterContainer: NonNullable<Slot<'div', 'tr'>>;\n};\n\nexport type VirtualizerConfigState = {\n  /**\n   * The current virtualized array of children to show in the DOM.\n   */\n  virtualizedChildren: React.ReactNode[];\n  /**\n   * The current start index for the virtualizer, all previous index's will be removed from DOM.\n   */\n  virtualizerStartIndex: number;\n  /**\n   * Current buffer height required at beginning of array.\n   */\n  afterBufferHeight: number;\n  /**\n   * Current buffer height required at end of array.\n   */\n  beforeBufferHeight: number;\n  /**\n   * The total current height of the scrollView/child content.\n   */\n  totalVirtualizerHeight: number;\n  /**\n   * The scroll direction\n   * @default vertical\n   */\n  axis?: 'vertical' | 'horizontal';\n  /**\n   * Tells the virtualizer to measure in the reverse direction (for column-reverse order etc.)\n   */\n  reversed?: boolean;\n  /**\n   * Enables the isScrolling property in the child render function\n   * Default: false - to prevent nessecary render function calls\n   */\n  enableScrollLoad?: boolean;\n  /**\n   * Pixel size of intersection observers and how much they 'cross over' into the bufferItems index.\n   * Minimum 1px.\n   */\n  bufferSize: number;\n  /**\n   * Ref for access to internal size knowledge, can be used to measure updates\n   */\n  childSizes: React.MutableRefObject<number[]>;\n  /**\n   * Ref for access to internal progressive size knowledge, can be used to measure updates\n   */\n  childProgressiveSizes: React.MutableRefObject<number[]>;\n};\n\nexport type VirtualizerState = ComponentState<VirtualizerSlots> & VirtualizerConfigState;\n\n/**\n * The main child render method of Virtualization\n * isScrolling will only be enabled when enableScrollLoad is set to true.\n */\nexport type VirtualizerChildRenderFunction = (index: number, isScrolling: boolean) => React.ReactNode;\n\nexport type VirtualizerDataRef = {\n  progressiveSizes: RefObject<number[]>;\n  nodeSizes: RefObject<number[]>;\n  setFlaggedIndex: (index: number | null) => void;\n  currentIndex: RefObject<number>;\n};\n\nexport type VirtualizerConfigProps = {\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   * Can be used dynamically.\n   */\n  children: VirtualizerChildRenderFunction;\n\n  /**\n   * Default cell size to use if no custom callback provided.\n   * If implementing `getItemSize` this should be the initial and ideally minimum cell size.\n   */\n  itemSize: number;\n\n  /**\n   * The total number of items to be virtualized.\n   */\n  numItems: number;\n\n  /**\n   * Number of children to render in the DOM during virtualization.\n   * Constraints:\n   * - Large enough that the items rendered in DOM cover the viewport\n   *   and intersection observer buffers (buffersize) at both ends.\n   */\n  virtualizerLength: number;\n\n  /**\n   * Defaults to 1/4th (or 1/3rd for dynamic items) of virtualizerLength.\n   * RECOMMEND: Override this with a consistent value if using a dynamic virtualizer.\n   *\n   * Controls the number of elements rendered before the current index entering the virtualized viewport.\n   * Constraints:\n   * - Large enough to cover bufferSize (prevents buffers intersecting into the viewport during rest state).\n   * - Small enough that the virtualizer only renders a few items outside of view.\n   */\n  bufferItems?: number;\n\n  /**\n   * Defaults to half of bufferItems * itemSize size (in pixels).\n   * RECOMMEND: Override this with a consistent minimum item size value if using a dynamic virtualizer.\n   * The length (in pixels) before the end/start DOM index where the virtualizer recalculation will be triggered.\n   * Increasing this reduces whitespace on ultra-fast scroll, as additional elements\n   * are buffered to appear while virtualization recalculates.\n   * Constraints:\n   * - At least 1px - although this will only trigger the recalculation after bookends (whitespace) enter viewport.\n   * - BufferSize must be smaller than bufferItems pixel size, as it prevents bookends entering viewport at rest.\n   */\n  bufferSize?: number;\n\n  /**\n   * Enables users to override the intersectionObserverRoot.\n   * RECOMMEND: DO NOT PASS THIS IN, as it can cause side effects\n   * when overlapping with other scroll views\n   */\n  scrollViewRef?: React.MutableRefObject<HTMLElement | null>;\n\n  /**\n   * The scroll direction\n   * @default vertical\n   */\n  axis?: 'vertical' | 'horizontal';\n\n  /**\n   * Tells the virtualizer to measure in the reverse direction (for column-reverse order etc.)\n   * This value should be flipped in RTL implementation (TBD whether automate RTL).\n   */\n  reversed?: boolean;\n\n  /**\n   * Enables the isScrolling property in the child render function\n   * Default: false - to prevent nessecary render function calls\n   */\n  enableScrollLoad?: boolean;\n\n  /**\n   * Callback for acquiring size of individual items\n   * @param index - the index of the requested size's child\n   */\n  getItemSize?: (index: number) => number;\n\n  /**\n   * Virtualizer context can be passed as a prop for extended class use\n   */\n  virtualizerContext?: VirtualizerContextProps;\n\n  /**\n   * Callback for notifying when a flagged index has been rendered\n   */\n  // eslint-disable-next-line @nx/workspace-consistent-callback-type -- can't change type of existing callback\n  onRenderedFlaggedIndex?: (index: number) => void;\n\n  /*\n   * Callback for notifying when a flagged index has been rendered\n   */\n  flaggedIndex?: MutableRefObject<number | null>;\n\n  /**\n   * Imperative ref contains our scrollTo index functionality for user control.\n   */\n  imperativeVirtualizerRef?: RefObject<VirtualizerDataRef>;\n\n  /**\n   * A ref that provides the size of container (vertical - height, horizontal - width), set by a resize observer.\n   * Virtualizer Measure hooks provide a suitable reference.\n   */\n  containerSizeRef: RefObject<number>;\n};\n\nexport type VirtualizerProps = ComponentProps<Partial<VirtualizerSlots>> & VirtualizerConfigProps;\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;iEAAuB"}
+{"version":3,"sources":["../src/components/Virtualizer/Virtualizer.types.ts"],"sourcesContent":["import * as React from 'react';\nimport type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\nimport type { VirtualizerContextProps } from '../../Utilities';\n\nexport type VirtualizerSlots = {\n  /**\n   * The intersection observed 'before' element will detect when scrolling towards the beginning.\n   */\n  before: NonNullable<Slot<'div', 'td'>>;\n  /**\n   * A block place holding whitespace at the beginning of current DOM children.\n   */\n  beforeContainer: NonNullable<Slot<'div', 'tr'>>;\n  /**\n   * The intersection observed 'after' element will detect when scrolling towards the end.\n   */\n  after: NonNullable<Slot<'div', 'td'>>;\n  /**\n   * A block place holding whitespace after the end of current DOM children.\n   */\n  afterContainer: NonNullable<Slot<'div', 'tr'>>;\n};\n\nexport type VirtualizerConfigState = {\n  /**\n   * The current virtualized array of children to show in the DOM.\n   */\n  virtualizedChildren: React.ReactNode[];\n  /**\n   * The current start index for the virtualizer, all previous index's will be removed from DOM.\n   */\n  virtualizerStartIndex: number;\n  /**\n   * Current buffer height required at beginning of array.\n   */\n  afterBufferHeight: number;\n  /**\n   * Current buffer height required at end of array.\n   */\n  beforeBufferHeight: number;\n  /**\n   * The total current height of the scrollView/child content.\n   */\n  totalVirtualizerHeight: number;\n  /**\n   * The scroll direction\n   * @default vertical\n   */\n  axis?: 'vertical' | 'horizontal';\n  /**\n   * Tells the virtualizer to measure in the reverse direction (for column-reverse order etc.)\n   */\n  reversed?: boolean;\n  /**\n   * Enables the isScrolling property in the child render function\n   * Default: false - to prevent nessecary render function calls\n   */\n  enableScrollLoad?: boolean;\n  /**\n   * Pixel size of intersection observers and how much they 'cross over' into the bufferItems index.\n   * Minimum 1px.\n   */\n  bufferSize: number;\n  /**\n   * Ref for access to internal size knowledge, can be used to measure updates\n   */\n  childSizes: React.MutableRefObject<number[]>;\n  /**\n   * Ref for access to internal progressive size knowledge, can be used to measure updates\n   */\n  childProgressiveSizes: React.MutableRefObject<number[]>;\n};\n\nexport type VirtualizerState = ComponentState<VirtualizerSlots> & VirtualizerConfigState;\n\n/**\n * The main child render method of Virtualization\n * isScrolling will only be enabled when enableScrollLoad is set to true.\n */\nexport type VirtualizerChildRenderFunction = (index: number, isScrolling: boolean) => React.ReactNode;\n\nexport type VirtualizerDataRef = {\n  progressiveSizes: React.RefObject<number[]>;\n  nodeSizes: React.RefObject<number[]>;\n  setFlaggedIndex: (index: number | null) => void;\n  currentIndex: React.RefObject<number>;\n};\n\nexport type VirtualizerConfigProps = {\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   * Can be used dynamically.\n   */\n  children: VirtualizerChildRenderFunction;\n\n  /**\n   * Default cell size to use if no custom callback provided.\n   * If implementing `getItemSize` this should be the initial and ideally minimum cell size.\n   */\n  itemSize: number;\n\n  /**\n   * The total number of items to be virtualized.\n   */\n  numItems: number;\n\n  /**\n   * Number of children to render in the DOM during virtualization.\n   * Constraints:\n   * - Large enough that the items rendered in DOM cover the viewport\n   *   and intersection observer buffers (buffersize) at both ends.\n   */\n  virtualizerLength: number;\n\n  /**\n   * Defaults to 1/4th (or 1/3rd for dynamic items) of virtualizerLength.\n   * RECOMMEND: Override this with a consistent value if using a dynamic virtualizer.\n   *\n   * Controls the number of elements rendered before the current index entering the virtualized viewport.\n   * Constraints:\n   * - Large enough to cover bufferSize (prevents buffers intersecting into the viewport during rest state).\n   * - Small enough that the virtualizer only renders a few items outside of view.\n   */\n  bufferItems?: number;\n\n  /**\n   * Defaults to half of bufferItems * itemSize size (in pixels).\n   * RECOMMEND: Override this with a consistent minimum item size value if using a dynamic virtualizer.\n   * The length (in pixels) before the end/start DOM index where the virtualizer recalculation will be triggered.\n   * Increasing this reduces whitespace on ultra-fast scroll, as additional elements\n   * are buffered to appear while virtualization recalculates.\n   * Constraints:\n   * - At least 1px - although this will only trigger the recalculation after bookends (whitespace) enter viewport.\n   * - BufferSize must be smaller than bufferItems pixel size, as it prevents bookends entering viewport at rest.\n   */\n  bufferSize?: number;\n\n  /**\n   * Enables users to override the intersectionObserverRoot.\n   * We recommend passing this in for accurate distance assessment in IO\n   */\n  scrollViewRef?: React.MutableRefObject<HTMLElement | null>;\n\n  /**\n   * The scroll direction\n   * @default vertical\n   */\n  axis?: 'vertical' | 'horizontal';\n\n  /**\n   * Tells the virtualizer to measure in the reverse direction (for column-reverse order etc.)\n   * This value should be flipped in RTL implementation (TBD whether automate RTL).\n   */\n  reversed?: boolean;\n\n  /**\n   * Enables the isScrolling property in the child render function\n   * Default: false - to prevent nessecary render function calls\n   */\n  enableScrollLoad?: boolean;\n\n  /**\n   * Callback for acquiring size of individual items\n   * @param index - the index of the requested size's child\n   */\n  getItemSize?: (index: number) => number;\n\n  /**\n   * Virtualizer context can be passed as a prop for extended class use\n   */\n  virtualizerContext?: VirtualizerContextProps;\n\n  /**\n   * Callback for notifying when a flagged index has been rendered\n   */\n  // eslint-disable-next-line @nx/workspace-consistent-callback-type -- can't change type of existing callback\n  onRenderedFlaggedIndex?: (index: number) => void;\n\n  /*\n   * Callback for notifying when a flagged index has been rendered\n   */\n  flaggedIndex?: React.MutableRefObject<number | null>;\n\n  /**\n   * Imperative ref contains our scrollTo index functionality for user control.\n   */\n  imperativeVirtualizerRef?: React.RefObject<VirtualizerDataRef>;\n\n  /**\n   * A ref that provides the size of container (vertical - height, horizontal - width), set by a resize observer.\n   * Virtualizer Measure hooks provide a suitable reference.\n   */\n  containerSizeRef: React.RefObject<number>;\n\n  /**\n   * A callback that enables updating scroll position for calculating required dynamic lengths,\n   * this should be passed in from useDynamicVirtualizerMeasure\n   */\n  updateScrollPosition?: (position: number) => void;\n\n  /**\n   * Spacing between rendered children for calculation, should match the container's gap CSS value.\n   */\n  gap?: number;\n};\n\nexport type VirtualizerProps = ComponentProps<Partial<VirtualizerSlots>> & VirtualizerConfigProps;\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;iEAAuB"}

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

@@ -1 +1 @@
-{"version":3,"sources":["index.ts"],"sourcesContent":["export * from './Virtualizer';\nexport * from './Virtualizer.types';\nexport * from './useVirtualizer';\nexport * from './renderVirtualizer';\nexport * from './useVirtualizerStyles.styles';\n"],"names":[],"rangeMappings":";;;;;;;;;","mappings":";;;;;uBAAc;uBACA;uBACA;uBACA;uBACA"}
+{"version":3,"sources":["../src/components/Virtualizer/index.ts"],"sourcesContent":["export * from './Virtualizer';\nexport * from './Virtualizer.types';\nexport * from './useVirtualizer';\nexport * from './renderVirtualizer';\nexport * from './useVirtualizerStyles.styles';\n"],"names":[],"rangeMappings":";;;;;;;;;","mappings":";;;;;uBAAc;uBACA;uBACA;uBACA;uBACA"}

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

@@ -1 +1 @@
-{"version":3,"sources":["renderVirtualizer.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\n\nimport * as React from 'react';\nimport type { VirtualizerSlots, VirtualizerState } from './Virtualizer.types';\nimport type { ReactNode } from 'react';\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: 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":";;;;;;;;;;;IA2BaA,iCAAAA;eAAAA;;IAlBAC,0BAAAA;eAAAA;;;;4BARb;iEAEuB;gCAIK;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,OAAkBC;IAClE,OAAA,WAAA,GACEP,IAAAA,eAAA,EAACF,OAAMU,QAAQ,EAAA;QAA8CC,UAAU;kBACpEH;OADkB,CAAC,4BAA4B,EAAEC,MAAM,CAAC;AAI/D"}
+{"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"}

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

@@ -8,42 +8,43 @@ Object.defineProperty(exports, "useVirtualizer_unstable", {
         return useVirtualizer_unstable;
     }
 });
-const _react = require("react");
+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 } = props;
+    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 = (0, _react.useRef)(_virtualizerContext.contextIndex);
-    const flaggedIndex = (0, _react.useRef)(null);
+    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 = (0, _react.useCallback)((index)=>{
+    const setActualIndex = _react.useCallback((index)=>{
         actualIndexRef.current = index;
         _virtualizerContext.setContextIndex(index);
     }, [
         _virtualizerContext
     ]);
     // Store ref to before padding element
-    const beforeElementRef = (0, _react.useRef)(null);
+    const beforeElementRef = _react.useRef(null);
     // Store ref to before padding element
-    const afterElementRef = (0, _react.useRef)(null);
+    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 = (0, _react.useRef)(new Array(getItemSize ? numItems : 0));
+    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 = (0, _react.useRef)(new Array(getItemSize ? numItems : 0));
+  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 = (0, _react.useRef)(new Array(virtualizerLength));
+    const childArray = _react.useRef(new Array(virtualizerLength));
     const populateSizeArrays = ()=>{
         if (!getItemSize) {
             // Static sizes, never mind!
@@ -59,7 +60,8 @@ function useVirtualizer_unstable(props) {
             }
         }
         for(let index = 0; index < numItems; index++){
-            childSizes.current[index] = getItemSize(index);
+            const _gap = index < numItems - 1 ? gap : 0;
+            childSizes.current[index] = getItemSize(index) + _gap;
             if (index === 0) {
                 childProgressiveSizes.current[index] = childSizes.current[index];
             } else {
@@ -67,10 +69,10 @@ function useVirtualizer_unstable(props) {
             }
         }
     };
-    const [isScrolling, setIsScrolling] = (0, _react.useState)(false);
+    const [isScrolling, setIsScrolling] = _react.useState(false);
     const [setScrollTimer, clearScrollTimer] = (0, _reactutilities.useTimeout)();
-    const scrollCounter = (0, _react.useRef)(0);
-    const initializeScrollingTimer = (0, _react.useCallback)(()=>{
+    const scrollCounter = _react.useRef(0);
+    const initializeScrollingTimer = _react.useCallback(()=>{
         if (!enableScrollLoad) {
             // Disabled by default for reduction of render callbacks
             return;
@@ -96,13 +98,13 @@ function useVirtualizer_unstable(props) {
         setScrollTimer,
         enableScrollLoad
     ]);
-    (0, _react.useEffect)(()=>{
+    _react.useEffect(()=>{
         initializeScrollingTimer();
     }, [
         actualIndex,
         initializeScrollingTimer
     ]);
-    const updateChildRows = (0, _react.useCallback)((newIndex)=>{
+    const updateChildRows = _react.useCallback((newIndex)=>{
         if (numItems === 0) {
             /* Nothing to virtualize */ return;
         }
@@ -121,7 +123,7 @@ function useVirtualizer_unstable(props) {
         renderChild,
         virtualizerLength
     ]);
-    const updateCurrentItemSizes = (0, _react.useCallback)((newIndex)=>{
+    const updateCurrentItemSizes = _react.useCallback((newIndex)=>{
         if (!getItemSize) {
             // Static sizes, not required.
             return;
@@ -132,7 +134,8 @@ function useVirtualizer_unstable(props) {
         const startIndex = Math.max(newIndex, 0);
         let didUpdate = false;
         for(let i = startIndex; i < endIndex; i++){
-            const newSize = getItemSize(i);
+            const _gap = i < numItems - 1 ? gap : 0;
+            const newSize = getItemSize(i) + _gap;
             if (newSize !== childSizes.current[i]) {
                 childSizes.current[i] = newSize;
                 didUpdate = true;
@@ -148,9 +151,10 @@ function useVirtualizer_unstable(props) {
     }, [
         getItemSize,
         numItems,
-        virtualizerLength
+        virtualizerLength,
+        gap
     ]);
-    const batchUpdateNewIndex = (0, _react.useCallback)((index)=>{
+    const batchUpdateNewIndex = _react.useCallback((index)=>{
         // Local updates
         updateChildRows(index);
         updateCurrentItemSizes(index);
@@ -161,7 +165,7 @@ function useVirtualizer_unstable(props) {
         updateChildRows,
         updateCurrentItemSizes
     ]);
-    const findIndexRecursive = (0, _react.useCallback)((scrollPos, lowIndex, highIndex)=>{
+    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;
@@ -184,7 +188,7 @@ function useVirtualizer_unstable(props) {
     }, [
         actualIndex
     ]);
-    const getIndexFromSizeArray = (0, _react.useCallback)((scrollPos)=>{
+    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;
@@ -197,32 +201,34 @@ function useVirtualizer_unstable(props) {
     }, [
         findIndexRecursive
     ]);
-    const getIndexFromScrollPosition = (0, _react.useCallback)((scrollPos)=>{
+    const getIndexFromScrollPosition = _react.useCallback((scrollPos)=>{
         if (!getItemSize) {
-            return Math.round(scrollPos / itemSize);
+            return Math.round(scrollPos / (itemSize + gap));
         }
         return getIndexFromSizeArray(scrollPos);
     }, [
         getIndexFromSizeArray,
         getItemSize,
-        itemSize
+        itemSize,
+        gap
     ]);
-    const calculateTotalSize = (0, _react.useCallback)(()=>{
+    const calculateTotalSize = _react.useCallback(()=>{
         if (!getItemSize) {
-            return itemSize * numItems;
+            return (itemSize + gap) * numItems;
         }
         // Time for custom size calcs
         return childProgressiveSizes.current[numItems - 1];
     }, [
         getItemSize,
         itemSize,
-        numItems
+        numItems,
+        gap
     ]);
-    const calculateBefore = (0, _react.useCallback)(()=>{
+    const calculateBefore = _react.useCallback(()=>{
         const currentIndex = Math.min(actualIndex, numItems - 1);
         if (!getItemSize) {
             // The missing items from before virtualization starts height
-            return currentIndex * itemSize;
+            return currentIndex * (itemSize + gap);
         }
         if (currentIndex <= 0) {
             return 0;
@@ -233,9 +239,10 @@ function useVirtualizer_unstable(props) {
         actualIndex,
         getItemSize,
         itemSize,
-        numItems
+        numItems,
+        gap
     ]);
-    const calculateAfter = (0, _react.useCallback)(()=>{
+    const calculateAfter = _react.useCallback(()=>{
         if (numItems === 0 || actualIndex + virtualizerLength >= numItems) {
             return 0;
         }
@@ -243,7 +250,7 @@ function useVirtualizer_unstable(props) {
         if (!getItemSize) {
             // The missing items from after virtualization ends height
             const remainingItems = numItems - lastItemIndex;
-            return remainingItems * itemSize;
+            return remainingItems * (itemSize + gap) - gap;
         }
         // Time for custom size calcs
         return childProgressiveSizes.current[numItems - 1] - childProgressiveSizes.current[lastItemIndex - 1];
@@ -252,10 +259,11 @@ function useVirtualizer_unstable(props) {
         getItemSize,
         itemSize,
         numItems,
-        virtualizerLength
+        virtualizerLength,
+        gap
     ]);
     // Observe intersections of virtualized components
-    const { setObserverList } = (0, _useIntersectionObserver.useIntersectionObserver)((0, _react.useCallback)(// eslint-disable-next-line no-restricted-globals
+    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) {
@@ -264,12 +272,16 @@ function useVirtualizer_unstable(props) {
             // No-op
             return;
         }
-        // Grab latest entry that is intersecting
-        const latestEntry = entries.length === 1 ? entries[0] : entries.sort((entry1, entry2)=>entry2.time - entry1.time).find((entry)=>{
-            return entry.intersectionRatio > 0;
+        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 || !latestEntry.isIntersecting) {
-            // If we don't find an intersecting area, ignore for now.
+        if (!latestEntry) {
             return;
         }
         // We have to be sure our item sizes are up to date with current indexed ref before calculation
@@ -339,33 +351,38 @@ function useVirtualizer_unstable(props) {
         // Safety limits
         const newStartIndex = Math.min(Math.max(startIndex, 0), maxIndex);
         (0, _reactdom.flushSync)(()=>{
-            _virtualizerContext.setContextPosition(measurementPos);
+            // 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);
             }
         });
     }, [
-        _virtualizerContext,
         actualIndex,
+        virtualizerLength,
         axis,
-        batchUpdateNewIndex,
-        bufferItems,
+        reversed,
+        numItems,
         bufferSize,
+        bufferItems,
+        containerSizeRef,
+        updateScrollPosition,
+        batchUpdateNewIndex,
         calculateAfter,
         calculateBefore,
         calculateTotalSize,
-        containerSizeRef,
         getIndexFromScrollPosition,
-        numItems,
-        reversed,
-        updateCurrentItemSizes,
-        virtualizerLength
+        updateCurrentItemSizes
     ]), {
         root: scrollViewRef ? scrollViewRef === null || scrollViewRef === void 0 ? void 0 : scrollViewRef.current : null,
         rootMargin: '0px',
         threshold: 0
     });
-    const setBeforeRef = (0, _react.useCallback)((element)=>{
+    const setBeforeRef = _react.useCallback((element)=>{
         if (!element || beforeElementRef.current === element) {
             return;
         }
@@ -380,7 +397,7 @@ function useVirtualizer_unstable(props) {
     }, [
         setObserverList
     ]);
-    const setAfterRef = (0, _react.useCallback)((element)=>{
+    const setAfterRef = _react.useCallback((element)=>{
         if (!element || afterElementRef.current === element) {
             return;
         }
@@ -396,14 +413,14 @@ function useVirtualizer_unstable(props) {
         setObserverList
     ]);
     // Initialize the size array before first render.
-    const hasInitialized = (0, _react.useRef)(false);
+    const hasInitialized = _react.useRef(false);
     const initializeSizeArray = ()=>{
         if (hasInitialized.current === false) {
             hasInitialized.current = true;
             populateSizeArrays();
         }
     };
-    (0, _react.useImperativeHandle)(imperativeVirtualizerRef, ()=>{
+    _react.useImperativeHandle(imperativeVirtualizerRef, ()=>{
         return {
             progressiveSizes: childProgressiveSizes,
             nodeSizes: childSizes,
@@ -416,7 +433,7 @@ function useVirtualizer_unstable(props) {
     ]);
     // Initialization on mount - update array index to 0 (ready state).
     // Only fire on mount (no deps).
-    (0, _react.useEffect)(()=>{
+    _react.useEffect(()=>{
         if (actualIndex < 0) {
             batchUpdateNewIndex(0);
         }
@@ -426,9 +443,9 @@ function useVirtualizer_unstable(props) {
    * forceUpdate:
    * We only want to trigger this when scrollLoading is enabled and set to false,
    * it will force re-render all children elements
-   */ const forceUpdate = (0, _react.useReducer)(()=>({}), {})[1];
+   */ const forceUpdate = _react.useReducer(()=>({}), {})[1];
     // If the user passes in an updated renderChild function - update current children
-    (0, _react.useEffect)(()=>{
+    _react.useEffect(()=>{
         if (actualIndex >= 0) {
             updateChildRows(actualIndex);
             if (enableScrollLoad && !isScrolling) {
@@ -440,16 +457,17 @@ function useVirtualizer_unstable(props) {
         renderChild,
         isScrolling
     ]);
-    (0, _react.useEffect)(()=>{
+    _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
+        getItemSize,
+        gap
     ]);
     // Effect to check flag index on updates
-    (0, _react.useEffect)(()=>{
+    _react.useEffect(()=>{
         if (!onRenderedFlaggedIndex || flaggedIndex.current === null) {
             return;
         }

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

@@ -1 +1 @@
-{"version":3,"sources":["useVirtualizer.ts"],"sourcesContent":["import type { ReactNode } from 'react';\nimport type { VirtualizerProps, VirtualizerState } from './Virtualizer.types';\n\nimport { useEffect, useRef, useCallback, useImperativeHandle, useState, useReducer } from 'react';\nimport { useIntersectionObserver } from '../../hooks/useIntersectionObserver';\nimport { useVirtualizerContextState_unstable } from '../../Utilities';\nimport { slot, useTimeout } from '@fluentui/react-utilities';\nimport { flushSync } from 'react-dom';\n\nexport function useVirtualizer_unstable(props: VirtualizerProps): VirtualizerState {\n  'use no memo';\n\n  const {\n    itemSize,\n    numItems,\n    virtualizerLength,\n    children: renderChild,\n    getItemSize,\n    bufferItems = Math.round(virtualizerLength / 4.0),\n    bufferSize = Math.floor(bufferItems / 2.0) * itemSize,\n    axis = 'vertical',\n    reversed = false,\n    virtualizerContext,\n    onRenderedFlaggedIndex,\n    imperativeVirtualizerRef,\n    containerSizeRef,\n    scrollViewRef,\n    enableScrollLoad,\n  } = props;\n\n  /* The context is optional, it's useful for injecting additional index logic, or performing uniform state updates*/\n  const _virtualizerContext = useVirtualizerContextState_unstable(virtualizerContext);\n\n  // We use this ref as a constant source to access the virtualizer's state imperatively\n  const actualIndexRef = useRef<number>(_virtualizerContext.contextIndex);\n  const flaggedIndex = useRef<number | null>(null);\n\n  const actualIndex = _virtualizerContext.contextIndex;\n  // Just in case our ref gets out of date vs the context during a re-render\n  if (_virtualizerContext.contextIndex !== actualIndexRef.current) {\n    actualIndexRef.current = _virtualizerContext.contextIndex;\n  }\n  const setActualIndex = useCallback(\n    (index: number) => {\n      actualIndexRef.current = index;\n      _virtualizerContext.setContextIndex(index);\n    },\n    [_virtualizerContext],\n  );\n\n  // Store ref to before padding element\n  const beforeElementRef = useRef<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  if (virtualizerContext?.childProgressiveSizes) {\n    virtualizerContext.childProgressiveSizes.current = childProgressiveSizes.current;\n  }\n\n  // The internal tracking REF for child array (updates often).\n  const childArray = useRef<ReactNode[]>(new Array(virtualizerLength));\n\n  const populateSizeArrays = () => {\n    if (!getItemSize) {\n      // Static sizes, never mind!\n      return;\n    }\n\n    if (numItems !== childSizes.current.length) {\n      childSizes.current = new Array<number>(numItems);\n    }\n\n    if (numItems !== childProgressiveSizes.current.length) {\n      childProgressiveSizes.current = new Array<number>(numItems);\n      if (virtualizerContext?.childProgressiveSizes) {\n        virtualizerContext.childProgressiveSizes.current = childProgressiveSizes.current;\n      }\n    }\n\n    for (let index = 0; index < numItems; index++) {\n      childSizes.current[index] = getItemSize(index);\n      if (index === 0) {\n        childProgressiveSizes.current[index] = childSizes.current[index];\n      } else {\n        childProgressiveSizes.current[index] = childProgressiveSizes.current[index - 1] + childSizes.current[index];\n      }\n    }\n  };\n\n  const [isScrolling, setIsScrolling] = useState<boolean>(false);\n  const [setScrollTimer, clearScrollTimer] = useTimeout();\n  const scrollCounter = useRef<number>(0);\n\n  const initializeScrollingTimer = useCallback(() => {\n    if (!enableScrollLoad) {\n      // Disabled by default for reduction of render callbacks\n      return;\n    }\n    /*\n     * This can be considered the 'velocity' required to start 'isScrolling'\n     * INIT_SCROLL_FLAG_REQ: Number of renders required to activate isScrolling\n     * INIT_SCROLL_FLAG_DELAY: Amount of time (ms) before current number of renders is reset\n     *  - Maybe we should let users customize these in the future.\n     */\n    const INIT_SCROLL_FLAG_REQ = 10;\n    const INIT_SCROLL_FLAG_DELAY = 100;\n\n    scrollCounter.current++;\n    if (scrollCounter.current >= INIT_SCROLL_FLAG_REQ) {\n      setIsScrolling(true);\n    }\n    clearScrollTimer();\n    setScrollTimer(() => {\n      setIsScrolling(false);\n      scrollCounter.current = 0;\n    }, INIT_SCROLL_FLAG_DELAY);\n  }, [clearScrollTimer, setScrollTimer, enableScrollLoad]);\n\n  useEffect(() => {\n    initializeScrollingTimer();\n  }, [actualIndex, initializeScrollingTimer]);\n\n  const updateChildRows = useCallback(\n    (newIndex: number) => {\n      if (numItems === 0) {\n        /* Nothing to virtualize */\n        return;\n      }\n\n      /*\n        We reset the array every time to ensure children are re-rendered\n        This function should only be called when update is nessecary\n       */\n      childArray.current = new Array(virtualizerLength);\n      const _actualIndex = Math.max(newIndex, 0);\n      const end = Math.min(_actualIndex + virtualizerLength, numItems);\n      for (let i = _actualIndex; i < end; i++) {\n        childArray.current[i - _actualIndex] = renderChild(i, isScrolling);\n      }\n    },\n    [isScrolling, numItems, renderChild, virtualizerLength],\n  );\n\n  const updateCurrentItemSizes = useCallback(\n    (newIndex: number) => {\n      if (!getItemSize) {\n        // Static sizes, not required.\n        return;\n      }\n      // We should always call our size function on index change (only for the items that will be rendered)\n      // This ensures we request the latest data for incoming items in case sizing has changed.\n      const endIndex = Math.min(newIndex + virtualizerLength, numItems);\n      const startIndex = Math.max(newIndex, 0);\n\n      let didUpdate = false;\n      for (let i = startIndex; i < endIndex; i++) {\n        const newSize = getItemSize(i);\n        if (newSize !== childSizes.current[i]) {\n          childSizes.current[i] = newSize;\n          didUpdate = true;\n        }\n      }\n\n      if (didUpdate) {\n        // Update our progressive size array\n        for (let i = startIndex; i < numItems; i++) {\n          const prevSize = i > 0 ? childProgressiveSizes.current[i - 1] : 0;\n          childProgressiveSizes.current[i] = prevSize + childSizes.current[i];\n        }\n      }\n    },\n    [getItemSize, numItems, virtualizerLength],\n  );\n\n  const batchUpdateNewIndex = useCallback(\n    (index: number) => {\n      // Local updates\n      updateChildRows(index);\n      updateCurrentItemSizes(index);\n\n      // State setters\n      setActualIndex(index);\n    },\n    [setActualIndex, updateChildRows, updateCurrentItemSizes],\n  );\n\n  const findIndexRecursive = useCallback(\n    (scrollPos: number, lowIndex: number, highIndex: number): number => {\n      if (lowIndex > highIndex) {\n        // We shouldn't get here - but no-op the index if we do.\n        return actualIndex;\n      }\n      const midpoint = Math.floor((lowIndex + highIndex) / 2);\n      const iBefore = Math.max(midpoint - 1, 0);\n      const iAfter = Math.min(midpoint + 1, childProgressiveSizes.current.length - 1);\n      const indexValue = childProgressiveSizes.current[midpoint];\n      const afterIndexValue = childProgressiveSizes.current[iAfter];\n      const beforeIndexValue = childProgressiveSizes.current[iBefore];\n      if (scrollPos <= afterIndexValue && scrollPos >= beforeIndexValue) {\n        /* We've found our index - if we are exactly matching before/after index that's ok,\n      better to reduce checks if it's right on the boundary. */\n        return midpoint;\n      }\n\n      if (indexValue > scrollPos) {\n        return findIndexRecursive(scrollPos, lowIndex, midpoint - 1);\n      } else {\n        return findIndexRecursive(scrollPos, midpoint + 1, highIndex);\n      }\n    },\n    [actualIndex],\n  );\n\n  const getIndexFromSizeArray = useCallback(\n    (scrollPos: number): number => {\n      /* Quick searches our progressive height array */\n      if (\n        scrollPos === 0 ||\n        childProgressiveSizes.current.length === 0 ||\n        scrollPos <= childProgressiveSizes.current[0]\n      ) {\n        // Check start\n        return 0;\n      }\n\n      if (scrollPos >= childProgressiveSizes.current[childProgressiveSizes.current.length - 1]) {\n        // Check end\n        return childProgressiveSizes.current.length - 1;\n      }\n\n      return findIndexRecursive(scrollPos, 0, childProgressiveSizes.current.length - 1);\n    },\n    [findIndexRecursive],\n  );\n  const getIndexFromScrollPosition = useCallback(\n    (scrollPos: number) => {\n      if (!getItemSize) {\n        return Math.round(scrollPos / itemSize);\n      }\n\n      return getIndexFromSizeArray(scrollPos);\n    },\n    [getIndexFromSizeArray, getItemSize, itemSize],\n  );\n\n  const calculateTotalSize = useCallback(() => {\n    if (!getItemSize) {\n      return itemSize * numItems;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[numItems - 1];\n  }, [getItemSize, itemSize, numItems]);\n\n  const calculateBefore = useCallback(() => {\n    const currentIndex = Math.min(actualIndex, numItems - 1);\n\n    if (!getItemSize) {\n      // The missing items from before virtualization starts height\n      return currentIndex * itemSize;\n    }\n\n    if (currentIndex <= 0) {\n      return 0;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[currentIndex - 1];\n  }, [actualIndex, getItemSize, itemSize, numItems]);\n\n  const calculateAfter = useCallback(() => {\n    if (numItems === 0 || actualIndex + virtualizerLength >= numItems) {\n      return 0;\n    }\n\n    const lastItemIndex = Math.min(actualIndex + virtualizerLength, numItems);\n    if (!getItemSize) {\n      // The missing items from after virtualization ends height\n      const remainingItems = numItems - lastItemIndex;\n      return remainingItems * itemSize;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[numItems - 1] - childProgressiveSizes.current[lastItemIndex - 1];\n  }, [actualIndex, getItemSize, itemSize, numItems, virtualizerLength]);\n\n  // Observe intersections of virtualized components\n  const { setObserverList } = useIntersectionObserver(\n    useCallback(\n      // TODO: exclude types from this lint rule: https://github.com/microsoft/fluentui/issues/31286\n      // eslint-disable-next-line no-restricted-globals\n      (entries: IntersectionObserverEntry[], observer: IntersectionObserver) => {\n        /* Sanity check - do we even need virtualization? */\n        if (virtualizerLength > numItems) {\n          if (actualIndex !== 0) {\n            batchUpdateNewIndex(0);\n          }\n          // No-op\n          return;\n        }\n\n        // 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 || !latestEntry.isIntersecting) {\n          // If we don't find an intersecting area, ignore for now.\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            // 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            // Minus from original before position\n            measurementPos -= overflowAmount;\n            // Ignore buffer size (IO offset)\n            measurementPos += bufferSize;\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.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\n        flushSync(() => {\n          _virtualizerContext.setContextPosition(measurementPos);\n          if (actualIndex !== newStartIndex) {\n            batchUpdateNewIndex(newStartIndex);\n          }\n        });\n      },\n      [\n        _virtualizerContext,\n        actualIndex,\n        axis,\n        batchUpdateNewIndex,\n        bufferItems,\n        bufferSize,\n        calculateAfter,\n        calculateBefore,\n        calculateTotalSize,\n        containerSizeRef,\n        getIndexFromScrollPosition,\n        numItems,\n        reversed,\n        updateCurrentItemSizes,\n        virtualizerLength,\n      ],\n    ),\n    {\n      root: scrollViewRef ? scrollViewRef?.current : null,\n      rootMargin: '0px',\n      threshold: 0,\n    },\n  );\n\n  const setBeforeRef = useCallback(\n    (element: HTMLDivElement) => {\n      if (!element || beforeElementRef.current === element) {\n        return;\n      }\n      beforeElementRef.current = element;\n      const newList = [];\n\n      newList.push(beforeElementRef.current);\n\n      if (afterElementRef.current) {\n        newList.push(afterElementRef.current);\n      }\n\n      // Ensure we update array if before element changed\n      setObserverList(newList);\n    },\n    [setObserverList],\n  );\n\n  const setAfterRef = useCallback(\n    (element: HTMLDivElement) => {\n      if (!element || afterElementRef.current === element) {\n        return;\n      }\n      afterElementRef.current = element;\n      const newList = [];\n\n      if (beforeElementRef.current) {\n        newList.push(beforeElementRef.current);\n      }\n\n      newList.push(afterElementRef.current);\n\n      // Ensure we update array if after element changed\n      setObserverList(newList);\n    },\n    [setObserverList],\n  );\n\n  // Initialize the size array before first render.\n  const hasInitialized = useRef<boolean>(false);\n  const initializeSizeArray = () => {\n    if (hasInitialized.current === false) {\n      hasInitialized.current = true;\n      populateSizeArrays();\n    }\n  };\n\n  useImperativeHandle(\n    imperativeVirtualizerRef,\n    () => {\n      return {\n        progressiveSizes: childProgressiveSizes,\n        nodeSizes: childSizes,\n        setFlaggedIndex: (index: number | null) => (flaggedIndex.current = index),\n        currentIndex: actualIndexRef,\n      };\n    },\n    [childProgressiveSizes, childSizes],\n  );\n\n  // Initialization on mount - update array index to 0 (ready state).\n  // Only fire on mount (no deps).\n  useEffect(() => {\n    if (actualIndex < 0) {\n      batchUpdateNewIndex(0);\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  /*\n   * forceUpdate:\n   * We only want to trigger this when scrollLoading is enabled and set to false,\n   * it will force re-render all children elements\n   */\n  const forceUpdate = useReducer(() => ({}), {})[1];\n  // If the user passes in an updated renderChild function - update current children\n  useEffect(() => {\n    if (actualIndex >= 0) {\n      updateChildRows(actualIndex);\n      if (enableScrollLoad && !isScrolling) {\n        forceUpdate();\n      }\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [renderChild, isScrolling]);\n\n  useEffect(() => {\n    // Ensure we repopulate if getItemSize callback changes\n    populateSizeArrays();\n\n    // We only run this effect on getItemSize change (recalc dynamic sizes)\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [getItemSize]);\n\n  // Effect to check flag index on updates\n  useEffect(() => {\n    if (!onRenderedFlaggedIndex || flaggedIndex.current === null) {\n      return;\n    }\n    if (actualIndex <= flaggedIndex.current && actualIndex + virtualizerLength >= flaggedIndex.current) {\n      onRenderedFlaggedIndex(flaggedIndex.current);\n      flaggedIndex.current = null;\n    }\n  }, [actualIndex, onRenderedFlaggedIndex, virtualizerLength]);\n\n  // Ensure we have run through and updated the whole size list array at least once.\n  initializeSizeArray();\n\n  if (getItemSize && (numItems !== childSizes.current.length || numItems !== childProgressiveSizes.current.length)) {\n    // Child length mismatch, repopulate size arrays.\n    populateSizeArrays();\n  }\n\n  // Ensure we recalc if virtualizer length changes\n  const maxCompare = Math.min(virtualizerLength, numItems);\n  if (childArray.current.length !== maxCompare && actualIndex + childArray.current.length < numItems) {\n    updateChildRows(actualIndex);\n  }\n\n  const isFullyInitialized = hasInitialized.current && actualIndex >= 0;\n  return {\n    components: {\n      before: 'div',\n      after: 'div',\n      beforeContainer: 'div',\n      afterContainer: 'div',\n    },\n    virtualizedChildren: childArray.current,\n    before: slot.always(props.before, {\n      defaultProps: {\n        ref: setBeforeRef,\n        role: 'none',\n      },\n      elementType: 'div',\n    }),\n    after: slot.always(props.after, {\n      defaultProps: {\n        ref: setAfterRef,\n        role: 'none',\n      },\n      elementType: 'div',\n    }),\n    beforeContainer: slot.always(props.beforeContainer, {\n      defaultProps: {\n        role: 'none',\n      },\n      elementType: 'div',\n    }),\n    afterContainer: slot.always(props.afterContainer, {\n      defaultProps: {\n        role: 'none',\n      },\n      elementType: 'div',\n    }),\n    beforeBufferHeight: isFullyInitialized ? calculateBefore() : 0,\n    afterBufferHeight: isFullyInitialized ? calculateAfter() : 0,\n    totalVirtualizerHeight: isFullyInitialized ? calculateTotalSize() : virtualizerLength * itemSize,\n    virtualizerStartIndex: actualIndex,\n    axis,\n    bufferSize,\n    reversed,\n    childSizes,\n    childProgressiveSizes,\n  };\n}\n"],"names":["useVirtualizer_unstable","props","itemSize","numItems","virtualizerLength","children","renderChild","getItemSize","bufferItems","Math","round","bufferSize","floor","axis","reversed","virtualizerContext","onRenderedFlaggedIndex","imperativeVirtualizerRef","containerSizeRef","scrollViewRef","enableScrollLoad","_virtualizerContext","useVirtualizerContextState_unstable","actualIndexRef","useRef","contextIndex","flaggedIndex","actualIndex","current","setActualIndex","useCallback","index","setContextIndex","beforeElementRef","afterElementRef","childSizes","Array","childProgressiveSizes","childArray","populateSizeArrays","length","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","latestEntry","sort","entry1","entry2","time","find","entry","intersectionRatio","isIntersecting","calculateOverBuffer","measurementPos","target","overflowAmount","intersectionRect","height","width","hOverflow","boundingClientRect","top","hOverflowReversed","bottom","wOverflow","left","wOverflowReversed","right","widthOverflow","heightOverflow","additionalOverflow","maxIndex","newStartIndex","flushSync","setContextPosition","root","rootMargin","threshold","setBeforeRef","element","newList","push","setAfterRef","hasInitialized","initializeSizeArray","useImperativeHandle","progressiveSizes","nodeSizes","setFlaggedIndex","forceUpdate","useReducer","maxCompare","isFullyInitialized","components","before","after","beforeContainer","afterContainer","virtualizedChildren","slot","always","defaultProps","ref","role","elementType","beforeBufferHeight","afterBufferHeight","totalVirtualizerHeight","virtualizerStartIndex"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../src/components/Virtualizer/useVirtualizer.ts"],"sourcesContent":["import * as React from 'react';\nimport type { VirtualizerProps, VirtualizerState } from './Virtualizer.types';\n\nimport { useIntersectionObserver } from '../../hooks/useIntersectionObserver';\nimport { useVirtualizerContextState_unstable } from '../../Utilities';\nimport { slot, useTimeout } from '@fluentui/react-utilities';\nimport { flushSync } from 'react-dom';\n\nexport function useVirtualizer_unstable(props: VirtualizerProps): VirtualizerState {\n  'use no memo';\n\n  const {\n    itemSize,\n    numItems,\n    virtualizerLength,\n    children: renderChild,\n    getItemSize,\n    bufferItems = Math.round(virtualizerLength / 4.0),\n    bufferSize = Math.floor(bufferItems / 2.0) * itemSize,\n    axis = 'vertical',\n    reversed = false,\n    virtualizerContext,\n    onRenderedFlaggedIndex,\n    imperativeVirtualizerRef,\n    containerSizeRef,\n    scrollViewRef,\n    enableScrollLoad,\n    updateScrollPosition,\n    gap = 0,\n  } = props;\n\n  /* The context is optional, it's useful for injecting additional index logic, or performing uniform state updates*/\n  const _virtualizerContext = useVirtualizerContextState_unstable(virtualizerContext);\n\n  // We use this ref as a constant source to access the virtualizer's state imperatively\n  const actualIndexRef = React.useRef<number>(_virtualizerContext.contextIndex);\n\n  const flaggedIndex = React.useRef<number | null>(null);\n  const actualIndex = _virtualizerContext.contextIndex;\n\n  // Just in case our ref gets out of date vs the context during a re-render\n  if (_virtualizerContext.contextIndex !== actualIndexRef.current) {\n    actualIndexRef.current = _virtualizerContext.contextIndex;\n  }\n  const setActualIndex = React.useCallback(\n    (index: number) => {\n      actualIndexRef.current = index;\n      _virtualizerContext.setContextIndex(index);\n    },\n    [_virtualizerContext],\n  );\n\n  // Store ref to before padding element\n  const beforeElementRef = React.useRef<HTMLElement | null>(null);\n\n  // Store ref to before padding element\n  const afterElementRef = React.useRef<HTMLElement | null>(null);\n\n  // We need to store an array to track dynamic sizes, we can use this to incrementally update changes\n  const childSizes = React.useRef<number[]>(new Array<number>(getItemSize ? numItems : 0));\n\n  /* We keep track of the progressive sizing/placement down the list,\n  this helps us skip re-calculations unless children/size changes */\n  const childProgressiveSizes = React.useRef<number[]>(new Array<number>(getItemSize ? numItems : 0));\n  if (virtualizerContext?.childProgressiveSizes) {\n    virtualizerContext.childProgressiveSizes.current = childProgressiveSizes.current;\n  }\n\n  // The internal tracking REF for child array (updates often).\n  const childArray = React.useRef<React.ReactNode[]>(new Array(virtualizerLength));\n\n  const populateSizeArrays = () => {\n    if (!getItemSize) {\n      // Static sizes, never mind!\n      return;\n    }\n\n    if (numItems !== childSizes.current.length) {\n      childSizes.current = new Array<number>(numItems);\n    }\n\n    if (numItems !== childProgressiveSizes.current.length) {\n      childProgressiveSizes.current = new Array<number>(numItems);\n      if (virtualizerContext?.childProgressiveSizes) {\n        virtualizerContext.childProgressiveSizes.current = childProgressiveSizes.current;\n      }\n    }\n\n    for (let index = 0; index < numItems; index++) {\n      const _gap = index < numItems - 1 ? gap : 0;\n      childSizes.current[index] = getItemSize(index) + _gap;\n      if (index === 0) {\n        childProgressiveSizes.current[index] = childSizes.current[index];\n      } else {\n        childProgressiveSizes.current[index] = childProgressiveSizes.current[index - 1] + childSizes.current[index];\n      }\n    }\n  };\n\n  const [isScrolling, setIsScrolling] = React.useState<boolean>(false);\n  const [setScrollTimer, clearScrollTimer] = useTimeout();\n  const scrollCounter = React.useRef<number>(0);\n\n  const initializeScrollingTimer = React.useCallback(() => {\n    if (!enableScrollLoad) {\n      // Disabled by default for reduction of render callbacks\n      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":";;;;+BAQgBA;;;eAAAA;;;;iEARO;yCAGiB;2BACY;gCACnB;0BACP;AAEnB,SAASA,wBAAwBC,KAAuB;IAC7D;IAEA,MAAM,EACJC,QAAQ,EACRC,QAAQ,EACRC,iBAAiB,EACjBC,UAAUC,WAAW,EACrBC,WAAW,EACXC,cAAcC,KAAKC,KAAK,CAACN,oBAAoB,IAAI,EACjDO,aAAaF,KAAKG,KAAK,CAACJ,cAAc,OAAON,QAAQ,EACrDW,OAAO,UAAU,EACjBC,WAAW,KAAK,EAChBC,kBAAkB,EAClBC,sBAAsB,EACtBC,wBAAwB,EACxBC,gBAAgB,EAChBC,aAAa,EACbC,gBAAgB,EAChBC,oBAAoB,EACpBC,MAAM,CAAC,EACR,GAAGrB;IAEJ,iHAAiH,GACjH,MAAMsB,sBAAsBC,IAAAA,8CAAAA,EAAoCT;IAEhE,sFAAsF;IACtF,MAAMU,iBAAiBC,OAAMC,MAAM,CAASJ,oBAAoBK,YAAY;IAE5E,MAAMC,eAAeH,OAAMC,MAAM,CAAgB;IACjD,MAAMG,cAAcP,oBAAoBK,YAAY;IAEpD,0EAA0E;IAC1E,IAAIL,oBAAoBK,YAAY,KAAKH,eAAeM,OAAO,EAAE;QAC/DN,eAAeM,OAAO,GAAGR,oBAAoBK,YAAY;IAC3D;IACA,MAAMI,iBAAiBN,OAAMO,WAAW,CACtC,CAACC;QACCT,eAAeM,OAAO,GAAGG;QACzBX,oBAAoBY,eAAe,CAACD;IACtC,GACA;QAACX;KAAoB;IAGvB,sCAAsC;IACtC,MAAMa,mBAAmBV,OAAMC,MAAM,CAAqB;IAE1D,sCAAsC;IACtC,MAAMU,kBAAkBX,OAAMC,MAAM,CAAqB;IAEzD,oGAAoG;IACpG,MAAMW,aAAaZ,OAAMC,MAAM,CAAW,IAAIY,MAAchC,cAAcJ,WAAW;IAErF;kEACgE,GAChE,MAAMqC,wBAAwBd,OAAMC,MAAM,CAAW,IAAIY,MAAchC,cAAcJ,WAAW;IAChG,IAAIY,uBAAAA,QAAAA,uBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,mBAAoByB,qBAAqB,EAAE;QAC7CzB,mBAAmByB,qBAAqB,CAACT,OAAO,GAAGS,sBAAsBT,OAAO;IAClF;IAEA,6DAA6D;IAC7D,MAAMU,aAAaf,OAAMC,MAAM,CAAoB,IAAIY,MAAMnC;IAE7D,MAAMsC,qBAAqB;QACzB,IAAI,CAACnC,aAAa;YAChB,4BAA4B;YAC5B;QACF;QAEA,IAAIJ,aAAamC,WAAWP,OAAO,CAACY,MAAM,EAAE;YAC1CL,WAAWP,OAAO,GAAG,IAAIQ,MAAcpC;QACzC;QAEA,IAAIA,aAAaqC,sBAAsBT,OAAO,CAACY,MAAM,EAAE;YACrDH,sBAAsBT,OAAO,GAAG,IAAIQ,MAAcpC;YAClD,IAAIY,uBAAAA,QAAAA,uBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,mBAAoByB,qBAAqB,EAAE;gBAC7CzB,mBAAmByB,qBAAqB,CAACT,OAAO,GAAGS,sBAAsBT,OAAO;YAClF;QACF;QAEA,IAAK,IAAIG,QAAQ,GAAGA,QAAQ/B,UAAU+B,QAAS;YAC7C,MAAMU,OAAOV,QAAQ/B,WAAW,IAAImB,MAAM;YAC1CgB,WAAWP,OAAO,CAACG,MAAM,GAAG3B,YAAY2B,SAASU;YACjD,IAAIV,UAAU,GAAG;gBACfM,sBAAsBT,OAAO,CAACG,MAAM,GAAGI,WAAWP,OAAO,CAACG,MAAM;YAClE,OAAO;gBACLM,sBAAsBT,OAAO,CAACG,MAAM,GAAGM,sBAAsBT,OAAO,CAACG,QAAQ,EAAE,GAAGI,WAAWP,OAAO,CAACG,MAAM;YAC7G;QACF;IACF;IAEA,MAAM,CAACW,aAAaC,eAAe,GAAGpB,OAAMqB,QAAQ,CAAU;IAC9D,MAAM,CAACC,gBAAgBC,iBAAiB,GAAGC,IAAAA,0BAAAA;IAC3C,MAAMC,gBAAgBzB,OAAMC,MAAM,CAAS;IAE3C,MAAMyB,2BAA2B1B,OAAMO,WAAW,CAAC;QACjD,IAAI,CAACb,kBAAkB;YACrB,wDAAwD;YACxD;QACF;QACA;;;;;KAKC,GACD,MAAMiC,uBAAuB;QAC7B,MAAMC,yBAAyB;QAE/BH,cAAcpB,OAAO;QACrB,IAAIoB,cAAcpB,OAAO,IAAIsB,sBAAsB;YACjDP,eAAe;QACjB;QACAG;QACAD,eAAe;YACbF,eAAe;YACfK,cAAcpB,OAAO,GAAG;QAC1B,GAAGuB;IACL,GAAG;QAACL;QAAkBD;QAAgB5B;KAAiB;IAEvDM,OAAM6B,SAAS,CAAC;QACdH;IACF,GAAG;QAACtB;QAAasB;KAAyB;IAE1C,MAAMI,kBAAkB9B,OAAMO,WAAW,CACvC,CAACwB;QACC,IAAItD,aAAa,GAAG;YAClB,yBAAyB,GACzB;QACF;QAEA;;;OAGC,GACDsC,WAAWV,OAAO,GAAG,IAAIQ,MAAMnC;QAC/B,MAAMsD,eAAejD,KAAKkD,GAAG,CAACF,UAAU;QACxC,MAAMG,MAAMnD,KAAKoD,GAAG,CAACH,eAAetD,mBAAmBD;QACvD,IAAK,IAAI2D,IAAIJ,cAAcI,IAAIF,KAAKE,IAAK;YACvCrB,WAAWV,OAAO,CAAC+B,IAAIJ,aAAa,GAAGpD,YAAYwD,GAAGjB;QACxD;IACF,GACA;QAACA;QAAa1C;QAAUG;QAAaF;KAAkB;IAGzD,MAAM2D,yBAAyBrC,OAAMO,WAAW,CAC9C,CAACwB;QACC,IAAI,CAAClD,aAAa;YAChB,8BAA8B;YAC9B;QACF;QACA,qGAAqG;QACrG,yFAAyF;QACzF,MAAMyD,WAAWvD,KAAKoD,GAAG,CAACJ,WAAWrD,mBAAmBD;QACxD,MAAM8D,aAAaxD,KAAKkD,GAAG,CAACF,UAAU;QAEtC,IAAIS,YAAY;QAChB,IAAK,IAAIJ,IAAIG,YAAYH,IAAIE,UAAUF,IAAK;YAC1C,MAAMlB,OAAOkB,IAAI3D,WAAW,IAAImB,MAAM;YACtC,MAAM6C,UAAU5D,YAAYuD,KAAKlB;YACjC,IAAIuB,YAAY7B,WAAWP,OAAO,CAAC+B,EAAE,EAAE;gBACrCxB,WAAWP,OAAO,CAAC+B,EAAE,GAAGK;gBACxBD,YAAY;YACd;QACF;QAEA,IAAIA,WAAW;YACb,oCAAoC;YACpC,IAAK,IAAIJ,IAAIG,YAAYH,IAAI3D,UAAU2D,IAAK;gBAC1C,MAAMM,WAAWN,IAAI,IAAItB,sBAAsBT,OAAO,CAAC+B,IAAI,EAAE,GAAG;gBAChEtB,sBAAsBT,OAAO,CAAC+B,EAAE,GAAGM,WAAW9B,WAAWP,OAAO,CAAC+B,EAAE;YACrE;QACF;IACF,GACA;QAACvD;QAAaJ;QAAUC;QAAmBkB;KAAI;IAGjD,MAAM+C,sBAAsB3C,OAAMO,WAAW,CAC3C,CAACC;QACC,gBAAgB;QAChBsB,gBAAgBtB;QAChB6B,uBAAuB7B;QAEvB,gBAAgB;QAChBF,eAAeE;IACjB,GACA;QAACF;QAAgBwB;QAAiBO;KAAuB;IAG3D,MAAMO,qBAAqB5C,OAAMO,WAAW,CAC1C,CAACsC,WAAmBC,UAAkBC;QACpC,IAAID,WAAWC,WAAW;YACxB,wDAAwD;YACxD,OAAO3C;QACT;QACA,MAAM4C,WAAWjE,KAAKG,KAAK,CAAC,AAAC4D,CAAAA,WAAWC,SAAAA,IAAa;QACrD,MAAME,UAAUlE,KAAKkD,GAAG,CAACe,WAAW,GAAG;QACvC,MAAME,SAASnE,KAAKoD,GAAG,CAACa,WAAW,GAAGlC,sBAAsBT,OAAO,CAACY,MAAM,GAAG;QAC7E,MAAMkC,aAAarC,sBAAsBT,OAAO,CAAC2C,SAAS;QAC1D,MAAMI,kBAAkBtC,sBAAsBT,OAAO,CAAC6C,OAAO;QAC7D,MAAMG,mBAAmBvC,sBAAsBT,OAAO,CAAC4C,QAAQ;QAC/D,IAAIJ,aAAaO,mBAAmBP,aAAaQ,kBAAkB;YACjE;6DACqD,GACrD,OAAOL;QACT;QAEA,IAAIG,aAAaN,WAAW;YAC1B,OAAOD,mBAAmBC,WAAWC,UAAUE,WAAW;QAC5D,OAAO;YACL,OAAOJ,mBAAmBC,WAAWG,WAAW,GAAGD;QACrD;IACF,GACA;QAAC3C;KAAY;IAGf,MAAMkD,wBAAwBtD,OAAMO,WAAW,CAC7C,CAACsC;QACC,+CAA+C,GAC/C,IACEA,cAAc,KACd/B,sBAAsBT,OAAO,CAACY,MAAM,KAAK,KACzC4B,aAAa/B,sBAAsBT,OAAO,CAAC,EAAE,EAC7C;YACA,cAAc;YACd,OAAO;QACT;QAEA,IAAIwC,aAAa/B,sBAAsBT,OAAO,CAACS,sBAAsBT,OAAO,CAACY,MAAM,GAAG,EAAE,EAAE;YACxF,YAAY;YACZ,OAAOH,sBAAsBT,OAAO,CAACY,MAAM,GAAG;QAChD;QAEA,OAAO2B,mBAAmBC,WAAW,GAAG/B,sBAAsBT,OAAO,CAACY,MAAM,GAAG;IACjF,GACA;QAAC2B;KAAmB;IAEtB,MAAMW,6BAA6BvD,OAAMO,WAAW,CAClD,CAACsC;QACC,IAAI,CAAChE,aAAa;YAChB,OAAOE,KAAKC,KAAK,CAAC6D,YAAarE,CAAAA,WAAWoB,GAAAA;QAC5C;QAEA,OAAO0D,sBAAsBT;IAC/B,GACA;QAACS;QAAuBzE;QAAaL;QAAUoB;KAAI;IAGrD,MAAM4D,qBAAqBxD,OAAMO,WAAW,CAAC;QAC3C,IAAI,CAAC1B,aAAa;YAChB,OAAO,AAACL,CAAAA,WAAWoB,GAAAA,IAAOnB;QAC5B;QAEA,6BAA6B;QAC7B,OAAOqC,sBAAsBT,OAAO,CAAC5B,WAAW,EAAE;IACpD,GAAG;QAACI;QAAaL;QAAUC;QAAUmB;KAAI;IAEzC,MAAM6D,kBAAkBzD,OAAMO,WAAW,CAAC;QACxC,MAAMmD,eAAe3E,KAAKoD,GAAG,CAAC/B,aAAa3B,WAAW;QAEtD,IAAI,CAACI,aAAa;YAChB,6DAA6D;YAC7D,OAAO6E,eAAgBlF,CAAAA,WAAWoB,GAAAA;QACpC;QAEA,IAAI8D,gBAAgB,GAAG;YACrB,OAAO;QACT;QAEA,6BAA6B;QAC7B,OAAO5C,sBAAsBT,OAAO,CAACqD,eAAe,EAAE;IACxD,GAAG;QAACtD;QAAavB;QAAaL;QAAUC;QAAUmB;KAAI;IAEtD,MAAM+D,iBAAiB3D,OAAMO,WAAW,CAAC;QACvC,IAAI9B,aAAa,KAAK2B,cAAc1B,qBAAqBD,UAAU;YACjE,OAAO;QACT;QAEA,MAAMmF,gBAAgB7E,KAAKoD,GAAG,CAAC/B,cAAc1B,mBAAmBD;QAChE,IAAI,CAACI,aAAa;YAChB,0DAA0D;YAC1D,MAAMgF,iBAAiBpF,WAAWmF;YAClC,OAAOC,iBAAkBrF,CAAAA,WAAWoB,GAAAA,IAAOA;QAC7C;QAEA,6BAA6B;QAC7B,OAAOkB,sBAAsBT,OAAO,CAAC5B,WAAW,EAAE,GAAGqC,sBAAsBT,OAAO,CAACuD,gBAAgB,EAAE;IACvG,GAAG;QAACxD;QAAavB;QAAaL;QAAUC;QAAUC;QAAmBkB;KAAI;IAEzE,kDAAkD;IAClD,MAAM,EAAEkE,eAAe,EAAE,GAAGC,IAAAA,gDAAAA,EAC1B/D,OAAMO,WAAW,CAEf,iDAAiD;IACjD,CAACyD,SAAsCC;QACrC,kDAAkD,GAClD,IAAIvF,oBAAoBD,UAAU;YAChC,IAAI2B,gBAAgB,GAAG;gBACrBuC,oBAAoB;YACtB;YACA,QAAQ;YACR;QACF;QAEA,IAAIqB,QAAQ/C,MAAM,KAAK,GAAG;YACxB,4BAA4B;YAC5B;QACF;QACA,6CAA6C;QAC7C,MAAMiD,gBAAgBF,QAAQG,IAAI,CAAC,CAACC,QAAQC,SAAWA,OAAOC,IAAI,GAAGF,OAAOE,IAAI;QAChF,MAAMC,cAAcL,cAAcM,IAAI,CAACC,CAAAA;YACrC,OAAOA,MAAMC,cAAc;QAC7B;QAEA,IAAI,CAACH,aAAa;YAChB;QACF;QAEA,+FAA+F;QAC/F,yBAAyB;QACzBlC,uBAAuBtC,eAAeM,OAAO;QAE7C,MAAMsE,sBAAsB;YAC1B;;;;;WAKC,GACD,IAAIC,iBAAiB;YACrB,IAAIL,YAAYM,MAAM,KAAKlE,gBAAgBN,OAAO,EAAE;gBAClD,6BAA6B;gBAC7BuE,iBAAiBpB,uBAAuBG;gBAExC,0FAA0F;gBAC1F,MAAMmB,iBACJ3F,SAAS,aAAaoF,YAAYQ,gBAAgB,CAACC,MAAM,GAAGT,YAAYQ,gBAAgB,CAACE,KAAK;gBAChG,iCAAiC;gBACjCL,kBAAkBE;gBAClB,iCAAiC;gBACjCF,kBAAkB3F;oBAEAO;gBADlB,yFAAyF;gBACzFoF,kBAAkBpF,CAAAA,4BAAAA,iBAAiBa,OAAO,AAAPA,MAAO,QAAxBb,8BAAAA,KAAAA,IAAAA,4BAA4B;gBAE9C,6FAA6F;gBAC7F,MAAM0F,YAAYX,YAAYY,kBAAkB,CAACC,GAAG,GAAGb,YAAYQ,gBAAgB,CAACK,GAAG;gBACvF,MAAMC,oBAAoBd,YAAYY,kBAAkB,CAACG,MAAM,GAAGf,YAAYQ,gBAAgB,CAACO,MAAM;gBACrG,MAAMC,YAAYhB,YAAYY,kBAAkB,CAACK,IAAI,GAAGjB,YAAYQ,gBAAgB,CAACS,IAAI;gBACzF,MAAMC,oBAAoBlB,YAAYY,kBAAkB,CAACO,KAAK,GAAGnB,YAAYQ,gBAAgB,CAACW,KAAK;gBACnG,MAAMC,gBAAgBvG,WAAWqG,oBAAoBF;gBACrD,MAAMK,iBAAiBxG,WAAWiG,oBAAoBH;gBACtD,MAAMW,qBAAqB1G,SAAS,aAAayG,iBAAiBD;gBAElE,IAAIvG,UAAU;oBACZwF,kBAAkBiB;gBACpB,OAAO;oBACLjB,kBAAkBiB;gBACpB;YACF,OAAO,IAAItB,YAAYM,MAAM,KAAKnE,iBAAiBL,OAAO,EAAE;gBAC1D,8BAA8B;gBAC9BuE,iBAAiBnB;gBAEjB,iGAAiG;gBACjG,MAAMqB,iBACJ3F,SAAS,aAAaoF,YAAYQ,gBAAgB,CAACC,MAAM,GAAGT,YAAYQ,gBAAgB,CAACE,KAAK;gBAEhG,sCAAsC;gBACtCL,kBAAkBE;gBAClB,iCAAiC;gBACjCF,kBAAkB3F;gBAClB,6FAA6F;gBAC7F,MAAMiG,YAAYX,YAAYY,kBAAkB,CAACG,MAAM,GAAGf,YAAYQ,gBAAgB,CAACO,MAAM;gBAC7F,MAAMD,oBAAoBd,YAAYY,kBAAkB,CAACC,GAAG,GAAGb,YAAYQ,gBAAgB,CAACK,GAAG;gBAC/F,MAAMG,YAAYhB,YAAYY,kBAAkB,CAACO,KAAK,GAAGnB,YAAYQ,gBAAgB,CAACW,KAAK;gBAC3F,MAAMD,oBAAoBlB,YAAYY,kBAAkB,CAACK,IAAI,GAAGjB,YAAYQ,gBAAgB,CAACS,IAAI;gBACjG,MAAMG,gBAAgBvG,WAAWqG,oBAAoBF;gBACrD,MAAMK,iBAAiBxG,WAAWiG,oBAAoBH;gBACtD,MAAMW,qBAAqB1G,SAAS,aAAayG,iBAAiBD;gBAElE,IAAIvG,UAAU;oBACZwF,kBAAkBiB;gBACpB,OAAO;oBACLjB,kBAAkBiB;gBACpB;YACF;YAEA,OAAOjB;QACT;QAEA,+CAA+C;QAC/C,MAAMA,iBAAiBD;QAEvB,MAAMmB,WAAW/G,KAAKkD,GAAG,CAACxD,WAAWC,mBAAmB;QAExD,MAAM6D,aAAagB,2BAA2BqB,kBAAkB9F;QAEhE,gBAAgB;QAChB,MAAMiH,gBAAgBhH,KAAKoD,GAAG,CAACpD,KAAKkD,GAAG,CAACM,YAAY,IAAIuD;QACxDE,IAAAA,mBAAAA,EAAU;YACR,kEAAkE;YAClE,IAAID,gBAAgBrH,qBAAqBD,YAAY2B,cAAc1B,qBAAqBD,UAAU;gBAChG,sDAAsD;gBACtD;YACF;YACAkB,yBAAAA,QAAAA,yBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,qBAAuBiF;YACvB,IAAIxE,gBAAgB2F,eAAe;gBACjCpD,oBAAoBoD;YACtB;QACF;IACF,GACA;QACE3F;QACA1B;QACAS;QACAC;QACAX;QACAQ;QACAH;QACAU;QACAG;QACAgD;QACAgB;QACAF;QACAD;QACAD;QACAlB;KACD,GAEH;QACE4D,MAAMxG,gBAAgBA,kBAAAA,QAAAA,kBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,cAAeY,OAAO,GAAG;QAC/C6F,YAAY;QACZC,WAAW;IACb;IAGF,MAAMC,eAAepG,OAAMO,WAAW,CACpC,CAAC8F;QACC,IAAI,CAACA,WAAW3F,iBAAiBL,OAAO,KAAKgG,SAAS;YACpD;QACF;QACA3F,iBAAiBL,OAAO,GAAGgG;QAC3B,MAAMC,UAAU,EAAE;QAElBA,QAAQC,IAAI,CAAC7F,iBAAiBL,OAAO;QAErC,IAAIM,gBAAgBN,OAAO,EAAE;YAC3BiG,QAAQC,IAAI,CAAC5F,gBAAgBN,OAAO;QACtC;QAEA,mDAAmD;QACnDyD,gBAAgBwC;IAClB,GACA;QAACxC;KAAgB;IAGnB,MAAM0C,cAAcxG,OAAMO,WAAW,CACnC,CAAC8F;QACC,IAAI,CAACA,WAAW1F,gBAAgBN,OAAO,KAAKgG,SAAS;YACnD;QACF;QACA1F,gBAAgBN,OAAO,GAAGgG;QAC1B,MAAMC,UAAU,EAAE;QAElB,IAAI5F,iBAAiBL,OAAO,EAAE;YAC5BiG,QAAQC,IAAI,CAAC7F,iBAAiBL,OAAO;QACvC;QAEAiG,QAAQC,IAAI,CAAC5F,gBAAgBN,OAAO;QAEpC,kDAAkD;QAClDyD,gBAAgBwC;IAClB,GACA;QAACxC;KAAgB;IAGnB,iDAAiD;IACjD,MAAM2C,iBAAiBzG,OAAMC,MAAM,CAAU;IAC7C,MAAMyG,sBAAsB;QAC1B,IAAID,eAAepG,OAAO,KAAK,OAAO;YACpCoG,eAAepG,OAAO,GAAG;YACzBW;QACF;IACF;IAEAhB,OAAM2G,mBAAmB,CACvBpH,0BACA;QACE,OAAO;YACLqH,kBAAkB9F;YAClB+F,WAAWjG;YACXkG,iBAAiB,CAACtG,QAA0BL,aAAaE,OAAO,GAAGG;YACnEkD,cAAc3D;QAChB;IACF,GACA;QAACe;QAAuBF;KAAW;IAGrC,mEAAmE;IACnE,gCAAgC;IAChCZ,OAAM6B,SAAS,CAAC;QACd,IAAIzB,cAAc,GAAG;YACnBuC,oBAAoB;QACtB;IACA,uDAAuD;IACzD,GAAG,EAAE;IAEL;;;;GAIC,GACD,MAAMoE,cAAc/G,OAAMgH,UAAU,CAAC,IAAO,CAAA,CAAC,CAAA,GAAI,CAAC,EAAE,CAAC,EAAE;IACvD,kFAAkF;IAClFhH,OAAM6B,SAAS,CAAC;QACd,IAAIzB,eAAe,GAAG;YACpB0B,gBAAgB1B;YAChB,IAAIV,oBAAoB,CAACyB,aAAa;gBACpC4F;YACF;QACF;IACA,uDAAuD;IACzD,GAAG;QAACnI;QAAauC;KAAY;IAE7BnB,OAAM6B,SAAS,CAAC;QACd,uDAAuD;QACvDb;IAEA,uEAAuE;IACvE,uDAAuD;IACzD,GAAG;QAACnC;QAAae;KAAI;IAErB,wCAAwC;IACxCI,OAAM6B,SAAS,CAAC;QACd,IAAI,CAACvC,0BAA0Ba,aAAaE,OAAO,KAAK,MAAM;YAC5D;QACF;QACA,IAAID,eAAeD,aAAaE,OAAO,IAAID,cAAc1B,qBAAqByB,aAAaE,OAAO,EAAE;YAClGf,uBAAuBa,aAAaE,OAAO;YAC3CF,aAAaE,OAAO,GAAG;QACzB;IACF,GAAG;QAACD;QAAad;QAAwBZ;KAAkB;IAE3D,kFAAkF;IAClFgI;IAEA,IAAI7H,eAAgBJ,CAAAA,aAAamC,WAAWP,OAAO,CAACY,MAAM,IAAIxC,aAAaqC,sBAAsBT,OAAO,CAACY,MAAM,AAANA,GAAS;QAChH,iDAAiD;QACjDD;IACF;IAEA,iDAAiD;IACjD,MAAMiG,aAAalI,KAAKoD,GAAG,CAACzD,mBAAmBD;IAC/C,IAAIsC,WAAWV,OAAO,CAACY,MAAM,KAAKgG,cAAc7G,cAAcW,WAAWV,OAAO,CAACY,MAAM,GAAGxC,UAAU;QAClGqD,gBAAgB1B;IAClB;IAEA,MAAM8G,qBAAqBT,eAAepG,OAAO,IAAID,eAAe;IACpE,OAAO;QACL+G,YAAY;YACVC,QAAQ;YACRC,OAAO;YACPC,iBAAiB;YACjBC,gBAAgB;QAClB;QACAC,qBAAqBzG,WAAWV,OAAO;QACvC+G,QAAQK,oBAAAA,CAAKC,MAAM,CAACnJ,MAAM6I,MAAM,EAAE;YAChCO,cAAc;gBACZC,KAAKxB;gBACLyB,MAAM;YACR;YACAC,aAAa;QACf;QACAT,OAAOI,oBAAAA,CAAKC,MAAM,CAACnJ,MAAM8I,KAAK,EAAE;YAC9BM,cAAc;gBACZC,KAAKpB;gBACLqB,MAAM;YACR;YACAC,aAAa;QACf;QACAR,iBAAiBG,oBAAAA,CAAKC,MAAM,CAACnJ,MAAM+I,eAAe,EAAE;YAClDK,cAAc;gBACZE,MAAM;YACR;YACAC,aAAa;QACf;QACAP,gBAAgBE,oBAAAA,CAAKC,MAAM,CAACnJ,MAAMgJ,cAAc,EAAE;YAChDI,cAAc;gBACZE,MAAM;YACR;YACAC,aAAa;QACf;QACAC,oBAAoBb,qBAAqBzD,oBAAoB;QAC7DuE,mBAAmBd,qBAAqBvD,mBAAmB;QAC3DsE,wBAAwBf,qBAAqB1D,uBAAuB9E,oBAAoBF;QACxF0J,uBAAuB9H;QACvBjB;QACAF;QACAG;QACAwB;QACAE;IACF;AACF"}

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

@@ -120,4 +120,4 @@ const useVirtualizerStyles_unstable = (state)=>{
         ...state.afterContainer.style
     };
     return state;
-}; //# sourceMappingURL=useVirtualizerStyles.styles.js.map
+};