@jobber/hooks 2.9.2-CJS-to-ESM.18 → 2.9.2-CJS-to-ESM.24

package/dist/index.cjs

@@ -0,0 +1,806 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../formatters/dist/global.js
+var require_global = __commonJS({
+  "../formatters/dist/global.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.global = void 0;
+    function getGlobal() {
+      if (typeof window !== "undefined") {
+        return window;
+      }
+      return global;
+    }
+    var glob = getGlobal();
+    exports2.global = glob;
+  }
+});
+
+// ../formatters/dist/config.js
+var require_config = __commonJS({
+  "../formatters/dist/config.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.config = void 0;
+    var global_1 = require_global();
+    var configOverrides = (global_1.global.ATLANTIS_ENV || {}).config || {};
+    exports2.config = Object.freeze(Object.assign({ defaultCurrency: "USD", errorNotifier(message, error) {
+      console.error(message, error);
+    } }, configOverrides));
+  }
+});
+
+// ../formatters/dist/currency.js
+var require_currency = __commonJS({
+  "../formatters/dist/currency.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.formatCurrency = void 0;
+    var config_1 = require_config();
+    function formatCurrency(amount, currency = config_1.config.defaultCurrency) {
+      return amount.toLocaleString("en", {
+        style: "currency",
+        currency
+      });
+    }
+    exports2.formatCurrency = formatCurrency;
+  }
+});
+
+// ../formatters/dist/CurrencyType.js
+var require_CurrencyType = __commonJS({
+  "../formatters/dist/CurrencyType.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// ../formatters/dist/index.js
+var require_dist = __commonJS({
+  "../formatters/dist/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
+          __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_currency(), exports2);
+    __exportStar(require_CurrencyType(), exports2);
+    __exportStar(require_config(), exports2);
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BREAKPOINT_SIZES: () => BREAKPOINT_SIZES,
+  Breakpoints: () => Breakpoints,
+  mockViewportWidth: () => mockViewportWidth,
+  useAssert: () => useAssert,
+  useBool: () => useBool,
+  useBreakpoints: () => useBreakpoints,
+  useCollectionQuery: () => useCollectionQuery,
+  useFocusTrap: () => useFocusTrap,
+  useFormState: () => useFormState,
+  useInView: () => useInView,
+  useIsMounted: () => useIsMounted,
+  useLiveAnnounce: () => useLiveAnnounce,
+  useOnKeyDown: () => useOnKeyDown,
+  usePasswordStrength: () => usePasswordStrength,
+  useRefocusOnActivator: () => useRefocusOnActivator,
+  useResizeObserver: () => useResizeObserver,
+  useSafeLayoutEffect: () => useSafeLayoutEffect,
+  useShowClear: () => useShowClear
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/useAssert/useAssert.tsx
+var import_process = __toESM(require("process"), 1);
+function useAssert(shouldShow, message, options) {
+  var _a, _b;
+  if (((_b = (_a = import_process.default) == null ? void 0 : _a.env) == null ? void 0 : _b.NODE_ENV) !== "production" && shouldShow) {
+    if (options == null ? void 0 : options.warn) {
+      console.warn(message);
+    } else {
+      throw new Error(message);
+    }
+  }
+}
+
+// src/useBool/useBool.ts
+var import_react = require("react");
+function useBool(initialState = false) {
+  const [state, setState] = (0, import_react.useState)(initialState);
+  const setTrue = (0, import_react.useCallback)(() => setState(true), []);
+  const setFalse = (0, import_react.useCallback)(() => setState(false), []);
+  const toggle = (0, import_react.useCallback)(() => setState((current) => !current), []);
+  return [state, setTrue, setFalse, toggle];
+}
+
+// src/useBreakpoints/useMediaQuery.ts
+var import_react2 = require("react");
+function useMediaQuery(CSSMediaQuery) {
+  const [matches, setMatches] = (0, import_react2.useState)(
+    window.matchMedia(CSSMediaQuery).matches
+  );
+  (0, import_react2.useEffect)(() => {
+    const media = window.matchMedia(CSSMediaQuery);
+    if (media.matches !== matches) {
+      setMatches(media.matches);
+    }
+    const listener = () => setMatches(media.matches);
+    media.addEventListener("change", listener);
+    return () => media.removeEventListener("change", listener);
+  }, [CSSMediaQuery]);
+  return matches;
+}
+
+// src/useBreakpoints/useBreakpoints.ts
+var BREAKPOINT_SIZES = { sm: 490, md: 768, lg: 1080, xl: 1440 };
+function useBreakpoints() {
+  const { sm, md, lg, xl } = BREAKPOINT_SIZES;
+  const extraSmallOnly = useMediaQuery(`(max-width: ${sm - 1}px)`);
+  const smallAndUp = useMediaQuery(`(min-width: ${sm}px)`);
+  const mediumAndUp = useMediaQuery(`(min-width: ${md}px)`);
+  const largeAndUp = useMediaQuery(`(min-width: ${lg}px)`);
+  const extraLargeAndUp = useMediaQuery(`(min-width: ${xl}px)`);
+  return {
+    smallAndUp,
+    mediumAndUp,
+    largeAndUp,
+    extraLargeAndUp,
+    extraSmallOnly,
+    smallOnly: smallAndUp && !mediumAndUp,
+    mediumOnly: mediumAndUp && !largeAndUp,
+    largeOnly: largeAndUp && !extraLargeAndUp
+  };
+}
+
+// src/useBreakpoints/mockViewportWidth/mockViewportWidth.ts
+var defaultMatchMedia = window.matchMedia;
+var defaultResizeTo = window.resizeTo;
+var defaultInnerWidth = window.innerWidth;
+function mockViewportWidth() {
+  return { cleanup, setViewportWidth };
+}
+function setViewportWidth(newWidth) {
+  Object.defineProperty(window, "matchMedia", {
+    writable: true,
+    value: jest.fn().mockImplementation((query) => {
+      const matches = isQueryMatching(query);
+      const instance = {
+        matches,
+        media: query,
+        onchange: null,
+        addListener: jest.fn(),
+        // Deprecated but some packages use it
+        removeListener: jest.fn(),
+        // Deprecated but some packages use it
+        addEventListener: jest.fn(),
+        removeEventListener: jest.fn(),
+        dispatchEvent: jest.fn()
+      };
+      window.addEventListener("resize", () => {
+        if (matches != instance.matches) {
+          instance.matches = matches;
+          instance.dispatchEvent("change");
+        }
+      });
+      return instance;
+    })
+  });
+  Object.defineProperty(window, "resizeTo", {
+    value: (width) => {
+      Object.defineProperty(window, "innerWidth", {
+        configurable: true,
+        writable: true,
+        value: width
+      });
+      window.dispatchEvent(new Event("resize"));
+    }
+  });
+  window.resizeTo(newWidth, window.innerHeight);
+}
+function cleanup() {
+  window.matchMedia = defaultMatchMedia;
+  window.resizeTo = defaultResizeTo;
+  window.innerWidth = defaultInnerWidth;
+}
+function isQueryMatching(query) {
+  const match = query.match(/(min-width|max-width):\s*(\d+)/);
+  if (!match)
+    return false;
+  const { innerWidth } = window;
+  const [, operator, value] = match;
+  const breakpoint = parseInt(value, 10);
+  switch (operator) {
+    case "max-width":
+      return innerWidth <= breakpoint;
+    case "min-width":
+      return innerWidth >= breakpoint;
+  }
+}
+
+// src/useCollectionQuery/useCollectionQuery.ts
+var import_client = require("@apollo/client");
+var import_lodash = require("lodash");
+var import_react5 = require("react");
+var import_formatters = __toESM(require_dist(), 1);
+
+// src/useCollectionQuery/uniqueNodes.tsx
+function uniqueNodes(nodes) {
+  const result = /* @__PURE__ */ new Map();
+  nodes.forEach((node) => {
+    result.set(`${node.__typename}-${node.id}`, node);
+  });
+  return Array.from(result.values());
+}
+
+// src/useCollectionQuery/uniqueEdges.tsx
+function createEdge(node) {
+  return {
+    node,
+    cursor: "",
+    __typename: `${node.__typename}Edge`
+  };
+}
+function uniqueEdges(edges) {
+  const result = /* @__PURE__ */ new Map();
+  edges.forEach((edge) => {
+    result.set(
+      `${edge.__typename}-${edge.node.__typename}-${edge.node.id}`,
+      edge
+    );
+  });
+  return Array.from(result.values());
+}
+
+// src/useIsMounted/useIsMounted.ts
+var import_react4 = require("react");
+
+// src/useSafeLayoutEffect/useSafeLayoutEffect.ts
+var import_react3 = require("react");
+var useSafeLayoutEffect = (globalThis == null ? void 0 : globalThis.document) ? import_react3.useLayoutEffect : import_react3.useEffect;
+
+// src/useIsMounted/useIsMounted.ts
+function useIsMounted() {
+  const isMounted = (0, import_react4.useRef)(false);
+  useSafeLayoutEffect(() => {
+    isMounted.current = true;
+    return () => {
+      isMounted.current = false;
+    };
+  }, []);
+  return isMounted;
+}
+
+// src/useCollectionQuery/useCollectionQuery.ts
+function useCollectionQuery({
+  query,
+  queryOptions,
+  getCollectionByPath,
+  subscription
+}) {
+  var _a, _b;
+  const { data, loading, refetch, error, fetchMore, subscribeToMore } = (0, import_client.useQuery)(query, queryOptions);
+  const isMounted = useIsMounted();
+  const [loadingRefresh, setLoadingRefresh] = (0, import_react5.useState)(false);
+  const [loadingNextPage, setLoadingNextPage] = (0, import_react5.useState)(false);
+  const [hookError, setHookError] = (0, import_react5.useState)();
+  const loadingInitialContent = loading && !loadingRefresh && !loadingNextPage;
+  const isSearching = !!((_a = queryOptions == null ? void 0 : queryOptions.variables) == null ? void 0 : _a.searchTerm);
+  const refresh = (0, import_react5.useCallback)(() => {
+    if (loadingInitialContent || loadingRefresh) {
+      return;
+    }
+    setLoadingRefresh(true);
+    fetchMore({
+      // a workaround fix for the error described in this post
+      // https://github.com/apollographql/apollo-client/issues/7491#issuecomment-767985363
+      // These changes can be reverted once we can update to version 3.4
+      // (the current release candidate)
+      variables: {},
+      updateQuery: (prev, { fetchMoreResult }) => fetchMoreResult || prev
+    }).catch((err) => import_formatters.config.errorNotifier("Refetch Error", err)).finally(() => {
+      if (isMounted.current) {
+        setLoadingRefresh(false);
+      }
+    });
+  }, [
+    loadingInitialContent,
+    loadingRefresh,
+    setLoadingRefresh,
+    refetch,
+    isMounted
+  ]);
+  const nextPage = (0, import_react5.useCallback)(() => {
+    var _a2;
+    if (loadingInitialContent || loadingRefresh || loadingNextPage) {
+      return;
+    }
+    const pageInfo = (_a2 = getCollectionByPath(data)) == null ? void 0 : _a2.pageInfo;
+    if (!pageInfo || !pageInfo.hasNextPage) {
+      return;
+    }
+    setLoadingNextPage(true);
+    setHookError(void 0);
+    fetchMore({
+      variables: {
+        cursor: pageInfo.endCursor
+      },
+      updateQuery: (prev, { fetchMoreResult }) => fetchMoreUpdateQueryHandler(prev, fetchMoreResult, getCollectionByPath)
+    }).catch((err) => {
+      import_formatters.config.errorNotifier("FetchMore Error", err);
+      setHookError(err);
+    }).finally(() => {
+      if (isMounted.current) {
+        setLoadingNextPage(false);
+      }
+    });
+  }, [
+    data,
+    loadingInitialContent,
+    loadingRefresh,
+    fetchMore,
+    loadingNextPage,
+    setLoadingNextPage,
+    getCollectionByPath,
+    isMounted
+  ]);
+  (0, import_react5.useEffect)(
+    () => {
+      if (subscription == void 0)
+        return;
+      const subscriptionOptions = subscription.options || {};
+      setHookError(void 0);
+      return subscribeToMore(__spreadProps(__spreadValues({}, subscriptionOptions), {
+        document: subscription.document,
+        updateQuery: (prev, { subscriptionData }) => subscribeToMoreHandler(
+          isSearching,
+          prev,
+          getCollectionByPath,
+          subscriptionData == null ? void 0 : subscriptionData.data,
+          subscription.getNodeByPath
+        ),
+        onError: (err) => {
+          import_formatters.config.errorNotifier("Subscribe to More Error", err);
+          setHookError(err);
+        }
+      }));
+    },
+    // Disabling this linter so we can force this only run once. If we didn't
+    // do this we would need to ensure subscription, subscribeToMore, and getNodeByPath
+    // all use useCallback.
+    [(_b = queryOptions == null ? void 0 : queryOptions.variables) == null ? void 0 : _b.searchTerm]
+  );
+  const combinedError = error || hookError;
+  return {
+    data,
+    error: combinedError,
+    refresh,
+    loadingRefresh,
+    nextPage,
+    loadingNextPage,
+    loadingInitialContent
+  };
+}
+function fetchMoreUpdateQueryHandler(prev, fetchMoreResult, getCollectionByPath) {
+  const nextCollection = getCollectionByPath(fetchMoreResult);
+  const output = (0, import_lodash.cloneDeep)(prev);
+  const outputCollection = getCollectionByPath(output);
+  if (outputCollection === void 0 || nextCollection === void 0) {
+    return output;
+  }
+  if (outputCollection.nodes && nextCollection.nodes) {
+    outputCollection.nodes = getUpdatedNodes(
+      outputCollection.nodes,
+      nextCollection.nodes
+    );
+  }
+  if (outputCollection.edges && nextCollection.edges) {
+    outputCollection.edges = getUpdatedEdges(
+      outputCollection.edges,
+      nextCollection.edges
+    );
+  }
+  Object.assign(outputCollection, __spreadValues({
+    pageInfo: (0, import_lodash.cloneDeep)(nextCollection.pageInfo)
+  }, getTotalCount(nextCollection.totalCount)));
+  return output;
+}
+function subscribeToMoreHandler(isSearching, prev, getCollectionByPath, subscriptionData, getNodeByPath) {
+  const node = getNodeByPath(subscriptionData);
+  const output = (0, import_lodash.cloneDeep)(prev);
+  const outputCollection = getCollectionByPath(output);
+  if (outputCollection == void 0 || node == void 0)
+    return output;
+  if (isAlreadyUpdated(outputCollection, node) || isSearching) {
+    return prev;
+  }
+  if (outputCollection.nodes) {
+    outputCollection.nodes = getUpdatedNodes(
+      outputCollection.nodes,
+      [node],
+      false
+    );
+  }
+  if (outputCollection.edges) {
+    outputCollection.edges = getUpdatedEdges(
+      outputCollection.edges,
+      [createEdge(node)],
+      false
+    );
+  }
+  Object.assign(outputCollection, __spreadValues({
+    pageInfo: (0, import_lodash.cloneDeep)(outputCollection.pageInfo)
+  }, getTotalCount(outputCollection.totalCount, 1)));
+  return output;
+}
+function getTotalCount(totalCount, additionalCount = 0) {
+  return totalCount !== void 0 ? { totalCount: totalCount + additionalCount } : {};
+}
+function isAlreadyUpdated(outputCollection, newNode) {
+  let edgesAlreadyUpdated = true;
+  let nodesAlreadyUpdated = true;
+  if (outputCollection.edges) {
+    edgesAlreadyUpdated = outputCollection.edges.some((edge) => {
+      return edge.node.id === newNode.id;
+    });
+  }
+  if (outputCollection.nodes) {
+    nodesAlreadyUpdated = outputCollection.nodes.some((node) => {
+      return node.id === newNode.id;
+    });
+  }
+  return edgesAlreadyUpdated && nodesAlreadyUpdated;
+}
+function getUpdatedEdges(prevEdges, nextEdges, appendToEnd = true) {
+  const newEdges = appendToEnd ? [...prevEdges, ...nextEdges] : [...nextEdges, ...prevEdges];
+  return uniqueEdges(newEdges);
+}
+function getUpdatedNodes(prevNodes, nextNodes, appendToEnd = true) {
+  const newNodes = appendToEnd ? [...prevNodes, ...nextNodes] : [...nextNodes, ...prevNodes];
+  return uniqueNodes(newNodes);
+}
+
+// src/useFocusTrap/useFocusTrap.ts
+var import_react6 = require("react");
+function useFocusTrap(active) {
+  const ref = (0, import_react6.useRef)(null);
+  function handleKeyDown(event) {
+    if (!(active && ref.current) || event.key !== "Tab") {
+      return;
+    }
+    const { firstElement, lastElement } = getElements(ref.current);
+    if (event.shiftKey) {
+      if (document.activeElement === firstElement) {
+        lastElement.focus();
+        event.preventDefault();
+      }
+    } else {
+      if (document.activeElement === lastElement) {
+        firstElement.focus();
+        event.preventDefault();
+      }
+    }
+  }
+  (0, import_react6.useEffect)(() => {
+    if (active && ref.current) {
+      const { firstElement } = getElements(ref.current);
+      firstElement.focus();
+      ref.current.addEventListener("keydown", handleKeyDown);
+    }
+    return () => {
+      var _a;
+      (_a = ref.current) == null ? void 0 : _a.removeEventListener("keydown", handleKeyDown);
+    };
+  }, [active]);
+  return ref;
+}
+function getElements(ref) {
+  const focusables = [
+    "button",
+    "[href]",
+    "input",
+    "select",
+    "textarea",
+    '[tabindex]:not([tabindex="-1"])'
+  ];
+  const elements = [
+    ...ref.querySelectorAll(focusables.join(", "))
+  ];
+  if (ref.getAttribute("tabindex") === "0") {
+    elements.unshift(ref);
+  }
+  const firstElement = elements[0];
+  const lastElement = elements[elements.length - 1];
+  return { firstElement, lastElement };
+}
+
+// src/useFormState/useFormState.ts
+var import_react7 = require("react");
+function useFormState() {
+  const [formState, setFormState] = (0, import_react7.useState)({
+    isDirty: false,
+    isValid: false
+  });
+  return [formState, setFormState];
+}
+
+// src/useInView/useInView.ts
+var import_react8 = require("react");
+function useInView() {
+  const ref = (0, import_react8.useRef)(null);
+  const [isInView, setIsInView] = (0, import_react8.useState)(false);
+  const handleIntersection = (0, import_react8.useCallback)(
+    (entries) => setIsInView(entries[0].isIntersecting),
+    [setIsInView]
+  );
+  (0, import_react8.useEffect)(() => {
+    if (!window.IntersectionObserver)
+      return;
+    const observer = new IntersectionObserver(handleIntersection);
+    ref.current && observer.observe(ref.current);
+    return () => {
+      ref.current && observer.unobserve(ref.current);
+    };
+  }, [handleIntersection, ref.current]);
+  return [ref, isInView];
+}
+
+// src/useLiveAnnounce/useLiveAnnounce.tsx
+var import_react9 = require("react");
+function useLiveAnnounce() {
+  const [announcedMessage, setAnnouncedMessage] = (0, import_react9.useState)("");
+  (0, import_react9.useEffect)(() => {
+    let target;
+    if (announcedMessage) {
+      target = createAnnouncedElement();
+      setTimeout(() => target.append(announcedMessage), 100);
+    }
+    return () => target == null ? void 0 : target.remove();
+  }, [announcedMessage]);
+  return {
+    liveAnnounce: (message) => {
+      setAnnouncedMessage(message);
+    }
+  };
+}
+function createAnnouncedElement() {
+  const el = document.createElement("div");
+  el.style.position = "absolute";
+  el.style.width = "1px";
+  el.style.height = "1px";
+  el.style.overflow = "hidden";
+  el.style.clipPath = " inset(100%)";
+  el.style.whiteSpace = " nowrap";
+  el.style.top = "0";
+  el.setAttribute("role", "status");
+  el.setAttribute("aria-atomic", "true");
+  el.setAttribute("aria-live", "assertive");
+  document.body.appendChild(el);
+  return el;
+}
+
+// src/useOnKeyDown/useOnKeyDown.ts
+var import_react10 = require("react");
+function useOnKeyDown(callback, keys) {
+  (0, import_react10.useEffect)(() => {
+    window.addEventListener("keydown", handler);
+    return () => {
+      window.removeEventListener("keydown", handler);
+    };
+  }, [handler]);
+  function handler(event) {
+    const keyboardEvent = event;
+    if (typeof keys === "string" && keyboardEvent.key === keys) {
+      callback(event);
+      return;
+    }
+    if (Array.isArray(keys) && keys.some((item) => {
+      if (typeof item === "string")
+        return keyboardEvent.key === item;
+      return Object.keys(item).every(
+        (index) => keyboardEvent[index] === item[index]
+      );
+    })) {
+      callback(event);
+      return;
+    }
+    if (!Array.isArray(keys) && typeof keys !== "string" && Object.keys(keys).every((index) => keyboardEvent[index] === keys[index])) {
+      callback(event);
+      return;
+    }
+  }
+}
+
+// src/usePasswordStrength/usePasswordStrength.ts
+var import_react11 = require("react");
+var import_zxcvbn = __toESM(require("zxcvbn"), 1);
+function usePasswordStrength(password, dictionary) {
+  const {
+    guesses,
+    score,
+    feedback: { warning, suggestions },
+    crack_times_display: { offline_fast_hashing_1e10_per_second: timeToCrack }
+  } = (0, import_react11.useMemo)(
+    () => (0, import_zxcvbn.default)(password, dictionary),
+    [password, dictionary]
+  );
+  return {
+    guesses,
+    score,
+    warning,
+    suggestions,
+    timeToCrack
+  };
+}
+
+// src/useRefocusOnActivator/useRefocusOnActivator.ts
+var import_react12 = require("react");
+function useRefocusOnActivator(active) {
+  (0, import_react12.useEffect)(() => {
+    let activator;
+    if (active && !activator) {
+      activator = document.activeElement;
+    }
+    return () => {
+      if (active) {
+        if (activator instanceof HTMLElement) {
+          activator.focus();
+        }
+        activator = void 0;
+      }
+    };
+  }, [active]);
+}
+
+// src/useResizeObserver/useResizeObserver.ts
+var import_react13 = require("react");
+var import_polyfilled = __toESM(require("use-resize-observer/polyfilled"), 1);
+var import_lodash2 = require("lodash");
+var Breakpoints = {
+  base: 640,
+  small: 500,
+  smaller: 265,
+  large: 750,
+  larger: 1024
+};
+var wait = 100;
+function useResizeObserver({
+  widths = Breakpoints,
+  heights = Breakpoints
+} = {}) {
+  const [exactSize, setSize] = (0, import_react13.useState)({
+    width: void 0,
+    height: void 0
+  });
+  const onResize = (0, import_react13.useMemo)(() => (0, import_lodash2.throttle)(setSize, wait), [wait]);
+  const { ref } = (0, import_polyfilled.default)({
+    onResize
+  });
+  const exactWidth = exactSize.width;
+  const exactHeight = exactSize.height;
+  const sizes = {
+    width: getSize(widths, exactSize.width),
+    height: getSize(heights, exactSize.height),
+    exactWidth,
+    exactHeight
+  };
+  return [ref, sizes];
+}
+function getSize(sizes, comparable) {
+  if (!comparable || !sizes) {
+    return void 0;
+  }
+  const sortedSizes = Object.values(sizes).sort((a, b) => a - b).reverse();
+  return sortedSizes.find((value) => value <= comparable) || sortedSizes[sortedSizes.length - 1];
+}
+
+// src/useShowClear/useShowClear.ts
+function useShowClear({
+  clearable,
+  multiline,
+  focused,
+  hasValue,
+  disabled = false
+}) {
+  if (multiline && clearable !== "never") {
+    throw new Error("Multiline inputs can not be clearable");
+  }
+  if (!hasValue || clearable === "never" || disabled) {
+    return false;
+  }
+  switch (clearable) {
+    case "while-editing":
+      return focused;
+    case "always":
+      return true;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BREAKPOINT_SIZES,
+  Breakpoints,
+  mockViewportWidth,
+  useAssert,
+  useBool,
+  useBreakpoints,
+  useCollectionQuery,
+  useFocusTrap,
+  useFormState,
+  useInView,
+  useIsMounted,
+  useLiveAnnounce,
+  useOnKeyDown,
+  usePasswordStrength,
+  useRefocusOnActivator,
+  useResizeObserver,
+  useSafeLayoutEffect,
+  useShowClear
+});
+//# sourceMappingURL=index.cjs.map