react-hotkeys-hook 5.0.0-1 → 5.0.0

package/README.md

@@ -136,7 +136,7 @@ useHotkeys(keys: string | string[], callback: (event: KeyboardEvent, handler: Ho
 
 | Parameter     | Type                                                    | Required? | Default value | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 |---------------|---------------------------------------------------------|-----------|---------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `keys`        | `string` or `string[]`                                  | required  | -             | set the hotkeys you want the hook to listen to. You can use single or multiple keys, modifier combinations, etc. This will either be a string or an array of strings. To separate multiple keys, use a colon. This split key value can be overridden with the `splitKey` option.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `keys`        | `string` or `string[]`                                  | required  | -             | set the hotkeys you want the hook to listen to. You can use single or multiple keys, modifier combinations, etc. This will either be a string or an array of strings. To separate multiple keys, use a comma. This split key value can be overridden with the `splitKey` option.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
 | `callback`    | `(event: KeyboardEvent, handler: HotkeysEvent) => void` | required  | -             | This is the callback function that will be called when the hotkey is pressed. The callback will receive the browsers native `KeyboardEvent` and the libraries `HotkeysEvent`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 | `options`     | `Options`                                               | optional  | `{}`          | Object to modify the behavior of the hook. Default options are given below.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | `dependencies` | `DependencyList`                                         | optional  | `[]`           | The given callback will always be memoised inside the hook. So if you reference any outside variables, you need to set them here for the callback to get updated (Much like `useCallback` works in React). |

package/package.json

@@ -1,19 +1,18 @@
 {
   "name": "react-hotkeys-hook",
   "description": "React hook for handling keyboard shortcuts",
-  "version": "5.0.0-1",
+  "version": "5.0.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/JohannesKlauss/react-keymap-hook.git"
   },
   "homepage": "https://johannesklauss.github.io/react-hotkeys-hook/",
   "author": "Johannes Klauss",
-  "main": "dist/index.js",
-  "module": "dist/react-hotkeys-hook.esm.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",
-    "src"
+    "packages/react-hotkeys-hook/dist"
   ],
   "keywords": [
     "react",
@@ -29,84 +28,17 @@
   ],
   "license": "MIT",
   "scripts": {
-    "build": "tsdx build",
-    "test": "jest",
-    "publish": "np",
-    "format": "prettier ./src/**/*.{ts,tsx} --write",
-    "lint": "eslint ./src/**/*.{ts,tsx} --fix && prettier ./src/**/*.{ts,tsx} --check"
-  },
-  "babel": {
-    "presets": [
-      "@babel/preset-env",
-      "@babel/preset-typescript",
-      "@babel/preset-react"
-    ]
-  },
-  "prettier": {
-    "printWidth": 120,
-    "semi": false,
-    "singleQuote": true,
-    "trailingComma": "es5"
-  },
-  "eslintConfig": {
-    "env": {
-      "browser": true,
-      "es2021": true
-    },
-    "extends": [
-      "eslint:recommended",
-      "plugin:react/recommended",
-      "plugin:@typescript-eslint/recommended"
-    ],
-    "parser": "@typescript-eslint/parser",
-    "parserOptions": {
-      "ecmaFeatures": {
-        "jsx": true
-      },
-      "ecmaVersion": "latest",
-      "sourceType": "module"
-    },
-    "plugins": [
-      "react",
-      "@typescript-eslint"
-    ],
-    "rules": {
-      "react/react-in-jsx-scope": "off",
-      "@typescript-eslint/no-empty-function": "off",
-      "@typescript-eslint/no-explicit-any": "off",
-      "@typescript-eslint/ban-ts-comment": "off"
-    }
-  },
-  "devDependencies": {
-    "@babel/core": "7.23.7",
-    "@babel/plugin-proposal-class-properties": "7.18.6",
-    "@babel/plugin-transform-react-jsx": "7.23.4",
-    "@babel/preset-env": "7.23.7",
-    "@babel/preset-react": "7.23.3",
-    "@babel/preset-typescript": "7.23.3",
-    "@testing-library/jest-dom": "5.17.0",
-    "@testing-library/react": "14.1.2",
-    "@testing-library/user-event": "14.5.2",
-    "@types/jest": "29.5.11",
-    "@types/react": "18.2.47",
-    "@types/react-dom": "18.2.18",
-    "@typescript-eslint/eslint-plugin": "5.60.0",
-    "@typescript-eslint/parser": "5.60.0",
-    "eslint": "8.56.0",
-    "eslint-plugin-prettier": "4.2.1",
-    "eslint-plugin-react": "7.33.2",
-    "jest": "29.7.0",
-    "jest-environment-jsdom": "29.7.0",
-    "prettier": "2.8.8",
-    "react": "18.2.0",
-    "react-dom": "18.2.0",
-    "react-test-renderer": "18.2.0",
-    "tsdx": "0.14.1",
-    "tslib": "2.6.2",
-    "typescript": "5.3.3"
+    "build": "npm run -w packages/react-hotkeys-hook build",
+    "build:documentation": "npm run -w packages/documentation build",
+    "lint": "npm run -w packages/react-hotkeys-hook lint",
+    "test": "npm run -w packages/react-hotkeys-hook test",
+    "prepublishOnly": "npm run test && npm run lint && npm run build"
   },
+  "workspaces": [
+    "packages/*"
+  ],
   "peerDependencies": {
-    "react": ">=16.8.1",
-    "react-dom": ">=16.8.1"
+    "react": ">=16.8.0",
+    "react-dom": ">=16.8.0"
   }
 }

package/{dist → packages/react-hotkeys-hook/dist}/BoundHotkeysProxyProvider.d.ts

@@ -1,14 +1,14 @@
-import { ReactNode } from 'react';
-import { Hotkey } from './types';
-declare 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.Element;
-export {};
+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 → packages/react-hotkeys-hook/dist}/HotkeysProvider.d.ts

@@ -1,16 +1,16 @@
-import { Hotkey } from './types';
-import { ReactNode } from 'react';
-export declare 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.Element;
-export {};
+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/packages/react-hotkeys-hook/dist/deepEqual.d.ts

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

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

@@ -1,6 +1,6 @@
-import useHotkeys from './useHotkeys';
-import type { Options, Keys, HotkeyCallback } from './types';
-import { HotkeysProvider, useHotkeysContext } from './HotkeysProvider';
-import { isHotkeyPressed } from './isHotkeyPressed';
-import useRecordHotkeys from './useRecordHotkeys';
-export { useHotkeys, useRecordHotkeys, useHotkeysContext, isHotkeyPressed, HotkeysProvider, Options, Keys, HotkeyCallback, };
+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, Options, Keys, HotkeyCallback, };

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

@@ -0,0 +1,220 @@
+import { createContext as I, useContext as q, useState as A, useCallback as w, useRef as S, useLayoutEffect as Q, useEffect as U } from "react";
+import { jsx as R } from "react/jsx-runtime";
+const F = ["shift", "alt", "meta", "mod", "ctrl", "control"], V = {
+  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(t) {
+  return (V[t.trim()] || t.trim()).toLowerCase().replace(/key|digit|numpad/, "");
+}
+function X(t) {
+  return F.includes(t);
+}
+function P(t, r = ",") {
+  return t.toLowerCase().split(r);
+}
+function b(t, r = "+", n = !1, a) {
+  const o = t.toLocaleLowerCase().split(r).map((i) => k(i)), l = {
+    alt: o.includes("alt"),
+    ctrl: o.includes("ctrl") || o.includes("control"),
+    shift: o.includes("shift"),
+    meta: o.includes("meta"),
+    mod: o.includes("mod"),
+    useKey: n
+  }, c = o.filter((i) => !F.includes(i));
+  return {
+    ...l,
+    keys: c,
+    description: a
+  };
+}
+typeof document < "u" && (document.addEventListener("keydown", (t) => {
+  t.code !== void 0 && T([k(t.code)]);
+}), document.addEventListener("keyup", (t) => {
+  t.code !== void 0 && W([k(t.code)]);
+})), typeof window < "u" && window.addEventListener("blur", () => {
+  g.clear();
+});
+const g = /* @__PURE__ */ new Set();
+function B(t) {
+  return Array.isArray(t);
+}
+function Y(t, r = ",") {
+  return (B(t) ? t : t.split(r)).every((a) => g.has(a.trim().toLowerCase()));
+}
+function T(t) {
+  const r = Array.isArray(t) ? t : [t];
+  g.has("meta") && g.forEach((n) => !X(n) && g.delete(n.toLowerCase())), r.forEach((n) => g.add(n.toLowerCase()));
+}
+function W(t) {
+  const r = Array.isArray(t) ? t : [t];
+  t === "meta" ? g.clear() : r.forEach((n) => g.delete(n.toLowerCase()));
+}
+function Z(t, r, n) {
+  (typeof n == "function" && n(t, r) || n === !0) && t.preventDefault();
+}
+function $(t, r, n) {
+  return typeof n == "function" ? n(t, r) : n === !0 || n === void 0;
+}
+function _(t) {
+  return z(t, ["input", "textarea", "select"]);
+}
+function z(t, r = !1) {
+  const { target: n, composed: a } = t;
+  let o;
+  return m(n) && a ? o = t.composedPath()[0] && t.composedPath()[0].tagName : o = n && n.tagName, B(r) ? !!(o && r && r.some((l) => l.toLowerCase() === o.toLowerCase())) : !!(o && r && r);
+}
+function m(t) {
+  return !!t.tagName && !t.tagName.startsWith("-") && t.tagName.includes("-");
+}
+function O(t, r) {
+  return t.length === 0 && r ? (console.warn(
+    'A hotkey has the "scopes" option set, however no active scopes were found. If you want to use the global scopes feature, you need to wrap your app in a <HotkeysProvider>'
+  ), !0) : r ? t.some((n) => r.includes(n)) || t.includes("*") : !0;
+}
+const ee = (t, r, n = !1) => {
+  const { alt: a, meta: o, mod: l, shift: c, ctrl: i, keys: u, useKey: v } = r, { code: h, key: e, ctrlKey: s, metaKey: d, shiftKey: C, altKey: K } = t, y = k(h);
+  if (v && (u == null ? void 0 : u.length) === 1 && u.includes(e))
+    return !0;
+  if (!(u != null && u.includes(y)) && !["ctrl", "control", "unknown", "meta", "alt", "shift", "os"].includes(y))
+    return !1;
+  if (!n) {
+    if (a !== K && y !== "alt" || c !== C && y !== "shift")
+      return !1;
+    if (l) {
+      if (!d && !s)
+        return !1;
+    } else if (o !== d && y !== "meta" && y !== "os" || i !== s && y !== "ctrl" && y !== "control")
+      return !1;
+  }
+  return u && u.length === 1 && u.includes(y) ? !0 : u ? Y(u) : !u;
+}, G = I(void 0), te = () => q(G);
+function re({ addHotkey: t, removeHotkey: r, children: n }) {
+  return /* @__PURE__ */ R(G.Provider, { value: { addHotkey: t, removeHotkey: r }, children: n });
+}
+function N(t, r) {
+  return t && r && typeof t == "object" && typeof r == "object" ? Object.keys(t).length === Object.keys(r).length && // @ts-expect-error TS7053
+  Object.keys(t).reduce((n, a) => n && N(t[a], r[a]), !0) : t === r;
+}
+const J = I({
+  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: () => {
+  }
+}), ne = () => q(J), fe = ({ initiallyActiveScopes: t = ["*"], children: r }) => {
+  const [n, a] = A(t), [o, l] = A([]), c = w((e) => {
+    a((s) => s.includes("*") ? [e] : Array.from(/* @__PURE__ */ new Set([...s, e])));
+  }, []), i = w((e) => {
+    a((s) => s.filter((d) => d !== e));
+  }, []), u = w((e) => {
+    a((s) => s.includes(e) ? s.filter((d) => d !== e) : s.includes("*") ? [e] : Array.from(/* @__PURE__ */ new Set([...s, e])));
+  }, []), v = w((e) => {
+    l((s) => [...s, e]);
+  }, []), h = w((e) => {
+    l((s) => s.filter((d) => !N(d, e)));
+  }, []);
+  return /* @__PURE__ */ R(
+    J.Provider,
+    {
+      value: { activeScopes: n, hotkeys: o, enableScope: c, disableScope: i, toggleScope: u },
+      children: /* @__PURE__ */ R(re, { addHotkey: v, removeHotkey: h, children: r })
+    }
+  );
+};
+function oe(t) {
+  const r = S(void 0);
+  return N(r.current, t) || (r.current = t), r.current;
+}
+const D = (t) => {
+  t.stopPropagation(), t.preventDefault(), t.stopImmediatePropagation();
+}, ce = typeof window < "u" ? Q : U;
+function se(t, r, n, a) {
+  const o = S(null), l = S(!1), c = n instanceof Array ? a instanceof Array ? void 0 : a : n, i = B(t) ? t.join(c == null ? void 0 : c.delimiter) : t, u = n instanceof Array ? n : a instanceof Array ? a : void 0, v = w(r, u ?? []), h = S(v);
+  u ? h.current = v : h.current = r;
+  const e = oe(c), { activeScopes: s } = ne(), d = te();
+  return ce(() => {
+    if ((e == null ? void 0 : e.enabled) === !1 || !O(s, e == null ? void 0 : e.scopes))
+      return;
+    const C = (f, p = !1) => {
+      var j;
+      if (!(_(f) && !z(f, e == null ? void 0 : e.enableOnFormTags))) {
+        if (o.current !== null) {
+          const E = o.current.getRootNode();
+          if ((E instanceof Document || E instanceof ShadowRoot) && E.activeElement !== o.current && !o.current.contains(E.activeElement)) {
+            D(f);
+            return;
+          }
+        }
+        (j = f.target) != null && j.isContentEditable && !(e != null && e.enableOnContentEditable) || P(i, e == null ? void 0 : e.delimiter).forEach((E) => {
+          var M, x;
+          const L = b(E, e == null ? void 0 : e.splitKey, e == null ? void 0 : e.useKey, e == null ? void 0 : e.description);
+          if (ee(f, L, e == null ? void 0 : e.ignoreModifiers) || (M = L.keys) != null && M.includes("*")) {
+            if ((x = e == null ? void 0 : e.ignoreEventWhen) != null && x.call(e, f) || p && l.current)
+              return;
+            if (Z(f, L, e == null ? void 0 : e.preventDefault), !$(f, L, e == null ? void 0 : e.enabled)) {
+              D(f);
+              return;
+            }
+            h.current(f, L), p || (l.current = !0);
+          }
+        });
+      }
+    }, K = (f) => {
+      f.code !== void 0 && (T(k(f.code)), ((e == null ? void 0 : e.keydown) === void 0 && (e == null ? void 0 : e.keyup) !== !0 || e != null && e.keydown) && C(f));
+    }, y = (f) => {
+      f.code !== void 0 && (W(k(f.code)), l.current = !1, e != null && e.keyup && C(f, !0));
+    }, H = o.current || (c == null ? void 0 : c.document) || document;
+    return H.addEventListener("keyup", y, c == null ? void 0 : c.eventListenerOptions), H.addEventListener("keydown", K, c == null ? void 0 : c.eventListenerOptions), d && P(i, e == null ? void 0 : e.delimiter).forEach(
+      (f) => d.addHotkey(
+        b(f, e == null ? void 0 : e.splitKey, e == null ? void 0 : e.useKey, e == null ? void 0 : e.description)
+      )
+    ), () => {
+      H.removeEventListener("keyup", y, c == null ? void 0 : c.eventListenerOptions), H.removeEventListener("keydown", K, c == null ? void 0 : c.eventListenerOptions), d && P(i, e == null ? void 0 : e.delimiter).forEach(
+        (f) => d.removeHotkey(
+          b(f, e == null ? void 0 : e.splitKey, e == null ? void 0 : e.useKey, e == null ? void 0 : e.description)
+        )
+      );
+    };
+  }, [i, e, s]), o;
+}
+function le() {
+  const [t, r] = A(/* @__PURE__ */ new Set()), [n, a] = A(!1), o = w((u) => {
+    u.code !== void 0 && (u.preventDefault(), u.stopPropagation(), r((v) => {
+      const h = new Set(v);
+      return h.add(k(u.code)), h;
+    }));
+  }, []), l = w(() => {
+    typeof document < "u" && (document.removeEventListener("keydown", o), a(!1));
+  }, [o]), c = w(() => {
+    r(/* @__PURE__ */ new Set()), typeof document < "u" && (l(), document.addEventListener("keydown", o), a(!0));
+  }, [o, l]), i = w(() => {
+    r(/* @__PURE__ */ new Set());
+  }, []);
+  return [t, { start: c, stop: l, resetKeys: i, isRecording: n }];
+}
+export {
+  fe as HotkeysProvider,
+  Y as isHotkeyPressed,
+  se as useHotkeys,
+  ne as useHotkeysContext,
+  le as useRecordHotkeys
+};

package/{dist → packages/react-hotkeys-hook/dist}/isHotkeyPressed.d.ts

@@ -1,4 +1,4 @@
-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;
+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 → packages/react-hotkeys-hook/dist}/parseHotkeys.d.ts

@@ -1,5 +1,5 @@
-import { Hotkey } from './types';
-export declare function mapKey(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, useKey?: boolean, description?: string): Hotkey;
+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, useKey?: boolean, description?: string): Hotkey;

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

@@ -0,0 +1,45 @@
+import { DependencyList } from 'react';
+export type FormTags = 'input' | 'textarea' | 'select' | 'INPUT' | 'TEXTAREA' | 'SELECT';
+export type Keys = string | readonly string[];
+export type Scopes = string | readonly string[];
+export type RefType<T> = T | null;
+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;
+};
+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;
+};
+export type OptionsOrDependencyArray = Options | DependencyList;

package/{dist → packages/react-hotkeys-hook/dist}/useDeepEqualMemo.d.ts

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

package/{dist → packages/react-hotkeys-hook/dist}/useHotkeys.d.ts

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

package/{dist → packages/react-hotkeys-hook/dist}/useRecordHotkeys.d.ts

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

package/{dist → packages/react-hotkeys-hook/dist}/validators.d.ts

@@ -1,7 +1,8 @@
-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({ target }: KeyboardEvent, enabledOnTags?: readonly FormTags[] | boolean): boolean;
-export declare function isScopeActive(activeScopes: string[], scopes?: Scopes): boolean;
-export declare const isHotkeyMatchingKeyboardEvent: (e: KeyboardEvent, hotkey: Hotkey, ignoreModifiers?: boolean) => boolean;
+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;

package/dist/deepEqual.d.ts

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

package/dist/index.js

@@ -1,8 +0,0 @@
-
-'use strict'
-
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./react-hotkeys-hook.cjs.production.min.js')
-} else {
-  module.exports = require('./react-hotkeys-hook.cjs.development.js')
-}