react-hotkeys-hook 3.4.5 → 3.4.6

package/dist/index.d.ts

@@ -1,4 +1,7 @@
-import useHotkeys from './useHotkeys';
-import type { Options } from './types';
-import { HotkeysProvider, useHotkeysContext } from './HotkeysProvider';
-export { useHotkeys, useHotkeysContext, HotkeysProvider, Options, };
+import { useIsHotkeyPressed } from './useIsHotkeyPressed';
+import { useHotkeys, Options } from './useHotkeys';
+declare const isHotkeyPressed: {
+    (keyCode: number): boolean;
+    (keyCode: string): boolean;
+};
+export { useHotkeys, useIsHotkeyPressed, isHotkeyPressed, Options };

package/dist/index.js

@@ -1,2 +1,8 @@
-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
+
+'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')
+}

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

@@ -0,0 +1,93 @@
+'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;
+
+    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) {
+      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

@@ -0,0 +1 @@
+{"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) {\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","useEffect","unbind","isHotkeyPressed"],"mappings":"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"}

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

@@ -0,0 +1,2 @@
+"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,k=s.enableOnContentEditable,E=void 0!==k&&k,P=n.useRef(null),p=n.useCallback((function(e,t){var n;return l&&!l(e)?!v:!!(r(e,["INPUT","TEXTAREA","SELECT"])&&!r(e,a)||null!=(n=e.target)&&n.isContentEditable&&!E)||(null===P.current||document.activeElement===P.current)&&(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||{},p),function(){return t.unbind(e,p)};t.unbind(e,p)}),[p,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

@@ -0,0 +1 @@
+{"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) {\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","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,gBAC9DzB,IAAWA,EAAOwB,IACZP,KAtCLhB,EA2C8BuB,EA3ChB,CAAC,QAAS,WAAY,aA2CavB,EAAUuB,EAAetB,aACxEsB,EAAcrB,WAAwBuB,oBAAsBP,KAK/C,OAAhBC,EAAIO,SAAoBC,SAASC,gBAAkBT,EAAIO,WACzDjB,EAASc,EAAeC,IACjB,KAIRb,GAAQQ,EAAKlB,EAAcF,UAAWY,GAAQ,CAACQ,EAAKlB,EAAcF,WAErE8B,aAAU,cACHZ,SAODH,IAAqB,IAAZC,IACVL,EAAoBK,SAAU,GAGjCjB,EAAQU,EAAOE,GAAuB,GAAIW,GAEnC,kBAAMvB,EAAQgC,OAAOtB,EAAMa,IAZhCvB,EAAQgC,OAAOtB,EAAMa,KAatB,CAACA,EAAkBb,EAAMS,IAErBE,gDEnFArB,EAAQS"}

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

@@ -0,0 +1,87 @@
+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;
+
+    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) {
+      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

@@ -0,0 +1 @@
+{"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) {\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","useEffect","unbind","isHotkeyPressed"],"mappings":"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"}

package/dist/useHotkeys.d.ts

@@ -1,2 +1,18 @@
-import { HotkeyCallback, Keys, OptionsOrDependencyArray, RefType } from './types';
-export default function useHotkeys<T extends HTMLElement>(keys: Keys, callback: HotkeyCallback, options?: OptionsOrDependencyArray, dependencies?: OptionsOrDependencyArray): import("react").MutableRefObject<RefType<T>>;
+import 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 {};

package/dist/useIsHotkeyPressed.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @deprecated Use isHotkeyPressed instead. Will be removed version 4.
+ */
+export declare function useIsHotkeyPressed(): {
+    (keyCode: number): boolean;
+    (keyCode: string): boolean;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-hotkeys-hook",
-  "version": "3.4.5",
+  "version": "3.4.6",
   "repository": "https://JohannesKlauss@github.com/JohannesKlauss/react-keymap-hook.git",
   "homepage": "https://johannesklauss.github.io/react-hotkeys-hook/",
   "author": "Johannes Klauss",

package/dist/HotkeysProvider.d.ts

@@ -1,16 +0,0 @@
-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.js.map

@@ -1,7 +0,0 @@
-{
-  "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

@@ -1,3 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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/validators.d.ts

@@ -1,7 +0,0 @@
-import { FormTags, Hotkey, Scopes, Trigger } from './types';
-export declare function maybePreventDefault(e: KeyboardEvent, hotkey: Hotkey, preventDefault?: Trigger): void;
-export declare function isHotkeyEnabled(e: KeyboardEvent, hotkey: Hotkey, enabled?: Trigger): boolean;
-export declare function isKeyboardEventTriggeredByInput(ev: KeyboardEvent): boolean;
-export declare function isHotkeyEnabledOnTag({ 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;