@fluentui/react-utilities 9.3.0 → 9.4.0

package/CHANGELOG.json

@@ -2,7 +2,51 @@
   "name": "@fluentui/react-utilities",
   "entries": [
     {
-      "date": "Tue, 20 Dec 2022 14:55:58 GMT",
+      "date": "Mon, 09 Jan 2023 14:31:49 GMT",
+      "tag": "@fluentui/react-utilities_v9.4.0",
+      "version": "9.4.0",
+      "comments": {
+        "minor": [
+          {
+            "author": "lingfangao@hotmail.com",
+            "package": "@fluentui/react-utilities",
+            "commit": "3c3291c008824d45e18580d51b6eb1526ea3792d",
+            "comment": "feat: implement `useScrollbarWidth` utility hook"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Wed, 04 Jan 2023 01:40:43 GMT",
+      "tag": "@fluentui/react-utilities_v9.3.1",
+      "version": "9.3.1",
+      "comments": {
+        "none": [
+          {
+            "author": "martinhochel@microsoft.com",
+            "package": "@fluentui/react-utilities",
+            "commit": "194b0cf0cc27c1c1233aa945f09b3ad29778d8ca",
+            "comment": "chore(scripts): use for @fluentui/scripts version within all package.json"
+          },
+          {
+            "author": "martinhochel@microsoft.com",
+            "package": "@fluentui/react-utilities",
+            "commit": "4ec2b998b294d6d9c3196d3d82893bdd97d0c105",
+            "comment": "chore(scripts): move index.ts to  to follow sub-folder domain packaging"
+          }
+        ],
+        "patch": [
+          {
+            "author": "bernardo.sunderhus@gmail.com",
+            "package": "@fluentui/react-utilities",
+            "commit": "2d76331327dc83bd7117e61e075a016e33b26731",
+            "comment": "feat: generalize is HTMLElement attribute to unknown"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Tue, 20 Dec 2022 14:59:33 GMT",
       "tag": "@fluentui/react-utilities_v9.3.0",
       "version": "9.3.0",
       "comments": {

package/CHANGELOG.md

@@ -1,12 +1,30 @@
 # Change Log - @fluentui/react-utilities
 
-This log was last generated on Tue, 20 Dec 2022 14:55:58 GMT and should not be manually modified.
+This log was last generated on Mon, 09 Jan 2023 14:31:49 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## [9.4.0](https://github.com/microsoft/fluentui/tree/@fluentui/react-utilities_v9.4.0)
+
+Mon, 09 Jan 2023 14:31:49 GMT 
+[Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-utilities_v9.3.1..@fluentui/react-utilities_v9.4.0)
+
+### Minor changes
+
+- feat: implement `useScrollbarWidth` utility hook ([PR #26144](https://github.com/microsoft/fluentui/pull/26144) by lingfangao@hotmail.com)
+
+## [9.3.1](https://github.com/microsoft/fluentui/tree/@fluentui/react-utilities_v9.3.1)
+
+Wed, 04 Jan 2023 01:40:43 GMT 
+[Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-utilities_v9.3.0..@fluentui/react-utilities_v9.3.1)
+
+### Patches
+
+- feat: generalize is HTMLElement attribute to unknown ([PR #25991](https://github.com/microsoft/fluentui/pull/25991) by bernardo.sunderhus@gmail.com)
+
 ## [9.3.0](https://github.com/microsoft/fluentui/tree/@fluentui/react-utilities_v9.3.0)
 
-Tue, 20 Dec 2022 14:55:58 GMT 
+Tue, 20 Dec 2022 14:59:33 GMT 
 [Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-utilities_v9.2.2..@fluentui/react-utilities_v9.3.0)
 
 ### Minor changes

package/dist/index.d.ts

@@ -197,13 +197,13 @@ export declare function isFluentTrigger(element: React_2.ReactElement): element
  * might be problematic while operating with [multiple realms](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms)
  *
  */
-export declare function isHTMLElement(element?: Node | null | undefined): element is HTMLElement;
+export declare function isHTMLElement(element?: unknown): element is HTMLElement;
 
 /**
  * @internal
  * Checks that the element has default behaviour from user input on click or 'Enter'/'Space' keys
  */
-export declare function isInteractiveHTMLElement(element: Node | null | undefined): boolean;
+export declare function isInteractiveHTMLElement(element: unknown): boolean;
 
 /**
  * Guard method that validates if a shorthand is a slot
@@ -575,6 +575,22 @@ export declare const useOnScrollOutside: (options: UseOnClickOrScrollOutsideOpti
  */
 export declare const usePrevious: <ValueType = unknown>(value: ValueType) => ValueType | null;
 
+/**
+ * @returns The width in pixels of the scrollbar in the user agent
+ */
+export declare function useScrollbarWidth(options: UseScrollbarWidthOptions): number | undefined;
+
+declare interface UseScrollbarWidthOptions {
+    /**
+     * Reference document to measure the scrollbar width
+     */
+    targetDocument: Document | null | undefined;
+    /**
+     * Does not use the cache and recalculates the scrollbar width
+     */
+    force?: boolean;
+}
+
 /**
  * @internal
  * Helper to manage a browser timeout.

package/lib/compose/getSlots.js

@@ -17,45 +17,37 @@ import { omit } from '../utils/omit';
  * @param state - State including slot definitions
  * @returns An object containing the `slots` map and `slotProps` map.
  */
-
 export function getSlots(state) {
   const slots = {};
   const slotProps = {};
   const slotNames = Object.keys(state.components);
-
   for (const slotName of slotNames) {
     const [slot, props] = getSlot(state, slotName);
     slots[slotName] = slot;
     slotProps[slotName] = props;
   }
-
   return {
     slots,
     slotProps: slotProps
   };
 }
-
 function getSlot(state, slotName) {
   var _a, _b, _c;
-
   if (state[slotName] === undefined) {
     return [null, undefined];
   }
-
   const {
     children,
     as: asProp,
     ...rest
   } = state[slotName];
   const slot = ((_a = state.components) === null || _a === void 0 ? void 0 : _a[slotName]) === undefined || typeof state.components[slotName] === 'string' ? asProp || ((_b = state.components) === null || _b === void 0 ? void 0 : _b[slotName]) || 'div' : state.components[slotName];
-
   if (typeof children === 'function') {
     const render = children;
     return [React.Fragment, {
       children: render(slot, rest)
     }];
   }
-
   const shouldOmitAsProp = typeof slot === 'string' && ((_c = state[slotName]) === null || _c === void 0 ? void 0 : _c.as);
   const slotProps = shouldOmitAsProp ? omit(state[slotName], ['as']) : state[slotName];
   return [slot, slotProps];

package/lib/compose/getSlots.js.map

@@ -1 +1 @@
-{"version":3,"sources":["packages/react-components/react-utilities/src/compose/getSlots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAZ,MAAuB,OAAvB;AAEA,SAAS,IAAT,QAAqB,eAArB;AA6BA;;;;;;;;;;;;;;;;AAgBG;;AACH,OAAM,SAAU,QAAV,CACJ,KADI,EACoB;EAKxB,MAAM,KAAK,GAAG,EAAd;EACA,MAAM,SAAS,GAAG,EAAlB;EAEA,MAAM,SAAS,GAAgB,MAAM,CAAC,IAAP,CAAY,KAAK,CAAC,UAAlB,CAA/B;;EACA,KAAK,MAAM,QAAX,IAAuB,SAAvB,EAAkC;IAChC,MAAM,CAAC,IAAD,EAAO,KAAP,IAAgB,OAAO,CAAC,KAAD,EAAQ,QAAR,CAA7B;IACA,KAAK,CAAC,QAAD,CAAL,GAAkB,IAAlB;IACA,SAAS,CAAC,QAAD,CAAT,GAAsB,KAAtB;EACD;;EACD,OAAO;IAAE,KAAF;IAAS,SAAS,EAAG;EAArB,CAAP;AACD;;AAED,SAAS,OAAT,CACE,KADF,EAEE,QAFF,EAEa;;;EAEX,IAAI,KAAK,CAAC,QAAD,CAAL,KAAoB,SAAxB,EAAmC;IACjC,OAAO,CAAC,IAAD,EAAO,SAAP,CAAP;EACD;;EACD,MAAM;IAAE,QAAF;IAAY,EAAE,EAAE,MAAhB;IAAwB,GAAG;EAA3B,IAAoC,KAAK,CAAC,QAAD,CAA/C;EAEA,MAAM,IAAI,GAAI,CAAA,CAAA,EAAA,GAAA,KAAK,CAAC,UAAN,MAAgB,IAAhB,IAAgB,EAAA,KAAA,KAAA,CAAhB,GAAgB,KAAA,CAAhB,GAAgB,EAAA,CAAG,QAAH,CAAhB,MAAiC,SAAjC,IAA8C,OAAO,KAAK,CAAC,UAAN,CAAiB,QAAjB,CAAP,KAAsC,QAApF,GACV,MAAM,KAAI,CAAA,EAAA,GAAA,KAAK,CAAC,UAAN,MAAgB,IAAhB,IAAgB,EAAA,KAAA,KAAA,CAAhB,GAAgB,KAAA,CAAhB,GAAgB,EAAA,CAAG,QAAH,CAApB,CAAN,IAA0C,KADhC,GAEV,KAAK,CAAC,UAAN,CAAiB,QAAjB,CAFJ;;EAIA,IAAI,OAAO,QAAP,KAAoB,UAAxB,EAAoC;IAClC,MAAM,MAAM,GAAG,QAAf;IACA,OAAO,CACL,KAAK,CAAC,QADD,EAEJ;MACC,QAAQ,EAAE,MAAM,CAAC,IAAD,EAAO,IAAP;IADjB,CAFI,CAAP;EAMD;;EAED,MAAM,gBAAgB,GAAG,OAAO,IAAP,KAAgB,QAAhB,KAA4B,CAAA,EAAA,GAAA,KAAK,CAAC,QAAD,CAAL,MAAe,IAAf,IAAe,EAAA,KAAA,KAAA,CAAf,GAAe,KAAA,CAAf,GAAe,EAAA,CAAE,EAA7C,CAAzB;EACA,MAAM,SAAS,GAAI,gBAAgB,GAAG,IAAI,CAAC,KAAK,CAAC,QAAD,CAAN,EAAmB,CAAC,IAAD,CAAnB,CAAP,GAAoC,KAAK,CAAC,QAAD,CAA5E;EAEA,OAAO,CAAC,IAAD,EAAO,SAAP,CAAP;AACD","sourcesContent":["import * as React from 'react';\n\nimport { omit } from '../utils/omit';\nimport type {\n  AsIntrinsicElement,\n  ComponentState,\n  ExtractSlotProps,\n  SlotPropsRecord,\n  SlotRenderFunction,\n  UnionToIntersection,\n} from './types';\n\nexport type Slots<S extends SlotPropsRecord> = {\n  [K in keyof S]: ExtractSlotProps<S[K]> extends AsIntrinsicElement<infer As>\n    ? // for slots with an `as` prop, the slot will be any one of the possible values of `as`\n      As\n    : ExtractSlotProps<S[K]> extends React.ComponentType<infer P>\n    ? React.ElementType<NonNullable<P>>\n    : React.ElementType<ExtractSlotProps<S[K]>>;\n};\n\ntype ObjectSlotProps<S extends SlotPropsRecord> = {\n  [K in keyof S]-?: ExtractSlotProps<S[K]> extends AsIntrinsicElement<infer As>\n    ? // For intrinsic element types, return the intersection of all possible\n      // element's props, to be compatible with the As type returned by Slots<>\n      UnionToIntersection<JSX.IntrinsicElements[As]>\n    : ExtractSlotProps<S[K]> extends React.ComponentType<infer P>\n    ? P\n    : never;\n};\n\n/**\n * Given the state and an array of slot names, will break out `slots` and `slotProps`\n * collections.\n *\n * The root is derived from a mix of `components` props and `as` prop.\n *\n * Slots will render as null if they are rendered as primitives with undefined children.\n *\n * The slotProps will always omit the `as` prop within them, and for slots that are string\n * primitives, the props will be filtered according to the slot type by the type system.\n * For example, if the slot is rendered `as: 'a'`, the props will be filtered for acceptable\n * anchor props. Note that this is only enforced at build time by Typescript -- there is no\n * runtime code filtering props in this function.\n *\n * @param state - State including slot definitions\n * @returns An object containing the `slots` map and `slotProps` map.\n */\nexport function getSlots<R extends SlotPropsRecord>(\n  state: ComponentState<R>,\n): {\n  slots: Slots<R>;\n  slotProps: ObjectSlotProps<R>;\n} {\n  const slots = {} as Slots<R>;\n  const slotProps = {} as R;\n\n  const slotNames: (keyof R)[] = Object.keys(state.components);\n  for (const slotName of slotNames) {\n    const [slot, props] = getSlot(state, slotName);\n    slots[slotName] = slot as Slots<R>[typeof slotName];\n    slotProps[slotName] = props;\n  }\n  return { slots, slotProps: (slotProps as unknown) as ObjectSlotProps<R> };\n}\n\nfunction getSlot<R extends SlotPropsRecord, K extends keyof R>(\n  state: ComponentState<R>,\n  slotName: K,\n): readonly [React.ElementType<R[K]> | null, R[K]] {\n  if (state[slotName] === undefined) {\n    return [null, undefined as R[K]];\n  }\n  const { children, as: asProp, ...rest } = state[slotName]!;\n\n  const slot = (state.components?.[slotName] === undefined || typeof state.components[slotName] === 'string'\n    ? asProp || state.components?.[slotName] || 'div'\n    : state.components[slotName]) as React.ElementType<R[K]>;\n\n  if (typeof children === 'function') {\n    const render = children as SlotRenderFunction<R[K]>;\n    return [\n      React.Fragment,\n      ({\n        children: render(slot, rest as Omit<R[K], 'children' | 'as'>),\n      } as unknown) as R[K],\n    ];\n  }\n\n  const shouldOmitAsProp = typeof slot === 'string' && state[slotName]?.as;\n  const slotProps = (shouldOmitAsProp ? omit(state[slotName]!, ['as']) : state[slotName]) as R[K];\n\n  return [slot, slotProps];\n}\n"],"sourceRoot":"../src/"}
+{"version":3,"mappings":"AAAA,OAAO,KAAKA,KAAK,MAAM,OAAO;AAE9B,SAASC,IAAI,QAAQ,eAAe;AA6BpC;;;;;;;;;;;;;;;;;AAiBA,OAAM,SAAUC,QAAQ,CACtBC,KAAwB;EAKxB,MAAMC,KAAK,GAAG,EAAc;EAC5B,MAAMC,SAAS,GAAG,EAAO;EAEzB,MAAMC,SAAS,GAAgBC,MAAM,CAACC,IAAI,CAACL,KAAK,CAACM,UAAU,CAAC;EAC5D,KAAK,MAAMC,QAAQ,IAAIJ,SAAS,EAAE;IAChC,MAAM,CAACK,IAAI,EAAEC,KAAK,CAAC,GAAGC,OAAO,CAACV,KAAK,EAAEO,QAAQ,CAAC;IAC9CN,KAAK,CAACM,QAAQ,CAAC,GAAGC,IAAiC;IACnDN,SAAS,CAACK,QAAQ,CAAC,GAAGE,KAAK;;EAE7B,OAAO;IAAER,KAAK;IAAEC,SAAS,EAAGA;EAA2C,CAAE;AAC3E;AAEA,SAASQ,OAAO,CACdV,KAAwB,EACxBO,QAAW;;EAEX,IAAIP,KAAK,CAACO,QAAQ,CAAC,KAAKI,SAAS,EAAE;IACjC,OAAO,CAAC,IAAI,EAAEA,SAAiB,CAAC;;EAElC,MAAM;IAAEC,QAAQ;IAAEC,EAAE,EAAEC,MAAM;IAAE,GAAGC;EAAI,CAAE,GAAGf,KAAK,CAACO,QAAQ,CAAE;EAE1D,MAAMC,IAAI,GAAI,YAAK,CAACF,UAAU,0CAAGC,QAAQ,CAAC,MAAKI,SAAS,IAAI,OAAOX,KAAK,CAACM,UAAU,CAACC,QAAQ,CAAC,KAAK,QAAQ,GACtGO,MAAM,KAAI,WAAK,CAACR,UAAU,0CAAGC,QAAQ,CAAC,KAAI,KAAK,GAC/CP,KAAK,CAACM,UAAU,CAACC,QAAQ,CAA6B;EAE1D,IAAI,OAAOK,QAAQ,KAAK,UAAU,EAAE;IAClC,MAAMI,MAAM,GAAGJ,QAAoC;IACnD,OAAO,CACLf,KAAK,CAACoB,QAAQ,EACb;MACCL,QAAQ,EAAEI,MAAM,CAACR,IAAI,EAAEO,IAAqC;KACzC,CACtB;;EAGH,MAAMG,gBAAgB,GAAG,OAAOV,IAAI,KAAK,QAAQ,KAAI,WAAK,CAACD,QAAQ,CAAC,0CAAEM,EAAE;EACxE,MAAMX,SAAS,GAAIgB,gBAAgB,GAAGpB,IAAI,CAACE,KAAK,CAACO,QAAQ,CAAE,EAAE,CAAC,IAAI,CAAC,CAAC,GAAGP,KAAK,CAACO,QAAQ,CAAU;EAE/F,OAAO,CAACC,IAAI,EAAEN,SAAS,CAAC;AAC1B","names":["React","omit","getSlots","state","slots","slotProps","slotNames","Object","keys","components","slotName","slot","props","getSlot","undefined","children","as","asProp","rest","render","Fragment","shouldOmitAsProp"],"sourceRoot":"../src/","sources":["packages/react-components/react-utilities/src/compose/getSlots.ts"],"sourcesContent":["import * as React from 'react';\n\nimport { omit } from '../utils/omit';\nimport type {\n  AsIntrinsicElement,\n  ComponentState,\n  ExtractSlotProps,\n  SlotPropsRecord,\n  SlotRenderFunction,\n  UnionToIntersection,\n} from './types';\n\nexport type Slots<S extends SlotPropsRecord> = {\n  [K in keyof S]: ExtractSlotProps<S[K]> extends AsIntrinsicElement<infer As>\n    ? // for slots with an `as` prop, the slot will be any one of the possible values of `as`\n      As\n    : ExtractSlotProps<S[K]> extends React.ComponentType<infer P>\n    ? React.ElementType<NonNullable<P>>\n    : React.ElementType<ExtractSlotProps<S[K]>>;\n};\n\ntype ObjectSlotProps<S extends SlotPropsRecord> = {\n  [K in keyof S]-?: ExtractSlotProps<S[K]> extends AsIntrinsicElement<infer As>\n    ? // For intrinsic element types, return the intersection of all possible\n      // element's props, to be compatible with the As type returned by Slots<>\n      UnionToIntersection<JSX.IntrinsicElements[As]>\n    : ExtractSlotProps<S[K]> extends React.ComponentType<infer P>\n    ? P\n    : never;\n};\n\n/**\n * Given the state and an array of slot names, will break out `slots` and `slotProps`\n * collections.\n *\n * The root is derived from a mix of `components` props and `as` prop.\n *\n * Slots will render as null if they are rendered as primitives with undefined children.\n *\n * The slotProps will always omit the `as` prop within them, and for slots that are string\n * primitives, the props will be filtered according to the slot type by the type system.\n * For example, if the slot is rendered `as: 'a'`, the props will be filtered for acceptable\n * anchor props. Note that this is only enforced at build time by Typescript -- there is no\n * runtime code filtering props in this function.\n *\n * @param state - State including slot definitions\n * @returns An object containing the `slots` map and `slotProps` map.\n */\nexport function getSlots<R extends SlotPropsRecord>(\n  state: ComponentState<R>,\n): {\n  slots: Slots<R>;\n  slotProps: ObjectSlotProps<R>;\n} {\n  const slots = {} as Slots<R>;\n  const slotProps = {} as R;\n\n  const slotNames: (keyof R)[] = Object.keys(state.components);\n  for (const slotName of slotNames) {\n    const [slot, props] = getSlot(state, slotName);\n    slots[slotName] = slot as Slots<R>[typeof slotName];\n    slotProps[slotName] = props;\n  }\n  return { slots, slotProps: (slotProps as unknown) as ObjectSlotProps<R> };\n}\n\nfunction getSlot<R extends SlotPropsRecord, K extends keyof R>(\n  state: ComponentState<R>,\n  slotName: K,\n): readonly [React.ElementType<R[K]> | null, R[K]] {\n  if (state[slotName] === undefined) {\n    return [null, undefined as R[K]];\n  }\n  const { children, as: asProp, ...rest } = state[slotName]!;\n\n  const slot = (state.components?.[slotName] === undefined || typeof state.components[slotName] === 'string'\n    ? asProp || state.components?.[slotName] || 'div'\n    : state.components[slotName]) as React.ElementType<R[K]>;\n\n  if (typeof children === 'function') {\n    const render = children as SlotRenderFunction<R[K]>;\n    return [\n      React.Fragment,\n      ({\n        children: render(slot, rest as Omit<R[K], 'children' | 'as'>),\n      } as unknown) as R[K],\n    ];\n  }\n\n  const shouldOmitAsProp = typeof slot === 'string' && state[slotName]?.as;\n  const slotProps = (shouldOmitAsProp ? omit(state[slotName]!, ['as']) : state[slotName]) as R[K];\n\n  return [slot, slotProps];\n}\n"]}

package/lib/compose/isResolvedShorthand.js

@@ -29,7 +29,6 @@ import { isValidElement } from 'react';
  * })
  * ```
  */
-
 export function isResolvedShorthand(shorthand) {
   return shorthand !== null && typeof shorthand === 'object' && !Array.isArray(shorthand) && ! /*#__PURE__*/isValidElement(shorthand);
 }

package/lib/compose/isResolvedShorthand.js.map

@@ -1 +1 @@
-{"version":3,"sources":["packages/react-components/react-utilities/src/compose/isResolvedShorthand.ts"],"names":[],"mappings":"AAAA,SAAS,cAAT,QAA+B,OAA/B;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;;AACH,OAAM,SAAU,mBAAV,CACJ,SADI,EACiB;EAErB,OAAO,SAAS,KAAK,IAAd,IAAsB,OAAO,SAAP,KAAqB,QAA3C,IAAuD,CAAC,KAAK,CAAC,OAAN,CAAc,SAAd,CAAxD,IAAoF,eAAC,cAAc,CAAC,SAAD,CAA1G;AACD","sourcesContent":["import { isValidElement } from 'react';\nimport type { ExtractSlotProps, Slot, UnknownSlotProps } from './types';\n\n/**\n * Guard method that validates if a shorthand is a slot\n * can be used to extends properties provided by a slot\n *\n * @example\n * ```\n * const backdropSlot = resolveShorthand(backdrop, {\n *  defaultProps: {\n *    onClick: useEventCallback(event => {\n *     if (isResolvedShorthand(backdrop)) {\n *        backdrop.onClick?.(event)\n *      }\n *      // do something after passing click down the line\n *    }),\n *  },\n * })\n * ```\n * @example\n * ```\n * const handleBackDropClick = (event) => {\n *  // do your thing\n * }\n * const backdropSlot = resolveShorthand(backdrop, {\n *  defaultProps: {\n *    onClick: useEventCallback(\n *      mergeCallbacks(isResolvedShorthand(backdrop) ? backdrop.onClick : undefined, handleBackdropClick)\n *    )\n * })\n * ```\n */\nexport function isResolvedShorthand<Shorthand extends Slot<UnknownSlotProps>>(\n  shorthand?: Shorthand,\n): shorthand is ExtractSlotProps<Shorthand> {\n  return shorthand !== null && typeof shorthand === 'object' && !Array.isArray(shorthand) && !isValidElement(shorthand);\n}\n"],"sourceRoot":"../src/"}
+{"version":3,"mappings":"AAAA,SAASA,cAAc,QAAQ,OAAO;AAGtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,OAAM,SAAUC,mBAAmB,CACjCC,SAAqB;EAErB,OAAOA,SAAS,KAAK,IAAI,IAAI,OAAOA,SAAS,KAAK,QAAQ,IAAI,CAACC,KAAK,CAACC,OAAO,CAACF,SAAS,CAAC,IAAI,eAACF,cAAc,CAACE,SAAS,CAAC;AACvH","names":["isValidElement","isResolvedShorthand","shorthand","Array","isArray"],"sourceRoot":"../src/","sources":["packages/react-components/react-utilities/src/compose/isResolvedShorthand.ts"],"sourcesContent":["import { isValidElement } from 'react';\nimport type { ExtractSlotProps, Slot, UnknownSlotProps } from './types';\n\n/**\n * Guard method that validates if a shorthand is a slot\n * can be used to extends properties provided by a slot\n *\n * @example\n * ```\n * const backdropSlot = resolveShorthand(backdrop, {\n *  defaultProps: {\n *    onClick: useEventCallback(event => {\n *     if (isResolvedShorthand(backdrop)) {\n *        backdrop.onClick?.(event)\n *      }\n *      // do something after passing click down the line\n *    }),\n *  },\n * })\n * ```\n * @example\n * ```\n * const handleBackDropClick = (event) => {\n *  // do your thing\n * }\n * const backdropSlot = resolveShorthand(backdrop, {\n *  defaultProps: {\n *    onClick: useEventCallback(\n *      mergeCallbacks(isResolvedShorthand(backdrop) ? backdrop.onClick : undefined, handleBackdropClick)\n *    )\n * })\n * ```\n */\nexport function isResolvedShorthand<Shorthand extends Slot<UnknownSlotProps>>(\n  shorthand?: Shorthand,\n): shorthand is ExtractSlotProps<Shorthand> {\n  return shorthand !== null && typeof shorthand === 'object' && !Array.isArray(shorthand) && !isValidElement(shorthand);\n}\n"]}

package/lib/compose/resolveShorthand.js

@@ -5,26 +5,22 @@ import { isValidElement } from 'react';
  * @param value - the base shorthand props
  * @param options - options to resolve shorthand props
  */
-
 export const resolveShorthand = (value, options) => {
   const {
     required = false,
     defaultProps
   } = options || {};
-
   if (value === null || value === undefined && !required) {
     return undefined;
   }
-
   let resolvedShorthand = {};
-
   if (typeof value === 'string' || typeof value === 'number' || Array.isArray(value) || /*#__PURE__*/isValidElement(value)) {
     resolvedShorthand.children = value;
   } else if (typeof value === 'object') {
     resolvedShorthand = value;
   }
-
-  return defaultProps ? { ...defaultProps,
+  return defaultProps ? {
+    ...defaultProps,
     ...resolvedShorthand
   } : resolvedShorthand;
 };

package/lib/compose/resolveShorthand.js.map

@@ -1 +1 @@
-{"version":3,"sources":["packages/react-components/react-utilities/src/compose/resolveShorthand.ts"],"names":[],"mappings":"AAAA,SAAS,cAAT,QAA+B,OAA/B;AAkBA;;;;;AAKG;;AACH,OAAO,MAAM,gBAAgB,GAA6B,CAAC,KAAD,EAAQ,OAAR,KAAmB;EAC3E,MAAM;IAAE,QAAQ,GAAG,KAAb;IAAoB;EAApB,IAAqC,OAAO,IAAI,EAAtD;;EACA,IAAI,KAAK,KAAK,IAAV,IAAmB,KAAK,KAAK,SAAV,IAAuB,CAAC,QAA/C,EAA0D;IACxD,OAAO,SAAP;EACD;;EAED,IAAI,iBAAiB,GAAG,EAAxB;;EAEA,IAAI,OAAO,KAAP,KAAiB,QAAjB,IAA6B,OAAO,KAAP,KAAiB,QAA9C,IAA0D,KAAK,CAAC,OAAN,CAAc,KAAd,CAA1D,iBAAkF,cAAc,CAAC,KAAD,CAApG,EAA6G;IAC3G,iBAAiB,CAAC,QAAlB,GAA6B,KAA7B;EACD,CAFD,MAEO,IAAI,OAAO,KAAP,KAAiB,QAArB,EAA+B;IACpC,iBAAiB,GAAG,KAApB;EACD;;EAED,OAAO,YAAY,GAAG,EAAE,GAAG,YAAL;IAAmB,GAAG;EAAtB,CAAH,GAA+C,iBAAlE;AACD,CAfM","sourcesContent":["import { isValidElement } from 'react';\nimport type { ReplaceNullWithUndefined, SlotShorthandValue, UnknownSlotProps } from './types';\n\nexport type ResolveShorthandOptions<Props, Required extends boolean = false> = {\n  required?: Required;\n  defaultProps?: Props;\n};\n\nexport type ResolveShorthandFunction<Props extends UnknownSlotProps = UnknownSlotProps> = {\n  <P extends Props | null>(\n    value: P | SlotShorthandValue | undefined,\n    options?: ResolveShorthandOptions<P, true>,\n  ): ReplaceNullWithUndefined<P>;\n  <P extends Props | null>(value: P | SlotShorthandValue | undefined, options?: ResolveShorthandOptions<P, boolean>):\n    | ReplaceNullWithUndefined<P>\n    | undefined;\n};\n\n/**\n * Resolves shorthands into slot props, to ensure normalization of the signature\n * being passed down to getSlots method\n * @param value - the base shorthand props\n * @param options - options to resolve shorthand props\n */\nexport const resolveShorthand: ResolveShorthandFunction = (value, options) => {\n  const { required = false, defaultProps } = options || {};\n  if (value === null || (value === undefined && !required)) {\n    return undefined;\n  }\n\n  let resolvedShorthand = {} as UnknownSlotProps;\n\n  if (typeof value === 'string' || typeof value === 'number' || Array.isArray(value) || isValidElement(value)) {\n    resolvedShorthand.children = value;\n  } else if (typeof value === 'object') {\n    resolvedShorthand = value;\n  }\n\n  return defaultProps ? { ...defaultProps, ...resolvedShorthand } : resolvedShorthand;\n};\n"],"sourceRoot":"../src/"}
+{"version":3,"mappings":"AAAA,SAASA,cAAc,QAAQ,OAAO;AAkBtC;;;;;;AAMA,OAAO,MAAMC,gBAAgB,GAA6B,CAACC,KAAK,EAAEC,OAAO,KAAI;EAC3E,MAAM;IAAEC,QAAQ,GAAG,KAAK;IAAEC;EAAY,CAAE,GAAGF,OAAO,IAAI,EAAE;EACxD,IAAID,KAAK,KAAK,IAAI,IAAKA,KAAK,KAAKI,SAAS,IAAI,CAACF,QAAS,EAAE;IACxD,OAAOE,SAAS;;EAGlB,IAAIC,iBAAiB,GAAG,EAAsB;EAE9C,IAAI,OAAOL,KAAK,KAAK,QAAQ,IAAI,OAAOA,KAAK,KAAK,QAAQ,IAAIM,KAAK,CAACC,OAAO,CAACP,KAAK,CAAC,iBAAIF,cAAc,CAACE,KAAK,CAAC,EAAE;IAC3GK,iBAAiB,CAACG,QAAQ,GAAGR,KAAK;GACnC,MAAM,IAAI,OAAOA,KAAK,KAAK,QAAQ,EAAE;IACpCK,iBAAiB,GAAGL,KAAK;;EAG3B,OAAOG,YAAY,GAAG;IAAE,GAAGA,YAAY;IAAE,GAAGE;EAAiB,CAAE,GAAGA,iBAAiB;AACrF,CAAC","names":["isValidElement","resolveShorthand","value","options","required","defaultProps","undefined","resolvedShorthand","Array","isArray","children"],"sourceRoot":"../src/","sources":["packages/react-components/react-utilities/src/compose/resolveShorthand.ts"],"sourcesContent":["import { isValidElement } from 'react';\nimport type { ReplaceNullWithUndefined, SlotShorthandValue, UnknownSlotProps } from './types';\n\nexport type ResolveShorthandOptions<Props, Required extends boolean = false> = {\n  required?: Required;\n  defaultProps?: Props;\n};\n\nexport type ResolveShorthandFunction<Props extends UnknownSlotProps = UnknownSlotProps> = {\n  <P extends Props | null>(\n    value: P | SlotShorthandValue | undefined,\n    options?: ResolveShorthandOptions<P, true>,\n  ): ReplaceNullWithUndefined<P>;\n  <P extends Props | null>(value: P | SlotShorthandValue | undefined, options?: ResolveShorthandOptions<P, boolean>):\n    | ReplaceNullWithUndefined<P>\n    | undefined;\n};\n\n/**\n * Resolves shorthands into slot props, to ensure normalization of the signature\n * being passed down to getSlots method\n * @param value - the base shorthand props\n * @param options - options to resolve shorthand props\n */\nexport const resolveShorthand: ResolveShorthandFunction = (value, options) => {\n  const { required = false, defaultProps } = options || {};\n  if (value === null || (value === undefined && !required)) {\n    return undefined;\n  }\n\n  let resolvedShorthand = {} as UnknownSlotProps;\n\n  if (typeof value === 'string' || typeof value === 'number' || Array.isArray(value) || isValidElement(value)) {\n    resolvedShorthand.children = value;\n  } else if (typeof value === 'object') {\n    resolvedShorthand = value;\n  }\n\n  return defaultProps ? { ...defaultProps, ...resolvedShorthand } : resolvedShorthand;\n};\n"]}

package/lib/hooks/index.js

@@ -8,5 +8,6 @@ export * from './useMergedRefs';
 export * from './useOnClickOutside';
 export * from './useOnScrollOutside';
 export * from './usePrevious';
+export * from './useScrollbarWidth';
 export * from './useTimeout';
 //# sourceMappingURL=index.js.map

package/lib/hooks/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"../src/","sources":["packages/react-components/react-utilities/src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC;AACxB,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC","sourcesContent":["export * from './useControllableState';\nexport * from './useEventCallback';\nexport * from './useFirstMount';\nexport * from './useForceUpdate';\nexport * from './useId';\nexport * from './useIsomorphicLayoutEffect';\nexport * from './useMergedRefs';\nexport * from './useOnClickOutside';\nexport * from './useOnScrollOutside';\nexport * from './usePrevious';\nexport * from './useTimeout';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"../src/","sources":["packages/react-components/react-utilities/src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC;AACxB,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC","sourcesContent":["export * from './useControllableState';\nexport * from './useEventCallback';\nexport * from './useFirstMount';\nexport * from './useForceUpdate';\nexport * from './useId';\nexport * from './useIsomorphicLayoutEffect';\nexport * from './useMergedRefs';\nexport * from './useOnClickOutside';\nexport * from './useOnScrollOutside';\nexport * from './usePrevious';\nexport * from './useScrollbarWidth';\nexport * from './useTimeout';\n"]}

package/lib/hooks/useControllableState.js

@@ -1,5 +1,4 @@
 import * as React from 'react';
-
 function isFactoryDispatch(newState) {
   return typeof newState === 'function';
 }
@@ -19,8 +18,6 @@ function isFactoryDispatch(newState) {
  * to the updater function will only be respected if the component is uncontrolled.
  * @see https://reactjs.org/docs/uncontrolled-components.html
  */
-
-
 export const useControllableState = options => {
   const isControlled = useIsControlled(options.state);
   const initialState = typeof options.defaultState === 'undefined' ? options.initialState : options.defaultState;
@@ -29,9 +26,9 @@ export const useControllableState = options => {
   const stateRef = React.useRef(state);
   React.useEffect(() => {
     stateRef.current = state;
-  }, [state]); // To match the behavior of the setter returned by React.useState, this callback's identity
+  }, [state]);
+  // To match the behavior of the setter returned by React.useState, this callback's identity
   // should never change. This means it MUST NOT directly reference variables that can change.
-
   const setState = React.useCallback(newState => {
     // React dispatch can use a factory
     // https://reactjs.org/docs/hooks-reference.html#functional-updates
@@ -40,7 +37,6 @@ export const useControllableState = options => {
     } else {
       stateRef.current = newState;
     }
-
     setInternalState(stateRef.current);
   }, []);
   return [state, setState];
@@ -50,10 +46,8 @@ export const useControllableState = options => {
  * 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
@@ -61,14 +55,14 @@ const useIsControlled = controlledValue => {
       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
+        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,"sources":["packages/react-components/react-utilities/src/hooks/useControllableState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAZ,MAAuB,OAAvB;;AAqBA,SAAS,iBAAT,CAAkC,QAAlC,EAAuE;EACrE,OAAO,OAAO,QAAP,KAAoB,UAA3B;AACD;AAED;;;;;;;;;;;;;;;AAeG;;;AACH,OAAO,MAAM,oBAAoB,GAC/B,OADkC,IAEsB;EACxD,MAAM,YAAY,GAAG,eAAe,CAAC,OAAO,CAAC,KAAT,CAApC;EACA,MAAM,YAAY,GAAG,OAAO,OAAO,CAAC,YAAf,KAAgC,WAAhC,GAA8C,OAAO,CAAC,YAAtD,GAAqE,OAAO,CAAC,YAAlG;EACA,MAAM,CAAC,aAAD,EAAgB,gBAAhB,IAAoC,KAAK,CAAC,QAAN,CAAsB,YAAtB,CAA1C;EAEA,MAAM,KAAK,GAAG,YAAY,GAAI,OAAO,CAAC,KAAZ,GAA8B,aAAxD;EAEA,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAN,CAAa,KAAb,CAAjB;EACA,KAAK,CAAC,SAAN,CAAgB,MAAK;IACnB,QAAQ,CAAC,OAAT,GAAmB,KAAnB;EACD,CAFD,EAEG,CAAC,KAAD,CAFH,EARwD,CAYxD;EACA;;EACA,MAAM,QAAQ,GAAG,KAAK,CAAC,WAAN,CAAmB,QAAD,IAA0C;IAC3E;IACA;IACA,IAAI,iBAAiB,CAAC,QAAD,CAArB,EAAiC;MAC/B,QAAQ,CAAC,OAAT,GAAmB,QAAQ,CAAC,QAAQ,CAAC,OAAV,CAA3B;IACD,CAFD,MAEO;MACL,QAAQ,CAAC,OAAT,GAAmB,QAAnB;IACD;;IAED,gBAAgB,CAAC,QAAQ,CAAC,OAAV,CAAhB;EACD,CAVgB,EAUd,EAVc,CAAjB;EAYA,OAAO,CAAC,KAAD,EAAQ,QAAR,CAAP;AACD,CA7BM;AA+BP;;;;AAIG;;AACH,MAAM,eAAe,GAAI,eAAD,IAA6B;EACnD,MAAM,CAAC,YAAD,IAAiB,KAAK,CAAC,QAAN,CAAwB,MAAM,eAAe,KAAK,SAAlD,CAAvB;;EAEA,IAAI,OAAO,CAAC,GAAR,CAAY,QAAZ,KAAyB,YAA7B,EAA2C;IACzC;IACA;IACA,KAAK,CAAC,SAAN,CAAgB,MAAK;MACnB,IAAI,YAAY,MAAM,eAAe,KAAK,SAA1B,CAAhB,EAAsD;QACpD,MAAM,KAAK,GAAG,IAAI,KAAJ,EAAd;QAEA,MAAM,cAAc,GAAG,YAAY,GAC/B,uCAD+B,GAE/B,wCAFJ;QAIA,MAAM,gBAAgB,GAAG,YAAY,GAAG,yBAAH,GAA+B,wBAApE,CAPoD,CASpD;;QACA,OAAO,CAAC,KAAR,CACE,CACE;QACA,6BAA6B,cAA7B,GAA8C,sCAFhD,EAGE,mBAAmB,gBAAnB,GAAsC,kCAHxC,EAIE,oGAJF,EAKE,2DALF,EAME,KAAK,CAAC,KANR,EAOE,IAPF,CAOO,GAPP,CADF;MAUD;IACF,CAtBD,EAsBG,CAAC,YAAD,EAAe,eAAf,CAtBH;EAuBD;;EAED,OAAO,YAAP;AACD,CAhCD","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`-like hook to manage a value that could be either controlled or uncontrolled,\n * such as a checked state or text input string.\n *\n * Unlike `setState`, it's okay to call the returned updater (dispatch) function for either a\n * controlled or uncontrolled component. Calls will only be respected if the component is uncontrolled.\n *\n * @returns Same as [`useState`](https://reactjs.org/docs/hooks-reference.html#usestate): an array\n * of the current value and an updater (dispatch) function. The updater function is referentially\n * stable (won't change during the component's lifecycle). It can take either a new value, or a\n * function which is passed the previous value and returns the new value. Unlike `setState`, calls\n * to the updater function will only be respected if the component is uncontrolled.\n * @see https://reactjs.org/docs/uncontrolled-components.html\n */\nexport const useControllableState = <State>(\n  options: UseControllableStateOptions<State>,\n): [State, React.Dispatch<React.SetStateAction<State>>] => {\n  const isControlled = useIsControlled(options.state);\n  const initialState = typeof options.defaultState === 'undefined' ? options.initialState : options.defaultState;\n  const [internalState, setInternalState] = React.useState<State>(initialState);\n\n  const state = isControlled ? (options.state as State) : internalState;\n\n  const stateRef = React.useRef(state);\n  React.useEffect(() => {\n    stateRef.current = state;\n  }, [state]);\n\n  // To match the behavior of the setter returned by React.useState, this callback's identity\n  // should never change. This means it MUST NOT directly reference variables that can change.\n  const setState = React.useCallback((newState: React.SetStateAction<State>) => {\n    // React dispatch can use a factory\n    // https://reactjs.org/docs/hooks-reference.html#functional-updates\n    if (isFactoryDispatch(newState)) {\n      stateRef.current = newState(stateRef.current);\n    } else {\n      stateRef.current = newState;\n    }\n\n    setInternalState(stateRef.current);\n  }, []);\n\n  return [state, setState];\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 = (controlledValue: unknown) => {\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"],"sourceRoot":"../src/"}
+{"version":3,"mappings":"AAAA,OAAO,KAAKA,KAAK,MAAM,OAAO;AAqB9B,SAASC,iBAAiB,CAAQC,QAAqC;EACrE,OAAO,OAAOA,QAAQ,KAAK,UAAU;AACvC;AAEA;;;;;;;;;;;;;;;;AAgBA,OAAO,MAAMC,oBAAoB,GAC/BC,OAA2C,IACa;EACxD,MAAMC,YAAY,GAAGC,eAAe,CAACF,OAAO,CAACG,KAAK,CAAC;EACnD,MAAMC,YAAY,GAAG,OAAOJ,OAAO,CAACK,YAAY,KAAK,WAAW,GAAGL,OAAO,CAACI,YAAY,GAAGJ,OAAO,CAACK,YAAY;EAC9G,MAAM,CAACC,aAAa,EAAEC,gBAAgB,CAAC,GAAGX,KAAK,CAACY,QAAQ,CAAQJ,YAAY,CAAC;EAE7E,MAAMD,KAAK,GAAGF,YAAY,GAAID,OAAO,CAACG,KAAe,GAAGG,aAAa;EAErE,MAAMG,QAAQ,GAAGb,KAAK,CAACc,MAAM,CAACP,KAAK,CAAC;EACpCP,KAAK,CAACe,SAAS,CAAC,MAAK;IACnBF,QAAQ,CAACG,OAAO,GAAGT,KAAK;EAC1B,CAAC,EAAE,CAACA,KAAK,CAAC,CAAC;EAEX;EACA;EACA,MAAMU,QAAQ,GAAGjB,KAAK,CAACkB,WAAW,CAAEhB,QAAqC,IAAI;IAC3E;IACA;IACA,IAAID,iBAAiB,CAACC,QAAQ,CAAC,EAAE;MAC/BW,QAAQ,CAACG,OAAO,GAAGd,QAAQ,CAACW,QAAQ,CAACG,OAAO,CAAC;KAC9C,MAAM;MACLH,QAAQ,CAACG,OAAO,GAAGd,QAAQ;;IAG7BS,gBAAgB,CAACE,QAAQ,CAACG,OAAO,CAAC;EACpC,CAAC,EAAE,EAAE,CAAC;EAEN,OAAO,CAACT,KAAK,EAAEU,QAAQ,CAAC;AAC1B,CAAC;AAED;;;;;AAKA,MAAMX,eAAe,GAAIa,eAAwB,IAAI;EACnD,MAAM,CAACd,YAAY,CAAC,GAAGL,KAAK,CAACY,QAAQ,CAAU,MAAMO,eAAe,KAAKC,SAAS,CAAC;EAEnF,IAAIC,OAAO,CAACC,GAAG,CAACC,QAAQ,KAAK,YAAY,EAAE;IACzC;IACA;IACAvB,KAAK,CAACe,SAAS,CAAC,MAAK;MACnB,IAAIV,YAAY,MAAMc,eAAe,KAAKC,SAAS,CAAC,EAAE;QACpD,MAAMI,KAAK,GAAG,IAAIC,KAAK,EAAE;QAEzB,MAAMC,cAAc,GAAGrB,YAAY,GAC/B,uCAAuC,GACvC,wCAAwC;QAE5C,MAAMsB,gBAAgB,GAAGtB,YAAY,GAAG,yBAAyB,GAAG,wBAAwB;QAE5F;QACAuB,OAAO,CAACJ,KAAK,CACX;QACE;QACA,0BAA0B,GAAGE,cAAc,GAAG,sCAAsC,EACpF,gBAAgB,GAAGC,gBAAgB,GAAG,kCAAkC,EACxE,oGAAoG,EACpG,2DAA2D,EAC3DH,KAAK,CAACK,KAAK,CACZ,CAACC,IAAI,CAAC,GAAG,CAAC,CACZ;;IAEL,CAAC,EAAE,CAACzB,YAAY,EAAEc,eAAe,CAAC,CAAC;;EAGrC,OAAOd,YAAY;AACrB,CAAC","names":["React","isFactoryDispatch","newState","useControllableState","options","isControlled","useIsControlled","state","initialState","defaultState","internalState","setInternalState","useState","stateRef","useRef","useEffect","current","setState","useCallback","controlledValue","undefined","process","env","NODE_ENV","error","Error","controlWarning","undefinedWarning","console","stack","join"],"sourceRoot":"../src/","sources":["packages/react-components/react-utilities/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`-like hook to manage a value that could be either controlled or uncontrolled,\n * such as a checked state or text input string.\n *\n * Unlike `setState`, it's okay to call the returned updater (dispatch) function for either a\n * controlled or uncontrolled component. Calls will only be respected if the component is uncontrolled.\n *\n * @returns Same as [`useState`](https://reactjs.org/docs/hooks-reference.html#usestate): an array\n * of the current value and an updater (dispatch) function. The updater function is referentially\n * stable (won't change during the component's lifecycle). It can take either a new value, or a\n * function which is passed the previous value and returns the new value. Unlike `setState`, calls\n * to the updater function will only be respected if the component is uncontrolled.\n * @see https://reactjs.org/docs/uncontrolled-components.html\n */\nexport const useControllableState = <State>(\n  options: UseControllableStateOptions<State>,\n): [State, React.Dispatch<React.SetStateAction<State>>] => {\n  const isControlled = useIsControlled(options.state);\n  const initialState = typeof options.defaultState === 'undefined' ? options.initialState : options.defaultState;\n  const [internalState, setInternalState] = React.useState<State>(initialState);\n\n  const state = isControlled ? (options.state as State) : internalState;\n\n  const stateRef = React.useRef(state);\n  React.useEffect(() => {\n    stateRef.current = state;\n  }, [state]);\n\n  // To match the behavior of the setter returned by React.useState, this callback's identity\n  // should never change. This means it MUST NOT directly reference variables that can change.\n  const setState = React.useCallback((newState: React.SetStateAction<State>) => {\n    // React dispatch can use a factory\n    // https://reactjs.org/docs/hooks-reference.html#functional-updates\n    if (isFactoryDispatch(newState)) {\n      stateRef.current = newState(stateRef.current);\n    } else {\n      stateRef.current = newState;\n    }\n\n    setInternalState(stateRef.current);\n  }, []);\n\n  return [state, setState];\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 = (controlledValue: unknown) => {\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"]}

package/lib/hooks/useEventCallback.js

@@ -13,7 +13,6 @@ import { useIsomorphicLayoutEffect } from './useIsomorphicLayoutEffect';
  *
  * @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');

package/lib/hooks/useEventCallback.js.map

@@ -1 +1 @@
-{"version":3,"sources":["packages/react-components/react-utilities/src/hooks/useEventCallback.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAZ,MAAuB,OAAvB;AACA,SAAS,yBAAT,QAA0C,6BAA1C;AAEA;;;;;;;;;;;;AAYG;;AACH,OAAO,MAAM,gBAAgB,GAAoC,EAAjC,IAAkE;EAChG,MAAM,WAAW,GAAG,KAAK,CAAC,MAAN,CAAwB,MAAK;IAC/C,MAAM,IAAI,KAAJ,CAAU,8CAAV,CAAN;EACD,CAFmB,CAApB;EAIA,yBAAyB,CAAC,MAAK;IAC7B,WAAW,CAAC,OAAZ,GAAsB,EAAtB;EACD,CAFwB,EAEtB,CAAC,EAAD,CAFsB,CAAzB;EAIA,OAAO,KAAK,CAAC,WAAN,CACL,CAAC,GAAG,IAAJ,KAAkB;IAChB,MAAM,QAAQ,GAAG,WAAW,CAAC,OAA7B;IACA,OAAO,QAAQ,CAAC,GAAG,IAAJ,CAAf;EACD,CAJI,EAKL,CAAC,WAAD,CALK,CAAP;AAOD,CAhBM","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"],"sourceRoot":"../src/"}
+{"version":3,"mappings":"AAAA,OAAO,KAAKA,KAAK,MAAM,OAAO;AAC9B,SAASC,yBAAyB,QAAQ,6BAA6B;AAEvE;;;;;;;;;;;;;AAaA,OAAO,MAAMC,gBAAgB,GAAoCC,EAA6B,IAAI;EAChG,MAAMC,WAAW,GAAGJ,KAAK,CAACK,MAAM,CAAY,MAAK;IAC/C,MAAM,IAAIC,KAAK,CAAC,8CAA8C,CAAC;EACjE,CAAC,CAAC;EAEFL,yBAAyB,CAAC,MAAK;IAC7BG,WAAW,CAACG,OAAO,GAAGJ,EAAE;EAC1B,CAAC,EAAE,CAACA,EAAE,CAAC,CAAC;EAER,OAAOH,KAAK,CAACQ,WAAW,CACtB,CAAC,GAAGC,IAAU,KAAI;IAChB,MAAMC,QAAQ,GAAGN,WAAW,CAACG,OAAO;IACpC,OAAOG,QAAQ,CAAC,GAAGD,IAAI,CAAC;EAC1B,CAAC,EACD,CAACL,WAAW,CAAC,CACd;AACH,CAAC","names":["React","useIsomorphicLayoutEffect","useEventCallback","fn","callbackRef","useRef","Error","current","useCallback","args","callback"],"sourceRoot":"../src/","sources":["packages/react-components/react-utilities/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"]}

package/lib/hooks/useFirstMount.js

@@ -10,15 +10,12 @@ 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;
 }
 //# sourceMappingURL=useFirstMount.js.map

package/lib/hooks/useFirstMount.js.map

@@ -1 +1 @@
-{"version":3,"sources":["packages/react-components/react-utilities/src/hooks/useFirstMount.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAZ,MAAuB,OAAvB;AAEA;;;;;;;;;;AAUG;;AACH,OAAM,SAAU,aAAV,GAAuB;EAC3B,MAAM,OAAO,GAAG,KAAK,CAAC,MAAN,CAAa,IAAb,CAAhB;;EAEA,IAAI,OAAO,CAAC,OAAZ,EAAqB;IACnB,OAAO,CAAC,OAAR,GAAkB,KAAlB;IACA,OAAO,IAAP;EACD;;EAED,OAAO,OAAO,CAAC,OAAf;AACD","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"],"sourceRoot":"../src/"}
+{"version":3,"mappings":"AAAA,OAAO,KAAKA,KAAK,MAAM,OAAO;AAE9B;;;;;;;;;;;AAWA,OAAM,SAAUC,aAAa;EAC3B,MAAMC,OAAO,GAAGF,KAAK,CAACG,MAAM,CAAC,IAAI,CAAC;EAElC,IAAID,OAAO,CAACE,OAAO,EAAE;IACnBF,OAAO,CAACE,OAAO,GAAG,KAAK;IACvB,OAAO,IAAI;;EAGb,OAAOF,OAAO,CAACE,OAAO;AACxB","names":["React","useFirstMount","isFirst","useRef","current"],"sourceRoot":"../src/","sources":["packages/react-components/react-utilities/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"]}

package/lib/hooks/useForceUpdate.js

@@ -3,7 +3,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];
 }

package/lib/hooks/useForceUpdate.js.map

@@ -1 +1 @@
-{"version":3,"sources":["packages/react-components/react-utilities/src/hooks/useForceUpdate.ts"],"names":[],"mappings":"AAAA,SAAS,UAAT,QAA2B,OAA3B;AAEA;;;AAGG;;AACH,OAAM,SAAU,cAAV,GAAwB;EAC5B,OAAO,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,CAAV,EAAa,CAAb,CAAV,CAA0B,CAA1B,CAAP;AACD","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"],"sourceRoot":"../src/"}
+{"version":3,"mappings":"AAAA,SAASA,UAAU,QAAQ,OAAO;AAElC;;;;AAIA,OAAM,SAAUC,cAAc;EAC5B,OAAOD,UAAU,CAACE,CAAC,IAAIA,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AACrC","names":["useReducer","useForceUpdate","x"],"sourceRoot":"../src/","sources":["packages/react-components/react-utilities/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"]}

package/lib/hooks/useId.js

@@ -3,7 +3,6 @@ import { defaultSSRContextValue, useSSRContext } from '../ssr/index';
 /**
  * Resets generated IDs, should be used only in tests.
  */
-
 export function resetIdsForTests() {
   defaultSSRContextValue.current = 0;
 }
@@ -15,14 +14,12 @@ export function resetIdsForTests() {
  *  without conditioning the hook call
  * @returns The ID
  */
-
 export function useId(prefix = 'fui-', providedId) {
   const contextValue = useSSRContext();
   return React.useMemo(() => {
     if (providedId) {
       return providedId;
     }
-
     return `${prefix}${++contextValue.current}`;
   }, [prefix, providedId, contextValue]);
 }

package/lib/hooks/useId.js.map

@@ -1 +1 @@
-{"version":3,"sources":["packages/react-components/react-utilities/src/hooks/useId.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAZ,MAAuB,OAAvB;AACA,SAAS,sBAAT,EAAiC,aAAjC,QAAsD,cAAtD;AAEA;;AAEG;;AACH,OAAM,SAAU,gBAAV,GAA0B;EAC9B,sBAAsB,CAAC,OAAvB,GAAiC,CAAjC;AACD;AAED;;;;;;;AAOG;;AACH,OAAM,SAAU,KAAV,CAAgB,MAAA,GAAiB,MAAjC,EAAyC,UAAzC,EAA4D;EAChE,MAAM,YAAY,GAAG,aAAa,EAAlC;EAEA,OAAO,KAAK,CAAC,OAAN,CAAc,MAAK;IACxB,IAAI,UAAJ,EAAgB;MACd,OAAO,UAAP;IACD;;IAED,OAAO,GAAG,MAAM,GAAG,EAAE,YAAY,CAAC,OAAO,EAAzC;EACD,CANM,EAMJ,CAAC,MAAD,EAAS,UAAT,EAAqB,YAArB,CANI,CAAP;AAOD","sourcesContent":["import * as React from 'react';\nimport { defaultSSRContextValue, useSSRContext } from '../ssr/index';\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\n  return React.useMemo(() => {\n    if (providedId) {\n      return providedId;\n    }\n\n    return `${prefix}${++contextValue.current}`;\n  }, [prefix, providedId, contextValue]);\n}\n"],"sourceRoot":"../src/"}
+{"version":3,"mappings":"AAAA,OAAO,KAAKA,KAAK,MAAM,OAAO;AAC9B,SAASC,sBAAsB,EAAEC,aAAa,QAAQ,cAAc;AAEpE;;;AAGA,OAAM,SAAUC,gBAAgB;EAC9BF,sBAAsB,CAACG,OAAO,GAAG,CAAC;AACpC;AAEA;;;;;;;;AAQA,OAAM,SAAUC,KAAK,CAACC,SAAiB,MAAM,EAAEC,UAAmB;EAChE,MAAMC,YAAY,GAAGN,aAAa,EAAE;EAEpC,OAAOF,KAAK,CAACS,OAAO,CAAC,MAAK;IACxB,IAAIF,UAAU,EAAE;MACd,OAAOA,UAAU;;IAGnB,OAAO,GAAGD,MAAM,GAAG,EAAEE,YAAY,CAACJ,OAAO,EAAE;EAC7C,CAAC,EAAE,CAACE,MAAM,EAAEC,UAAU,EAAEC,YAAY,CAAC,CAAC;AACxC","names":["React","defaultSSRContextValue","useSSRContext","resetIdsForTests","current","useId","prefix","providedId","contextValue","useMemo"],"sourceRoot":"../src/","sources":["packages/react-components/react-utilities/src/hooks/useId.ts"],"sourcesContent":["import * as React from 'react';\nimport { defaultSSRContextValue, useSSRContext } from '../ssr/index';\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\n  return React.useMemo(() => {\n    if (providedId) {\n      return providedId;\n    }\n\n    return `${prefix}${++contextValue.current}`;\n  }, [prefix, providedId, contextValue]);\n}\n"]}

package/lib/hooks/useIsomorphicLayoutEffect.js

@@ -10,6 +10,5 @@ import { canUseDOM } from '../ssr/index';
  * 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

package/lib/hooks/useIsomorphicLayoutEffect.js.map

@@ -1 +1 @@
-{"version":3,"sources":["packages/react-components/react-utilities/src/hooks/useIsomorphicLayoutEffect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAZ,MAAuB,OAAvB;AACA,SAAS,SAAT,QAA0B,cAA1B;AAEA;;;;;;;;AAQG;AACH;;AACA,OAAO,MAAM,yBAAyB,GAA2B,aAAA,SAAS,KAAK,KAAK,CAAC,eAAX,GAA6B,KAAK,CAAC,SAAtG","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"],"sourceRoot":"../src/"}
+{"version":3,"mappings":"AAAA,OAAO,KAAKA,KAAK,MAAM,OAAO;AAC9B,SAASC,SAAS,QAAQ,cAAc;AAExC;;;;;;;;;AASA;AACA,OAAO,MAAMC,yBAAyB,GAA2B,sBAAS,EAAE,GAAGF,KAAK,CAACG,eAAe,GAAGH,KAAK,CAACI,SAAS","names":["React","canUseDOM","useIsomorphicLayoutEffect","useLayoutEffect","useEffect"],"sourceRoot":"../src/","sources":["packages/react-components/react-utilities/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"]}

package/lib/hooks/useMergedRefs.js

@@ -5,12 +5,10 @@ import * as React from 'react';
  * @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);
@@ -19,7 +17,8 @@ export function useMergedRefs(...refs) {
         ref.current = value;
       }
     }
-  }, // eslint-disable-next-line react-hooks/exhaustive-deps -- already exhaustive
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps -- already exhaustive
   [...refs]);
   return mergedCallback;
 }

package/lib/hooks/useMergedRefs.js.map

@@ -1 +1 @@
-{"version":3,"sources":["packages/react-components/react-utilities/src/hooks/useMergedRefs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAZ,MAAuB,OAAvB;AAQA;;;;;AAKG;;AACH,OAAM,SAAU,aAAV,CAA2B,GAAG,IAA9B,EAAgE;EACpE,MAAM,cAAc,GAA0B,KAAK,CAAC,WAAN,CAC3C,KAAD,IAAa;IACX;IACE,cAAwD,CAAC,OAAzD,GAAmE,KAAnE;;IAEF,KAAK,MAAM,GAAX,IAAkB,IAAlB,EAAwB;MACtB,IAAI,OAAO,GAAP,KAAe,UAAnB,EAA+B;QAC7B,GAAG,CAAC,KAAD,CAAH;MACD,CAFD,MAEO,IAAI,GAAJ,EAAS;QACd;QACE,GAA6C,CAAC,OAA9C,GAAwD,KAAxD;MACH;IACF;EACF,CAb2C,EAc5C;EACA,CAAC,GAAG,IAAJ,CAf4C,CAA9C;EAkBA,OAAO,cAAP;AACD","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"],"sourceRoot":"../src/"}
+{"version":3,"mappings":"AAAA,OAAO,KAAKA,KAAK,MAAM,OAAO;AAQ9B;;;;;;AAMA,OAAM,SAAUC,aAAa,CAAI,GAAGC,IAAkC;EACpE,MAAMC,cAAc,GAA0BH,KAAK,CAACI,WAAW,CAC5DC,KAAQ,IAAI;IACX;IACEF,cAAwD,CAACG,OAAO,GAAGD,KAAK;IAE1E,KAAK,MAAME,GAAG,IAAIL,IAAI,EAAE;MACtB,IAAI,OAAOK,GAAG,KAAK,UAAU,EAAE;QAC7BA,GAAG,CAACF,KAAK,CAAC;OACX,MAAM,IAAIE,GAAG,EAAE;QACd;QACEA,GAA6C,CAACD,OAAO,GAAGD,KAAK;;;EAGrE,CAAC;EACD;EACA,CAAC,GAAGH,IAAI,CAAC,CAC0B;EAErC,OAAOC,cAAc;AACvB","names":["React","useMergedRefs","refs","mergedCallback","useCallback","value","current","ref"],"sourceRoot":"../src/","sources":["packages/react-components/react-utilities/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"]}