react-hotkeys-hook 3.4.2 → 3.4.5

package/README.md

@@ -1,6 +1,59 @@
-# react-hotkeys-hook
-React hook for using keyboard shortcuts in components.
-This is a hook version for the [hotkeys] package.
+<hr>
+<div align="center">
+  <h1 align="center">
+    useHotkeys(key, handler)
+  </h1>
+</div>
+
+<p align="center">
+  <a href="https://bundlephobia.com/result?p=react-hotkeys-hook">
+    <img alt="Bundlephobia" src="https://img.shields.io/bundlephobia/minzip/react-hotkeys-hook?style=for-the-badge&labelColor=24292e">
+  </a>
+  <a aria-label="Types" href="https://www.npmjs.com/package/react-hotkeys-hook">
+    <img alt="Types" src="https://img.shields.io/npm/types/react-use-system-color-mode?style=for-the-badge&labelColor=24292e">
+  </a>
+  <a aria-label="NPM version" href="https://www.npmjs.com/package/react-hotkeys-hook">
+    <img alt="NPM Version" src="https://img.shields.io/npm/v/react-hotkeys-hook?style=for-the-badge&labelColor=24292e">
+  </a>
+  <a aria-label="License" href="https://jaredlunde.mit-license.org/">
+    <img alt="MIT License" src="https://img.shields.io/npm/l/react-hotkeys-hook?style=for-the-badge&labelColor=24292e">
+  </a>
+</p>
+
+<p align="center">
+  <a aria-label="Sponsored by Spaceteams" href="https://spaceteams.de">
+    <img alt="Sponsored by Spaceteams" src="https://raw.githubusercontent.com/spaceteams/badges/main/sponsored-by-spaceteams.svg">
+  </a>
+</p>
+
+<pre align="center">npm i react-hotkeys-hook</pre>
+
+<p align="center">
+A React hook for using keyboard shortcuts in components.
+</p>
+
+<hr>
+
+## Quick Start
+
+```jsx harmony
+import { useHotkeys } from 'react-use-hotkeys-hook'
+
+export const ExampleComponent = () => {
+  const [count, setCount] = useState(0)
+  useHotkeys('ctrl+k', () => setCount(prevCount => prevCount + 1))
+
+  return (
+    <p>
+      Pressed {count} times.
+    </p>
+  )
+}
+```
+
+The hook takes care of all the binding and unbinding for you.
+As soon as the component mounts into the DOM, the key stroke will be
+listened to. When the component unmounts it will stop listening.
 
 ## Documentation & Live Examples
 
@@ -13,39 +66,9 @@ This is a hook version for the [hotkeys] package.
 If you use this package please share your thoughts on how we can improve this hook with version 4.
 Please engage at the corresponding [Github issue](https://github.com/JohannesKlauss/react-hotkeys-hook/issues/574).
 
-## Installation
-
-```shell
-npm install react-hotkeys-hook
-```
-
-or
+## API
 
-```shell
-yarn add react-hotkeys-hook
-```
-
-Make sure that you have at least version 16.8 of `react` and `react-dom` installed, or otherwise hooks won't work for you.
-
-## Usage
-```js
-export const ExampleComponent = () => {
-  const [count, setCount] = useState(0);
-  useHotkeys('ctrl+k', () => setCount(prevCount => prevCount + 1));
-    
-  return (
-    <p>
-      Pressed {count} times.
-    </p>
-  );
-};
-```
-
-The hook takes care of all the binding and unbinding for you.
-As soon as the component mounts into the DOM, the key stroke will be
-listened to. When the component unmounts it will stop listening.
-
-### Call Signature
+### useHotkeys()
 
 ```typescript
 useHotkeys(keys: string, callback: (event: KeyboardEvent, handler: HotkeysEvent) => void, options: Options = {}, deps: any[] = [])
@@ -53,11 +76,11 @@ useHotkeys(keys: string, callback: (event: KeyboardEvent, handler: HotkeysEvent)
 
 ### Parameters
 - `keys: string`: Here you can set the key strokes you want the hook to listen to. You can use single or multiple keys,
-modifier combination, etc. See [this](https://github.com/jaywcjlove/hotkeys/#defining-shortcuts)
-section on the hotkeys documentation for more info.
+  modifier combination, etc. See [this](https://github.com/jaywcjlove/hotkeys/#defining-shortcuts)
+  section on the hotkeys documentation for more info.
 - `callback: (event: KeyboardEvent, handler: HotkeysEvent) => void`: Gets executed when the defined keystroke
-gets hit by the user. **Important:** Since version 1.5.0 this callback gets memoised inside the hook. So you don't have
-to do this anymore by yourself.
+  gets hit by the user. **Important:** Since version 1.5.0 this callback gets memoised inside the hook. So you don't have
+  to do this anymore by yourself.
 - `options: Options = {}`
   - `filter: (event: KeyboardEvent): boolean` is used to filter if a callback gets triggered depending on the keyboard event.
     **Breaking Change in `3.0.0`!** Prior to version `3.0.0` the filter settings was one global setting that applied to every
@@ -70,20 +93,20 @@ to do this anymore by yourself.
   - `keydown: boolean` Determine if want to listen on the keydown event
   - `enabled: boolean` is used to prevent installation of the hotkey when set to false (default value: `true`)
 - `deps: any[] = []`: The dependency array that gets appended to the memoisation of the callback. Here you define the inner
-dependencies of your callback. If for example your callback actions depend on a referentially unstable value or a value
-that will change over time, you should add this value to your deps array. Since most of the time your callback won't
-depend on any unstable callbacks or changing values over time you can leave this value alone since it will be set to an
-empty array by default. See the [Memoisation](#memoisation) section to
-learn more and see an example where you have to set this array.
+  dependencies of your callback. If for example your callback actions depend on a referentially unstable value or a value
+  that will change over time, you should add this value to your deps array. Since most of the time your callback won't
+  depend on any unstable callbacks or changing values over time you can leave this value alone since it will be set to an
+  empty array by default. See the [Memoisation](#memoisation) section to
+  learn more and see an example where you have to set this array.
 
 ### `isHotkeyPressed` function
 
 This function allows us to check if the user is currently pressing down a key.
 
 ```ts
-import { isHotkeyPressed } from 'react-hotkeys-hook';
+import { isHotkeyPressed } from 'react-hotkeys-hook'
 
-isHotkeyPressed('return'); // Returns true if Return key is pressed down.
+isHotkeyPressed('return') // Returns true if Return key is pressed down.
 ```
 
 ## Support
@@ -91,10 +114,6 @@ isHotkeyPressed('return'); // Returns true if Return key is pressed down.
 * Ask your question in the [Github Discussions]([Support](https://github.com/JohannesKlauss/react-hotkeys-hook/discussions))
 * Ask your question on [StackOverflow](https://stackoverflow.com/search?page=1&tab=Relevance&q=react-hotkeys-hook)
 
-If you'd like to support me, please buy me a ko-fi:
-
-![alt text](https://ucbab0164bf5c81e2a9872c53fa1.previews.dropboxusercontent.com/p/thumb/ABTE4xGDxskgsqIuOARP8_ePPukYVVLKu8I7pKjNIf9u7aJmZcTeCXXCVyQsHkviVu_5aHZWlDRVoxO_o6gEDyTngS6wyWdoRdFqzANOEgUGj5ZcREIMy33x6DKDJkg1CORDq74mJPPBmkUnIph9OKWswrc2zY3sKeNBbBbbE2Xadfy78mWAQCtRXuvwrwV-mDjxsvxrcOZo73i-9J1u2p2QYjeP7jGPCqNnuavI-18SF65Kq6KFBEyhJQ1WtqJzmEWT92alq24aQlizVSt9w10_ouccdemRwhPaSLaFvyAETrFo9gGQe21ocMjTzT9tTb7ctWZBkIi6zVvy8EKfKsTE8nB7O3tbNd2_uQrVnd-kLg/p.png?fv_content=true&size_mode=5 "Buy me a Ko-Fi")
-
 ## Found an issue or have a feature request?
 
 Open up an [issue](https://github.com/JohannesKlauss/react-hotkeys-hook/issues/new)
@@ -104,9 +123,23 @@ or [pull request](https://github.com/JohannesKlauss/react-hotkeys-hook/compare)
 
 Checkout this repo, run `yarn` or `npm i` and then run the `test` script to test the behavior of the hook.
 
-## Authors
+## Contributing
+Contributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make are **greatly appreciated**.
+
+1. Fork the Project
+2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
+3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
+4. Push to the Branch (`git push origin feature/AmazingFeature`)
+5. Open a Pull Request
+
+## License
+Distributed under the MIT License. See `LICENSE` for more information.
+
+## Contact
+
+Johannes Klauss - [@JohannesKlauss](https://github.com/JohannesKlauss) - klauss.johannes@gmail.com
 
-* Johannes Klauss
+Project Link: [https://github.com/JohannesKlauss/react-hotkeys-hook](https://github.com/JohannesKlauss/react-use-system-color-mode)
 
 ## Contributors
 
@@ -118,11 +151,3 @@ Checkout this repo, run `yarn` or `npm i` and then run the `test` script to test
 * [godspeedelbow](https://github.com/godspeedelbow)
 * [JoshuaKGoldberg](https://github.com/JoshuaKGoldberg)
 * [ggascoigne](https://github.com/ggascoigne)
-
----
-
-MIT License.
-
----
-
-[hotkeys]: https://github.com/jaywcjlove/hotkeys

package/dist/HotkeysProvider.d.ts

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

package/dist/index.d.ts

@@ -1,3 +1,4 @@
-import { useIsHotkeyPressed } from './useIsHotkeyPressed';
-import { useHotkeys, Options } from './useHotkeys';
-export { useHotkeys, useIsHotkeyPressed, Options };
+import useHotkeys from './useHotkeys';
+import type { Options } from './types';
+import { HotkeysProvider, useHotkeysContext } from './HotkeysProvider';
+export { useHotkeys, useHotkeysContext, HotkeysProvider, Options, };

package/dist/index.js

@@ -1,8 +1,2 @@
-
-'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')
-}
+import{useCallback as R,useLayoutEffect as N,useRef as S}from"react";var A=["ctrl","shift","alt","meta","mod"];function H(t,o=","){return typeof t=="string"?t.split(o):t}function b(t,o="+"){let e=t.toLocaleLowerCase().split(o).map(a=>a.trim()),i={alt:e.includes("alt"),ctrl:e.includes("ctrl"),shift:e.includes("shift"),meta:e.includes("meta"),mod:e.includes("mod")},c=e.filter(a=>!A.includes(a));return{...i,keys:c}}function E(t,o,e){(typeof e=="function"&&e(t,o)||e===!0)&&t.preventDefault()}function K(t,o,e){return typeof e=="function"?e(t,o):e===!0||e===void 0}function h(t){return g(t,["INPUT","TEXTAREA","SELECT"])}function g({target:t},o){let e=t&&t.tagName;return Boolean(e&&o&&o.includes(e))}function T(t,o){return t.length===0&&o?(console.warn("A hotkey has a set scopes options, although no active scopes were found. If you want to use the global scopes feature, you need to wrap your app in a <HotkeysProvider>"),!0):o?t.some(e=>o.includes(e))||t.includes("*"):!0}var x=(t,o,e)=>{let{alt:i,ctrl:c,meta:a,mod:r,shift:d,keys:n}=o,{altKey:l,ctrlKey:u,metaKey:f,shiftKey:p,key:s,code:m}=t,y=m.toLowerCase().replace("key",""),k=s.toLowerCase();if(l!==i&&k!=="alt"||p!==d&&k!=="shift")return!1;if(r){if(!f&&!u)return!1}else if(f!==a&&y!=="meta"||u!==c&&y!=="ctrl")return!1;return n&&n.length===1&&(n.includes(k)||n.includes(y))?!0:n?n.every(L=>e.has(L)):!n};import{createContext as O,useMemo as M,useState as P,useContext as D}from"react";var C=O(void 0),v=()=>{let t=D(C);return t===void 0?{hotkeys:[],activeScopes:[],toggleScope:()=>{},activateScope:()=>{},deactivateScope:()=>{}}:t},I=({initialActiveScopes:t=["*"],children:o})=>{let[e,i]=P(t?.length>0?t:["*"]),c=M(()=>e.includes("*"),[e]),a=n=>{i(c?[n]:[...e,n])},r=n=>{let l=e.filter(u=>u!==n);l.length===0?i(["*"]):i(l)},d=n=>{e.includes(n)?r(n):a(n)};return React.createElement(C.Provider,{value:{activeScopes:e,hotkeys:[],activateScope:a,deactivateScope:r,toggleScope:d}},o)};function w(t,o,e,i){let c=S(null),{current:a}=S(new Set),r=e instanceof Array?i instanceof Array?void 0:i:e,d=e instanceof Array?e:i instanceof Array?i:[],n=R(o,[...d]),l=v();return N(()=>{if(r?.enabled===!1||!T(l.activeScopes,r?.scopes))return;let u=s=>{h(s)&&!g(s,r?.enableOnTags)||c.current!==null&&document.activeElement!==c.current||(console.log("isContentEditable",s.target?.isContentEditable),!(s.target?.isContentEditable&&!r?.enableOnContentEditable)&&H(t,r?.splitKey).forEach(m=>{let y=b(m,r?.combinationKey);if(x(s,y,a)||y.keys?.includes("*")){if(E(s,y,r?.preventDefault),!K(s,y,r?.enabled))return;n(s,y)}}))},f=s=>{a.add(s.key.toLowerCase()),(r?.keydown===void 0&&r?.keyup!==!0||r?.keydown)&&u(s)},p=s=>{r?.keyup&&u(s),a.delete(s.key.toLowerCase())};return document.addEventListener("keyup",p),document.addEventListener("keydown",f),()=>{document.removeEventListener("keyup",p),document.removeEventListener("keydown",f)}},[t,n,r]),c}export{I as HotkeysProvider,w as useHotkeys,v as useHotkeysContext};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/useHotkeys.ts", "../src/parseHotkeys.ts", "../src/validators.ts", "../src/HotkeysProvider.tsx"],
+  "sourcesContent": ["import { HotkeyCallback, Keys, OptionsOrDependencyArray, RefType } from './types'\nimport { useCallback, useLayoutEffect, useRef } from 'react'\nimport { parseHotkey, parseKeysHookInput } from './parseHotkeys'\nimport {\n  isHotkeyEnabled,\n  isHotkeyEnabledOnTag,\n  isHotkeyMatchingKeyboardEvent,\n  isKeyboardEventTriggeredByInput,\n  isScopeActive,\n  maybePreventDefault,\n} from './validators'\nimport { useHotkeysContext } from './HotkeysProvider'\n\nexport default function useHotkeys<T extends HTMLElement>(\n  keys: Keys,\n  callback: HotkeyCallback,\n  options?: OptionsOrDependencyArray,\n  dependencies?: OptionsOrDependencyArray\n) {\n  const ref = useRef<RefType<T>>(null)\n  const { current: pressedDownKeys } = useRef<Set<string>>(new Set())\n\n  const _options = !(options instanceof Array) ? options : !(dependencies instanceof Array) ? dependencies : undefined\n  const _deps = options instanceof Array ? options : dependencies instanceof Array ? dependencies : []\n\n  const cb = useCallback(callback, [..._deps])\n  const ctx = useHotkeysContext()\n\n  useLayoutEffect(() => {\n    if (_options?.enabled === false || !isScopeActive(ctx.activeScopes, _options?.scopes)) {\n      return\n    }\n\n    const listener = (e: KeyboardEvent) => {\n      if (isKeyboardEventTriggeredByInput(e) && !isHotkeyEnabledOnTag(e, _options?.enableOnTags)) {\n        return\n      }\n\n      if (ref.current !== null && document.activeElement !== ref.current) {\n        return\n      }\n\n      console.log('isContentEditable', ((e.target as HTMLElement)?.isContentEditable))\n\n      if (((e.target as HTMLElement)?.isContentEditable && !_options?.enableOnContentEditable)) {\n        return\n      }\n\n      parseKeysHookInput(keys, _options?.splitKey).forEach((key) => {\n        const hotkey = parseHotkey(key, _options?.combinationKey)\n\n        if (isHotkeyMatchingKeyboardEvent(e, hotkey, pressedDownKeys) || hotkey.keys?.includes('*')) {\n          maybePreventDefault(e, hotkey, _options?.preventDefault)\n\n          if (!isHotkeyEnabled(e, hotkey, _options?.enabled)) {\n            return\n          }\n\n          cb(e, hotkey)\n        }\n      })\n    }\n\n    const handleKeyDown = (event: KeyboardEvent) => {\n      pressedDownKeys.add(event.key.toLowerCase())\n\n      if ((_options?.keydown === undefined && _options?.keyup !== true) || _options?.keydown) {\n        listener(event)\n      }\n    }\n\n    const handleKeyUp = (event: KeyboardEvent) => {\n      if (_options?.keyup) {\n        listener(event)\n      }\n\n      pressedDownKeys.delete(event.key.toLowerCase())\n    }\n\n    document.addEventListener('keyup', handleKeyUp)\n    document.addEventListener('keydown', handleKeyDown)\n\n    return () => {\n      document.removeEventListener('keyup', handleKeyUp)\n      document.removeEventListener('keydown', handleKeyDown)\n    }\n  }, [keys, cb, _options])\n\n  return ref\n}\n", "import { Hotkey, KeyboardModifiers, Keys } from './types'\n\nconst reservedModifierKeywords = ['ctrl', 'shift', 'alt', 'meta', 'mod']\n\nexport function parseKeysHookInput(keys: Keys, splitKey: string = ','): string[] {\n  if (typeof keys === 'string') {\n    return keys.split(splitKey)\n  }\n\n  return keys\n}\n\nexport function parseHotkey(hotkey: string, combinationKey: string = '+'): Hotkey {\n  const keys = hotkey\n    .toLocaleLowerCase()\n    .split(combinationKey)\n    .map((k) => k.trim())\n\n  const modifiers: KeyboardModifiers = {\n    alt: keys.includes('alt'),\n    ctrl: keys.includes('ctrl'),\n    shift: keys.includes('shift'),\n    meta: keys.includes('meta'),\n    mod: keys.includes('mod'),\n  }\n\n  const singleCharKeys = keys.filter((k) => !reservedModifierKeywords.includes(k))\n\n  return {\n    ...modifiers,\n    keys: singleCharKeys,\n  }\n}\n", "import { FormTags, Hotkey, Scopes, Trigger } from './types'\n\nexport function maybePreventDefault(e: KeyboardEvent, hotkey: Hotkey, preventDefault?: Trigger): void {\n  if ((typeof preventDefault === 'function' && preventDefault(e, hotkey)) || preventDefault === true) {\n    e.preventDefault()\n  }\n}\n\nexport function isHotkeyEnabled(e: KeyboardEvent, hotkey: Hotkey, enabled?: Trigger): boolean {\n  if (typeof enabled === 'function') {\n    return enabled(e, hotkey)\n  }\n\n  return enabled === true || enabled === undefined\n}\n\nexport function isKeyboardEventTriggeredByInput(ev: KeyboardEvent): boolean {\n  return isHotkeyEnabledOnTag(ev, ['INPUT', 'TEXTAREA', 'SELECT'])\n}\n\nexport function isHotkeyEnabledOnTag({ target }: KeyboardEvent, enabledOnTags?: FormTags[]): boolean {\n  const targetTagName = target && (target as HTMLElement).tagName\n\n  return Boolean(targetTagName && enabledOnTags && enabledOnTags.includes(targetTagName as FormTags))\n}\n\nexport function isScopeActive(activeScopes: string[], scopes?: Scopes): boolean {\n  if (activeScopes.length === 0 && scopes) {\n    console.warn(\n      'A hotkey has a set scopes options, although no active scopes were found. If you want to use the global scopes feature, you need to wrap your app in a <HotkeysProvider>'\n    )\n\n    return true\n  }\n\n  if (!scopes) {\n    return true\n  }\n\n  return activeScopes.some(scope => scopes.includes(scope)) || activeScopes.includes('*')\n}\n\nexport const isHotkeyMatchingKeyboardEvent = (e: KeyboardEvent, hotkey: Hotkey, pressedDownKeys: Set<string>): boolean => {\n  const { alt, ctrl, meta, mod, shift, keys } = hotkey\n  const { altKey, ctrlKey, metaKey, shiftKey, key: pressedKeyUppercase, code } = e\n\n  const keyCode = code.toLowerCase().replace('key', '')\n  const pressedKey = pressedKeyUppercase.toLowerCase()\n\n  if (altKey !== alt && pressedKey !== 'alt') {\n    return false\n  }\n\n  if (shiftKey !== shift && pressedKey !== 'shift') {\n    return false\n  }\n\n  // Mod is a special key name that is checking for meta on macOS and ctrl on other platforms\n  if (mod) {\n    if (!metaKey && !ctrlKey) {\n      return false\n    }\n  } else {\n    if (metaKey !== meta && keyCode !== 'meta') {\n      return false\n    }\n\n    if (ctrlKey !== ctrl && keyCode !== 'ctrl') {\n      return false\n    }\n  }\n\n  // All modifiers are correct, now check the key\n  // If the key is set we check for the key\n  if (keys && keys.length === 1 && (keys.includes(pressedKey) || keys.includes(keyCode))) {\n    return true\n  } else if (keys) {\n    // Check if all keys are present in pressedDownKeys set\n    return keys.every(key => pressedDownKeys.has(key))\n  }\n  else if (!keys) {\n    // If the key is not set, we only listen for modifiers, that check went alright, so we return true\n    return true\n  }\n\n  // There is nothing that matches.\n  return false\n}\n", "import { Hotkey } from './types'\nimport { createContext, ReactNode, useMemo, useState, useContext } from 'react'\n\ntype HotkeysContextType = {\n  hotkeys: Hotkey[]\n  activeScopes: string[]\n  toggleScope: (scope: string) => void\n  activateScope: (scope: string) => void\n  deactivateScope: (scope: string) => void\n}\n\nconst HotkeysContext = createContext<HotkeysContextType | undefined>(undefined)\n\ninterface Props {\n  initialActiveScopes?: string[]\n  children: ReactNode\n}\n\nexport const useHotkeysContext = () => {\n  const context = useContext(HotkeysContext)\n\n  // The context is only needed for special features like global scoping, so we don't throw an error if it's not defined\n  if (context === undefined) {\n    return {\n      hotkeys: [],\n      activeScopes: [],\n      toggleScope: () => {},\n      activateScope: () => {},\n      deactivateScope: () => {},\n    }\n  }\n\n  return context\n}\n\nexport const HotkeysProvider = ({initialActiveScopes = ['*'], children}: Props) => {\n  const [activeScopes, setActiveScopes] = useState(initialActiveScopes?.length > 0 ? initialActiveScopes : ['*'])\n\n  const isAllActive = useMemo(() => activeScopes.includes('*'), [activeScopes])\n\n  const activateScope = (scope: string) => {\n    if (isAllActive) {\n      setActiveScopes([scope])\n    } else {\n      setActiveScopes([...activeScopes, scope])\n    }\n  }\n\n  const deactivateScope = (scope: string) => {\n    const scopes = activeScopes.filter(s => s !== scope)\n\n    if (scopes.length === 0) {\n      setActiveScopes(['*'])\n    } else {\n      setActiveScopes(scopes)\n    }\n  }\n\n  const toggleScope = (scope: string) => {\n    if (activeScopes.includes(scope)) {\n      deactivateScope(scope)\n    } else {\n      activateScope(scope)\n    }\n  }\n\n  return (\n    <HotkeysContext.Provider value={{activeScopes, hotkeys: [], activateScope, deactivateScope, toggleScope}}>\n      {children}\n    </HotkeysContext.Provider>\n  )\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/parseHotkeys.d.ts

@@ -0,0 +1,3 @@
+import { Hotkey, Keys } from './types';
+export declare function parseKeysHookInput(keys: Keys, splitKey?: string): string[];
+export declare function parseHotkey(hotkey: string, combinationKey?: string): Hotkey;

package/dist/types.d.ts

@@ -0,0 +1,32 @@
+import type { DependencyList } from 'react';
+export declare type FormTags = 'INPUT' | 'TEXTAREA' | 'SELECT';
+export declare type Keys = string | string[];
+export declare type Scopes = string | string[];
+export declare type RefType<T> = T | null;
+export declare type KeyboardModifiers = {
+    alt?: boolean;
+    ctrl?: boolean;
+    meta?: boolean;
+    shift?: boolean;
+    mod?: boolean;
+};
+export declare type Hotkey = KeyboardModifiers & {
+    keys?: string[];
+    scopes?: Scopes;
+};
+export declare type HotkeysEvent = Hotkey & {};
+export declare type HotkeyCallback = (keyboardEvent: KeyboardEvent, hotkeysEvent: HotkeysEvent) => void;
+export declare type Trigger = boolean | ((keyboardEvent: KeyboardEvent, hotkeysEvent: HotkeysEvent) => boolean);
+export declare type Options = {
+    enabled?: Trigger;
+    enableOnTags?: FormTags[];
+    enableOnContentEditable?: boolean;
+    combinationKey?: string;
+    splitKey?: string;
+    scopes?: Scopes;
+    keyup?: boolean;
+    keydown?: boolean;
+    preventDefault?: Trigger;
+    description?: string;
+};
+export declare type OptionsOrDependencyArray = Options | DependencyList;

package/dist/useHotkeys.d.ts

@@ -1,18 +1,2 @@
-import hotkeys, { KeyHandler } from 'hotkeys-js';
-import React from 'react';
-declare type AvailableTags = 'INPUT' | 'TEXTAREA' | 'SELECT';
-export declare type Options = {
-    enabled?: boolean;
-    filter?: typeof hotkeys.filter;
-    filterPreventDefault?: boolean;
-    enableOnTags?: AvailableTags[];
-    enableOnContentEditable?: boolean;
-    splitKey?: string;
-    scope?: string;
-    keyup?: boolean;
-    keydown?: boolean;
-};
-export declare function useHotkeys<T extends Element>(keys: string, callback: KeyHandler, options?: Options): React.MutableRefObject<T | null>;
-export declare function useHotkeys<T extends Element>(keys: string, callback: KeyHandler, deps?: any[]): React.MutableRefObject<T | null>;
-export declare function useHotkeys<T extends Element>(keys: string, callback: KeyHandler, options?: Options, deps?: any[]): React.MutableRefObject<T | null>;
-export {};
+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>>;

package/dist/validators.d.ts

@@ -0,0 +1,7 @@
+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?: FormTags[]): boolean;
+export declare function isScopeActive(activeScopes: string[], scopes?: Scopes): boolean;
+export declare const isHotkeyMatchingKeyboardEvent: (e: KeyboardEvent, hotkey: Hotkey, pressedDownKeys: Set<string>) => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-hotkeys-hook",
-  "version": "3.4.2",
+  "version": "3.4.5",
   "repository": "https://JohannesKlauss@github.com/JohannesKlauss/react-keymap-hook.git",
   "homepage": "https://johannesklauss.github.io/react-hotkeys-hook/",
   "author": "Johannes Klauss",
@@ -54,29 +54,29 @@
     "trailingComma": "es5"
   },
   "dependencies": {
-    "hotkeys-js": "3.8.7"
+    "hotkeys-js": "3.9.3"
   },
   "devDependencies": {
-    "@babel/core": "7.15.5",
-    "@babel/plugin-proposal-class-properties": "7.14.5",
-    "@babel/preset-env": "7.15.6",
-    "@babel/preset-react": "7.14.5",
-    "@babel/preset-typescript": "7.15.0",
-    "@testing-library/react": "12.1.0",
-    "@testing-library/react-hooks": "7.0.2",
-    "@testing-library/user-event": "13.2.1",
-    "@types/jest": "27.0.1",
-    "@types/react": "17.0.24",
-    "@types/react-dom": "17.0.9",
+    "@babel/core": "7.17.10",
+    "@babel/plugin-proposal-class-properties": "7.16.7",
+    "@babel/preset-env": "7.17.10",
+    "@babel/preset-react": "7.16.7",
+    "@babel/preset-typescript": "7.16.7",
+    "@testing-library/react": "13.2.0",
+    "@testing-library/react-hooks": "8.0.0",
+    "@testing-library/user-event": "13.5.0",
+    "@types/jest": "27.5.1",
+    "@types/react": "18.0.9",
+    "@types/react-dom": "18.0.3",
     "eslint-plugin-prettier": "4.0.0",
     "jest": "26.6.3",
-    "prettier": "2.4.1",
-    "react": "17.0.2",
-    "react-dom": "17.0.2",
-    "react-test-renderer": "17.0.2",
+    "prettier": "2.6.2",
+    "react": "18.1.0",
+    "react-dom": "18.1.0",
+    "react-test-renderer": "18.1.0",
     "tsdx": "0.14.1",
-    "tslib": "2.3.1",
-    "typescript": "4.4.3"
+    "tslib": "2.4.0",
+    "typescript": "4.6.4"
   },
   "peerDependencies": {
     "react": ">=16.8.1",

package/dist/react-hotkeys-hook.cjs.development.js

@@ -1,85 +0,0 @@
-'use strict';
-
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-var hotkeys = _interopDefault(require('hotkeys-js'));
-var react = require('react');
-
-function useIsHotkeyPressed() {
-  return hotkeys.isPressed;
-}
-
-hotkeys.filter = function () {
-  return true;
-};
-
-var tagFilter = function tagFilter(_ref, enableOnTags) {
-  var target = _ref.target;
-  var targetTagName = target && target.tagName;
-  return Boolean(targetTagName && enableOnTags && enableOnTags.includes(targetTagName));
-};
-
-var isKeyboardEventTriggeredByInput = function isKeyboardEventTriggeredByInput(ev) {
-  return tagFilter(ev, ['INPUT', 'TEXTAREA', 'SELECT']);
-};
-
-function useHotkeys(keys, callback, options, deps) {
-  if (options instanceof Array) {
-    deps = options;
-    options = undefined;
-  }
-
-  var _ref2 = options || {},
-      enableOnTags = _ref2.enableOnTags,
-      filter = _ref2.filter,
-      keyup = _ref2.keyup,
-      keydown = _ref2.keydown,
-      _ref2$filterPreventDe = _ref2.filterPreventDefault,
-      filterPreventDefault = _ref2$filterPreventDe === void 0 ? true : _ref2$filterPreventDe,
-      _ref2$enabled = _ref2.enabled,
-      enabled = _ref2$enabled === void 0 ? true : _ref2$enabled,
-      _ref2$enableOnContent = _ref2.enableOnContentEditable,
-      enableOnContentEditable = _ref2$enableOnContent === void 0 ? false : _ref2$enableOnContent;
-
-  var ref = react.useRef(null); // The return value of this callback determines if the browsers default behavior is prevented.
-
-  var memoisedCallback = react.useCallback(function (keyboardEvent, hotkeysEvent) {
-    var _keyboardEvent$target;
-
-    if (filter && !filter(keyboardEvent)) {
-      return !filterPreventDefault;
-    } // Check whether the hotkeys was triggered inside an input and that input is enabled or if it was triggered by a content editable tag and it is enabled.
-
-
-    if (isKeyboardEventTriggeredByInput(keyboardEvent) && !tagFilter(keyboardEvent, enableOnTags) || (_keyboardEvent$target = keyboardEvent.target) != null && _keyboardEvent$target.isContentEditable && !enableOnContentEditable) {
-      return true;
-    }
-
-    if (ref.current === null || document.activeElement === ref.current) {
-      callback(keyboardEvent, hotkeysEvent);
-      return true;
-    }
-
-    return false;
-  }, deps ? [ref, enableOnTags, filter].concat(deps) : [ref, enableOnTags, filter]);
-  react.useEffect(function () {
-    if (!enabled) {
-      return;
-    } // In this case keydown is likely undefined, so we set it to false, since hotkeys needs the `keydown` key to have a value.
-
-
-    if (keyup && keydown !== true) {
-      options.keydown = false;
-    }
-
-    hotkeys(keys, options || {}, memoisedCallback);
-    return function () {
-      return hotkeys.unbind(keys, memoisedCallback);
-    };
-  }, [memoisedCallback, options, keys, enabled]);
-  return ref;
-}
-
-exports.useHotkeys = useHotkeys;
-exports.useIsHotkeyPressed = useIsHotkeyPressed;
-//# sourceMappingURL=react-hotkeys-hook.cjs.development.js.map

package/dist/react-hotkeys-hook.cjs.development.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-hotkeys-hook.cjs.development.js","sources":["../src/useIsHotkeyPressed.ts","../src/useHotkeys.ts"],"sourcesContent":["import hotkeys from 'hotkeys-js';\n\nexport function useIsHotkeyPressed() {\n  return hotkeys.isPressed;\n}","import hotkeys, { HotkeysEvent, KeyHandler } from 'hotkeys-js';\nimport React, { useCallback, useEffect, useRef } from 'react';\n\ntype AvailableTags = 'INPUT' | 'TEXTAREA' | 'SELECT';\n\n// We implement our own custom filter system.\nhotkeys.filter = () => true;\n\nconst tagFilter = ({ target }: KeyboardEvent, enableOnTags?: AvailableTags[]) => {\n  const targetTagName = target && (target as HTMLElement).tagName;\n\n  return Boolean((targetTagName && enableOnTags && enableOnTags.includes(targetTagName as AvailableTags)));\n};\n\nconst isKeyboardEventTriggeredByInput = (ev: KeyboardEvent) => {\n  return tagFilter(ev, ['INPUT', 'TEXTAREA', 'SELECT']);\n};\n\nexport type Options = {\n  enabled?: boolean; // Main setting that determines if the hotkey is enabled or not. (Default: true)\n  filter?: typeof hotkeys.filter; // A filter function returning whether the callback should get triggered or not. (Default: undefined)\n  filterPreventDefault?: boolean; // Prevent default browser behavior if the filter function returns false. (Default: true)\n  enableOnTags?: AvailableTags[]; // Enable hotkeys on a list of tags. (Default: [])\n  enableOnContentEditable?: boolean; // Enable hotkeys on tags with contentEditable props. (Default: false)\n  splitKey?: string; // Character to split keys in hotkeys combinations. (Default +)\n  scope?: string; // Scope. Currently not doing anything.\n  keyup?: boolean; // Trigger on keyup event? (Default: undefined)\n  keydown?: boolean; // Trigger on keydown event? (Default: true)\n};\n\nexport function useHotkeys<T extends Element>(keys: string, callback: KeyHandler, options?: Options): React.MutableRefObject<T | null>;\nexport function useHotkeys<T extends Element>(keys: string, callback: KeyHandler, deps?: any[]): React.MutableRefObject<T | null>;\nexport function useHotkeys<T extends Element>(keys: string, callback: KeyHandler, options?: Options, deps?: any[]): React.MutableRefObject<T | null>;\nexport function useHotkeys<T extends Element>(keys: string, callback: KeyHandler, options?: any[] | Options, deps?: any[]): React.MutableRefObject<T | null> {\n  if (options instanceof Array) {\n    deps = options;\n    options = undefined;\n  }\n\n  const {\n    enableOnTags,\n    filter,\n    keyup,\n    keydown,\n    filterPreventDefault = true,\n    enabled = true,\n    enableOnContentEditable = false,\n  } = options as Options || {};\n  const ref = useRef<T | null>(null);\n\n  // The return value of this callback determines if the browsers default behavior is prevented.\n  const memoisedCallback = useCallback((keyboardEvent: KeyboardEvent, hotkeysEvent: HotkeysEvent) => {\n    if (filter && !filter(keyboardEvent)) {\n      return !filterPreventDefault;\n    }\n\n    // Check whether the hotkeys was triggered inside an input and that input is enabled or if it was triggered by a content editable tag and it is enabled.\n    if (\n      (isKeyboardEventTriggeredByInput(keyboardEvent) && !tagFilter(keyboardEvent, enableOnTags))\n      || ((keyboardEvent.target as HTMLElement)?.isContentEditable && !enableOnContentEditable)\n    ) {\n      return true;\n    }\n\n    if (ref.current === null || document.activeElement === ref.current) {\n      callback(keyboardEvent, hotkeysEvent);\n      return true;\n    }\n\n    return false;\n  }, deps ? [ref, enableOnTags, filter, ...deps] : [ref, enableOnTags, filter]);\n\n  useEffect(() => {\n    if (!enabled) {\n      return;\n    }\n\n    // In this case keydown is likely undefined, so we set it to false, since hotkeys needs the `keydown` key to have a value.\n    if (keyup && keydown !== true) {\n      (options as Options).keydown = false;\n    }\n\n    hotkeys(keys, (options as Options) || {}, memoisedCallback);\n\n    return () => hotkeys.unbind(keys, memoisedCallback);\n  }, [memoisedCallback, options, keys, enabled]);\n\n  return ref;\n}\n"],"names":["useIsHotkeyPressed","hotkeys","isPressed","filter","tagFilter","enableOnTags","target","targetTagName","tagName","Boolean","includes","isKeyboardEventTriggeredByInput","ev","useHotkeys","keys","callback","options","deps","Array","undefined","keyup","keydown","filterPreventDefault","enabled","enableOnContentEditable","ref","useRef","memoisedCallback","useCallback","keyboardEvent","hotkeysEvent","isContentEditable","current","document","activeElement","useEffect","unbind"],"mappings":";;;;;;;SAEgBA;AACd,SAAOC,OAAO,CAACC,SAAf;AACD;;ACEDD,OAAO,CAACE,MAAR,GAAiB;AAAA,SAAM,IAAN;AAAA,CAAjB;;AAEA,IAAMC,SAAS,GAAG,SAAZA,SAAY,OAA4BC,YAA5B;MAAGC,cAAAA;AACnB,MAAMC,aAAa,GAAGD,MAAM,IAAKA,MAAsB,CAACE,OAAxD;AAEA,SAAOC,OAAO,CAAEF,aAAa,IAAIF,YAAjB,IAAiCA,YAAY,CAACK,QAAb,CAAsBH,aAAtB,CAAnC,CAAd;AACD,CAJD;;AAMA,IAAMI,+BAA+B,GAAG,SAAlCA,+BAAkC,CAACC,EAAD;AACtC,SAAOR,SAAS,CAACQ,EAAD,EAAK,CAAC,OAAD,EAAU,UAAV,EAAsB,QAAtB,CAAL,CAAhB;AACD,CAFD;;AAmBA,SAAgBC,WAA8BC,MAAcC,UAAsBC,SAA2BC;AAC3G,MAAID,OAAO,YAAYE,KAAvB,EAA8B;AAC5BD,IAAAA,IAAI,GAAGD,OAAP;AACAA,IAAAA,OAAO,GAAGG,SAAV;AACD;;cAUGH,OAAkB,IAAI;MAPxBX,qBAAAA;MACAF,eAAAA;MACAiB,cAAAA;MACAC,gBAAAA;oCACAC;MAAAA,0DAAuB;4BACvBC;MAAAA,qCAAU;oCACVC;MAAAA,6DAA0B;;AAE5B,MAAMC,GAAG,GAAGC,YAAM,CAAW,IAAX,CAAlB;;AAGA,MAAMC,gBAAgB,GAAGC,iBAAW,CAAC,UAACC,aAAD,EAA+BC,YAA/B;;;AACnC,QAAI3B,MAAM,IAAI,CAACA,MAAM,CAAC0B,aAAD,CAArB,EAAsC;AACpC,aAAO,CAACP,oBAAR;AACD;;;AAGD,QACGX,+BAA+B,CAACkB,aAAD,CAA/B,IAAkD,CAACzB,SAAS,CAACyB,aAAD,EAAgBxB,YAAhB,CAA7D,IACK,yBAAAwB,aAAa,CAACvB,MAAd,mCAAsCyB,iBAAtC,IAA2D,CAACP,uBAFnE,EAGE;AACA,aAAO,IAAP;AACD;;AAED,QAAIC,GAAG,CAACO,OAAJ,KAAgB,IAAhB,IAAwBC,QAAQ,CAACC,aAAT,KAA2BT,GAAG,CAACO,OAA3D,EAAoE;AAClEjB,MAAAA,QAAQ,CAACc,aAAD,EAAgBC,YAAhB,CAAR;AACA,aAAO,IAAP;AACD;;AAED,WAAO,KAAP;AACD,GAnBmC,EAmBjCb,IAAI,IAAIQ,GAAJ,EAASpB,YAAT,EAAuBF,MAAvB,SAAkCc,IAAlC,IAA0C,CAACQ,GAAD,EAAMpB,YAAN,EAAoBF,MAApB,CAnBb,CAApC;AAqBAgC,EAAAA,eAAS,CAAC;AACR,QAAI,CAACZ,OAAL,EAAc;AACZ;AACD;;;AAGD,QAAIH,KAAK,IAAIC,OAAO,KAAK,IAAzB,EAA+B;AAC5BL,MAAAA,OAAmB,CAACK,OAApB,GAA8B,KAA9B;AACF;;AAEDpB,IAAAA,OAAO,CAACa,IAAD,EAAQE,OAAmB,IAAI,EAA/B,EAAmCW,gBAAnC,CAAP;AAEA,WAAO;AAAA,aAAM1B,OAAO,CAACmC,MAAR,CAAetB,IAAf,EAAqBa,gBAArB,CAAN;AAAA,KAAP;AACD,GAbQ,EAaN,CAACA,gBAAD,EAAmBX,OAAnB,EAA4BF,IAA5B,EAAkCS,OAAlC,CAbM,CAAT;AAeA,SAAOE,GAAP;AACD;;;;;"}

package/dist/react-hotkeys-hook.cjs.production.min.js

@@ -1,2 +0,0 @@
-"use strict";var e,t=(e=require("hotkeys-js"))&&"object"==typeof e&&"default"in e?e.default:e,n=require("react");t.filter=function(){return!0};var r=function(e,t){var n=e.target,r=n&&n.tagName;return Boolean(r&&t&&t.includes(r))};exports.useHotkeys=function(e,u,i,o){i instanceof Array&&(o=i,i=void 0);var a=i||{},l=a.enableOnTags,s=a.filter,c=a.keyup,f=a.keydown,d=a.filterPreventDefault,v=void 0===d||d,b=a.enabled,y=void 0===b||b,E=a.enableOnContentEditable,k=void 0!==E&&E,T=n.useRef(null),g=n.useCallback((function(e,t){var n;return s&&!s(e)?!v:!!(r(e,["INPUT","TEXTAREA","SELECT"])&&!r(e,l)||null!=(n=e.target)&&n.isContentEditable&&!k)||(null===T.current||document.activeElement===T.current)&&(u(e,t),!0)}),o?[T,l,s].concat(o):[T,l,s]);return n.useEffect((function(){if(y)return c&&!0!==f&&(i.keydown=!1),t(e,i||{},g),function(){return t.unbind(e,g)}}),[g,i,e,y]),T},exports.useIsHotkeyPressed=function(){return t.isPressed};
-//# sourceMappingURL=react-hotkeys-hook.cjs.production.min.js.map

package/dist/react-hotkeys-hook.cjs.production.min.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-hotkeys-hook.cjs.production.min.js","sources":["../src/useHotkeys.ts","../src/useIsHotkeyPressed.ts"],"sourcesContent":["import hotkeys, { HotkeysEvent, KeyHandler } from 'hotkeys-js';\nimport React, { useCallback, useEffect, useRef } from 'react';\n\ntype AvailableTags = 'INPUT' | 'TEXTAREA' | 'SELECT';\n\n// We implement our own custom filter system.\nhotkeys.filter = () => true;\n\nconst tagFilter = ({ target }: KeyboardEvent, enableOnTags?: AvailableTags[]) => {\n  const targetTagName = target && (target as HTMLElement).tagName;\n\n  return Boolean((targetTagName && enableOnTags && enableOnTags.includes(targetTagName as AvailableTags)));\n};\n\nconst isKeyboardEventTriggeredByInput = (ev: KeyboardEvent) => {\n  return tagFilter(ev, ['INPUT', 'TEXTAREA', 'SELECT']);\n};\n\nexport type Options = {\n  enabled?: boolean; // Main setting that determines if the hotkey is enabled or not. (Default: true)\n  filter?: typeof hotkeys.filter; // A filter function returning whether the callback should get triggered or not. (Default: undefined)\n  filterPreventDefault?: boolean; // Prevent default browser behavior if the filter function returns false. (Default: true)\n  enableOnTags?: AvailableTags[]; // Enable hotkeys on a list of tags. (Default: [])\n  enableOnContentEditable?: boolean; // Enable hotkeys on tags with contentEditable props. (Default: false)\n  splitKey?: string; // Character to split keys in hotkeys combinations. (Default +)\n  scope?: string; // Scope. Currently not doing anything.\n  keyup?: boolean; // Trigger on keyup event? (Default: undefined)\n  keydown?: boolean; // Trigger on keydown event? (Default: true)\n};\n\nexport function useHotkeys<T extends Element>(keys: string, callback: KeyHandler, options?: Options): React.MutableRefObject<T | null>;\nexport function useHotkeys<T extends Element>(keys: string, callback: KeyHandler, deps?: any[]): React.MutableRefObject<T | null>;\nexport function useHotkeys<T extends Element>(keys: string, callback: KeyHandler, options?: Options, deps?: any[]): React.MutableRefObject<T | null>;\nexport function useHotkeys<T extends Element>(keys: string, callback: KeyHandler, options?: any[] | Options, deps?: any[]): React.MutableRefObject<T | null> {\n  if (options instanceof Array) {\n    deps = options;\n    options = undefined;\n  }\n\n  const {\n    enableOnTags,\n    filter,\n    keyup,\n    keydown,\n    filterPreventDefault = true,\n    enabled = true,\n    enableOnContentEditable = false,\n  } = options as Options || {};\n  const ref = useRef<T | null>(null);\n\n  // The return value of this callback determines if the browsers default behavior is prevented.\n  const memoisedCallback = useCallback((keyboardEvent: KeyboardEvent, hotkeysEvent: HotkeysEvent) => {\n    if (filter && !filter(keyboardEvent)) {\n      return !filterPreventDefault;\n    }\n\n    // Check whether the hotkeys was triggered inside an input and that input is enabled or if it was triggered by a content editable tag and it is enabled.\n    if (\n      (isKeyboardEventTriggeredByInput(keyboardEvent) && !tagFilter(keyboardEvent, enableOnTags))\n      || ((keyboardEvent.target as HTMLElement)?.isContentEditable && !enableOnContentEditable)\n    ) {\n      return true;\n    }\n\n    if (ref.current === null || document.activeElement === ref.current) {\n      callback(keyboardEvent, hotkeysEvent);\n      return true;\n    }\n\n    return false;\n  }, deps ? [ref, enableOnTags, filter, ...deps] : [ref, enableOnTags, filter]);\n\n  useEffect(() => {\n    if (!enabled) {\n      return;\n    }\n\n    // In this case keydown is likely undefined, so we set it to false, since hotkeys needs the `keydown` key to have a value.\n    if (keyup && keydown !== true) {\n      (options as Options).keydown = false;\n    }\n\n    hotkeys(keys, (options as Options) || {}, memoisedCallback);\n\n    return () => hotkeys.unbind(keys, memoisedCallback);\n  }, [memoisedCallback, options, keys, enabled]);\n\n  return ref;\n}\n","import hotkeys from 'hotkeys-js';\n\nexport function useIsHotkeyPressed() {\n  return hotkeys.isPressed;\n}"],"names":["hotkeys","filter","tagFilter","enableOnTags","target","targetTagName","tagName","Boolean","includes","keys","callback","options","deps","Array","undefined","keyup","keydown","filterPreventDefault","enabled","enableOnContentEditable","ref","useRef","memoisedCallback","useCallback","keyboardEvent","hotkeysEvent","isContentEditable","current","document","activeElement","useEffect","unbind","isPressed"],"mappings":"iHAMAA,EAAQC,OAAS,kBAAM,GAEvB,IAAMC,EAAY,WAA4BC,OAAzBC,IAAAA,OACbC,EAAgBD,GAAWA,EAAuBE,eAEjDC,QAASF,GAAiBF,GAAgBA,EAAaK,SAASH,wBAsBzE,SAA8CI,EAAcC,EAAsBC,EAA2BC,GACvGD,aAAmBE,QACrBD,EAAOD,EACPA,OAAUG,SAWRH,GAAsB,GAPxBR,IAAAA,aACAF,IAAAA,OACAc,IAAAA,MACAC,IAAAA,YACAC,qBAAAA,oBACAC,QAAAA,oBACAC,wBAAAA,gBAEIC,EAAMC,SAAiB,MAGvBC,EAAmBC,eAAY,SAACC,EAA8BC,gBAC9DxB,IAAWA,EAAOuB,IACZP,KAtCLf,EA2C8BsB,EA3ChB,CAAC,QAAS,WAAY,aA2CatB,EAAUsB,EAAerB,aACxEqB,EAAcpB,WAAwBsB,oBAAsBP,KAK/C,OAAhBC,EAAIO,SAAoBC,SAASC,gBAAkBT,EAAIO,WACzDjB,EAASc,EAAeC,IACjB,KAIRb,GAAQQ,EAAKjB,EAAcF,UAAWW,GAAQ,CAACQ,EAAKjB,EAAcF,WAErE6B,aAAU,cACHZ,SAKDH,IAAqB,IAAZC,IACVL,EAAoBK,SAAU,GAGjChB,EAAQS,EAAOE,GAAuB,GAAIW,GAEnC,kBAAMtB,EAAQ+B,OAAOtB,EAAMa,MACjC,CAACA,EAAkBX,EAASF,EAAMS,IAE9BE,gDCpFApB,EAAQgC"}

package/dist/react-hotkeys-hook.esm.js

@@ -1,80 +0,0 @@
-import hotkeys from 'hotkeys-js';
-import { useRef, useCallback, useEffect } from 'react';
-
-function useIsHotkeyPressed() {
-  return hotkeys.isPressed;
-}
-
-hotkeys.filter = function () {
-  return true;
-};
-
-var tagFilter = function tagFilter(_ref, enableOnTags) {
-  var target = _ref.target;
-  var targetTagName = target && target.tagName;
-  return Boolean(targetTagName && enableOnTags && enableOnTags.includes(targetTagName));
-};
-
-var isKeyboardEventTriggeredByInput = function isKeyboardEventTriggeredByInput(ev) {
-  return tagFilter(ev, ['INPUT', 'TEXTAREA', 'SELECT']);
-};
-
-function useHotkeys(keys, callback, options, deps) {
-  if (options instanceof Array) {
-    deps = options;
-    options = undefined;
-  }
-
-  var _ref2 = options || {},
-      enableOnTags = _ref2.enableOnTags,
-      filter = _ref2.filter,
-      keyup = _ref2.keyup,
-      keydown = _ref2.keydown,
-      _ref2$filterPreventDe = _ref2.filterPreventDefault,
-      filterPreventDefault = _ref2$filterPreventDe === void 0 ? true : _ref2$filterPreventDe,
-      _ref2$enabled = _ref2.enabled,
-      enabled = _ref2$enabled === void 0 ? true : _ref2$enabled,
-      _ref2$enableOnContent = _ref2.enableOnContentEditable,
-      enableOnContentEditable = _ref2$enableOnContent === void 0 ? false : _ref2$enableOnContent;
-
-  var ref = useRef(null); // The return value of this callback determines if the browsers default behavior is prevented.
-
-  var memoisedCallback = useCallback(function (keyboardEvent, hotkeysEvent) {
-    var _keyboardEvent$target;
-
-    if (filter && !filter(keyboardEvent)) {
-      return !filterPreventDefault;
-    } // Check whether the hotkeys was triggered inside an input and that input is enabled or if it was triggered by a content editable tag and it is enabled.
-
-
-    if (isKeyboardEventTriggeredByInput(keyboardEvent) && !tagFilter(keyboardEvent, enableOnTags) || (_keyboardEvent$target = keyboardEvent.target) != null && _keyboardEvent$target.isContentEditable && !enableOnContentEditable) {
-      return true;
-    }
-
-    if (ref.current === null || document.activeElement === ref.current) {
-      callback(keyboardEvent, hotkeysEvent);
-      return true;
-    }
-
-    return false;
-  }, deps ? [ref, enableOnTags, filter].concat(deps) : [ref, enableOnTags, filter]);
-  useEffect(function () {
-    if (!enabled) {
-      return;
-    } // In this case keydown is likely undefined, so we set it to false, since hotkeys needs the `keydown` key to have a value.
-
-
-    if (keyup && keydown !== true) {
-      options.keydown = false;
-    }
-
-    hotkeys(keys, options || {}, memoisedCallback);
-    return function () {
-      return hotkeys.unbind(keys, memoisedCallback);
-    };
-  }, [memoisedCallback, options, keys, enabled]);
-  return ref;
-}
-
-export { useHotkeys, useIsHotkeyPressed };
-//# sourceMappingURL=react-hotkeys-hook.esm.js.map

package/dist/react-hotkeys-hook.esm.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-hotkeys-hook.esm.js","sources":["../src/useIsHotkeyPressed.ts","../src/useHotkeys.ts"],"sourcesContent":["import hotkeys from 'hotkeys-js';\n\nexport function useIsHotkeyPressed() {\n  return hotkeys.isPressed;\n}","import hotkeys, { HotkeysEvent, KeyHandler } from 'hotkeys-js';\nimport React, { useCallback, useEffect, useRef } from 'react';\n\ntype AvailableTags = 'INPUT' | 'TEXTAREA' | 'SELECT';\n\n// We implement our own custom filter system.\nhotkeys.filter = () => true;\n\nconst tagFilter = ({ target }: KeyboardEvent, enableOnTags?: AvailableTags[]) => {\n  const targetTagName = target && (target as HTMLElement).tagName;\n\n  return Boolean((targetTagName && enableOnTags && enableOnTags.includes(targetTagName as AvailableTags)));\n};\n\nconst isKeyboardEventTriggeredByInput = (ev: KeyboardEvent) => {\n  return tagFilter(ev, ['INPUT', 'TEXTAREA', 'SELECT']);\n};\n\nexport type Options = {\n  enabled?: boolean; // Main setting that determines if the hotkey is enabled or not. (Default: true)\n  filter?: typeof hotkeys.filter; // A filter function returning whether the callback should get triggered or not. (Default: undefined)\n  filterPreventDefault?: boolean; // Prevent default browser behavior if the filter function returns false. (Default: true)\n  enableOnTags?: AvailableTags[]; // Enable hotkeys on a list of tags. (Default: [])\n  enableOnContentEditable?: boolean; // Enable hotkeys on tags with contentEditable props. (Default: false)\n  splitKey?: string; // Character to split keys in hotkeys combinations. (Default +)\n  scope?: string; // Scope. Currently not doing anything.\n  keyup?: boolean; // Trigger on keyup event? (Default: undefined)\n  keydown?: boolean; // Trigger on keydown event? (Default: true)\n};\n\nexport function useHotkeys<T extends Element>(keys: string, callback: KeyHandler, options?: Options): React.MutableRefObject<T | null>;\nexport function useHotkeys<T extends Element>(keys: string, callback: KeyHandler, deps?: any[]): React.MutableRefObject<T | null>;\nexport function useHotkeys<T extends Element>(keys: string, callback: KeyHandler, options?: Options, deps?: any[]): React.MutableRefObject<T | null>;\nexport function useHotkeys<T extends Element>(keys: string, callback: KeyHandler, options?: any[] | Options, deps?: any[]): React.MutableRefObject<T | null> {\n  if (options instanceof Array) {\n    deps = options;\n    options = undefined;\n  }\n\n  const {\n    enableOnTags,\n    filter,\n    keyup,\n    keydown,\n    filterPreventDefault = true,\n    enabled = true,\n    enableOnContentEditable = false,\n  } = options as Options || {};\n  const ref = useRef<T | null>(null);\n\n  // The return value of this callback determines if the browsers default behavior is prevented.\n  const memoisedCallback = useCallback((keyboardEvent: KeyboardEvent, hotkeysEvent: HotkeysEvent) => {\n    if (filter && !filter(keyboardEvent)) {\n      return !filterPreventDefault;\n    }\n\n    // Check whether the hotkeys was triggered inside an input and that input is enabled or if it was triggered by a content editable tag and it is enabled.\n    if (\n      (isKeyboardEventTriggeredByInput(keyboardEvent) && !tagFilter(keyboardEvent, enableOnTags))\n      || ((keyboardEvent.target as HTMLElement)?.isContentEditable && !enableOnContentEditable)\n    ) {\n      return true;\n    }\n\n    if (ref.current === null || document.activeElement === ref.current) {\n      callback(keyboardEvent, hotkeysEvent);\n      return true;\n    }\n\n    return false;\n  }, deps ? [ref, enableOnTags, filter, ...deps] : [ref, enableOnTags, filter]);\n\n  useEffect(() => {\n    if (!enabled) {\n      return;\n    }\n\n    // In this case keydown is likely undefined, so we set it to false, since hotkeys needs the `keydown` key to have a value.\n    if (keyup && keydown !== true) {\n      (options as Options).keydown = false;\n    }\n\n    hotkeys(keys, (options as Options) || {}, memoisedCallback);\n\n    return () => hotkeys.unbind(keys, memoisedCallback);\n  }, [memoisedCallback, options, keys, enabled]);\n\n  return ref;\n}\n"],"names":["useIsHotkeyPressed","hotkeys","isPressed","filter","tagFilter","enableOnTags","target","targetTagName","tagName","Boolean","includes","isKeyboardEventTriggeredByInput","ev","useHotkeys","keys","callback","options","deps","Array","undefined","keyup","keydown","filterPreventDefault","enabled","enableOnContentEditable","ref","useRef","memoisedCallback","useCallback","keyboardEvent","hotkeysEvent","isContentEditable","current","document","activeElement","useEffect","unbind"],"mappings":";;;SAEgBA;AACd,SAAOC,OAAO,CAACC,SAAf;AACD;;ACEDD,OAAO,CAACE,MAAR,GAAiB;AAAA,SAAM,IAAN;AAAA,CAAjB;;AAEA,IAAMC,SAAS,GAAG,SAAZA,SAAY,OAA4BC,YAA5B;MAAGC,cAAAA;AACnB,MAAMC,aAAa,GAAGD,MAAM,IAAKA,MAAsB,CAACE,OAAxD;AAEA,SAAOC,OAAO,CAAEF,aAAa,IAAIF,YAAjB,IAAiCA,YAAY,CAACK,QAAb,CAAsBH,aAAtB,CAAnC,CAAd;AACD,CAJD;;AAMA,IAAMI,+BAA+B,GAAG,SAAlCA,+BAAkC,CAACC,EAAD;AACtC,SAAOR,SAAS,CAACQ,EAAD,EAAK,CAAC,OAAD,EAAU,UAAV,EAAsB,QAAtB,CAAL,CAAhB;AACD,CAFD;;AAmBA,SAAgBC,WAA8BC,MAAcC,UAAsBC,SAA2BC;AAC3G,MAAID,OAAO,YAAYE,KAAvB,EAA8B;AAC5BD,IAAAA,IAAI,GAAGD,OAAP;AACAA,IAAAA,OAAO,GAAGG,SAAV;AACD;;cAUGH,OAAkB,IAAI;MAPxBX,qBAAAA;MACAF,eAAAA;MACAiB,cAAAA;MACAC,gBAAAA;oCACAC;MAAAA,0DAAuB;4BACvBC;MAAAA,qCAAU;oCACVC;MAAAA,6DAA0B;;AAE5B,MAAMC,GAAG,GAAGC,MAAM,CAAW,IAAX,CAAlB;;AAGA,MAAMC,gBAAgB,GAAGC,WAAW,CAAC,UAACC,aAAD,EAA+BC,YAA/B;;;AACnC,QAAI3B,MAAM,IAAI,CAACA,MAAM,CAAC0B,aAAD,CAArB,EAAsC;AACpC,aAAO,CAACP,oBAAR;AACD;;;AAGD,QACGX,+BAA+B,CAACkB,aAAD,CAA/B,IAAkD,CAACzB,SAAS,CAACyB,aAAD,EAAgBxB,YAAhB,CAA7D,IACK,yBAAAwB,aAAa,CAACvB,MAAd,mCAAsCyB,iBAAtC,IAA2D,CAACP,uBAFnE,EAGE;AACA,aAAO,IAAP;AACD;;AAED,QAAIC,GAAG,CAACO,OAAJ,KAAgB,IAAhB,IAAwBC,QAAQ,CAACC,aAAT,KAA2BT,GAAG,CAACO,OAA3D,EAAoE;AAClEjB,MAAAA,QAAQ,CAACc,aAAD,EAAgBC,YAAhB,CAAR;AACA,aAAO,IAAP;AACD;;AAED,WAAO,KAAP;AACD,GAnBmC,EAmBjCb,IAAI,IAAIQ,GAAJ,EAASpB,YAAT,EAAuBF,MAAvB,SAAkCc,IAAlC,IAA0C,CAACQ,GAAD,EAAMpB,YAAN,EAAoBF,MAApB,CAnBb,CAApC;AAqBAgC,EAAAA,SAAS,CAAC;AACR,QAAI,CAACZ,OAAL,EAAc;AACZ;AACD;;;AAGD,QAAIH,KAAK,IAAIC,OAAO,KAAK,IAAzB,EAA+B;AAC5BL,MAAAA,OAAmB,CAACK,OAApB,GAA8B,KAA9B;AACF;;AAEDpB,IAAAA,OAAO,CAACa,IAAD,EAAQE,OAAmB,IAAI,EAA/B,EAAmCW,gBAAnC,CAAP;AAEA,WAAO;AAAA,aAAM1B,OAAO,CAACmC,MAAR,CAAetB,IAAf,EAAqBa,gBAArB,CAAN;AAAA,KAAP;AACD,GAbQ,EAaN,CAACA,gBAAD,EAAmBX,OAAnB,EAA4BF,IAA5B,EAAkCS,OAAlC,CAbM,CAAT;AAeA,SAAOE,GAAP;AACD;;;;"}

package/dist/useIsHotkeyPressed.d.ts

@@ -1,4 +0,0 @@
-export declare function useIsHotkeyPressed(): {
-    (keyCode: number): boolean;
-    (keyCode: string): boolean;
-};