react-hotkeys-hook 3.4.7 → 4.0.0-2

package/src/isHotkeyPressed.ts

@@ -0,0 +1,51 @@
+import { Hotkey } from './types'
+import { parseHotkey } from './parseHotkeys'
+import isEqual from 'lodash/isEqual'
+
+const currentlyPressedKeys: Set<Hotkey> = new Set<Hotkey>()
+
+export function isHotkeyPressed(key: string | string[], splitKey: string = ','): boolean {
+  const hotkeyArray = Array.isArray(key) ? key : key.split(splitKey)
+
+  return hotkeyArray.every((hotkey) => {
+    const parsedHotkey = parseHotkey(hotkey)
+
+    for (const pressedHotkey of currentlyPressedKeys) {
+      if (isEqual(parsedHotkey, pressedHotkey)) {
+        return true
+      }
+    }
+  })
+}
+
+export function pushToCurrentlyPressedKeys(key: string | string[]): void {
+  const hotkeyArray = Array.isArray(key) ? key : [key]
+
+  hotkeyArray.forEach(hotkey => currentlyPressedKeys.add(parseHotkey(hotkey)))
+}
+
+export function removeFromCurrentlyPressedKeys(key: string | string[]): void {
+  const hotkeyArray = Array.isArray(key) ? key : [key]
+
+  hotkeyArray.forEach((hotkey) => {
+    const parsedHotkey = parseHotkey(hotkey)
+
+    for (const pressedHotkey of currentlyPressedKeys) {
+      if (pressedHotkey.keys?.every((key) => parsedHotkey.keys?.includes(key))) {
+        currentlyPressedKeys.delete(pressedHotkey)
+      }
+    }
+  })
+}
+
+(() => {
+  window.addEventListener('DOMContentLoaded', () => {
+    document.addEventListener('keydown', e => {
+      pushToCurrentlyPressedKeys(e.key)
+    })
+
+    document.addEventListener('keyup', e => {
+      removeFromCurrentlyPressedKeys(e.key)
+    })
+  })
+})()

package/src/parseHotkeys.ts

@@ -0,0 +1,33 @@
+import { Hotkey, KeyboardModifiers, Keys } from './types'
+
+const reservedModifierKeywords = ['ctrl', 'shift', 'alt', 'meta', 'mod']
+
+export function parseKeysHookInput(keys: Keys, splitKey: string = ','): string[] {
+  if (typeof keys === 'string') {
+    return keys.split(splitKey)
+  }
+
+  return keys
+}
+
+export function parseHotkey(hotkey: string, combinationKey: string = '+'): Hotkey {
+  const keys = hotkey
+    .toLocaleLowerCase()
+    .split(combinationKey)
+    .map((k) => k.trim())
+
+  const modifiers: KeyboardModifiers = {
+    alt: keys.includes('alt'),
+    ctrl: keys.includes('ctrl'),
+    shift: keys.includes('shift'),
+    meta: keys.includes('meta'),
+    mod: keys.includes('mod'),
+  }
+
+  const singleCharKeys = keys.filter((k) => !reservedModifierKeywords.includes(k))
+
+  return {
+    ...modifiers,
+    keys: singleCharKeys,
+  }
+}

package/src/types.ts

@@ -0,0 +1,41 @@
+import type { DependencyList } from 'react'
+
+export type FormTags = 'input' | 'textarea' | 'select' | 'INPUT' | 'TEXTAREA' | 'SELECT'
+export type Keys = string | string[]
+export type Scopes = string | string[]
+
+export type RefType<T> = T | null
+
+export type KeyboardModifiers = {
+  alt?: boolean
+  ctrl?: boolean
+  meta?: boolean
+  shift?: boolean
+  mod?: boolean
+}
+
+export type Hotkey = KeyboardModifiers & {
+  keys?: string[]
+  scopes?: Scopes
+}
+
+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 // Main setting that determines if the hotkey is enabled or not. (Default: true)
+  enableOnFormTags?: FormTags[] | boolean // Enable hotkeys on a list of tags. (Default: false)
+  enableOnContentEditable?: boolean // Enable hotkeys on tags with contentEditable props. (Default: false)
+  combinationKey?: string // Character to split keys in hotkeys combinations. (Default: +)
+  splitKey?: string // Character to separate different hotkeys. (Default: ,)
+  scopes?: Scopes // Scope
+  keyup?: boolean // Trigger on keyup event? (Default: undefined)
+  keydown?: boolean // Trigger on keydown event? (Default: true)
+  preventDefault?: Trigger // Prevent default browser behavior? (Default: false)
+  description?: string // Use this option to describe what the hotkey does. (Default: undefined)
+}
+
+export type OptionsOrDependencyArray = Options | DependencyList

package/src/useHotkeys.ts

@@ -1,91 +1,113 @@
-import hotkeys, { HotkeysEvent, KeyHandler } from 'hotkeys-js';
-import React, { useCallback, useEffect, useRef } from 'react';
-
-type AvailableTags = 'INPUT' | 'TEXTAREA' | 'SELECT';
-
-// We implement our own custom filter system.
-hotkeys.filter = () => true;
-
-const tagFilter = ({ target }: KeyboardEvent, enableOnTags?: AvailableTags[]) => {
-  const targetTagName = target && (target as HTMLElement).tagName;
-
-  return Boolean((targetTagName && enableOnTags && enableOnTags.includes(targetTagName as AvailableTags)));
-};
-
-const isKeyboardEventTriggeredByInput = (ev: KeyboardEvent) => {
-  return tagFilter(ev, ['INPUT', 'TEXTAREA', 'SELECT']);
-};
-
-export type Options = {
-  enabled?: boolean; // Main setting that determines if the hotkey is enabled or not. (Default: true)
-  filter?: typeof hotkeys.filter; // A filter function returning whether the callback should get triggered or not. (Default: undefined)
-  filterPreventDefault?: boolean; // Prevent default browser behavior if the filter function returns false. (Default: true)
-  enableOnTags?: AvailableTags[]; // Enable hotkeys on a list of tags. (Default: [])
-  enableOnContentEditable?: boolean; // Enable hotkeys on tags with contentEditable props. (Default: false)
-  splitKey?: string; // Character to split keys in hotkeys combinations. (Default +)
-  scope?: string; // Scope. Currently not doing anything.
-  keyup?: boolean; // Trigger on keyup event? (Default: undefined)
-  keydown?: boolean; // Trigger on keydown event? (Default: true)
-};
-
-export function useHotkeys<T extends Element>(keys: string, callback: KeyHandler, options?: Options): React.MutableRefObject<T | null>;
-export function useHotkeys<T extends Element>(keys: string, callback: KeyHandler, deps?: any[]): React.MutableRefObject<T | null>;
-export function useHotkeys<T extends Element>(keys: string, callback: KeyHandler, options?: Options, deps?: any[]): React.MutableRefObject<T | null>;
-export function useHotkeys<T extends Element>(keys: string, callback: KeyHandler, options?: any[] | Options, deps?: any[]): React.MutableRefObject<T | null> {
-  if (options instanceof Array) {
-    deps = options;
-    options = undefined;
-  }
-
-  const {
-    enableOnTags,
-    filter,
-    keyup,
-    keydown,
-    filterPreventDefault = true,
-    enabled = true,
-    enableOnContentEditable = false,
-  } = options as Options || {};
-  const ref = useRef<T | null>(null);
-
-  // The return value of this callback determines if the browsers default behavior is prevented.
-  const memoisedCallback = useCallback((keyboardEvent: KeyboardEvent, hotkeysEvent: HotkeysEvent) => {
-    if (filter && !filter(keyboardEvent)) {
-      return !filterPreventDefault;
-    }
+import { HotkeyCallback, Keys, OptionsOrDependencyArray, RefType } from './types'
+import { useCallback, useLayoutEffect, useRef } from 'react'
+import { parseHotkey, parseKeysHookInput } from './parseHotkeys'
+import {
+  isHotkeyEnabled,
+  isHotkeyEnabledOnTag,
+  isHotkeyMatchingKeyboardEvent,
+  isKeyboardEventTriggeredByInput,
+  isScopeActive,
+  maybePreventDefault,
+} from './validators'
+import { useHotkeysContext } from './HotkeysProvider'
+import { useBoundHotkeysProxy } from './BoundHotkeysProxyProvider'
+
+const stopPropagation = (e: KeyboardEvent): void => {
+  e.stopPropagation()
+  e.preventDefault()
+  e.stopImmediatePropagation()
+}
+
+export default function useHotkeys<T extends HTMLElement>(
+  keys: Keys,
+  callback: HotkeyCallback,
+  options?: OptionsOrDependencyArray,
+  dependencies?: OptionsOrDependencyArray,
+) {
+  const ref = useRef<RefType<T>>(null)
+  const { current: pressedDownKeys } = useRef<Set<string>>(new Set())
+
+  const _options = !(options instanceof Array) ? options : !(dependencies instanceof Array) ? dependencies : undefined
+  const _deps = options instanceof Array ? options : dependencies instanceof Array ? dependencies : []
+
+  const cb = useCallback(callback, [..._deps])
+  const ctx = useHotkeysContext()
 
-    // 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 as HTMLElement)?.isContentEditable && !enableOnContentEditable)
-    ) {
-      return true;
+  const proxy = useBoundHotkeysProxy()
+
+  useLayoutEffect(() => {
+    if (_options?.enabled === false || !isScopeActive(ctx.activeScopes, _options?.scopes)) {
+      return
     }
 
-    if (ref.current === null || document.activeElement === ref.current || ref.current?.contains(document.activeElement)) {
-      callback(keyboardEvent, hotkeysEvent);
-      return true;
+    const listener = (e: KeyboardEvent) => {
+      if (isKeyboardEventTriggeredByInput(e) && !isHotkeyEnabledOnTag(e, _options?.enableOnFormTags)) {
+        return
+      }
+
+      if (ref.current !== null && document.activeElement !== ref.current && !ref.current.contains(document.activeElement)) {
+        stopPropagation(e)
+
+        return
+      }
+
+      if (((e.target as HTMLElement)?.isContentEditable && !_options?.enableOnContentEditable)) {
+        return
+      }
+
+      parseKeysHookInput(keys, _options?.splitKey).forEach((key) => {
+        const hotkey = parseHotkey(key, _options?.combinationKey)
+
+        if (isHotkeyMatchingKeyboardEvent(e, hotkey, pressedDownKeys) || hotkey.keys?.includes('*')) {
+          maybePreventDefault(e, hotkey, _options?.preventDefault)
+
+          if (!isHotkeyEnabled(e, hotkey, _options?.enabled)) {
+            stopPropagation(e)
+
+            return
+          }
+
+          cb(e, hotkey)
+        }
+      })
     }
 
-    return false;
-  }, deps ? [ref, enableOnTags, filter, ...deps] : [ref, enableOnTags, filter]);
+    const handleKeyDown = (event: KeyboardEvent) => {
+      pressedDownKeys.add(event.key.toLowerCase())
 
-  useEffect(() => {
-    if (!enabled) {
-      hotkeys.unbind(keys, memoisedCallback);
+      if ((_options?.keydown === undefined && _options?.keyup !== true) || _options?.keydown) {
+        listener(event)
+      }
+    }
+
+    const handleKeyUp = (event: KeyboardEvent) => {
+      pressedDownKeys.delete(event.key.toLowerCase())
 
-      return;
+      if (_options?.keyup) {
+        listener(event)
+      }
     }
 
-    // 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 as Options).keydown = false;
+    // @ts-ignore
+    (ref.current || document).addEventListener('keyup', handleKeyUp);
+    // @ts-ignore
+    (ref.current || document).addEventListener('keydown', handleKeyDown)
+
+    if (proxy) {
+      parseKeysHookInput(keys, _options?.splitKey).forEach((key) => proxy.addHotkey(parseHotkey(key, _options?.combinationKey)))
     }
 
-    hotkeys(keys, (options as Options) || {}, memoisedCallback);
+    return () => {
+      // @ts-ignore
+      (ref.current || document).removeEventListener('keyup', handleKeyUp);
+      // @ts-ignore
+      (ref.current || document).removeEventListener('keydown', handleKeyDown)
 
-    return () => hotkeys.unbind(keys, memoisedCallback);
-  }, [memoisedCallback, keys, enabled]);
+      if (proxy) {
+        parseKeysHookInput(keys, _options?.splitKey).forEach((key) => proxy.removeHotkey(parseHotkey(key, _options?.combinationKey)))
+      }
+    }
+  }, [keys, cb, _options])
 
-  return ref;
+  return ref
 }

package/src/validators.ts

@@ -0,0 +1,92 @@
+import { FormTags, Hotkey, Scopes, Trigger } from './types'
+
+export function maybePreventDefault(e: KeyboardEvent, hotkey: Hotkey, preventDefault?: Trigger): void {
+  if ((typeof preventDefault === 'function' && preventDefault(e, hotkey)) || preventDefault === true) {
+    e.preventDefault()
+  }
+}
+
+export function isHotkeyEnabled(e: KeyboardEvent, hotkey: Hotkey, enabled?: Trigger): boolean {
+  if (typeof enabled === 'function') {
+    return enabled(e, hotkey)
+  }
+
+  return enabled === true || enabled === undefined
+}
+
+export function isKeyboardEventTriggeredByInput(ev: KeyboardEvent): boolean {
+  return isHotkeyEnabledOnTag(ev, ['input', 'textarea', 'select'])
+}
+
+export function isHotkeyEnabledOnTag({ target }: KeyboardEvent, enabledOnTags: FormTags[] | boolean = false): boolean {
+  const targetTagName = target && (target as HTMLElement).tagName
+
+  if (enabledOnTags instanceof Array) {
+    return Boolean(targetTagName && enabledOnTags && enabledOnTags.some(tag => tag.toLowerCase() === targetTagName.toLowerCase()))
+  }
+
+  return Boolean(targetTagName && enabledOnTags && enabledOnTags === true)
+}
+
+export function isScopeActive(activeScopes: string[], scopes?: Scopes): boolean {
+  if (activeScopes.length === 0 && scopes) {
+    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>'
+    )
+
+    return true
+  }
+
+  if (!scopes) {
+    return true
+  }
+
+  return activeScopes.some(scope => scopes.includes(scope)) || activeScopes.includes('*')
+}
+
+export const isHotkeyMatchingKeyboardEvent = (e: KeyboardEvent, hotkey: Hotkey, pressedDownKeys: Set<string>): boolean => {
+  const { alt, ctrl, meta, mod, shift, keys } = hotkey
+  const { altKey, ctrlKey, metaKey, shiftKey, key: pressedKeyUppercase, code } = e
+
+  const keyCode = code.toLowerCase().replace('key', '')
+  const pressedKey = pressedKeyUppercase.toLowerCase()
+
+  if (altKey !== alt && pressedKey !== 'alt') {
+    return false
+  }
+
+  if (shiftKey !== shift && pressedKey !== 'shift') {
+    return false
+  }
+
+  // Mod is a special key name that is checking for meta on macOS and ctrl on other platforms
+  if (mod) {
+    if (!metaKey && !ctrlKey) {
+      return false
+    }
+  } else {
+    if (metaKey !== meta && keyCode !== 'meta') {
+      return false
+    }
+
+    if (ctrlKey !== ctrl && keyCode !== 'ctrl') {
+      return false
+    }
+  }
+
+  // All modifiers are correct, now check the key
+  // If the key is set we check for the key
+  if (keys && keys.length === 1 && (keys.includes(pressedKey) || keys.includes(keyCode))) {
+    return true
+  } else if (keys) {
+    // Check if all keys are present in pressedDownKeys set
+    return keys.every(key => pressedDownKeys.has(key))
+  }
+  else if (!keys) {
+    // If the key is not set, we only listen for modifiers, that check went alright, so we return true
+    return true
+  }
+
+  // There is nothing that matches.
+  return false
+}

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

@@ -1,93 +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');
-
-/**
- * @deprecated Use isHotkeyPressed instead. Will be removed version 4.
- */
-
-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, _ref$current;
-
-    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 || (_ref$current = ref.current) != null && _ref$current.contains(document.activeElement)) {
-      callback(keyboardEvent, hotkeysEvent);
-      return true;
-    }
-
-    return false;
-  }, deps ? [ref, enableOnTags, filter].concat(deps) : [ref, enableOnTags, filter]);
-  react.useEffect(function () {
-    if (!enabled) {
-      hotkeys.unbind(keys, memoisedCallback);
-      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, keys, enabled]);
-  return ref;
-}
-
-var isHotkeyPressed = hotkeys.isPressed;
-
-exports.isHotkeyPressed = isHotkeyPressed;
-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","../src/index.ts"],"sourcesContent":["import hotkeys from 'hotkeys-js';\n\n/**\n * @deprecated Use isHotkeyPressed instead. Will be removed version 4.\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 || ref.current?.contains(document.activeElement)) {\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      hotkeys.unbind(keys, memoisedCallback);\n\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, keys, enabled]);\n\n  return ref;\n}\n","import { useIsHotkeyPressed } from './useIsHotkeyPressed';\nimport { useHotkeys, Options } from './useHotkeys';\nimport hotkeys from 'hotkeys-js';\n\nconst isHotkeyPressed = hotkeys.isPressed;\n\nexport { useHotkeys, useIsHotkeyPressed, isHotkeyPressed, Options };"],"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","contains","useEffect","unbind","isHotkeyPressed"],"mappings":"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"}

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.isHotkeyPressed=t.isPressed,exports.useHotkeys=function(e,u,i,o){i instanceof Array&&(o=i,i=void 0);var s=i||{},a=s.enableOnTags,l=s.filter,c=s.keyup,d=s.keydown,f=s.filterPreventDefault,v=void 0===f||f,b=s.enabled,y=void 0===b||b,E=s.enableOnContentEditable,k=void 0!==E&&E,P=n.useRef(null),m=n.useCallback((function(e,t){var n,i;return l&&!l(e)?!v:!!(r(e,["INPUT","TEXTAREA","SELECT"])&&!r(e,a)||null!=(n=e.target)&&n.isContentEditable&&!k)||!!(null===P.current||document.activeElement===P.current||null!=(i=P.current)&&i.contains(document.activeElement))&&(u(e,t),!0)}),o?[P,a,l].concat(o):[P,a,l]);return n.useEffect((function(){if(y)return c&&!0!==d&&(i.keydown=!1),t(e,i||{},m),function(){return t.unbind(e,m)};t.unbind(e,m)}),[m,e,y]),P},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/index.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 || ref.current?.contains(document.activeElement)) {\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      hotkeys.unbind(keys, memoisedCallback);\n\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, keys, enabled]);\n\n  return ref;\n}\n","import { useIsHotkeyPressed } from './useIsHotkeyPressed';\nimport { useHotkeys, Options } from './useHotkeys';\nimport hotkeys from 'hotkeys-js';\n\nconst isHotkeyPressed = hotkeys.isPressed;\n\nexport { useHotkeys, useIsHotkeyPressed, isHotkeyPressed, Options };","import hotkeys from 'hotkeys-js';\n\n/**\n * @deprecated Use isHotkeyPressed instead. Will be removed version 4.\n */\nexport function useIsHotkeyPressed() {\n  return hotkeys.isPressed;\n}"],"names":["hotkeys","filter","tagFilter","enableOnTags","target","targetTagName","tagName","Boolean","includes","isPressed","keys","callback","options","deps","Array","undefined","keyup","keydown","filterPreventDefault","enabled","enableOnContentEditable","ref","useRef","memoisedCallback","useCallback","keyboardEvent","hotkeysEvent","isContentEditable","current","document","activeElement","_ref$current","contains","useEffect","unbind"],"mappings":"iHAMAA,EAAQC,OAAS,kBAAM,GAEvB,IAAMC,EAAY,WAA4BC,OAAzBC,IAAAA,OACbC,EAAgBD,GAAWA,EAAuBE,eAEjDC,QAASF,GAAiBF,GAAgBA,EAAaK,SAASH,6BCPjDL,EAAQS,6BD6BhC,SAA8CC,EAAcC,EAAsBC,EAA2BC,GACvGD,aAAmBE,QACrBD,EAAOD,EACPA,OAAUG,SAWRH,GAAsB,GAPxBT,IAAAA,aACAF,IAAAA,OACAe,IAAAA,MACAC,IAAAA,YACAC,qBAAAA,oBACAC,QAAAA,oBACAC,wBAAAA,gBAEIC,EAAMC,SAAiB,MAGvBC,EAAmBC,eAAY,SAACC,EAA8BC,kBAC9DzB,IAAWA,EAAOwB,IACZP,KAtCLhB,EA2C8BuB,EA3ChB,CAAC,QAAS,WAAY,aA2CavB,EAAUuB,EAAetB,aACxEsB,EAAcrB,WAAwBuB,oBAAsBP,OAK/C,OAAhBC,EAAIO,SAAoBC,SAASC,gBAAkBT,EAAIO,kBAAWP,EAAIO,UAAJG,EAAaC,SAASH,SAASC,kBACnGnB,EAASc,EAAeC,IACjB,KAIRb,GAAQQ,EAAKlB,EAAcF,UAAWY,GAAQ,CAACQ,EAAKlB,EAAcF,WAErEgC,aAAU,cACHd,SAODH,IAAqB,IAAZC,IACVL,EAAoBK,SAAU,GAGjCjB,EAAQU,EAAOE,GAAuB,GAAIW,GAEnC,kBAAMvB,EAAQkC,OAAOxB,EAAMa,IAZhCvB,EAAQkC,OAAOxB,EAAMa,KAatB,CAACA,EAAkBb,EAAMS,IAErBE,gDEnFArB,EAAQS"}

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

@@ -1,87 +0,0 @@
-import hotkeys from 'hotkeys-js';
-import { useRef, useCallback, useEffect } from 'react';
-
-/**
- * @deprecated Use isHotkeyPressed instead. Will be removed version 4.
- */
-
-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, _ref$current;
-
-    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 || (_ref$current = ref.current) != null && _ref$current.contains(document.activeElement)) {
-      callback(keyboardEvent, hotkeysEvent);
-      return true;
-    }
-
-    return false;
-  }, deps ? [ref, enableOnTags, filter].concat(deps) : [ref, enableOnTags, filter]);
-  useEffect(function () {
-    if (!enabled) {
-      hotkeys.unbind(keys, memoisedCallback);
-      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, keys, enabled]);
-  return ref;
-}
-
-var isHotkeyPressed = hotkeys.isPressed;
-
-export { isHotkeyPressed, 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","../src/index.ts"],"sourcesContent":["import hotkeys from 'hotkeys-js';\n\n/**\n * @deprecated Use isHotkeyPressed instead. Will be removed version 4.\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 || ref.current?.contains(document.activeElement)) {\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      hotkeys.unbind(keys, memoisedCallback);\n\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, keys, enabled]);\n\n  return ref;\n}\n","import { useIsHotkeyPressed } from './useIsHotkeyPressed';\nimport { useHotkeys, Options } from './useHotkeys';\nimport hotkeys from 'hotkeys-js';\n\nconst isHotkeyPressed = hotkeys.isPressed;\n\nexport { useHotkeys, useIsHotkeyPressed, isHotkeyPressed, Options };"],"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","contains","useEffect","unbind","isHotkeyPressed"],"mappings":"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"}