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

package/lib-commonjs/hooks/useMeasureList.js.map

@@ -1 +1 @@
-{"version":3,"sources":["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":["createResizeObserverFromDocument","useMeasureList","currentIndex","refLength","totalLength","defaultItemSize","widthArray","React","useRef","Array","fill","heightArray","refArray","targetDocument","useFluent","sizeUpdateCount","handleIndexUpdate","useCallback","index","isChanged","boundClientRect","current","getBoundingClientRect","containerWidth","width","containerHeight","height","handleElementResizeCallback","entries","entry","target","handleResize","useEffect","newHeightLength","length","newWidthLength","concat","slice","resizeObserver","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":["createResizeObserverFromDocument","useMeasureList","currentIndex","refLength","totalLength","defaultItemSize","widthArray","React","useRef","Array","fill","heightArray","refArray","targetDocument","useFluent","sizeUpdateCount","handleIndexUpdate","useCallback","index","isChanged","boundClientRect","current","getBoundingClientRect","containerWidth","width","containerHeight","height","handleElementResizeCallback","entries","entry","target","handleResize","useEffect","newHeightLength","length","newWidthLength","concat","slice","resizeObserver","createIndexedRef","measureElementRef","el","undefined","unobserve","observe","_resizeObserver","disconnect","callback","defaultView","ResizeObserver"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib-commonjs/hooks/useMutationObserver.js.map

@@ -1 +1 @@
-{"version":3,"sources":["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":["useMutationObserver","useRef","useEffect","React","target","callback","options","observer","targetDocument","useFluent","win","defaultView","current","MutationObserver","observe","disconnect"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAMaA;;;eAAAA;;;;iEALU;qCACyB;AAEhD,MAAM,EAAEC,MAAM,EAAEC,SAAS,EAAE,GAAGC;AAEvB,MAAMH,sBAAsB,CACjCI,QACAC,UACAC;IAIA;IAEA,8FAA8F;IAC9F,iDAAiD;IACjD,MAAMC,WAAWN;IACjB,MAAM,EAAEO,cAAc,EAAE,GAAGC,IAAAA,uCAAAA;IAC3B,MAAMC,MAAMF,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAAgBG,WAAW;IAEvCT,UAAU;QACR,IAAI,CAACQ,KAAK;YACR;QACF;QACA,8DAA8D;QAC9DH,SAASK,OAAO,GAAG,IAAIF,IAAIG,gBAAgB,CAACR;IAC9C,GAAG;QAACA;QAAUK;KAAI;IAElBR,UAAU;QACR,IAAIE,QAAQ;gBAEVG;YAAAA,CAAAA,oBAAAA,SAASK,OAAO,AAAPA,MAAO,QAAhBL,sBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,kBAAkBO,OAAO,CAACV,QAAQE;QACpC;QAEA,OAAO;gBACLC;YAAAA,CAAAA,oBAAAA,SAASK,OAAO,AAAPA,MAAO,QAAhBL,sBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,kBAAkBQ,UAAU;QAC9B;IACF,GAAG;QAACX;QAAQE;KAAQ;IAEpB,OAAO;QAAEC;IAAS;AACpB"}
+{"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":["useMutationObserver","useRef","useEffect","React","target","callback","options","observer","targetDocument","useFluent","win","defaultView","current","MutationObserver","observe","disconnect"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAKaA;;;eAAAA;;;;iEALU;qCACyB;AAEhD,MAAM,EAAEC,MAAM,EAAEC,SAAS,EAAE,GAAGC;AAEvB,MAAMH,sBAAsB,CACjCI,QACAC,UACAC;IAIA;IAEA,8FAA8F;IAC9F,iDAAiD;IACjD,MAAMC,WAAWN;IACjB,MAAM,EAAEO,cAAc,EAAE,GAAGC,IAAAA,uCAAAA;IAC3B,MAAMC,MAAMF,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAAgBG,WAAW;IAEvCT,UAAU;QACR,IAAI,CAACQ,KAAK;YACR;QACF;QACA,8DAA8D;QAC9DH,SAASK,OAAO,GAAG,IAAIF,IAAIG,gBAAgB,CAACR;IAC9C,GAAG;QAACA;QAAUK;KAAI;IAElBR,UAAU;QACR,IAAIE,QAAQ;gBAEVG;YAAAA,CAAAA,oBAAAA,SAASK,OAAO,AAAPA,MAAO,QAAhBL,sBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,kBAAkBO,OAAO,CAACV,QAAQE;QACpC;QAEA,OAAO;gBACLC;YAAAA,CAAAA,oBAAAA,SAASK,OAAO,AAAPA,MAAO,QAAhBL,sBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,kBAAkBQ,UAAU;QAC9B;IACF,GAAG;QAACX;QAAQE;KAAQ;IAEpB,OAAO;QAAEC;IAAS;AACpB"}

package/lib-commonjs/hooks/useResizeObserverRef.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useResizeObserverRef.ts"],"sourcesContent":["import * as React from 'react';\nimport { useFluent_unstable as useFluent } from '@fluentui/react-shared-contexts';\nimport { debounce } from '../utilities/debounce';\nimport { createResizeObserverFromDocument } from '../utilities/createResizeObserverFromDocument';\nimport { ResizeCallbackWithRef } from './hooks.types';\n\n/**\n * useResizeObserverRef_unstable simplifies resize observer connection and ensures debounce/cleanup\n */\nexport const useResizeObserverRef_unstable = (resizeCallback: ResizeCallbackWithRef) => {\n  'use no memo';\n\n  const { targetDocument } = useFluent();\n  const container = React.useRef<HTMLElement | null>(null);\n  const containerHeightRef = React.useRef<number>(0);\n  const containerWidthRef = React.useRef<number>(0);\n  // the handler for resize observer\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 handleResize = debounce((entries: ResizeObserverEntry[], observer: ResizeObserver) => {\n    const containerHeight = container.current?.clientHeight;\n    const containerWidth = container.current?.clientWidth;\n    // Our resize observer will fire on scroll resize, let index change handle that instead.\n    if (containerHeightRef.current !== containerHeight || containerWidth !== containerWidthRef.current) {\n      containerWidthRef.current = containerWidth ?? 0;\n      containerHeightRef.current = containerHeight ?? 0;\n      resizeCallback(entries, observer, container);\n    }\n  });\n\n  // Keep the reference of ResizeObserver in the state, as it should live through renders\n  const [resizeObserver, setResizeObserver] = React.useState(() =>\n    createResizeObserverFromDocument(targetDocument, handleResize),\n  );\n\n  React.useEffect(() => {\n    // Update our state when resizeCallback changes\n    container.current = null;\n    resizeObserver?.disconnect();\n    setResizeObserver(() => createResizeObserverFromDocument(targetDocument, handleResize));\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [resizeCallback, targetDocument]);\n\n  React.useEffect(() => {\n    return () => {\n      container.current = null;\n      resizeObserver?.disconnect();\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  const scrollRef = React.useCallback(\n    (instance: HTMLElement | HTMLDivElement | null) => {\n      if (container.current !== instance) {\n        if (container.current) {\n          resizeObserver?.unobserve(container.current);\n        }\n\n        container.current = instance;\n        if (container.current) {\n          resizeObserver?.observe(container.current);\n        }\n      }\n    },\n    [resizeObserver],\n  );\n\n  return scrollRef;\n};\n"],"names":["useResizeObserverRef_unstable","resizeCallback","targetDocument","useFluent","container","React","useRef","containerHeightRef","containerWidthRef","handleResize","debounce","entries","observer","containerHeight","current","clientHeight","containerWidth","clientWidth","resizeObserver","setResizeObserver","useState","createResizeObserverFromDocument","useEffect","disconnect","scrollRef","useCallback","instance","unobserve","observe"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BASaA;;;eAAAA;;;;iEATU;qCACyB;0BACvB;kDACwB;AAM1C,MAAMA,gCAAgC,CAACC;IAC5C;IAEA,MAAM,EAAEC,cAAc,EAAE,GAAGC,IAAAA,uCAAAA;IAC3B,MAAMC,YAAYC,OAAMC,MAAM,CAAqB;IACnD,MAAMC,qBAAqBF,OAAMC,MAAM,CAAS;IAChD,MAAME,oBAAoBH,OAAMC,MAAM,CAAS;IAC/C,kCAAkC;IAClC,8FAA8F;IAC9F,iDAAiD;IACjD,MAAMG,eAAeC,IAAAA,kBAAAA,EAAS,CAACC,SAAgCC;YACrCR,oBACDA;QADvB,MAAMS,kBAAAA,AAAkBT,CAAAA,qBAAAA,UAAUU,OAAO,AAAPA,MAAO,QAAjBV,uBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,mBAAmBW,YAAY;QACvD,MAAMC,iBAAAA,AAAiBZ,CAAAA,sBAAAA,UAAUU,OAAO,AAAPA,MAAO,QAAjBV,wBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,oBAAmBa,WAAW;QACrD,wFAAwF;QACxF,IAAIV,mBAAmBO,OAAO,KAAKD,mBAAmBG,mBAAmBR,kBAAkBM,OAAO,EAAE;YAClGN,kBAAkBM,OAAO,GAAGE,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,iBAAkB;YAC9CT,mBAAmBO,OAAO,GAAGD,oBAAAA,QAAAA,oBAAAA,KAAAA,IAAAA,kBAAmB;YAChDZ,eAAeU,SAASC,UAAUR;QACpC;IACF;IAEA,uFAAuF;IACvF,MAAM,CAACc,gBAAgBC,kBAAkB,GAAGd,OAAMe,QAAQ,CAAC,IACzDC,IAAAA,kEAAAA,EAAiCnB,gBAAgBO;IAGnDJ,OAAMiB,SAAS,CAAC;QACd,+CAA+C;QAC/ClB,UAAUU,OAAO,GAAG;QACpBI,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAAgBK,UAAU;QAC1BJ,kBAAkB,IAAME,IAAAA,kEAAAA,EAAiCnB,gBAAgBO;IACzE,uDAAuD;IACzD,GAAG;QAACR;QAAgBC;KAAe;IAEnCG,OAAMiB,SAAS,CAAC;QACd,OAAO;YACLlB,UAAUU,OAAO,GAAG;YACpBI,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAAgBK,UAAU;QAC5B;IACA,uDAAuD;IACzD,GAAG,EAAE;IAEL,MAAMC,YAAYnB,OAAMoB,WAAW,CACjC,CAACC;QACC,IAAItB,UAAUU,OAAO,KAAKY,UAAU;YAClC,IAAItB,UAAUU,OAAO,EAAE;gBACrBI,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAAgBS,SAAS,CAACvB,UAAUU,OAAO;YAC7C;YAEAV,UAAUU,OAAO,GAAGY;YACpB,IAAItB,UAAUU,OAAO,EAAE;gBACrBI,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAAgBU,OAAO,CAACxB,UAAUU,OAAO;YAC3C;QACF;IACF,GACA;QAACI;KAAe;IAGlB,OAAOM;AACT"}
+{"version":3,"sources":["../src/hooks/useResizeObserverRef.ts"],"sourcesContent":["import * as React from 'react';\nimport { useFluent_unstable as useFluent } from '@fluentui/react-shared-contexts';\nimport { debounce } from '../utilities/debounce';\nimport { createResizeObserverFromDocument } from '../utilities/createResizeObserverFromDocument';\nimport { ResizeCallbackWithRef } from './hooks.types';\n\n/**\n * useResizeObserverRef_unstable simplifies resize observer connection and ensures debounce/cleanup\n */\nexport const useResizeObserverRef_unstable = (resizeCallback: ResizeCallbackWithRef) => {\n  'use no memo';\n\n  const { targetDocument } = useFluent();\n  const container = React.useRef<HTMLElement | null>(null);\n  const containerHeightRef = React.useRef<number>(0);\n  const containerWidthRef = React.useRef<number>(0);\n  // the handler for resize observer\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 handleResize = debounce((entries: ResizeObserverEntry[], observer: ResizeObserver) => {\n    const containerHeight = container.current?.clientHeight;\n    const containerWidth = container.current?.clientWidth;\n    // Our resize observer will fire on scroll resize, let index change handle that instead.\n    if (containerHeightRef.current !== containerHeight || containerWidth !== containerWidthRef.current) {\n      containerWidthRef.current = containerWidth ?? 0;\n      containerHeightRef.current = containerHeight ?? 0;\n      resizeCallback(entries, observer, container);\n    }\n  });\n\n  // Keep the reference of ResizeObserver in the state, as it should live through renders\n  const [resizeObserver, setResizeObserver] = React.useState(() =>\n    createResizeObserverFromDocument(targetDocument, handleResize),\n  );\n\n  React.useEffect(() => {\n    // Update our state when resizeCallback changes\n    container.current = null;\n    resizeObserver?.disconnect();\n    setResizeObserver(() => createResizeObserverFromDocument(targetDocument, handleResize));\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [resizeCallback, targetDocument]);\n\n  React.useEffect(() => {\n    return () => {\n      container.current = null;\n      resizeObserver?.disconnect();\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  const scrollRef = React.useCallback(\n    (instance: HTMLElement | HTMLDivElement | null) => {\n      if (container.current !== instance) {\n        if (container.current) {\n          resizeObserver?.unobserve(container.current);\n        }\n\n        container.current = instance;\n        if (container.current) {\n          resizeObserver?.observe(container.current);\n        }\n      }\n    },\n    [resizeObserver],\n  );\n\n  return scrollRef;\n};\n"],"names":["useResizeObserverRef_unstable","resizeCallback","targetDocument","useFluent","container","React","useRef","containerHeightRef","containerWidthRef","handleResize","debounce","entries","observer","containerHeight","current","clientHeight","containerWidth","clientWidth","resizeObserver","setResizeObserver","useState","createResizeObserverFromDocument","useEffect","disconnect","scrollRef","useCallback","instance","unobserve","observe"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BASaA;;;eAAAA;;;;iEATU;qCACyB;0BACvB;kDACwB;AAM1C,MAAMA,gCAAgC,CAACC;IAC5C;IAEA,MAAM,EAAEC,cAAc,EAAE,GAAGC,IAAAA,uCAAAA;IAC3B,MAAMC,YAAYC,OAAMC,MAAM,CAAqB;IACnD,MAAMC,qBAAqBF,OAAMC,MAAM,CAAS;IAChD,MAAME,oBAAoBH,OAAMC,MAAM,CAAS;IAC/C,kCAAkC;IAClC,8FAA8F;IAC9F,iDAAiD;IACjD,MAAMG,eAAeC,IAAAA,kBAAAA,EAAS,CAACC,SAAgCC;YACrCR,oBACDA;QADvB,MAAMS,kBAAAA,AAAkBT,CAAAA,qBAAAA,UAAUU,OAAO,AAAPA,MAAO,QAAjBV,uBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,mBAAmBW,YAAY;QACvD,MAAMC,iBAAAA,AAAiBZ,CAAAA,sBAAAA,UAAUU,OAAO,AAAPA,MAAO,QAAjBV,wBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,oBAAmBa,WAAW;QACrD,wFAAwF;QACxF,IAAIV,mBAAmBO,OAAO,KAAKD,mBAAmBG,mBAAmBR,kBAAkBM,OAAO,EAAE;YAClGN,kBAAkBM,OAAO,GAAGE,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,iBAAkB;YAC9CT,mBAAmBO,OAAO,GAAGD,oBAAAA,QAAAA,oBAAAA,KAAAA,IAAAA,kBAAmB;YAChDZ,eAAeU,SAASC,UAAUR;QACpC;IACF;IAEA,uFAAuF;IACvF,MAAM,CAACc,gBAAgBC,kBAAkB,GAAGd,OAAMe,QAAQ,CAAC,IACzDC,IAAAA,kEAAAA,EAAiCnB,gBAAgBO;IAGnDJ,OAAMiB,SAAS,CAAC;QACd,+CAA+C;QAC/ClB,UAAUU,OAAO,GAAG;QACpBI,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAAgBK,UAAU;QAC1BJ,kBAAkB,IAAME,IAAAA,kEAAAA,EAAiCnB,gBAAgBO;IACzE,uDAAuD;IACzD,GAAG;QAACR;QAAgBC;KAAe;IAEnCG,OAAMiB,SAAS,CAAC;QACd,OAAO;YACLlB,UAAUU,OAAO,GAAG;YACpBI,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAAgBK,UAAU;QAC5B;IACA,uDAAuD;IACzD,GAAG,EAAE;IAEL,MAAMC,YAAYnB,OAAMoB,WAAW,CACjC,CAACC;QACC,IAAItB,UAAUU,OAAO,KAAKY,UAAU;YAClC,IAAItB,UAAUU,OAAO,EAAE;gBACrBI,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAAgBS,SAAS,CAACvB,UAAUU,OAAO;YAC7C;YAEAV,UAAUU,OAAO,GAAGY;YACpB,IAAItB,UAAUU,OAAO,EAAE;gBACrBI,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAAgBU,OAAO,CAACxB,UAAUU,OAAO;YAC3C;QACF;IACF,GACA;QAACI;KAAe;IAGlB,OAAOM;AACT"}

package/lib-commonjs/hooks/useStaticPagination.js

@@ -15,8 +15,8 @@ const useStaticVirtualizerPagination = (virtualizerProps, paginationEnabled = tr
     'use no memo';
     const { itemSize, axis = 'vertical' } = virtualizerProps;
     const [setScrollTimer, clearScrollTimer] = (0, _reactutilities.useTimeout)();
-    const lastScrollPos = (0, _react.useRef)(0);
-    const lastIndexScrolled = (0, _react.useRef)(0);
+    const lastScrollPos = _react.useRef(0);
+    const lastIndexScrolled = _react.useRef(0);
     const scrollContainer = _react.useRef(null);
     const clearListeners = ()=>{
         if (scrollContainer.current) {

package/lib-commonjs/hooks/useStaticPagination.js.map

@@ -1 +1 @@
-{"version":3,"sources":["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":["useStaticVirtualizerPagination","virtualizerProps","paginationEnabled","itemSize","axis","setScrollTimer","clearScrollTimer","useTimeout","lastScrollPos","useRef","lastIndexScrolled","scrollContainer","React","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":";;;;+BAWaA;;;eAAAA;;;;iEAXU;gCAGI;AAQpB,MAAMA,iCAAiC,CAC5CC,kBACAC,oBAA6B,IAAI;IAEjC;IAEA,MAAM,EAAEC,QAAQ,EAAEC,OAAO,UAAU,EAAE,GAAGH;IAExC,MAAM,CAACI,gBAAgBC,iBAAiB,GAAGC,IAAAA,0BAAAA;IAC3C,MAAMC,gBAAgBC,IAAAA,aAAAA,EAAe;IACrC,MAAMC,oBAAoBD,IAAAA,aAAAA,EAAe;IAEzC,MAAME,kBAAkBC,OAAMH,MAAM,CAAqB;IAEzD,MAAMI,iBAAiB;QACrB,IAAIF,gBAAgBG,OAAO,EAAE;YAC3BH,gBAAgBG,OAAO,CAACC,mBAAmB,CAAC,UAAUC;YAEtDL,gBAAgBG,OAAO,GAAG;YAC1BR;QACF;IACF;IAEAM,OAAMK,SAAS,CAAC;QACd,OAAO;YACLJ;QACF;IACA,uDAAuD;IACzD,GAAG,EAAE;IAEL;;;;GAIC,GACD,MAAMK,cAAcN,OAAMO,WAAW,CAAC;QACpC,IAAI,CAACR,gBAAgBG,OAAO,IAAI,CAACZ,mBAAmB;YAClD,qBAAqB;YACrB;QACF;QAEA,MAAMkB,mBAAmBC,KAAKC,KAAK,CACjClB,SAAS,aAAaO,gBAAgBG,OAAO,CAACS,SAAS,GAAGZ,gBAAgBG,OAAO,CAACU,UAAU;QAE9F,MAAMC,cAAcJ,KAAKC,KAAK,CAACF,mBAAmBjB;QAElD,IAAIuB,WAAW;QACf,IAAIL,KAAKC,KAAK,CAACG,cAAcf,kBAAkBI,OAAO,MAAM,GAAG;YAC7D,4EAA4E;YAC5E,MAAMa,aAAanB,cAAcM,OAAO,GAAGM,mBAAmB,IAAI,CAAC;YACnE,MAAMQ,oBAAoBpB,cAAcM,OAAO,KAAKM;YACpD,MAAMS,SAASD,oBAAoB,IAAID;YAEvCD,WAAWD,cAAcI;QAC3B,OAAO;YACL,6DAA6D;YAC7DH,WAAWD;QACb;QAEA,MAAMK,cAAcJ,WAAWvB;QAE/B,IAAIC,SAAS,YAAY;YACvBO,gBAAgBG,OAAO,CAACiB,QAAQ,CAAC;gBAAEC,KAAKF;gBAAaG,UAAU;YAAS;QAC1E,OAAO;YACLtB,gBAAgBG,OAAO,CAACiB,QAAQ,CAAC;gBAAEG,MAAMJ;gBAAaG,UAAU;YAAS;QAC3E;QACAzB,cAAcM,OAAO,GAAGgB;QACxBpB,kBAAkBI,OAAO,GAAGY;IAC9B,GAAG;QAACxB;QAAmBE;QAAMD;KAAS;IAEtC;;GAEC,GACD,MAAMa,WAAWJ,OAAMO,WAAW,CAChCgB,CAAAA;QACE7B;QACAD,eAAea,aAAa;IAC9B,GACA;QAACA;QAAaZ;QAAkBD;KAAe;IAGjD;;;GAGC,GACD,MAAM+B,gBAAgBxB,OAAMO,WAAW,CACrC,CAACkB;QACC,IAAI,CAACnC,mBAAmB;YACtBW;YACAF,gBAAgBG,OAAO,GAAG;YAC1B;QACF;QACA,IAAIH,gBAAgBG,OAAO,KAAKuB,UAAU;YACxCxB;YAEAF,gBAAgBG,OAAO,GAAGuB;YAC1B,IAAI1B,gBAAgBG,OAAO,EAAE;gBAC3BH,gBAAgBG,OAAO,CAACwB,gBAAgB,CAAC,UAAUtB;YACrD;QACF;IACF,GAEA;QAACA;QAAUE;QAAahB;KAAkB;IAG5C,OAAOkC;AACT"}
+{"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":["useStaticVirtualizerPagination","virtualizerProps","paginationEnabled","itemSize","axis","setScrollTimer","clearScrollTimer","useTimeout","lastScrollPos","React","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":";;;;+BAUaA;;;eAAAA;;;;iEAVU;gCAEI;AAQpB,MAAMA,iCAAiC,CAC5CC,kBACAC,oBAA6B,IAAI;IAEjC;IAEA,MAAM,EAAEC,QAAQ,EAAEC,OAAO,UAAU,EAAE,GAAGH;IAExC,MAAM,CAACI,gBAAgBC,iBAAiB,GAAGC,IAAAA,0BAAAA;IAC3C,MAAMC,gBAAgBC,OAAMC,MAAM,CAAS;IAC3C,MAAMC,oBAAoBF,OAAMC,MAAM,CAAS;IAE/C,MAAME,kBAAkBH,OAAMC,MAAM,CAAqB;IAEzD,MAAMG,iBAAiB;QACrB,IAAID,gBAAgBE,OAAO,EAAE;YAC3BF,gBAAgBE,OAAO,CAACC,mBAAmB,CAAC,UAAUC;YAEtDJ,gBAAgBE,OAAO,GAAG;YAC1BR;QACF;IACF;IAEAG,OAAMQ,SAAS,CAAC;QACd,OAAO;YACLJ;QACF;IACA,uDAAuD;IACzD,GAAG,EAAE;IAEL;;;;GAIC,GACD,MAAMK,cAAcT,OAAMU,WAAW,CAAC;QACpC,IAAI,CAACP,gBAAgBE,OAAO,IAAI,CAACZ,mBAAmB;YAClD,qBAAqB;YACrB;QACF;QAEA,MAAMkB,mBAAmBC,KAAKC,KAAK,CACjClB,SAAS,aAAaQ,gBAAgBE,OAAO,CAACS,SAAS,GAAGX,gBAAgBE,OAAO,CAACU,UAAU;QAE9F,MAAMC,cAAcJ,KAAKC,KAAK,CAACF,mBAAmBjB;QAElD,IAAIuB,WAAW;QACf,IAAIL,KAAKC,KAAK,CAACG,cAAcd,kBAAkBG,OAAO,MAAM,GAAG;YAC7D,4EAA4E;YAC5E,MAAMa,aAAanB,cAAcM,OAAO,GAAGM,mBAAmB,IAAI,CAAC;YACnE,MAAMQ,oBAAoBpB,cAAcM,OAAO,KAAKM;YACpD,MAAMS,SAASD,oBAAoB,IAAID;YAEvCD,WAAWD,cAAcI;QAC3B,OAAO;YACL,6DAA6D;YAC7DH,WAAWD;QACb;QAEA,MAAMK,cAAcJ,WAAWvB;QAE/B,IAAIC,SAAS,YAAY;YACvBQ,gBAAgBE,OAAO,CAACiB,QAAQ,CAAC;gBAAEC,KAAKF;gBAAaG,UAAU;YAAS;QAC1E,OAAO;YACLrB,gBAAgBE,OAAO,CAACiB,QAAQ,CAAC;gBAAEG,MAAMJ;gBAAaG,UAAU;YAAS;QAC3E;QACAzB,cAAcM,OAAO,GAAGgB;QACxBnB,kBAAkBG,OAAO,GAAGY;IAC9B,GAAG;QAACxB;QAAmBE;QAAMD;KAAS;IAEtC;;GAEC,GACD,MAAMa,WAAWP,OAAMU,WAAW,CAChCgB,CAAAA;QACE7B;QACAD,eAAea,aAAa;IAC9B,GACA;QAACA;QAAaZ;QAAkBD;KAAe;IAGjD;;;GAGC,GACD,MAAM+B,gBAAgB3B,OAAMU,WAAW,CACrC,CAACkB;QACC,IAAI,CAACnC,mBAAmB;YACtBW;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,GAEA;QAACA;QAAUE;QAAahB;KAAkB;IAG5C,OAAOkC;AACT"}

package/lib-commonjs/hooks/useVirtualizerMeasure.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useVirtualizerMeasure.ts"],"sourcesContent":["import * as React from 'react';\nimport { VirtualizerMeasureProps } from './hooks.types';\nimport { useResizeObserverRef_unstable } from './useResizeObserverRef';\nimport { useFluent_unstable as useFluent } from '@fluentui/react-shared-contexts';\n\n/**\n * React hook that measures virtualized space based on a static size to ensure optimized virtualization length.\n */\nexport const useStaticVirtualizerMeasure = <TElement extends HTMLElement>(\n  virtualizerProps: VirtualizerMeasureProps,\n): {\n  virtualizerLength: number;\n  bufferItems: number;\n  bufferSize: number;\n  scrollRef: (instance: TElement | null) => void;\n  containerSizeRef: React.MutableRefObject<number>;\n} => {\n  const { defaultItemSize, direction = 'vertical', bufferItems, bufferSize } = virtualizerProps;\n\n  const [state, setState] = React.useState({\n    virtualizerLength: 0,\n    _bufferSize: 0,\n    _bufferItems: 0,\n  });\n\n  const containerSizeRef = React.useRef<number>(0);\n  const { targetDocument } = useFluent();\n\n  const { virtualizerLength, _bufferItems, _bufferSize } = state;\n\n  const resizeCallback = React.useCallback(\n    (\n      _entries: ResizeObserverEntry[],\n      // TODO: exclude types from this lint rule: https://github.com/microsoft/fluentui/issues/31286\n      // eslint-disable-next-line no-restricted-globals\n      _observer: ResizeObserver,\n      scrollRef?: React.MutableRefObject<HTMLElement | null>,\n    ) => {\n      if (!scrollRef?.current) {\n        return;\n      }\n\n      if (scrollRef.current !== targetDocument?.body) {\n        // We have a local scroll container\n        containerSizeRef.current =\n          direction === 'vertical'\n            ? scrollRef?.current.getBoundingClientRect().height\n            : scrollRef?.current.getBoundingClientRect().width;\n      } else if (targetDocument?.defaultView) {\n        // If our scroll ref is the document body, we should check window height\n        containerSizeRef.current =\n          direction === 'vertical' ? targetDocument?.defaultView?.innerHeight : targetDocument?.defaultView?.innerWidth;\n      }\n      /*\n       * Number of items required to cover viewport.\n       */\n      const length = Math.ceil(containerSizeRef.current / defaultItemSize + 1);\n\n      /*\n       * Number of items to append at each end, i.e. 'preload' each side before entering view.\n       * Minimum: 1\n       */\n      const newBufferItems = bufferItems ?? Math.max(Math.ceil(length / 4), 1);\n\n      /*\n       * This is how far we deviate into the bufferItems to detect a redraw.\n       */\n      const newBufferSize = bufferSize ?? Math.max(defaultItemSize / 2.0, 1);\n\n      const totalLength = length + newBufferItems * 2;\n\n      setState({\n        virtualizerLength: totalLength,\n        _bufferItems: newBufferItems,\n        _bufferSize: newBufferSize,\n      });\n    },\n    [bufferItems, bufferSize, defaultItemSize, direction, targetDocument?.body, targetDocument?.defaultView],\n  );\n\n  const scrollRef = useResizeObserverRef_unstable(resizeCallback);\n\n  return {\n    virtualizerLength,\n    bufferItems: _bufferItems,\n    bufferSize: _bufferSize,\n    scrollRef,\n    containerSizeRef,\n  };\n};\n"],"names":["useStaticVirtualizerMeasure","virtualizerProps","defaultItemSize","direction","bufferItems","bufferSize","state","setState","React","useState","virtualizerLength","_bufferSize","_bufferItems","containerSizeRef","useRef","targetDocument","useFluent","resizeCallback","useCallback","_entries","_observer","scrollRef","current","body","getBoundingClientRect","height","width","defaultView","innerHeight","innerWidth","length","Math","ceil","newBufferItems","max","newBufferSize","totalLength","useResizeObserverRef_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAQaA;;;eAAAA;;;;iEARU;sCAEuB;qCACE;AAKzC,MAAMA,8BAA8B,CACzCC;IAQA,MAAM,EAAEC,eAAe,EAAEC,YAAY,UAAU,EAAEC,WAAW,EAAEC,UAAU,EAAE,GAAGJ;IAE7E,MAAM,CAACK,OAAOC,SAAS,GAAGC,OAAMC,QAAQ,CAAC;QACvCC,mBAAmB;QACnBC,aAAa;QACbC,cAAc;IAChB;IAEA,MAAMC,mBAAmBL,OAAMM,MAAM,CAAS;IAC9C,MAAM,EAAEC,cAAc,EAAE,GAAGC,IAAAA,uCAAAA;IAE3B,MAAM,EAAEN,iBAAiB,EAAEE,YAAY,EAAED,WAAW,EAAE,GAAGL;IAEzD,MAAMW,iBAAiBT,OAAMU,WAAW,CACtC,CACEC,UAEA,iDAAiD;IACjDC,WACAC;QAEA,IAAI,CAACA,CAAAA,cAAAA,QAAAA,cAAAA,KAAAA,IAAAA,KAAAA,IAAAA,UAAWC,OAAO,AAAPA,GAAS;YACvB;QACF;QAEA,IAAID,UAAUC,OAAO,KAAKP,CAAAA,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAAgBQ,IAAI,AAAJA,GAAM;YAC9C,mCAAmC;YACnCV,iBAAiBS,OAAO,GACtBnB,cAAc,aACVkB,cAAAA,QAAAA,cAAAA,KAAAA,IAAAA,KAAAA,IAAAA,UAAWC,OAAO,CAACE,qBAAqB,GAAGC,MAAM,GACjDJ,cAAAA,QAAAA,cAAAA,KAAAA,IAAAA,KAAAA,IAAAA,UAAWC,OAAO,CAACE,qBAAqB,GAAGE,KAAK;QACxD,OAAO,IAAIX,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAAgBY,WAAW,EAAE;gBAGTZ,6BAA2CA;YAFxE,wEAAwE;YACxEF,iBAAiBS,OAAO,GACtBnB,cAAc,aAAaY,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,CAAAA,8BAAAA,eAAgBY,WAAW,AAAXA,MAAW,QAA3BZ,gCAAAA,KAAAA,IAAAA,KAAAA,IAAAA,4BAA6Ba,WAAW,GAAGb,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,CAAAA,+BAAAA,eAAgBY,WAAW,AAAXA,MAAW,QAA3BZ,iCAAAA,KAAAA,IAAAA,KAAAA,IAAAA,6BAA6Bc,UAAU;QACjH;QACA;;OAEC,GACD,MAAMC,SAASC,KAAKC,IAAI,CAACnB,iBAAiBS,OAAO,GAAGpB,kBAAkB;QAEtE;;;OAGC,GACD,MAAM+B,iBAAiB7B,gBAAAA,QAAAA,gBAAAA,KAAAA,IAAAA,cAAe2B,KAAKG,GAAG,CAACH,KAAKC,IAAI,CAACF,SAAS,IAAI;QAEtE;;OAEC,GACD,MAAMK,gBAAgB9B,eAAAA,QAAAA,eAAAA,KAAAA,IAAAA,aAAc0B,KAAKG,GAAG,CAAChC,kBAAkB,KAAK;QAEpE,MAAMkC,cAAcN,SAASG,iBAAiB;QAE9C1B,SAAS;YACPG,mBAAmB0B;YACnBxB,cAAcqB;YACdtB,aAAawB;QACf;IACF,GACA;QAAC/B;QAAaC;QAAYH;QAAiBC;QAAWY,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAAgBQ,IAAI;QAAER,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAAgBY,WAAW;KAAC;IAG1G,MAAMN,YAAYgB,IAAAA,mDAAAA,EAA8BpB;IAEhD,OAAO;QACLP;QACAN,aAAaQ;QACbP,YAAYM;QACZU;QACAR;IACF;AACF"}
+{"version":3,"sources":["../src/hooks/useVirtualizerMeasure.ts"],"sourcesContent":["import * as React from 'react';\nimport { VirtualizerMeasureProps } from './hooks.types';\nimport { useResizeObserverRef_unstable } from './useResizeObserverRef';\nimport { useFluent_unstable as useFluent } from '@fluentui/react-shared-contexts';\n\n/**\n * React hook that measures virtualized space based on a static size to ensure optimized virtualization length.\n */\nexport const useStaticVirtualizerMeasure = <TElement extends HTMLElement>(\n  virtualizerProps: VirtualizerMeasureProps,\n): {\n  virtualizerLength: number;\n  bufferItems: number;\n  bufferSize: number;\n  scrollRef: (instance: TElement | null) => void;\n  containerSizeRef: React.MutableRefObject<number>;\n} => {\n  const { defaultItemSize, direction = 'vertical', bufferItems, bufferSize } = virtualizerProps;\n\n  const [state, setState] = React.useState({\n    virtualizerLength: 0,\n    _bufferSize: 0,\n    _bufferItems: 0,\n  });\n\n  const containerSizeRef = React.useRef<number>(0);\n  const { targetDocument } = useFluent();\n\n  const { virtualizerLength, _bufferItems, _bufferSize } = state;\n\n  const resizeCallback = React.useCallback(\n    (\n      _entries: ResizeObserverEntry[],\n      // TODO: exclude types from this lint rule: https://github.com/microsoft/fluentui/issues/31286\n      // eslint-disable-next-line no-restricted-globals\n      _observer: ResizeObserver,\n      scrollRef?: React.MutableRefObject<HTMLElement | null>,\n    ) => {\n      if (!scrollRef?.current) {\n        return;\n      }\n\n      if (scrollRef.current !== targetDocument?.body) {\n        // We have a local scroll container\n        containerSizeRef.current =\n          direction === 'vertical'\n            ? scrollRef?.current.getBoundingClientRect().height\n            : scrollRef?.current.getBoundingClientRect().width;\n      } else if (targetDocument?.defaultView) {\n        // If our scroll ref is the document body, we should check window height\n        containerSizeRef.current =\n          direction === 'vertical' ? targetDocument?.defaultView?.innerHeight : targetDocument?.defaultView?.innerWidth;\n      }\n      /*\n       * Number of items required to cover viewport.\n       */\n      const length = Math.ceil(containerSizeRef.current / defaultItemSize + 1);\n\n      /*\n       * Number of items to append at each end, i.e. 'preload' each side before entering view.\n       * Minimum: 1\n       */\n      const newBufferItems = bufferItems ?? Math.max(Math.ceil(length / 4), 1);\n\n      /*\n       * This is how far we deviate into the bufferItems to detect a redraw.\n       */\n      const newBufferSize = bufferSize ?? Math.max(defaultItemSize / 2.0, 1);\n\n      const totalLength = length + newBufferItems * 2;\n\n      setState({\n        virtualizerLength: totalLength,\n        _bufferItems: newBufferItems,\n        _bufferSize: newBufferSize,\n      });\n    },\n    [bufferItems, bufferSize, defaultItemSize, direction, targetDocument?.body, targetDocument?.defaultView],\n  );\n\n  const scrollRef = useResizeObserverRef_unstable(resizeCallback);\n\n  return {\n    virtualizerLength,\n    bufferItems: _bufferItems,\n    bufferSize: _bufferSize,\n    scrollRef,\n    containerSizeRef,\n  };\n};\n"],"names":["useStaticVirtualizerMeasure","virtualizerProps","defaultItemSize","direction","bufferItems","bufferSize","state","setState","React","useState","virtualizerLength","_bufferSize","_bufferItems","containerSizeRef","useRef","targetDocument","useFluent","resizeCallback","useCallback","_entries","_observer","scrollRef","current","body","getBoundingClientRect","height","width","defaultView","innerHeight","innerWidth","length","Math","ceil","newBufferItems","max","newBufferSize","totalLength","useResizeObserverRef_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAQaA;;;eAAAA;;;;iEARU;sCAEuB;qCACE;AAKzC,MAAMA,8BAA8B,CACzCC;IAQA,MAAM,EAAEC,eAAe,EAAEC,YAAY,UAAU,EAAEC,WAAW,EAAEC,UAAU,EAAE,GAAGJ;IAE7E,MAAM,CAACK,OAAOC,SAAS,GAAGC,OAAMC,QAAQ,CAAC;QACvCC,mBAAmB;QACnBC,aAAa;QACbC,cAAc;IAChB;IAEA,MAAMC,mBAAmBL,OAAMM,MAAM,CAAS;IAC9C,MAAM,EAAEC,cAAc,EAAE,GAAGC,IAAAA,uCAAAA;IAE3B,MAAM,EAAEN,iBAAiB,EAAEE,YAAY,EAAED,WAAW,EAAE,GAAGL;IAEzD,MAAMW,iBAAiBT,OAAMU,WAAW,CACtC,CACEC,UAEA,iDAAiD;IACjDC,WACAC;QAEA,IAAI,CAACA,CAAAA,cAAAA,QAAAA,cAAAA,KAAAA,IAAAA,KAAAA,IAAAA,UAAWC,OAAO,AAAPA,GAAS;YACvB;QACF;QAEA,IAAID,UAAUC,OAAO,KAAKP,CAAAA,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAAgBQ,IAAI,AAAJA,GAAM;YAC9C,mCAAmC;YACnCV,iBAAiBS,OAAO,GACtBnB,cAAc,aACVkB,cAAAA,QAAAA,cAAAA,KAAAA,IAAAA,KAAAA,IAAAA,UAAWC,OAAO,CAACE,qBAAqB,GAAGC,MAAM,GACjDJ,cAAAA,QAAAA,cAAAA,KAAAA,IAAAA,KAAAA,IAAAA,UAAWC,OAAO,CAACE,qBAAqB,GAAGE,KAAK;QACxD,OAAO,IAAIX,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAAgBY,WAAW,EAAE;gBAGTZ,6BAA2CA;YAFxE,wEAAwE;YACxEF,iBAAiBS,OAAO,GACtBnB,cAAc,aAAaY,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,CAAAA,8BAAAA,eAAgBY,WAAW,AAAXA,MAAW,QAA3BZ,gCAAAA,KAAAA,IAAAA,KAAAA,IAAAA,4BAA6Ba,WAAW,GAAGb,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,CAAAA,+BAAAA,eAAgBY,WAAW,AAAXA,MAAW,QAA3BZ,iCAAAA,KAAAA,IAAAA,KAAAA,IAAAA,6BAA6Bc,UAAU;QACjH;QACA;;OAEC,GACD,MAAMC,SAASC,KAAKC,IAAI,CAACnB,iBAAiBS,OAAO,GAAGpB,kBAAkB;QAEtE;;;OAGC,GACD,MAAM+B,iBAAiB7B,gBAAAA,QAAAA,gBAAAA,KAAAA,IAAAA,cAAe2B,KAAKG,GAAG,CAACH,KAAKC,IAAI,CAACF,SAAS,IAAI;QAEtE;;OAEC,GACD,MAAMK,gBAAgB9B,eAAAA,QAAAA,eAAAA,KAAAA,IAAAA,aAAc0B,KAAKG,GAAG,CAAChC,kBAAkB,KAAK;QAEpE,MAAMkC,cAAcN,SAASG,iBAAiB;QAE9C1B,SAAS;YACPG,mBAAmB0B;YACnBxB,cAAcqB;YACdtB,aAAawB;QACf;IACF,GACA;QAAC/B;QAAaC;QAAYH;QAAiBC;QAAWY,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAAgBQ,IAAI;QAAER,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAAgBY,WAAW;KAAC;IAG1G,MAAMN,YAAYgB,IAAAA,mDAAAA,EAA8BpB;IAEhD,OAAO;QACLP;QACAN,aAAaQ;QACbP,YAAYM;QACZU;QACAR;IACF;AACF"}

package/lib-commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.ts"],"sourcesContent":["export {\n  Virtualizer,\n  virtualizerClassNames,\n  useVirtualizer_unstable,\n  renderVirtualizer_unstable,\n  useVirtualizerStyles_unstable,\n} from './Virtualizer';\n\nexport type {\n  VirtualizerProps,\n  VirtualizerState,\n  VirtualizerSlots,\n  VirtualizerChildRenderFunction,\n  VirtualizerDataRef,\n} from './Virtualizer';\n\nexport {\n  useIntersectionObserver,\n  useStaticVirtualizerMeasure,\n  useDynamicVirtualizerMeasure,\n  useResizeObserverRef_unstable,\n  useMeasureList,\n} from './Hooks';\n\nexport type {\n  ResizeCallbackWithRef,\n  VirtualizerMeasureDynamicProps,\n  VirtualizerMeasureProps,\n  IndexedResizeCallbackElement,\n} from './Hooks';\n\nexport type { ScrollToItemDynamicParams, ScrollToItemStaticParams, ScrollToInterface } from './Utilities';\n\nexport {\n  VirtualizerContextProvider,\n  useVirtualizerContext_unstable,\n  scrollToItemStatic,\n  scrollToItemDynamic,\n} from './Utilities';\n\nexport type { VirtualizerContextProps, DynamicVirtualizerContextProps } from './Utilities';\n\nexport {\n  VirtualizerScrollView,\n  virtualizerScrollViewClassNames,\n  useVirtualizerScrollView_unstable,\n  renderVirtualizerScrollView_unstable,\n  useVirtualizerScrollViewStyles_unstable,\n} from './VirtualizerScrollView';\n\nexport type {\n  VirtualizerScrollViewProps,\n  VirtualizerScrollViewState,\n  VirtualizerScrollViewSlots,\n} from './VirtualizerScrollView';\n\nexport {\n  VirtualizerScrollViewDynamic,\n  virtualizerScrollViewDynamicClassNames,\n  useVirtualizerScrollViewDynamic_unstable,\n  renderVirtualizerScrollViewDynamic_unstable,\n  useVirtualizerScrollViewDynamicStyles_unstable,\n} from './VirtualizerScrollViewDynamic';\n\nexport type {\n  VirtualizerScrollViewDynamicProps,\n  VirtualizerScrollViewDynamicState,\n  VirtualizerScrollViewDynamicSlots,\n} from './VirtualizerScrollViewDynamic';\n"],"names":["Virtualizer","VirtualizerContextProvider","VirtualizerScrollView","VirtualizerScrollViewDynamic","renderVirtualizerScrollViewDynamic_unstable","renderVirtualizerScrollView_unstable","renderVirtualizer_unstable","scrollToItemDynamic","scrollToItemStatic","useDynamicVirtualizerMeasure","useIntersectionObserver","useMeasureList","useResizeObserverRef_unstable","useStaticVirtualizerMeasure","useVirtualizerContext_unstable","useVirtualizerScrollViewDynamicStyles_unstable","useVirtualizerScrollViewDynamic_unstable","useVirtualizerScrollViewStyles_unstable","useVirtualizerScrollView_unstable","useVirtualizerStyles_unstable","useVirtualizer_unstable","virtualizerClassNames","virtualizerScrollViewClassNames","virtualizerScrollViewDynamicClassNames"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IACEA,WAAW;eAAXA,wBAAW;;IAiCXC,0BAA0B;eAA1BA,qCAA0B;;IAS1BC,qBAAqB;eAArBA,4CAAqB;;IAcrBC,4BAA4B;eAA5BA,0DAA4B;;IAG5BC,2CAA2C;eAA3CA,yEAA2C;;IAd3CC,oCAAoC;eAApCA,2DAAoC;;IA1CpCC,0BAA0B;eAA1BA,uCAA0B;;IAiC1BC,mBAAmB;eAAnBA,8BAAmB;;IADnBC,kBAAkB;eAAlBA,6BAAkB;;IAjBlBC,4BAA4B;eAA5BA,mCAA4B;;IAF5BC,uBAAuB;eAAvBA,8BAAuB;;IAIvBC,cAAc;eAAdA,qBAAc;;IADdC,6BAA6B;eAA7BA,oCAA6B;;IAF7BC,2BAA2B;eAA3BA,kCAA2B;;IAiB3BC,8BAA8B;eAA9BA,yCAA8B;;IA0B9BC,8CAA8C;eAA9CA,4EAA8C;;IAF9CC,wCAAwC;eAAxCA,sEAAwC;;IAZxCC,uCAAuC;eAAvCA,8DAAuC;;IAFvCC,iCAAiC;eAAjCA,wDAAiC;;IAxCjCC,6BAA6B;eAA7BA,0CAA6B;;IAF7BC,uBAAuB;eAAvBA,oCAAuB;;IADvBC,qBAAqB;eAArBA,kCAAqB;;IA0CrBC,+BAA+B;eAA/BA,sDAA+B;;IAc/BC,sCAAsC;eAAtCA,oEAAsC;;;6BApDjC;uBAgBA;2BAgBA;uCAUA;8CAcA"}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export {\n  Virtualizer,\n  virtualizerClassNames,\n  useVirtualizer_unstable,\n  renderVirtualizer_unstable,\n  useVirtualizerStyles_unstable,\n} from './Virtualizer';\n\nexport type {\n  VirtualizerProps,\n  VirtualizerState,\n  VirtualizerSlots,\n  VirtualizerChildRenderFunction,\n  VirtualizerDataRef,\n} from './Virtualizer';\n\nexport {\n  useIntersectionObserver,\n  useStaticVirtualizerMeasure,\n  useDynamicVirtualizerMeasure,\n  useResizeObserverRef_unstable,\n  useMeasureList,\n} from './Hooks';\n\nexport type {\n  ResizeCallbackWithRef,\n  VirtualizerMeasureDynamicProps,\n  VirtualizerMeasureProps,\n  IndexedResizeCallbackElement,\n} from './Hooks';\n\nexport type { ScrollToItemDynamicParams, ScrollToItemStaticParams, ScrollToInterface } from './Utilities';\n\nexport {\n  VirtualizerContextProvider,\n  useVirtualizerContext_unstable,\n  scrollToItemStatic,\n  scrollToItemDynamic,\n} from './Utilities';\n\nexport type { VirtualizerContextProps, DynamicVirtualizerContextProps } from './Utilities';\n\nexport {\n  VirtualizerScrollView,\n  virtualizerScrollViewClassNames,\n  useVirtualizerScrollView_unstable,\n  renderVirtualizerScrollView_unstable,\n  useVirtualizerScrollViewStyles_unstable,\n} from './VirtualizerScrollView';\n\nexport type {\n  VirtualizerScrollViewProps,\n  VirtualizerScrollViewState,\n  VirtualizerScrollViewSlots,\n} from './VirtualizerScrollView';\n\nexport {\n  VirtualizerScrollViewDynamic,\n  virtualizerScrollViewDynamicClassNames,\n  useVirtualizerScrollViewDynamic_unstable,\n  renderVirtualizerScrollViewDynamic_unstable,\n  useVirtualizerScrollViewDynamicStyles_unstable,\n} from './VirtualizerScrollViewDynamic';\n\nexport type {\n  VirtualizerScrollViewDynamicProps,\n  VirtualizerScrollViewDynamicState,\n  VirtualizerScrollViewDynamicSlots,\n} from './VirtualizerScrollViewDynamic';\n"],"names":["Virtualizer","VirtualizerContextProvider","VirtualizerScrollView","VirtualizerScrollViewDynamic","renderVirtualizerScrollViewDynamic_unstable","renderVirtualizerScrollView_unstable","renderVirtualizer_unstable","scrollToItemDynamic","scrollToItemStatic","useDynamicVirtualizerMeasure","useIntersectionObserver","useMeasureList","useResizeObserverRef_unstable","useStaticVirtualizerMeasure","useVirtualizerContext_unstable","useVirtualizerScrollViewDynamicStyles_unstable","useVirtualizerScrollViewDynamic_unstable","useVirtualizerScrollViewStyles_unstable","useVirtualizerScrollView_unstable","useVirtualizerStyles_unstable","useVirtualizer_unstable","virtualizerClassNames","virtualizerScrollViewClassNames","virtualizerScrollViewDynamicClassNames"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IACEA,WAAW;eAAXA,wBAAW;;IAiCXC,0BAA0B;eAA1BA,qCAA0B;;IAS1BC,qBAAqB;eAArBA,4CAAqB;;IAcrBC,4BAA4B;eAA5BA,0DAA4B;;IAG5BC,2CAA2C;eAA3CA,yEAA2C;;IAd3CC,oCAAoC;eAApCA,2DAAoC;;IA1CpCC,0BAA0B;eAA1BA,uCAA0B;;IAiC1BC,mBAAmB;eAAnBA,8BAAmB;;IADnBC,kBAAkB;eAAlBA,6BAAkB;;IAjBlBC,4BAA4B;eAA5BA,mCAA4B;;IAF5BC,uBAAuB;eAAvBA,8BAAuB;;IAIvBC,cAAc;eAAdA,qBAAc;;IADdC,6BAA6B;eAA7BA,oCAA6B;;IAF7BC,2BAA2B;eAA3BA,kCAA2B;;IAiB3BC,8BAA8B;eAA9BA,yCAA8B;;IA0B9BC,8CAA8C;eAA9CA,4EAA8C;;IAF9CC,wCAAwC;eAAxCA,sEAAwC;;IAZxCC,uCAAuC;eAAvCA,8DAAuC;;IAFvCC,iCAAiC;eAAjCA,wDAAiC;;IAxCjCC,6BAA6B;eAA7BA,0CAA6B;;IAF7BC,uBAAuB;eAAvBA,oCAAuB;;IADvBC,qBAAqB;eAArBA,kCAAqB;;IA0CrBC,+BAA+B;eAA/BA,sDAA+B;;IAc/BC,sCAAsC;eAAtCA,oEAAsC;;;6BApDjC;uBAgBA;2BAgBA;uCAUA;8CAcA"}

package/lib-commonjs/utilities/ImperativeScrolling/imperativeScrolling.js.map

@@ -1 +1 @@
-{"version":3,"sources":["imperativeScrolling.ts"],"sourcesContent":["import { ScrollToItemStaticParams } from './imperativeScrolling.types';\n\nexport const scrollToItemStatic = (params: ScrollToItemStaticParams) => {\n  const { index, itemSize, totalItems, scrollViewRef, axis = 'vertical', reversed = false, behavior = 'auto' } = params;\n\n  if (axis === 'horizontal') {\n    if (reversed) {\n      scrollViewRef.current?.scrollTo({\n        left: totalItems * itemSize - itemSize * index,\n        behavior,\n      });\n    } else {\n      scrollViewRef.current?.scrollTo({\n        left: itemSize * index,\n        behavior,\n      });\n    }\n  } else {\n    if (reversed) {\n      scrollViewRef.current?.scrollTo({\n        top: totalItems * itemSize - itemSize * index,\n        behavior,\n      });\n    } else {\n      scrollViewRef.current?.scrollTo({\n        top: itemSize * index,\n        behavior,\n      });\n    }\n  }\n};\n"],"names":["scrollToItemStatic","params","index","itemSize","totalItems","scrollViewRef","axis","reversed","behavior","current","scrollTo","left","top"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAEaA;;;eAAAA;;;AAAN,MAAMA,qBAAqB,CAACC;IACjC,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAEC,UAAU,EAAEC,aAAa,EAAEC,OAAO,UAAU,EAAEC,WAAW,KAAK,EAAEC,WAAW,MAAM,EAAE,GAAGP;IAE/G,IAAIK,SAAS,cAAc;QACzB,IAAIC,UAAU;gBACZF;YAAAA,CAAAA,yBAAAA,cAAcI,OAAO,AAAPA,MAAO,QAArBJ,2BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,uBAAuBK,QAAQ,CAAC;gBAC9BC,MAAMP,aAAaD,WAAWA,WAAWD;gBACzCM;YACF;QACF,OAAO;gBACLH;YAAAA,CAAAA,0BAAAA,cAAcI,OAAO,AAAPA,MAAO,QAArBJ,4BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,wBAAuBK,QAAQ,CAAC;gBAC9BC,MAAMR,WAAWD;gBACjBM;YACF;QACF;IACF,OAAO;QACL,IAAID,UAAU;gBACZF;YAAAA,CAAAA,0BAAAA,cAAcI,OAAO,AAAPA,MAAO,QAArBJ,4BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,wBAAuBK,QAAQ,CAAC;gBAC9BE,KAAKR,aAAaD,WAAWA,WAAWD;gBACxCM;YACF;QACF,OAAO;gBACLH;YAAAA,CAAAA,0BAAAA,cAAcI,OAAO,AAAPA,MAAO,QAArBJ,4BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,wBAAuBK,QAAQ,CAAC;gBAC9BE,KAAKT,WAAWD;gBAChBM;YACF;QACF;IACF;AACF"}
+{"version":3,"sources":["../src/utilities/ImperativeScrolling/imperativeScrolling.ts"],"sourcesContent":["import { ScrollToItemStaticParams } from './imperativeScrolling.types';\n\nexport const scrollToItemStatic = (params: ScrollToItemStaticParams) => {\n  const { index, itemSize, totalItems, scrollViewRef, axis = 'vertical', reversed = false, behavior = 'auto' } = params;\n\n  if (axis === 'horizontal') {\n    if (reversed) {\n      scrollViewRef.current?.scrollTo({\n        left: totalItems * itemSize - itemSize * index,\n        behavior,\n      });\n    } else {\n      scrollViewRef.current?.scrollTo({\n        left: itemSize * index,\n        behavior,\n      });\n    }\n  } else {\n    if (reversed) {\n      scrollViewRef.current?.scrollTo({\n        top: totalItems * itemSize - itemSize * index,\n        behavior,\n      });\n    } else {\n      scrollViewRef.current?.scrollTo({\n        top: itemSize * index,\n        behavior,\n      });\n    }\n  }\n};\n"],"names":["scrollToItemStatic","params","index","itemSize","totalItems","scrollViewRef","axis","reversed","behavior","current","scrollTo","left","top"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAEaA;;;eAAAA;;;AAAN,MAAMA,qBAAqB,CAACC;IACjC,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAEC,UAAU,EAAEC,aAAa,EAAEC,OAAO,UAAU,EAAEC,WAAW,KAAK,EAAEC,WAAW,MAAM,EAAE,GAAGP;IAE/G,IAAIK,SAAS,cAAc;QACzB,IAAIC,UAAU;gBACZF;YAAAA,CAAAA,yBAAAA,cAAcI,OAAO,AAAPA,MAAO,QAArBJ,2BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,uBAAuBK,QAAQ,CAAC;gBAC9BC,MAAMP,aAAaD,WAAWA,WAAWD;gBACzCM;YACF;QACF,OAAO;gBACLH;YAAAA,CAAAA,0BAAAA,cAAcI,OAAO,AAAPA,MAAO,QAArBJ,4BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,wBAAuBK,QAAQ,CAAC;gBAC9BC,MAAMR,WAAWD;gBACjBM;YACF;QACF;IACF,OAAO;QACL,IAAID,UAAU;gBACZF;YAAAA,CAAAA,0BAAAA,cAAcI,OAAO,AAAPA,MAAO,QAArBJ,4BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,wBAAuBK,QAAQ,CAAC;gBAC9BE,KAAKR,aAAaD,WAAWA,WAAWD;gBACxCM;YACF;QACF,OAAO;gBACLH;YAAAA,CAAAA,0BAAAA,cAAcI,OAAO,AAAPA,MAAO,QAArBJ,4BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,wBAAuBK,QAAQ,CAAC;gBAC9BE,KAAKT,WAAWD;gBAChBM;YACF;QACF;IACF;AACF"}

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

@@ -2,3 +2,5 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));

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

@@ -1 +1 @@
-{"version":3,"sources":["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":""}
+{"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":[],"rangeMappings":";;;;;","mappings":";;;;;iEAAuB"}

package/lib-commonjs/utilities/ImperativeScrolling/imperativeScrollingDynamic.js.map

@@ -1 +1 @@
-{"version":3,"sources":["imperativeScrollingDynamic.ts"],"sourcesContent":["import { ScrollToItemDynamicParams } from './imperativeScrolling.types';\n\nexport const scrollToItemDynamic = (params: ScrollToItemDynamicParams) => {\n  const { index, itemSizes, totalSize, scrollViewRef, axis = 'vertical', reversed = false, behavior = 'auto' } = params;\n  if (!itemSizes.current) {\n    return;\n  }\n\n  if (itemSizes.current === null || itemSizes.current.length < index) {\n    // null check - abort\n    return;\n  }\n\n  let itemDepth = 0;\n  for (let i = 0; i < index; i++) {\n    if (i < index) {\n      itemDepth += itemSizes.current[i];\n    }\n  }\n\n  if (axis === 'horizontal') {\n    if (reversed) {\n      scrollViewRef.current?.scrollTo({\n        left: totalSize - itemDepth,\n        behavior,\n      });\n    } else {\n      scrollViewRef.current?.scrollTo({\n        left: itemDepth,\n        behavior,\n      });\n    }\n  } else {\n    if (reversed) {\n      scrollViewRef.current?.scrollTo({\n        top: totalSize - itemDepth,\n        behavior,\n      });\n    } else {\n      scrollViewRef.current?.scrollTo({\n        top: itemDepth,\n        behavior,\n      });\n    }\n  }\n};\n"],"names":["scrollToItemDynamic","params","index","itemSizes","totalSize","scrollViewRef","axis","reversed","behavior","current","length","itemDepth","i","scrollTo","left","top"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAEaA;;;eAAAA;;;AAAN,MAAMA,sBAAsB,CAACC;IAClC,MAAM,EAAEC,KAAK,EAAEC,SAAS,EAAEC,SAAS,EAAEC,aAAa,EAAEC,OAAO,UAAU,EAAEC,WAAW,KAAK,EAAEC,WAAW,MAAM,EAAE,GAAGP;IAC/G,IAAI,CAACE,UAAUM,OAAO,EAAE;QACtB;IACF;IAEA,IAAIN,UAAUM,OAAO,KAAK,QAAQN,UAAUM,OAAO,CAACC,MAAM,GAAGR,OAAO;QAClE,qBAAqB;QACrB;IACF;IAEA,IAAIS,YAAY;IAChB,IAAK,IAAIC,IAAI,GAAGA,IAAIV,OAAOU,IAAK;QAC9B,IAAIA,IAAIV,OAAO;YACbS,aAAaR,UAAUM,OAAO,CAACG,EAAE;QACnC;IACF;IAEA,IAAIN,SAAS,cAAc;QACzB,IAAIC,UAAU;gBACZF;YAAAA,CAAAA,yBAAAA,cAAcI,OAAO,AAAPA,MAAO,QAArBJ,2BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,uBAAuBQ,QAAQ,CAAC;gBAC9BC,MAAMV,YAAYO;gBAClBH;YACF;QACF,OAAO;gBACLH;YAAAA,CAAAA,0BAAAA,cAAcI,OAAO,AAAPA,MAAO,QAArBJ,4BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,wBAAuBQ,QAAQ,CAAC;gBAC9BC,MAAMH;gBACNH;YACF;QACF;IACF,OAAO;QACL,IAAID,UAAU;gBACZF;YAAAA,CAAAA,0BAAAA,cAAcI,OAAO,AAAPA,MAAO,QAArBJ,4BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,wBAAuBQ,QAAQ,CAAC;gBAC9BE,KAAKX,YAAYO;gBACjBH;YACF;QACF,OAAO;gBACLH;YAAAA,CAAAA,0BAAAA,cAAcI,OAAO,AAAPA,MAAO,QAArBJ,4BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,wBAAuBQ,QAAQ,CAAC;gBAC9BE,KAAKJ;gBACLH;YACF;QACF;IACF;AACF"}
+{"version":3,"sources":["../src/utilities/ImperativeScrolling/imperativeScrollingDynamic.ts"],"sourcesContent":["import { ScrollToItemDynamicParams } from './imperativeScrolling.types';\n\nexport const scrollToItemDynamic = (params: ScrollToItemDynamicParams) => {\n  const { index, itemSizes, totalSize, scrollViewRef, axis = 'vertical', reversed = false, behavior = 'auto' } = params;\n  if (!itemSizes.current) {\n    return;\n  }\n\n  if (itemSizes.current === null || itemSizes.current.length < index) {\n    // null check - abort\n    return;\n  }\n\n  let itemDepth = 0;\n  for (let i = 0; i < index; i++) {\n    if (i < index) {\n      itemDepth += itemSizes.current[i];\n    }\n  }\n\n  if (axis === 'horizontal') {\n    if (reversed) {\n      scrollViewRef.current?.scrollTo({\n        left: totalSize - itemDepth,\n        behavior,\n      });\n    } else {\n      scrollViewRef.current?.scrollTo({\n        left: itemDepth,\n        behavior,\n      });\n    }\n  } else {\n    if (reversed) {\n      scrollViewRef.current?.scrollTo({\n        top: totalSize - itemDepth,\n        behavior,\n      });\n    } else {\n      scrollViewRef.current?.scrollTo({\n        top: itemDepth,\n        behavior,\n      });\n    }\n  }\n};\n"],"names":["scrollToItemDynamic","params","index","itemSizes","totalSize","scrollViewRef","axis","reversed","behavior","current","length","itemDepth","i","scrollTo","left","top"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAEaA;;;eAAAA;;;AAAN,MAAMA,sBAAsB,CAACC;IAClC,MAAM,EAAEC,KAAK,EAAEC,SAAS,EAAEC,SAAS,EAAEC,aAAa,EAAEC,OAAO,UAAU,EAAEC,WAAW,KAAK,EAAEC,WAAW,MAAM,EAAE,GAAGP;IAC/G,IAAI,CAACE,UAAUM,OAAO,EAAE;QACtB;IACF;IAEA,IAAIN,UAAUM,OAAO,KAAK,QAAQN,UAAUM,OAAO,CAACC,MAAM,GAAGR,OAAO;QAClE,qBAAqB;QACrB;IACF;IAEA,IAAIS,YAAY;IAChB,IAAK,IAAIC,IAAI,GAAGA,IAAIV,OAAOU,IAAK;QAC9B,IAAIA,IAAIV,OAAO;YACbS,aAAaR,UAAUM,OAAO,CAACG,EAAE;QACnC;IACF;IAEA,IAAIN,SAAS,cAAc;QACzB,IAAIC,UAAU;gBACZF;YAAAA,CAAAA,yBAAAA,cAAcI,OAAO,AAAPA,MAAO,QAArBJ,2BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,uBAAuBQ,QAAQ,CAAC;gBAC9BC,MAAMV,YAAYO;gBAClBH;YACF;QACF,OAAO;gBACLH;YAAAA,CAAAA,0BAAAA,cAAcI,OAAO,AAAPA,MAAO,QAArBJ,4BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,wBAAuBQ,QAAQ,CAAC;gBAC9BC,MAAMH;gBACNH;YACF;QACF;IACF,OAAO;QACL,IAAID,UAAU;gBACZF;YAAAA,CAAAA,0BAAAA,cAAcI,OAAO,AAAPA,MAAO,QAArBJ,4BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,wBAAuBQ,QAAQ,CAAC;gBAC9BE,KAAKX,YAAYO;gBACjBH;YACF;QACF,OAAO;gBACLH;YAAAA,CAAAA,0BAAAA,cAAcI,OAAO,AAAPA,MAAO,QAArBJ,4BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,wBAAuBQ,QAAQ,CAAC;gBAC9BE,KAAKJ;gBACLH;YACF;QACF;IACF;AACF"}

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

@@ -1 +1 @@
-{"version":3,"sources":["index.ts"],"sourcesContent":["export * from './imperativeScrolling';\nexport * from './imperativeScrolling.types';\nexport * from './imperativeScrollingDynamic';\n"],"names":[],"rangeMappings":";;;;;;;","mappings":";;;;;uBAAc;uBACA;uBACA"}
+{"version":3,"sources":["../src/utilities/ImperativeScrolling/index.ts"],"sourcesContent":["export * from './imperativeScrolling';\nexport * from './imperativeScrolling.types';\nexport * from './imperativeScrollingDynamic';\n"],"names":[],"rangeMappings":";;;;;;;","mappings":";;;;;uBAAc;uBACA;uBACA"}

package/lib-commonjs/utilities/VirtualizerContext/VirtualizerContext.js

@@ -28,23 +28,19 @@ const useVirtualizerContext_unstable = ()=>{
 };
 const useVirtualizerContextState_unstable = (passedContext)=>{
     const virtualizerContext = useVirtualizerContext_unstable();
-    const [_contextIndex, _setContextIndex] = (0, _react.useState)(-1);
-    const [_contextPosition, _setContextPosition] = (0, _react.useState)(0);
-    const childProgressiveSizes = (0, _react.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 = (0, _react.useMemo)(()=>{
-        var _passedContext_contextIndex, _ref, _passedContext_setContextIndex, _ref1, _passedContext_contextPosition, _ref2, _passedContext_setContextPosition, _ref3;
+   */ 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,
             setContextIndex: (_ref1 = (_passedContext_setContextIndex = passedContext === null || passedContext === void 0 ? void 0 : passedContext.setContextIndex) !== null && _passedContext_setContextIndex !== void 0 ? _passedContext_setContextIndex : virtualizerContext === null || virtualizerContext === void 0 ? void 0 : virtualizerContext.setContextIndex) !== null && _ref1 !== void 0 ? _ref1 : _setContextIndex,
-            contextPosition: (_ref2 = (_passedContext_contextPosition = passedContext === null || passedContext === void 0 ? void 0 : passedContext.contextPosition) !== null && _passedContext_contextPosition !== void 0 ? _passedContext_contextPosition : virtualizerContext === null || virtualizerContext === void 0 ? void 0 : virtualizerContext.contextPosition) !== null && _ref2 !== void 0 ? _ref2 : _contextPosition,
-            setContextPosition: (_ref3 = (_passedContext_setContextPosition = passedContext === null || passedContext === void 0 ? void 0 : passedContext.setContextPosition) !== null && _passedContext_setContextPosition !== void 0 ? _passedContext_setContextPosition : virtualizerContext === null || virtualizerContext === void 0 ? void 0 : virtualizerContext.setContextPosition) !== null && _ref3 !== void 0 ? _ref3 : _setContextPosition,
             childProgressiveSizes
         };
     }, [
         _contextIndex,
-        _contextPosition,
         passedContext,
         virtualizerContext
     ]);

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

@@ -1 +1 @@
-{"version":3,"sources":["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 [_contextPosition, _setContextPosition] = useState<number>(0);\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      contextPosition: passedContext?.contextPosition ?? virtualizerContext?.contextPosition ?? _contextPosition,\n      setContextPosition:\n        passedContext?.setContextPosition ?? virtualizerContext?.setContextPosition ?? _setContextPosition,\n      childProgressiveSizes,\n    }),\n    [_contextIndex, _contextPosition, passedContext, virtualizerContext],\n  );\n\n  return context;\n};\n"],"names":["VirtualizerContextProvider","useVirtualizerContextState_unstable","useVirtualizerContext_unstable","VirtualizerContext","React","createContext","undefined","Provider","useContext","passedContext","virtualizerContext","_contextIndex","_setContextIndex","useState","_contextPosition","_setContextPosition","childProgressiveSizes","useRef","context","useMemo","contextIndex","setContextIndex","contextPosition","setContextPosition"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAQaA,0BAAAA;eAAAA;;IAMAC,mCAAAA;eAAAA;;IAJAC,8BAAAA;eAAAA;;;;iEAVU;AAIvB,MAAMC,mCAAqBC,OAAMC,aAAa,CAC5CC;AAGK,MAAMN,6BAA6BG,mBAAmBI,QAAQ;AAE9D,MAAML,iCAAiC;IAC5C,OAAOE,OAAMI,UAAU,CAACL;AAC1B;AAEO,MAAMF,sCAAsC,CACjDQ;IAEA,MAAMC,qBAAqBR;IAC3B,MAAM,CAACS,eAAeC,iBAAiB,GAAGC,IAAAA,eAAAA,EAAiB,CAAC;IAC5D,MAAM,CAACC,kBAAkBC,oBAAoB,GAAGF,IAAAA,eAAAA,EAAiB;IACjE,MAAMG,wBAAwBC,IAAAA,aAAAA,EAAiB,EAAE;IAEjD;;GAEC,GACD,MAAMC,UAAUC,IAAAA,cAAAA,EACd;YACgBV,6BAAAA,MACGA,gCAAAA,OACAA,gCAAAA,OAEfA,mCAAAA;eALG;YACLW,cAAcX,CAAAA,OAAAA,CAAAA,8BAAAA,kBAAAA,QAAAA,kBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,cAAeW,YAAY,AAAZA,MAAY,QAA3BX,gCAAAA,KAAAA,IAAAA,8BAA+BC,uBAAAA,QAAAA,uBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,mBAAoBU,YAAY,AAAZA,MAAY,QAA/DX,SAAAA,KAAAA,IAAAA,OAAmEE;YACjFU,iBAAiBZ,CAAAA,QAAAA,CAAAA,iCAAAA,kBAAAA,QAAAA,kBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,cAAeY,eAAe,AAAfA,MAAe,QAA9BZ,mCAAAA,KAAAA,IAAAA,iCAAkCC,uBAAAA,QAAAA,uBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,mBAAoBW,eAAe,AAAfA,MAAe,QAArEZ,UAAAA,KAAAA,IAAAA,QAAyEG;YAC1FU,iBAAiBb,CAAAA,QAAAA,CAAAA,iCAAAA,kBAAAA,QAAAA,kBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,cAAea,eAAe,AAAfA,MAAe,QAA9Bb,mCAAAA,KAAAA,IAAAA,iCAAkCC,uBAAAA,QAAAA,uBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,mBAAoBY,eAAe,AAAfA,MAAe,QAArEb,UAAAA,KAAAA,IAAAA,QAAyEK;YAC1FS,oBACEd,CAAAA,QAAAA,CAAAA,oCAAAA,kBAAAA,QAAAA,kBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,cAAec,kBAAkB,AAAlBA,MAAkB,QAAjCd,sCAAAA,KAAAA,IAAAA,oCAAqCC,uBAAAA,QAAAA,uBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,mBAAoBa,kBAAkB,AAAlBA,MAAkB,QAA3Ed,UAAAA,KAAAA,IAAAA,QAA+EM;YACjFC;QACF;IAAA,GACA;QAACL;QAAeG;QAAkBL;QAAeC;KAAmB;IAGtE,OAAOQ;AACT"}
+{"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":["VirtualizerContextProvider","useVirtualizerContextState_unstable","useVirtualizerContext_unstable","VirtualizerContext","React","createContext","undefined","Provider","useContext","passedContext","virtualizerContext","_contextIndex","_setContextIndex","useState","childProgressiveSizes","useRef","context","useMemo","contextIndex","setContextIndex"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAOaA,0BAAAA;eAAAA;;IAMAC,mCAAAA;eAAAA;;IAJAC,8BAAAA;eAAAA;;;;iEATU;AAGvB,MAAMC,mCAAqBC,OAAMC,aAAa,CAC5CC;AAGK,MAAMN,6BAA6BG,mBAAmBI,QAAQ;AAE9D,MAAML,iCAAiC;IAC5C,OAAOE,OAAMI,UAAU,CAACL;AAC1B;AAEO,MAAMF,sCAAsC,CACjDQ;IAEA,MAAMC,qBAAqBR;IAC3B,MAAM,CAACS,eAAeC,iBAAiB,GAAGR,OAAMS,QAAQ,CAAS,CAAC;IAClE,MAAMC,wBAAwBV,OAAMW,MAAM,CAAW,EAAE;IAEvD;;GAEC,GACD,MAAMC,UAAUZ,OAAMa,OAAO,CAC3B;YACgBR,6BAAAA,MACGA,gCAAAA;eAFZ;YACLS,cAAcT,CAAAA,OAAAA,CAAAA,8BAAAA,kBAAAA,QAAAA,kBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,cAAeS,YAAY,AAAZA,MAAY,QAA3BT,gCAAAA,KAAAA,IAAAA,8BAA+BC,uBAAAA,QAAAA,uBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,mBAAoBQ,YAAY,AAAZA,MAAY,QAA/DT,SAAAA,KAAAA,IAAAA,OAAmEE;YACjFQ,iBAAiBV,CAAAA,QAAAA,CAAAA,iCAAAA,kBAAAA,QAAAA,kBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,cAAeU,eAAe,AAAfA,MAAe,QAA9BV,mCAAAA,KAAAA,IAAAA,iCAAkCC,uBAAAA,QAAAA,uBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,mBAAoBS,eAAe,AAAfA,MAAe,QAArEV,UAAAA,KAAAA,IAAAA,QAAyEG;YAC1FE;QACF;IAAA,GACA;QAACH;QAAeF;QAAeC;KAAmB;IAGpD,OAAOM;AACT"}

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

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

package/lib-commonjs/utilities/VirtualizerContext/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["types.ts"],"sourcesContent":["import * as React from 'react';\n/**\n * {@docCategory Virtualizer}\n */\nexport type VirtualizerContextProps = {\n  contextIndex: number;\n  setContextIndex: (index: number) => void;\n  /*\n   * These option props are used in dynamic virtualizer\n   */\n  contextPosition?: number;\n  setContextPosition?: (index: number) => void;\n  childProgressiveSizes?: React.MutableRefObject<number[]>;\n};\n\n/**\n * Some props are optional on static virtualizer, but required for dynamic.\n */\nexport type DynamicVirtualizerContextProps = Required<VirtualizerContextProps>;\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;iEAAuB"}
+{"version":3,"sources":["../src/utilities/VirtualizerContext/types.ts"],"sourcesContent":["import * as React from 'react';\n/**\n * {@docCategory Virtualizer}\n */\nexport type VirtualizerContextProps = {\n  contextIndex: number;\n  setContextIndex: (index: number) => void;\n  /*\n   * These optional props are used in dynamic virtualizer\n   */\n  childProgressiveSizes?: React.MutableRefObject<number[]>;\n};\n\n/**\n * Some props are optional on static virtualizer, but required for dynamic.\n */\nexport type DynamicVirtualizerContextProps = Required<VirtualizerContextProps>;\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;iEAAuB"}

package/lib-commonjs/utilities/createResizeObserverFromDocument.js.map

@@ -1 +1 @@
-{"version":3,"sources":["createResizeObserverFromDocument.ts"],"sourcesContent":["/**\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":["createResizeObserverFromDocument","targetDocument","callback","defaultView","ResizeObserver"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;;;;;CAMC;;;;+BACeA;;;eAAAA;;;AAAT,SAASA,iCACdC,cAA2C,EAC3CC,QAAgC;QAE3BD;IAAL,IAAI,CAACA,CAAAA,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,CAAAA,8BAAAA,eAAgBE,WAAW,AAAXA,MAAW,QAA3BF,gCAAAA,KAAAA,IAAAA,KAAAA,IAAAA,4BAA6BG,cAAc,AAAdA,GAAgB;QAChD,OAAO;IACT;IAEA,OAAO,IAAIH,eAAeE,WAAW,CAACC,cAAc,CAACF;AACvD"}
+{"version":3,"sources":["../src/utilities/createResizeObserverFromDocument.ts"],"sourcesContent":["/**\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":["createResizeObserverFromDocument","targetDocument","callback","defaultView","ResizeObserver"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;;;;;CAMC;;;;+BACeA;;;eAAAA;;;AAAT,SAASA,iCACdC,cAA2C,EAC3CC,QAAgC;QAE3BD;IAAL,IAAI,CAACA,CAAAA,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,CAAAA,8BAAAA,eAAgBE,WAAW,AAAXA,MAAW,QAA3BF,gCAAAA,KAAAA,IAAAA,KAAAA,IAAAA,4BAA6BG,cAAc,AAAdA,GAAgB;QAChD,OAAO;IACT;IAEA,OAAO,IAAIH,eAAeE,WAAW,CAACC,cAAc,CAACF;AACvD"}

package/lib-commonjs/utilities/debounce.js.map

@@ -1 +1 @@
-{"version":3,"sources":["debounce.ts"],"sourcesContent":["/**\n * Microtask debouncer\n * https://developer.mozilla.org/en-US/docs/Web/API/HTML_DOM_API/Microtask_guide\n * @param fn - Function to debounce\n * @returns debounced function\n */\nexport function debounce(fn: Function) {\n  let pending: boolean;\n  return () => {\n    if (!pending) {\n      pending = true;\n      queueMicrotask(() => {\n        // Need to set pending to `false` before the debounced function is run.\n        // React can actually interrupt the function while it's running!\n        pending = false;\n        fn();\n      });\n    }\n  };\n}\n"],"names":["debounce","fn","pending","queueMicrotask"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;;;;CAKC;;;;+BACeA;;;eAAAA;;;AAAT,SAASA,SAASC,EAAY;IACnC,IAAIC;IACJ,OAAO;QACL,IAAI,CAACA,SAAS;YACZA,UAAU;YACVC,eAAe;gBACb,uEAAuE;gBACvE,gEAAgE;gBAChED,UAAU;gBACVD;YACF;QACF;IACF;AACF"}
+{"version":3,"sources":["../src/utilities/debounce.ts"],"sourcesContent":["/**\n * Microtask debouncer\n * https://developer.mozilla.org/en-US/docs/Web/API/HTML_DOM_API/Microtask_guide\n * @param fn - Function to debounce\n * @returns debounced function\n */\nexport function debounce(fn: Function) {\n  let pending: boolean;\n  return () => {\n    if (!pending) {\n      pending = true;\n      queueMicrotask(() => {\n        // Need to set pending to `false` before the debounced function is run.\n        // React can actually interrupt the function while it's running!\n        pending = false;\n        fn();\n      });\n    }\n  };\n}\n"],"names":["debounce","fn","pending","queueMicrotask"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;;;;CAKC;;;;+BACeA;;;eAAAA;;;AAAT,SAASA,SAASC,EAAY;IACnC,IAAIC;IACJ,OAAO;QACL,IAAI,CAACA,SAAS;YACZA,UAAU;YACVC,eAAe;gBACb,uEAAuE;gBACvE,gEAAgE;gBAChED,UAAU;gBACVD;YACF;QACF;IACF;AACF"}

package/lib-commonjs/utilities/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.ts"],"sourcesContent":["export * from './VirtualizerContext';\nexport * from './ImperativeScrolling';\n"],"names":[],"rangeMappings":";;;;;;","mappings":";;;;;uBAAc;uBACA"}
+{"version":3,"sources":["../src/utilities/index.ts"],"sourcesContent":["export * from './VirtualizerContext';\nexport * from './ImperativeScrolling';\n"],"names":[],"rangeMappings":";;;;;;","mappings":";;;;;uBAAc;uBACA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluentui/react-virtualizer",
-  "version": "9.0.0-alpha.86",
+  "version": "9.0.0-alpha.88",
   "description": "Generic and composable virtualizer framework built on browser intersection observer",
   "main": "lib-commonjs/index.js",
   "module": "lib/index.js",
@@ -11,29 +11,16 @@
     "url": "https://github.com/microsoft/fluentui"
   },
   "license": "MIT",
-  "scripts": {
-    "build": "just-scripts build",
-    "clean": "just-scripts clean",
-    "code-style": "just-scripts code-style",
-    "just": "just-scripts",
-    "lint": "just-scripts lint",
-    "test": "jest --passWithNoTests",
-    "storybook": "yarn --cwd ../stories storybook",
-    "start": "yarn storybook",
-    "generate-api": "just-scripts generate-api",
-    "type-check": "just-scripts type-check"
-  },
   "devDependencies": {
     "@fluentui/eslint-plugin": "*",
     "@fluentui/react-conformance": "*",
     "@fluentui/react-conformance-griffel": "*",
-    "@fluentui/scripts-api-extractor": "*",
-    "@fluentui/scripts-tasks": "*"
+    "@fluentui/scripts-api-extractor": "*"
   },
   "dependencies": {
-    "@fluentui/react-jsx-runtime": "^9.0.45",
-    "@fluentui/react-utilities": "^9.18.16",
-    "@fluentui/react-shared-contexts": "^9.20.2",
+    "@fluentui/react-jsx-runtime": "^9.0.47",
+    "@fluentui/react-utilities": "^9.18.18",
+    "@fluentui/react-shared-contexts": "^9.21.1",
     "@griffel/react": "^1.5.22",
     "@swc/helpers": "^0.5.1"
   },