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

package/lib-commonjs/hooks/useDynamicVirtualizerMeasure.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useDynamicVirtualizerMeasure", {
+    enumerable: true,
+    get: function() {
+        return useDynamicVirtualizerMeasure;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _reactutilities = require("@fluentui/react-utilities");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useResizeObserverRef = require("./useResizeObserverRef");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const useDynamicVirtualizerMeasure = (virtualizerProps)=>{
+    const { defaultItemSize, direction = 'vertical', numItems, getItemSize, bufferItems, bufferSize, virtualizerContext } = virtualizerProps;
+    const [state, setState] = _react.useState({
+        virtualizerLength: 0,
+        virtualizerBufferItems: 0,
+        virtualizerBufferSize: 0
+    });
+    const containerSizeRef = _react.useRef(0);
+    const scrollPosition = _react.useRef(0);
+    const { virtualizerLength, virtualizerBufferItems, virtualizerBufferSize } = state;
+    const { targetDocument } = (0, _reactsharedcontexts.useFluent_unstable)();
+    const container = _react.useRef(null);
+    const handleScrollResize = _react.useCallback((scrollRef)=>{
+        if (!(scrollRef === null || scrollRef === void 0 ? void 0 : scrollRef.current)) {
+            // Error? ignore?
+            return;
+        }
+        if (scrollRef.current !== (targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.body)) {
+            // We have a local scroll container
+            containerSizeRef.current = direction === 'vertical' ? scrollRef === null || scrollRef === void 0 ? void 0 : scrollRef.current.getBoundingClientRect().height : scrollRef === null || scrollRef === void 0 ? void 0 : scrollRef.current.getBoundingClientRect().width;
+        } else if (targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.defaultView) {
+            var _targetDocument_defaultView, _targetDocument_defaultView1;
+            // If our scroll ref is the document body, we should check window height
+            containerSizeRef.current = direction === 'vertical' ? targetDocument === null || targetDocument === void 0 ? void 0 : (_targetDocument_defaultView = targetDocument.defaultView) === null || _targetDocument_defaultView === void 0 ? void 0 : _targetDocument_defaultView.innerHeight : targetDocument === null || targetDocument === void 0 ? void 0 : (_targetDocument_defaultView1 = targetDocument.defaultView) === null || _targetDocument_defaultView1 === void 0 ? void 0 : _targetDocument_defaultView1.innerWidth;
+        }
+        let indexSizer = 0;
+        let i = 0;
+        let length = 0;
+        const startIndex = virtualizerContext.contextIndex;
+        const sizeToBeat = containerSizeRef.current + virtualizerBufferSize * 2;
+        while(indexSizer <= sizeToBeat && i + startIndex < numItems){
+            const iItemSize = getItemSize(startIndex + i);
+            if (virtualizerContext.childProgressiveSizes.current.length < numItems) {
+                /* We are in unknown territory, either an initial render or an update
+            in virtualizer item length has occurred.
+            We need to let the new items render first then we can accurately assess.*/ return virtualizerLength - virtualizerBufferSize * 2;
+            }
+            const currentScrollPos = scrollPosition.current;
+            const currentItemPos = virtualizerContext.childProgressiveSizes.current[startIndex + i] - iItemSize;
+            if (currentScrollPos > currentItemPos + iItemSize) {
+                // The item isn't in view, ignore for now.
+                i++;
+                continue;
+            } else if (currentScrollPos > currentItemPos) {
+                // The item is partially out of view, ignore the out of bounds portion
+                const variance = currentItemPos + iItemSize - currentScrollPos;
+                indexSizer += variance;
+            } else {
+                // Item is in view
+                indexSizer += iItemSize;
+            }
+            // Increment
+            i++;
+            length++;
+        }
+        /*
+       * Number of items to append at each end, i.e. 'preload' each side before entering view.
+       * Minimum: 2 - we give slightly more buffer for dynamic version.
+       */ const newBufferItems = bufferItems !== null && bufferItems !== void 0 ? bufferItems : Math.max(Math.ceil(length / 3), 1);
+        /*
+       * This is how far we deviate into the bufferItems to detect a redraw.
+       */ const newBufferSize = bufferSize !== null && bufferSize !== void 0 ? bufferSize : Math.max(defaultItemSize / 2, 1);
+        const totalLength = length + newBufferItems * 2;
+        setState({
+            virtualizerLength: totalLength,
+            virtualizerBufferSize: newBufferSize,
+            virtualizerBufferItems: newBufferItems
+        });
+    }, [
+        bufferItems,
+        bufferSize,
+        defaultItemSize,
+        direction,
+        getItemSize,
+        numItems,
+        targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.body,
+        targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.defaultView,
+        virtualizerBufferSize,
+        virtualizerContext.childProgressiveSizes,
+        virtualizerContext.contextIndex,
+        virtualizerLength
+    ]);
+    const resizeCallback = _react.useCallback((_entries, // eslint-disable-next-line no-restricted-globals
+    _observer, scrollRef)=>{
+        if (scrollRef) {
+            handleScrollResize(scrollRef);
+        }
+    }, [
+        handleScrollResize
+    ]);
+    const scrollRef = (0, _reactutilities.useMergedRefs)(container, (0, _useResizeObserverRef.useResizeObserverRef_unstable)(resizeCallback));
+    (0, _reactutilities.useIsomorphicLayoutEffect)(()=>{
+        if (virtualizerContext.contextIndex + virtualizerLength < numItems) {
+            // Avoid re-rendering/re-calculating when the end index has already been reached
+            handleScrollResize(container);
+        }
+    }, [
+        handleScrollResize,
+        numItems,
+        virtualizerContext.contextIndex,
+        virtualizerLength
+    ]);
+    const updateScrollPosition = _react.useCallback((_scrollPosition)=>{
+        scrollPosition.current = _scrollPosition;
+        // Check if our vLength's need recalculating
+        handleScrollResize(scrollRef);
+    }, [
+        handleScrollResize,
+        scrollRef
+    ]);
+    return {
+        virtualizerLength,
+        bufferItems: virtualizerBufferItems,
+        bufferSize: virtualizerBufferSize,
+        scrollRef,
+        containerSizeRef,
+        updateScrollPosition
+    };
+};

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/hooks/useDynamicVirtualizerMeasure.ts"],"sourcesContent":["import { useIsomorphicLayoutEffect, useMergedRefs } from '@fluentui/react-utilities';\nimport * as React from 'react';\nimport { VirtualizerMeasureDynamicProps } 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 dynamically to ensure optimized virtualization length.\n */\nexport const useDynamicVirtualizerMeasure = <TElement extends HTMLElement>(\n  virtualizerProps: VirtualizerMeasureDynamicProps,\n): {\n  virtualizerLength: number;\n  bufferItems: number;\n  bufferSize: number;\n  scrollRef: (instance: TElement | null) => void;\n  containerSizeRef: React.RefObject<number>;\n  updateScrollPosition: (scrollPosition: number) => void;\n} => {\n  const {\n    defaultItemSize,\n    direction = 'vertical',\n    numItems,\n    getItemSize,\n    bufferItems,\n    bufferSize,\n    virtualizerContext,\n  } = virtualizerProps;\n\n  const [state, setState] = React.useState({\n    virtualizerLength: 0,\n    virtualizerBufferItems: 0,\n    virtualizerBufferSize: 0,\n  });\n\n  const containerSizeRef = React.useRef<number>(0);\n  const scrollPosition = React.useRef<number>(0);\n  const { virtualizerLength, virtualizerBufferItems, virtualizerBufferSize } = state;\n\n  const { targetDocument } = useFluent();\n  const container = React.useRef<HTMLElement | null>(null);\n  const handleScrollResize = React.useCallback(\n    (scrollRef: React.MutableRefObject<HTMLElement | null>) => {\n      if (!scrollRef?.current) {\n        // Error? ignore?\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      let indexSizer = 0;\n      let i = 0;\n      let length = 0;\n\n      const startIndex = virtualizerContext.contextIndex;\n      const sizeToBeat = containerSizeRef.current + virtualizerBufferSize * 2;\n\n      while (indexSizer <= sizeToBeat && i + startIndex < numItems) {\n        const iItemSize = getItemSize(startIndex + i);\n        if (virtualizerContext.childProgressiveSizes.current.length < numItems) {\n          /* We are in unknown territory, either an initial render or an update\n            in virtualizer item length has occurred.\n            We need to let the new items render first then we can accurately assess.*/\n          return virtualizerLength - virtualizerBufferSize * 2;\n        }\n\n        const currentScrollPos = scrollPosition.current;\n        const currentItemPos = virtualizerContext.childProgressiveSizes.current[startIndex + i] - iItemSize;\n\n        if (currentScrollPos > currentItemPos + iItemSize) {\n          // The item isn't in view, ignore for now.\n          i++;\n          continue;\n        } else if (currentScrollPos > currentItemPos) {\n          // The item is partially out of view, ignore the out of bounds portion\n          const variance = currentItemPos + iItemSize - currentScrollPos;\n          indexSizer += variance;\n        } else {\n          // Item is in view\n          indexSizer += iItemSize;\n        }\n        // Increment\n        i++;\n        length++;\n      }\n\n      /*\n       * Number of items to append at each end, i.e. 'preload' each side before entering view.\n       * Minimum: 2 - we give slightly more buffer for dynamic version.\n       */\n      const newBufferItems = bufferItems ?? Math.max(Math.ceil(length / 3), 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, 1);\n      const totalLength = length + newBufferItems * 2;\n\n      setState({\n        virtualizerLength: totalLength,\n        virtualizerBufferSize: newBufferSize,\n        virtualizerBufferItems: newBufferItems,\n      });\n    },\n    [\n      bufferItems,\n      bufferSize,\n      defaultItemSize,\n      direction,\n      getItemSize,\n      numItems,\n      targetDocument?.body,\n      targetDocument?.defaultView,\n      virtualizerBufferSize,\n      virtualizerContext.childProgressiveSizes,\n      virtualizerContext.contextIndex,\n      virtualizerLength,\n    ],\n  );\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) {\n        handleScrollResize(scrollRef);\n      }\n    },\n    [handleScrollResize],\n  );\n\n  const scrollRef = useMergedRefs(container, useResizeObserverRef_unstable(resizeCallback));\n\n  useIsomorphicLayoutEffect(() => {\n    if (virtualizerContext.contextIndex + virtualizerLength < numItems) {\n      // Avoid re-rendering/re-calculating when the end index has already been reached\n      handleScrollResize(container);\n    }\n  }, [handleScrollResize, numItems, virtualizerContext.contextIndex, virtualizerLength]);\n\n  const updateScrollPosition = React.useCallback(\n    (_scrollPosition: number) => {\n      scrollPosition.current = _scrollPosition;\n      // Check if our vLength's need recalculating\n      handleScrollResize(scrollRef);\n    },\n    [handleScrollResize, scrollRef],\n  );\n\n  return {\n    virtualizerLength,\n    bufferItems: virtualizerBufferItems,\n    bufferSize: virtualizerBufferSize,\n    scrollRef,\n    containerSizeRef,\n    updateScrollPosition,\n  };\n};\n"],"names":["useDynamicVirtualizerMeasure","virtualizerProps","defaultItemSize","direction","numItems","getItemSize","bufferItems","bufferSize","virtualizerContext","state","setState","React","useState","virtualizerLength","virtualizerBufferItems","virtualizerBufferSize","containerSizeRef","useRef","scrollPosition","targetDocument","useFluent","container","handleScrollResize","useCallback","scrollRef","current","body","getBoundingClientRect","height","width","defaultView","innerHeight","innerWidth","indexSizer","i","length","startIndex","contextIndex","sizeToBeat","iItemSize","childProgressiveSizes","currentScrollPos","currentItemPos","variance","newBufferItems","Math","max","ceil","newBufferSize","totalLength","resizeCallback","_entries","_observer","useMergedRefs","useResizeObserverRef_unstable","useIsomorphicLayoutEffect","updateScrollPosition","_scrollPosition"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib-commonjs/hooks/useIntersectionObserver.js

@@ -1,59 +1,135 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.useIntersectionObserver = void 0;
-const React = /*#__PURE__*/require("react");
-const react_utilities_1 = /*#__PURE__*/require("@fluentui/react-utilities");
-const {
-  useState,
-  useRef
-} = React;
-/**
- * React hook that allows easy usage of the browser API IntersectionObserver within React
- * @param callback - A function called when the percentage of the target element is visible crosses a threshold.
- * @param options - An optional object which customizes the observer. If options isn't specified, the observer uses the
- * document's viewport as the root, with no margin, and a 0% threshold (meaning that even a one-pixel change is
- * enough to trigger a callback).
- * @returns An array containing a callback to update the list of Elements the observer should listen to, a callback to
- * update the init options of the IntersectionObserver and a ref to the IntersectionObserver instance itself.
- */
-const useIntersectionObserver = (callback, options) => {
-  // export const useIntersectionObserver = (
-  //   callback: IntersectionObserverCallback,
-  //   options?: IntersectionObserverInit,
-  // ): [
-  //   Dispatch<SetStateAction<Element[] | undefined>>,
-  //   Dispatch<SetStateAction<IntersectionObserverInit | undefined>>,
-  //   MutableRefObject<IntersectionObserver | undefined>,
-  // ] => {
-  const observer = useRef();
-  const [observerList, setObserverList] = useState();
-  const [observerInit, setObserverInit] = useState(options);
-  // Observer elements in passed in list and clean up previous list
-  // This effect is only triggered when observerList is updated
-  react_utilities_1.useIsomorphicLayoutEffect(() => {
-    observer.current = new IntersectionObserver(callback, observerInit);
-    // If we have an instance of IO and a list with elements, observer the elements
-    if (observer.current && observerList && observerList.length > 0) {
-      observerList.forEach(element => {
-        var _a;
-        (_a = observer.current) === null || _a === void 0 ? void 0 : _a.observe(element);
-      });
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getRTLRootMargin: function() {
+        return getRTLRootMargin;
+    },
+    useIntersectionObserver: function() {
+        return useIntersectionObserver;
     }
-    // clean up previous elements being listened to
-    return () => {
-      if (observer.current) {
-        observer.current.disconnect();
-      }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const _useMutationObserver = require("./useMutationObserver");
+const { useCallback, useState, useRef } = _react;
+const getRTLRootMargin = (ltrRootMargin, target, win)=>{
+    if (target && win) {
+        // get the computed dir for the target element
+        const newDir = win.getComputedStyle(target).direction;
+        // If we're in rtl reading direction, we might need to flip the margins on the left/right sides
+        if (newDir === 'rtl') {
+            let newMargin = ltrRootMargin;
+            const splitMargins = ltrRootMargin.split(' ');
+            // We only need to do this if we get four values, otherwise the sides are equal and don't require flipping.
+            if (splitMargins.length === 4) {
+                newMargin = `${splitMargins[0]} ${splitMargins[3]} ${splitMargins[2]} ${splitMargins[1]}`;
+            }
+            return newMargin;
+        } else {
+            return ltrRootMargin;
+        }
+    }
+    return ltrRootMargin;
+};
+const useIntersectionObserver = (callback, options)=>{
+    'use no memo';
+    // TODO: exclude types from this lint rule: https://github.com/microsoft/fluentui/issues/31286
+    // eslint-disable-next-line no-restricted-globals
+    const observer = useRef();
+    const [observerList, setObserverList] = useState();
+    const { targetDocument } = (0, _reactsharedcontexts.useFluent_unstable)();
+    const win = targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.defaultView;
+    var _options_rootMargin;
+    // set the initial init with corrected margins based on the observed root's calculated reading direction.
+    const [observerInit, setObserverInit] = useState(options && {
+        ...options,
+        rootMargin: getRTLRootMargin((_options_rootMargin = options.rootMargin) !== null && _options_rootMargin !== void 0 ? _options_rootMargin : '0px', options.root, win)
+    });
+    var _options_rootMargin1;
+    // We have to assume that any values passed in for rootMargin by the consuming app are ltr values. As such we will store the ltr value.
+    const ltrRootMargin = useRef((_options_rootMargin1 = options === null || options === void 0 ? void 0 : options.rootMargin) !== null && _options_rootMargin1 !== void 0 ? _options_rootMargin1 : '0px');
+    // Callback function to execute when mutations are observed
+    const mutationObserverCallback = useCallback((mutationList)=>{
+        for (const mutation of mutationList){
+            // Ensuring that the right attribute is being observed and that the root is within the tree of the element being mutated.
+            if (mutation.type === 'attributes' && mutation.attributeName === 'dir' && (options === null || options === void 0 ? void 0 : options.root) && mutation.target.contains(options === null || options === void 0 ? void 0 : options.root)) {
+                setObserverInit({
+                    ...observerInit,
+                    rootMargin: getRTLRootMargin(ltrRootMargin.current, observerInit === null || observerInit === void 0 ? void 0 : observerInit.root, win)
+                });
+            }
+        }
+    }, [
+        ltrRootMargin,
+        observerInit,
+        options === null || options === void 0 ? void 0 : options.root,
+        win
+    ]);
+    // Mutation observer for dir attribute changes in the document
+    (0, _useMutationObserver.useMutationObserver)(targetDocument, mutationObserverCallback, {
+        attributes: true,
+        subtree: true,
+        attributeFilter: [
+            'dir'
+        ]
+    });
+    // Observer elements in passed in list and clean up previous list
+    // This effect is only triggered when observerList is updated
+    (0, _reactutilities.useIsomorphicLayoutEffect)(()=>{
+        if (!win) {
+            return;
+        }
+        observer.current = new win.IntersectionObserver(callback, {
+            ...observerInit,
+            rootMargin: getRTLRootMargin(ltrRootMargin.current, observerInit === null || observerInit === void 0 ? void 0 : observerInit.root, win)
+        });
+        // If we have an instance of IO and a list with elements, observer the elements
+        if (observer.current && observerList && observerList.length > 0) {
+            observerList.forEach((element)=>{
+                var _observer_current;
+                (_observer_current = observer.current) === null || _observer_current === void 0 ? void 0 : _observer_current.observe(element);
+            });
+        }
+        // clean up previous elements being listened to
+        return ()=>{
+            if (observer.current) {
+                observer.current.disconnect();
+            }
+        };
+    }, [
+        observerList,
+        observerInit,
+        callback,
+        win
+    ]);
+    // Do not use internally, we need to track external settings only here
+    const setObserverInitExternal = useCallback((newInit)=>{
+        var _newInit_rootMargin;
+        // Since we know this is coming from consumers, we can store this value as LTR somewhat safely.
+        ltrRootMargin.current = (_newInit_rootMargin = newInit === null || newInit === void 0 ? void 0 : newInit.rootMargin) !== null && _newInit_rootMargin !== void 0 ? _newInit_rootMargin : '0px';
+        // Call the internal setter to update the value and ensure if our calculated direction is rtl, we flip the margin
+        setObserverInit({
+            ...newInit,
+            rootMargin: getRTLRootMargin(ltrRootMargin.current, newInit === null || newInit === void 0 ? void 0 : newInit.root, win)
+        });
+    }, [
+        ltrRootMargin,
+        setObserverInit,
+        win
+    ]);
+    return {
+        setObserverList,
+        setObserverInit: setObserverInitExternal,
+        observer
     };
-  }, [observerList, observerInit, callback]);
-  return {
-    setObserverList,
-    setObserverInit,
-    observer
-  };
 };
-exports.useIntersectionObserver = useIntersectionObserver;
-//# sourceMappingURL=useIntersectionObserver.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["React","require","react_utilities_1","useState","useRef","useIntersectionObserver","callback","options","observer","observerList","setObserverList","observerInit","setObserverInit","useIsomorphicLayoutEffect","current","IntersectionObserver","length","forEach","element","_a","observe","disconnect","exports"],"sources":["../src/packages/react-components/react-virtualizer/src/hooks/useIntersectionObserver.ts"],"sourcesContent":["import type { Dispatch, MutableRefObject, SetStateAction } from 'react';\nimport * as React from 'react';\nimport { useIsomorphicLayoutEffect } from '@fluentui/react-utilities';\n\nconst { useState, useRef } = React;\n\n/**\n * React hook that allows easy usage of the browser API IntersectionObserver within React\n * @param callback - A function called when the percentage of the target element is visible crosses a threshold.\n * @param options - An optional object which customizes the observer. If options isn't specified, the observer uses the\n * document's viewport as the root, with no margin, and a 0% threshold (meaning that even a one-pixel change is\n * enough to trigger a callback).\n * @returns An array containing a callback to update the list of Elements the observer should listen to, a callback to\n * update the init options of the IntersectionObserver and a ref to the IntersectionObserver instance itself.\n */\n\nexport const useIntersectionObserver = (\n  callback: IntersectionObserverCallback,\n  options?: IntersectionObserverInit,\n): {\n  setObserverList: Dispatch<SetStateAction<Element[] | undefined>>;\n  setObserverInit: Dispatch<SetStateAction<IntersectionObserverInit | undefined>>;\n  observer: MutableRefObject<IntersectionObserver | undefined>;\n} => {\n  // export const useIntersectionObserver = (\n  //   callback: IntersectionObserverCallback,\n  //   options?: IntersectionObserverInit,\n  // ): [\n  //   Dispatch<SetStateAction<Element[] | undefined>>,\n  //   Dispatch<SetStateAction<IntersectionObserverInit | undefined>>,\n  //   MutableRefObject<IntersectionObserver | undefined>,\n  // ] => {\n  const observer = useRef<IntersectionObserver>();\n  const [observerList, setObserverList] = useState<Element[]>();\n  const [observerInit, setObserverInit] = useState<IntersectionObserverInit | undefined>(options);\n\n  // Observer elements in passed in list and clean up previous list\n  // This effect is only triggered when observerList is updated\n  useIsomorphicLayoutEffect(() => {\n    observer.current = new IntersectionObserver(callback, observerInit);\n\n    // If we have an instance of IO and a list with elements, observer the elements\n    if (observer.current && observerList && observerList.length > 0) {\n      observerList.forEach(element => {\n        observer.current?.observe(element);\n      });\n    }\n\n    // clean up previous elements being listened to\n    return () => {\n      if (observer.current) {\n        observer.current.disconnect();\n      }\n    };\n  }, [observerList, observerInit, callback]);\n\n  return { setObserverList, setObserverInit, observer };\n};\n"],"mappings":";;;;;;AACA,MAAAA,KAAA,gBAAAC,OAAA;AACA,MAAAC,iBAAA,gBAAAD,OAAA;AAEA,MAAM;EAAEE,QAAQ;EAAEC;AAAM,CAAE,GAAGJ,KAAK;AAElC;;;;;;;;;AAUO,MAAMK,uBAAuB,GAAGA,CACrCC,QAAsC,EACtCC,OAAkC,KAKhC;EACF;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,MAAMC,QAAQ,GAAGJ,MAAM,EAAwB;EAC/C,MAAM,CAACK,YAAY,EAAEC,eAAe,CAAC,GAAGP,QAAQ,EAAa;EAC7D,MAAM,CAACQ,YAAY,EAAEC,eAAe,CAAC,GAAGT,QAAQ,CAAuCI,OAAO,CAAC;EAE/F;EACA;EACAL,iBAAA,CAAAW,yBAAyB,CAAC,MAAK;IAC7BL,QAAQ,CAACM,OAAO,GAAG,IAAIC,oBAAoB,CAACT,QAAQ,EAAEK,YAAY,CAAC;IAEnE;IACA,IAAIH,QAAQ,CAACM,OAAO,IAAIL,YAAY,IAAIA,YAAY,CAACO,MAAM,GAAG,CAAC,EAAE;MAC/DP,YAAY,CAACQ,OAAO,CAACC,OAAO,IAAG;;QAC7B,CAAAC,EAAA,GAAAX,QAAQ,CAACM,OAAO,cAAAK,EAAA,uBAAAA,EAAA,CAAEC,OAAO,CAACF,OAAO,CAAC;MACpC,CAAC,CAAC;;IAGJ;IACA,OAAO,MAAK;MACV,IAAIV,QAAQ,CAACM,OAAO,EAAE;QACpBN,QAAQ,CAACM,OAAO,CAACO,UAAU,EAAE;;IAEjC,CAAC;EACH,CAAC,EAAE,CAACZ,YAAY,EAAEE,YAAY,EAAEL,QAAQ,CAAC,CAAC;EAE1C,OAAO;IAAEI,eAAe;IAAEE,eAAe;IAAEJ;EAAQ,CAAE;AACvD,CAAC;AAzCYc,OAAA,CAAAjB,uBAAuB,GAAAA,uBAAA"}
+{"version":3,"sources":["../src/hooks/useIntersectionObserver.ts"],"sourcesContent":["import * as React from 'react';\nimport { useIsomorphicLayoutEffect } from '@fluentui/react-utilities';\nimport { useFluent_unstable as useFluent } from '@fluentui/react-shared-contexts';\n\nconst { useCallback, useState, useRef } = React;\nimport { useMutationObserver } from './useMutationObserver';\n\n/**\n * This function will take the rootMargin and flip the sides if we are in RTL based on the computed reading direction of the target element.\n * @param ltrRootMargin the margin to be processed and flipped if required\n * @param target target element that will have its current reading direction determined\n * @returns the corrected rootMargin (if it was necessary to correct)\n */\nexport const getRTLRootMargin = (\n  ltrRootMargin: string,\n  target?: Element | Document | null | undefined,\n  win?: Window | null,\n): string => {\n  if (target && win) {\n    // get the computed dir for the target element\n    const newDir = win.getComputedStyle(target as Element).direction;\n\n    // If we're in rtl reading direction, we might need to flip the margins on the left/right sides\n    if (newDir === 'rtl') {\n      let newMargin = ltrRootMargin;\n      const splitMargins = ltrRootMargin.split(' ');\n\n      // We only need to do this if we get four values, otherwise the sides are equal and don't require flipping.\n      if (splitMargins.length === 4) {\n        newMargin = `${splitMargins[0]} ${splitMargins[3]} ${splitMargins[2]} ${splitMargins[1]}`;\n      }\n\n      return newMargin;\n    } else {\n      return ltrRootMargin;\n    }\n  }\n\n  return ltrRootMargin;\n};\n\n/**\n * React hook that allows easy usage of the browser API IntersectionObserver within React\n * @param callback - A function called when the percentage of the target element is visible crosses a threshold.\n * @param options - An optional object which customizes the observer. If options isn't specified, the observer uses the\n * document's viewport as the root, with no margin, and a 0% threshold (meaning that even a one-pixel change is\n * enough to trigger a callback).\n * @returns An array containing a callback to update the list of Elements the observer should listen to, a callback to\n * update the init options of the IntersectionObserver and a ref to the IntersectionObserver instance itself.\n */\n\nexport const useIntersectionObserver = (\n  callback: IntersectionObserverCallback,\n  options?: IntersectionObserverInit,\n): {\n  setObserverList: React.Dispatch<React.SetStateAction<Element[] | undefined>>;\n  setObserverInit: (newInit: IntersectionObserverInit | undefined) => void;\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: React.MutableRefObject<IntersectionObserver | undefined>;\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<IntersectionObserver>();\n  const [observerList, setObserverList] = useState<Element[]>();\n  const { targetDocument } = useFluent();\n  const win = targetDocument?.defaultView;\n\n  // set the initial init with corrected margins based on the observed root's calculated reading direction.\n  const [observerInit, setObserverInit] = useState<IntersectionObserverInit | undefined>(\n    options && {\n      ...options,\n      rootMargin: getRTLRootMargin(options.rootMargin ?? '0px', options.root as Element, win),\n    },\n  );\n\n  // We have to assume that any values passed in for rootMargin by the consuming app are ltr values. As such we will store the ltr value.\n  const ltrRootMargin = useRef<string>(options?.rootMargin ?? '0px');\n\n  // Callback function to execute when mutations are observed\n  const mutationObserverCallback: MutationCallback = useCallback(\n    mutationList => {\n      for (const mutation of mutationList) {\n        // Ensuring that the right attribute is being observed and that the root is within the tree of the element being mutated.\n        if (\n          mutation.type === 'attributes' &&\n          mutation.attributeName === 'dir' &&\n          options?.root &&\n          mutation.target.contains(options?.root)\n        ) {\n          setObserverInit({\n            ...observerInit,\n            rootMargin: getRTLRootMargin(ltrRootMargin.current, observerInit?.root, win),\n          });\n        }\n      }\n    },\n    [ltrRootMargin, observerInit, options?.root, win],\n  );\n\n  // Mutation observer for dir attribute changes in the document\n  useMutationObserver(targetDocument, mutationObserverCallback, {\n    attributes: true,\n    subtree: true,\n    attributeFilter: ['dir'],\n  });\n\n  // Observer elements in passed in list and clean up previous list\n  // This effect is only triggered when observerList is updated\n  useIsomorphicLayoutEffect(() => {\n    if (!win) {\n      return;\n    }\n\n    observer.current = new win.IntersectionObserver(callback, {\n      ...observerInit,\n      rootMargin: getRTLRootMargin(ltrRootMargin.current, observerInit?.root, win),\n    });\n\n    // If we have an instance of IO and a list with elements, observer the elements\n    if (observer.current && observerList && observerList.length > 0) {\n      observerList.forEach(element => {\n        observer.current?.observe(element);\n      });\n    }\n\n    // clean up previous elements being listened to\n    return () => {\n      if (observer.current) {\n        observer.current.disconnect();\n      }\n    };\n  }, [observerList, observerInit, callback, win]);\n\n  // Do not use internally, we need to track external settings only here\n  const setObserverInitExternal = useCallback(\n    (newInit: IntersectionObserverInit | undefined) => {\n      // Since we know this is coming from consumers, we can store this value as LTR somewhat safely.\n      ltrRootMargin.current = newInit?.rootMargin ?? '0px';\n\n      // Call the internal setter to update the value and ensure if our calculated direction is rtl, we flip the margin\n      setObserverInit({\n        ...newInit,\n        rootMargin: getRTLRootMargin(ltrRootMargin.current, newInit?.root as Element, win),\n      });\n    },\n    [ltrRootMargin, setObserverInit, win],\n  );\n\n  return { setObserverList, setObserverInit: setObserverInitExternal, observer };\n};\n"],"names":["getRTLRootMargin","useIntersectionObserver","useCallback","useState","useRef","React","ltrRootMargin","target","win","newDir","getComputedStyle","direction","newMargin","splitMargins","split","length","callback","options","observer","observerList","setObserverList","targetDocument","useFluent","defaultView","observerInit","setObserverInit","rootMargin","root","mutationObserverCallback","mutationList","mutation","type","attributeName","contains","current","useMutationObserver","attributes","subtree","attributeFilter","useIsomorphicLayoutEffect","IntersectionObserver","forEach","element","observe","disconnect","setObserverInitExternal","newInit"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib-commonjs/hooks/useMeasureList.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createResizeObserverFromDocument: function() {
+        return createResizeObserverFromDocument;
+    },
+    useMeasureList: function() {
+        return useMeasureList;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+function useMeasureList(currentIndex, refLength, totalLength, defaultItemSize) {
+    const widthArray = _react.useRef(new Array(totalLength).fill(defaultItemSize));
+    const heightArray = _react.useRef(new Array(totalLength).fill(defaultItemSize));
+    const refArray = _react.useRef([]);
+    const { targetDocument } = (0, _reactsharedcontexts.useFluent_unstable)();
+    // This lets us trigger updates when a size change occurs.
+    const sizeUpdateCount = _react.useRef(0);
+    // the handler for resize observer
+    const handleIndexUpdate = _react.useCallback((index)=>{
+        var _refArray_current_index;
+        let isChanged = false;
+        const boundClientRect = (_refArray_current_index = refArray.current[index]) === null || _refArray_current_index === void 0 ? void 0 : _refArray_current_index.getBoundingClientRect();
+        const containerWidth = boundClientRect === null || boundClientRect === void 0 ? void 0 : boundClientRect.width;
+        if (containerWidth !== widthArray.current[currentIndex + index]) {
+            isChanged = true;
+        }
+        widthArray.current[currentIndex + index] = containerWidth || defaultItemSize;
+        const containerHeight = boundClientRect === null || boundClientRect === void 0 ? void 0 : boundClientRect.height;
+        if (containerHeight !== heightArray.current[currentIndex + index]) {
+            isChanged = true;
+        }
+        heightArray.current[currentIndex + index] = containerHeight || defaultItemSize;
+        if (isChanged) {
+            sizeUpdateCount.current = sizeUpdateCount.current + 1;
+        }
+    }, [
+        currentIndex,
+        defaultItemSize,
+        sizeUpdateCount
+    ]);
+    const handleElementResizeCallback = (entries)=>{
+        for (const entry of entries){
+            const target = entry.target;
+            // Call the elements own resize handler (indexed)
+            target.handleResize();
+        }
+    };
+    _react.useEffect(()=>{
+        const newHeightLength = totalLength - heightArray.current.length;
+        const newWidthLength = totalLength - widthArray.current.length;
+        /* Ensure we grow or truncate arrays with prior properties,
+    keeping the existing values is important for whitespace assumptions.
+    Even if items in the 'middle' are deleted, we will recalc the whitespace as it is explored.*/ if (newWidthLength > 0) {
+            widthArray.current = widthArray.current.concat(new Array(newWidthLength).fill(defaultItemSize));
+        } else if (newWidthLength < 0) {
+            widthArray.current = widthArray.current.slice(0, totalLength);
+        }
+        if (newHeightLength > 0) {
+            heightArray.current = heightArray.current.concat(new Array(newHeightLength).fill(defaultItemSize));
+        } else if (newHeightLength < 0) {
+            heightArray.current = heightArray.current.slice(0, totalLength);
+        }
+    }, [
+        defaultItemSize,
+        totalLength
+    ]);
+    // Keep the reference of ResizeObserver as a ref, as it should live through renders
+    const resizeObserver = _react.useRef(createResizeObserverFromDocument(targetDocument, handleElementResizeCallback));
+    /* createIndexedRef provides a dynamic function to create an undefined number of refs at render time
+   * these refs then provide an indexed callback via attaching 'handleResize' to the element itself
+   * this function is then called on resize by handleElementResize and relies on indexing
+   * to track continuous sizes throughout renders while releasing all virtualized element refs each render cycle.
+   */ const createIndexedRef = _react.useCallback((index)=>{
+        const measureElementRef = (el)=>{
+            if (!targetDocument || !resizeObserver.current) {
+                return;
+            }
+            if (el) {
+                el.handleResize = ()=>{
+                    handleIndexUpdate(index);
+                };
+            }
+            // cleanup previous container
+            if (refArray.current[index] !== undefined && refArray.current[index] !== null) {
+                resizeObserver.current.unobserve(refArray.current[index]);
+            }
+            refArray.current[index] = undefined;
+            if (el) {
+                refArray.current[index] = el;
+                resizeObserver.current.observe(el);
+                handleIndexUpdate(index);
+            }
+        };
+        return measureElementRef;
+    }, [
+        handleIndexUpdate,
+        resizeObserver,
+        targetDocument
+    ]);
+    _react.useEffect(()=>{
+        const _resizeObserver = resizeObserver;
+        return ()=>{
+            var _resizeObserver_current;
+            return (_resizeObserver_current = _resizeObserver.current) === null || _resizeObserver_current === void 0 ? void 0 : _resizeObserver_current.disconnect();
+        };
+    }, [
+        resizeObserver
+    ]);
+    return {
+        widthArray,
+        heightArray,
+        createIndexedRef,
+        refArray,
+        sizeUpdateCount: sizeUpdateCount.current
+    };
+}
+function createResizeObserverFromDocument(targetDocument, callback) {
+    var _targetDocument_defaultView;
+    if (!(targetDocument === null || targetDocument === void 0 ? void 0 : (_targetDocument_defaultView = targetDocument.defaultView) === null || _targetDocument_defaultView === void 0 ? void 0 : _targetDocument_defaultView.ResizeObserver)) {
+        return null;
+    }
+    return new targetDocument.defaultView.ResizeObserver(callback);
+}

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useMutationObserver", {
+    enumerable: true,
+    get: function() {
+        return useMutationObserver;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const { useRef, useEffect } = _react;
+const useMutationObserver = (target, callback, options)=>{
+    'use no memo';
+    // TODO: exclude types from this lint rule: https://github.com/microsoft/fluentui/issues/31286
+    // eslint-disable-next-line no-restricted-globals
+    const observer = useRef();
+    const { targetDocument } = (0, _reactsharedcontexts.useFluent_unstable)();
+    const win = targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.defaultView;
+    useEffect(()=>{
+        if (!win) {
+            return;
+        }
+        // Create an observer instance linked to the callback function
+        observer.current = new win.MutationObserver(callback);
+    }, [
+        callback,
+        win
+    ]);
+    useEffect(()=>{
+        if (target) {
+            var _observer_current;
+            (_observer_current = observer.current) === null || _observer_current === void 0 ? void 0 : _observer_current.observe(target, options);
+        }
+        return ()=>{
+            var _observer_current;
+            (_observer_current = observer.current) === null || _observer_current === void 0 ? void 0 : _observer_current.disconnect();
+        };
+    }, [
+        target,
+        options
+    ]);
+    return {
+        observer
+    };
+};

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

@@ -0,0 +1 @@
+{"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"}