@fluentui/react-utilities 0.0.0-nightly050f89bf0020211102.1

package/lib-commonjs/hooks/index.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var tslib_1 = /*#__PURE__*/require("tslib");
+
+tslib_1.__exportStar(require("./useControllableState"), exports);
+
+tslib_1.__exportStar(require("./useBoolean"), exports);
+
+tslib_1.__exportStar(require("./useConst"), exports);
+
+tslib_1.__exportStar(require("./useControllableValue"), exports);
+
+tslib_1.__exportStar(require("./useEventCallback"), exports);
+
+tslib_1.__exportStar(require("./useFirstMount"), exports);
+
+tslib_1.__exportStar(require("./useId"), exports);
+
+tslib_1.__exportStar(require("./useIsomorphicLayoutEffect"), exports);
+
+tslib_1.__exportStar(require("./useMergedRefs"), exports);
+
+tslib_1.__exportStar(require("./useMount"), exports);
+
+tslib_1.__exportStar(require("./useOnClickOutside"), exports);
+
+tslib_1.__exportStar(require("./useOnScrollOutside"), exports);
+
+tslib_1.__exportStar(require("./usePrevious"), exports);
+
+tslib_1.__exportStar(require("./useTimeout"), exports);
+
+tslib_1.__exportStar(require("./useUnmount"), exports);
+
+tslib_1.__exportStar(require("./useForceUpdate"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/index.ts"],"names":[],"mappings":";;;;;;;;AAAA,OAAA,CAAA,YAAA,CAAA,OAAA,CAAA,wBAAA,CAAA,EAAA,OAAA;;AACA,OAAA,CAAA,YAAA,CAAA,OAAA,CAAA,cAAA,CAAA,EAAA,OAAA;;AACA,OAAA,CAAA,YAAA,CAAA,OAAA,CAAA,YAAA,CAAA,EAAA,OAAA;;AACA,OAAA,CAAA,YAAA,CAAA,OAAA,CAAA,wBAAA,CAAA,EAAA,OAAA;;AACA,OAAA,CAAA,YAAA,CAAA,OAAA,CAAA,oBAAA,CAAA,EAAA,OAAA;;AACA,OAAA,CAAA,YAAA,CAAA,OAAA,CAAA,iBAAA,CAAA,EAAA,OAAA;;AACA,OAAA,CAAA,YAAA,CAAA,OAAA,CAAA,SAAA,CAAA,EAAA,OAAA;;AACA,OAAA,CAAA,YAAA,CAAA,OAAA,CAAA,6BAAA,CAAA,EAAA,OAAA;;AACA,OAAA,CAAA,YAAA,CAAA,OAAA,CAAA,iBAAA,CAAA,EAAA,OAAA;;AACA,OAAA,CAAA,YAAA,CAAA,OAAA,CAAA,YAAA,CAAA,EAAA,OAAA;;AACA,OAAA,CAAA,YAAA,CAAA,OAAA,CAAA,qBAAA,CAAA,EAAA,OAAA;;AACA,OAAA,CAAA,YAAA,CAAA,OAAA,CAAA,sBAAA,CAAA,EAAA,OAAA;;AACA,OAAA,CAAA,YAAA,CAAA,OAAA,CAAA,eAAA,CAAA,EAAA,OAAA;;AACA,OAAA,CAAA,YAAA,CAAA,OAAA,CAAA,cAAA,CAAA,EAAA,OAAA;;AACA,OAAA,CAAA,YAAA,CAAA,OAAA,CAAA,cAAA,CAAA,EAAA,OAAA;;AACA,OAAA,CAAA,YAAA,CAAA,OAAA,CAAA,kBAAA,CAAA,EAAA,OAAA","sourceRoot":""}

package/lib-commonjs/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-commonjs/hooks/useBoolean.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useBoolean = void 0;
+
+var React = /*#__PURE__*/require("react");
+
+var useConst_1 = /*#__PURE__*/require("./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.
+ */
+
+
+function useBoolean(initialState) {
+  var _a = React.useState(initialState),
+      value = _a[0],
+      setValue = _a[1];
+
+  var setTrue = useConst_1.useConst(function () {
+    return function () {
+      setValue(true);
+    };
+  });
+  var setFalse = useConst_1.useConst(function () {
+    return function () {
+      setValue(false);
+    };
+  });
+  var toggle = useConst_1.useConst(function () {
+    return function () {
+      setValue(function (currentValue) {
+        return !currentValue;
+      });
+    };
+  });
+  return [value, {
+    setTrue: setTrue,
+    setFalse: setFalse,
+    toggle: toggle
+  }];
+}
+
+exports.useBoolean = useBoolean;
+//# sourceMappingURL=useBoolean.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/useBoolean.ts"],"names":[],"mappings":";;;;;;;AAAA,IAAA,KAAA,gBAAA,OAAA,CAAA,OAAA,CAAA;;AACA,IAAA,UAAA,gBAAA,OAAA,CAAA,YAAA,CAAA;AAYA;;;;;;AAMG;;;AACH,SAAgB,UAAhB,CAA2B,YAA3B,EAAgD;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,UAAA,CAAA,QAAA,CAAS,YAAA;AAAM,WAAA,YAAA;AAC7B,MAAA,QAAQ,CAAC,IAAD,CAAR;AAD6B,KAAA;AAE9B,GAFe,CAAhB;AAGA,MAAM,QAAQ,GAAG,UAAA,CAAA,QAAA,CAAS,YAAA;AAAM,WAAA,YAAA;AAC9B,MAAA,QAAQ,CAAC,KAAD,CAAR;AAD8B,KAAA;AAE/B,GAFgB,CAAjB;AAGA,MAAM,MAAM,GAAG,UAAA,CAAA,QAAA,CAAS,YAAA;AAAM,WAAA,YAAA;AAC5B,MAAA,QAAQ,CAAC,UAAA,YAAA,EAAY;AAAI,eAAA,CAAA,YAAA;AAAa,OAA9B,CAAR;AAD4B,KAAA;AAE7B,GAFc,CAAf;AAIA,SAAO,CAAC,KAAD,EAAQ;AAAE,IAAA,OAAO,EAAA,OAAT;AAAW,IAAA,QAAQ,EAAA,QAAnB;AAAqB,IAAA,MAAM,EAAA;AAA3B,GAAR,CAAP;AACD;;AAdD,OAAA,CAAA,UAAA,GAAA,UAAA","sourceRoot":""}

package/lib-commonjs/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-commonjs/hooks/useConst.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useConst = void 0;
+
+var React = /*#__PURE__*/require("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.
+ */
+
+
+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;
+}
+
+exports.useConst = useConst;
+//# sourceMappingURL=useConst.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/useConst.ts"],"names":[],"mappings":";;;;;;;AAAA,IAAA,KAAA,gBAAA,OAAA,CAAA,OAAA,CAAA;AAEA;;;;;;;;;;AAUG;;;AACH,SAAgB,QAAhB,CAA4B,YAA5B,EAAuD;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;;AAbD,OAAA,CAAA,QAAA,GAAA,QAAA","sourceRoot":""}

package/lib-commonjs/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-commonjs/hooks/useControllableState.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useControllableState = void 0;
+
+var React = /*#__PURE__*/require("react");
+
+var useConst_1 = /*#__PURE__*/require("./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
+ */
+
+
+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];
+};
+
+exports.useControllableState = useControllableState;
+/**
+ * Helper hook to handle previous comparison of controlled/uncontrolled
+ * Prints an error when isControlled value switches between subsequent renders
+ * @returns - whether the value is controlled
+ */
+
+var useIsControlled = function (controlledValue) {
+  var isControlled = useConst_1.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-commonjs/hooks/useControllableState.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/useControllableState.ts"],"names":[],"mappings":";;;;;;;AAAA,IAAA,KAAA,gBAAA,OAAA,CAAA,OAAA,CAAA;;AACA,IAAA,UAAA,gBAAA,OAAA,CAAA,YAAA,CAAA;;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;;;AACI,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;;AAAM,OAAA,CAAA,oBAAA,GAAoB,oBAApB;AA+Bb;;;;AAIG;;AACH,IAAM,eAAe,GAAG,UAAC,eAAD,EAAyB;AAC/C,MAAM,YAAY,GAAG,UAAA,CAAA,QAAA,CAAkB,eAAe,KAAK,SAAtC,CAArB;;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-commonjs/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-commonjs/hooks/useControllableValue.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useControllableValue = void 0;
+
+var React = /*#__PURE__*/require("react");
+
+var useConst_1 = /*#__PURE__*/require("./useConst");
+
+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_1.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];
+}
+
+exports.useControllableValue = useControllableValue;
+/**
+ * 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_1.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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/useControllableValue.ts"],"names":[],"mappings":";;;;;;;AAAA,IAAA,KAAA,gBAAA,OAAA,CAAA,OAAA,CAAA;;AACA,IAAA,UAAA,gBAAA,OAAA,CAAA,YAAA,CAAA;;AAqCA,SAAgB,oBAAhB,CAKE,eALF,EAME,wBANF,EAOE,QAPF,EAOqD;AAE7C,MAAA,EAAA,GAAoB,KAAK,CAAC,QAAN,CAAmC,wBAAnC,CAApB;AAAA,MAAC,KAAK,GAAA,EAAA,CAAA,CAAA,CAAN;AAAA,MAAQ,QAAQ,GAAA,EAAA,CAAA,CAAA,CAAhB;;AACN,MAAM,YAAY,GAAG,eAAe,CAAC,eAAD,CAApC;AACA,MAAM,YAAY,GAAG,YAAY,GAAG,eAAH,GAAqB,KAAtD,CAJmD,CAMnD;AACA;;AACA,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAN,CAAa,YAAb,CAAjB;AACA,MAAM,WAAW,GAAG,KAAK,CAAC,MAAN,CAAa,QAAb,CAApB;AACA,EAAA,KAAK,CAAC,SAAN,CAAgB,YAAA;AACd,IAAA,QAAQ,CAAC,OAAT,GAAmB,YAAnB;AACA,IAAA,WAAW,CAAC,OAAZ,GAAsB,QAAtB;AACD,GAHD,EAVmD,CAenD;AACA;;AACA,MAAM,sBAAsB,GAAG,UAAA,CAAA,QAAA,CAAS,YAAA;AAAM,WAAA,UAAC,MAAD,EAAmD,EAAnD,EAA8D;AAC1G;AACA;AACA,UAAM,QAAQ,GAAG,OAAO,MAAP,KAAkB,UAAlB,GAAgC,MAAmB,CAAC,QAAQ,CAAC,OAAV,CAAnD,GAAwE,MAAzF;;AAEA,UAAI,WAAW,CAAC,OAAhB,EAAyB;AACvB,QAAA,WAAW,CAAC,OAAZ,CAAoB,EAApB,EAAyB,QAAzB;AACD;;AAED,UAAI,CAAC,YAAL,EAAmB;AACjB,QAAA,QAAQ,CAAC,QAAD,CAAR;AACD;AAX2C,KAAA;AAY7C,GAZ8B,CAA/B;AAcA,SAAO,CAAC,YAAD,EAAe,sBAAf,CAAP;AACD;;AAvCD,OAAA,CAAA,oBAAA,GAAA,oBAAA;AAyCA;;;AAGG;;AACH,IAAM,eAAe,GAAG,UAAS,eAAT,EAAgC;AACtD,MAAM,YAAY,GAAG,UAAA,CAAA,QAAA,CAAkB,eAAe,KAAK,SAAtC,CAArB;;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-commonjs/hooks/useEventCallback.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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 declare const useEventCallback: <Args extends unknown[], Return>(fn: (...args: Args) => Return) => (...args: Args) => Return;

package/lib-commonjs/hooks/useEventCallback.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useEventCallback = void 0;
+
+var React = /*#__PURE__*/require("react");
+
+var useIsomorphicLayoutEffect_1 = /*#__PURE__*/require("./useIsomorphicLayoutEffect");
+/**
+ * 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
+ */
+
+
+var useEventCallback = function (fn) {
+  var callbackRef = React.useRef(function () {
+    throw new Error('Cannot call an event handler while rendering');
+  });
+  useIsomorphicLayoutEffect_1.useIsomorphicLayoutEffect(function () {
+    callbackRef.current = fn;
+  }, [fn]);
+  return React.useCallback(function () {
+    var args = [];
+
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+
+    var callback = callbackRef.current;
+    return callback.apply(void 0, args);
+  }, [callbackRef]);
+};
+
+exports.useEventCallback = useEventCallback;
+//# sourceMappingURL=useEventCallback.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/useEventCallback.ts"],"names":[],"mappings":";;;;;;;AAAA,IAAA,KAAA,gBAAA,OAAA,CAAA,OAAA,CAAA;;AACA,IAAA,2BAAA,gBAAA,OAAA,CAAA,6BAAA,CAAA;AAEA;;;;;;;;;;;AAWG;;;AACI,IAAM,gBAAgB,GAAG,UAAiC,EAAjC,EAA8D;AAC5F,MAAM,WAAW,GAAG,KAAK,CAAC,MAAN,CAAwB,YAAA;AAC1C,UAAM,IAAI,KAAJ,CAAU,8CAAV,CAAN;AACD,GAFmB,CAApB;AAIA,EAAA,2BAAA,CAAA,yBAAA,CAA0B,YAAA;AACxB,IAAA,WAAW,CAAC,OAAZ,GAAsB,EAAtB;AACD,GAFD,EAEG,CAAC,EAAD,CAFH;AAIA,SAAO,KAAK,CAAC,WAAN,CACL,YAAA;AAAC,QAAA,IAAA,GAAA,EAAA;;SAAA,IAAA,EAAA,GAAA,C,EAAA,EAAA,GAAA,SAAA,CAAA,M,EAAA,EAAA,E,EAAa;AAAb,MAAA,IAAA,CAAA,EAAA,CAAA,GAAA,SAAA,CAAA,EAAA,CAAA;;;AACC,QAAM,QAAQ,GAAG,WAAW,CAAC,OAA7B;AACA,WAAO,QAAQ,CAAA,KAAR,CAAQ,KAAA,CAAR,EAAY,IAAZ,CAAP;AACD,GAJI,EAKL,CAAC,WAAD,CALK,CAAP;AAOD,CAhBM;;AAAM,OAAA,CAAA,gBAAA,GAAgB,gBAAhB","sourceRoot":""}

package/lib-commonjs/hooks/useFirstMount.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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 declare function useFirstMount(): boolean;

package/lib-commonjs/hooks/useFirstMount.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useFirstMount = void 0;
+
+var React = /*#__PURE__*/require("react");
+/**
+ * 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();
+ */
+
+
+function useFirstMount() {
+  var isFirst = React.useRef(true);
+
+  if (isFirst.current) {
+    isFirst.current = false;
+    return true;
+  }
+
+  return isFirst.current;
+}
+
+exports.useFirstMount = useFirstMount;
+//# sourceMappingURL=useFirstMount.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/useFirstMount.ts"],"names":[],"mappings":";;;;;;;AAAA,IAAA,KAAA,gBAAA,OAAA,CAAA,OAAA,CAAA;AAEA;;;;;;;;;AASG;;;AACH,SAAgB,aAAhB,GAA6B;AAC3B,MAAM,OAAO,GAAG,KAAK,CAAC,MAAN,CAAa,IAAb,CAAhB;;AAEA,MAAI,OAAO,CAAC,OAAZ,EAAqB;AACnB,IAAA,OAAO,CAAC,OAAR,GAAkB,KAAlB;AACA,WAAO,IAAP;AACD;;AAED,SAAO,OAAO,CAAC,OAAf;AACD;;AATD,OAAA,CAAA,aAAA,GAAA,aAAA","sourceRoot":""}

package/lib-commonjs/hooks/useForceUpdate.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Forces a re-render, similar to `forceUpdate` in class components.
+ */
+export declare function useForceUpdate(): import("react").DispatchWithoutAction;

package/lib-commonjs/hooks/useForceUpdate.js

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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/useForceUpdate.ts"],"names":[],"mappings":";;;;;;;AAAA,IAAA,OAAA,gBAAA,OAAA,CAAA,OAAA,CAAA;AAEA;;AAEG;;;AACH,SAAgB,cAAhB,GAA8B;AAC5B,SAAO,OAAA,CAAA,UAAA,CAAW,UAAA,CAAA,EAAC;AAAI,WAAA,CAAC,GAAD,CAAA;AAAK,GAArB,EAAuB,CAAvB,EAA0B,CAA1B,CAAP;AACD;;AAFD,OAAA,CAAA,cAAA,GAAA,cAAA","sourceRoot":""}

package/lib-commonjs/hooks/useId.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Resets generated IDs, should be used only in tests.
+ *
+ * @private
+ */
+export declare function resetIdsForTests(): void;
+/**
+ * Hook to generate a unique ID.
+ *
+ * @param prefix - Optional prefix for the ID
+ * @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 declare function useId(prefix?: string, providedId?: string): string;

package/lib-commonjs/hooks/useId.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useId = exports.resetIdsForTests = void 0;
+
+var React = /*#__PURE__*/require("react");
+
+var index_1 = /*#__PURE__*/require("../ssr/index");
+/**
+ * Resets generated IDs, should be used only in tests.
+ *
+ * @private
+ */
+
+
+function resetIdsForTests() {
+  index_1.defaultSSRContextValue.current = 0;
+}
+
+exports.resetIdsForTests = resetIdsForTests;
+/**
+ * Hook to generate a unique ID.
+ *
+ * @param prefix - Optional prefix for the ID
+ * @param providedId - Optional id provided by a parent component. Defaults to the provided value if present,
+ *  without conditioning the hook call
+ * @returns The ID
+ */
+
+function useId(prefix, providedId) {
+  var contextValue = index_1.useSSRContext();
+  return React.useMemo(function () {
+    return providedId || "" + prefix + ++contextValue.current;
+  }, [prefix, providedId, contextValue]);
+}
+
+exports.useId = useId;
+//# sourceMappingURL=useId.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/useId.ts"],"names":[],"mappings":";;;;;;;AAAA,IAAA,KAAA,gBAAA,OAAA,CAAA,OAAA,CAAA;;AACA,IAAA,OAAA,gBAAA,OAAA,CAAA,cAAA,CAAA;AAEA;;;;AAIG;;;AACH,SAAgB,gBAAhB,GAAgC;AAC9B,EAAA,OAAA,CAAA,sBAAA,CAAuB,OAAvB,GAAiC,CAAjC;AACD;;AAFD,OAAA,CAAA,gBAAA,GAAA,gBAAA;AAIA;;;;;;;AAOG;;AACH,SAAgB,KAAhB,CAAsB,MAAtB,EAAuC,UAAvC,EAA0D;AACxD,MAAM,YAAY,GAAG,OAAA,CAAA,aAAA,EAArB;AAEA,SAAO,KAAK,CAAC,OAAN,CAAc,YAAA;AAAM,WAAA,UAAU,IAAI,KAAG,MAAH,GAAY,EAAE,YAAY,CAAxC,OAAA;AAAkD,GAAtE,EAAwE,CAAC,MAAD,EAAS,UAAT,EAAqB,YAArB,CAAxE,CAAP;AACD;;AAJD,OAAA,CAAA,KAAA,GAAA,KAAA","sourceRoot":""}

package/lib-commonjs/hooks/useIsomorphicLayoutEffect.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+/**
+ * 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
+ */
+export declare const useIsomorphicLayoutEffect: typeof React.useEffect;

package/lib-commonjs/hooks/useIsomorphicLayoutEffect.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useIsomorphicLayoutEffect = void 0;
+
+var React = /*#__PURE__*/require("react");
+
+var index_1 = /*#__PURE__*/require("../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
+
+
+exports.useIsomorphicLayoutEffect = /*#__PURE__*/index_1.canUseDOM() ? React.useLayoutEffect : React.useEffect;
+//# sourceMappingURL=useIsomorphicLayoutEffect.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/useIsomorphicLayoutEffect.ts"],"names":[],"mappings":";;;;;;;AAAA,IAAA,KAAA,gBAAA,OAAA,CAAA,OAAA,CAAA;;AACA,IAAA,OAAA,gBAAA,OAAA,CAAA,cAAA,CAAA;AAEA;;;;;;;;AAQG;AACH;;;AACa,OAAA,CAAA,yBAAA,GAAoD,aAAA,OAAA,CAAA,SAAA,KAAc,KAAK,CAAC,eAApB,GAAsC,KAAK,CAAC,SAAhG","sourceRoot":""}