@fluentui/react-utilities 0.0.0-nightly050f89bf0020211102.1

package/lib/compose/getSlots.d.ts

@@ -0,0 +1,29 @@
+import * as React from 'react';
+import { AsIntrinsicElement, ComponentState, ObjectShorthandPropsRecord, ObjectShorthandProps, UnionToIntersection } from './types';
+export declare type Slots<S extends ObjectShorthandPropsRecord> = {
+    [K in keyof S]-?: NonNullable<S[K]> extends AsIntrinsicElement<infer As> ? As : S[K] extends ObjectShorthandProps<infer P> ? React.ElementType<NonNullable<P>> : React.ElementType<NonNullable<S[K]>>;
+};
+declare type SlotProps<S extends ObjectShorthandPropsRecord> = {
+    [K in keyof S]-?: NonNullable<S[K]> extends AsIntrinsicElement<infer As> ? UnionToIntersection<JSX.IntrinsicElements[As]> : NonNullable<S[K]> extends ObjectShorthandProps<infer P> ? P : never;
+};
+/**
+ * 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 the the slot type. For example, if the
+ * slot is rendered `as: 'a'`, the props will be filtered for acceptable anchor props.
+ *
+ * @param state - State including slot definitions
+ * @param slotNames - Name of which props are slots
+ * @returns An object containing the `slots` map and `slotProps` map.
+ */
+export declare function getSlots<R extends ObjectShorthandPropsRecord>(state: ComponentState<R>, slotNames?: (keyof R)[]): {
+    slots: Slots<R>;
+    slotProps: SlotProps<R>;
+};
+export {};

package/lib/compose/getSlots.js

@@ -0,0 +1,72 @@
+import { __rest } from "tslib";
+import * as React from 'react';
+import { nullRender } from './nullRender';
+import { omit } from '../utils/omit';
+/**
+ * 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 the the slot type. For example, if the
+ * slot is rendered `as: 'a'`, the props will be filtered for acceptable anchor props.
+ *
+ * @param state - State including slot definitions
+ * @param slotNames - Name of which props are slots
+ * @returns An object containing the `slots` map and `slotProps` map.
+ */
+
+export function getSlots(state, slotNames) {
+  if (slotNames === void 0) {
+    slotNames = ['root'];
+  }
+
+  var slots = {};
+  var slotProps = {};
+
+  for (var _i = 0, slotNames_1 = slotNames; _i < slotNames_1.length; _i++) {
+    var slotName = slotNames_1[_i];
+
+    var _a = getSlot(state, slotName),
+        slot = _a[0],
+        props = _a[1];
+
+    slots[slotName] = slot;
+    slotProps[slotName] = props;
+  }
+
+  return {
+    slots: slots,
+    slotProps: slotProps
+  };
+}
+
+function getSlot(state, slotName) {
+  var _a, _b, _c;
+
+  if (state[slotName] === undefined) {
+    return [nullRender, undefined];
+  }
+
+  var _d = state[slotName],
+      children = _d.children,
+      asProp = _d.as,
+      rest = __rest(_d, ["children", "as"]);
+
+  var slot = ((_a = state.components) === null || _a === void 0 ? void 0 : _a[slotName]) === undefined || typeof state.components[slotName] === 'string' ? asProp || ((_b = state.components) === null || _b === void 0 ? void 0 : _b[slotName]) || 'div' : state.components[slotName];
+
+  if (typeof children === 'function') {
+    var render = children;
+    return [React.Fragment, {
+      children: render(slot, rest)
+    }];
+  }
+
+  var shouldOmitAsProp = typeof slot === 'string' && ((_c = state[slotName]) === null || _c === void 0 ? void 0 : _c.as);
+  var slotProps = shouldOmitAsProp ? omit(state[slotName], ['as']) : state[slotName];
+  return [slot, slotProps];
+}
+//# sourceMappingURL=getSlots.js.map

package/lib/compose/getSlots.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/compose/getSlots.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,KAAZ,MAAuB,OAAvB;AAUA,SAAS,UAAT,QAA2B,cAA3B;AACA,SAAS,IAAT,QAAqB,eAArB;AAqBA;;;;;;;;;;;;;;;AAeG;;AACH,OAAM,SAAU,QAAV,CACJ,KADI,EAEJ,SAFI,EAE6B;AAAjC,MAAA,SAAA,KAAA,KAAA,CAAA,EAAA;AAAA,IAAA,SAAA,GAAA,CAA0B,MAA1B,CAAA;AAAiC;;AAKjC,MAAM,KAAK,GAAG,EAAd;AACA,MAAM,SAAS,GAAG,EAAlB;;AAEA,OAAuB,IAAA,EAAA,GAAA,CAAA,EAAA,WAAA,GAAA,SAAvB,EAAuB,EAAA,GAAA,WAAA,CAAA,MAAvB,EAAuB,EAAA,EAAvB,EAAkC;AAA7B,QAAM,QAAQ,GAAA,WAAA,CAAA,EAAA,CAAd;;AACG,QAAA,EAAA,GAAgB,OAAO,CAAC,KAAD,EAAQ,QAAR,CAAvB;AAAA,QAAC,IAAI,GAAA,EAAA,CAAA,CAAA,CAAL;AAAA,QAAO,KAAK,GAAA,EAAA,CAAA,CAAA,CAAZ;;AACN,IAAA,KAAK,CAAC,QAAD,CAAL,GAAkB,IAAlB;AACA,IAAA,SAAS,CAAC,QAAD,CAAT,GAAsB,KAAtB;AACD;;AACD,SAAO;AAAE,IAAA,KAAK,EAAA,KAAP;AAAS,IAAA,SAAS,EAAG;AAArB,GAAP;AACD;;AAED,SAAS,OAAT,CACE,KADF,EAEE,QAFF,EAEa;;;AAEX,MAAI,KAAK,CAAC,QAAD,CAAL,KAAoB,SAAxB,EAAmC;AACjC,WAAO,CAAC,UAAD,EAAa,SAAb,CAAP;AACD;;AACD,MAAM,EAAA,GAAoC,KAAK,CAAC,QAAD,CAA/C;AAAA,MAAQ,QAAQ,GAAA,EAAA,CAAA,QAAhB;AAAA,MAAsB,MAAM,GAAA,EAAA,CAAA,EAA5B;AAAA,MAAiC,IAAI,GAAA,MAAA,CAAA,EAAA,EAA/B,CAAA,UAAA,EAAA,IAAA,CAA+B,CAArC;;AAEA,MAAM,IAAI,GAAI,CAAA,CAAA,EAAA,GAAA,KAAK,CAAC,UAAN,MAAgB,IAAhB,IAAgB,EAAA,KAAA,KAAA,CAAhB,GAAgB,KAAA,CAAhB,GAAgB,EAAA,CAAG,QAAH,CAAhB,MAAiC,SAAjC,IAA8C,OAAO,KAAK,CAAC,UAAN,CAAiB,QAAjB,CAAP,KAAsC,QAApF,GACV,MAAM,KAAA,CAAA,EAAA,GAAI,KAAK,CAAC,UAAV,MAAoB,IAApB,IAAoB,EAAA,KAAA,KAAA,CAApB,GAAoB,KAAA,CAApB,GAAoB,EAAA,CAAG,QAAH,CAApB,CAAN,IAA0C,KADhC,GAEV,KAAK,CAAC,UAAN,CAAiB,QAAjB,CAFJ;;AAIA,MAAI,OAAO,QAAP,KAAoB,UAAxB,EAAoC;AAClC,QAAM,MAAM,GAAG,QAAf;AACA,WAAO,CACL,KAAK,CAAC,QADD,EAEJ;AACC,MAAA,QAAQ,EAAE,MAAM,CAAC,IAAD,EAAO,IAAP;AADjB,KAFI,CAAP;AAMD;;AAED,MAAM,gBAAgB,GAAG,OAAO,IAAP,KAAgB,QAAhB,KAAwB,CAAA,EAAA,GAAI,KAAK,CAAC,QAAD,CAAT,MAAmB,IAAnB,IAAmB,EAAA,KAAA,KAAA,CAAnB,GAAmB,KAAA,CAAnB,GAAmB,EAAA,CAAE,EAA7C,CAAzB;AACA,MAAM,SAAS,GAAI,gBAAgB,GAAG,IAAI,CAAC,KAAK,CAAC,QAAD,CAAN,EAAmB,CAAC,IAAD,CAAnB,CAAP,GAAoC,KAAK,CAAC,QAAD,CAA5E;AAEA,SAAO,CAAC,IAAD,EAAO,SAAP,CAAP;AACD","sourceRoot":""}

package/lib/compose/index.d.ts

@@ -0,0 +1,4 @@
+export * from './getSlots';
+export * from './nullRender';
+export * from './resolveShorthand';
+export * from './types';

package/lib/compose/index.js

@@ -0,0 +1,5 @@
+export * from './getSlots';
+export * from './nullRender';
+export * from './resolveShorthand';
+export * from './types';
+//# sourceMappingURL=index.js.map

package/lib/compose/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/compose/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,SAAS,CAAC"}

package/lib/compose/nullRender.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Simple constant function for returning null, used to render empty templates in JSX.
+ */
+export declare const nullRender: () => null;

package/lib/compose/nullRender.js

@@ -0,0 +1,7 @@
+/**
+ * Simple constant function for returning null, used to render empty templates in JSX.
+ */
+export var nullRender = function () {
+  return null;
+};
+//# sourceMappingURL=nullRender.js.map

package/lib/compose/nullRender.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/compose/nullRender.tsx"],"names":[],"mappings":"AAAA;;AAEG;AACH,OAAO,IAAM,UAAU,GAAG,YAAA;AAAM,SAAA,IAAA;AAAI,CAA7B","sourceRoot":""}

package/lib/compose/resolveShorthand.d.ts

@@ -0,0 +1,12 @@
+import type { DefaultObjectShorthandProps, ShorthandProps } from './types';
+export declare type ResolveShorthandOptions<Props extends Record<string, any>, Required extends boolean = false> = {
+    required?: Required;
+    defaultProps?: Props;
+};
+/**
+ * Resolves ShorthandProps into ObjectShorthandProps, to ensure normalization of the signature
+ * being passed down to getSlots method
+ * @param value - the base ShorthandProps
+ * @param options - options to resolve ShorthandProps
+ */
+export declare function resolveShorthand<Props extends DefaultObjectShorthandProps, Required extends boolean = false>(value: ShorthandProps<Props>, options?: ResolveShorthandOptions<Props, Required>): Required extends false ? Props | undefined : Props;

package/lib/compose/resolveShorthand.js

@@ -0,0 +1,30 @@
+import { __assign } from "tslib";
+import { isValidElement } from 'react';
+/**
+ * Resolves ShorthandProps into ObjectShorthandProps, to ensure normalization of the signature
+ * being passed down to getSlots method
+ * @param value - the base ShorthandProps
+ * @param options - options to resolve ShorthandProps
+ */
+
+export function resolveShorthand(value, options) {
+  var _a = options || {},
+      _b = _a.required,
+      required = _b === void 0 ? false : _b,
+      defaultProps = _a.defaultProps;
+
+  if (value === null || value === undefined && !required) {
+    return undefined;
+  }
+
+  var resolvedShorthand = {};
+
+  if (typeof value === 'string' || typeof value === 'number' || Array.isArray(value) || /*#__PURE__*/isValidElement(value)) {
+    resolvedShorthand.children = value;
+  } else if (typeof value === 'object') {
+    resolvedShorthand = value;
+  }
+
+  return defaultProps ? __assign(__assign({}, defaultProps), resolvedShorthand) : resolvedShorthand;
+}
+//# sourceMappingURL=resolveShorthand.js.map

package/lib/compose/resolveShorthand.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/compose/resolveShorthand.ts"],"names":[],"mappings":";AAAA,SAAS,cAAT,QAA+B,OAA/B;AASA;;;;;AAKG;;AACH,OAAM,SAAU,gBAAV,CACJ,KADI,EAEJ,OAFI,EAE8C;AAE5C,MAAA,EAAA,GAAqC,OAAO,IAAI,EAAhD;AAAA,MAAE,EAAA,GAAA,EAAA,CAAA,QAAF;AAAA,MAAE,QAAQ,GAAA,EAAA,KAAA,KAAA,CAAA,GAAG,KAAH,GAAQ,EAAlB;AAAA,MAAoB,YAAY,GAAA,EAAA,CAAA,YAAhC;;AACN,MAAI,KAAK,KAAK,IAAV,IAAmB,KAAK,KAAK,SAAV,IAAuB,CAAC,QAA/C,EAA0D;AACxD,WAAO,SAAP;AACD;;AAED,MAAI,iBAAiB,GAAG,EAAxB;;AAEA,MAAI,OAAO,KAAP,KAAiB,QAAjB,IAA6B,OAAO,KAAP,KAAiB,QAA9C,IAA0D,KAAK,CAAC,OAAN,CAAc,KAAd,CAA1D,iBAAkF,cAAc,CAAC,KAAD,CAApG,EAA6G;AAC3G,IAAA,iBAAiB,CAAC,QAAlB,GAA6B,KAA7B;AACD,GAFD,MAEO,IAAI,OAAO,KAAP,KAAiB,QAArB,EAA+B;AACpC,IAAA,iBAAiB,GAAG,KAApB;AACD;;AAED,SAAQ,YAAY,GAAE,QAAA,CAAA,QAAA,CAAA,EAAA,EAAM,YAAN,CAAA,EAAuB,iBAAvB,CAAF,GAA+C,iBAAnE;AAGD","sourceRoot":""}

package/lib/compose/types.d.ts

@@ -0,0 +1,104 @@
+import * as React from 'react';
+export declare type ShorthandRenderFunction<Props> = (Component: React.ElementType<Props>, props: Omit<Props, 'children' | 'as'>) => React.ReactNode;
+export declare type ObjectShorthandPropsRecord = Record<string, DefaultObjectShorthandProps | undefined>;
+export declare type ShorthandProps<Props extends DefaultObjectShorthandProps> = React.ReactChild | React.ReactNodeArray | React.ReactPortal | number | null | undefined | Props;
+/**
+ * Matches any shorthand props type.
+ *
+ * This should ONLY be used in type templates as in `extends DefaultObjectShorthandProps`;
+ * it shouldn't be used as the type of a slot.
+ */
+export declare type DefaultObjectShorthandProps = ObjectShorthandProps<{
+    children?: React.ReactNode;
+    as?: keyof JSX.IntrinsicElements;
+}>;
+/**
+ * Defines the slot props for a slot that supports a Component type.
+ *
+ * For intrinsic elements like 'div', use {@link IntrinsicShorthandProps} instead.
+ */
+export declare type ObjectShorthandProps<Props extends {
+    children?: React.ReactNode;
+} = {}> = Props & {
+    children?: Props['children'] | ShorthandRenderFunction<Props>;
+};
+/**
+ * Define the slot arguments for a slot that supports one or more intrinsic element types, such as 'div'.
+ * For slots that support custom components, use {@link ObjectShorthandProps} instead.
+ *
+ * The first param is the slot's default type if no `as` prop is specified.
+ * The second param is an optional union of alternative types that can be specified for the `as` prop.
+ *
+ * ```
+ * IntrinsicShorthandProps<'div'> // Slot is always div
+ * IntrinsicShorthandProps<'button', 'a'> // Defaults to button, but allows as="a" with anchor-specific props
+ * IntrinsicShorthandProps<'label', 'span' | 'div'>; // Defaults to label, but allows as="span" or as="div"
+ * ```
+ */
+export declare type IntrinsicShorthandProps<DefaultAs extends keyof JSX.IntrinsicElements, AlternateAs extends keyof JSX.IntrinsicElements = never> = IsSingleton<DefaultAs> extends false ? 'Error: first parameter to IntrinsicShorthandProps must be a single element type, not a union of types' : ({
+    as?: DefaultAs;
+} & ObjectShorthandProps<React.PropsWithRef<JSX.IntrinsicElements[DefaultAs]>>) | {
+    [As in AlternateAs]: {
+        as: As;
+    } & ObjectShorthandProps<React.PropsWithRef<JSX.IntrinsicElements[As]>>;
+}[AlternateAs];
+/**
+ * Evaluates to true if the given type contains exactly one string, or false if it is a union of strings.
+ *
+ * ```
+ * IsSingleton<'a'> // true
+ * IsSingleton<'a' | 'b' | 'c'> // false
+ * ```
+ */
+export declare type IsSingleton<T extends string> = {
+    [K in T]: Exclude<T, K> extends never ? true : false;
+}[T];
+/**
+ * Helper type for inferring the type of the as prop from a Props type.
+ *
+ * For example:
+ * ```
+ * type Example<T> = T extends AsIntrinsicElement<infer As> ? As : never;
+ * ```
+ */
+export declare type AsIntrinsicElement<As extends keyof JSX.IntrinsicElements> = {
+    as?: As;
+};
+/**
+ * Converts a union type (`A | B | C`) to an intersection type (`A & B & C`)
+ */
+export declare type UnionToIntersection<U> = (U extends unknown ? (x: U) => U : never) extends (x: infer I) => U ? I : never;
+/**
+ * Removes the 'ref' prop from the given Props type, leaving unions intact (such as the discriminated union created by
+ * IntrinsicShorthandProps). This allows IntrinsicShorthandProps to be used with React.forwardRef.
+ *
+ * The conditional "extends unknown" (always true) exploits a quirk in the way TypeScript handles conditional
+ * types, to prevent unions from being expanded.
+ */
+export declare type PropsWithoutRef<P> = 'ref' extends keyof P ? (P extends unknown ? Omit<P, 'ref'> : P) : P;
+export declare type ComponentProps<Shorthands extends ObjectShorthandPropsRecord, Primary extends keyof Shorthands = 'root'> = Omit<{
+    [Key in keyof Shorthands]?: ShorthandProps<NonNullable<Shorthands[Key]>>;
+}, Primary> & PropsWithoutRef<Shorthands[Primary]>;
+export declare type ComponentState<Shorthands extends ObjectShorthandPropsRecord> = {
+    components?: {
+        [Key in keyof Shorthands]-?: React.ComponentType<NonNullable<Shorthands[Key]> extends ObjectShorthandProps<infer P> ? P : NonNullable<Shorthands[Key]>> | (NonNullable<Shorthands[Key]> extends AsIntrinsicElement<infer As> ? As : keyof JSX.IntrinsicElements);
+    };
+} & Shorthands;
+/**
+ * This is part of a hack to infer the element type from a native element *props* type.
+ * The only place the original element is found in a native props type (at least that's workable
+ * for inference) is in the event handlers, so some of the helper types use this event handler
+ * name to infer the original element type.
+ *
+ * Notes:
+ * - Using an extremely obscure event handler reduces the likelihood that its signature will be
+ *   modified in any component's props.
+ * - Inferring based on a single prop name instead of a larger type like `DOMAttributes<T>` should be
+ *   less expensive for typescript to evaluate and is less likely to result in type expansion in .d.ts.
+ */
+declare type ObscureEventName = 'onLostPointerCaptureCapture';
+/**
+ * Return type for `React.forwardRef`, including inference of the proper typing for the ref.
+ */
+export declare type ForwardRefComponent<Props> = ObscureEventName extends keyof Props ? Required<Props>[ObscureEventName] extends React.PointerEventHandler<infer Element> ? React.ForwardRefExoticComponent<Props & React.RefAttributes<Element>> : never : never;
+export {};

package/lib/compose/types.js

@@ -0,0 +1,6 @@
+export {}; // A definition like this would also work, but typescript is more likely to unnecessarily expand
+// the props type with this version (and it's likely much more expensive to evaluate)
+// export type ForwardRefComponent<Props> = Props extends React.DOMAttributes<infer Element>
+//   ? React.ForwardRefExoticComponent<Props> & React.RefAttributes<Element>
+//   : never;
+//# sourceMappingURL=types.js.map

package/lib/compose/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/compose/types.ts"],"names":[],"mappings":"WA2IA;AACA;AACA;AACA;AACA","sourceRoot":""}

package/lib/hooks/index.d.ts

@@ -0,0 +1,16 @@
+export * from './useControllableState';
+export * from './useBoolean';
+export * from './useConst';
+export * from './useControllableValue';
+export * from './useEventCallback';
+export * from './useFirstMount';
+export * from './useId';
+export * from './useIsomorphicLayoutEffect';
+export * from './useMergedRefs';
+export * from './useMount';
+export * from './useOnClickOutside';
+export * from './useOnScrollOutside';
+export * from './usePrevious';
+export * from './useTimeout';
+export * from './useUnmount';
+export * from './useForceUpdate';

package/lib/hooks/index.js

@@ -0,0 +1,17 @@
+export * from './useControllableState';
+export * from './useBoolean';
+export * from './useConst';
+export * from './useControllableValue';
+export * from './useEventCallback';
+export * from './useFirstMount';
+export * from './useId';
+export * from './useIsomorphicLayoutEffect';
+export * from './useMergedRefs';
+export * from './useMount';
+export * from './useOnClickOutside';
+export * from './useOnScrollOutside';
+export * from './usePrevious';
+export * from './useTimeout';
+export * from './useUnmount';
+export * from './useForceUpdate';
+//# sourceMappingURL=index.js.map

package/lib/hooks/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC;AACxB,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC"}

package/lib/hooks/useBoolean.d.ts

@@ -0,0 +1,17 @@
+/** Updater callbacks returned by `useBoolean`. */
+export declare type UseBooleanCallbacks = {
+    /** Set the value to true. Always has the same identity. */
+    setTrue: () => void;
+    /** Set the value to false. Always has the same identity. */
+    setFalse: () => void;
+    /** Toggle the value. Always has the same identity. */
+    toggle: () => void;
+};
+/**
+ * Hook to store a value and generate callbacks for setting the value to true or false.
+ * The identity of the callbacks will always stay the same.
+ *
+ * @param initialState - Initial value
+ * @returns Array with the current value and an object containing the updater callbacks.
+ */
+export declare function useBoolean(initialState: boolean): [boolean, UseBooleanCallbacks];

package/lib/hooks/useBoolean.js

@@ -0,0 +1,39 @@
+import * as React from 'react';
+import { useConst } from './useConst';
+/**
+ * Hook to store a value and generate callbacks for setting the value to true or false.
+ * The identity of the callbacks will always stay the same.
+ *
+ * @param initialState - Initial value
+ * @returns Array with the current value and an object containing the updater callbacks.
+ */
+
+export function useBoolean(initialState) {
+  var _a = React.useState(initialState),
+      value = _a[0],
+      setValue = _a[1];
+
+  var setTrue = useConst(function () {
+    return function () {
+      setValue(true);
+    };
+  });
+  var setFalse = useConst(function () {
+    return function () {
+      setValue(false);
+    };
+  });
+  var toggle = useConst(function () {
+    return function () {
+      setValue(function (currentValue) {
+        return !currentValue;
+      });
+    };
+  });
+  return [value, {
+    setTrue: setTrue,
+    setFalse: setFalse,
+    toggle: toggle
+  }];
+}
+//# sourceMappingURL=useBoolean.js.map

package/lib/hooks/useBoolean.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/useBoolean.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAZ,MAAuB,OAAvB;AACA,SAAS,QAAT,QAAyB,YAAzB;AAYA;;;;;;AAMG;;AACH,OAAM,SAAU,UAAV,CAAqB,YAArB,EAA0C;AACxC,MAAA,EAAA,GAAoB,KAAK,CAAC,QAAN,CAAe,YAAf,CAApB;AAAA,MAAC,KAAK,GAAA,EAAA,CAAA,CAAA,CAAN;AAAA,MAAQ,QAAQ,GAAA,EAAA,CAAA,CAAA,CAAhB;;AAEN,MAAM,OAAO,GAAG,QAAQ,CAAC,YAAA;AAAM,WAAA,YAAA;AAC7B,MAAA,QAAQ,CAAC,IAAD,CAAR;AAD6B,KAAA;AAE9B,GAFuB,CAAxB;AAGA,MAAM,QAAQ,GAAG,QAAQ,CAAC,YAAA;AAAM,WAAA,YAAA;AAC9B,MAAA,QAAQ,CAAC,KAAD,CAAR;AAD8B,KAAA;AAE/B,GAFwB,CAAzB;AAGA,MAAM,MAAM,GAAG,QAAQ,CAAC,YAAA;AAAM,WAAA,YAAA;AAC5B,MAAA,QAAQ,CAAC,UAAA,YAAA,EAAY;AAAI,eAAA,CAAA,YAAA;AAAa,OAA9B,CAAR;AAD4B,KAAA;AAE7B,GAFsB,CAAvB;AAIA,SAAO,CAAC,KAAD,EAAQ;AAAE,IAAA,OAAO,EAAA,OAAT;AAAW,IAAA,QAAQ,EAAA,QAAnB;AAAqB,IAAA,MAAM,EAAA;AAA3B,GAAR,CAAP;AACD","sourceRoot":""}

package/lib/hooks/useConst.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Hook to initialize and return a constant value. Unlike `React.useMemo`, this is guaranteed to
+ * always return the same value (and if the initializer is a function, only call it once).
+ * This is similar to setting a private member in a class constructor.
+ *
+ * If the value should ever change based on dependencies, use `React.useMemo` instead.
+ *
+ * @param initialValue - Initial value, or function to get the initial value. Similar to `useState`,
+ * only the value/function passed in the first time this is called is respected.
+ * @returns The value. The identity of this value will always be the same.
+ */
+export declare function useConst<T>(initialValue: T | (() => T)): T;

package/lib/hooks/useConst.js

@@ -0,0 +1,30 @@
+import * as React from 'react';
+/**
+ * Hook to initialize and return a constant value. Unlike `React.useMemo`, this is guaranteed to
+ * always return the same value (and if the initializer is a function, only call it once).
+ * This is similar to setting a private member in a class constructor.
+ *
+ * If the value should ever change based on dependencies, use `React.useMemo` instead.
+ *
+ * @param initialValue - Initial value, or function to get the initial value. Similar to `useState`,
+ * only the value/function passed in the first time this is called is respected.
+ * @returns The value. The identity of this value will always be the same.
+ */
+
+export function useConst(initialValue) {
+  // Use useRef to store the value because it's the least expensive built-in hook that works here
+  // (we could also use `const [value] = React.useState(initialValue)` but that's more expensive
+  // internally due to reducer handling which we don't need)
+  var ref = React.useRef();
+
+  if (ref.current === undefined) {
+    // Box the value in an object so we can tell if it's initialized even if the initializer
+    // returns/is undefined
+    ref.current = {
+      value: typeof initialValue === 'function' ? initialValue() : initialValue
+    };
+  }
+
+  return ref.current.value;
+}
+//# sourceMappingURL=useConst.js.map

package/lib/hooks/useConst.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/useConst.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAZ,MAAuB,OAAvB;AAEA;;;;;;;;;;AAUG;;AACH,OAAM,SAAU,QAAV,CAAsB,YAAtB,EAAiD;AACrD;AACA;AACA;AACA,MAAM,GAAG,GAAG,KAAK,CAAC,MAAN,EAAZ;;AACA,MAAI,GAAG,CAAC,OAAJ,KAAgB,SAApB,EAA+B;AAC7B;AACA;AACA,IAAA,GAAG,CAAC,OAAJ,GAAc;AACZ,MAAA,KAAK,EAAE,OAAO,YAAP,KAAwB,UAAxB,GAAsC,YAAyB,EAA/D,GAAoE;AAD/D,KAAd;AAGD;;AACD,SAAO,GAAG,CAAC,OAAJ,CAAY,KAAnB;AACD","sourceRoot":""}

package/lib/hooks/useControllableState.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+export declare type UseControllableStateOptions<State> = {
+    /**
+     * User provided default state or factory initializer
+     */
+    defaultState?: State | (() => State);
+    /**
+     * User provided controllable state, undefined state means internal state will be used
+     */
+    state: State | undefined;
+    /**
+     * Used to initialize state if all user provided states are undefined
+     */
+    initialState: State;
+};
+/**
+ * A useState 'like' hook that allows optional user control
+ * Useful for components which allow uncontrolled and controlled behaviour for users
+ * @returns - https://reactjs.org/docs/hooks-state.html
+ */
+export declare const useControllableState: <State>(options: UseControllableStateOptions<State>) => [State, React.Dispatch<React.SetStateAction<State>>];

package/lib/hooks/useControllableState.js

@@ -0,0 +1,72 @@
+import * as React from 'react';
+import { useConst } from './useConst';
+
+function isUndefined(state) {
+  return typeof state === 'undefined';
+}
+
+function isFactoryDispatch(newState) {
+  return typeof newState === 'function';
+}
+/**
+ * A useState 'like' hook that allows optional user control
+ * Useful for components which allow uncontrolled and controlled behaviour for users
+ * @returns - https://reactjs.org/docs/hooks-state.html
+ */
+
+
+export var useControllableState = function (options) {
+  var isControlled = useIsControlled(options.state);
+  var initialState = isUndefined(options.defaultState) ? options.initialState : options.defaultState;
+
+  var _a = React.useState(initialState),
+      internalState = _a[0],
+      setInternalState = _a[1];
+
+  var state = isControlled ? options.state : internalState;
+  var stateRef = React.useRef(state);
+  React.useEffect(function () {
+    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.
+
+  var setState = React.useCallback(function (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];
+};
+/**
+ * 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
+ */
+
+var useIsControlled = function (controlledValue) {
+  var isControlled = useConst(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(function () {
+      if (isControlled !== (controlledValue !== undefined)) {
+        var error = new Error();
+        var controlWarning = isControlled ? 'a controlled value to be uncontrolled' : 'an uncontrolled value to be controlled';
+        var 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,"sources":["../../src/hooks/useControllableState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAZ,MAAuB,OAAvB;AACA,SAAS,QAAT,QAAyB,YAAzB;;AAiBA,SAAS,WAAT,CAAqB,KAArB,EAAmC;AACjC,SAAO,OAAO,KAAP,KAAiB,WAAxB;AACD;;AAED,SAAS,iBAAT,CAAkC,QAAlC,EAAuE;AACrE,SAAO,OAAO,QAAP,KAAoB,UAA3B;AACD;AAED;;;;AAIG;;;AACH,OAAO,IAAM,oBAAoB,GAAG,UAClC,OADkC,EACS;AAE3C,MAAM,YAAY,GAAG,eAAe,CAAC,OAAO,CAAC,KAAT,CAApC;AACA,MAAM,YAAY,GAAG,WAAW,CAAC,OAAO,CAAC,YAAT,CAAX,GAAoC,OAAO,CAAC,YAA5C,GAA2D,OAAO,CAAC,YAAxF;;AACM,MAAA,EAAA,GAAoC,KAAK,CAAC,QAAN,CAAsB,YAAtB,CAApC;AAAA,MAAC,aAAa,GAAA,EAAA,CAAA,CAAA,CAAd;AAAA,MAAgB,gBAAgB,GAAA,EAAA,CAAA,CAAA,CAAhC;;AAEN,MAAM,KAAK,GAAG,YAAY,GAAI,OAAO,CAAC,KAAZ,GAA8B,aAAxD;AAEA,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAN,CAAa,KAAb,CAAjB;AACA,EAAA,KAAK,CAAC,SAAN,CAAgB,YAAA;AACd,IAAA,QAAQ,CAAC,OAAT,GAAmB,KAAnB;AACD,GAFD,EAEG,CAAC,KAAD,CAFH,EAT2C,CAa3C;AACA;;AACA,MAAM,QAAQ,GAAG,KAAK,CAAC,WAAN,CAAkB,UAAC,QAAD,EAAsC;AACvE;AACA;AACA,QAAI,iBAAiB,CAAC,QAAD,CAArB,EAAiC;AAC/B,MAAA,QAAQ,CAAC,OAAT,GAAmB,QAAQ,CAAC,QAAQ,CAAC,OAAV,CAA3B;AACD,KAFD,MAEO;AACL,MAAA,QAAQ,CAAC,OAAT,GAAmB,QAAnB;AACD;;AAED,IAAA,gBAAgB,CAAC,QAAQ,CAAC,OAAV,CAAhB;AACD,GAVgB,EAUd,EAVc,CAAjB;AAYA,SAAO,CAAC,KAAD,EAAQ,QAAR,CAAP;AACD,CA7BM;AA+BP;;;;AAIG;;AACH,IAAM,eAAe,GAAG,UAAC,eAAD,EAAyB;AAC/C,MAAM,YAAY,GAAG,QAAQ,CAAU,eAAe,KAAK,SAA9B,CAA7B;;AAEA,MAAI,OAAO,CAAC,GAAR,CAAY,QAAZ,KAAyB,YAA7B,EAA2C;AACzC;AACA;AACA,IAAA,KAAK,CAAC,SAAN,CAAgB,YAAA;AACd,UAAI,YAAY,MAAM,eAAe,KAAK,SAA1B,CAAhB,EAAsD;AACpD,YAAM,KAAK,GAAG,IAAI,KAAJ,EAAd;AAEA,YAAM,cAAc,GAAG,YAAY,GAC/B,uCAD+B,GAE/B,wCAFJ;AAIA,YAAM,gBAAgB,GAAG,YAAY,GAAG,yBAAH,GAA+B,wBAApE,CAPoD,CASpD;;AACA,QAAA,OAAO,CAAC,KAAR,CACE,CACE;AACA,qCAA6B,cAA7B,GAA8C,sCAFhD,EAGE,mBAAmB,gBAAnB,GAAsC,kCAHxC,EAIE,oGAJF,EAKE,2DALF,EAME,KAAK,CAAC,KANR,EAOE,IAPF,CAOO,GAPP,CADF;AAUD;AACF,KAtBD,EAsBG,CAAC,YAAD,EAAe,eAAf,CAtBH;AAuBD;;AAED,SAAO,YAAP;AACD,CAhCD","sourceRoot":""}

package/lib/hooks/useControllableValue.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+export declare type ChangeCallback<TElement extends HTMLElement, TValue, TEvent extends React.SyntheticEvent<TElement> | undefined> = (ev: TEvent, newValue: TValue | undefined) => void;
+/**
+ * Default value can be a value or an initializer
+ */
+declare type DefaultValue<TValue> = TValue | (() => TValue);
+/**
+ * Hook to manage a value that could be either controlled or uncontrolled, such as a checked state or
+ * text box string.
+ * @param controlledValue - The controlled value passed in the props. This value will always be used if provided,
+ * and the internal state will be updated to reflect it.
+ * @param defaultUncontrolledValue - Initial value for the internal state in the uncontrolled case.
+ * @returns An array of the current value and an updater callback. Like `React.useState`, the updater
+ * callback always has the same identity, and it can take either a new value, or a function which
+ * is passed the previous value and returns the new value.
+ * @see https://reactjs.org/docs/uncontrolled-components.html
+ */
+export declare function useControllableValue<TValue, TElement extends HTMLElement>(controlledValue: TValue, defaultUncontrolledValue: DefaultValue<TValue>): Readonly<[TValue, (update: React.SetStateAction<TValue>) => void]>;
+export declare function useControllableValue<TValue, TElement extends HTMLElement, TEvent extends React.SyntheticEvent<TElement> | undefined>(controlledValue: TValue, defaultUncontrolledValue: DefaultValue<TValue>, onChange: ChangeCallback<TElement, TValue, TEvent>): Readonly<[TValue, (update: React.SetStateAction<TValue>, ev?: React.FormEvent<TElement>) => void]>;
+export {};

package/lib/hooks/useControllableValue.js

@@ -0,0 +1,62 @@
+import * as React from 'react';
+import { useConst } from './useConst';
+export function useControllableValue(controlledValue, defaultUncontrolledValue, onChange) {
+  var _a = React.useState(defaultUncontrolledValue),
+      value = _a[0],
+      setValue = _a[1];
+
+  var isControlled = useIsControlled(controlledValue);
+  var currentValue = isControlled ? controlledValue : value; // Duplicate the current value and onChange in refs so they're accessible from
+  // setValueOrCallOnChange without creating a new callback every time
+
+  var valueRef = React.useRef(currentValue);
+  var onChangeRef = React.useRef(onChange);
+  React.useEffect(function () {
+    valueRef.current = currentValue;
+    onChangeRef.current = onChange;
+  }); // 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.
+
+  var setValueOrCallOnChange = useConst(function () {
+    return function (update, ev) {
+      // Assuming here that TValue is not a function, because a controllable value will typically
+      // be something a user can enter as input
+      var newValue = typeof update === 'function' ? update(valueRef.current) : update;
+
+      if (onChangeRef.current) {
+        onChangeRef.current(ev, newValue);
+      }
+
+      if (!isControlled) {
+        setValue(newValue);
+      }
+    };
+  });
+  return [currentValue, setValueOrCallOnChange];
+}
+/**
+ * Helper hook to handle previous comparison of controlled/uncontrolled
+ * Prints an error when isControlled value switches between subsequent renders
+ */
+
+var useIsControlled = function (controlledValue) {
+  var isControlled = useConst(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(function () {
+      if (isControlled !== (controlledValue !== undefined)) {
+        var error = new Error();
+        var controlWarning = isControlled ? 'a controlled value to be uncontrolled' : 'an uncontrolled value to be controlled';
+        var 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=useControllableValue.js.map