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

package/lib/hooks/useMeasureList.js

@@ -1,5 +1,4 @@
 import * as React from 'react';
-import { useRef } from 'react';
 import { useFluent_unstable as useFluent } from '@fluentui/react-shared-contexts';
 /**
  * Provides a way of automating size in the virtualizer
@@ -13,7 +12,7 @@ import { useFluent_unstable as useFluent } from '@fluentui/react-shared-contexts
     const refArray = React.useRef([]);
     const { targetDocument } = useFluent();
     // This lets us trigger updates when a size change occurs.
-    const sizeUpdateCount = useRef(0);
+    const sizeUpdateCount = React.useRef(0);
     // the handler for resize observer
     const handleIndexUpdate = React.useCallback((index)=>{
         var _refArray_current_index;

package/lib/hooks/useMeasureList.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/hooks/useMeasureList.ts"],"sourcesContent":["import * as React from 'react';\nimport { useRef } from 'react';\nimport { useFluent_unstable as useFluent } from '@fluentui/react-shared-contexts';\n\nexport interface IndexedResizeCallbackElement {\n  handleResize: () => void;\n}\n/**\n * Provides a way of automating size in the virtualizer\n * Returns\n * `width` - element width ref (0 by default),\n * `height` - element height ref (0 by default),\n * `measureElementRef` - a ref function to be passed as `ref` to the element you want to measure\n */\nexport function useMeasureList<\n  TElement extends HTMLElement & IndexedResizeCallbackElement = HTMLElement & IndexedResizeCallbackElement,\n>(currentIndex: number, refLength: number, totalLength: number, defaultItemSize: number) {\n  const widthArray = React.useRef(new Array(totalLength).fill(defaultItemSize));\n  const heightArray = React.useRef(new Array(totalLength).fill(defaultItemSize));\n\n  const refArray = React.useRef<Array<TElement | undefined | null>>([]);\n  const { targetDocument } = useFluent();\n\n  // This lets us trigger updates when a size change occurs.\n  const sizeUpdateCount = useRef(0);\n\n  // the handler for resize observer\n  const handleIndexUpdate = React.useCallback(\n    (index: number) => {\n      let isChanged = false;\n      const boundClientRect = refArray.current[index]?.getBoundingClientRect();\n      const containerWidth = boundClientRect?.width;\n      if (containerWidth !== widthArray.current[currentIndex + index]) {\n        isChanged = true;\n      }\n      widthArray.current[currentIndex + index] = containerWidth || defaultItemSize;\n\n      const containerHeight = boundClientRect?.height;\n\n      if (containerHeight !== heightArray.current[currentIndex + index]) {\n        isChanged = true;\n      }\n      heightArray.current[currentIndex + index] = containerHeight || defaultItemSize;\n\n      if (isChanged) {\n        sizeUpdateCount.current = sizeUpdateCount.current + 1;\n      }\n    },\n    [currentIndex, defaultItemSize, sizeUpdateCount],\n  );\n\n  const handleElementResizeCallback = (entries: ResizeObserverEntry[]) => {\n    for (const entry of entries) {\n      const target = entry.target as TElement;\n      // Call the elements own resize handler (indexed)\n      target.handleResize();\n    }\n  };\n\n  React.useEffect(() => {\n    const newHeightLength = totalLength - heightArray.current.length;\n    const newWidthLength = totalLength - widthArray.current.length;\n    /* Ensure we grow or truncate arrays with prior properties,\n    keeping the existing values is important for whitespace assumptions.\n    Even if items in the 'middle' are deleted, we will recalc the whitespace as it is explored.*/\n    if (newWidthLength > 0) {\n      widthArray.current = widthArray.current.concat(new Array(newWidthLength).fill(defaultItemSize));\n    } else if (newWidthLength < 0) {\n      widthArray.current = widthArray.current.slice(0, totalLength);\n    }\n    if (newHeightLength > 0) {\n      heightArray.current = heightArray.current.concat(new Array(newHeightLength).fill(defaultItemSize));\n    } else if (newHeightLength < 0) {\n      heightArray.current = heightArray.current.slice(0, totalLength);\n    }\n  }, [defaultItemSize, totalLength]);\n\n  // Keep the reference of ResizeObserver as a ref, as it should live through renders\n  const resizeObserver = React.useRef(createResizeObserverFromDocument(targetDocument, handleElementResizeCallback));\n\n  /* createIndexedRef provides a dynamic function to create an undefined number of refs at render time\n   * these refs then provide an indexed callback via attaching 'handleResize' to the element itself\n   * this function is then called on resize by handleElementResize and relies on indexing\n   * to track continuous sizes throughout renders while releasing all virtualized element refs each render cycle.\n   */\n  const createIndexedRef = React.useCallback(\n    (index: number) => {\n      const measureElementRef = (el: TElement) => {\n        if (!targetDocument || !resizeObserver.current) {\n          return;\n        }\n\n        if (el) {\n          el.handleResize = () => {\n            handleIndexUpdate(index);\n          };\n        }\n\n        // cleanup previous container\n        if (refArray.current[index] !== undefined && refArray.current[index] !== null) {\n          resizeObserver.current.unobserve(refArray.current[index]!);\n        }\n\n        refArray.current[index] = undefined;\n        if (el) {\n          refArray.current[index] = el;\n          resizeObserver.current.observe(el);\n          handleIndexUpdate(index);\n        }\n      };\n\n      return measureElementRef;\n    },\n    [handleIndexUpdate, resizeObserver, targetDocument],\n  );\n\n  React.useEffect(() => {\n    const _resizeObserver = resizeObserver;\n    return () => _resizeObserver.current?.disconnect();\n  }, [resizeObserver]);\n\n  return { widthArray, heightArray, createIndexedRef, refArray, sizeUpdateCount: sizeUpdateCount.current };\n}\n\n/**\n * FIXME - TS 3.8/3.9 don't have ResizeObserver types by default, move this to a shared utility once we bump the minbar\n * A utility method that creates a ResizeObserver from a target document\n * @param targetDocument - document to use to create the ResizeObserver\n * @param callback  - https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver/ResizeObserver#callback\n * @returns a ResizeObserver instance or null if the global does not exist on the document\n */\nexport function createResizeObserverFromDocument(\n  targetDocument: Document | null | undefined,\n  callback: ResizeObserverCallback,\n) {\n  if (!targetDocument?.defaultView?.ResizeObserver) {\n    return null;\n  }\n\n  return new targetDocument.defaultView.ResizeObserver(callback);\n}\n"],"names":["React","useRef","useFluent_unstable","useFluent","useMeasureList","currentIndex","refLength","totalLength","defaultItemSize","widthArray","Array","fill","heightArray","refArray","targetDocument","sizeUpdateCount","handleIndexUpdate","useCallback","index","isChanged","boundClientRect","current","getBoundingClientRect","containerWidth","width","containerHeight","height","handleElementResizeCallback","entries","entry","target","handleResize","useEffect","newHeightLength","length","newWidthLength","concat","slice","resizeObserver","createResizeObserverFromDocument","createIndexedRef","measureElementRef","el","undefined","unobserve","observe","_resizeObserver","disconnect","callback","defaultView","ResizeObserver"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../src/hooks/useMeasureList.ts"],"sourcesContent":["import * as React from 'react';\nimport { useFluent_unstable as useFluent } from '@fluentui/react-shared-contexts';\n\nexport interface IndexedResizeCallbackElement {\n  handleResize: () => void;\n}\n/**\n * Provides a way of automating size in the virtualizer\n * Returns\n * `width` - element width ref (0 by default),\n * `height` - element height ref (0 by default),\n * `measureElementRef` - a ref function to be passed as `ref` to the element you want to measure\n */\nexport function useMeasureList<\n  TElement extends HTMLElement & IndexedResizeCallbackElement = HTMLElement & IndexedResizeCallbackElement,\n>(currentIndex: number, refLength: number, totalLength: number, defaultItemSize: number) {\n  const widthArray = React.useRef(new Array(totalLength).fill(defaultItemSize));\n  const heightArray = React.useRef(new Array(totalLength).fill(defaultItemSize));\n\n  const refArray = React.useRef<Array<TElement | undefined | null>>([]);\n  const { targetDocument } = useFluent();\n\n  // This lets us trigger updates when a size change occurs.\n  const sizeUpdateCount = React.useRef(0);\n\n  // the handler for resize observer\n  const handleIndexUpdate = React.useCallback(\n    (index: number) => {\n      let isChanged = false;\n      const boundClientRect = refArray.current[index]?.getBoundingClientRect();\n      const containerWidth = boundClientRect?.width;\n      if (containerWidth !== widthArray.current[currentIndex + index]) {\n        isChanged = true;\n      }\n      widthArray.current[currentIndex + index] = containerWidth || defaultItemSize;\n\n      const containerHeight = boundClientRect?.height;\n\n      if (containerHeight !== heightArray.current[currentIndex + index]) {\n        isChanged = true;\n      }\n      heightArray.current[currentIndex + index] = containerHeight || defaultItemSize;\n\n      if (isChanged) {\n        sizeUpdateCount.current = sizeUpdateCount.current + 1;\n      }\n    },\n    [currentIndex, defaultItemSize, sizeUpdateCount],\n  );\n\n  const handleElementResizeCallback = (entries: ResizeObserverEntry[]) => {\n    for (const entry of entries) {\n      const target = entry.target as TElement;\n      // Call the elements own resize handler (indexed)\n      target.handleResize();\n    }\n  };\n\n  React.useEffect(() => {\n    const newHeightLength = totalLength - heightArray.current.length;\n    const newWidthLength = totalLength - widthArray.current.length;\n    /* Ensure we grow or truncate arrays with prior properties,\n    keeping the existing values is important for whitespace assumptions.\n    Even if items in the 'middle' are deleted, we will recalc the whitespace as it is explored.*/\n    if (newWidthLength > 0) {\n      widthArray.current = widthArray.current.concat(new Array(newWidthLength).fill(defaultItemSize));\n    } else if (newWidthLength < 0) {\n      widthArray.current = widthArray.current.slice(0, totalLength);\n    }\n    if (newHeightLength > 0) {\n      heightArray.current = heightArray.current.concat(new Array(newHeightLength).fill(defaultItemSize));\n    } else if (newHeightLength < 0) {\n      heightArray.current = heightArray.current.slice(0, totalLength);\n    }\n  }, [defaultItemSize, totalLength]);\n\n  // Keep the reference of ResizeObserver as a ref, as it should live through renders\n  const resizeObserver = React.useRef(createResizeObserverFromDocument(targetDocument, handleElementResizeCallback));\n\n  /* createIndexedRef provides a dynamic function to create an undefined number of refs at render time\n   * these refs then provide an indexed callback via attaching 'handleResize' to the element itself\n   * this function is then called on resize by handleElementResize and relies on indexing\n   * to track continuous sizes throughout renders while releasing all virtualized element refs each render cycle.\n   */\n  const createIndexedRef = React.useCallback(\n    (index: number) => {\n      const measureElementRef = (el: TElement) => {\n        if (!targetDocument || !resizeObserver.current) {\n          return;\n        }\n\n        if (el) {\n          el.handleResize = () => {\n            handleIndexUpdate(index);\n          };\n        }\n\n        // cleanup previous container\n        if (refArray.current[index] !== undefined && refArray.current[index] !== null) {\n          resizeObserver.current.unobserve(refArray.current[index]!);\n        }\n\n        refArray.current[index] = undefined;\n        if (el) {\n          refArray.current[index] = el;\n          resizeObserver.current.observe(el);\n          handleIndexUpdate(index);\n        }\n      };\n\n      return measureElementRef;\n    },\n    [handleIndexUpdate, resizeObserver, targetDocument],\n  );\n\n  React.useEffect(() => {\n    const _resizeObserver = resizeObserver;\n    return () => _resizeObserver.current?.disconnect();\n  }, [resizeObserver]);\n\n  return { widthArray, heightArray, createIndexedRef, refArray, sizeUpdateCount: sizeUpdateCount.current };\n}\n\n/**\n * FIXME - TS 3.8/3.9 don't have ResizeObserver types by default, move this to a shared utility once we bump the minbar\n * A utility method that creates a ResizeObserver from a target document\n * @param targetDocument - document to use to create the ResizeObserver\n * @param callback  - https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver/ResizeObserver#callback\n * @returns a ResizeObserver instance or null if the global does not exist on the document\n */\nexport function createResizeObserverFromDocument(\n  targetDocument: Document | null | undefined,\n  callback: ResizeObserverCallback,\n) {\n  if (!targetDocument?.defaultView?.ResizeObserver) {\n    return null;\n  }\n\n  return new targetDocument.defaultView.ResizeObserver(callback);\n}\n"],"names":["React","useFluent_unstable","useFluent","useMeasureList","currentIndex","refLength","totalLength","defaultItemSize","widthArray","useRef","Array","fill","heightArray","refArray","targetDocument","sizeUpdateCount","handleIndexUpdate","useCallback","index","isChanged","boundClientRect","current","getBoundingClientRect","containerWidth","width","containerHeight","height","handleElementResizeCallback","entries","entry","target","handleResize","useEffect","newHeightLength","length","newWidthLength","concat","slice","resizeObserver","createResizeObserverFromDocument","createIndexedRef","measureElementRef","el","undefined","unobserve","observe","_resizeObserver","disconnect","callback","defaultView","ResizeObserver"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib/hooks/useMutationObserver.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/hooks/useMutationObserver.ts"],"sourcesContent":["import type { MutableRefObject } from 'react';\nimport * as React from 'react';\nimport { useFluent_unstable as useFluent } from '@fluentui/react-shared-contexts';\n\nconst { useRef, useEffect } = React;\n\nexport const useMutationObserver = (\n  target: Element | Document | undefined,\n  callback: MutationCallback,\n  options?: MutationObserverInit,\n): {\n  observer: MutableRefObject<MutationObserver | undefined>; // eslint-disable-line no-restricted-globals\n} => {\n  'use no memo';\n\n  // TODO: exclude types from this lint rule: https://github.com/microsoft/fluentui/issues/31286\n  // eslint-disable-next-line no-restricted-globals\n  const observer = useRef<MutationObserver>();\n  const { targetDocument } = useFluent();\n  const win = targetDocument?.defaultView;\n\n  useEffect(() => {\n    if (!win) {\n      return;\n    }\n    // Create an observer instance linked to the callback function\n    observer.current = new win.MutationObserver(callback);\n  }, [callback, win]);\n\n  useEffect(() => {\n    if (target) {\n      // Start observing the target node for configured mutations\n      observer.current?.observe(target, options);\n    }\n\n    return () => {\n      observer.current?.disconnect();\n    };\n  }, [target, options]);\n\n  return { observer };\n};\n"],"names":["React","useFluent_unstable","useFluent","useRef","useEffect","useMutationObserver","target","callback","options","observer","targetDocument","win","defaultView","current","MutationObserver","observe","disconnect"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AACA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,sBAAsBC,SAAS,QAAQ,kCAAkC;AAElF,MAAM,EAAEC,MAAM,EAAEC,SAAS,EAAE,GAAGJ;AAE9B,OAAO,MAAMK,sBAAsB,CACjCC,QACAC,UACAC;IAIA;IAEA,8FAA8F;IAC9F,iDAAiD;IACjD,MAAMC,WAAWN;IACjB,MAAM,EAAEO,cAAc,EAAE,GAAGR;IAC3B,MAAMS,MAAMD,2BAAAA,qCAAAA,eAAgBE,WAAW;IAEvCR,UAAU;QACR,IAAI,CAACO,KAAK;YACR;QACF;QACA,8DAA8D;QAC9DF,SAASI,OAAO,GAAG,IAAIF,IAAIG,gBAAgB,CAACP;IAC9C,GAAG;QAACA;QAAUI;KAAI;IAElBP,UAAU;QACR,IAAIE,QAAQ;gBACV,2DAA2D;YAC3DG;aAAAA,oBAAAA,SAASI,OAAO,cAAhBJ,wCAAAA,kBAAkBM,OAAO,CAACT,QAAQE;QACpC;QAEA,OAAO;gBACLC;aAAAA,oBAAAA,SAASI,OAAO,cAAhBJ,wCAAAA,kBAAkBO,UAAU;QAC9B;IACF,GAAG;QAACV;QAAQE;KAAQ;IAEpB,OAAO;QAAEC;IAAS;AACpB,EAAE"}
+{"version":3,"sources":["../src/hooks/useMutationObserver.ts"],"sourcesContent":["import * as React from 'react';\nimport { useFluent_unstable as useFluent } from '@fluentui/react-shared-contexts';\n\nconst { useRef, useEffect } = React;\n\nexport const useMutationObserver = (\n  target: Element | Document | undefined,\n  callback: MutationCallback,\n  options?: MutationObserverInit,\n): {\n  observer: React.MutableRefObject<MutationObserver | undefined>; // eslint-disable-line no-restricted-globals\n} => {\n  'use no memo';\n\n  // TODO: exclude types from this lint rule: https://github.com/microsoft/fluentui/issues/31286\n  // eslint-disable-next-line no-restricted-globals\n  const observer = useRef<MutationObserver>();\n  const { targetDocument } = useFluent();\n  const win = targetDocument?.defaultView;\n\n  useEffect(() => {\n    if (!win) {\n      return;\n    }\n    // Create an observer instance linked to the callback function\n    observer.current = new win.MutationObserver(callback);\n  }, [callback, win]);\n\n  useEffect(() => {\n    if (target) {\n      // Start observing the target node for configured mutations\n      observer.current?.observe(target, options);\n    }\n\n    return () => {\n      observer.current?.disconnect();\n    };\n  }, [target, options]);\n\n  return { observer };\n};\n"],"names":["React","useFluent_unstable","useFluent","useRef","useEffect","useMutationObserver","target","callback","options","observer","targetDocument","win","defaultView","current","MutationObserver","observe","disconnect"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,sBAAsBC,SAAS,QAAQ,kCAAkC;AAElF,MAAM,EAAEC,MAAM,EAAEC,SAAS,EAAE,GAAGJ;AAE9B,OAAO,MAAMK,sBAAsB,CACjCC,QACAC,UACAC;IAIA;IAEA,8FAA8F;IAC9F,iDAAiD;IACjD,MAAMC,WAAWN;IACjB,MAAM,EAAEO,cAAc,EAAE,GAAGR;IAC3B,MAAMS,MAAMD,2BAAAA,qCAAAA,eAAgBE,WAAW;IAEvCR,UAAU;QACR,IAAI,CAACO,KAAK;YACR;QACF;QACA,8DAA8D;QAC9DF,SAASI,OAAO,GAAG,IAAIF,IAAIG,gBAAgB,CAACP;IAC9C,GAAG;QAACA;QAAUI;KAAI;IAElBP,UAAU;QACR,IAAIE,QAAQ;gBACV,2DAA2D;YAC3DG;aAAAA,oBAAAA,SAASI,OAAO,cAAhBJ,wCAAAA,kBAAkBM,OAAO,CAACT,QAAQE;QACpC;QAEA,OAAO;gBACLC;aAAAA,oBAAAA,SAASI,OAAO,cAAhBJ,wCAAAA,kBAAkBO,UAAU;QAC9B;IACF,GAAG;QAACV;QAAQE;KAAQ;IAEpB,OAAO;QAAEC;IAAS;AACpB,EAAE"}

package/lib/hooks/useStaticPagination.js

@@ -1,5 +1,4 @@
 import * as React from 'react';
-import { useRef } from 'react';
 import { useTimeout } from '@fluentui/react-utilities';
 /**
  * Optional hook that will enable pagination on the virtualizer so that it 'autoscrolls' to an items exact position
@@ -10,8 +9,8 @@ import { useTimeout } from '@fluentui/react-utilities';
     'use no memo';
     const { itemSize, axis = 'vertical' } = virtualizerProps;
     const [setScrollTimer, clearScrollTimer] = useTimeout();
-    const lastScrollPos = useRef(0);
-    const lastIndexScrolled = useRef(0);
+    const lastScrollPos = React.useRef(0);
+    const lastIndexScrolled = React.useRef(0);
     const scrollContainer = React.useRef(null);
     const clearListeners = ()=>{
         if (scrollContainer.current) {

package/lib/hooks/useStaticPagination.js.map

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

package/lib/utilities/ImperativeScrolling/imperativeScrolling.types.js

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

package/lib/utilities/ImperativeScrolling/imperativeScrolling.types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/utilities/ImperativeScrolling/imperativeScrolling.types.ts"],"sourcesContent":["import type { RefObject } from 'react';\n\nexport type ScrollToItemStaticParams = {\n  index: number;\n  itemSize: number;\n  totalItems: number;\n  scrollViewRef: RefObject<HTMLDivElement>;\n  axis?: 'horizontal' | 'vertical';\n  reversed?: boolean;\n  behavior?: ScrollBehavior;\n};\n\nexport type ScrollToItemDynamicParams = {\n  index: number;\n  itemSizes: RefObject<number[]>;\n  totalSize: number;\n  scrollViewRef: RefObject<HTMLDivElement>;\n  axis?: 'horizontal' | 'vertical';\n  reversed?: boolean;\n  behavior?: ScrollBehavior;\n};\n\nexport type ScrollToInterface = {\n  scrollTo: (index: number, behavior?: ScrollBehavior, callback?: (index: number) => void) => void;\n  virtualizerLength: RefObject<number>;\n  currentIndex: RefObject<number> | undefined;\n};\n"],"names":[],"rangeMappings":"","mappings":"AAsBA,WAIE"}
+{"version":3,"sources":["../src/utilities/ImperativeScrolling/imperativeScrolling.types.ts"],"sourcesContent":["import * as React from 'react';\n\nexport type ScrollToItemStaticParams = {\n  index: number;\n  itemSize: number;\n  totalItems: number;\n  scrollViewRef: React.RefObject<HTMLDivElement>;\n  axis?: 'horizontal' | 'vertical';\n  reversed?: boolean;\n  behavior?: ScrollBehavior;\n};\n\nexport type ScrollToItemDynamicParams = {\n  index: number;\n  itemSizes: React.RefObject<number[]>;\n  totalSize: number;\n  scrollViewRef: React.RefObject<HTMLDivElement>;\n  axis?: 'horizontal' | 'vertical';\n  reversed?: boolean;\n  behavior?: ScrollBehavior;\n};\n\nexport type ScrollToInterface = {\n  scrollTo: (index: number, behavior?: ScrollBehavior, callback?: (index: number) => void) => void;\n  virtualizerLength: React.RefObject<number>;\n  currentIndex: React.RefObject<number> | undefined;\n};\n"],"names":["React"],"rangeMappings":"","mappings":"AAAA,YAAYA,WAAW,QAAQ"}

package/lib/utilities/ImperativeScrolling/index.js

@@ -1,3 +1,2 @@
-export * from './imperativeScrolling';
-export * from './imperativeScrolling.types';
-export * from './imperativeScrollingDynamic';
+export { scrollToItemStatic } from './imperativeScrolling';
+export { scrollToItemDynamic } from './imperativeScrollingDynamic';

package/lib/utilities/ImperativeScrolling/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/utilities/ImperativeScrolling/index.ts"],"sourcesContent":["export * from './imperativeScrolling';\nexport * from './imperativeScrolling.types';\nexport * from './imperativeScrollingDynamic';\n"],"names":[],"rangeMappings":";;","mappings":"AAAA,cAAc,wBAAwB;AACtC,cAAc,8BAA8B;AAC5C,cAAc,+BAA+B"}
+{"version":3,"sources":["../src/utilities/ImperativeScrolling/index.ts"],"sourcesContent":["export { scrollToItemStatic } from './imperativeScrolling';\nexport type {\n  ScrollToInterface,\n  ScrollToItemDynamicParams,\n  ScrollToItemStaticParams,\n} from './imperativeScrolling.types';\nexport { scrollToItemDynamic } from './imperativeScrollingDynamic';\n"],"names":["scrollToItemStatic","scrollToItemDynamic"],"rangeMappings":";","mappings":"AAAA,SAASA,kBAAkB,QAAQ,wBAAwB;AAM3D,SAASC,mBAAmB,QAAQ,+BAA+B"}

package/lib/utilities/VirtualizerContext/VirtualizerContext.js

@@ -1,5 +1,4 @@
 import * as React from 'react';
-import { useMemo, useState, useRef } from 'react';
 const VirtualizerContext = React.createContext(undefined);
 export const VirtualizerContextProvider = VirtualizerContext.Provider;
 export const useVirtualizerContext_unstable = ()=>{
@@ -7,11 +6,11 @@ export const useVirtualizerContext_unstable = ()=>{
 };
 export const useVirtualizerContextState_unstable = (passedContext)=>{
     const virtualizerContext = useVirtualizerContext_unstable();
-    const [_contextIndex, _setContextIndex] = useState(-1);
-    const childProgressiveSizes = useRef([]);
+    const [_contextIndex, _setContextIndex] = React.useState(-1);
+    const childProgressiveSizes = React.useRef([]);
     /* We respect any wrapped providers while also ensuring defaults or passed through
    * Order of usage -> Passed Prop -> Provider Context -> Internal State default
-   */ const context = useMemo(()=>{
+   */ const context = React.useMemo(()=>{
         var _passedContext_contextIndex, _ref, _passedContext_setContextIndex, _ref1;
         return {
             contextIndex: (_ref = (_passedContext_contextIndex = passedContext === null || passedContext === void 0 ? void 0 : passedContext.contextIndex) !== null && _passedContext_contextIndex !== void 0 ? _passedContext_contextIndex : virtualizerContext === null || virtualizerContext === void 0 ? void 0 : virtualizerContext.contextIndex) !== null && _ref !== void 0 ? _ref : _contextIndex,

package/lib/utilities/VirtualizerContext/VirtualizerContext.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/utilities/VirtualizerContext/VirtualizerContext.ts"],"sourcesContent":["import * as React from 'react';\nimport type { DynamicVirtualizerContextProps, VirtualizerContextProps } from './types';\nimport { useMemo, useState, useRef } from 'react';\n\nconst VirtualizerContext = React.createContext<VirtualizerContextProps | undefined>(\n  undefined,\n) as React.Context<VirtualizerContextProps>;\n\nexport const VirtualizerContextProvider = VirtualizerContext.Provider;\n\nexport const useVirtualizerContext_unstable = () => {\n  return React.useContext(VirtualizerContext);\n};\n\nexport const useVirtualizerContextState_unstable = (\n  passedContext?: VirtualizerContextProps,\n): DynamicVirtualizerContextProps => {\n  const virtualizerContext = useVirtualizerContext_unstable();\n  const [_contextIndex, _setContextIndex] = useState<number>(-1);\n  const childProgressiveSizes = useRef<number[]>([]);\n\n  /* We respect any wrapped providers while also ensuring defaults or passed through\n   * Order of usage -> Passed Prop -> Provider Context -> Internal State default\n   */\n  const context = useMemo(\n    () => ({\n      contextIndex: passedContext?.contextIndex ?? virtualizerContext?.contextIndex ?? _contextIndex,\n      setContextIndex: passedContext?.setContextIndex ?? virtualizerContext?.setContextIndex ?? _setContextIndex,\n      childProgressiveSizes,\n    }),\n    [_contextIndex, passedContext, virtualizerContext],\n  );\n\n  return context;\n};\n"],"names":["React","useMemo","useState","useRef","VirtualizerContext","createContext","undefined","VirtualizerContextProvider","Provider","useVirtualizerContext_unstable","useContext","useVirtualizerContextState_unstable","passedContext","virtualizerContext","_contextIndex","_setContextIndex","childProgressiveSizes","context","contextIndex","setContextIndex"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,SAASC,OAAO,EAAEC,QAAQ,EAAEC,MAAM,QAAQ,QAAQ;AAElD,MAAMC,qBAAqBJ,MAAMK,aAAa,CAC5CC;AAGF,OAAO,MAAMC,6BAA6BH,mBAAmBI,QAAQ,CAAC;AAEtE,OAAO,MAAMC,iCAAiC;IAC5C,OAAOT,MAAMU,UAAU,CAACN;AAC1B,EAAE;AAEF,OAAO,MAAMO,sCAAsC,CACjDC;IAEA,MAAMC,qBAAqBJ;IAC3B,MAAM,CAACK,eAAeC,iBAAiB,GAAGb,SAAiB,CAAC;IAC5D,MAAMc,wBAAwBb,OAAiB,EAAE;IAEjD;;GAEC,GACD,MAAMc,UAAUhB,QACd;YACgBW,6BAAAA,MACGA,gCAAAA;eAFZ;YACLM,cAAcN,CAAAA,OAAAA,CAAAA,8BAAAA,0BAAAA,oCAAAA,cAAeM,YAAY,cAA3BN,yCAAAA,8BAA+BC,+BAAAA,yCAAAA,mBAAoBK,YAAY,cAA/DN,kBAAAA,OAAmEE;YACjFK,iBAAiBP,CAAAA,QAAAA,CAAAA,iCAAAA,0BAAAA,oCAAAA,cAAeO,eAAe,cAA9BP,4CAAAA,iCAAkCC,+BAAAA,yCAAAA,mBAAoBM,eAAe,cAArEP,mBAAAA,QAAyEG;YAC1FC;QACF;IAAA,GACA;QAACF;QAAeF;QAAeC;KAAmB;IAGpD,OAAOI;AACT,EAAE"}
+{"version":3,"sources":["../src/utilities/VirtualizerContext/VirtualizerContext.ts"],"sourcesContent":["import * as React from 'react';\nimport type { DynamicVirtualizerContextProps, VirtualizerContextProps } from './types';\n\nconst VirtualizerContext = React.createContext<VirtualizerContextProps | undefined>(\n  undefined,\n) as React.Context<VirtualizerContextProps>;\n\nexport const VirtualizerContextProvider = VirtualizerContext.Provider;\n\nexport const useVirtualizerContext_unstable = () => {\n  return React.useContext(VirtualizerContext);\n};\n\nexport const useVirtualizerContextState_unstable = (\n  passedContext?: VirtualizerContextProps,\n): DynamicVirtualizerContextProps => {\n  const virtualizerContext = useVirtualizerContext_unstable();\n  const [_contextIndex, _setContextIndex] = React.useState<number>(-1);\n  const childProgressiveSizes = React.useRef<number[]>([]);\n\n  /* We respect any wrapped providers while also ensuring defaults or passed through\n   * Order of usage -> Passed Prop -> Provider Context -> Internal State default\n   */\n  const context = React.useMemo(\n    () => ({\n      contextIndex: passedContext?.contextIndex ?? virtualizerContext?.contextIndex ?? _contextIndex,\n      setContextIndex: passedContext?.setContextIndex ?? virtualizerContext?.setContextIndex ?? _setContextIndex,\n      childProgressiveSizes,\n    }),\n    [_contextIndex, passedContext, virtualizerContext],\n  );\n\n  return context;\n};\n"],"names":["React","VirtualizerContext","createContext","undefined","VirtualizerContextProvider","Provider","useVirtualizerContext_unstable","useContext","useVirtualizerContextState_unstable","passedContext","virtualizerContext","_contextIndex","_setContextIndex","useState","childProgressiveSizes","useRef","context","useMemo","contextIndex","setContextIndex"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,YAAYA,WAAW,QAAQ;AAG/B,MAAMC,qBAAqBD,MAAME,aAAa,CAC5CC;AAGF,OAAO,MAAMC,6BAA6BH,mBAAmBI,QAAQ,CAAC;AAEtE,OAAO,MAAMC,iCAAiC;IAC5C,OAAON,MAAMO,UAAU,CAACN;AAC1B,EAAE;AAEF,OAAO,MAAMO,sCAAsC,CACjDC;IAEA,MAAMC,qBAAqBJ;IAC3B,MAAM,CAACK,eAAeC,iBAAiB,GAAGZ,MAAMa,QAAQ,CAAS,CAAC;IAClE,MAAMC,wBAAwBd,MAAMe,MAAM,CAAW,EAAE;IAEvD;;GAEC,GACD,MAAMC,UAAUhB,MAAMiB,OAAO,CAC3B;YACgBR,6BAAAA,MACGA,gCAAAA;eAFZ;YACLS,cAAcT,CAAAA,OAAAA,CAAAA,8BAAAA,0BAAAA,oCAAAA,cAAeS,YAAY,cAA3BT,yCAAAA,8BAA+BC,+BAAAA,yCAAAA,mBAAoBQ,YAAY,cAA/DT,kBAAAA,OAAmEE;YACjFQ,iBAAiBV,CAAAA,QAAAA,CAAAA,iCAAAA,0BAAAA,oCAAAA,cAAeU,eAAe,cAA9BV,4CAAAA,iCAAkCC,+BAAAA,yCAAAA,mBAAoBS,eAAe,cAArEV,mBAAAA,QAAyEG;YAC1FE;QACF;IAAA,GACA;QAACH;QAAeF;QAAeC;KAAmB;IAGpD,OAAOM;AACT,EAAE"}

package/lib/utilities/VirtualizerContext/index.js

@@ -1,2 +1 @@
-export * from './VirtualizerContext';
-export * from './types';
+export { VirtualizerContextProvider, useVirtualizerContextState_unstable, useVirtualizerContext_unstable } from './VirtualizerContext';

package/lib/utilities/VirtualizerContext/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/utilities/VirtualizerContext/index.ts"],"sourcesContent":["export * from './VirtualizerContext';\nexport * from './types';\n"],"names":[],"rangeMappings":";","mappings":"AAAA,cAAc,uBAAuB;AACrC,cAAc,UAAU"}
+{"version":3,"sources":["../src/utilities/VirtualizerContext/index.ts"],"sourcesContent":["export {\n  VirtualizerContextProvider,\n  useVirtualizerContextState_unstable,\n  useVirtualizerContext_unstable,\n} from './VirtualizerContext';\nexport type { DynamicVirtualizerContextProps, VirtualizerContextProps } from './types';\n"],"names":["VirtualizerContextProvider","useVirtualizerContextState_unstable","useVirtualizerContext_unstable"],"rangeMappings":"","mappings":"AAAA,SACEA,0BAA0B,EAC1BC,mCAAmC,EACnCC,8BAA8B,QACzB,uBAAuB"}

package/lib/utilities/index.js

@@ -1,2 +1,2 @@
-export * from './VirtualizerContext';
-export * from './ImperativeScrolling';
+export { VirtualizerContextProvider, useVirtualizerContextState_unstable, useVirtualizerContext_unstable } from './VirtualizerContext';
+export { scrollToItemDynamic, scrollToItemStatic } from './ImperativeScrolling';

package/lib/utilities/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/utilities/index.ts"],"sourcesContent":["export * from './VirtualizerContext';\nexport * from './ImperativeScrolling';\n"],"names":[],"rangeMappings":";","mappings":"AAAA,cAAc,uBAAuB;AACrC,cAAc,wBAAwB"}
+{"version":3,"sources":["../src/utilities/index.ts"],"sourcesContent":["export type { DynamicVirtualizerContextProps, VirtualizerContextProps } from './VirtualizerContext';\nexport {\n  VirtualizerContextProvider,\n  useVirtualizerContextState_unstable,\n  useVirtualizerContext_unstable,\n} from './VirtualizerContext';\nexport type { ScrollToInterface, ScrollToItemDynamicParams, ScrollToItemStaticParams } from './ImperativeScrolling';\nexport { scrollToItemDynamic, scrollToItemStatic } from './ImperativeScrolling';\n"],"names":["VirtualizerContextProvider","useVirtualizerContextState_unstable","useVirtualizerContext_unstable","scrollToItemDynamic","scrollToItemStatic"],"rangeMappings":";","mappings":"AACA,SACEA,0BAA0B,EAC1BC,mCAAmC,EACnCC,8BAA8B,QACzB,uBAAuB;AAE9B,SAASC,mBAAmB,EAAEC,kBAAkB,QAAQ,wBAAwB"}

package/lib-commonjs/Hooks.js

@@ -2,5 +2,33 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _export_star = require("@swc/helpers/_/_export_star");
-_export_star._(require("./hooks/index"), exports);
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createResizeObserverFromDocument: function() {
+        return _index.createResizeObserverFromDocument;
+    },
+    getRTLRootMargin: function() {
+        return _index.getRTLRootMargin;
+    },
+    useDynamicVirtualizerMeasure: function() {
+        return _index.useDynamicVirtualizerMeasure;
+    },
+    useIntersectionObserver: function() {
+        return _index.useIntersectionObserver;
+    },
+    useMeasureList: function() {
+        return _index.useMeasureList;
+    },
+    useResizeObserverRef_unstable: function() {
+        return _index.useResizeObserverRef_unstable;
+    },
+    useStaticVirtualizerMeasure: function() {
+        return _index.useStaticVirtualizerMeasure;
+    }
+});
+const _index = require("./hooks/index");

package/lib-commonjs/Hooks.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/Hooks.ts"],"sourcesContent":["export * from './hooks/index';\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;uBAAc"}
+{"version":3,"sources":["../src/Hooks.ts"],"sourcesContent":["export type {\n  IndexedResizeCallbackElement,\n  ResizeCallbackWithRef,\n  VirtualizerDynamicPaginationProps,\n  VirtualizerMeasureDynamicProps,\n  VirtualizerMeasureProps,\n  VirtualizerStaticPaginationProps,\n} from './hooks/index';\nexport {\n  createResizeObserverFromDocument,\n  getRTLRootMargin,\n  useDynamicVirtualizerMeasure,\n  useIntersectionObserver,\n  useMeasureList,\n  useResizeObserverRef_unstable,\n  useStaticVirtualizerMeasure,\n} from './hooks/index';\n"],"names":["createResizeObserverFromDocument","getRTLRootMargin","useDynamicVirtualizerMeasure","useIntersectionObserver","useMeasureList","useResizeObserverRef_unstable","useStaticVirtualizerMeasure"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IASEA,gCAAgC;eAAhCA,uCAAgC;;IAChCC,gBAAgB;eAAhBA,uBAAgB;;IAChBC,4BAA4B;eAA5BA,mCAA4B;;IAC5BC,uBAAuB;eAAvBA,8BAAuB;;IACvBC,cAAc;eAAdA,qBAAc;;IACdC,6BAA6B;eAA7BA,oCAA6B;;IAC7BC,2BAA2B;eAA3BA,kCAA2B;;;uBACtB"}

package/lib-commonjs/Utilities.js

@@ -2,5 +2,27 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _export_star = require("@swc/helpers/_/_export_star");
-_export_star._(require("./utilities/index"), exports);
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    VirtualizerContextProvider: function() {
+        return _index.VirtualizerContextProvider;
+    },
+    scrollToItemDynamic: function() {
+        return _index.scrollToItemDynamic;
+    },
+    scrollToItemStatic: function() {
+        return _index.scrollToItemStatic;
+    },
+    useVirtualizerContextState_unstable: function() {
+        return _index.useVirtualizerContextState_unstable;
+    },
+    useVirtualizerContext_unstable: function() {
+        return _index.useVirtualizerContext_unstable;
+    }
+});
+const _index = require("./utilities/index");

package/lib-commonjs/Utilities.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/Utilities.ts"],"sourcesContent":["export * from './utilities/index';\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;uBAAc"}
+{"version":3,"sources":["../src/Utilities.ts"],"sourcesContent":["export type {\n  DynamicVirtualizerContextProps,\n  ScrollToInterface,\n  ScrollToItemDynamicParams,\n  ScrollToItemStaticParams,\n  VirtualizerContextProps,\n} from './utilities/index';\nexport {\n  VirtualizerContextProvider,\n  scrollToItemDynamic,\n  scrollToItemStatic,\n  useVirtualizerContextState_unstable,\n  useVirtualizerContext_unstable,\n} from './utilities/index';\n"],"names":["VirtualizerContextProvider","scrollToItemDynamic","scrollToItemStatic","useVirtualizerContextState_unstable","useVirtualizerContext_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAQEA,0BAA0B;eAA1BA,iCAA0B;;IAC1BC,mBAAmB;eAAnBA,0BAAmB;;IACnBC,kBAAkB;eAAlBA,yBAAkB;;IAClBC,mCAAmC;eAAnCA,0CAAmC;;IACnCC,8BAA8B;eAA9BA,qCAA8B;;;uBACzB"}

package/lib-commonjs/Virtualizer.js

@@ -2,5 +2,30 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _export_star = require("@swc/helpers/_/_export_star");
-_export_star._(require("./components/Virtualizer/index"), exports);
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Virtualizer: function() {
+        return _index.Virtualizer;
+    },
+    renderVirtualizerChildPlaceholder: function() {
+        return _index.renderVirtualizerChildPlaceholder;
+    },
+    renderVirtualizer_unstable: function() {
+        return _index.renderVirtualizer_unstable;
+    },
+    useVirtualizerStyles_unstable: function() {
+        return _index.useVirtualizerStyles_unstable;
+    },
+    useVirtualizer_unstable: function() {
+        return _index.useVirtualizer_unstable;
+    },
+    virtualizerClassNames: function() {
+        return _index.virtualizerClassNames;
+    }
+});
+const _index = require("./components/Virtualizer/index");

package/lib-commonjs/Virtualizer.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/Virtualizer.ts"],"sourcesContent":["export * from './components/Virtualizer/index';\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;uBAAc"}
+{"version":3,"sources":["../src/Virtualizer.ts"],"sourcesContent":["export type {\n  VirtualizerChildRenderFunction,\n  VirtualizerConfigProps,\n  VirtualizerConfigState,\n  VirtualizerDataRef,\n  VirtualizerProps,\n  VirtualizerSlots,\n  VirtualizerState,\n} from './components/Virtualizer/index';\nexport {\n  Virtualizer,\n  renderVirtualizerChildPlaceholder,\n  renderVirtualizer_unstable,\n  useVirtualizerStyles_unstable,\n  useVirtualizer_unstable,\n  virtualizerClassNames,\n} from './components/Virtualizer/index';\n"],"names":["Virtualizer","renderVirtualizerChildPlaceholder","renderVirtualizer_unstable","useVirtualizerStyles_unstable","useVirtualizer_unstable","virtualizerClassNames"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAUEA,WAAW;eAAXA,kBAAW;;IACXC,iCAAiC;eAAjCA,wCAAiC;;IACjCC,0BAA0B;eAA1BA,iCAA0B;;IAC1BC,6BAA6B;eAA7BA,oCAA6B;;IAC7BC,uBAAuB;eAAvBA,8BAAuB;;IACvBC,qBAAqB;eAArBA,4BAAqB;;;uBAChB"}

package/lib-commonjs/VirtualizerScrollView.js

@@ -2,5 +2,27 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _export_star = require("@swc/helpers/_/_export_star");
-_export_star._(require("./components/VirtualizerScrollView/index"), exports);
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    VirtualizerScrollView: function() {
+        return _index.VirtualizerScrollView;
+    },
+    renderVirtualizerScrollView_unstable: function() {
+        return _index.renderVirtualizerScrollView_unstable;
+    },
+    useVirtualizerScrollViewStyles_unstable: function() {
+        return _index.useVirtualizerScrollViewStyles_unstable;
+    },
+    useVirtualizerScrollView_unstable: function() {
+        return _index.useVirtualizerScrollView_unstable;
+    },
+    virtualizerScrollViewClassNames: function() {
+        return _index.virtualizerScrollViewClassNames;
+    }
+});
+const _index = require("./components/VirtualizerScrollView/index");

package/lib-commonjs/VirtualizerScrollView.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/VirtualizerScrollView.ts"],"sourcesContent":["export * from './components/VirtualizerScrollView/index';\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;uBAAc"}
+{"version":3,"sources":["../src/VirtualizerScrollView.ts"],"sourcesContent":["export type {\n  VirtualizerScrollViewProps,\n  VirtualizerScrollViewSlots,\n  VirtualizerScrollViewState,\n} from './components/VirtualizerScrollView/index';\nexport {\n  VirtualizerScrollView,\n  renderVirtualizerScrollView_unstable,\n  useVirtualizerScrollViewStyles_unstable,\n  useVirtualizerScrollView_unstable,\n  virtualizerScrollViewClassNames,\n} from './components/VirtualizerScrollView/index';\n"],"names":["VirtualizerScrollView","renderVirtualizerScrollView_unstable","useVirtualizerScrollViewStyles_unstable","useVirtualizerScrollView_unstable","virtualizerScrollViewClassNames"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAMEA,qBAAqB;eAArBA,4BAAqB;;IACrBC,oCAAoC;eAApCA,2CAAoC;;IACpCC,uCAAuC;eAAvCA,8CAAuC;;IACvCC,iCAAiC;eAAjCA,wCAAiC;;IACjCC,+BAA+B;eAA/BA,sCAA+B;;;uBAC1B"}

package/lib-commonjs/VirtualizerScrollViewDynamic.js

@@ -2,5 +2,27 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _export_star = require("@swc/helpers/_/_export_star");
-_export_star._(require("./components/VirtualizerScrollViewDynamic/index"), exports);
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    VirtualizerScrollViewDynamic: function() {
+        return _index.VirtualizerScrollViewDynamic;
+    },
+    renderVirtualizerScrollViewDynamic_unstable: function() {
+        return _index.renderVirtualizerScrollViewDynamic_unstable;
+    },
+    useVirtualizerScrollViewDynamicStyles_unstable: function() {
+        return _index.useVirtualizerScrollViewDynamicStyles_unstable;
+    },
+    useVirtualizerScrollViewDynamic_unstable: function() {
+        return _index.useVirtualizerScrollViewDynamic_unstable;
+    },
+    virtualizerScrollViewDynamicClassNames: function() {
+        return _index.virtualizerScrollViewDynamicClassNames;
+    }
+});
+const _index = require("./components/VirtualizerScrollViewDynamic/index");

package/lib-commonjs/VirtualizerScrollViewDynamic.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/VirtualizerScrollViewDynamic.ts"],"sourcesContent":["export * from './components/VirtualizerScrollViewDynamic/index';\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;uBAAc"}
+{"version":3,"sources":["../src/VirtualizerScrollViewDynamic.ts"],"sourcesContent":["export type {\n  VirtualizerScrollViewDynamicProps,\n  VirtualizerScrollViewDynamicSlots,\n  VirtualizerScrollViewDynamicState,\n} from './components/VirtualizerScrollViewDynamic/index';\nexport {\n  VirtualizerScrollViewDynamic,\n  renderVirtualizerScrollViewDynamic_unstable,\n  useVirtualizerScrollViewDynamicStyles_unstable,\n  useVirtualizerScrollViewDynamic_unstable,\n  virtualizerScrollViewDynamicClassNames,\n} from './components/VirtualizerScrollViewDynamic/index';\n"],"names":["VirtualizerScrollViewDynamic","renderVirtualizerScrollViewDynamic_unstable","useVirtualizerScrollViewDynamicStyles_unstable","useVirtualizerScrollViewDynamic_unstable","virtualizerScrollViewDynamicClassNames"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAMEA,4BAA4B;eAA5BA,mCAA4B;;IAC5BC,2CAA2C;eAA3CA,kDAA2C;;IAC3CC,8CAA8C;eAA9CA,qDAA8C;;IAC9CC,wCAAwC;eAAxCA,+CAAwC;;IACxCC,sCAAsC;eAAtCA,6CAAsC;;;uBACjC"}

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":["../src/components/Virtualizer/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":["../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';\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   * 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?: 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  /**\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\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

@@ -2,9 +2,33 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _export_star = require("@swc/helpers/_/_export_star");
-_export_star._(require("./Virtualizer"), exports);
-_export_star._(require("./Virtualizer.types"), exports);
-_export_star._(require("./useVirtualizer"), exports);
-_export_star._(require("./renderVirtualizer"), exports);
-_export_star._(require("./useVirtualizerStyles.styles"), exports);
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Virtualizer: function() {
+        return _Virtualizer.Virtualizer;
+    },
+    renderVirtualizerChildPlaceholder: function() {
+        return _renderVirtualizer.renderVirtualizerChildPlaceholder;
+    },
+    renderVirtualizer_unstable: function() {
+        return _renderVirtualizer.renderVirtualizer_unstable;
+    },
+    useVirtualizerStyles_unstable: function() {
+        return _useVirtualizerStylesstyles.useVirtualizerStyles_unstable;
+    },
+    useVirtualizer_unstable: function() {
+        return _useVirtualizer.useVirtualizer_unstable;
+    },
+    virtualizerClassNames: function() {
+        return _useVirtualizerStylesstyles.virtualizerClassNames;
+    }
+});
+const _Virtualizer = require("./Virtualizer");
+const _useVirtualizer = require("./useVirtualizer");
+const _renderVirtualizer = require("./renderVirtualizer");
+const _useVirtualizerStylesstyles = require("./useVirtualizerStyles.styles");

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

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

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

@@ -1 +1 @@
-{"version":3,"sources":["../src/components/Virtualizer/renderVirtualizer.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\n\nimport * as React from 'react';\nimport type { VirtualizerSlots, VirtualizerState } from './Virtualizer.types';\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"}