react-hotkeys-hook 5.2.4 → 5.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Johannes Klauss
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,23 +1,19 @@
 {
   "name": "react-hotkeys-hook",
-  "version": "5.2.4",
-  "type": "module",
-  "scripts": {
-    "dev": "vite",
-    "build": "tsc && vite build",
-    "test": "vitest",
-    "prepublishOnly": "vitest run && npm run build"
-  },
+  "description": "React hook for handling keyboard shortcuts",
+  "version": "5.3.0",
+  "sideEffects": false,
   "repository": {
     "type": "git",
     "url": "https://github.com/JohannesKlauss/react-keymap-hook.git"
   },
   "homepage": "https://react-hotkeys-hook.vercel.app/",
   "author": "Johannes Klauss",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "type": "module",
+  "main": "packages/react-hotkeys-hook/dist/index.js",
+  "types": "packages/react-hotkeys-hook/dist/index.d.ts",
   "files": [
-    "dist"
+    "packages/react-hotkeys-hook/dist"
   ],
   "keywords": [
     "react",
@@ -32,24 +28,22 @@
     "hotkeys"
   ],
   "license": "MIT",
+  "scripts": {
+    "build": "npm run -w packages/react-hotkeys-hook build",
+    "build:documentation": "npm run -w packages/documentation build",
+    "test": "npm run -w packages/react-hotkeys-hook test",
+    "prepublishOnly": "npm run test && npm run lint && npm run build",
+    "format": "npx @biomejs/biome format --write packages",
+    "lint": "npx @biomejs/biome lint --write packages"
+  },
+  "workspaces": [
+    "packages/*"
+  ],
   "peerDependencies": {
     "react": ">=16.8.0",
     "react-dom": ">=16.8.0"
   },
   "devDependencies": {
-    "@eslint/js": "9.39.2",
-    "@types/react": "19.2.8",
-    "@types/react-dom": "19.2.3",
-    "@vitejs/plugin-react": "5.1.2",
-    "@testing-library/jest-dom": "6.9.1",
-    "@testing-library/react": "16.3.1",
-    "@testing-library/user-event": "14.6.1",
-    "@types/node": "24.10.8",
-    "globals": "16.5.0",
-    "jsdom": "27.4.0",
-    "typescript": "5.9.3",
-    "vite": "7.3.1",
-    "vitest": "4.0.17",
-    "vite-plugin-dts": "4.5.4"
+    "@biomejs/biome": "2.4.13"
   }
 }

package/packages/react-hotkeys-hook/dist/index.d.ts

@@ -0,0 +1,94 @@
+import { DependencyList } from 'react';
+import { JSX } from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { RefCallback } from 'react';
+
+declare type EventListenerOptions_2 = {
+    capture?: boolean;
+    once?: boolean;
+    passive?: boolean;
+    signal?: AbortSignal;
+} | boolean;
+
+declare type FormTags = 'input' | 'textarea' | 'select' | 'INPUT' | 'TEXTAREA' | 'SELECT' | 'searchbox' | 'slider' | 'spinbutton' | 'menuitem' | 'menuitemcheckbox' | 'menuitemradio' | 'option' | 'radio' | 'textbox';
+
+declare type Hotkey = KeyboardModifiers & {
+    keys?: readonly string[];
+    scopes?: Scopes;
+    description?: string;
+    isSequence?: boolean;
+    hotkey: string;
+    metadata?: Record<string, unknown>;
+};
+
+export declare type HotkeyCallback = (keyboardEvent: KeyboardEvent, hotkeysEvent: HotkeysEvent) => void;
+
+declare type HotkeysContextType = {
+    hotkeys: ReadonlyArray<Hotkey>;
+    activeScopes: string[];
+    toggleScope: (scope: string) => void;
+    enableScope: (scope: string) => void;
+    disableScope: (scope: string) => void;
+};
+
+declare type HotkeysEvent = Hotkey;
+
+export declare const HotkeysProvider: ({ initiallyActiveScopes, children }: Props) => JSX.Element;
+
+export declare function isHotkeyPressed(key: string | readonly string[], delimiter?: string): boolean;
+
+declare type KeyboardModifiers = {
+    alt?: boolean;
+    ctrl?: boolean;
+    meta?: boolean;
+    shift?: boolean;
+    mod?: boolean;
+    useKey?: boolean;
+};
+
+export declare type Keys = string | readonly string[];
+
+export declare type Options = {
+    enabled?: Trigger;
+    enableOnFormTags?: readonly FormTags[] | boolean;
+    enableOnContentEditable?: boolean;
+    ignoreEventWhen?: (e: KeyboardEvent) => boolean;
+    splitKey?: string;
+    delimiter?: string;
+    scopes?: Scopes;
+    keyup?: boolean;
+    keydown?: boolean;
+    preventDefault?: Trigger;
+    description?: string;
+    document?: Document;
+    ignoreModifiers?: boolean;
+    eventListenerOptions?: EventListenerOptions_2;
+    useKey?: boolean;
+    sequenceTimeoutMs?: number;
+    sequenceSplitKey?: string;
+    metadata?: Record<string, unknown>;
+};
+
+declare type OptionsOrDependencyArray = Options | DependencyList;
+
+declare interface Props {
+    initiallyActiveScopes?: string[];
+    children: ReactNode;
+}
+
+declare type Scopes = string | readonly string[];
+
+declare type Trigger = boolean | ((keyboardEvent: KeyboardEvent, hotkeysEvent: HotkeysEvent) => boolean);
+
+export declare function useHotkeys<T extends HTMLElement>(keys: Keys, callback: HotkeyCallback, options?: OptionsOrDependencyArray, dependencies?: OptionsOrDependencyArray): RefCallback<T | null>;
+
+export declare const useHotkeysContext: () => HotkeysContextType;
+
+export declare function useRecordHotkeys(useKey?: boolean, blacklist?: string[]): readonly [Set<string>, {
+    readonly start: () => void;
+    readonly stop: () => void;
+    readonly resetKeys: () => void;
+    readonly isRecording: boolean;
+}];
+
+export { }

package/packages/react-hotkeys-hook/dist/index.js

@@ -0,0 +1,313 @@
+import { createContext as j, useContext as W, useState as A, useCallback as h, useRef as K, useLayoutEffect as X, useEffect as I, useMemo as Y } from "react";
+import { jsx as x } from "react/jsx-runtime";
+const F = ["shift", "alt", "meta", "mod", "ctrl", "control"];
+function Z() {
+  return typeof navigator > "u" ? !1 : /mac/i.test(navigator.userAgent) && !/iphone|ipad|ipod/i.test(navigator.userAgent);
+}
+const ee = {
+  esc: "escape",
+  return: "enter",
+  left: "arrowleft",
+  right: "arrowright",
+  up: "arrowup",
+  down: "arrowdown",
+  ShiftLeft: "shift",
+  ShiftRight: "shift",
+  AltLeft: "alt",
+  AltRight: "alt",
+  MetaLeft: "meta",
+  MetaRight: "meta",
+  OSLeft: "meta",
+  OSRight: "meta",
+  ControlLeft: "ctrl",
+  ControlRight: "ctrl"
+};
+function L(e) {
+  return (ee[e.trim()] || e.trim()).toLowerCase().replace(/key|digit|numpad/, "");
+}
+function $(e) {
+  return F.includes(e);
+}
+function R(e, t = ",") {
+  return e.toLowerCase().split(t);
+}
+function O(e, t = "+", r = ">", i = !1, u, f) {
+  let d = [], l = !1;
+  e = e.trim(), e.includes(r) ? (l = !0, d = e.toLocaleLowerCase().split(r).map((y) => L(y))) : d = e.toLocaleLowerCase().split(t).map((y) => L(y));
+  const o = {
+    alt: d.includes("alt"),
+    ctrl: d.includes("ctrl") || d.includes("control"),
+    shift: d.includes("shift"),
+    meta: d.includes("meta"),
+    mod: d.includes("mod"),
+    useKey: i
+  }, p = d.filter((y) => !F.includes(y));
+  return {
+    ...o,
+    keys: p,
+    description: u,
+    isSequence: l,
+    hotkey: e,
+    metadata: f
+  };
+}
+typeof document < "u" && (document.addEventListener("keydown", (e) => {
+  e.code !== void 0 && z([L(e.code)]);
+}), document.addEventListener("keyup", (e) => {
+  e.code !== void 0 && G([L(e.code)]);
+})), typeof window < "u" && (window.addEventListener("blur", () => {
+  g.clear();
+}), window.addEventListener("focus", () => {
+  g.clear();
+}), window.addEventListener("contextmenu", () => {
+  setTimeout(() => {
+    g.clear();
+  }, 0);
+})), typeof document < "u" && document.addEventListener("visibilitychange", () => {
+  g.clear();
+});
+const g = /* @__PURE__ */ new Set();
+function D(e) {
+  return Array.isArray(e);
+}
+function te(e, t = ",") {
+  return (D(e) ? e : e.split(t)).every((i) => g.has(i.trim().toLowerCase()));
+}
+function z(e) {
+  const t = Array.isArray(e) ? e : [e];
+  g.has("meta") && g.forEach((r) => {
+    $(r) || g.delete(r.toLowerCase());
+  }), t.forEach((r) => {
+    g.add(r.toLowerCase());
+  });
+}
+function G(e) {
+  const t = Array.isArray(e) ? e : [e];
+  e === "meta" ? g.clear() : t.forEach((r) => {
+    g.delete(r.toLowerCase());
+  });
+}
+function re(e, t, r) {
+  (typeof r == "function" && r(e, t) || r === !0) && e.preventDefault();
+}
+function ne(e, t, r) {
+  return typeof r == "function" ? r(e, t) : r === !0 || r === void 0;
+}
+const oe = [
+  "input",
+  "textarea",
+  "select",
+  "searchbox",
+  "slider",
+  "spinbutton",
+  "menuitem",
+  "menuitemcheckbox",
+  "menuitemradio",
+  "option",
+  "radio",
+  "textbox"
+];
+function se(e) {
+  return J(e, oe);
+}
+function J(e, t = !1) {
+  const { target: r, composed: i } = e;
+  let u, f;
+  return ie(r) && i ? (u = e.composedPath()[0] && e.composedPath()[0].tagName, f = e.composedPath()[0] && e.composedPath()[0].role) : (u = r && r.tagName, f = r && r.role), D(t) ? !!(u && t?.some((d) => d.toLowerCase() === u.toLowerCase() || d === f)) : !!(u && t && t);
+}
+function ie(e) {
+  return !!e.tagName && !e.tagName.startsWith("-") && e.tagName.includes("-");
+}
+function ue(e, t) {
+  return e.length === 0 && t ? !1 : t ? e.some((r) => t.includes(r)) || e.includes("*") : !0;
+}
+const ce = (e, t, r = !1) => {
+  const { alt: i, meta: u, mod: f, shift: d, ctrl: l, keys: o, useKey: p } = t, { code: y, key: s, ctrlKey: c, metaKey: n, shiftKey: E, altKey: C } = e, m = L(y);
+  if (p && o?.length === 1 && o.includes(s.toLowerCase()))
+    return !0;
+  if (!o?.includes(m) && !["ctrl", "control", "unknown", "meta", "alt", "shift", "os"].includes(m))
+    return !1;
+  if (!r) {
+    if (i !== C && m !== "alt" || d !== E && m !== "shift")
+      return !1;
+    if (f) {
+      if (Z() ? !n : !c)
+        return !1;
+    } else if (u !== n && m !== "meta" && m !== "os" || l !== c && m !== "ctrl" && m !== "control")
+      return !1;
+  }
+  return o && o.length === 1 && o.includes(m) ? !0 : o && o.length > 0 ? o.includes(m) ? te(o) : !1 : !o || o.length === 0;
+}, Q = j(void 0), ae = () => W(Q);
+function de({ addHotkey: e, removeHotkey: t, children: r }) {
+  return /* @__PURE__ */ x(Q.Provider, { value: { addHotkey: e, removeHotkey: t }, children: r });
+}
+function M(e, t) {
+  return e && t && typeof e == "object" && typeof t == "object" ? Object.keys(e).length === Object.keys(t).length && // @ts-expect-error TS7053
+  Object.keys(e).reduce((r, i) => r && M(e[i], t[i]), !0) : e === t;
+}
+const U = j({
+  hotkeys: [],
+  activeScopes: [],
+  // This array has to be empty instead of containing '*' as default, to check if the provider is set or not
+  toggleScope: () => {
+  },
+  enableScope: () => {
+  },
+  disableScope: () => {
+  }
+}), fe = () => W(U), ve = ({ initiallyActiveScopes: e = ["*"], children: t }) => {
+  const [r, i] = A(e), [u, f] = A([]), d = h((s) => {
+    i((c) => c.includes("*") ? [s] : Array.from(/* @__PURE__ */ new Set([...c, s])));
+  }, []), l = h((s) => {
+    i((c) => c.filter((n) => n !== s));
+  }, []), o = h((s) => {
+    i((c) => c.includes(s) ? c.filter((n) => n !== s) : c.includes("*") ? [s] : Array.from(/* @__PURE__ */ new Set([...c, s])));
+  }, []), p = h((s) => {
+    f((c) => [...c, s]);
+  }, []), y = h((s) => {
+    f((c) => c.filter((n) => !M(n, s)));
+  }, []);
+  return /* @__PURE__ */ x(
+    U.Provider,
+    {
+      value: { activeScopes: r, hotkeys: u, enableScope: d, disableScope: l, toggleScope: o },
+      children: /* @__PURE__ */ x(de, { addHotkey: p, removeHotkey: y, children: t })
+    }
+  );
+};
+function le(e) {
+  const t = K(void 0);
+  return M(t.current, e) || (t.current = e), t.current;
+}
+const ye = (e) => {
+  e.stopPropagation(), e.preventDefault(), e.stopImmediatePropagation();
+}, me = typeof window < "u" ? X : I;
+function pe(e) {
+  if (!e) return;
+  const { enabled: t, preventDefault: r, ignoreEventWhen: i, ...u } = e;
+  return u;
+}
+function we(e, t, r, i) {
+  const [u, f] = A(null), d = h((w) => (f(w), () => f(null)), []), l = K(!1), o = Array.isArray(r) ? Array.isArray(i) ? void 0 : i : r, p = D(e) ? e.join(o?.delimiter) : e, y = Array.isArray(r) ? r : Array.isArray(i) ? i : void 0, s = h(t, y ?? []), c = K(s);
+  y ? c.current = s : c.current = t;
+  const n = le(pe(o)), E = K(o?.enabled);
+  E.current = o?.enabled;
+  const C = K(o?.preventDefault);
+  C.current = o?.preventDefault;
+  const m = K(o?.ignoreEventWhen);
+  m.current = o?.ignoreEventWhen;
+  const { activeScopes: T } = fe(), b = ae();
+  return me(() => {
+    if (E.current === !1 || !ue(T, n?.scopes))
+      return;
+    let w = [], S;
+    const q = (a, _ = !1) => {
+      if (!(se(a) && !J(a, n?.enableOnFormTags))) {
+        if (u !== null) {
+          const k = u.getRootNode();
+          if ((k instanceof Document || k instanceof ShadowRoot) && k.activeElement !== u && !u.contains(k.activeElement)) {
+            ye(a);
+            return;
+          }
+        }
+        a.target?.isContentEditable && !n?.enableOnContentEditable || R(p, n?.delimiter).forEach((k) => {
+          if (k.includes(n?.splitKey ?? "+") && k.includes(n?.sequenceSplitKey ?? ">")) {
+            console.warn(
+              `Hotkey ${k} contains both ${n?.splitKey ?? "+"} and ${n?.sequenceSplitKey ?? ">"} which is not supported.`
+            );
+            return;
+          }
+          const v = O(
+            k,
+            n?.splitKey,
+            n?.sequenceSplitKey,
+            n?.useKey,
+            n?.description,
+            n?.metadata
+          );
+          if (v.isSequence) {
+            S = setTimeout(() => {
+              w = [];
+            }, n?.sequenceTimeoutMs ?? 1e3);
+            const P = v.useKey ? a.key : L(a.code);
+            if ($(P.toLowerCase()))
+              return;
+            w.push(P);
+            const V = v.keys?.[w.length - 1];
+            if (P !== V) {
+              w = [], S && clearTimeout(S);
+              return;
+            }
+            w.length === v.keys?.length && (c.current(a, v), S && clearTimeout(S), w = []);
+          } else if (ce(a, v, n?.ignoreModifiers) || v.keys?.includes("*")) {
+            if (m.current?.(a) || _ && l.current || (re(a, v, C.current), !ne(a, v, E.current)))
+              return;
+            c.current(a, v), _ || (l.current = !0);
+          }
+        });
+      }
+    }, B = (a) => {
+      a.code !== void 0 && (z(L(a.code)), (n?.keydown === void 0 && n?.keyup !== !0 || n?.keydown) && q(a));
+    }, N = (a) => {
+      a.code !== void 0 && (G(L(a.code)), l.current = !1, n?.keyup && q(a, !0));
+    }, H = u || o?.document || document;
+    return H.addEventListener("keyup", N, o?.eventListenerOptions), H.addEventListener("keydown", B, o?.eventListenerOptions), b && R(p, n?.delimiter).forEach((a) => {
+      b.addHotkey(
+        O(
+          a,
+          n?.splitKey,
+          n?.sequenceSplitKey,
+          n?.useKey,
+          n?.description,
+          n?.metadata
+        )
+      );
+    }), () => {
+      H.removeEventListener("keyup", N, o?.eventListenerOptions), H.removeEventListener("keydown", B, o?.eventListenerOptions), b && R(p, n?.delimiter).forEach((a) => {
+        b.removeHotkey(
+          O(
+            a,
+            n?.splitKey,
+            n?.sequenceSplitKey,
+            n?.useKey,
+            n?.description,
+            n?.metadata
+          )
+        );
+      }), w = [], S && clearTimeout(S);
+    };
+  }, [u, n, T, p]), d;
+}
+function ke(e = !1, t = []) {
+  const [r, i] = A(/* @__PURE__ */ new Set()), [u, f] = A(!1), d = Y(() => new Set(t.map((s) => s.toLowerCase())), [t]), l = h(
+    (s) => {
+      if (s.code === void 0)
+        return;
+      const c = L(e ? s.key : s.code).toLowerCase();
+      d.has(c) || (s.preventDefault(), s.stopPropagation(), i((n) => {
+        const E = new Set(n);
+        return E.add(c), E;
+      }));
+    },
+    [e, d]
+  ), o = h(() => {
+    f(!1);
+  }, []), p = h(() => {
+    i(/* @__PURE__ */ new Set()), f(!0);
+  }, []), y = h(() => {
+    i(/* @__PURE__ */ new Set());
+  }, []);
+  return I(() => {
+    if (typeof document < "u" && u)
+      return document.addEventListener("keydown", l), () => {
+        document.removeEventListener("keydown", l);
+      };
+  }, [u, l]), [r, { start: p, stop: o, resetKeys: y, isRecording: u }];
+}
+export {
+  ve as HotkeysProvider,
+  te as isHotkeyPressed,
+  we as useHotkeys,
+  fe as useHotkeysContext,
+  ke as useRecordHotkeys
+};

package/dist/BoundHotkeysProxyProvider.d.ts

@@ -1,14 +0,0 @@
-import { ReactNode } from 'react';
-import { Hotkey } from './types';
-type BoundHotkeysProxyProviderType = {
-    addHotkey: (hotkey: Hotkey) => void;
-    removeHotkey: (hotkey: Hotkey) => void;
-};
-export declare const useBoundHotkeysProxy: () => BoundHotkeysProxyProviderType | undefined;
-interface Props {
-    children: ReactNode;
-    addHotkey: (hotkey: Hotkey) => void;
-    removeHotkey: (hotkey: Hotkey) => void;
-}
-export default function BoundHotkeysProxyProviderProvider({ addHotkey, removeHotkey, children }: Props): import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/HotkeysProvider.d.ts

@@ -1,16 +0,0 @@
-import { Hotkey } from './types';
-import { ReactNode } from 'react';
-export type HotkeysContextType = {
-    hotkeys: ReadonlyArray<Hotkey>;
-    activeScopes: string[];
-    toggleScope: (scope: string) => void;
-    enableScope: (scope: string) => void;
-    disableScope: (scope: string) => void;
-};
-export declare const useHotkeysContext: () => HotkeysContextType;
-interface Props {
-    initiallyActiveScopes?: string[];
-    children: ReactNode;
-}
-export declare const HotkeysProvider: ({ initiallyActiveScopes, children }: Props) => import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/deepEqual.d.ts

@@ -1 +0,0 @@
-export default function deepEqual(x?: unknown, y?: unknown): boolean;

package/dist/index.d.ts

@@ -1,6 +0,0 @@
-import { default as useHotkeys } from './useHotkeys';
-import { Options, Keys, HotkeyCallback } from './types';
-import { HotkeysProvider, useHotkeysContext } from './HotkeysProvider';
-import { isHotkeyPressed } from './isHotkeyPressed';
-import { default as useRecordHotkeys } from './useRecordHotkeys';
-export { useHotkeys, useRecordHotkeys, useHotkeysContext, isHotkeyPressed, HotkeysProvider, type Options, type Keys, type HotkeyCallback, };

package/dist/index.js

@@ -1,290 +0,0 @@
-import { createContext as T, useContext as M, useState as A, useCallback as w, useRef as S, useLayoutEffect as z, useEffect as J } from "react";
-import { jsx as b } from "react/jsx-runtime";
-const j = ["shift", "alt", "meta", "mod", "ctrl", "control"], Q = {
-  esc: "escape",
-  return: "enter",
-  left: "arrowleft",
-  right: "arrowright",
-  up: "arrowup",
-  down: "arrowdown",
-  ShiftLeft: "shift",
-  ShiftRight: "shift",
-  AltLeft: "alt",
-  AltRight: "alt",
-  MetaLeft: "meta",
-  MetaRight: "meta",
-  OSLeft: "meta",
-  OSRight: "meta",
-  ControlLeft: "ctrl",
-  ControlRight: "ctrl"
-};
-function K(e) {
-  return (Q[e.trim()] || e.trim()).toLowerCase().replace(/key|digit|numpad/, "");
-}
-function D(e) {
-  return j.includes(e);
-}
-function H(e, r = ",") {
-  return e.toLowerCase().split(r);
-}
-function P(e, r = "+", o = ">", i = !1, c, a) {
-  let n = [], y = !1;
-  e = e.trim(), e.includes(o) ? (y = !0, n = e.toLocaleLowerCase().split(o).map((f) => K(f))) : n = e.toLocaleLowerCase().split(r).map((f) => K(f));
-  const u = {
-    alt: n.includes("alt"),
-    ctrl: n.includes("ctrl") || n.includes("control"),
-    shift: n.includes("shift"),
-    meta: n.includes("meta"),
-    mod: n.includes("mod"),
-    useKey: i
-  }, l = n.filter((f) => !j.includes(f));
-  return {
-    ...u,
-    keys: l,
-    description: c,
-    isSequence: y,
-    hotkey: e,
-    metadata: a
-  };
-}
-typeof document < "u" && (document.addEventListener("keydown", (e) => {
-  e.code !== void 0 && _([K(e.code)]);
-}), document.addEventListener("keyup", (e) => {
-  e.code !== void 0 && I([K(e.code)]);
-})), typeof window < "u" && (window.addEventListener("blur", () => {
-  L.clear();
-}), window.addEventListener("contextmenu", () => {
-  setTimeout(() => {
-    L.clear();
-  }, 0);
-}));
-const L = /* @__PURE__ */ new Set();
-function R(e) {
-  return Array.isArray(e);
-}
-function U(e, r = ",") {
-  return (R(e) ? e : e.split(r)).every((i) => L.has(i.trim().toLowerCase()));
-}
-function _(e) {
-  const r = Array.isArray(e) ? e : [e];
-  L.has("meta") && L.forEach((o) => {
-    D(o) || L.delete(o.toLowerCase());
-  }), r.forEach((o) => {
-    L.add(o.toLowerCase());
-  });
-}
-function I(e) {
-  const r = Array.isArray(e) ? e : [e];
-  e === "meta" ? L.clear() : r.forEach((o) => {
-    L.delete(o.toLowerCase());
-  });
-}
-function V(e, r, o) {
-  (typeof o == "function" && o(e, r) || o === !0) && e.preventDefault();
-}
-function X(e, r, o) {
-  return typeof o == "function" ? o(e, r) : o === !0 || o === void 0;
-}
-const Y = [
-  "input",
-  "textarea",
-  "select",
-  "searchbox",
-  "slider",
-  "spinbutton",
-  "menuitem",
-  "menuitemcheckbox",
-  "menuitemradio",
-  "option",
-  "radio",
-  "textbox"
-];
-function Z(e) {
-  return F(e, Y);
-}
-function F(e, r = !1) {
-  const { target: o, composed: i } = e;
-  let c, a;
-  return ee(o) && i ? (c = e.composedPath()[0] && e.composedPath()[0].tagName, a = e.composedPath()[0] && e.composedPath()[0].role) : (c = o && o.tagName, a = o && o.role), R(r) ? !!(c && r && r.some((n) => n.toLowerCase() === c.toLowerCase() || n === a)) : !!(c && r && r);
-}
-function ee(e) {
-  return !!e.tagName && !e.tagName.startsWith("-") && e.tagName.includes("-");
-}
-function te(e, r) {
-  return e.length === 0 && r ? !1 : r ? e.some((o) => r.includes(o)) || e.includes("*") : !0;
-}
-const re = (e, r, o = !1) => {
-  const { alt: i, meta: c, mod: a, shift: n, ctrl: y, keys: u, useKey: l } = r, { code: f, key: t, ctrlKey: d, metaKey: m, shiftKey: g, altKey: k } = e, p = K(f);
-  if (l && u?.length === 1 && u.includes(t.toLowerCase()))
-    return !0;
-  if (!u?.includes(p) && !["ctrl", "control", "unknown", "meta", "alt", "shift", "os"].includes(p))
-    return !1;
-  if (!o) {
-    if (i !== k && p !== "alt" || n !== g && p !== "shift")
-      return !1;
-    if (a) {
-      if (!m && !d)
-        return !1;
-    } else if (c !== m && p !== "meta" && p !== "os" || y !== d && p !== "ctrl" && p !== "control")
-      return !1;
-  }
-  return u && u.length === 1 && u.includes(p) ? !0 : u && u.length > 0 ? u.includes(p) ? U(u) : !1 : !u || u.length === 0;
-}, $ = T(void 0), oe = () => M($);
-function ne({ addHotkey: e, removeHotkey: r, children: o }) {
-  return /* @__PURE__ */ b($.Provider, { value: { addHotkey: e, removeHotkey: r }, children: o });
-}
-function x(e, r) {
-  return e && r && typeof e == "object" && typeof r == "object" ? Object.keys(e).length === Object.keys(r).length && // @ts-expect-error TS7053
-  Object.keys(e).reduce((o, i) => o && x(e[i], r[i]), !0) : e === r;
-}
-const W = T({
-  hotkeys: [],
-  activeScopes: [],
-  // This array has to be empty instead of containing '*' as default, to check if the provider is set or not
-  toggleScope: () => {
-  },
-  enableScope: () => {
-  },
-  disableScope: () => {
-  }
-}), se = () => M(W), de = ({ initiallyActiveScopes: e = ["*"], children: r }) => {
-  const [o, i] = A(e), [c, a] = A([]), n = w((t) => {
-    i((d) => d.includes("*") ? [t] : Array.from(/* @__PURE__ */ new Set([...d, t])));
-  }, []), y = w((t) => {
-    i((d) => d.filter((m) => m !== t));
-  }, []), u = w((t) => {
-    i((d) => d.includes(t) ? d.filter((m) => m !== t) : d.includes("*") ? [t] : Array.from(/* @__PURE__ */ new Set([...d, t])));
-  }, []), l = w((t) => {
-    a((d) => [...d, t]);
-  }, []), f = w((t) => {
-    a((d) => d.filter((m) => !x(m, t)));
-  }, []);
-  return /* @__PURE__ */ b(
-    W.Provider,
-    {
-      value: { activeScopes: o, hotkeys: c, enableScope: n, disableScope: y, toggleScope: u },
-      children: /* @__PURE__ */ b(ne, { addHotkey: l, removeHotkey: f, children: r })
-    }
-  );
-};
-function ie(e) {
-  const r = S(void 0);
-  return x(r.current, e) || (r.current = e), r.current;
-}
-const N = (e) => {
-  e.stopPropagation(), e.preventDefault(), e.stopImmediatePropagation();
-}, ce = typeof window < "u" ? z : J;
-function fe(e, r, o, i) {
-  const c = S(null), a = S(!1), n = Array.isArray(o) ? Array.isArray(i) ? void 0 : i : o, y = R(e) ? e.join(n?.delimiter) : e, u = Array.isArray(o) ? o : Array.isArray(i) ? i : void 0, l = w(r, u ?? []), f = S(l);
-  u ? f.current = l : f.current = r;
-  const t = ie(n), { activeScopes: d } = se(), m = oe();
-  return ce(() => {
-    if (t?.enabled === !1 || !te(d, t?.scopes))
-      return;
-    let g = [], k;
-    const p = (s, B = !1) => {
-      if (!(Z(s) && !F(s, t?.enableOnFormTags))) {
-        if (c.current !== null) {
-          const v = c.current.getRootNode();
-          if ((v instanceof Document || v instanceof ShadowRoot) && v.activeElement !== c.current && !c.current.contains(v.activeElement)) {
-            N(s);
-            return;
-          }
-        }
-        s.target?.isContentEditable && !t?.enableOnContentEditable || H(y, t?.delimiter).forEach((v) => {
-          if (v.includes(t?.splitKey ?? "+") && v.includes(t?.sequenceSplitKey ?? ">")) {
-            console.warn(
-              `Hotkey ${v} contains both ${t?.splitKey ?? "+"} and ${t?.sequenceSplitKey ?? ">"} which is not supported.`
-            );
-            return;
-          }
-          const h = P(
-            v,
-            t?.splitKey,
-            t?.sequenceSplitKey,
-            t?.useKey,
-            t?.description,
-            t?.metadata
-          );
-          if (h.isSequence) {
-            k = setTimeout(() => {
-              g = [];
-            }, t?.sequenceTimeoutMs ?? 1e3);
-            const C = h.useKey ? s.key : K(s.code);
-            if (D(C.toLowerCase()))
-              return;
-            g.push(C);
-            const G = h.keys?.[g.length - 1];
-            if (C !== G) {
-              g = [], k && clearTimeout(k);
-              return;
-            }
-            g.length === h.keys?.length && (f.current(s, h), k && clearTimeout(k), g = []);
-          } else if (re(s, h, t?.ignoreModifiers) || h.keys?.includes("*")) {
-            if (t?.ignoreEventWhen?.(s) || B && a.current)
-              return;
-            if (V(s, h, t?.preventDefault), !X(s, h, t?.enabled)) {
-              N(s);
-              return;
-            }
-            f.current(s, h), B || (a.current = !0);
-          }
-        });
-      }
-    }, O = (s) => {
-      s.code !== void 0 && (_(K(s.code)), (t?.keydown === void 0 && t?.keyup !== !0 || t?.keydown) && p(s));
-    }, q = (s) => {
-      s.code !== void 0 && (I(K(s.code)), a.current = !1, t?.keyup && p(s, !0));
-    }, E = c.current || n?.document || document;
-    return E.addEventListener("keyup", q, n?.eventListenerOptions), E.addEventListener("keydown", O, n?.eventListenerOptions), m && H(y, t?.delimiter).forEach((s) => {
-      m.addHotkey(
-        P(
-          s,
-          t?.splitKey,
-          t?.sequenceSplitKey,
-          t?.useKey,
-          t?.description,
-          t?.metadata
-        )
-      );
-    }), () => {
-      E.removeEventListener("keyup", q, n?.eventListenerOptions), E.removeEventListener("keydown", O, n?.eventListenerOptions), m && H(y, t?.delimiter).forEach((s) => {
-        m.removeHotkey(
-          P(
-            s,
-            t?.splitKey,
-            t?.sequenceSplitKey,
-            t?.useKey,
-            t?.description,
-            t?.metadata
-          )
-        );
-      }), g = [], k && clearTimeout(k);
-    };
-  }, [y, t, d]), c;
-}
-function le(e = !1) {
-  const [r, o] = A(/* @__PURE__ */ new Set()), [i, c] = A(!1), a = w(
-    (l) => {
-      l.code !== void 0 && (l.preventDefault(), l.stopPropagation(), o((f) => {
-        const t = new Set(f);
-        return t.add(K(e ? l.key : l.code)), t;
-      }));
-    },
-    [e]
-  ), n = w(() => {
-    typeof document < "u" && (document.removeEventListener("keydown", a), c(!1));
-  }, [a]), y = w(() => {
-    o(/* @__PURE__ */ new Set()), typeof document < "u" && (n(), document.addEventListener("keydown", a), c(!0));
-  }, [a, n]), u = w(() => {
-    o(/* @__PURE__ */ new Set());
-  }, []);
-  return [r, { start: y, stop: n, resetKeys: u, isRecording: i }];
-}
-export {
-  de as HotkeysProvider,
-  U as isHotkeyPressed,
-  fe as useHotkeys,
-  se as useHotkeysContext,
-  le as useRecordHotkeys
-};

package/dist/isHotkeyPressed.d.ts

@@ -1,4 +0,0 @@
-export declare function isReadonlyArray(value: unknown): value is readonly unknown[];
-export declare function isHotkeyPressed(key: string | readonly string[], delimiter?: string): boolean;
-export declare function pushToCurrentlyPressedKeys(key: string | string[]): void;
-export declare function removeFromCurrentlyPressedKeys(key: string | string[]): void;

package/dist/parseHotkeys.d.ts

@@ -1,5 +0,0 @@
-import { Hotkey } from './types';
-export declare function mapCode(key: string): string;
-export declare function isHotkeyModifier(key: string): boolean;
-export declare function parseKeysHookInput(keys: string, delimiter?: string): string[];
-export declare function parseHotkey(hotkey: string, splitKey?: string, sequenceSplitKey?: string, useKey?: boolean, description?: string, metadata?: Record<string, unknown>): Hotkey;

package/dist/types.d.ts

@@ -1,50 +0,0 @@
-import { DependencyList } from 'react';
-export type FormTags = 'input' | 'textarea' | 'select' | 'INPUT' | 'TEXTAREA' | 'SELECT' | 'searchbox' | 'slider' | 'spinbutton' | 'menuitem' | 'menuitemcheckbox' | 'menuitemradio' | 'option' | 'radio' | 'textbox';
-export type Keys = string | readonly string[];
-export type Scopes = string | readonly string[];
-export type EventListenerOptions = {
-    capture?: boolean;
-    once?: boolean;
-    passive?: boolean;
-    signal?: AbortSignal;
-} | boolean;
-export type KeyboardModifiers = {
-    alt?: boolean;
-    ctrl?: boolean;
-    meta?: boolean;
-    shift?: boolean;
-    mod?: boolean;
-    useKey?: boolean;
-};
-export type Hotkey = KeyboardModifiers & {
-    keys?: readonly string[];
-    scopes?: Scopes;
-    description?: string;
-    isSequence?: boolean;
-    hotkey: string;
-    metadata?: Record<string, unknown>;
-};
-export type HotkeysEvent = Hotkey;
-export type HotkeyCallback = (keyboardEvent: KeyboardEvent, hotkeysEvent: HotkeysEvent) => void;
-export type Trigger = boolean | ((keyboardEvent: KeyboardEvent, hotkeysEvent: HotkeysEvent) => boolean);
-export type Options = {
-    enabled?: Trigger;
-    enableOnFormTags?: readonly FormTags[] | boolean;
-    enableOnContentEditable?: boolean;
-    ignoreEventWhen?: (e: KeyboardEvent) => boolean;
-    splitKey?: string;
-    delimiter?: string;
-    scopes?: Scopes;
-    keyup?: boolean;
-    keydown?: boolean;
-    preventDefault?: Trigger;
-    description?: string;
-    document?: Document;
-    ignoreModifiers?: boolean;
-    eventListenerOptions?: EventListenerOptions;
-    useKey?: boolean;
-    sequenceTimeoutMs?: number;
-    sequenceSplitKey?: string;
-    metadata?: Record<string, unknown>;
-};
-export type OptionsOrDependencyArray = Options | DependencyList;

package/dist/useDeepEqualMemo.d.ts

@@ -1 +0,0 @@
-export default function useDeepEqualMemo<T>(value: T): T | undefined;

package/dist/useHotkeys.d.ts

@@ -1,2 +0,0 @@
-import { HotkeyCallback, Keys, OptionsOrDependencyArray } from './types';
-export default function useHotkeys<T extends HTMLElement>(keys: Keys, callback: HotkeyCallback, options?: OptionsOrDependencyArray, dependencies?: OptionsOrDependencyArray): import('react').RefObject<T | null>;

package/dist/useRecordHotkeys.d.ts

@@ -1,6 +0,0 @@
-export default function useRecordHotkeys(useKey?: boolean): readonly [Set<string>, {
-    readonly start: () => void;
-    readonly stop: () => void;
-    readonly resetKeys: () => void;
-    readonly isRecording: boolean;
-}];

package/dist/validators.d.ts

@@ -1,8 +0,0 @@
-import { FormTags, Hotkey, Scopes, Trigger } from './types';
-export declare function maybePreventDefault(e: KeyboardEvent, hotkey: Hotkey, preventDefault?: Trigger): void;
-export declare function isHotkeyEnabled(e: KeyboardEvent, hotkey: Hotkey, enabled?: Trigger): boolean;
-export declare function isKeyboardEventTriggeredByInput(ev: KeyboardEvent): boolean;
-export declare function isHotkeyEnabledOnTag(event: KeyboardEvent, enabledOnTags?: readonly FormTags[] | boolean): boolean;
-export declare function isCustomElement(element: HTMLElement): boolean;
-export declare function isScopeActive(activeScopes: string[], scopes?: Scopes): boolean;
-export declare const isHotkeyMatchingKeyboardEvent: (e: KeyboardEvent, hotkey: Hotkey, ignoreModifiers?: boolean) => boolean;