@fluentui/react-utilities 9.9.1 → 9.9.2

package/lib/hooks/useControllableState.js

@@ -1,6 +1,6 @@
 import * as React from 'react';
 function isFactoryDispatch(newState) {
-  return typeof newState === 'function';
+    return typeof newState === 'function';
 }
 /**
  * @internal
@@ -18,52 +18,65 @@ function isFactoryDispatch(newState) {
  * ❗️❗️ Calls to the dispatcher will only modify the state if the state is `uncontrolled`.
  * Meaning that if a state is `controlled`, calls to the dispatcher do not modify the state.
  *
- */
-export const useControllableState = options => {
-  const [internalState, setInternalState] = React.useState(() => {
-    if (options.defaultState === undefined) {
-      return options.initialState;
-    }
-    return isInitializer(options.defaultState) ? options.defaultState() : options.defaultState;
-  });
-  // Heads up!
-  // This part is specific for controlled mode and mocks behavior of React dispatcher function.
-  const stateValueRef = React.useRef(options.state);
-  React.useEffect(() => {
-    stateValueRef.current = options.state;
-  }, [options.state]);
-  const setControlledState = React.useCallback(newState => {
-    if (isFactoryDispatch(newState)) {
-      newState(stateValueRef.current);
-    }
-  }, []);
-  return useIsControlled(options.state) ? [options.state, setControlledState] : [internalState, setInternalState];
+ */ export const useControllableState = (options)=>{
+    const [internalState, setInternalState] = React.useState(()=>{
+        if (options.defaultState === undefined) {
+            return options.initialState;
+        }
+        return isInitializer(options.defaultState) ? options.defaultState() : options.defaultState;
+    });
+    // Heads up!
+    // This part is specific for controlled mode and mocks behavior of React dispatcher function.
+    const stateValueRef = React.useRef(options.state);
+    React.useEffect(()=>{
+        stateValueRef.current = options.state;
+    }, [
+        options.state
+    ]);
+    const setControlledState = React.useCallback((newState)=>{
+        if (isFactoryDispatch(newState)) {
+            newState(stateValueRef.current);
+        }
+    }, []);
+    return useIsControlled(options.state) ? [
+        options.state,
+        setControlledState
+    ] : [
+        internalState,
+        setInternalState
+    ];
 };
 function isInitializer(value) {
-  return typeof value === 'function';
+    return typeof value === 'function';
 }
 /**
  * Helper hook to handle previous comparison of controlled/uncontrolled
  * Prints an error when isControlled value switches between subsequent renders
  * @returns - whether the value is controlled
- */
-const useIsControlled = controlledValue => {
-  const [isControlled] = React.useState(() => controlledValue !== undefined);
-  if (process.env.NODE_ENV !== 'production') {
-    // We don't want these warnings in production even though it is against native behaviour
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    React.useEffect(() => {
-      if (isControlled !== (controlledValue !== undefined)) {
-        const error = new Error();
-        const controlWarning = isControlled ? 'a controlled value to be uncontrolled' : 'an uncontrolled value to be controlled';
-        const undefinedWarning = isControlled ? 'defined to an undefined' : 'undefined to a defined';
-        // eslint-disable-next-line no-console
-        console.error([
-        // Default react error
-        'A component is changing ' + controlWarning + '. This is likely caused by the value', 'changing from ' + undefinedWarning + ' value, which should not happen.', 'Decide between using a controlled or uncontrolled input element for the lifetime of the component.', 'More info: https://reactjs.org/link/controlled-components', error.stack].join(' '));
-      }
-    }, [isControlled, controlledValue]);
-  }
-  return isControlled;
+ */ const useIsControlled = (controlledValue)=>{
+    const [isControlled] = React.useState(()=>controlledValue !== undefined);
+    if (process.env.NODE_ENV !== 'production') {
+        // We don't want these warnings in production even though it is against native behaviour
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        React.useEffect(()=>{
+            if (isControlled !== (controlledValue !== undefined)) {
+                const error = new Error();
+                const controlWarning = isControlled ? 'a controlled value to be uncontrolled' : 'an uncontrolled value to be controlled';
+                const undefinedWarning = isControlled ? 'defined to an undefined' : 'undefined to a defined';
+                // eslint-disable-next-line no-console
+                console.error([
+                    // Default react error
+                    'A component is changing ' + controlWarning + '. This is likely caused by the value',
+                    'changing from ' + undefinedWarning + ' value, which should not happen.',
+                    'Decide between using a controlled or uncontrolled input element for the lifetime of the component.',
+                    'More info: https://reactjs.org/link/controlled-components',
+                    error.stack
+                ].join(' '));
+            }
+        }, [
+            isControlled,
+            controlledValue
+        ]);
+    }
+    return isControlled;
 };
-//# sourceMappingURL=useControllableState.js.map

package/lib/hooks/useControllableState.js.map

@@ -1 +1 @@
-{"version":3,"names":["React","isFactoryDispatch","newState","useControllableState","options","internalState","setInternalState","useState","defaultState","undefined","initialState","isInitializer","stateValueRef","useRef","state","useEffect","current","setControlledState","useCallback","useIsControlled","value","controlledValue","isControlled","process","env","NODE_ENV","error","Error","controlWarning","undefinedWarning","console","stack","join"],"sources":["../../src/hooks/useControllableState.ts"],"sourcesContent":["import * as React from 'react';\n\n/**\n * @internal\n */\nexport type UseControllableStateOptions<State> = {\n  /**\n   * User-provided default state or initializer, for uncontrolled usage.\n   */\n  defaultState?: State | (() => State);\n  /**\n   * User-provided controlled state. `undefined` means internal state will be used.\n   */\n  state: State | undefined;\n  /**\n   * Used as the initial state if `state` and `defaultState` are both `undefined`.\n   * If `undefined` is the correct initial state, pass that here.\n   */\n  initialState: State;\n};\n\nfunction isFactoryDispatch<State>(newState: React.SetStateAction<State>): newState is (prevState: State) => State {\n  return typeof newState === 'function';\n}\n\n/**\n * @internal\n *\n * A [`useState`](https://reactjs.org/docs/hooks-reference.html#usestate)-like hook\n * to manage a value that could be either `controlled` or `uncontrolled`,\n * such as a checked state or text input string.\n *\n * @see https://react.dev/learn/sharing-state-between-components#controlled-and-uncontrolled-components for more details on `controlled`/`uncontrolled`\n *\n * @returns an array of the current value and an updater (dispatcher) function.\n * The updater function is referentially stable (won't change during the component's lifecycle).\n * It can take either a new value, or a function which is passed the previous value and returns the new value.\n *\n * ❗️❗️ Calls to the dispatcher will only modify the state if the state is `uncontrolled`.\n * Meaning that if a state is `controlled`, calls to the dispatcher do not modify the state.\n *\n */\nexport const useControllableState = <State>(\n  options: UseControllableStateOptions<State>,\n): [State, React.Dispatch<React.SetStateAction<State>>] => {\n  const [internalState, setInternalState] = React.useState<State>(() => {\n    if (options.defaultState === undefined) {\n      return options.initialState;\n    }\n    return isInitializer(options.defaultState) ? options.defaultState() : options.defaultState;\n  });\n\n  // Heads up!\n  // This part is specific for controlled mode and mocks behavior of React dispatcher function.\n\n  const stateValueRef = React.useRef<State | undefined>(options.state);\n\n  React.useEffect(() => {\n    stateValueRef.current = options.state;\n  }, [options.state]);\n\n  const setControlledState = React.useCallback((newState: React.SetStateAction<State>) => {\n    if (isFactoryDispatch(newState)) {\n      newState(stateValueRef.current as State);\n    }\n  }, []);\n\n  return useIsControlled(options.state) ? [options.state, setControlledState] : [internalState, setInternalState];\n};\n\nfunction isInitializer<State>(value: State | (() => State)): value is () => State {\n  return typeof value === 'function';\n}\n\n/**\n * Helper hook to handle previous comparison of controlled/uncontrolled\n * Prints an error when isControlled value switches between subsequent renders\n * @returns - whether the value is controlled\n */\nconst useIsControlled = <V>(controlledValue: V | undefined): controlledValue is V => {\n  const [isControlled] = React.useState<boolean>(() => controlledValue !== undefined);\n\n  if (process.env.NODE_ENV !== 'production') {\n    // We don't want these warnings in production even though it is against native behaviour\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useEffect(() => {\n      if (isControlled !== (controlledValue !== undefined)) {\n        const error = new Error();\n\n        const controlWarning = isControlled\n          ? 'a controlled value to be uncontrolled'\n          : 'an uncontrolled value to be controlled';\n\n        const undefinedWarning = isControlled ? 'defined to an undefined' : 'undefined to a defined';\n\n        // eslint-disable-next-line no-console\n        console.error(\n          [\n            // Default react error\n            'A component is changing ' + controlWarning + '. This is likely caused by the value',\n            'changing from ' + undefinedWarning + ' value, which should not happen.',\n            'Decide between using a controlled or uncontrolled input element for the lifetime of the component.',\n            'More info: https://reactjs.org/link/controlled-components',\n            error.stack,\n          ].join(' '),\n        );\n      }\n    }, [isControlled, controlledValue]);\n  }\n\n  return isControlled;\n};\n"],"mappings":"AAAA,YAAYA,KAAA,MAAW;AAqBvB,SAASC,kBAAyBC,QAAqC,EAA2C;EAChH,OAAO,OAAOA,QAAA,KAAa;AAC7B;AAEA;;;;;;;;;;;;;;;;;AAiBA,OAAO,MAAMC,oBAAA,GACXC,OAAA,IACyD;EACzD,MAAM,CAACC,aAAA,EAAeC,gBAAA,CAAiB,GAAGN,KAAA,CAAMO,QAAQ,CAAQ,MAAM;IACpE,IAAIH,OAAA,CAAQI,YAAY,KAAKC,SAAA,EAAW;MACtC,OAAOL,OAAA,CAAQM,YAAY;IAC7B;IACA,OAAOC,aAAA,CAAcP,OAAA,CAAQI,YAAY,IAAIJ,OAAA,CAAQI,YAAY,KAAKJ,OAAA,CAAQI,YAAY;EAC5F;EAEA;EACA;EAEA,MAAMI,aAAA,GAAgBZ,KAAA,CAAMa,MAAM,CAAoBT,OAAA,CAAQU,KAAK;EAEnEd,KAAA,CAAMe,SAAS,CAAC,MAAM;IACpBH,aAAA,CAAcI,OAAO,GAAGZ,OAAA,CAAQU,KAAK;EACvC,GAAG,CAACV,OAAA,CAAQU,KAAK,CAAC;EAElB,MAAMG,kBAAA,GAAqBjB,KAAA,CAAMkB,WAAW,CAAEhB,QAAA,IAA0C;IACtF,IAAID,iBAAA,CAAkBC,QAAA,GAAW;MAC/BA,QAAA,CAASU,aAAA,CAAcI,OAAO;IAChC;EACF,GAAG,EAAE;EAEL,OAAOG,eAAA,CAAgBf,OAAA,CAAQU,KAAK,IAAI,CAACV,OAAA,CAAQU,KAAK,EAAEG,kBAAA,CAAmB,GAAG,CAACZ,aAAA,EAAeC,gBAAA,CAAiB;AACjH;AAEA,SAASK,cAAqBS,KAA4B,EAAwB;EAChF,OAAO,OAAOA,KAAA,KAAU;AAC1B;AAEA;;;;;AAKA,MAAMD,eAAA,GAAsBE,eAAA,IAAyD;EACnF,MAAM,CAACC,YAAA,CAAa,GAAGtB,KAAA,CAAMO,QAAQ,CAAU,MAAMc,eAAA,KAAoBZ,SAAA;EAEzE,IAAIc,OAAA,CAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;IACzC;IACA;IACAzB,KAAA,CAAMe,SAAS,CAAC,MAAM;MACpB,IAAIO,YAAA,MAAkBD,eAAA,KAAoBZ,SAAQ,GAAI;QACpD,MAAMiB,KAAA,GAAQ,IAAIC,KAAA;QAElB,MAAMC,cAAA,GAAiBN,YAAA,GACnB,0CACA,wCAAwC;QAE5C,MAAMO,gBAAA,GAAmBP,YAAA,GAAe,4BAA4B,wBAAwB;QAE5F;QACAQ,OAAA,CAAQJ,KAAK,CACX;QACE;QACA,6BAA6BE,cAAA,GAAiB,wCAC9C,mBAAmBC,gBAAA,GAAmB,oCACtC,sGACA,6DACAH,KAAA,CAAMK,KAAK,CACZ,CAACC,IAAI,CAAC;MAEX;IACF,GAAG,CAACV,YAAA,EAAcD,eAAA,CAAgB;EACpC;EAEA,OAAOC,YAAA;AACT"}
+{"version":3,"sources":["useControllableState.ts"],"sourcesContent":["import * as React from 'react';\n\n/**\n * @internal\n */\nexport type UseControllableStateOptions<State> = {\n  /**\n   * User-provided default state or initializer, for uncontrolled usage.\n   */\n  defaultState?: State | (() => State);\n  /**\n   * User-provided controlled state. `undefined` means internal state will be used.\n   */\n  state: State | undefined;\n  /**\n   * Used as the initial state if `state` and `defaultState` are both `undefined`.\n   * If `undefined` is the correct initial state, pass that here.\n   */\n  initialState: State;\n};\n\nfunction isFactoryDispatch<State>(newState: React.SetStateAction<State>): newState is (prevState: State) => State {\n  return typeof newState === 'function';\n}\n\n/**\n * @internal\n *\n * A [`useState`](https://reactjs.org/docs/hooks-reference.html#usestate)-like hook\n * to manage a value that could be either `controlled` or `uncontrolled`,\n * such as a checked state or text input string.\n *\n * @see https://react.dev/learn/sharing-state-between-components#controlled-and-uncontrolled-components for more details on `controlled`/`uncontrolled`\n *\n * @returns an array of the current value and an updater (dispatcher) function.\n * The updater function is referentially stable (won't change during the component's lifecycle).\n * It can take either a new value, or a function which is passed the previous value and returns the new value.\n *\n * ❗️❗️ Calls to the dispatcher will only modify the state if the state is `uncontrolled`.\n * Meaning that if a state is `controlled`, calls to the dispatcher do not modify the state.\n *\n */\nexport const useControllableState = <State>(\n  options: UseControllableStateOptions<State>,\n): [State, React.Dispatch<React.SetStateAction<State>>] => {\n  const [internalState, setInternalState] = React.useState<State>(() => {\n    if (options.defaultState === undefined) {\n      return options.initialState;\n    }\n    return isInitializer(options.defaultState) ? options.defaultState() : options.defaultState;\n  });\n\n  // Heads up!\n  // This part is specific for controlled mode and mocks behavior of React dispatcher function.\n\n  const stateValueRef = React.useRef<State | undefined>(options.state);\n\n  React.useEffect(() => {\n    stateValueRef.current = options.state;\n  }, [options.state]);\n\n  const setControlledState = React.useCallback((newState: React.SetStateAction<State>) => {\n    if (isFactoryDispatch(newState)) {\n      newState(stateValueRef.current as State);\n    }\n  }, []);\n\n  return useIsControlled(options.state) ? [options.state, setControlledState] : [internalState, setInternalState];\n};\n\nfunction isInitializer<State>(value: State | (() => State)): value is () => State {\n  return typeof value === 'function';\n}\n\n/**\n * Helper hook to handle previous comparison of controlled/uncontrolled\n * Prints an error when isControlled value switches between subsequent renders\n * @returns - whether the value is controlled\n */\nconst useIsControlled = <V>(controlledValue: V | undefined): controlledValue is V => {\n  const [isControlled] = React.useState<boolean>(() => controlledValue !== undefined);\n\n  if (process.env.NODE_ENV !== 'production') {\n    // We don't want these warnings in production even though it is against native behaviour\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useEffect(() => {\n      if (isControlled !== (controlledValue !== undefined)) {\n        const error = new Error();\n\n        const controlWarning = isControlled\n          ? 'a controlled value to be uncontrolled'\n          : 'an uncontrolled value to be controlled';\n\n        const undefinedWarning = isControlled ? 'defined to an undefined' : 'undefined to a defined';\n\n        // eslint-disable-next-line no-console\n        console.error(\n          [\n            // Default react error\n            'A component is changing ' + controlWarning + '. This is likely caused by the value',\n            'changing from ' + undefinedWarning + ' value, which should not happen.',\n            'Decide between using a controlled or uncontrolled input element for the lifetime of the component.',\n            'More info: https://reactjs.org/link/controlled-components',\n            error.stack,\n          ].join(' '),\n        );\n      }\n    }, [isControlled, controlledValue]);\n  }\n\n  return isControlled;\n};\n"],"names":["React","isFactoryDispatch","newState","useControllableState","options","internalState","setInternalState","useState","defaultState","undefined","initialState","isInitializer","stateValueRef","useRef","state","useEffect","current","setControlledState","useCallback","useIsControlled","value","controlledValue","isControlled","process","env","NODE_ENV","error","Error","controlWarning","undefinedWarning","console","stack","join"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAqB/B,SAASC,kBAAyBC,QAAqC,EAA2C;IAChH,OAAO,OAAOA,aAAa;AAC7B;AAEA;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,MAAMC,uBAAuB,CAClCC,UACyD;IACzD,MAAM,CAACC,eAAeC,iBAAiB,GAAGN,MAAMO,QAAQ,CAAQ,IAAM;QACpE,IAAIH,QAAQI,YAAY,KAAKC,WAAW;YACtC,OAAOL,QAAQM,YAAY;QAC7B,CAAC;QACD,OAAOC,cAAcP,QAAQI,YAAY,IAAIJ,QAAQI,YAAY,KAAKJ,QAAQI,YAAY;IAC5F;IAEA,YAAY;IACZ,6FAA6F;IAE7F,MAAMI,gBAAgBZ,MAAMa,MAAM,CAAoBT,QAAQU,KAAK;IAEnEd,MAAMe,SAAS,CAAC,IAAM;QACpBH,cAAcI,OAAO,GAAGZ,QAAQU,KAAK;IACvC,GAAG;QAACV,QAAQU,KAAK;KAAC;IAElB,MAAMG,qBAAqBjB,MAAMkB,WAAW,CAAC,CAAChB,WAA0C;QACtF,IAAID,kBAAkBC,WAAW;YAC/BA,SAASU,cAAcI,OAAO;QAChC,CAAC;IACH,GAAG,EAAE;IAEL,OAAOG,gBAAgBf,QAAQU,KAAK,IAAI;QAACV,QAAQU,KAAK;QAAEG;KAAmB,GAAG;QAACZ;QAAeC;KAAiB;AACjH,EAAE;AAEF,SAASK,cAAqBS,KAA4B,EAAwB;IAChF,OAAO,OAAOA,UAAU;AAC1B;AAEA;;;;CAIC,GACD,MAAMD,kBAAkB,CAAIE,kBAAyD;IACnF,MAAM,CAACC,aAAa,GAAGtB,MAAMO,QAAQ,CAAU,IAAMc,oBAAoBZ;IAEzE,IAAIc,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;QACzC,wFAAwF;QACxF,sDAAsD;QACtDzB,MAAMe,SAAS,CAAC,IAAM;YACpB,IAAIO,iBAAkBD,CAAAA,oBAAoBZ,SAAQ,GAAI;gBACpD,MAAMiB,QAAQ,IAAIC;gBAElB,MAAMC,iBAAiBN,eACnB,0CACA,wCAAwC;gBAE5C,MAAMO,mBAAmBP,eAAe,4BAA4B,wBAAwB;gBAE5F,sCAAsC;gBACtCQ,QAAQJ,KAAK,CACX;oBACE,sBAAsB;oBACtB,6BAA6BE,iBAAiB;oBAC9C,mBAAmBC,mBAAmB;oBACtC;oBACA;oBACAH,MAAMK,KAAK;iBACZ,CAACC,IAAI,CAAC;YAEX,CAAC;QACH,GAAG;YAACV;YAAcD;SAAgB;IACpC,CAAC;IAED,OAAOC;AACT"}

package/lib/hooks/useEventCallback.js

@@ -12,17 +12,19 @@ import { useIsomorphicLayoutEffect } from './useIsomorphicLayoutEffect';
  * will not be invalidated between re-renders
  *
  * @param fn - The callback function that will be used
- */
-export const useEventCallback = fn => {
-  const callbackRef = React.useRef(() => {
-    throw new Error('Cannot call an event handler while rendering');
-  });
-  useIsomorphicLayoutEffect(() => {
-    callbackRef.current = fn;
-  }, [fn]);
-  return React.useCallback((...args) => {
-    const callback = callbackRef.current;
-    return callback(...args);
-  }, [callbackRef]);
+ */ export const useEventCallback = (fn)=>{
+    const callbackRef = React.useRef(()=>{
+        throw new Error('Cannot call an event handler while rendering');
+    });
+    useIsomorphicLayoutEffect(()=>{
+        callbackRef.current = fn;
+    }, [
+        fn
+    ]);
+    return React.useCallback((...args)=>{
+        const callback = callbackRef.current;
+        return callback(...args);
+    }, [
+        callbackRef
+    ]);
 };
-//# sourceMappingURL=useEventCallback.js.map

package/lib/hooks/useEventCallback.js.map

@@ -1 +1 @@
-{"version":3,"names":["React","useIsomorphicLayoutEffect","useEventCallback","fn","callbackRef","useRef","Error","current","useCallback","args","callback"],"sources":["../../src/hooks/useEventCallback.ts"],"sourcesContent":["import * as React from 'react';\nimport { useIsomorphicLayoutEffect } from './useIsomorphicLayoutEffect';\n\n/**\n * @internal\n * https://reactjs.org/docs/hooks-faq.html#how-to-read-an-often-changing-value-from-usecallback\n *\n * Modified `useCallback` that can be used when dependencies change too frequently. Can occur when\n * e.g. user props are dependencies which could change on every render\n * e.g. volatile values (i.e. useState/useDispatch) are dependencies which could change frequently\n *\n * This should not be used often, but can be a useful re-render optimization since the callback is a ref and\n * will not be invalidated between re-renders\n *\n * @param fn - The callback function that will be used\n */\nexport const useEventCallback = <Args extends unknown[], Return>(fn: (...args: Args) => Return) => {\n  const callbackRef = React.useRef<typeof fn>(() => {\n    throw new Error('Cannot call an event handler while rendering');\n  });\n\n  useIsomorphicLayoutEffect(() => {\n    callbackRef.current = fn;\n  }, [fn]);\n\n  return React.useCallback(\n    (...args: Args) => {\n      const callback = callbackRef.current;\n      return callback(...args);\n    },\n    [callbackRef],\n  );\n};\n"],"mappings":"AAAA,YAAYA,KAAA,MAAW;AACvB,SAASC,yBAAyB,QAAQ;AAE1C;;;;;;;;;;;;;AAaA,OAAO,MAAMC,gBAAA,GAAoDC,EAAA,IAAkC;EACjG,MAAMC,WAAA,GAAcJ,KAAA,CAAMK,MAAM,CAAY,MAAM;IAChD,MAAM,IAAIC,KAAA,CAAM;EAClB;EAEAL,yBAAA,CAA0B,MAAM;IAC9BG,WAAA,CAAYG,OAAO,GAAGJ,EAAA;EACxB,GAAG,CAACA,EAAA,CAAG;EAEP,OAAOH,KAAA,CAAMQ,WAAW,CACtB,CAAC,GAAGC,IAAA,KAAe;IACjB,MAAMC,QAAA,GAAWN,WAAA,CAAYG,OAAO;IACpC,OAAOG,QAAA,IAAYD,IAAA;EACrB,GACA,CAACL,WAAA,CAAY;AAEjB"}
+{"version":3,"sources":["useEventCallback.ts"],"sourcesContent":["import * as React from 'react';\nimport { useIsomorphicLayoutEffect } from './useIsomorphicLayoutEffect';\n\n/**\n * @internal\n * https://reactjs.org/docs/hooks-faq.html#how-to-read-an-often-changing-value-from-usecallback\n *\n * Modified `useCallback` that can be used when dependencies change too frequently. Can occur when\n * e.g. user props are dependencies which could change on every render\n * e.g. volatile values (i.e. useState/useDispatch) are dependencies which could change frequently\n *\n * This should not be used often, but can be a useful re-render optimization since the callback is a ref and\n * will not be invalidated between re-renders\n *\n * @param fn - The callback function that will be used\n */\nexport const useEventCallback = <Args extends unknown[], Return>(fn: (...args: Args) => Return) => {\n  const callbackRef = React.useRef<typeof fn>(() => {\n    throw new Error('Cannot call an event handler while rendering');\n  });\n\n  useIsomorphicLayoutEffect(() => {\n    callbackRef.current = fn;\n  }, [fn]);\n\n  return React.useCallback(\n    (...args: Args) => {\n      const callback = callbackRef.current;\n      return callback(...args);\n    },\n    [callbackRef],\n  );\n};\n"],"names":["React","useIsomorphicLayoutEffect","useEventCallback","fn","callbackRef","useRef","Error","current","useCallback","args","callback"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,yBAAyB,QAAQ,8BAA8B;AAExE;;;;;;;;;;;;CAYC,GACD,OAAO,MAAMC,mBAAmB,CAAiCC,KAAkC;IACjG,MAAMC,cAAcJ,MAAMK,MAAM,CAAY,IAAM;QAChD,MAAM,IAAIC,MAAM,gDAAgD;IAClE;IAEAL,0BAA0B,IAAM;QAC9BG,YAAYG,OAAO,GAAGJ;IACxB,GAAG;QAACA;KAAG;IAEP,OAAOH,MAAMQ,WAAW,CACtB,CAAC,GAAGC,OAAe;QACjB,MAAMC,WAAWN,YAAYG,OAAO;QACpC,OAAOG,YAAYD;IACrB,GACA;QAACL;KAAY;AAEjB,EAAE"}

package/lib/hooks/useFirstMount.js

@@ -9,13 +9,11 @@ import * as React from 'react';
  *
  * @example
  * const isFirstMount = useFirstMount();
- */
-export function useFirstMount() {
-  const isFirst = React.useRef(true);
-  if (isFirst.current) {
-    isFirst.current = false;
-    return true;
-  }
-  return isFirst.current;
+ */ export function useFirstMount() {
+    const isFirst = React.useRef(true);
+    if (isFirst.current) {
+        isFirst.current = false;
+        return true;
+    }
+    return isFirst.current;
 }
-//# sourceMappingURL=useFirstMount.js.map

package/lib/hooks/useFirstMount.js.map

@@ -1 +1 @@
-{"version":3,"names":["React","useFirstMount","isFirst","useRef","current"],"sources":["../../src/hooks/useFirstMount.ts"],"sourcesContent":["import * as React from 'react';\n\n/**\n * @internal\n * Checks if components was mounted the first time.\n * Since concurrent mode will be released in the future this needs to be verified\n * Currently (React 17) will always render the initial mount once\n * https://codesandbox.io/s/heuristic-brook-s4w0q?file=/src/App.jsx\n * https://codesandbox.io/s/holy-grass-8nieu?file=/src/App.jsx\n *\n * @example\n * const isFirstMount = useFirstMount();\n */\nexport function useFirstMount(): boolean {\n  const isFirst = React.useRef(true);\n\n  if (isFirst.current) {\n    isFirst.current = false;\n    return true;\n  }\n\n  return isFirst.current;\n}\n"],"mappings":"AAAA,YAAYA,KAAA,MAAW;AAEvB;;;;;;;;;;;AAWA,OAAO,SAASC,cAAA,EAAyB;EACvC,MAAMC,OAAA,GAAUF,KAAA,CAAMG,MAAM,CAAC,IAAI;EAEjC,IAAID,OAAA,CAAQE,OAAO,EAAE;IACnBF,OAAA,CAAQE,OAAO,GAAG,KAAK;IACvB,OAAO,IAAI;EACb;EAEA,OAAOF,OAAA,CAAQE,OAAO;AACxB"}
+{"version":3,"sources":["useFirstMount.ts"],"sourcesContent":["import * as React from 'react';\n\n/**\n * @internal\n * Checks if components was mounted the first time.\n * Since concurrent mode will be released in the future this needs to be verified\n * Currently (React 17) will always render the initial mount once\n * https://codesandbox.io/s/heuristic-brook-s4w0q?file=/src/App.jsx\n * https://codesandbox.io/s/holy-grass-8nieu?file=/src/App.jsx\n *\n * @example\n * const isFirstMount = useFirstMount();\n */\nexport function useFirstMount(): boolean {\n  const isFirst = React.useRef(true);\n\n  if (isFirst.current) {\n    isFirst.current = false;\n    return true;\n  }\n\n  return isFirst.current;\n}\n"],"names":["React","useFirstMount","isFirst","useRef","current"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B;;;;;;;;;;CAUC,GACD,OAAO,SAASC,gBAAyB;IACvC,MAAMC,UAAUF,MAAMG,MAAM,CAAC,IAAI;IAEjC,IAAID,QAAQE,OAAO,EAAE;QACnBF,QAAQE,OAAO,GAAG,KAAK;QACvB,OAAO,IAAI;IACb,CAAC;IAED,OAAOF,QAAQE,OAAO;AACxB,CAAC"}

package/lib/hooks/useForceUpdate.js

@@ -2,8 +2,6 @@ import { useReducer } from 'react';
 /**
  * @internal
  * Forces a re-render, similar to `forceUpdate` in class components.
- */
-export function useForceUpdate() {
-  return useReducer(x => x + 1, 0)[1];
+ */ export function useForceUpdate() {
+    return useReducer((x)=>x + 1, 0)[1];
 }
-//# sourceMappingURL=useForceUpdate.js.map

package/lib/hooks/useForceUpdate.js.map

@@ -1 +1 @@
-{"version":3,"names":["useReducer","useForceUpdate","x"],"sources":["../../src/hooks/useForceUpdate.ts"],"sourcesContent":["import { useReducer } from 'react';\n\n/**\n * @internal\n * Forces a re-render, similar to `forceUpdate` in class components.\n */\nexport function useForceUpdate() {\n  return useReducer(x => x + 1, 0)[1];\n}\n"],"mappings":"AAAA,SAASA,UAAU,QAAQ;AAE3B;;;;AAIA,OAAO,SAASC,eAAA,EAAiB;EAC/B,OAAOD,UAAA,CAAWE,CAAA,IAAKA,CAAA,GAAI,GAAG,EAAE,CAAC,EAAE;AACrC"}
+{"version":3,"sources":["useForceUpdate.ts"],"sourcesContent":["import { useReducer } from 'react';\n\n/**\n * @internal\n * Forces a re-render, similar to `forceUpdate` in class components.\n */\nexport function useForceUpdate() {\n  return useReducer(x => x + 1, 0)[1];\n}\n"],"names":["useReducer","useForceUpdate","x"],"mappings":"AAAA,SAASA,UAAU,QAAQ,QAAQ;AAEnC;;;CAGC,GACD,OAAO,SAASC,iBAAiB;IAC/B,OAAOD,WAAWE,CAAAA,IAAKA,IAAI,GAAG,EAAE,CAAC,EAAE;AACrC,CAAC"}

package/lib/hooks/useId.js

@@ -1,19 +1,17 @@
 import * as React from 'react';
 import { defaultSSRContextValue, useSSRContext } from '../ssr/index';
-const IdPrefixContext = /*#__PURE__*/React.createContext(undefined);
+const IdPrefixContext = React.createContext(undefined);
 /**
  * Allows to define a prefix that will be used for all IDs generated by useId() hook. It's useful to avoid collisions
  * between different bundles.
- */
-export const IdPrefixProvider = IdPrefixContext.Provider;
+ */ export const IdPrefixProvider = IdPrefixContext.Provider;
 function useIdPrefix() {
-  return React.useContext(IdPrefixContext) || '';
+    return React.useContext(IdPrefixContext) || '';
 }
 /**
  * Resets generated IDs, should be used only in tests.
- */
-export function resetIdsForTests() {
-  defaultSSRContextValue.current = 0;
+ */ export function resetIdsForTests() {
+    defaultSSRContextValue.current = 0;
 }
 /**
  * Hook to generate a unique ID.
@@ -22,27 +20,32 @@ export function resetIdsForTests() {
  * @param providedId - Optional id provided by a parent component. Defaults to the provided value if present,
  *  without conditioning the hook call
  * @returns The ID
- */
-export function useId(prefix = 'fui-', providedId) {
-  const contextValue = useSSRContext();
-  const idPrefix = useIdPrefix();
-  // Checking if useId is available on React, if it is, we use it to generate the id. String concatenation is used to
-  // prevent bundlers from complaining with older versions of React.
-  const _useId = React['use' + 'Id'];
-  if (_useId) {
-    const generatedId = _useId();
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    const escapedId = React.useMemo(() => generatedId.replace(/:/g, ''), [generatedId]);
-    return providedId || `${idPrefix}${prefix}${escapedId}`;
-  }
-  // Hooks appear to be running conditionally, but they will always run in the same order since it's based on
-  // the version of React being used. This is safe to ignore.
-  // eslint-disable-next-line react-hooks/rules-of-hooks
-  return React.useMemo(() => {
-    if (providedId) {
-      return providedId;
+ */ export function useId(prefix = 'fui-', providedId) {
+    const contextValue = useSSRContext();
+    const idPrefix = useIdPrefix();
+    // Checking if useId is available on React, if it is, we use it to generate the id. String concatenation is used to
+    // prevent bundlers from complaining with older versions of React.
+    const _useId = React['use' + 'Id'];
+    if (_useId) {
+        const generatedId = _useId();
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        const escapedId = React.useMemo(()=>generatedId.replace(/:/g, ''), [
+            generatedId
+        ]);
+        return providedId || `${idPrefix}${prefix}${escapedId}`;
     }
-    return `${idPrefix}${prefix}${++contextValue.current}`;
-  }, [idPrefix, prefix, providedId, contextValue]);
+    // Hooks appear to be running conditionally, but they will always run in the same order since it's based on
+    // the version of React being used. This is safe to ignore.
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    return React.useMemo(()=>{
+        if (providedId) {
+            return providedId;
+        }
+        return `${idPrefix}${prefix}${++contextValue.current}`;
+    }, [
+        idPrefix,
+        prefix,
+        providedId,
+        contextValue
+    ]);
 }
-//# sourceMappingURL=useId.js.map

package/lib/hooks/useId.js.map

@@ -1 +1 @@
-{"version":3,"names":["React","defaultSSRContextValue","useSSRContext","IdPrefixContext","createContext","undefined","IdPrefixProvider","Provider","useIdPrefix","useContext","resetIdsForTests","current","useId","prefix","providedId","contextValue","idPrefix","_useId","generatedId","escapedId","useMemo","replace"],"sources":["../../src/hooks/useId.ts"],"sourcesContent":["import * as React from 'react';\nimport { defaultSSRContextValue, useSSRContext } from '../ssr/index';\n\nconst IdPrefixContext = React.createContext<string | undefined>(undefined);\n\n/**\n * Allows to define a prefix that will be used for all IDs generated by useId() hook. It's useful to avoid collisions\n * between different bundles.\n */\nexport const IdPrefixProvider = IdPrefixContext.Provider;\n\nfunction useIdPrefix(): string {\n  return React.useContext(IdPrefixContext) || '';\n}\n\n/**\n * Resets generated IDs, should be used only in tests.\n */\nexport function resetIdsForTests(): void {\n  defaultSSRContextValue.current = 0;\n}\n\n/**\n * Hook to generate a unique ID.\n *\n * @param prefix - Optional prefix for the ID. Defaults to 'fui-'.\n * @param providedId - Optional id provided by a parent component. Defaults to the provided value if present,\n *  without conditioning the hook call\n * @returns The ID\n */\nexport function useId(prefix: string = 'fui-', providedId?: string): string {\n  const contextValue = useSSRContext();\n  const idPrefix = useIdPrefix();\n\n  // Checking if useId is available on React, if it is, we use it to generate the id. String concatenation is used to\n  // prevent bundlers from complaining with older versions of React.\n  const _useId = (React as never)['use' + 'Id'] as (() => string) | undefined;\n\n  if (_useId) {\n    const generatedId = _useId();\n\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    const escapedId = React.useMemo(() => generatedId.replace(/:/g, ''), [generatedId]);\n\n    return providedId || `${idPrefix}${prefix}${escapedId}`;\n  }\n\n  // Hooks appear to be running conditionally, but they will always run in the same order since it's based on\n  // the version of React being used. This is safe to ignore.\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  return React.useMemo(() => {\n    if (providedId) {\n      return providedId;\n    }\n\n    return `${idPrefix}${prefix}${++contextValue.current}`;\n  }, [idPrefix, prefix, providedId, contextValue]);\n}\n"],"mappings":"AAAA,YAAYA,KAAA,MAAW;AACvB,SAASC,sBAAsB,EAAEC,aAAa,QAAQ;AAEtD,MAAMC,eAAA,gBAAkBH,KAAA,CAAMI,aAAa,CAAqBC,SAAA;AAEhE;;;;AAIA,OAAO,MAAMC,gBAAA,GAAmBH,eAAA,CAAgBI,QAAQ;AAExD,SAASC,YAAA,EAAsB;EAC7B,OAAOR,KAAA,CAAMS,UAAU,CAACN,eAAA,KAAoB;AAC9C;AAEA;;;AAGA,OAAO,SAASO,iBAAA,EAAyB;EACvCT,sBAAA,CAAuBU,OAAO,GAAG;AACnC;AAEA;;;;;;;;AAQA,OAAO,SAASC,MAAMC,MAAA,GAAiB,MAAM,EAAEC,UAAmB,EAAU;EAC1E,MAAMC,YAAA,GAAeb,aAAA;EACrB,MAAMc,QAAA,GAAWR,WAAA;EAEjB;EACA;EACA,MAAMS,MAAA,GAASjB,KAAgB,CAAC,QAAQ,KAAK;EAE7C,IAAIiB,MAAA,EAAQ;IACV,MAAMC,WAAA,GAAcD,MAAA;IAEpB;IACA,MAAME,SAAA,GAAYnB,KAAA,CAAMoB,OAAO,CAAC,MAAMF,WAAA,CAAYG,OAAO,CAAC,MAAM,KAAK,CAACH,WAAA,CAAY;IAElF,OAAOJ,UAAA,IAAe,GAAEE,QAAS,GAAEH,MAAO,GAAEM,SAAU,EAAC;EACzD;EAEA;EACA;EACA;EACA,OAAOnB,KAAA,CAAMoB,OAAO,CAAC,MAAM;IACzB,IAAIN,UAAA,EAAY;MACd,OAAOA,UAAA;IACT;IAEA,OAAQ,GAAEE,QAAS,GAAEH,MAAO,GAAE,EAAEE,YAAA,CAAaJ,OAAQ,EAAC;EACxD,GAAG,CAACK,QAAA,EAAUH,MAAA,EAAQC,UAAA,EAAYC,YAAA,CAAa;AACjD"}
+{"version":3,"sources":["useId.ts"],"sourcesContent":["import * as React from 'react';\nimport { defaultSSRContextValue, useSSRContext } from '../ssr/index';\n\nconst IdPrefixContext = React.createContext<string | undefined>(undefined);\n\n/**\n * Allows to define a prefix that will be used for all IDs generated by useId() hook. It's useful to avoid collisions\n * between different bundles.\n */\nexport const IdPrefixProvider = IdPrefixContext.Provider;\n\nfunction useIdPrefix(): string {\n  return React.useContext(IdPrefixContext) || '';\n}\n\n/**\n * Resets generated IDs, should be used only in tests.\n */\nexport function resetIdsForTests(): void {\n  defaultSSRContextValue.current = 0;\n}\n\n/**\n * Hook to generate a unique ID.\n *\n * @param prefix - Optional prefix for the ID. Defaults to 'fui-'.\n * @param providedId - Optional id provided by a parent component. Defaults to the provided value if present,\n *  without conditioning the hook call\n * @returns The ID\n */\nexport function useId(prefix: string = 'fui-', providedId?: string): string {\n  const contextValue = useSSRContext();\n  const idPrefix = useIdPrefix();\n\n  // Checking if useId is available on React, if it is, we use it to generate the id. String concatenation is used to\n  // prevent bundlers from complaining with older versions of React.\n  const _useId = (React as never)['use' + 'Id'] as (() => string) | undefined;\n\n  if (_useId) {\n    const generatedId = _useId();\n\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    const escapedId = React.useMemo(() => generatedId.replace(/:/g, ''), [generatedId]);\n\n    return providedId || `${idPrefix}${prefix}${escapedId}`;\n  }\n\n  // Hooks appear to be running conditionally, but they will always run in the same order since it's based on\n  // the version of React being used. This is safe to ignore.\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  return React.useMemo(() => {\n    if (providedId) {\n      return providedId;\n    }\n\n    return `${idPrefix}${prefix}${++contextValue.current}`;\n  }, [idPrefix, prefix, providedId, contextValue]);\n}\n"],"names":["React","defaultSSRContextValue","useSSRContext","IdPrefixContext","createContext","undefined","IdPrefixProvider","Provider","useIdPrefix","useContext","resetIdsForTests","current","useId","prefix","providedId","contextValue","idPrefix","_useId","generatedId","escapedId","useMemo","replace"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,sBAAsB,EAAEC,aAAa,QAAQ,eAAe;AAErE,MAAMC,kBAAkBH,MAAMI,aAAa,CAAqBC;AAEhE;;;CAGC,GACD,OAAO,MAAMC,mBAAmBH,gBAAgBI,QAAQ,CAAC;AAEzD,SAASC,cAAsB;IAC7B,OAAOR,MAAMS,UAAU,CAACN,oBAAoB;AAC9C;AAEA;;CAEC,GACD,OAAO,SAASO,mBAAyB;IACvCT,uBAAuBU,OAAO,GAAG;AACnC,CAAC;AAED;;;;;;;CAOC,GACD,OAAO,SAASC,MAAMC,SAAiB,MAAM,EAAEC,UAAmB,EAAU;IAC1E,MAAMC,eAAeb;IACrB,MAAMc,WAAWR;IAEjB,mHAAmH;IACnH,kEAAkE;IAClE,MAAMS,SAAS,AAACjB,KAAe,CAAC,QAAQ,KAAK;IAE7C,IAAIiB,QAAQ;QACV,MAAMC,cAAcD;QAEpB,sDAAsD;QACtD,MAAME,YAAYnB,MAAMoB,OAAO,CAAC,IAAMF,YAAYG,OAAO,CAAC,MAAM,KAAK;YAACH;SAAY;QAElF,OAAOJ,cAAc,CAAC,EAAEE,SAAS,EAAEH,OAAO,EAAEM,UAAU,CAAC;IACzD,CAAC;IAED,2GAA2G;IAC3G,2DAA2D;IAC3D,sDAAsD;IACtD,OAAOnB,MAAMoB,OAAO,CAAC,IAAM;QACzB,IAAIN,YAAY;YACd,OAAOA;QACT,CAAC;QAED,OAAO,CAAC,EAAEE,SAAS,EAAEH,OAAO,EAAE,EAAEE,aAAaJ,OAAO,CAAC,CAAC;IACxD,GAAG;QAACK;QAAUH;QAAQC;QAAYC;KAAa;AACjD,CAAC"}

package/lib/hooks/useIsomorphicLayoutEffect.js

@@ -9,5 +9,4 @@ import { canUseDOM } from '../ssr/index';
  * https://gist.github.com/gaearon/e7d97cdf38a2907924ea12e4ebdf3c85
  * https://github.com/reduxjs/react-redux/blob/master/src/utils/useIsomorphicLayoutEffect.js
  */ // eslint-disable-next-line no-restricted-properties
-export const useIsomorphicLayoutEffect = /*#__PURE__*/canUseDOM() ? React.useLayoutEffect : React.useEffect;
-//# sourceMappingURL=useIsomorphicLayoutEffect.js.map
+export const useIsomorphicLayoutEffect = canUseDOM() ? React.useLayoutEffect : React.useEffect;

package/lib/hooks/useIsomorphicLayoutEffect.js.map

@@ -1 +1 @@
-{"version":3,"names":["React","canUseDOM","useIsomorphicLayoutEffect","useLayoutEffect","useEffect"],"sources":["../../src/hooks/useIsomorphicLayoutEffect.ts"],"sourcesContent":["import * as React from 'react';\nimport { canUseDOM } from '../ssr/index';\n\n/**\n * React currently throws a warning when using useLayoutEffect on the server. To get around it, we can conditionally\n * useEffect on the server (no-op) and useLayoutEffect in the browser. We occasionally need useLayoutEffect to\n * ensure we don't get a render flash for certain operations, but we may also need affected components to render on\n * the server.\n *\n * https://gist.github.com/gaearon/e7d97cdf38a2907924ea12e4ebdf3c85\n * https://github.com/reduxjs/react-redux/blob/master/src/utils/useIsomorphicLayoutEffect.js\n */\n// eslint-disable-next-line no-restricted-properties\nexport const useIsomorphicLayoutEffect: typeof React.useEffect = canUseDOM() ? React.useLayoutEffect : React.useEffect;\n"],"mappings":"AAAA,YAAYA,KAAA,MAAW;AACvB,SAASC,SAAS,QAAQ;AAE1B;;;;;;;;GAAA,CASA;AACA,OAAO,MAAMC,yBAAA,GAAoD,aAAAD,SAAA,KAAcD,KAAA,CAAMG,eAAe,GAAGH,KAAA,CAAMI,SAAS"}
+{"version":3,"sources":["useIsomorphicLayoutEffect.ts"],"sourcesContent":["import * as React from 'react';\nimport { canUseDOM } from '../ssr/index';\n\n/**\n * React currently throws a warning when using useLayoutEffect on the server. To get around it, we can conditionally\n * useEffect on the server (no-op) and useLayoutEffect in the browser. We occasionally need useLayoutEffect to\n * ensure we don't get a render flash for certain operations, but we may also need affected components to render on\n * the server.\n *\n * https://gist.github.com/gaearon/e7d97cdf38a2907924ea12e4ebdf3c85\n * https://github.com/reduxjs/react-redux/blob/master/src/utils/useIsomorphicLayoutEffect.js\n */\n// eslint-disable-next-line no-restricted-properties\nexport const useIsomorphicLayoutEffect: typeof React.useEffect = canUseDOM() ? React.useLayoutEffect : React.useEffect;\n"],"names":["React","canUseDOM","useIsomorphicLayoutEffect","useLayoutEffect","useEffect"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,SAAS,QAAQ,eAAe;AAEzC;;;;;;;;CAQC,GACD,oDAAoD;AACpD,OAAO,MAAMC,4BAAoDD,cAAcD,MAAMG,eAAe,GAAGH,MAAMI,SAAS,CAAC"}

package/lib/hooks/useMergedRefs.js

@@ -4,22 +4,21 @@ import * as React from 'react';
  * updates all provided refs
  * @param refs - Refs to collectively update with one ref value.
  * @returns A function with an attached "current" prop, so that it can be treated like a RefObject.
- */
-export function useMergedRefs(...refs) {
-  const mergedCallback = React.useCallback(value => {
-    // Update the "current" prop hanging on the function.
-    mergedCallback.current = value;
-    for (const ref of refs) {
-      if (typeof ref === 'function') {
-        ref(value);
-      } else if (ref) {
-        // work around the immutability of the React.Ref type
-        ref.current = value;
-      }
-    }
-  },
-  // eslint-disable-next-line react-hooks/exhaustive-deps -- already exhaustive
-  [...refs]);
-  return mergedCallback;
+ */ export function useMergedRefs(...refs) {
+    const mergedCallback = React.useCallback((value)=>{
+        // Update the "current" prop hanging on the function.
+        mergedCallback.current = value;
+        for (const ref of refs){
+            if (typeof ref === 'function') {
+                ref(value);
+            } else if (ref) {
+                // work around the immutability of the React.Ref type
+                ref.current = value;
+            }
+        }
+    }, // eslint-disable-next-line react-hooks/exhaustive-deps -- already exhaustive
+    [
+        ...refs
+    ]);
+    return mergedCallback;
 }
-//# sourceMappingURL=useMergedRefs.js.map

package/lib/hooks/useMergedRefs.js.map

@@ -1 +1 @@
-{"version":3,"names":["React","useMergedRefs","refs","mergedCallback","useCallback","value","current","ref"],"sources":["../../src/hooks/useMergedRefs.ts"],"sourcesContent":["import * as React from 'react';\n\n/**\n * A Ref function which can be treated like a ref object in that it has an attached\n * current property, which will be updated as the ref is evaluated.\n */\nexport type RefObjectFunction<T> = React.RefObject<T> & ((value: T) => void);\n\n/**\n * React hook to merge multiple React refs (either MutableRefObjects or ref callbacks) into a single ref callback that\n * updates all provided refs\n * @param refs - Refs to collectively update with one ref value.\n * @returns A function with an attached \"current\" prop, so that it can be treated like a RefObject.\n */\nexport function useMergedRefs<T>(...refs: (React.Ref<T> | undefined)[]): RefObjectFunction<T> {\n  const mergedCallback: RefObjectFunction<T> = React.useCallback(\n    (value: T) => {\n      // Update the \"current\" prop hanging on the function.\n      (mergedCallback as unknown as React.MutableRefObject<T>).current = value;\n\n      for (const ref of refs) {\n        if (typeof ref === 'function') {\n          ref(value);\n        } else if (ref) {\n          // work around the immutability of the React.Ref type\n          (ref as unknown as React.MutableRefObject<T>).current = value;\n        }\n      }\n    },\n    // eslint-disable-next-line react-hooks/exhaustive-deps -- already exhaustive\n    [...refs],\n  ) as unknown as RefObjectFunction<T>;\n\n  return mergedCallback;\n}\n"],"mappings":"AAAA,YAAYA,KAAA,MAAW;AAQvB;;;;;;AAMA,OAAO,SAASC,cAAiB,GAAGC,IAAkC,EAAwB;EAC5F,MAAMC,cAAA,GAAuCH,KAAA,CAAMI,WAAW,CAC3DC,KAAA,IAAa;IACZ;IACCF,cAAA,CAAwDG,OAAO,GAAGD,KAAA;IAEnE,KAAK,MAAME,GAAA,IAAOL,IAAA,EAAM;MACtB,IAAI,OAAOK,GAAA,KAAQ,YAAY;QAC7BA,GAAA,CAAIF,KAAA;MACN,OAAO,IAAIE,GAAA,EAAK;QACd;QACCA,GAAA,CAA6CD,OAAO,GAAGD,KAAA;MAC1D;IACF;EACF;EACA;EACA,C,GAAIH,IAAA,CAAK;EAGX,OAAOC,cAAA;AACT"}
+{"version":3,"sources":["useMergedRefs.ts"],"sourcesContent":["import * as React from 'react';\n\n/**\n * A Ref function which can be treated like a ref object in that it has an attached\n * current property, which will be updated as the ref is evaluated.\n */\nexport type RefObjectFunction<T> = React.RefObject<T> & ((value: T) => void);\n\n/**\n * React hook to merge multiple React refs (either MutableRefObjects or ref callbacks) into a single ref callback that\n * updates all provided refs\n * @param refs - Refs to collectively update with one ref value.\n * @returns A function with an attached \"current\" prop, so that it can be treated like a RefObject.\n */\nexport function useMergedRefs<T>(...refs: (React.Ref<T> | undefined)[]): RefObjectFunction<T> {\n  const mergedCallback: RefObjectFunction<T> = React.useCallback(\n    (value: T) => {\n      // Update the \"current\" prop hanging on the function.\n      (mergedCallback as unknown as React.MutableRefObject<T>).current = value;\n\n      for (const ref of refs) {\n        if (typeof ref === 'function') {\n          ref(value);\n        } else if (ref) {\n          // work around the immutability of the React.Ref type\n          (ref as unknown as React.MutableRefObject<T>).current = value;\n        }\n      }\n    },\n    // eslint-disable-next-line react-hooks/exhaustive-deps -- already exhaustive\n    [...refs],\n  ) as unknown as RefObjectFunction<T>;\n\n  return mergedCallback;\n}\n"],"names":["React","useMergedRefs","refs","mergedCallback","useCallback","value","current","ref"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAQ/B;;;;;CAKC,GACD,OAAO,SAASC,cAAiB,GAAGC,IAAkC,EAAwB;IAC5F,MAAMC,iBAAuCH,MAAMI,WAAW,CAC5D,CAACC,QAAa;QACZ,qDAAqD;QACpDF,eAAwDG,OAAO,GAAGD;QAEnE,KAAK,MAAME,OAAOL,KAAM;YACtB,IAAI,OAAOK,QAAQ,YAAY;gBAC7BA,IAAIF;YACN,OAAO,IAAIE,KAAK;gBACd,qDAAqD;gBACpDA,IAA6CD,OAAO,GAAGD;YAC1D,CAAC;QACH;IACF,GACA,6EAA6E;IAC7E;WAAIH;KAAK;IAGX,OAAOC;AACT,CAAC"}