@cxl/keyboard 0.0.1 → 0.1.0

package/README.md

@@ -2,11 +2,11 @@
 	
 [![npm version](https://badge.fury.io/js/%40cxl%2Fkeyboard.svg)](https://badge.fury.io/js/%40cxl%2Fkeyboard)
 
-Keybaard Handling Library
+Keyboard Handling Library
 
 ## Project Details
 
--   Branch Version: [0.0.1](https://npmjs.com/package/@cxl/keyboard/v/0.0.1)
+-   Branch Version: [0.1.0](https://npmjs.com/package/@cxl/keyboard/v/0.1.0)
 -   License: UNLICENSED
 -   Documentation: [Link](https://cxlio.github.io/cxl/keyboard)
 -   Report Issues: [Github](https://github.com/cxlio/cxl/issues)

package/amd/index.d.ts

@@ -0,0 +1,86 @@
+/// <amd-module name="@cxl/keyboard" />
+interface Key {
+    ctrlKey: boolean;
+    altKey: boolean;
+    shiftKey: boolean;
+    metaKey: boolean;
+    key: string;
+}
+/**
+ * The `KeyboardOptions` interface defines the configuration needed to handle keyboard interactions with
+ * a specific HTML element.
+ */
+export interface KeyboardOptions {
+    /**
+     * Specifies the HTML element on which keyboard events are captured.
+     * This element will receive focus and listen for key events.
+     */
+    element: HTMLElement;
+    /**
+     * A callback function that processes key events. It receives the current key being pressed
+     * and the sequence of keys accumulated so far. It returns `true` or `false` to indicate whether
+     * the sequence was consumed.
+     */
+    onKey: (key: string, sequence: string[]) => boolean;
+    /**
+     * The time in milliseconds to wait between key presses before resetting the sequence.
+     * Defaults to 250ms if not provided, ensuring thoughtful key sequences rather than accidental key presses.
+     */
+    delay?: number;
+    /**
+     * Optional parameter to specify a custom `KeyboardLayout`.
+     * Defaults to 'en-US' if not provided. This affects how key combinations and modifier keys are interpreted.
+     */
+    layout?: KeyboardLayout;
+    /**
+     * Boolean indicating whether to capture key events in the capture phase.
+     * This determines when the event listener reacts in the event propagation flow.
+     */
+    capture?: boolean;
+}
+export interface KeyboardLayout {
+    shiftedKeys: string[];
+    shiftMap: Record<string, string>;
+    modKey: 'metaKey' | 'ctrlKey';
+}
+export declare const KeyboardLayoutData: Record<string, KeyboardLayout>;
+/**
+ * The `handleKeyboard` function sets up event listeners to handle keyboard events on a given HTML element.
+ * It accepts a  configuration object (`KeyboardOptions`) which includes the target HTML element, a callback
+ * `onKey` to handle keyboard sequences, a `delay` for typing sequence recognition, an optional keyboard
+ * layout, and an optional capture mode for events.
+ *
+ * - Defaults the delay to 250ms if not specified, using this delay to determine when to treat subsequent
+ *   key presses as part of the same sequence or a new one.
+ * - Determines the keyboard layout, either from the provided options or defaults, which affects how keys
+ *   (especially with modifiers) are interpreted.
+ * - Adds a `keydown` event listener to the provided element, allowing modification of event behavior such
+ *   as propagation and default handling based on the `onKey` callback result.
+ * - Builds a key sequence based on timing and calls the `onKey` handler with the assembled sequence,
+ *   stopping event propagation based on handler response.
+ * - The handler uses the sequence to manage shortcuts and performs preventative measures against default
+ *   browser actions.
+ * @return A cleanup function that removes the event listener.
+ */
+export declare function handleKeyboard({ element, onKey, delay, layout, capture, }: KeyboardOptions): () => void;
+/**
+ * This function, `parseKey`, takes a key combination string and splits it into a sequence of `Key` objects.
+ * It uses regular  expressions to identify each part of the key combination, accounting for modifier keys
+ * like 'shift', 'ctrl', 'alt', 'meta', and 'mod', the latter being dependent on the `modKey` from the
+ * `KeyboardLayout` (either 'ctrlKey' or 'metaKey' depending on the platform). For non-modifier keys, it
+ * checks if the `shiftKey` is active and if the key should be shifted using the `shiftMap`. This logic
+ * ensures the function captures accurate key state details in preparation for further handling like matching
+ * key sequences in the `handleKeyboard` function.
+ */
+export declare function parseKey(key: string, { modKey, shiftedKeys, shiftMap }?: KeyboardLayout): Key[];
+/**
+ * Converts a string representing a key combination into a normalized string format.
+ * This function takes a `key` string and an optional `layout` object (defaults to the user's layout).
+ * It uses `parseKey` to break the key combination into individual `Key` objects, each representing
+ * a parsed key press. It then converts each `Key` object back to a string using `keyboardEventToString`,
+ * considering the layout's details like `shiftedKeys` and `shiftMap`. The resulting
+ * strings are concatenated with spaces and returned as the normalized form. This is useful
+ * for ensuring consistent representation of key sequences across different keyboard layouts.
+ */
+export declare function normalize(key: string, layout?: KeyboardLayout): string;
+export {};

package/amd/index.js

@@ -0,0 +1 @@
+define("@cxl/keyboard",["require","exports"],(function(e,t){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.KeyboardLayoutData=void 0,t.handleKeyboard=function({element:e,onKey:a,delay:n,layout:r,capture:s}){const y=void 0===n?250:n,l=o.language;let c=[],f=0;const d=r||t.KeyboardLayoutData[l]||t.KeyboardLayoutData["en-US"];function u(e){const t=i(e,d);let o=Date.now();if(!t)return;o-f<y?c.push(t):c=[t];const n=c.slice(0);do{if(!1!==a(n.join(" "),c)){e.stopPropagation(),e.preventDefault(),o=0;break}n.shift()}while(n.length);f=o}return e.addEventListener("keydown",u,{capture:s}),()=>e.removeEventListener("keydown",u,{capture:s})},t.parseKey=y,t.normalize=function(e,t=s()){return y(e,t).map((e=>i(e,t))).join(" ")};const o="undefined"!=typeof window?window.navigator:{language:"en-US",platform:"nodejs"},a=/(shift|ctrl|control|alt|option|meta|command|cmd|mod|[^\s+]+)(\s*\+|\s)?/g,n={"/":"?",".":">",",":"<","'":'"',";":":","[":"{","]":"}","\\":"|","`":"~","=":"+","-":"_",1:"!",2:"@",3:"#",4:"$",5:"%",6:"^",7:"&",8:"*",9:"(",0:")"};t.KeyboardLayoutData={"en-US":{shiftedKeys:Object.values(n),shiftMap:n,modKey:/Mac|iPod|iPhone|iPad/.test(o.platform)?"metaKey":"ctrlKey"}};const r={ArrowUp:"up",ArrowDown:"down",ArrowLeft:"left",ArrowRight:"right",Escape:"esc"," ":"space"};function i(e,{shiftedKeys:t}){const o=e.key;if(!o||"Shift"===o||"Alt"===o||"Meta"===o||"Control"===o)return"";const a=r[o]||o.toLowerCase();let n;return e.ctrlKey&&(n="ctrl"),e.altKey&&(n=n?n+"+alt":"alt"),e.shiftKey&&!t.includes(a)&&(n=n?n+"+shift":"shift"),e.metaKey&&(n=n?n+"+meta":"meta"),n?n+"+"+a:a}function s(){return t.KeyboardLayoutData[o?.language]||t.KeyboardLayoutData["en-US"]}function y(e,{modKey:t,shiftedKeys:o,shiftMap:n}=s()){const r=[];let i,y={ctrlKey:!1,shiftKey:!1,metaKey:!1,altKey:!1,key:""};for(;i=a.exec(e.toLowerCase());){const e=i[1];if("shift"===e)y.shiftKey=!0;else if("ctrl"===e||"control"===e)y.ctrlKey=!0;else if("alt"===e||"option"===e)y.altKey=!0;else if("meta"===e||"cmd"===e||"command"===e)y.metaKey=!0;else if("mod"===e)y[t]=!0;else if(y.key=e,y.shiftKey)if(o.includes(e))y.shiftKey=!1;else{const t=n[e];t&&(y.key=t,y.shiftKey=!1)}"+"!==i[2]&&(r.push(y),y={ctrlKey:!1,shiftKey:!1,metaKey:!1,altKey:!1,key:""})}return r}}));

package/index.d.ts

@@ -1,26 +1,86 @@
 /// <amd-module name="@cxl/keyboard" />
-export declare type KeyNameMap = Record<number, string>;
-export interface Key {
+interface Key {
     ctrlKey: boolean;
     altKey: boolean;
     shiftKey: boolean;
     metaKey: boolean;
     key: string;
 }
+/**
+ * The `KeyboardOptions` interface defines the configuration needed to handle keyboard interactions with
+ * a specific HTML element.
+ */
 export interface KeyboardOptions {
+    /**
+     * Specifies the HTML element on which keyboard events are captured.
+     * This element will receive focus and listen for key events.
+     */
     element: HTMLElement;
+    /**
+     * A callback function that processes key events. It receives the current key being pressed
+     * and the sequence of keys accumulated so far. It returns `true` or `false` to indicate whether
+     * the sequence was consumed.
+     */
     onKey: (key: string, sequence: string[]) => boolean;
+    /**
+     * The time in milliseconds to wait between key presses before resetting the sequence.
+     * Defaults to 250ms if not provided, ensuring thoughtful key sequences rather than accidental key presses.
+     */
     delay?: number;
+    /**
+     * Optional parameter to specify a custom `KeyboardLayout`.
+     * Defaults to 'en-US' if not provided. This affects how key combinations and modifier keys are interpreted.
+     */
     layout?: KeyboardLayout;
+    /**
+     * Boolean indicating whether to capture key events in the capture phase.
+     * This determines when the event listener reacts in the event propagation flow.
+     */
+    capture?: boolean;
 }
 export interface KeyboardLayout {
     shiftedKeys: string[];
     shiftMap: Record<string, string>;
     modKey: 'metaKey' | 'ctrlKey';
 }
-export declare const Pass: {};
-export declare const TranslateKey: Record<string, string>;
-export declare function handleKeyboard({ element, onKey, delay, layout, }: KeyboardOptions): () => void;
-export declare function getDefaultLayout(): KeyboardLayout;
-export declare function parseKey(key: string, { modKey, shiftMap }?: KeyboardLayout): Key[];
+export declare const KeyboardLayoutData: Record<string, KeyboardLayout>;
+/**
+ * The `handleKeyboard` function sets up event listeners to handle keyboard events on a given HTML element.
+ * It accepts a  configuration object (`KeyboardOptions`) which includes the target HTML element, a callback
+ * `onKey` to handle keyboard sequences, a `delay` for typing sequence recognition, an optional keyboard
+ * layout, and an optional capture mode for events.
+ *
+ * - Defaults the delay to 250ms if not specified, using this delay to determine when to treat subsequent
+ *   key presses as part of the same sequence or a new one.
+ * - Determines the keyboard layout, either from the provided options or defaults, which affects how keys
+ *   (especially with modifiers) are interpreted.
+ * - Adds a `keydown` event listener to the provided element, allowing modification of event behavior such
+ *   as propagation and default handling based on the `onKey` callback result.
+ * - Builds a key sequence based on timing and calls the `onKey` handler with the assembled sequence,
+ *   stopping event propagation based on handler response.
+ * - The handler uses the sequence to manage shortcuts and performs preventative measures against default
+ *   browser actions.
+ * @return A cleanup function that removes the event listener.
+ */
+export declare function handleKeyboard({ element, onKey, delay, layout, capture, }: KeyboardOptions): () => void;
+/**
+ * This function, `parseKey`, takes a key combination string and splits it into a sequence of `Key` objects.
+ * It uses regular  expressions to identify each part of the key combination, accounting for modifier keys
+ * like 'shift', 'ctrl', 'alt', 'meta', and 'mod', the latter being dependent on the `modKey` from the
+ * `KeyboardLayout` (either 'ctrlKey' or 'metaKey' depending on the platform). For non-modifier keys, it
+ * checks if the `shiftKey` is active and if the key should be shifted using the `shiftMap`. This logic
+ * ensures the function captures accurate key state details in preparation for further handling like matching
+ * key sequences in the `handleKeyboard` function.
+ */
+export declare function parseKey(key: string, { modKey, shiftedKeys, shiftMap }?: KeyboardLayout): Key[];
+/**
+ * Converts a string representing a key combination into a normalized string format.
+ * This function takes a `key` string and an optional `layout` object (defaults to the user's layout).
+ * It uses `parseKey` to break the key combination into individual `Key` objects, each representing
+ * a parsed key press. It then converts each `Key` object back to a string using `keyboardEventToString`,
+ * considering the layout's details like `shiftedKeys` and `shiftMap`. The resulting
+ * strings are concatenated with spaces and returned as the normalized form. This is useful
+ * for ensuring consistent representation of key sequences across different keyboard layouts.
+ */
 export declare function normalize(key: string, layout?: KeyboardLayout): string;
+export {};

package/index.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalize = exports.parseKey = exports.getDefaultLayout = exports.handleKeyboard = exports.TranslateKey = exports.Pass = void 0;
-exports.Pass = {};
+exports.KeyboardLayoutData = void 0;
+exports.handleKeyboard = handleKeyboard;
+exports.parseKey = parseKey;
+exports.normalize = normalize;
+///<amd-module name="@cxl/keyboard"/>
 const navigator = typeof window !== 'undefined'
     ? window.navigator
     : { language: 'en-US', platform: 'nodejs' };
 const IS_MAC = /Mac|iPod|iPhone|iPad/;
-const PARSE_KEY = /(shift|ctrl|control|alt|option|meta|command|cmd|mod|\w+)(\s*\+|\s)?/g;
+const PARSE_KEY = /(shift|ctrl|control|alt|option|meta|command|cmd|mod|[^\s+]+)(\s*\+|\s)?/g;
 const SHIFT_MAP = {
     '/': '?',
     '.': '>',
@@ -30,24 +33,29 @@ const SHIFT_MAP = {
     '9': '(',
     '0': ')',
 };
-const KeyboardLayoutData = {
+exports.KeyboardLayoutData = {
     'en-US': {
         shiftedKeys: Object.values(SHIFT_MAP),
         shiftMap: SHIFT_MAP,
         modKey: IS_MAC.test(navigator.platform) ? 'metaKey' : 'ctrlKey',
     },
 };
-exports.TranslateKey = {
-    Shift: '',
-    Alt: '',
-    Meta: '',
-    Control: '',
+const TranslateKey = {
     ArrowUp: 'up',
     ArrowDown: 'down',
     ArrowLeft: 'left',
     ArrowRight: 'right',
     Escape: 'esc',
+    ' ': 'space',
 };
+/**
+ * This function converts a `Key` event into a string representation, encoding modifier keys
+ * (ctrl, alt, shift, meta) and the key itself. It checks each modifier key flag in the `Key`
+ * object, constructing a result string with '+' separators. Non-modifier keys are lowercased
+ * and looked up in `TranslateKey` for a more readable name. If the key itself is a shifted
+ * character (not included in `shiftedKeys`), 'shift' is added to the modifiers. This string
+ * format is useful for handling complex keyboard shortcuts consistently across different layouts.
+ */
 function keyboardEventToString(ev, { shiftedKeys }) {
     const key = ev.key;
     if (!key ||
@@ -56,7 +64,7 @@ function keyboardEventToString(ev, { shiftedKeys }) {
         key === 'Meta' ||
         key === 'Control')
         return '';
-    const ch = exports.TranslateKey[key] || key.toLowerCase();
+    const ch = TranslateKey[key] || key.toLowerCase();
     let result;
     if (ev.ctrlKey)
         result = 'ctrl';
@@ -68,12 +76,30 @@ function keyboardEventToString(ev, { shiftedKeys }) {
         result = result ? result + '+meta' : 'meta';
     return result ? result + '+' + ch : ch;
 }
-function handleKeyboard({ element, onKey, delay, layout, }) {
+/**
+ * The `handleKeyboard` function sets up event listeners to handle keyboard events on a given HTML element.
+ * It accepts a  configuration object (`KeyboardOptions`) which includes the target HTML element, a callback
+ * `onKey` to handle keyboard sequences, a `delay` for typing sequence recognition, an optional keyboard
+ * layout, and an optional capture mode for events.
+ *
+ * - Defaults the delay to 250ms if not specified, using this delay to determine when to treat subsequent
+ *   key presses as part of the same sequence or a new one.
+ * - Determines the keyboard layout, either from the provided options or defaults, which affects how keys
+ *   (especially with modifiers) are interpreted.
+ * - Adds a `keydown` event listener to the provided element, allowing modification of event behavior such
+ *   as propagation and default handling based on the `onKey` callback result.
+ * - Builds a key sequence based on timing and calls the `onKey` handler with the assembled sequence,
+ *   stopping event propagation based on handler response.
+ * - The handler uses the sequence to manage shortcuts and performs preventative measures against default
+ *   browser actions.
+ * @return A cleanup function that removes the event listener.
+ */
+function handleKeyboard({ element, onKey, delay, layout, capture, }) {
     const D = delay === undefined ? 250 : delay;
     const locale = navigator.language;
     let sequence = [];
     let lastT = 0;
-    const newLayout = layout || KeyboardLayoutData[locale] || KeyboardLayoutData['en-US'];
+    const newLayout = layout || exports.KeyboardLayoutData[locale] || exports.KeyboardLayoutData['en-US'];
     function handler(ev) {
         const k = keyboardEventToString(ev, newLayout);
         let t = Date.now();
@@ -95,14 +121,12 @@ function handleKeyboard({ element, onKey, delay, layout, }) {
         } while (seq.length);
         lastT = t;
     }
-    element.addEventListener('keydown', handler);
-    return () => element.removeEventListener('keydown', handler);
+    element.addEventListener('keydown', handler, { capture });
+    return () => element.removeEventListener('keydown', handler, { capture });
 }
-exports.handleKeyboard = handleKeyboard;
 function getDefaultLayout() {
-    return (KeyboardLayoutData[navigator === null || navigator === void 0 ? void 0 : navigator.language] || KeyboardLayoutData['en-US']);
+    return (exports.KeyboardLayoutData[navigator?.language] || exports.KeyboardLayoutData['en-US']);
 }
-exports.getDefaultLayout = getDefaultLayout;
 function newKey() {
     return {
         ctrlKey: false,
@@ -112,7 +136,16 @@ function newKey() {
         key: '',
     };
 }
-function parseKey(key, { modKey, shiftMap } = getDefaultLayout()) {
+/**
+ * This function, `parseKey`, takes a key combination string and splits it into a sequence of `Key` objects.
+ * It uses regular  expressions to identify each part of the key combination, accounting for modifier keys
+ * like 'shift', 'ctrl', 'alt', 'meta', and 'mod', the latter being dependent on the `modKey` from the
+ * `KeyboardLayout` (either 'ctrlKey' or 'metaKey' depending on the platform). For non-modifier keys, it
+ * checks if the `shiftKey` is active and if the key should be shifted using the `shiftMap`. This logic
+ * ensures the function captures accurate key state details in preparation for further handling like matching
+ * key sequences in the `handleKeyboard` function.
+ */
+function parseKey(key, { modKey, shiftedKeys, shiftMap } = getDefaultLayout()) {
     const sequence = [];
     let match;
     let event = newKey();
@@ -129,10 +162,19 @@ function parseKey(key, { modKey, shiftMap } = getDefaultLayout()) {
         else if (ch === 'mod')
             event[modKey] = true;
         else {
-            const shifted = shiftMap[ch];
-            if (shifted)
-                event.shiftKey = false;
-            event.key = shifted || ch;
+            event.key = ch;
+            if (event.shiftKey) {
+                if (shiftedKeys.includes(ch)) {
+                    event.shiftKey = false;
+                }
+                else {
+                    const shifted = shiftMap[ch];
+                    if (shifted) {
+                        event.key = shifted;
+                        event.shiftKey = false;
+                    }
+                }
+            }
         }
         if (match[2] !== '+') {
             sequence.push(event);
@@ -141,13 +183,16 @@ function parseKey(key, { modKey, shiftMap } = getDefaultLayout()) {
     }
     return sequence;
 }
-exports.parseKey = parseKey;
+/**
+ * Converts a string representing a key combination into a normalized string format.
+ * This function takes a `key` string and an optional `layout` object (defaults to the user's layout).
+ * It uses `parseKey` to break the key combination into individual `Key` objects, each representing
+ * a parsed key press. It then converts each `Key` object back to a string using `keyboardEventToString`,
+ * considering the layout's details like `shiftedKeys` and `shiftMap`. The resulting
+ * strings are concatenated with spaces and returned as the normalized form. This is useful
+ * for ensuring consistent representation of key sequences across different keyboard layouts.
+ */
 function normalize(key, layout = getDefaultLayout()) {
     const sequence = parseKey(key, layout);
-    let i = sequence.length;
-    while (i--)
-        sequence[i] = keyboardEventToString(sequence[i], layout);
-    return sequence.join(' ');
+    return sequence.map(key => keyboardEventToString(key, layout)).join(' ');
 }
-exports.normalize = normalize;
-//# sourceMappingURL=index.js.map

package/index.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.KeyboardLayoutData=void 0,exports.handleKeyboard=handleKeyboard,exports.parseKey=parseKey,exports.normalize=normalize;const navigator="undefined"!=typeof window?window.navigator:{language:"en-US",platform:"nodejs"},IS_MAC=/Mac|iPod|iPhone|iPad/,PARSE_KEY=/(shift|ctrl|control|alt|option|meta|command|cmd|mod|[^\s+]+)(\s*\+|\s)?/g,SHIFT_MAP={"/":"?",".":">",",":"<","'":'"',";":":","[":"{","]":"}","\\":"|","`":"~","=":"+","-":"_",1:"!",2:"@",3:"#",4:"$",5:"%",6:"^",7:"&",8:"*",9:"(",0:")"};exports.KeyboardLayoutData={"en-US":{shiftedKeys:Object.values(SHIFT_MAP),shiftMap:SHIFT_MAP,modKey:IS_MAC.test(navigator.platform)?"metaKey":"ctrlKey"}};const TranslateKey={ArrowUp:"up",ArrowDown:"down",ArrowLeft:"left",ArrowRight:"right",Escape:"esc"," ":"space"};function keyboardEventToString(e,{shiftedKeys:t}){const o=e.key;if(!o||"Shift"===o||"Alt"===o||"Meta"===o||"Control"===o)return"";const a=TranslateKey[o]||o.toLowerCase();let n;return e.ctrlKey&&(n="ctrl"),e.altKey&&(n=n?n+"+alt":"alt"),e.shiftKey&&!t.includes(a)&&(n=n?n+"+shift":"shift"),e.metaKey&&(n=n?n+"+meta":"meta"),n?n+"+"+a:a}function handleKeyboard({element:e,onKey:t,delay:o,layout:a,capture:n}){const r=void 0===o?250:o,s=navigator.language;let i=[],y=0;const l=a||exports.KeyboardLayoutData[s]||exports.KeyboardLayoutData["en-US"];function d(e){const o=keyboardEventToString(e,l);let a=Date.now();if(!o)return;a-y<r?i.push(o):i=[o];const n=i.slice(0);do{if(!1!==t(n.join(" "),i)){e.stopPropagation(),e.preventDefault(),a=0;break}n.shift()}while(n.length);y=a}return e.addEventListener("keydown",d,{capture:n}),()=>e.removeEventListener("keydown",d,{capture:n})}function getDefaultLayout(){return exports.KeyboardLayoutData[navigator?.language]||exports.KeyboardLayoutData["en-US"]}function newKey(){return{ctrlKey:!1,shiftKey:!1,metaKey:!1,altKey:!1,key:""}}function parseKey(e,{modKey:t,shiftedKeys:o,shiftMap:a}=getDefaultLayout()){const n=[];let r,s=newKey();for(;r=PARSE_KEY.exec(e.toLowerCase());){const e=r[1];if("shift"===e)s.shiftKey=!0;else if("ctrl"===e||"control"===e)s.ctrlKey=!0;else if("alt"===e||"option"===e)s.altKey=!0;else if("meta"===e||"cmd"===e||"command"===e)s.metaKey=!0;else if("mod"===e)s[t]=!0;else if(s.key=e,s.shiftKey)if(o.includes(e))s.shiftKey=!1;else{const t=a[e];t&&(s.key=t,s.shiftKey=!1)}"+"!==r[2]&&(n.push(s),s=newKey())}return n}function normalize(e,t=getDefaultLayout()){return parseKey(e,t).map((e=>keyboardEventToString(e,t))).join(" ")}

package/mjs/index.d.ts

@@ -0,0 +1,85 @@
+interface Key {
+    ctrlKey: boolean;
+    altKey: boolean;
+    shiftKey: boolean;
+    metaKey: boolean;
+    key: string;
+}
+/**
+ * The `KeyboardOptions` interface defines the configuration needed to handle keyboard interactions with
+ * a specific HTML element.
+ */
+export interface KeyboardOptions {
+    /**
+     * Specifies the HTML element on which keyboard events are captured.
+     * This element will receive focus and listen for key events.
+     */
+    element: HTMLElement;
+    /**
+     * A callback function that processes key events. It receives the current key being pressed
+     * and the sequence of keys accumulated so far. It returns `true` or `false` to indicate whether
+     * the sequence was consumed.
+     */
+    onKey: (key: string, sequence: string[]) => boolean;
+    /**
+     * The time in milliseconds to wait between key presses before resetting the sequence.
+     * Defaults to 250ms if not provided, ensuring thoughtful key sequences rather than accidental key presses.
+     */
+    delay?: number;
+    /**
+     * Optional parameter to specify a custom `KeyboardLayout`.
+     * Defaults to 'en-US' if not provided. This affects how key combinations and modifier keys are interpreted.
+     */
+    layout?: KeyboardLayout;
+    /**
+     * Boolean indicating whether to capture key events in the capture phase.
+     * This determines when the event listener reacts in the event propagation flow.
+     */
+    capture?: boolean;
+}
+export interface KeyboardLayout {
+    shiftedKeys: string[];
+    shiftMap: Record<string, string>;
+    modKey: 'metaKey' | 'ctrlKey';
+}
+export declare const KeyboardLayoutData: Record<string, KeyboardLayout>;
+/**
+ * The `handleKeyboard` function sets up event listeners to handle keyboard events on a given HTML element.
+ * It accepts a  configuration object (`KeyboardOptions`) which includes the target HTML element, a callback
+ * `onKey` to handle keyboard sequences, a `delay` for typing sequence recognition, an optional keyboard
+ * layout, and an optional capture mode for events.
+ *
+ * - Defaults the delay to 250ms if not specified, using this delay to determine when to treat subsequent
+ *   key presses as part of the same sequence or a new one.
+ * - Determines the keyboard layout, either from the provided options or defaults, which affects how keys
+ *   (especially with modifiers) are interpreted.
+ * - Adds a `keydown` event listener to the provided element, allowing modification of event behavior such
+ *   as propagation and default handling based on the `onKey` callback result.
+ * - Builds a key sequence based on timing and calls the `onKey` handler with the assembled sequence,
+ *   stopping event propagation based on handler response.
+ * - The handler uses the sequence to manage shortcuts and performs preventative measures against default
+ *   browser actions.
+ * @return A cleanup function that removes the event listener.
+ */
+export declare function handleKeyboard({ element, onKey, delay, layout, capture, }: KeyboardOptions): () => void;
+/**
+ * This function, `parseKey`, takes a key combination string and splits it into a sequence of `Key` objects.
+ * It uses regular  expressions to identify each part of the key combination, accounting for modifier keys
+ * like 'shift', 'ctrl', 'alt', 'meta', and 'mod', the latter being dependent on the `modKey` from the
+ * `KeyboardLayout` (either 'ctrlKey' or 'metaKey' depending on the platform). For non-modifier keys, it
+ * checks if the `shiftKey` is active and if the key should be shifted using the `shiftMap`. This logic
+ * ensures the function captures accurate key state details in preparation for further handling like matching
+ * key sequences in the `handleKeyboard` function.
+ */
+export declare function parseKey(key: string, { modKey, shiftedKeys, shiftMap }?: KeyboardLayout): Key[];
+/**
+ * Converts a string representing a key combination into a normalized string format.
+ * This function takes a `key` string and an optional `layout` object (defaults to the user's layout).
+ * It uses `parseKey` to break the key combination into individual `Key` objects, each representing
+ * a parsed key press. It then converts each `Key` object back to a string using `keyboardEventToString`,
+ * considering the layout's details like `shiftedKeys` and `shiftMap`. The resulting
+ * strings are concatenated with spaces and returned as the normalized form. This is useful
+ * for ensuring consistent representation of key sequences across different keyboard layouts.
+ */
+export declare function normalize(key: string, layout?: KeyboardLayout): string;
+export {};

package/mjs/index.js

@@ -0,0 +1 @@
+const navigator="undefined"!=typeof window?window.navigator:{language:"en-US",platform:"nodejs"},IS_MAC=/Mac|iPod|iPhone|iPad/,PARSE_KEY=/(shift|ctrl|control|alt|option|meta|command|cmd|mod|[^\s+]+)(\s*\+|\s)?/g,SHIFT_MAP={"/":"?",".":">",",":"<","'":'"',";":":","[":"{","]":"}","\\":"|","`":"~","=":"+","-":"_",1:"!",2:"@",3:"#",4:"$",5:"%",6:"^",7:"&",8:"*",9:"(",0:")"};export const KeyboardLayoutData={"en-US":{shiftedKeys:Object.values(SHIFT_MAP),shiftMap:SHIFT_MAP,modKey:IS_MAC.test(navigator.platform)?"metaKey":"ctrlKey"}};const TranslateKey={ArrowUp:"up",ArrowDown:"down",ArrowLeft:"left",ArrowRight:"right",Escape:"esc"," ":"space"};function keyboardEventToString(e,{shiftedKeys:t}){const o=e.key;if(!o||"Shift"===o||"Alt"===o||"Meta"===o||"Control"===o)return"";const a=TranslateKey[o]||o.toLowerCase();let n;return e.ctrlKey&&(n="ctrl"),e.altKey&&(n=n?n+"+alt":"alt"),e.shiftKey&&!t.includes(a)&&(n=n?n+"+shift":"shift"),e.metaKey&&(n=n?n+"+meta":"meta"),n?n+"+"+a:a}export function handleKeyboard({element:e,onKey:t,delay:o,layout:a,capture:n}){const r=void 0===o?250:o,i=navigator.language;let s=[],y=0;const l=a||KeyboardLayoutData[i]||KeyboardLayoutData["en-US"];function f(e){const o=keyboardEventToString(e,l);let a=Date.now();if(!o)return;a-y<r?s.push(o):s=[o];const n=s.slice(0);do{if(!1!==t(n.join(" "),s)){e.stopPropagation(),e.preventDefault(),a=0;break}n.shift()}while(n.length);y=a}return e.addEventListener("keydown",f,{capture:n}),()=>e.removeEventListener("keydown",f,{capture:n})}function getDefaultLayout(){return KeyboardLayoutData[navigator?.language]||KeyboardLayoutData["en-US"]}function newKey(){return{ctrlKey:!1,shiftKey:!1,metaKey:!1,altKey:!1,key:""}}export function parseKey(e,{modKey:t,shiftedKeys:o,shiftMap:a}=getDefaultLayout()){const n=[];let r,i=newKey();for(;r=PARSE_KEY.exec(e.toLowerCase());){const e=r[1];if("shift"===e)i.shiftKey=!0;else if("ctrl"===e||"control"===e)i.ctrlKey=!0;else if("alt"===e||"option"===e)i.altKey=!0;else if("meta"===e||"cmd"===e||"command"===e)i.metaKey=!0;else if("mod"===e)i[t]=!0;else if(i.key=e,i.shiftKey)if(o.includes(e))i.shiftKey=!1;else{const t=a[e];t&&(i.key=t,i.shiftKey=!1)}"+"!==r[2]&&(n.push(i),i=newKey())}return n}export function normalize(e,t=getDefaultLayout()){return parseKey(e,t).map((e=>keyboardEventToString(e,t))).join(" ")}

package/package.json

@@ -1,22 +1,21 @@
 {
   "name": "@cxl/keyboard",
-  "version": "0.0.1",
-  "description": "Keybaard Handling Library",
+  "version": "0.1.0",
+  "description": "Keyboard Handling Library",
   "license": "UNLICENSED",
   "files": [
     "*.js",
     "*.d.ts",
-    "*.js.map",
+    "*.css",
     "amd/*.js",
     "amd/*.d.ts",
-    "amd/*.js.map",
-    "es6/*.js",
-    "es6/*.d.ts",
-    "es6/*.js.map",
+    "mjs/*.js",
+    "mjs/*.d.ts",
     "LICENSE",
     "*.md"
   ],
   "main": "index.js",
+  "browser": "amd/index.js",
   "homepage": "https://cxlio.github.io/cxl/keyboard",
   "bugs": "https://github.com/cxlio/cxl/issues",
   "repository": {
@@ -24,4 +23,4 @@
     "url": "https://github.com/cxlio/cxl.git",
     "directory": "keyboard"
   }
-}
+}

package/test.js

@@ -4,11 +4,16 @@ const spec_1 = require("@cxl/spec");
 const index_js_1 = require("@cxl/keyboard");
 exports.default = (0, spec_1.spec)('keyboard', s => {
     s.test('normalize', it => {
+        it.should('handle empty and null inputs', a => {
+            a.equal((0, index_js_1.normalize)(''), '');
+        });
         it.should('parse single keys', a => {
             a.equal((0, index_js_1.normalize)('  x  '), 'x');
+            a.equal((0, index_js_1.normalize)('ctrl+x'), 'ctrl+x');
         });
         it.should('parse multiple keys', a => {
             a.equal((0, index_js_1.normalize)('  x  y'), 'x y');
+            a.equal((0, index_js_1.normalize)('x    y'), 'x y');
             a.equal((0, index_js_1.normalize)('ctrl+shift+x'), 'ctrl+shift+x');
         });
         it.should('parse mod key', a => {
@@ -18,8 +23,129 @@ exports.default = (0, spec_1.spec)('keyboard', s => {
         });
         it.should('normalize shifted keys', a => {
             a.equal((0, index_js_1.normalize)('shift+5'), '%');
+            a.equal((0, index_js_1.normalize)('shift+A'), 'shift+a');
+            a.equal((0, index_js_1.normalize)('shift+y'), 'shift+y');
             a.equal((0, index_js_1.normalize)('shift+ctrl+5'), 'ctrl+%');
         });
+        it.should('handle non character keys', a => {
+            a.equal((0, index_js_1.normalize)(':'), ':');
+            a.equal((0, index_js_1.normalize)('/'), '/');
+            a.equal((0, index_js_1.normalize)('.'), '.');
+            a.equal((0, index_js_1.normalize)('?'), '?');
+            a.equal((0, index_js_1.normalize)('shift+/'), '?');
+            a.equal((0, index_js_1.normalize)('shift+?'), '?');
+            a.equal((0, index_js_1.normalize)('ctrl+:'), 'ctrl+:');
+        });
+        it.should('normalize special keys with modifiers', a => {
+            a.equal((0, index_js_1.normalize)('ctrl+alt+del'), 'ctrl+alt+del');
+            a.equal((0, index_js_1.normalize)('ctrl+shift+esc'), 'ctrl+shift+esc');
+        });
+    });
+    s.test('parseKey', it => {
+        it.should('correctly parse simple keys without modifiers', a => {
+            const result = (0, index_js_1.parseKey)('a');
+            a.equal(result.length, 1);
+            a.equal(result[0].key, 'a');
+            a.equal(result[0].shiftKey, false);
+            a.equal(result[0].ctrlKey, false);
+            a.equal(result[0].altKey, false);
+            a.equal(result[0].metaKey, false);
+        });
+        it.should('correctly parse modifier keys', a => {
+            const result = (0, index_js_1.parseKey)('shift+b');
+            a.equal(result.length, 1);
+            a.equal(result[0].key, 'b');
+            a.equal(result[0].shiftKey, true);
+            a.equal(result[0].ctrlKey, false);
+            a.equal(result[0].altKey, false);
+            a.equal(result[0].metaKey, false);
+        });
+        it.should('correctly parse multiple keys with modifiers', a => {
+            const result = (0, index_js_1.parseKey)('ctrl+alt+del');
+            a.equal(result.length, 1);
+            a.equal(result[0].key, 'del');
+            a.equal(result[0].shiftKey, false);
+            a.equal(result[0].ctrlKey, true);
+            a.equal(result[0].altKey, true);
+            a.equal(result[0].metaKey, false);
+        });
+        it.should('handle key sequences separated by spaces', a => {
+            const result = (0, index_js_1.parseKey)('ctrl+a ctrl+b');
+            a.equal(result.length, 2);
+            a.equal(result[0].key, 'a');
+            a.equal(result[0].ctrlKey, true);
+            a.equal(result[1].key, 'b');
+            a.equal(result[1].ctrlKey, true);
+        });
+        it.should('map mod key to the correct modifier', a => {
+            const defaultLayout = index_js_1.KeyboardLayoutData['en-US'];
+            const result = (0, index_js_1.parseKey)('mod+c');
+            a.equal(result.length, 1);
+            a.equal(result[0].key, 'c');
+            a.equal(result[0][defaultLayout.modKey], true);
+        });
+        it.should('handle shifted characters correctly', a => {
+            const result = (0, index_js_1.parseKey)('shift+1');
+            a.equal(result.length, 1);
+            a.equal(result[0].key, '!'); // assuming shift+1 maps to '@' in shiftMap
+            a.equal(result[0].shiftKey, false);
+        });
+    });
+    s.test('handleKeyboard', it => {
+        it.should('call onKey with the correct sequence', (a) => {
+            // Setup a mock element
+            const elementMock = a.element('div');
+            const on = a.spyFn(elementMock, 'addEventListener');
+            const off = a.spyFn(elementMock, 'removeEventListener');
+            // Setup a mock callback
+            const onKeyMock = (0, spec_1.mockFn)(key => (key === 'a b' ? true : false));
+            // Register the handler
+            const dispose = (0, index_js_1.handleKeyboard)({
+                element: elementMock,
+                onKey: onKeyMock,
+                delay: 100,
+                layout: undefined,
+                capture: false,
+            });
+            // Simulate keydown events
+            const eventA = new KeyboardEvent('keydown', { key: 'a' });
+            const eventB = new KeyboardEvent('keydown', { key: 'b' });
+            // This will call the handler linked to the event
+            a.assert(typeof on.lastEvent?.arguments[1] === 'function');
+            on.lastEvent?.arguments[1](eventA);
+            a.equal(onKeyMock.lastArguments?.[0], 'a');
+            on.lastEvent?.arguments[1](eventB);
+            a.equal(onKeyMock.lastArguments?.[0], 'a b');
+            // Cleanup
+            dispose();
+            a.equal(off.lastEvent?.called, 1);
+        });
+        it.should('reset sequence after delay', async (a) => {
+            const elementMock = a.element('div');
+            const on = a.spyFn(elementMock, 'addEventListener');
+            const off = a.spyFn(elementMock, 'removeEventListener');
+            const onKeyMock = (0, spec_1.mockFn)(key => (key === 'a b' ? true : false));
+            const dispose = (0, index_js_1.handleKeyboard)({
+                element: elementMock,
+                onKey: onKeyMock,
+                delay: 100,
+                layout: undefined,
+                capture: false,
+            });
+            // Simulate keydown event
+            const eventA = new KeyboardEvent('keydown', { key: 'a' });
+            a.assert(typeof on.lastEvent?.arguments[1] === 'function');
+            on.lastEvent?.arguments[1](eventA);
+            // Advance time beyond delay
+            await new Promise(resolve => setTimeout(resolve, 200));
+            a.equal(onKeyMock.lastArguments?.[0], 'a');
+            // Simulate another keydown event
+            const eventC = new KeyboardEvent('keydown', { key: 'c' });
+            on.lastEvent?.arguments[1](eventC);
+            a.equal(onKeyMock.lastArguments?.[0], 'c');
+            // Cleanup
+            dispose();
+            a.equal(off.lastEvent?.called, 1);
+        });
     });
 });
-//# sourceMappingURL=test.js.map

package/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../keyboard/index.ts"],"names":[],"mappings":"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"}

package/test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"test.js","sourceRoot":"","sources":["../../keyboard/test.ts"],"names":[],"mappings":";;AAAA,oCAAiC;AACjC,4CAAuC;AAEvC,kBAAe,IAAA,WAAI,EAAC,UAAU,EAAE,CAAC,CAAC,EAAE;IACnC,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC,EAAE;QACxB,EAAE,CAAC,MAAM,CAAC,mBAAmB,EAAE,CAAC,CAAC,EAAE;YAClC,CAAC,CAAC,KAAK,CAAC,IAAA,oBAAS,EAAC,OAAO,CAAC,EAAE,GAAG,CAAC,CAAC;QAClC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,MAAM,CAAC,qBAAqB,EAAE,CAAC,CAAC,EAAE;YACpC,CAAC,CAAC,KAAK,CAAC,IAAA,oBAAS,EAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,CAAC;YACpC,CAAC,CAAC,KAAK,CAAC,IAAA,oBAAS,EAAC,cAAc,CAAC,EAAE,cAAc,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,MAAM,CAAC,eAAe,EAAE,CAAC,CAAC,EAAE;YAC9B,CAAC,CAAC,KAAK,CAAC,IAAA,oBAAS,EAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,CAAC;YACtC,CAAC,CAAC,KAAK,CAAC,IAAA,oBAAS,EAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,CAAC;YACtC,CAAC,CAAC,KAAK,CAAC,IAAA,oBAAS,EAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,CAAC;QACvC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,MAAM,CAAC,wBAAwB,EAAE,CAAC,CAAC,EAAE;YACvC,CAAC,CAAC,KAAK,CAAC,IAAA,oBAAS,EAAC,SAAS,CAAC,EAAE,GAAG,CAAC,CAAC;YACnC,CAAC,CAAC,KAAK,CAAC,IAAA,oBAAS,EAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,CAAC;QAC9C,CAAC,CAAC,CAAC;IACJ,CAAC,CAAC,CAAC;AACJ,CAAC,CAAC,CAAC"}