@fluentui/react-utilities 0.0.0-nightly-20230501-0418.1 → 0.0.0-nightly-20230503-0419.1

package/lib/compose/constants.js

@@ -0,0 +1,5 @@
+/**
+ * @internal
+ * Internal reference for the render function
+ */export const SLOT_RENDER_FUNCTION_SYMBOL = /*#__PURE__*/Symbol('fui.slotRenderFunction');
+//# sourceMappingURL=constants.js.map

package/lib/compose/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["SLOT_RENDER_FUNCTION_SYMBOL","Symbol"],"sources":["../../src/compose/constants.ts"],"sourcesContent":["/**\n * @internal\n * Internal reference for the render function\n */\nexport const SLOT_RENDER_FUNCTION_SYMBOL = Symbol('fui.slotRenderFunction');\n"],"mappings":"AAAA;;;GAIA,OAAO,MAAMA,2BAAA,gBAA8BC,MAAA,CAAO"}

package/lib/compose/getSlots.js

@@ -0,0 +1,58 @@
+import * as React from 'react';
+import { omit } from '../utils/omit';
+import { SLOT_RENDER_FUNCTION_SYMBOL } from './constants';
+/**
+ * Given the state and an array of slot names, will break out `slots` and `slotProps`
+ * collections.
+ *
+ * The root is derived from a mix of `components` props and `as` prop.
+ *
+ * Slots will render as null if they are rendered as primitives with undefined children.
+ *
+ * The slotProps will always omit the `as` prop within them, and for slots that are string
+ * primitives, the props will be filtered according to the slot type by the type system.
+ * For example, if the slot is rendered `as: 'a'`, the props will be filtered for acceptable
+ * anchor props. Note that this is only enforced at build time by Typescript -- there is no
+ * runtime code filtering props in this function.
+ *
+ * @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 _state_components, _state_components1;
+  const props = state[slotName];
+  if (props === undefined) {
+    return [null, undefined];
+  }
+  const {
+    children,
+    as: asProp,
+    [SLOT_RENDER_FUNCTION_SYMBOL]: renderFunction,
+    ...rest
+  } = props;
+  const slot = ((_state_components = state.components) === null || _state_components === void 0 ? void 0 : _state_components[slotName]) === undefined || typeof state.components[slotName] === 'string' ? asProp || ((_state_components1 = state.components) === null || _state_components1 === void 0 ? void 0 : _state_components1[slotName]) || 'div' : state.components[slotName];
+  if (renderFunction || typeof children === 'function') {
+    const render = renderFunction || children;
+    return [React.Fragment, {
+      children: render(slot, rest)
+    }];
+  }
+  const shouldOmitAsProp = typeof slot === 'string' && asProp;
+  const slotProps = shouldOmitAsProp ? omit(props, ['as']) : props;
+  return [slot, slotProps];
+}
+//# sourceMappingURL=getSlots.js.map

package/lib/compose/getSlots.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","omit","SLOT_RENDER_FUNCTION_SYMBOL","getSlots","state","slots","slotProps","slotNames","Object","keys","components","slotName","slot","props","getSlot","_state_components","_state_components1","undefined","children","as","asProp","renderFunction","rest","render","Fragment","shouldOmitAsProp"],"sources":["../../src/compose/getSlots.ts"],"sourcesContent":["import * as React from 'react';\n\nimport { omit } from '../utils/omit';\nimport { SLOT_RENDER_FUNCTION_SYMBOL } from './constants';\nimport type {\n  AsIntrinsicElement,\n  ComponentState,\n  ExtractSlotProps,\n  SlotPropsRecord,\n  SlotRenderFunction,\n  UnionToIntersection,\n  UnknownSlotProps,\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\nexport type 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]> // Slot<'div', 'span'>\n    : ExtractSlotProps<S[K]> extends React.ComponentType<infer P>\n    ? P // Slot<typeof Button>\n    : ExtractSlotProps<S[K]>; // Slot<ButtonProps>\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  const props = state[slotName];\n\n  if (props === undefined) {\n    return [null, undefined as R[K]];\n  }\n\n  const {\n    children,\n    as: asProp,\n    [SLOT_RENDER_FUNCTION_SYMBOL]: renderFunction,\n    ...rest\n  } = props as typeof props & { [SLOT_RENDER_FUNCTION_SYMBOL]?: SlotRenderFunction<R[K]> };\n\n  const slot = (\n    state.components?.[slotName] === undefined || typeof state.components[slotName] === 'string'\n      ? asProp || state.components?.[slotName] || 'div'\n      : state.components[slotName]\n  ) as React.ElementType<R[K]>;\n\n  if (renderFunction || typeof children === 'function') {\n    const render = renderFunction || (children as SlotRenderFunction<R[K]>);\n    return [\n      React.Fragment,\n      {\n        children: render(slot, rest as Omit<R[K], 'as'>),\n      } as unknown as R[K],\n    ];\n  }\n\n  const shouldOmitAsProp = typeof slot === 'string' && asProp;\n  const slotProps = (shouldOmitAsProp ? omit(props, ['as']) : (props as UnknownSlotProps)) as R[K];\n  return [slot, slotProps];\n}\n"],"mappings":"AAAA,YAAYA,KAAA,MAAW;AAEvB,SAASC,IAAI,QAAQ;AACrB,SAASC,2BAA2B,QAAQ;AA8B5C;;;;;;;;;;;;;;;;;AAiBA,OAAO,SAASC,SACdC,KAAwB,EAIxB;EACA,MAAMC,KAAA,GAAQ,CAAC;EACf,MAAMC,SAAA,GAAY,CAAC;EAEnB,MAAMC,SAAA,GAAyBC,MAAA,CAAOC,IAAI,CAACL,KAAA,CAAMM,UAAU;EAC3D,KAAK,MAAMC,QAAA,IAAYJ,SAAA,EAAW;IAChC,MAAM,CAACK,IAAA,EAAMC,KAAA,CAAM,GAAGC,OAAA,CAAQV,KAAA,EAAOO,QAAA;IACrCN,KAAK,CAACM,QAAA,CAAS,GAAGC,IAAA;IAClBN,SAAS,CAACK,QAAA,CAAS,GAAGE,KAAA;EACxB;EACA,OAAO;IAAER,KAAA;IAAOC,SAAA,EAAWA;EAA2C;AACxE;AAEA,SAASQ,QACPV,KAAwB,EACxBO,QAAW,EACsC;MAe/CI,iBAAA,EACcC,kBAAA;EAfhB,MAAMH,KAAA,GAAQT,KAAK,CAACO,QAAA,CAAS;EAE7B,IAAIE,KAAA,KAAUI,SAAA,EAAW;IACvB,OAAO,CAAC,IAAI,EAAEA,SAAA,CAAkB;EAClC;EAEA,MAAM;IACJC,QAAA;IACAC,EAAA,EAAIC,MAAA;IACJ,CAAClB,2BAAA,GAA8BmB,cAAA;IAC/B,GAAGC;EAAA,CACJ,GAAGT,KAAA;EAEJ,MAAMD,IAAA,GACJ,EAAAG,iBAAA,GAAAX,KAAA,CAAMM,UAAU,cAAhBK,iBAAA,uBAAAA,iBAAkB,CAACJ,QAAA,CAAS,MAAKM,SAAA,IAAa,OAAOb,KAAA,CAAMM,UAAU,CAACC,QAAA,CAAS,KAAK,WAChFS,MAAA,KAAU,CAAAJ,kBAAA,GAAAZ,KAAA,CAAMM,UAAU,cAAhBM,kBAAA,uBAAAA,kBAAkB,CAACL,QAAA,CAAS,CAAD,IAAK,QAC1CP,KAAA,CAAMM,UAAU,CAACC,QAAA,CAAS;EAGhC,IAAIU,cAAA,IAAkB,OAAOH,QAAA,KAAa,YAAY;IACpD,MAAMK,MAAA,GAASF,cAAA,IAAmBH,QAAA;IAClC,OAAO,CACLlB,KAAA,CAAMwB,QAAQ,EACd;MACEN,QAAA,EAAUK,MAAA,CAAOX,IAAA,EAAMU,IAAA;IACzB,EACD;EACH;EAEA,MAAMG,gBAAA,GAAmB,OAAOb,IAAA,KAAS,YAAYQ,MAAA;EACrD,MAAMd,SAAA,GAAamB,gBAAA,GAAmBxB,IAAA,CAAKY,KAAA,EAAO,CAAC,KAAK,IAAKA,KAA0B;EACvF,OAAO,CAACD,IAAA,EAAMN,SAAA,CAAU;AAC1B"}

package/lib/compose/getSlotsNext.js

@@ -0,0 +1,34 @@
+import * as React from 'react';
+/**
+ * Similar to `getSlots`, main difference is that it's compatible with new custom jsx pragma
+ */
+export function getSlotsNext(state) {
+  const slots = {};
+  const slotProps = {};
+  const slotNames = Object.keys(state.components);
+  for (const slotName of slotNames) {
+    const [slot, props] = getSlotNext(state, slotName);
+    slots[slotName] = slot;
+    slotProps[slotName] = props;
+  }
+  return {
+    slots,
+    slotProps: slotProps
+  };
+}
+function getSlotNext(state, slotName) {
+  var _state_components, _state_components1;
+  const props = state[slotName];
+  if (props === undefined) {
+    return [null, undefined];
+  }
+  const {
+    as: asProp,
+    ...propsWithoutAs
+  } = props;
+  const slot = ((_state_components = state.components) === null || _state_components === void 0 ? void 0 : _state_components[slotName]) === undefined || typeof state.components[slotName] === 'string' ? asProp || ((_state_components1 = state.components) === null || _state_components1 === void 0 ? void 0 : _state_components1[slotName]) || 'div' : state.components[slotName];
+  const shouldOmitAsProp = typeof slot === 'string' && asProp;
+  const slotProps = shouldOmitAsProp ? propsWithoutAs : props;
+  return [slot, slotProps];
+}
+//# sourceMappingURL=getSlotsNext.js.map

package/lib/compose/getSlotsNext.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","getSlotsNext","state","slots","slotProps","slotNames","Object","keys","components","slotName","slot","props","getSlotNext","_state_components","_state_components1","undefined","as","asProp","propsWithoutAs","shouldOmitAsProp"],"sources":["../../src/compose/getSlotsNext.ts"],"sourcesContent":["import * as React from 'react';\nimport type { ComponentState, SlotPropsRecord, UnknownSlotProps } from './types';\nimport { ObjectSlotProps, Slots } from './getSlots';\n\n/**\n * Similar to `getSlots`, main difference is that it's compatible with new custom jsx pragma\n */\nexport function getSlotsNext<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] = getSlotNext(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 getSlotNext<R extends SlotPropsRecord, K extends keyof R>(\n  state: ComponentState<R>,\n  slotName: K,\n): readonly [React.ElementType<R[K]> | null, R[K]] {\n  const props = state[slotName];\n\n  if (props === undefined) {\n    return [null, undefined as R[K]];\n  }\n  const { as: asProp, ...propsWithoutAs } = props;\n\n  const slot = (\n    state.components?.[slotName] === undefined || typeof state.components[slotName] === 'string'\n      ? asProp || state.components?.[slotName] || 'div'\n      : state.components[slotName]\n  ) as React.ElementType<R[K]>;\n\n  const shouldOmitAsProp = typeof slot === 'string' && asProp;\n  const slotProps: UnknownSlotProps = shouldOmitAsProp ? propsWithoutAs : props;\n\n  return [slot, slotProps as R[K]];\n}\n"],"mappings":"AAAA,YAAYA,KAAA,MAAW;AAIvB;;;AAGA,OAAO,SAASC,aACdC,KAAwB,EAIxB;EACA,MAAMC,KAAA,GAAQ,CAAC;EACf,MAAMC,SAAA,GAAY,CAAC;EAEnB,MAAMC,SAAA,GAAyBC,MAAA,CAAOC,IAAI,CAACL,KAAA,CAAMM,UAAU;EAC3D,KAAK,MAAMC,QAAA,IAAYJ,SAAA,EAAW;IAChC,MAAM,CAACK,IAAA,EAAMC,KAAA,CAAM,GAAGC,WAAA,CAAYV,KAAA,EAAOO,QAAA;IACzCN,KAAK,CAACM,QAAA,CAAS,GAAGC,IAAA;IAClBN,SAAS,CAACK,QAAA,CAAS,GAAGE,KAAA;EACxB;EACA,OAAO;IAAER,KAAA;IAAOC,SAAA,EAAWA;EAA2C;AACxE;AAEA,SAASQ,YACPV,KAAwB,EACxBO,QAAW,EACsC;MAS/CI,iBAAA,EACcC,kBAAA;EAThB,MAAMH,KAAA,GAAQT,KAAK,CAACO,QAAA,CAAS;EAE7B,IAAIE,KAAA,KAAUI,SAAA,EAAW;IACvB,OAAO,CAAC,IAAI,EAAEA,SAAA,CAAkB;EAClC;EACA,MAAM;IAAEC,EAAA,EAAIC,MAAA;IAAQ,GAAGC;EAAA,CAAgB,GAAGP,KAAA;EAE1C,MAAMD,IAAA,GACJ,EAAAG,iBAAA,GAAAX,KAAA,CAAMM,UAAU,cAAhBK,iBAAA,uBAAAA,iBAAkB,CAACJ,QAAA,CAAS,MAAKM,SAAA,IAAa,OAAOb,KAAA,CAAMM,UAAU,CAACC,QAAA,CAAS,KAAK,WAChFQ,MAAA,KAAU,CAAAH,kBAAA,GAAAZ,KAAA,CAAMM,UAAU,cAAhBM,kBAAA,uBAAAA,kBAAkB,CAACL,QAAA,CAAS,CAAD,IAAK,QAC1CP,KAAA,CAAMM,UAAU,CAACC,QAAA,CAAS;EAGhC,MAAMU,gBAAA,GAAmB,OAAOT,IAAA,KAAS,YAAYO,MAAA;EACrD,MAAMb,SAAA,GAA8Be,gBAAA,GAAmBD,cAAA,GAAiBP,KAAK;EAE7E,OAAO,CAACD,IAAA,EAAMN,SAAA,CAAkB;AAClC"}

package/lib/compose/index.js

@@ -0,0 +1,7 @@
+export * from './getSlots';
+export * from './resolveShorthand';
+export * from './types';
+export * from './isResolvedShorthand';
+export * from './constants';
+export * from './getSlotsNext';
+//# sourceMappingURL=index.js.map

package/lib/compose/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["../../src/compose/index.ts"],"sourcesContent":["export * from './getSlots';\nexport * from './resolveShorthand';\nexport * from './types';\nexport * from './isResolvedShorthand';\nexport * from './constants';\nexport * from './getSlotsNext';\n"],"mappings":"AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc"}

package/lib/compose/isResolvedShorthand.js

@@ -0,0 +1,35 @@
+import { isValidElement } from 'react';
+/**
+ * Guard method that validates if a shorthand is a slot
+ * can be used to extends properties provided by a slot
+ *
+ * @example
+ * ```
+ * const backdropSlot = resolveShorthand(backdrop, {
+ *  defaultProps: {
+ *    onClick: useEventCallback(event => {
+ *     if (isResolvedShorthand(backdrop)) {
+ *        backdrop.onClick?.(event)
+ *      }
+ *      // do something after passing click down the line
+ *    }),
+ *  },
+ * })
+ * ```
+ * @example
+ * ```
+ * const handleBackDropClick = (event) => {
+ *  // do your thing
+ * }
+ * const backdropSlot = resolveShorthand(backdrop, {
+ *  defaultProps: {
+ *    onClick: useEventCallback(
+ *      mergeCallbacks(isResolvedShorthand(backdrop) ? backdrop.onClick : undefined, handleBackdropClick)
+ *    )
+ * })
+ * ```
+ */
+export function isResolvedShorthand(shorthand) {
+  return shorthand !== null && typeof shorthand === 'object' && !Array.isArray(shorthand) && ! /*#__PURE__*/isValidElement(shorthand);
+}
+//# sourceMappingURL=isResolvedShorthand.js.map

package/lib/compose/isResolvedShorthand.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["isValidElement","isResolvedShorthand","shorthand","Array","isArray"],"sources":["../../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"],"mappings":"AAAA,SAASA,cAAc,QAAQ;AAG/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,OAAO,SAASC,oBACdC,SAAqB,EACqB;EAC1C,OAAOA,SAAA,KAAc,IAAI,IAAI,OAAOA,SAAA,KAAc,YAAY,CAACC,KAAA,CAAMC,OAAO,CAACF,SAAA,KAAc,eAACF,cAAA,CAAeE,SAAA;AAC7G"}

package/lib/compose/resolveShorthand.js

@@ -0,0 +1,34 @@
+import { isValidElement } from 'react';
+import { SLOT_RENDER_FUNCTION_SYMBOL } from './constants';
+/**
+ * Resolves shorthands into slot props, to ensure normalization of the signature
+ * being passed down to getSlots method
+ * @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 = {};
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  if (typeof value === 'string' || typeof value === 'number' || Array.isArray(value) || /*#__PURE__*/isValidElement(value)) {
+    resolvedShorthand.children = value;
+  } else if (typeof value === 'object') {
+    resolvedShorthand = value;
+  }
+  resolvedShorthand = {
+    ...defaultProps,
+    ...resolvedShorthand
+  };
+  if (typeof resolvedShorthand.children === 'function') {
+    resolvedShorthand[SLOT_RENDER_FUNCTION_SYMBOL] = resolvedShorthand.children;
+    resolvedShorthand.children = defaultProps === null || defaultProps === void 0 ? void 0 : defaultProps.children;
+  }
+  return resolvedShorthand;
+};
+//# sourceMappingURL=resolveShorthand.js.map

package/lib/compose/resolveShorthand.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["isValidElement","SLOT_RENDER_FUNCTION_SYMBOL","resolveShorthand","value","options","required","defaultProps","undefined","resolvedShorthand","Array","isArray","children"],"sources":["../../src/compose/resolveShorthand.ts"],"sourcesContent":["import { isValidElement } from 'react';\nimport type { SlotRenderFunction, SlotShorthandValue, UnknownSlotProps } from './types';\nimport { SLOT_RENDER_FUNCTION_SYMBOL } from './constants';\n\nexport type ResolveShorthandOptions<Props, Required extends boolean = false> = Required extends true\n  ? { required: true; defaultProps?: Props }\n  : { required?: Required; defaultProps?: Props };\n\nexport type ResolveShorthandFunction<Props extends UnknownSlotProps = UnknownSlotProps> = {\n  <P extends Props>(value: P | SlotShorthandValue | undefined, options: ResolveShorthandOptions<P, true>): P;\n  <P extends Props>(value: P | SlotShorthandValue | null | undefined, options?: ResolveShorthandOptions<P, boolean>):\n    | 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: UnknownSlotProps & {\n    [SLOT_RENDER_FUNCTION_SYMBOL]?: SlotRenderFunction<UnknownSlotProps>;\n  } = {};\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  if (typeof value === 'string' || typeof value === 'number' || Array.isArray(value) || isValidElement<any>(value)) {\n    resolvedShorthand.children = value;\n  } else if (typeof value === 'object') {\n    resolvedShorthand = value;\n  }\n\n  resolvedShorthand = {\n    ...defaultProps,\n    ...resolvedShorthand,\n  };\n\n  if (typeof resolvedShorthand.children === 'function') {\n    resolvedShorthand[SLOT_RENDER_FUNCTION_SYMBOL] = resolvedShorthand.children as SlotRenderFunction<UnknownSlotProps>;\n    resolvedShorthand.children = defaultProps?.children;\n  }\n\n  return resolvedShorthand;\n};\n"],"mappings":"AAAA,SAASA,cAAc,QAAQ;AAE/B,SAASC,2BAA2B,QAAQ;AAa5C;;;;;;AAMA,OAAO,MAAMC,gBAAA,GAA6CA,CAACC,KAAA,EAAOC,OAAA,KAAY;EAC5E,MAAM;IAAEC,QAAA,GAAW,KAAK;IAAEC;EAAY,CAAE,GAAGF,OAAA,IAAW,CAAC;EACvD,IAAID,KAAA,KAAU,IAAI,IAAKA,KAAA,KAAUI,SAAA,IAAa,CAACF,QAAA,EAAW;IACxD,OAAOE,SAAA;EACT;EAEA,IAAIC,iBAAA,GAEA,CAAC;EAEL;EACA,IAAI,OAAOL,KAAA,KAAU,YAAY,OAAOA,KAAA,KAAU,YAAYM,KAAA,CAAMC,OAAO,CAACP,KAAA,kBAAUH,cAAA,CAAoBG,KAAA,GAAQ;IAChHK,iBAAA,CAAkBG,QAAQ,GAAGR,KAAA;EAC/B,OAAO,IAAI,OAAOA,KAAA,KAAU,UAAU;IACpCK,iBAAA,GAAoBL,KAAA;EACtB;EAEAK,iBAAA,GAAoB;IAClB,GAAGF,YAAY;IACf,GAAGE;EACL;EAEA,IAAI,OAAOA,iBAAA,CAAkBG,QAAQ,KAAK,YAAY;IACpDH,iBAAiB,CAACP,2BAAA,CAA4B,GAAGO,iBAAA,CAAkBG,QAAQ;IAC3EH,iBAAA,CAAkBG,QAAQ,GAAGL,YAAA,aAAAA,YAAA,uBAAAA,YAAA,CAAcK,QAAQ;EACrD;EAEA,OAAOH,iBAAA;AACT"}

package/lib/compose/types.js

@@ -0,0 +1,2 @@
+import * as React from 'react';
+//# sourceMappingURL=types.js.map

package/lib/compose/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React"],"sources":["../../src/compose/types.ts"],"sourcesContent":["import * as React from 'react';\n\nexport type SlotRenderFunction<Props> = (\n  Component: React.ElementType<Props>,\n  props: Omit<Props, '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":"AAAA,YAAYA,KAAA,MAAW"}

package/lib/events/index.js

@@ -0,0 +1,2 @@
+export * from './mouseTouchHelpers';
+//# sourceMappingURL=index.js.map

package/lib/events/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["../../src/events/index.ts"],"sourcesContent":["export * from './mouseTouchHelpers';\n"],"mappings":"AAAA,cAAc"}

package/lib/events/mouseTouchHelpers.js

@@ -0,0 +1,39 @@
+import * as React from 'react';
+/**
+ * Returns true if event is a touch event. Useful when sharing logic between touch and mouse interactions.
+ */
+export function isTouchEvent(event) {
+  return event.type.startsWith('touch');
+}
+/**
+ * Returns true if event is a mouse event. Useful when sharing logic between touch and mouse interactions.
+ */
+export function isMouseEvent(event) {
+  return event.type.startsWith('mouse') || ['click', 'contextmenu', 'dblclick'].indexOf(event.type) > -1;
+}
+/**
+ * Returns an object with clientX, clientY for TouchOrMouseEvent.
+ * Returns zeros in case the event is not a mouse or a touch event.
+ */
+export 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.');
+    }
+    return {
+      clientX: 0,
+      clientY: 0
+    };
+  }
+}
+//# sourceMappingURL=mouseTouchHelpers.js.map

package/lib/events/mouseTouchHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","isTouchEvent","event","type","startsWith","isMouseEvent","indexOf","getEventClientCoords","clientX","clientY","touches","process","env","NODE_ENV","Error"],"sources":["../../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":"AAAA,YAAYA,KAAA,MAAW;AAQvB;;;AAGA,OAAO,SAASC,aAAaC,KAAwB,EAA0C;EAC7F,OAAOA,KAAA,CAAMC,IAAI,CAACC,UAAU,CAAC;AAC/B;AAEA;;;AAGA,OAAO,SAASC,aAAaH,KAAwB,EAA0C;EAC7F,OAAOA,KAAA,CAAMC,IAAI,CAACC,UAAU,CAAC,YAAY,CAAC,SAAS,eAAe,WAAW,CAACE,OAAO,CAACJ,KAAA,CAAMC,IAAI,IAAI,CAAC;AACvG;AAEA;;;;AAIA,OAAO,SAASI,qBAAqBL,KAAwB,EAAwC;EACnG,IAAIG,YAAA,CAAaH,KAAA,GAAQ;IACvB,OAAO;MAAEM,OAAA,EAASN,KAAA,CAAMM,OAAO;MAAEC,OAAA,EAASP,KAAA,CAAMO;IAAQ;EAC1D,OAAO,IAAIR,YAAA,CAAaC,KAAA,GAAQ;IAC9B,OAAO;MAAEM,OAAA,EAASN,KAAA,CAAMQ,OAAO,CAAC,EAAE,CAACF,OAAO;MAAEC,OAAA,EAASP,KAAA,CAAMQ,OAAO,CAAC,EAAE,CAACD;IAAQ;EAChF,OAAO;IACL,IAAIE,OAAA,CAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;MACzC,MAAM,IAAIC,KAAA,CAAM;IAClB;IACA,OAAO;MAAEN,OAAA,EAAS;MAAGC,OAAA,EAAS;IAAE;EAClC;AACF"}

package/lib/hooks/index.js

@@ -0,0 +1,13 @@
+export * from './useControllableState';
+export * from './useEventCallback';
+export * from './useFirstMount';
+export * from './useForceUpdate';
+export * from './useId';
+export * from './useIsomorphicLayoutEffect';
+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

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["../../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":"AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc"}

package/lib/hooks/useControllableState.js

@@ -0,0 +1,49 @@
+import * as React from 'react';
+/**
+ * @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
+ */
+export const useControllableState = options => {
+  const initialState = typeof options.defaultState === 'undefined' ? options.initialState : options.defaultState;
+  const [internalState, setInternalState] = React.useState(initialState);
+  return useIsControlled(options.state) ? [options.state, noop] : [internalState, setInternalState];
+};
+function noop() {
+  /* noop */}
+/**
+ * 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;
+};
+//# sourceMappingURL=useControllableState.js.map

package/lib/hooks/useControllableState.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","useControllableState","options","initialState","defaultState","internalState","setInternalState","useState","useIsControlled","state","noop","controlledValue","isControlled","undefined","process","env","NODE_ENV","useEffect","error","Error","controlWarning","undefinedWarning","console","stack","join"],"sources":["../../src/hooks/useControllableState.ts"],"sourcesContent":["import * as React from 'react';\n\n/**\n * @internal\n */\nexport type UseControllableStateOptions<State> = {\n  /**\n   * User-provided default state or initializer, for uncontrolled usage.\n   */\n  defaultState?: State | (() => State);\n  /**\n   * User-provided controlled state. `undefined` means internal state will be used.\n   */\n  state: State | undefined;\n  /**\n   * Used as the initial state if `state` and `defaultState` are both `undefined`.\n   * If `undefined` is the correct initial state, pass that here.\n   */\n  initialState: State;\n};\n\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 initialState = typeof options.defaultState === 'undefined' ? options.initialState : options.defaultState;\n  const [internalState, setInternalState] = React.useState<State>(initialState);\n  return useIsControlled(options.state) ? [options.state, noop] : [internalState, setInternalState];\n};\n\nfunction noop() {\n  /* noop */\n}\n\n/**\n * Helper hook to handle previous comparison of controlled/uncontrolled\n * Prints an error when isControlled value switches between subsequent renders\n * @returns - whether the value is controlled\n */\nconst useIsControlled = <V>(controlledValue?: V): controlledValue is V => {\n  const [isControlled] = React.useState<boolean>(() => controlledValue !== undefined);\n\n  if (process.env.NODE_ENV !== 'production') {\n    // We don't want these warnings in production even though it is against native behaviour\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useEffect(() => {\n      if (isControlled !== (controlledValue !== undefined)) {\n        const error = new Error();\n\n        const controlWarning = isControlled\n          ? 'a controlled value to be uncontrolled'\n          : 'an uncontrolled value to be controlled';\n\n        const undefinedWarning = isControlled ? 'defined to an undefined' : 'undefined to a defined';\n\n        // eslint-disable-next-line no-console\n        console.error(\n          [\n            // Default react error\n            'A component is changing ' + controlWarning + '. This is likely caused by the value',\n            'changing from ' + undefinedWarning + ' value, which should not happen.',\n            'Decide between using a controlled or uncontrolled input element for the lifetime of the component.',\n            'More info: https://reactjs.org/link/controlled-components',\n            error.stack,\n          ].join(' '),\n        );\n      }\n    }, [isControlled, controlledValue]);\n  }\n\n  return isControlled;\n};\n"],"mappings":"AAAA,YAAYA,KAAA,MAAW;AAqBvB;;;;;;;;;;;;;;;;AAgBA,OAAO,MAAMC,oBAAA,GACXC,OAAA,IACyD;EACzD,MAAMC,YAAA,GAAe,OAAOD,OAAA,CAAQE,YAAY,KAAK,cAAcF,OAAA,CAAQC,YAAY,GAAGD,OAAA,CAAQE,YAAY;EAC9G,MAAM,CAACC,aAAA,EAAeC,gBAAA,CAAiB,GAAGN,KAAA,CAAMO,QAAQ,CAAQJ,YAAA;EAChE,OAAOK,eAAA,CAAgBN,OAAA,CAAQO,KAAK,IAAI,CAACP,OAAA,CAAQO,KAAK,EAAEC,IAAA,CAAK,GAAG,CAACL,aAAA,EAAeC,gBAAA,CAAiB;AACnG;AAEA,SAASI,KAAA,EAAO;EACd;AAGF;;;;;AAKA,MAAMF,eAAA,GAAsBG,eAAA,IAA8C;EACxE,MAAM,CAACC,YAAA,CAAa,GAAGZ,KAAA,CAAMO,QAAQ,CAAU,MAAMI,eAAA,KAAoBE,SAAA;EAEzE,IAAIC,OAAA,CAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;IACzC;IACA;IACAhB,KAAA,CAAMiB,SAAS,CAAC,MAAM;MACpB,IAAIL,YAAA,MAAkBD,eAAA,KAAoBE,SAAQ,GAAI;QACpD,MAAMK,KAAA,GAAQ,IAAIC,KAAA;QAElB,MAAMC,cAAA,GAAiBR,YAAA,GACnB,0CACA,wCAAwC;QAE5C,MAAMS,gBAAA,GAAmBT,YAAA,GAAe,4BAA4B,wBAAwB;QAE5F;QACAU,OAAA,CAAQJ,KAAK,CACX;QACE;QACA,6BAA6BE,cAAA,GAAiB,wCAC9C,mBAAmBC,gBAAA,GAAmB,oCACtC,sGACA,6DACAH,KAAA,CAAMK,KAAK,CACZ,CAACC,IAAI,CAAC;MAEX;IACF,GAAG,CAACZ,YAAA,EAAcD,eAAA,CAAgB;EACpC;EAEA,OAAOC,YAAA;AACT"}

package/lib/hooks/useEventCallback.js

@@ -0,0 +1,28 @@
+import * as React from 'react';
+import { useIsomorphicLayoutEffect } from './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
+ */
+export const useEventCallback = fn => {
+  const callbackRef = React.useRef(() => {
+    throw new Error('Cannot call an event handler while rendering');
+  });
+  useIsomorphicLayoutEffect(() => {
+    callbackRef.current = fn;
+  }, [fn]);
+  return React.useCallback((...args) => {
+    const callback = callbackRef.current;
+    return callback(...args);
+  }, [callbackRef]);
+};
+//# sourceMappingURL=useEventCallback.js.map

package/lib/hooks/useEventCallback.js.map

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

package/lib/hooks/useFirstMount.js

@@ -0,0 +1,21 @@
+import * as React from '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();
+ */
+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

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

package/lib/hooks/useForceUpdate.js

@@ -0,0 +1,9 @@
+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];
+}
+//# sourceMappingURL=useForceUpdate.js.map

package/lib/hooks/useForceUpdate.js.map

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

package/lib/hooks/useId.js

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

package/lib/hooks/useId.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","defaultSSRContextValue","useSSRContext","IdPrefixContext","createContext","undefined","IdPrefixProvider","Provider","useIdPrefix","useContext","resetIdsForTests","current","useId","prefix","providedId","contextValue","idPrefix","_useId","generatedId","escapedId","useMemo","replace"],"sources":["../../src/hooks/useId.ts"],"sourcesContent":["import * as React from 'react';\nimport { defaultSSRContextValue, useSSRContext } from '../ssr/index';\n\nconst IdPrefixContext = React.createContext<string | undefined>(undefined);\n\n/**\n * Allows to define a prefix that will be used for all IDs generated by useId() hook. It's useful to avoid collisions\n * between different bundles.\n */\nexport const IdPrefixProvider = IdPrefixContext.Provider;\n\nfunction useIdPrefix(): string {\n  return React.useContext(IdPrefixContext) || '';\n}\n\n/**\n * Resets generated IDs, should be used only in tests.\n */\nexport function resetIdsForTests(): void {\n  defaultSSRContextValue.current = 0;\n}\n\n/**\n * Hook to generate a unique ID.\n *\n * @param prefix - Optional prefix for the ID. Defaults to 'fui-'.\n * @param providedId - Optional id provided by a parent component. Defaults to the provided value if present,\n *  without conditioning the hook call\n * @returns The ID\n */\nexport function useId(prefix: string = 'fui-', providedId?: string): string {\n  const contextValue = useSSRContext();\n  const idPrefix = useIdPrefix();\n\n  // Checking if useId is available on React, if it is, we use it to generate the id. String concatenation is used to\n  // prevent bundlers from complaining with older versions of React.\n  const _useId = (React as never)['use' + 'Id'] as (() => string) | undefined;\n\n  if (_useId) {\n    const generatedId = _useId();\n\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    const escapedId = React.useMemo(() => generatedId.replace(/:/g, ''), [generatedId]);\n\n    return providedId || `${idPrefix}${prefix}${escapedId}`;\n  }\n\n  // Hooks appear to be running conditionally, but they will always run in the same order since it's based on\n  // the version of React being used. This is safe to ignore.\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  return React.useMemo(() => {\n    if (providedId) {\n      return providedId;\n    }\n\n    return `${idPrefix}${prefix}${++contextValue.current}`;\n  }, [idPrefix, prefix, providedId, contextValue]);\n}\n"],"mappings":"AAAA,YAAYA,KAAA,MAAW;AACvB,SAASC,sBAAsB,EAAEC,aAAa,QAAQ;AAEtD,MAAMC,eAAA,gBAAkBH,KAAA,CAAMI,aAAa,CAAqBC,SAAA;AAEhE;;;;AAIA,OAAO,MAAMC,gBAAA,GAAmBH,eAAA,CAAgBI,QAAQ;AAExD,SAASC,YAAA,EAAsB;EAC7B,OAAOR,KAAA,CAAMS,UAAU,CAACN,eAAA,KAAoB;AAC9C;AAEA;;;AAGA,OAAO,SAASO,iBAAA,EAAyB;EACvCT,sBAAA,CAAuBU,OAAO,GAAG;AACnC;AAEA;;;;;;;;AAQA,OAAO,SAASC,MAAMC,MAAA,GAAiB,MAAM,EAAEC,UAAmB,EAAU;EAC1E,MAAMC,YAAA,GAAeb,aAAA;EACrB,MAAMc,QAAA,GAAWR,WAAA;EAEjB;EACA;EACA,MAAMS,MAAA,GAASjB,KAAgB,CAAC,QAAQ,KAAK;EAE7C,IAAIiB,MAAA,EAAQ;IACV,MAAMC,WAAA,GAAcD,MAAA;IAEpB;IACA,MAAME,SAAA,GAAYnB,KAAA,CAAMoB,OAAO,CAAC,MAAMF,WAAA,CAAYG,OAAO,CAAC,MAAM,KAAK,CAACH,WAAA,CAAY;IAElF,OAAOJ,UAAA,IAAe,GAAEE,QAAS,GAAEH,MAAO,GAAEM,SAAU,EAAC;EACzD;EAEA;EACA;EACA;EACA,OAAOnB,KAAA,CAAMoB,OAAO,CAAC,MAAM;IACzB,IAAIN,UAAA,EAAY;MACd,OAAOA,UAAA;IACT;IAEA,OAAQ,GAAEE,QAAS,GAAEH,MAAO,GAAE,EAAEE,YAAA,CAAaJ,OAAQ,EAAC;EACxD,GAAG,CAACK,QAAA,EAAUH,MAAA,EAAQC,UAAA,EAAYC,YAAA,CAAa;AACjD"}

package/lib/hooks/useIsomorphicLayoutEffect.js

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { canUseDOM } from '../ssr/index';
+/**
+ * React currently throws a warning when using useLayoutEffect on the server. To get around it, we can conditionally
+ * useEffect on the server (no-op) and useLayoutEffect in the browser. We occasionally need useLayoutEffect to
+ * ensure we don't get a render flash for certain operations, but we may also need affected components to render on
+ * the server.
+ *
+ * https://gist.github.com/gaearon/e7d97cdf38a2907924ea12e4ebdf3c85
+ * https://github.com/reduxjs/react-redux/blob/master/src/utils/useIsomorphicLayoutEffect.js
+ */ // eslint-disable-next-line no-restricted-properties
+export const useIsomorphicLayoutEffect = /*#__PURE__*/canUseDOM() ? React.useLayoutEffect : React.useEffect;
+//# sourceMappingURL=useIsomorphicLayoutEffect.js.map

package/lib/hooks/useIsomorphicLayoutEffect.js.map

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

package/lib/hooks/useMergedRefs.js

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

package/lib/hooks/useMergedRefs.js.map

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