@fluentui/react-utilities 9.7.0 → 9.7.2

package/lib-commonjs/compose/types.js

@@ -1,6 +1,9 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
+const _interopRequireWildcard = require("@swc/helpers/lib/_interop_require_wildcard.js").default;
+const _react = /*#__PURE__*/ _interopRequireWildcard(require("react"));
+ //# sourceMappingURL=types.js.map
+
 //# sourceMappingURL=types.js.map

package/lib-commonjs/compose/types.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["../src/packages/react-components/react-utilities/src/compose/types.ts"],"sourcesContent":["import * as React from 'react';\n\nexport type SlotRenderFunction<Props> = (\n  Component: React.ElementType<Props>,\n  props: Omit<Props, 'children' | 'as'>,\n) => React.ReactNode;\n\n/**\n * Matches any component's Slots type (such as ButtonSlots).\n *\n * This should ONLY be used in type templates as in `extends SlotPropsRecord`;\n * it shouldn't be used as a component's Slots type.\n */\nexport type SlotPropsRecord = Record<string, UnknownSlotProps | SlotShorthandValue | null | undefined>;\n\n/**\n * The shorthand value of a slot allows specifying its child\n */\nexport type SlotShorthandValue = React.ReactChild | React.ReactNode[] | React.ReactPortal;\n\n/**\n * Matches any slot props type.\n *\n * This should ONLY be used in type templates as in `extends UnknownSlotProps`;\n * it shouldn't be used as the type of a slot.\n */\nexport type UnknownSlotProps = Pick<React.HTMLAttributes<HTMLElement>, 'children' | 'className' | 'style'> & {\n  as?: keyof JSX.IntrinsicElements;\n};\n\n/**\n * Helper type for {@link Slot}. Adds shorthand types that are assignable to the slot's `children`.\n */\ntype WithSlotShorthandValue<Props extends { children?: unknown }> =\n  | Props\n  | Extract<SlotShorthandValue, Props['children']>;\n\n/**\n * Helper type for {@link Slot}. Takes the props we want to support for a slot and adds the ability for `children`\n * to be a render function that takes those props.\n */\ntype WithSlotRenderFunction<Props> = Props & {\n  children?: (Props extends { children?: unknown } ? Props['children'] : never) | SlotRenderFunction<Props>;\n};\n\n/**\n * HTML element types that are not allowed to have children.\n *\n * Reference: https://developer.mozilla.org/en-US/docs/Glossary/Empty_element\n */\ntype EmptyIntrinsicElements =\n  | 'area'\n  | 'base'\n  | 'br'\n  | 'col'\n  | 'embed'\n  | 'hr'\n  | 'img'\n  | 'input'\n  | 'link'\n  | 'meta'\n  | 'param'\n  | 'source'\n  | 'track'\n  | 'wbr';\n\n/**\n * Helper type for {@link Slot}. Modifies `JSX.IntrinsicElements[Type]`:\n * * Removes legacy string ref.\n * * Disallows children for empty tags like 'img'.\n */\ntype IntrinsicElementProps<Type extends keyof JSX.IntrinsicElements> = Type extends EmptyIntrinsicElements\n  ? PropsWithoutChildren<React.PropsWithRef<JSX.IntrinsicElements[Type]>>\n  : React.PropsWithRef<JSX.IntrinsicElements[Type]>;\n\n/**\n * The props type and shorthand value for a slot. Type is either a single intrinsic element like `'div'`,\n * or a component like `typeof Button`.\n *\n * If a slot needs to support multiple intrinsic element types, use the `AlternateAs` param (see examples below).\n *\n * By default, slots can be set to `null` to prevent them from being rendered. If a slot must always be rendered,\n * wrap with `NonNullable` (see examples below).\n *\n * @example\n * ```\n * // Intrinsic element examples:\n * Slot<'div'> // Slot is always div\n * Slot<'button', 'a'> // Defaults to button, but allows as=\"a\" with anchor-specific props\n * Slot<'span', 'div' | 'pre'> // Defaults to span, but allows as=\"div\" or as=\"pre\"\n * NonNullable<Slot<'div'>> // Slot that will always be rendered (can't be set to null by the user)\n *\n * // Component examples:\n * Slot<typeof Button> // Slot is always a Button, and accepts all of Button's Props\n * NonNullable<Slot<typeof Label>> // Slot is a Label and will always be rendered (can't be set to null by the user)\n * ```\n */\nexport type Slot<\n  Type extends keyof JSX.IntrinsicElements | React.ComponentType | React.VoidFunctionComponent | UnknownSlotProps,\n  AlternateAs extends keyof JSX.IntrinsicElements = never,\n> = IsSingleton<Extract<Type, string>> extends true\n  ?\n      | WithSlotShorthandValue<\n          Type extends keyof JSX.IntrinsicElements // Intrinsic elements like `div`\n            ? { as?: Type } & WithSlotRenderFunction<IntrinsicElementProps<Type>>\n            : Type extends React.ComponentType<infer Props> // Component types like `typeof Button`\n            ? WithSlotRenderFunction<Props>\n            : Type // Props types like `ButtonProps`\n        >\n      | {\n          [As in AlternateAs]: { as: As } & WithSlotRenderFunction<IntrinsicElementProps<As>>;\n        }[AlternateAs]\n      | null\n  : 'Error: First parameter to Slot must not be not a union of types. See documentation of Slot type.';\n\n/**\n * Evaluates to true if the given type contains exactly one string, or false if it is a union of strings.\n *\n * ```\n * IsSingleton<'a'> // true\n * IsSingleton<'a' | 'b' | 'c'> // false\n * ```\n */\nexport type IsSingleton<T extends string> = { [K in T]: Exclude<T, K> extends never ? true : false }[T];\n\n/**\n * Helper type for inferring the type of the as prop from a Props type.\n *\n * For example:\n * ```\n * type Example<T> = T extends AsIntrinsicElement<infer As> ? As : never;\n * ```\n */\nexport type AsIntrinsicElement<As extends keyof JSX.IntrinsicElements> = { as?: As };\n\n/**\n * Converts a union type (`A | B | C`) to an intersection type (`A & B & C`)\n */\nexport type UnionToIntersection<U> = (U extends unknown ? (x: U) => U : never) extends (x: infer I) => U ? I : never;\n\n/**\n * Removes the 'ref' prop from the given Props type, leaving unions intact (such as the discriminated union created by\n * IntrinsicSlotProps). This allows IntrinsicSlotProps to be used with React.forwardRef.\n *\n * The conditional \"extends unknown\" (always true) exploits a quirk in the way TypeScript handles conditional\n * types, to prevent unions from being expanded.\n */\nexport type PropsWithoutRef<P> = 'ref' extends keyof P ? (P extends unknown ? Omit<P, 'ref'> : P) : P;\n\n/**\n * Removes the 'ref' prop from the given Props type, leaving unions intact (such as the discriminated union created by\n * IntrinsicSlotProps). This allows IntrinsicSlotProps to be used with React.forwardRef.\n *\n * The conditional \"extends unknown\" (always true) exploits a quirk in the way TypeScript handles conditional\n * types, to prevent unions from being expanded.\n */\nexport type PropsWithoutChildren<P> = 'children' extends keyof P ? (P extends unknown ? Omit<P, 'children'> : P) : P;\n\n/**\n * Removes SlotShorthandValue and null from the slot type, extracting just the slot's Props object.\n */\nexport type ExtractSlotProps<S> = Exclude<S, SlotShorthandValue | null | undefined>;\n\n/**\n * Defines the Props type for a component given its slots and the definition of which one is the primary slot,\n * defaulting to root if one is not provided.\n */\nexport type ComponentProps<Slots extends SlotPropsRecord, Primary extends keyof Slots = 'root'> =\n  // Include a prop for each slot (see note below about the Omit)\n  Omit<Slots, Primary & 'root'> &\n    // Include all of the props of the primary slot inline in the component's props\n    PropsWithoutRef<ExtractSlotProps<Slots[Primary]>>;\n\n// Note: the `Omit<Slots, Primary & 'root'>` above is a little tricky. Here's what it's doing:\n// * If the Primary slot is 'root', then omit the `root` slot prop.\n// * Otherwise, don't omit any props: include *both* the Primary and `root` props.\n//   We need both props to allow the user to specify native props for either slot because the `root` slot is\n//   special and always gets className and style props, per RFC https://github.com/microsoft/fluentui/pull/18983\n\n/**\n * If type T includes `null`, remove it and add `undefined` instead.\n */\nexport type ReplaceNullWithUndefined<T> = T extends null ? Exclude<T, null> | undefined : T;\n\n/**\n * Defines the State object of a component given its slots.\n */\nexport type ComponentState<Slots extends SlotPropsRecord> = {\n  components: {\n    [Key in keyof Slots]-?:\n      | React.ComponentType<ExtractSlotProps<Slots[Key]>>\n      | (ExtractSlotProps<Slots[Key]> extends AsIntrinsicElement<infer As> ? As : keyof JSX.IntrinsicElements);\n  };\n} & {\n  // Include a prop for each slot, with the shorthand resolved to a props object\n  // The root slot can never be null, so also exclude null from it\n  [Key in keyof Slots]: ReplaceNullWithUndefined<\n    Exclude<Slots[Key], SlotShorthandValue | (Key extends 'root' ? null : never)>\n  >;\n};\n\n/**\n * This is part of a hack to infer the element type from a native element *props* type.\n * The only place the original element is found in a native props type (at least that's workable\n * for inference) is in the event handlers, so some of the helper types use this event handler\n * name to infer the original element type.\n *\n * Notes:\n * - Using an extremely obscure event handler reduces the likelihood that its signature will be\n *   modified in any component's props.\n * - Inferring based on a single prop name instead of a larger type like `DOMAttributes<T>` should be\n *   less expensive for typescript to evaluate and is less likely to result in type expansion in .d.ts.\n */\ntype ObscureEventName = 'onLostPointerCaptureCapture';\n\n/**\n * Return type for `React.forwardRef`, including inference of the proper typing for the ref.\n */\nexport type ForwardRefComponent<Props> = ObscureEventName extends keyof Props\n  ? Required<Props>[ObscureEventName] extends React.PointerEventHandler<infer Element>\n    ? React.ForwardRefExoticComponent<Props & React.RefAttributes<Element>>\n    : never\n  : never;\n// A definition like this would also work, but typescript is more likely to unnecessarily expand\n// the props type with this version (and it's likely much more expensive to evaluate)\n// export type ForwardRefComponent<Props> = Props extends React.DOMAttributes<infer Element>\n//   ? React.ForwardRefExoticComponent<Props> & React.RefAttributes<Element>\n//   : never;\n\n/**\n * Helper type to correctly define the slot class names object.\n */\nexport type SlotClassNames<Slots> = {\n  [SlotName in keyof Slots]-?: string;\n};\n"],"mappings":""}
+{"version":3,"sources":["../../lib/compose/types.js"],"sourcesContent":["import * as React from 'react';\n//# sourceMappingURL=types.js.map"],"names":[],"mappings":";;;;;6DAAuB;CACvB,iCAAiC"}

package/lib-commonjs/events/index.js

@@ -1,8 +1,9 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-const tslib_1 = /*#__PURE__*/require("tslib");
-tslib_1.__exportStar(require("./mouseTouchHelpers"), exports);
+const _exportStar = require("@swc/helpers/lib/_export_star.js").default;
+_exportStar(require("./mouseTouchHelpers"), exports);
+ //# sourceMappingURL=index.js.map
+
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["tslib_1","__exportStar","require","exports"],"sources":["../src/packages/react-components/react-utilities/src/events/index.ts"],"sourcesContent":["export * from './mouseTouchHelpers';\n"],"mappings":";;;;;;AAAAA,OAAA,CAAAC,YAAA,CAAAC,OAAA,yBAAAC,OAAA"}
+{"version":3,"sources":["../../lib/events/index.js"],"sourcesContent":["export * from './mouseTouchHelpers';\n//# sourceMappingURL=index.js.map"],"names":[],"mappings":";;;;;oBAAc;CACd,iCAAiC"}

package/lib-commonjs/events/mouseTouchHelpers.js

@@ -1,47 +1,50 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isTouchEvent: ()=>isTouchEvent,
+    isMouseEvent: ()=>isMouseEvent,
+    getEventClientCoords: ()=>getEventClientCoords
 });
-exports.getEventClientCoords = exports.isMouseEvent = exports.isTouchEvent = void 0;
-/**
- * Returns true if event is a touch event. Useful when sharing logic between touch and mouse interactions.
- */
+const _interopRequireWildcard = require("@swc/helpers/lib/_interop_require_wildcard.js").default;
+const _react = /*#__PURE__*/ _interopRequireWildcard(require("react"));
 function isTouchEvent(event) {
-  return event.type.startsWith('touch');
+    return event.type.startsWith('touch');
 }
-exports.isTouchEvent = isTouchEvent;
-/**
- * Returns true if event is a mouse event. Useful when sharing logic between touch and mouse interactions.
- */
 function isMouseEvent(event) {
-  return event.type.startsWith('mouse') || ['click', 'contextmenu', 'dblclick'].indexOf(event.type) > -1;
+    return event.type.startsWith('mouse') || [
+        'click',
+        'contextmenu',
+        'dblclick'
+    ].indexOf(event.type) > -1;
 }
-exports.isMouseEvent = isMouseEvent;
-/**
- * Returns an object with clientX, clientY for TouchOrMouseEvent.
- * Returns zeros in case the event is not a mouse or a touch event.
- */
 function getEventClientCoords(event) {
-  if (isMouseEvent(event)) {
-    return {
-      clientX: event.clientX,
-      clientY: event.clientY
-    };
-  } else if (isTouchEvent(event)) {
-    return {
-      clientX: event.touches[0].clientX,
-      clientY: event.touches[0].clientY
-    };
-  } else {
-    if (process.env.NODE_ENV !== 'production') {
-      throw new Error('@fluentui/react-utilities]: Unable to get clientX. Unknown event type.');
+    if (isMouseEvent(event)) {
+        return {
+            clientX: event.clientX,
+            clientY: event.clientY
+        };
+    } else if (isTouchEvent(event)) {
+        return {
+            clientX: event.touches[0].clientX,
+            clientY: event.touches[0].clientY
+        };
+    } else {
+        if (process.env.NODE_ENV !== 'production') {
+            throw new Error('@fluentui/react-utilities]: Unable to get clientX. Unknown event type.');
+        }
+        return {
+            clientX: 0,
+            clientY: 0
+        };
     }
-    return {
-      clientX: 0,
-      clientY: 0
-    };
-  }
-}
-exports.getEventClientCoords = getEventClientCoords;
+} //# sourceMappingURL=mouseTouchHelpers.js.map
+
 //# sourceMappingURL=mouseTouchHelpers.js.map

package/lib-commonjs/events/mouseTouchHelpers.js.map

@@ -1 +1 @@
-{"version":3,"names":["isTouchEvent","event","type","startsWith","exports","isMouseEvent","indexOf","getEventClientCoords","clientX","clientY","touches","process","env","NODE_ENV","Error"],"sources":["../src/packages/react-components/react-utilities/src/events/mouseTouchHelpers.ts"],"sourcesContent":["import * as React from 'react';\n\nexport type NativeTouchOrMouseEvent = MouseEvent | TouchEvent;\n\nexport type ReactTouchOrMouseEvent = React.MouseEvent | React.TouchEvent;\n\nexport type TouchOrMouseEvent = NativeTouchOrMouseEvent | ReactTouchOrMouseEvent;\n\n/**\n * Returns true if event is a touch event. Useful when sharing logic between touch and mouse interactions.\n */\nexport function isTouchEvent(event: TouchOrMouseEvent): event is TouchEvent | React.TouchEvent {\n  return event.type.startsWith('touch');\n}\n\n/**\n * Returns true if event is a mouse event. Useful when sharing logic between touch and mouse interactions.\n */\nexport function isMouseEvent(event: TouchOrMouseEvent): event is MouseEvent | React.MouseEvent {\n  return event.type.startsWith('mouse') || ['click', 'contextmenu', 'dblclick'].indexOf(event.type) > -1;\n}\n\n/**\n * Returns an object with clientX, clientY for TouchOrMouseEvent.\n * Returns zeros in case the event is not a mouse or a touch event.\n */\nexport function getEventClientCoords(event: TouchOrMouseEvent): { clientX: number; clientY: number } {\n  if (isMouseEvent(event)) {\n    return { clientX: event.clientX, clientY: event.clientY };\n  } else if (isTouchEvent(event)) {\n    return { clientX: event.touches[0].clientX, clientY: event.touches[0].clientY };\n  } else {\n    if (process.env.NODE_ENV !== 'production') {\n      throw new Error('@fluentui/react-utilities]: Unable to get clientX. Unknown event type.');\n    }\n    return { clientX: 0, clientY: 0 };\n  }\n}\n"],"mappings":";;;;;;AAQA;;;AAGA,SAAgBA,YAAYA,CAACC,KAAwB;EACnD,OAAOA,KAAK,CAACC,IAAI,CAACC,UAAU,CAAC,OAAO,CAAC;AACvC;AAFAC,OAAA,CAAAJ,YAAA,GAAAA,YAAA;AAIA;;;AAGA,SAAgBK,YAAYA,CAACJ,KAAwB;EACnD,OAAOA,KAAK,CAACC,IAAI,CAACC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,aAAa,EAAE,UAAU,CAAC,CAACG,OAAO,CAACL,KAAK,CAACC,IAAI,CAAC,GAAG,CAAC,CAAC;AACxG;AAFAE,OAAA,CAAAC,YAAA,GAAAA,YAAA;AAIA;;;;AAIA,SAAgBE,oBAAoBA,CAACN,KAAwB;EAC3D,IAAII,YAAY,CAACJ,KAAK,CAAC,EAAE;IACvB,OAAO;MAAEO,OAAO,EAAEP,KAAK,CAACO,OAAO;MAAEC,OAAO,EAAER,KAAK,CAACQ;IAAO,CAAE;GAC1D,MAAM,IAAIT,YAAY,CAACC,KAAK,CAAC,EAAE;IAC9B,OAAO;MAAEO,OAAO,EAAEP,KAAK,CAACS,OAAO,CAAC,CAAC,CAAC,CAACF,OAAO;MAAEC,OAAO,EAAER,KAAK,CAACS,OAAO,CAAC,CAAC,CAAC,CAACD;IAAO,CAAE;GAChF,MAAM;IACL,IAAIE,OAAO,CAACC,GAAG,CAACC,QAAQ,KAAK,YAAY,EAAE;MACzC,MAAM,IAAIC,KAAK,CAAC,wEAAwE,CAAC;;IAE3F,OAAO;MAAEN,OAAO,EAAE,CAAC;MAAEC,OAAO,EAAE;IAAC,CAAE;;AAErC;AAXAL,OAAA,CAAAG,oBAAA,GAAAA,oBAAA"}
+{"version":3,"sources":["../../lib/events/mouseTouchHelpers.js"],"sourcesContent":["import * as React from 'react';\n/**\n * Returns true if event is a touch event. Useful when sharing logic between touch and mouse interactions.\n */\nexport function isTouchEvent(event) {\n  return event.type.startsWith('touch');\n}\n/**\n * Returns true if event is a mouse event. Useful when sharing logic between touch and mouse interactions.\n */\nexport function isMouseEvent(event) {\n  return event.type.startsWith('mouse') || ['click', 'contextmenu', 'dblclick'].indexOf(event.type) > -1;\n}\n/**\n * Returns an object with clientX, clientY for TouchOrMouseEvent.\n * Returns zeros in case the event is not a mouse or a touch event.\n */\nexport function getEventClientCoords(event) {\n  if (isMouseEvent(event)) {\n    return {\n      clientX: event.clientX,\n      clientY: event.clientY\n    };\n  } else if (isTouchEvent(event)) {\n    return {\n      clientX: event.touches[0].clientX,\n      clientY: event.touches[0].clientY\n    };\n  } else {\n    if (process.env.NODE_ENV !== 'production') {\n      throw new Error('@fluentui/react-utilities]: Unable to get clientX. Unknown event type.');\n    }\n    return {\n      clientX: 0,\n      clientY: 0\n    };\n  }\n}\n//# sourceMappingURL=mouseTouchHelpers.js.map"],"names":["isTouchEvent","isMouseEvent","getEventClientCoords","event","type","startsWith","indexOf","clientX","clientY","touches","process","env","NODE_ENV","Error"],"mappings":";;;;;;;;;;;IAIgBA,YAAY,MAAZA;IAMAC,YAAY,MAAZA;IAOAC,oBAAoB,MAApBA;;;6DAjBO;AAIhB,SAASF,aAAaG,KAAK,EAAE;IAClC,OAAOA,MAAMC,IAAI,CAACC,UAAU,CAAC;AAC/B;AAIO,SAASJ,aAAaE,KAAK,EAAE;IAClC,OAAOA,MAAMC,IAAI,CAACC,UAAU,CAAC,YAAY;QAAC;QAAS;QAAe;KAAW,CAACC,OAAO,CAACH,MAAMC,IAAI,IAAI,CAAC;AACvG;AAKO,SAASF,qBAAqBC,KAAK,EAAE;IAC1C,IAAIF,aAAaE,QAAQ;QACvB,OAAO;YACLI,SAASJ,MAAMI,OAAO;YACtBC,SAASL,MAAMK,OAAO;QACxB;IACF,OAAO,IAAIR,aAAaG,QAAQ;QAC9B,OAAO;YACLI,SAASJ,MAAMM,OAAO,CAAC,EAAE,CAACF,OAAO;YACjCC,SAASL,MAAMM,OAAO,CAAC,EAAE,CAACD,OAAO;QACnC;IACF,OAAO;QACL,IAAIE,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;YACzC,MAAM,IAAIC,MAAM,0EAA0E;QAC5F,CAAC;QACD,OAAO;YACLN,SAAS;YACTC,SAAS;QACX;IACF,CAAC;AACH,EACA,6CAA6C"}

package/lib-commonjs/hooks/index.js

@@ -1,19 +1,20 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-const tslib_1 = /*#__PURE__*/require("tslib");
-tslib_1.__exportStar(require("./useControllableState"), exports);
-tslib_1.__exportStar(require("./useEventCallback"), exports);
-tslib_1.__exportStar(require("./useFirstMount"), exports);
-tslib_1.__exportStar(require("./useForceUpdate"), exports);
-tslib_1.__exportStar(require("./useId"), exports);
-tslib_1.__exportStar(require("./useIsomorphicLayoutEffect"), exports);
-tslib_1.__exportStar(require("./useMergedRefs"), exports);
-tslib_1.__exportStar(require("./useOnClickOutside"), exports);
-tslib_1.__exportStar(require("./useOnScrollOutside"), exports);
-tslib_1.__exportStar(require("./usePrevious"), exports);
-tslib_1.__exportStar(require("./useScrollbarWidth"), exports);
-tslib_1.__exportStar(require("./useTimeout"), exports);
+const _exportStar = require("@swc/helpers/lib/_export_star.js").default;
+_exportStar(require("./useControllableState"), exports);
+_exportStar(require("./useEventCallback"), exports);
+_exportStar(require("./useFirstMount"), exports);
+_exportStar(require("./useForceUpdate"), exports);
+_exportStar(require("./useId"), exports);
+_exportStar(require("./useIsomorphicLayoutEffect"), exports);
+_exportStar(require("./useMergedRefs"), exports);
+_exportStar(require("./useOnClickOutside"), exports);
+_exportStar(require("./useOnScrollOutside"), exports);
+_exportStar(require("./usePrevious"), exports);
+_exportStar(require("./useScrollbarWidth"), exports);
+_exportStar(require("./useTimeout"), exports);
+ //# sourceMappingURL=index.js.map
+
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["tslib_1","__exportStar","require","exports"],"sources":["../src/packages/react-components/react-utilities/src/hooks/index.ts"],"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"],"mappings":";;;;;;AAAAA,OAAA,CAAAC,YAAA,CAAAC,OAAA,4BAAAC,OAAA;AACAH,OAAA,CAAAC,YAAA,CAAAC,OAAA,wBAAAC,OAAA;AACAH,OAAA,CAAAC,YAAA,CAAAC,OAAA,qBAAAC,OAAA;AACAH,OAAA,CAAAC,YAAA,CAAAC,OAAA,sBAAAC,OAAA;AACAH,OAAA,CAAAC,YAAA,CAAAC,OAAA,aAAAC,OAAA;AACAH,OAAA,CAAAC,YAAA,CAAAC,OAAA,iCAAAC,OAAA;AACAH,OAAA,CAAAC,YAAA,CAAAC,OAAA,qBAAAC,OAAA;AACAH,OAAA,CAAAC,YAAA,CAAAC,OAAA,yBAAAC,OAAA;AACAH,OAAA,CAAAC,YAAA,CAAAC,OAAA,0BAAAC,OAAA;AACAH,OAAA,CAAAC,YAAA,CAAAC,OAAA,mBAAAC,OAAA;AACAH,OAAA,CAAAC,YAAA,CAAAC,OAAA,yBAAAC,OAAA;AACAH,OAAA,CAAAC,YAAA,CAAAC,OAAA,kBAAAC,OAAA"}
+{"version":3,"sources":["../../lib/hooks/index.js"],"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//# sourceMappingURL=index.js.map"],"names":[],"mappings":";;;;;oBAAc;oBACA;oBACA;oBACA;oBACA;oBACA;oBACA;oBACA;oBACA;oBACA;oBACA;oBACA;CACd,iCAAiC"}

package/lib-commonjs/hooks/useControllableState.js

@@ -1,75 +1,74 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
+});
+Object.defineProperty(exports, "useControllableState", {
+    enumerable: true,
+    get: ()=>useControllableState
 });
-exports.useControllableState = void 0;
-const React = /*#__PURE__*/require("react");
+const _interopRequireWildcard = require("@swc/helpers/lib/_interop_require_wildcard.js").default;
+const _react = /*#__PURE__*/ _interopRequireWildcard(require("react"));
 function isFactoryDispatch(newState) {
-  return typeof newState === 'function';
+    return typeof newState === 'function';
 }
-/**
- * @internal
- *
- * A `useState`-like hook to manage a value that could be either controlled or uncontrolled,
- * such as a checked state or text input string.
- *
- * Unlike `setState`, it's okay to call the returned updater (dispatch) function for either a
- * controlled or uncontrolled component. Calls will only be respected if the component is uncontrolled.
- *
- * @returns Same as [`useState`](https://reactjs.org/docs/hooks-reference.html#usestate): an array
- * of the current value and an updater (dispatch) function. The updater function is referentially
- * stable (won't change during the component's lifecycle). It can take either a new value, or a
- * function which is passed the previous value and returns the new value. Unlike `setState`, calls
- * to the updater function will only be respected if the component is uncontrolled.
- * @see https://reactjs.org/docs/uncontrolled-components.html
- */
-const useControllableState = options => {
-  const isControlled = useIsControlled(options.state);
-  const initialState = typeof options.defaultState === 'undefined' ? options.initialState : options.defaultState;
-  const [internalState, setInternalState] = React.useState(initialState);
-  const state = isControlled ? options.state : internalState;
-  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
-  // 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
-    if (isFactoryDispatch(newState)) {
-      stateRef.current = newState(stateRef.current);
-    } else {
-      stateRef.current = newState;
-    }
-    setInternalState(stateRef.current);
-  }, []);
-  return [state, setState];
+const useControllableState = (options)=>{
+    const isControlled = useIsControlled(options.state);
+    const initialState = typeof options.defaultState === 'undefined' ? options.initialState : options.defaultState;
+    const [internalState, setInternalState] = _react.useState(initialState);
+    const state = isControlled ? options.state : internalState;
+    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
+    // 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
+        if (isFactoryDispatch(newState)) {
+            stateRef.current = newState(stateRef.current);
+        } else {
+            stateRef.current = newState;
+        }
+        setInternalState(stateRef.current);
+    }, []);
+    return [
+        state,
+        setState
+    ];
 };
-exports.useControllableState = useControllableState;
 /**
  * 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
+
 //# sourceMappingURL=useControllableState.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["React","require","isFactoryDispatch","newState","useControllableState","options","isControlled","useIsControlled","state","initialState","defaultState","internalState","setInternalState","useState","stateRef","useRef","useEffect","current","setState","useCallback","exports","controlledValue","undefined","process","env","NODE_ENV","error","Error","controlWarning","undefinedWarning","console","stack","join"],"sources":["../src/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"],"mappings":";;;;;;AAAA,MAAAA,KAAA,gBAAAC,OAAA;AAqBA,SAASC,iBAAiBA,CAAQC,QAAqC;EACrE,OAAO,OAAOA,QAAQ,KAAK,UAAU;AACvC;AAEA;;;;;;;;;;;;;;;;AAgBO,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,GAAGZ,KAAK,CAACa,QAAQ,CAAQJ,YAAY,CAAC;EAE7E,MAAMD,KAAK,GAAGF,YAAY,GAAID,OAAO,CAACG,KAAe,GAAGG,aAAa;EAErE,MAAMG,QAAQ,GAAGd,KAAK,CAACe,MAAM,CAACP,KAAK,CAAC;EACpCR,KAAK,CAACgB,SAAS,CAAC,MAAK;IACnBF,QAAQ,CAACG,OAAO,GAAGT,KAAK;EAC1B,CAAC,EAAE,CAACA,KAAK,CAAC,CAAC;EAEX;EACA;EACA,MAAMU,QAAQ,GAAGlB,KAAK,CAACmB,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;AA7BYE,OAAA,CAAAhB,oBAAoB,GAAAA,oBAAA;AA+BjC;;;;;AAKA,MAAMG,eAAe,GAAIc,eAAwB,IAAI;EACnD,MAAM,CAACf,YAAY,CAAC,GAAGN,KAAK,CAACa,QAAQ,CAAU,MAAMQ,eAAe,KAAKC,SAAS,CAAC;EAEnF,IAAIC,OAAO,CAACC,GAAG,CAACC,QAAQ,KAAK,YAAY,EAAE;IACzC;IACA;IACAzB,KAAK,CAACgB,SAAS,CAAC,MAAK;MACnB,IAAIV,YAAY,MAAMe,eAAe,KAAKC,SAAS,CAAC,EAAE;QACpD,MAAMI,KAAK,GAAG,IAAIC,KAAK,EAAE;QAEzB,MAAMC,cAAc,GAAGtB,YAAY,GAC/B,uCAAuC,GACvC,wCAAwC;QAE5C,MAAMuB,gBAAgB,GAAGvB,YAAY,GAAG,yBAAyB,GAAG,wBAAwB;QAE5F;QACAwB,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,CAAC1B,YAAY,EAAEe,eAAe,CAAC,CAAC;;EAGrC,OAAOf,YAAY;AACrB,CAAC"}
+{"version":3,"sources":["../../lib/hooks/useControllableState.js"],"sourcesContent":["import * as React from 'react';\nfunction isFactoryDispatch(newState) {\n  return typeof newState === 'function';\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 = options => {\n  const isControlled = useIsControlled(options.state);\n  const initialState = typeof options.defaultState === 'undefined' ? options.initialState : options.defaultState;\n  const [internalState, setInternalState] = React.useState(initialState);\n  const state = isControlled ? options.state : internalState;\n  const stateRef = React.useRef(state);\n  React.useEffect(() => {\n    stateRef.current = state;\n  }, [state]);\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 => {\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    setInternalState(stateRef.current);\n  }, []);\n  return [state, setState];\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 => {\n  const [isControlled] = React.useState(() => controlledValue !== undefined);\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        const controlWarning = isControlled ? 'a controlled value to be uncontrolled' : 'an uncontrolled value to be controlled';\n        const undefinedWarning = isControlled ? 'defined to an undefined' : 'undefined to a defined';\n        // eslint-disable-next-line no-console\n        console.error([\n        // Default react error\n        '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(' '));\n      }\n    }, [isControlled, controlledValue]);\n  }\n  return isControlled;\n};\n//# sourceMappingURL=useControllableState.js.map"],"names":["useControllableState","isFactoryDispatch","newState","options","isControlled","useIsControlled","state","initialState","defaultState","internalState","setInternalState","React","useState","stateRef","useRef","useEffect","current","setState","useCallback","controlledValue","undefined","process","env","NODE_ENV","error","Error","controlWarning","undefinedWarning","console","stack","join"],"mappings":";;;;+BAoBaA;;aAAAA;;;6DApBU;AACvB,SAASC,kBAAkBC,QAAQ,EAAE;IACnC,OAAO,OAAOA,aAAa;AAC7B;AAiBO,MAAMF,uBAAuBG,CAAAA,UAAW;IAC7C,MAAMC,eAAeC,gBAAgBF,QAAQG,KAAK;IAClD,MAAMC,eAAe,OAAOJ,QAAQK,YAAY,KAAK,cAAcL,QAAQI,YAAY,GAAGJ,QAAQK,YAAY;IAC9G,MAAM,CAACC,eAAeC,iBAAiB,GAAGC,OAAMC,QAAQ,CAACL;IACzD,MAAMD,QAAQF,eAAeD,QAAQG,KAAK,GAAGG,aAAa;IAC1D,MAAMI,WAAWF,OAAMG,MAAM,CAACR;IAC9BK,OAAMI,SAAS,CAAC,IAAM;QACpBF,SAASG,OAAO,GAAGV;IACrB,GAAG;QAACA;KAAM;IACV,2FAA2F;IAC3F,4FAA4F;IAC5F,MAAMW,WAAWN,OAAMO,WAAW,CAAChB,CAAAA,WAAY;QAC7C,mCAAmC;QACnC,mEAAmE;QACnE,IAAID,kBAAkBC,WAAW;YAC/BW,SAASG,OAAO,GAAGd,SAASW,SAASG,OAAO;QAC9C,OAAO;YACLH,SAASG,OAAO,GAAGd;QACrB,CAAC;QACDQ,iBAAiBG,SAASG,OAAO;IACnC,GAAG,EAAE;IACL,OAAO;QAACV;QAAOW;KAAS;AAC1B;AACA;;;;CAIC,GACD,MAAMZ,kBAAkBc,CAAAA,kBAAmB;IACzC,MAAM,CAACf,aAAa,GAAGO,OAAMC,QAAQ,CAAC,IAAMO,oBAAoBC;IAChE,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;QACzC,wFAAwF;QACxF,sDAAsD;QACtDZ,OAAMI,SAAS,CAAC,IAAM;YACpB,IAAIX,iBAAkBe,CAAAA,oBAAoBC,SAAQ,GAAI;gBACpD,MAAMI,QAAQ,IAAIC;gBAClB,MAAMC,iBAAiBtB,eAAe,0CAA0C,wCAAwC;gBACxH,MAAMuB,mBAAmBvB,eAAe,4BAA4B,wBAAwB;gBAC5F,sCAAsC;gBACtCwB,QAAQJ,KAAK,CAAC;oBACd,sBAAsB;oBACtB,6BAA6BE,iBAAiB;oBAAwC,mBAAmBC,mBAAmB;oBAAoC;oBAAsG;oBAA6DH,MAAMK,KAAK;iBAAC,CAACC,IAAI,CAAC;YACvV,CAAC;QACH,GAAG;YAAC1B;YAAce;SAAgB;IACpC,CAAC;IACD,OAAOf;AACT,GACA,gDAAgD"}

package/lib-commonjs/hooks/useEventCallback.js

@@ -1,35 +1,29 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
+});
+Object.defineProperty(exports, "useEventCallback", {
+    enumerable: true,
+    get: ()=>useEventCallback
 });
-exports.useEventCallback = void 0;
-const React = /*#__PURE__*/require("react");
-const useIsomorphicLayoutEffect_1 = /*#__PURE__*/require("./useIsomorphicLayoutEffect");
-/**
- * @internal
- * https://reactjs.org/docs/hooks-faq.html#how-to-read-an-often-changing-value-from-usecallback
- *
- * Modified `useCallback` that can be used when dependencies change too frequently. Can occur when
- * e.g. user props are dependencies which could change on every render
- * e.g. volatile values (i.e. useState/useDispatch) are dependencies which could change frequently
- *
- * This should not be used often, but can be a useful re-render optimization since the callback is a ref and
- * will not be invalidated between re-renders
- *
- * @param fn - The callback function that will be used
- */
-const useEventCallback = fn => {
-  const callbackRef = React.useRef(() => {
-    throw new Error('Cannot call an event handler while rendering');
-  });
-  useIsomorphicLayoutEffect_1.useIsomorphicLayoutEffect(() => {
-    callbackRef.current = fn;
-  }, [fn]);
-  return React.useCallback((...args) => {
-    const callback = callbackRef.current;
-    return callback(...args);
-  }, [callbackRef]);
-};
-exports.useEventCallback = useEventCallback;
+const _interopRequireWildcard = require("@swc/helpers/lib/_interop_require_wildcard.js").default;
+const _react = /*#__PURE__*/ _interopRequireWildcard(require("react"));
+const _useIsomorphicLayoutEffect = require("./useIsomorphicLayoutEffect");
+const useEventCallback = (fn)=>{
+    const callbackRef = _react.useRef(()=>{
+        throw new Error('Cannot call an event handler while rendering');
+    });
+    (0, _useIsomorphicLayoutEffect.useIsomorphicLayoutEffect)(()=>{
+        callbackRef.current = fn;
+    }, [
+        fn
+    ]);
+    return _react.useCallback((...args)=>{
+        const callback = callbackRef.current;
+        return callback(...args);
+    }, [
+        callbackRef
+    ]);
+}; //# sourceMappingURL=useEventCallback.js.map
+
 //# sourceMappingURL=useEventCallback.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["React","require","useIsomorphicLayoutEffect_1","useEventCallback","fn","callbackRef","useRef","Error","useIsomorphicLayoutEffect","current","useCallback","args","callback","exports"],"sources":["../src/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"],"mappings":";;;;;;AAAA,MAAAA,KAAA,gBAAAC,OAAA;AACA,MAAAC,2BAAA,gBAAAD,OAAA;AAEA;;;;;;;;;;;;;AAaO,MAAME,gBAAgB,GAAoCC,EAA6B,IAAI;EAChG,MAAMC,WAAW,GAAGL,KAAK,CAACM,MAAM,CAAY,MAAK;IAC/C,MAAM,IAAIC,KAAK,CAAC,8CAA8C,CAAC;EACjE,CAAC,CAAC;EAEFL,2BAAA,CAAAM,yBAAyB,CAAC,MAAK;IAC7BH,WAAW,CAACI,OAAO,GAAGL,EAAE;EAC1B,CAAC,EAAE,CAACA,EAAE,CAAC,CAAC;EAER,OAAOJ,KAAK,CAACU,WAAW,CACtB,CAAC,GAAGC,IAAU,KAAI;IAChB,MAAMC,QAAQ,GAAGP,WAAW,CAACI,OAAO;IACpC,OAAOG,QAAQ,CAAC,GAAGD,IAAI,CAAC;EAC1B,CAAC,EACD,CAACN,WAAW,CAAC,CACd;AACH,CAAC;AAhBYQ,OAAA,CAAAV,gBAAgB,GAAAA,gBAAA"}
+{"version":3,"sources":["../../lib/hooks/useEventCallback.js"],"sourcesContent":["import * as React from 'react';\nimport { useIsomorphicLayoutEffect } from './useIsomorphicLayoutEffect';\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 = fn => {\n  const callbackRef = React.useRef(() => {\n    throw new Error('Cannot call an event handler while rendering');\n  });\n  useIsomorphicLayoutEffect(() => {\n    callbackRef.current = fn;\n  }, [fn]);\n  return React.useCallback((...args) => {\n    const callback = callbackRef.current;\n    return callback(...args);\n  }, [callbackRef]);\n};\n//# sourceMappingURL=useEventCallback.js.map"],"names":["useEventCallback","fn","callbackRef","React","useRef","Error","useIsomorphicLayoutEffect","current","useCallback","args","callback"],"mappings":";;;;+BAeaA;;aAAAA;;;6DAfU;2CACmB;AAcnC,MAAMA,mBAAmBC,CAAAA,KAAM;IACpC,MAAMC,cAAcC,OAAMC,MAAM,CAAC,IAAM;QACrC,MAAM,IAAIC,MAAM,gDAAgD;IAClE;IACAC,IAAAA,oDAAyB,EAAC,IAAM;QAC9BJ,YAAYK,OAAO,GAAGN;IACxB,GAAG;QAACA;KAAG;IACP,OAAOE,OAAMK,WAAW,CAAC,CAAC,GAAGC,OAAS;QACpC,MAAMC,WAAWR,YAAYK,OAAO;QACpC,OAAOG,YAAYD;IACrB,GAAG;QAACP;KAAY;AAClB,GACA,4CAA4C"}

package/lib-commonjs/hooks/useFirstMount.js

@@ -1,28 +1,20 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
+});
+Object.defineProperty(exports, "useFirstMount", {
+    enumerable: true,
+    get: ()=>useFirstMount
 });
-exports.useFirstMount = void 0;
-const React = /*#__PURE__*/require("react");
-/**
- * @internal
- * Checks if components was mounted the first time.
- * Since concurrent mode will be released in the future this needs to be verified
- * Currently (React 17) will always render the initial mount once
- * https://codesandbox.io/s/heuristic-brook-s4w0q?file=/src/App.jsx
- * https://codesandbox.io/s/holy-grass-8nieu?file=/src/App.jsx
- *
- * @example
- * const isFirstMount = useFirstMount();
- */
+const _interopRequireWildcard = require("@swc/helpers/lib/_interop_require_wildcard.js").default;
+const _react = /*#__PURE__*/ _interopRequireWildcard(require("react"));
 function useFirstMount() {
-  const isFirst = React.useRef(true);
-  if (isFirst.current) {
-    isFirst.current = false;
-    return true;
-  }
-  return isFirst.current;
-}
-exports.useFirstMount = useFirstMount;
+    const isFirst = _react.useRef(true);
+    if (isFirst.current) {
+        isFirst.current = false;
+        return true;
+    }
+    return isFirst.current;
+} //# sourceMappingURL=useFirstMount.js.map
+
 //# sourceMappingURL=useFirstMount.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["React","require","useFirstMount","isFirst","useRef","current","exports"],"sources":["../src/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"],"mappings":";;;;;;AAAA,MAAAA,KAAA,gBAAAC,OAAA;AAEA;;;;;;;;;;;AAWA,SAAgBC,aAAaA,CAAA;EAC3B,MAAMC,OAAO,GAAGH,KAAK,CAACI,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;AATAC,OAAA,CAAAJ,aAAA,GAAAA,aAAA"}
+{"version":3,"sources":["../../lib/hooks/useFirstMount.js"],"sourcesContent":["import * as React from 'react';\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() {\n  const isFirst = React.useRef(true);\n  if (isFirst.current) {\n    isFirst.current = false;\n    return true;\n  }\n  return isFirst.current;\n}\n//# sourceMappingURL=useFirstMount.js.map"],"names":["useFirstMount","isFirst","React","useRef","current"],"mappings":";;;;+BAYgBA;;aAAAA;;;6DAZO;AAYhB,SAASA,gBAAgB;IAC9B,MAAMC,UAAUC,OAAMC,MAAM,CAAC,IAAI;IACjC,IAAIF,QAAQG,OAAO,EAAE;QACnBH,QAAQG,OAAO,GAAG,KAAK;QACvB,OAAO,IAAI;IACb,CAAC;IACD,OAAOH,QAAQG,OAAO;AACxB,EACA,yCAAyC"}

package/lib-commonjs/hooks/useForceUpdate.js

@@ -1,16 +1,14 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
+});
+Object.defineProperty(exports, "useForceUpdate", {
+    enumerable: true,
+    get: ()=>useForceUpdate
 });
-exports.useForceUpdate = void 0;
-const react_1 = /*#__PURE__*/require("react");
-/**
- * @internal
- * Forces a re-render, similar to `forceUpdate` in class components.
- */
+const _react = require("react");
 function useForceUpdate() {
-  return react_1.useReducer(x => x + 1, 0)[1];
-}
-exports.useForceUpdate = useForceUpdate;
+    return (0, _react.useReducer)((x)=>x + 1, 0)[1];
+} //# sourceMappingURL=useForceUpdate.js.map
+
 //# sourceMappingURL=useForceUpdate.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["react_1","require","useForceUpdate","useReducer","x","exports"],"sources":["../src/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"],"mappings":";;;;;;AAAA,MAAAA,OAAA,gBAAAC,OAAA;AAEA;;;;AAIA,SAAgBC,cAAcA,CAAA;EAC5B,OAAOF,OAAA,CAAAG,UAAU,CAACC,CAAC,IAAIA,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AACrC;AAFAC,OAAA,CAAAH,cAAA,GAAAA,cAAA"}
+{"version":3,"sources":["../../lib/hooks/useForceUpdate.js"],"sourcesContent":["import { useReducer } from 'react';\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//# sourceMappingURL=useForceUpdate.js.map"],"names":["useForceUpdate","useReducer","x"],"mappings":";;;;+BAKgBA;;aAAAA;;uBALW;AAKpB,SAASA,iBAAiB;IAC/B,OAAOC,IAAAA,iBAAU,EAACC,CAAAA,IAAKA,IAAI,GAAG,EAAE,CAAC,EAAE;AACrC,EACA,0CAA0C"}