@design.estate/dees-domtools 2.5.4 → 3.0.0

package/dist_ts/domtools.classes.keyboard.js

@@ -120,6 +120,7 @@ export class Keyboard {
     domNode;
     mapCombosToHandlers = new Map();
     pressedKeys = new Set();
+    listening = false;
     constructor(domNode) {
         this.domNode = domNode;
         this.startListening();
@@ -131,40 +132,67 @@ export class Keyboard {
         return subject;
     }
     triggerKeyPress(keysArg) {
-        for (const key of keysArg) {
+        const normalizedKeys = this.normalizeKeys(keysArg);
+        for (const key of normalizedKeys) {
             this.pressedKeys.add(key);
         }
-        this.checkMatchingKeyboardSubjects();
-        for (const key of keysArg) {
+        this.checkMatchingKeyboardSubjects(this.createKeyboardEvent(normalizedKeys));
+        for (const key of normalizedKeys) {
             this.pressedKeys.delete(key);
         }
     }
     startListening() {
+        if (this.listening) {
+            return;
+        }
         this.domNode.addEventListener('keydown', this.handleKeyDown);
         this.domNode.addEventListener('keyup', this.handleKeyUp);
+        this.listening = true;
     }
     stopListening() {
+        if (!this.listening) {
+            return;
+        }
         this.domNode.removeEventListener('keydown', this.handleKeyDown);
         this.domNode.removeEventListener('keyup', this.handleKeyUp);
+        this.listening = false;
     }
     clear() {
         this.stopListening();
+        for (const comboEntry of this.mapCombosToHandlers.values()) {
+            for (const subject of comboEntry.subjects) {
+                subject.complete();
+            }
+        }
         this.mapCombosToHandlers.clear();
         this.pressedKeys.clear();
     }
+    dispose() {
+        this.clear();
+    }
     handleKeyDown = (event) => {
-        this.pressedKeys.add(event.keyCode);
+        const resolvedKey = this.resolveKey(event);
+        if (resolvedKey === null) {
+            return;
+        }
+        this.pressedKeys.add(resolvedKey);
         this.checkMatchingKeyboardSubjects(event);
     };
     checkMatchingKeyboardSubjects(payloadArg) {
-        this.mapCombosToHandlers.forEach((subjectArg, keysArg) => {
-            if (this.areAllKeysPressed(keysArg)) {
-                subjectArg.next(payloadArg);
+        this.mapCombosToHandlers.forEach((comboEntry) => {
+            if (this.areAllKeysPressed(comboEntry.keys)) {
+                for (const subjectArg of comboEntry.subjects) {
+                    subjectArg.next(payloadArg);
+                }
             }
         });
     }
     handleKeyUp = (event) => {
-        this.pressedKeys.delete(event.keyCode);
+        const resolvedKey = this.resolveKey(event);
+        if (resolvedKey === null) {
+            return;
+        }
+        this.pressedKeys.delete(resolvedKey);
     };
     areAllKeysPressed(keysArg) {
         let result = true;
@@ -176,13 +204,320 @@ export class Keyboard {
         return result;
     }
     registerKeys(keysArg, subjectArg) {
-        if (!this.mapCombosToHandlers.has(keysArg)) {
-            this.mapCombosToHandlers.set(keysArg, subjectArg);
+        const normalizedKeys = this.normalizeKeys(keysArg);
+        const comboKey = normalizedKeys.join('+');
+        const existingEntry = this.mapCombosToHandlers.get(comboKey);
+        if (!existingEntry) {
+            this.mapCombosToHandlers.set(comboKey, {
+                keys: normalizedKeys,
+                subjects: [subjectArg],
+            });
+            return;
+        }
+        existingEntry.subjects.push(subjectArg);
+    }
+    normalizeKeys(keysArg) {
+        return [...new Set(keysArg)].sort((leftKey, rightKey) => leftKey - rightKey);
+    }
+    resolveKey(event) {
+        return this.resolveKeyFromCode(event.code)
+            ?? this.resolveKeyFromKey(event.key)
+            ?? this.resolveKeyFromKeyCode(event.keyCode);
+    }
+    resolveKeyFromCode(codeArg) {
+        if (!codeArg) {
+            return null;
+        }
+        if (codeArg.startsWith('Key') && codeArg.length === 4) {
+            return Key[codeArg.slice(3)] ?? null;
+        }
+        if (codeArg.startsWith('Digit') && codeArg.length === 6) {
+            return this.resolveKeyFromKey(codeArg.slice(5));
         }
-        else {
-            const subject = this.mapCombosToHandlers.get(keysArg);
-            return subject;
+        switch (codeArg) {
+            case 'Backspace':
+                return Key.Backspace;
+            case 'Tab':
+                return Key.Tab;
+            case 'Enter':
+            case 'NumpadEnter':
+                return Key.Enter;
+            case 'ShiftLeft':
+            case 'ShiftRight':
+                return Key.Shift;
+            case 'ControlLeft':
+            case 'ControlRight':
+                return Key.Ctrl;
+            case 'AltLeft':
+            case 'AltRight':
+                return Key.Alt;
+            case 'Pause':
+                return Key.PauseBreak;
+            case 'CapsLock':
+                return Key.CapsLock;
+            case 'Escape':
+                return Key.Escape;
+            case 'Space':
+                return Key.Space;
+            case 'PageUp':
+                return Key.PageUp;
+            case 'PageDown':
+                return Key.PageDown;
+            case 'End':
+                return Key.End;
+            case 'Home':
+                return Key.Home;
+            case 'ArrowLeft':
+                return Key.LeftArrow;
+            case 'ArrowUp':
+                return Key.UpArrow;
+            case 'ArrowRight':
+                return Key.RightArrow;
+            case 'ArrowDown':
+                return Key.DownArrow;
+            case 'Insert':
+                return Key.Insert;
+            case 'Delete':
+                return Key.Delete;
+            case 'MetaLeft':
+                return Key.LeftWindowKey;
+            case 'MetaRight':
+                return Key.RightWindowKey;
+            case 'ContextMenu':
+                return Key.SelectKey;
+            case 'Numpad0':
+                return Key.Numpad0;
+            case 'Numpad1':
+                return Key.Numpad1;
+            case 'Numpad2':
+                return Key.Numpad2;
+            case 'Numpad3':
+                return Key.Numpad3;
+            case 'Numpad4':
+                return Key.Numpad4;
+            case 'Numpad5':
+                return Key.Numpad5;
+            case 'Numpad6':
+                return Key.Numpad6;
+            case 'Numpad7':
+                return Key.Numpad7;
+            case 'Numpad8':
+                return Key.Numpad8;
+            case 'Numpad9':
+                return Key.Numpad9;
+            case 'NumpadMultiply':
+                return Key.Multiply;
+            case 'NumpadAdd':
+                return Key.Add;
+            case 'NumpadSubtract':
+                return Key.Subtract;
+            case 'NumpadDecimal':
+                return Key.DecimalPoint;
+            case 'NumpadDivide':
+                return Key.Divide;
+            case 'F1':
+                return Key.F1;
+            case 'F2':
+                return Key.F2;
+            case 'F3':
+                return Key.F3;
+            case 'F4':
+                return Key.F4;
+            case 'F5':
+                return Key.F5;
+            case 'F6':
+                return Key.F6;
+            case 'F7':
+                return Key.F7;
+            case 'F8':
+                return Key.F8;
+            case 'F9':
+                return Key.F9;
+            case 'F10':
+                return Key.F10;
+            case 'F11':
+                return Key.F11;
+            case 'F12':
+                return Key.F12;
+            case 'NumLock':
+                return Key.NumLock;
+            case 'ScrollLock':
+                return Key.ScrollLock;
+            case 'Semicolon':
+                return Key.SemiColon;
+            case 'Equal':
+                return Key.Equals;
+            case 'Comma':
+                return Key.Comma;
+            case 'Minus':
+                return Key.Dash;
+            case 'Period':
+                return Key.Period;
+            case 'Slash':
+                return Key.ForwardSlash;
+            case 'Backquote':
+                return Key.Tilde;
+            case 'BracketLeft':
+                return Key.OpenBracket;
+            case 'BracketRight':
+                return Key.ClosedBracket;
+            case 'Quote':
+                return Key.Quote;
+            default:
+                return null;
+        }
+    }
+    resolveKeyFromKey(keyArg) {
+        if (!keyArg) {
+            return null;
+        }
+        if (keyArg.length === 1) {
+            const upperKey = keyArg.toUpperCase();
+            if (upperKey >= 'A' && upperKey <= 'Z') {
+                return Key[upperKey] ?? null;
+            }
+            switch (keyArg) {
+                case '0':
+                    return Key.Zero;
+                case '1':
+                    return Key.One;
+                case '2':
+                    return Key.Two;
+                case '3':
+                    return Key.Three;
+                case '4':
+                    return Key.Four;
+                case '5':
+                    return Key.Five;
+                case '6':
+                    return Key.Six;
+                case '7':
+                    return Key.Seven;
+                case '8':
+                    return Key.Eight;
+                case '9':
+                    return Key.Nine;
+                case ' ':
+                    return Key.Space;
+                case ';':
+                    return Key.SemiColon;
+                case '=':
+                    return Key.Equals;
+                case ',':
+                    return Key.Comma;
+                case '-':
+                    return Key.Dash;
+                case '.':
+                    return Key.Period;
+                case '/':
+                    return Key.ForwardSlash;
+                case '`':
+                    return Key.Tilde;
+                case '[':
+                    return Key.OpenBracket;
+                case ']':
+                    return Key.ClosedBracket;
+                case '\'':
+                    return Key.Quote;
+                default:
+                    return null;
+            }
+        }
+        switch (keyArg) {
+            case 'Backspace':
+                return Key.Backspace;
+            case 'Tab':
+                return Key.Tab;
+            case 'Enter':
+                return Key.Enter;
+            case 'Shift':
+                return Key.Shift;
+            case 'Control':
+                return Key.Ctrl;
+            case 'Alt':
+                return Key.Alt;
+            case 'Pause':
+                return Key.PauseBreak;
+            case 'CapsLock':
+                return Key.CapsLock;
+            case 'Escape':
+                return Key.Escape;
+            case 'PageUp':
+                return Key.PageUp;
+            case 'PageDown':
+                return Key.PageDown;
+            case 'End':
+                return Key.End;
+            case 'Home':
+                return Key.Home;
+            case 'ArrowLeft':
+                return Key.LeftArrow;
+            case 'ArrowUp':
+                return Key.UpArrow;
+            case 'ArrowRight':
+                return Key.RightArrow;
+            case 'ArrowDown':
+                return Key.DownArrow;
+            case 'Insert':
+                return Key.Insert;
+            case 'Delete':
+                return Key.Delete;
+            case 'Meta':
+                return Key.LeftWindowKey;
+            case 'ContextMenu':
+                return Key.SelectKey;
+            case 'NumLock':
+                return Key.NumLock;
+            case 'ScrollLock':
+                return Key.ScrollLock;
+            default:
+                return null;
+        }
+    }
+    resolveKeyFromKeyCode(keyCodeArg) {
+        if (typeof keyCodeArg !== 'number') {
+            return null;
+        }
+        return typeof Key[keyCodeArg] !== 'undefined' ? keyCodeArg : null;
+    }
+    createKeyboardEvent(keysArg) {
+        const triggerKey = keysArg[keysArg.length - 1] ?? Key.Enter;
+        const keyDescriptor = this.getKeyDescriptor(triggerKey);
+        return new KeyboardEvent('keydown', {
+            key: keyDescriptor.key,
+            code: keyDescriptor.code,
+            ctrlKey: keysArg.includes(Key.Ctrl),
+            shiftKey: keysArg.includes(Key.Shift),
+            altKey: keysArg.includes(Key.Alt),
+            metaKey: keysArg.includes(Key.LeftWindowKey) || keysArg.includes(Key.RightWindowKey),
+        });
+    }
+    getKeyDescriptor(keyArg) {
+        switch (keyArg) {
+            case Key.Ctrl:
+                return { key: 'Control', code: 'ControlLeft' };
+            case Key.Shift:
+                return { key: 'Shift', code: 'ShiftLeft' };
+            case Key.Alt:
+                return { key: 'Alt', code: 'AltLeft' };
+            case Key.Enter:
+                return { key: 'Enter', code: 'Enter' };
+            case Key.Space:
+                return { key: ' ', code: 'Space' };
+            default: {
+                const keyName = Key[keyArg];
+                if (keyName && keyName.length === 1) {
+                    if (keyName >= 'A' && keyName <= 'Z') {
+                        return { key: keyName.toLowerCase(), code: `Key${keyName}` };
+                    }
+                }
+                if (keyArg >= Key.Zero && keyArg <= Key.Nine) {
+                    const digit = String(keyArg - Key.Zero);
+                    return { key: digit, code: `Digit${digit}` };
+                }
+                return { key: keyName ?? 'Unidentified', code: 'Unidentified' };
+            }
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"domtools.classes.keyboard.js","sourceRoot":"","sources":["../ts/domtools.classes.keyboard.ts"],"names":[],"mappings":"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"}

package/dist_ts/domtools.classes.scroller.d.ts

@@ -1,8 +1,11 @@
 import type { DomTools } from './domtools.classes.domtools.js';
 export declare class Scroller {
     domtoolsInstance: DomTools;
+    private disposed;
     private scrollCallbacks;
     private lenisInstance;
+    private lenisScrollUnsubscribe;
+    private nativeScrollListenerAttached;
     private handleNativeScroll;
     private handleLenisScroll;
     constructor(domtoolsInstanceArg: DomTools);
@@ -23,11 +26,12 @@ export declare class Scroller {
     enableLenisScroll(optionsArg?: {
         disableOnNativeSmoothScroll?: boolean;
     }): Promise<void>;
+    disableLenisScroll(): void;
     /**
      * Registers a callback to be executed on scroll.
      * @param callback A function to execute on each scroll event.
      */
-    onScroll(callback: () => void): void;
+    onScroll(callback: () => void): () => void;
     /**
      * Executes all registered scroll callbacks concurrently.
      */
@@ -48,4 +52,5 @@ export declare class Scroller {
      * Detaches the Lenis scroll event listener.
      */
     private detachLenisScrollListener;
+    dispose(): void;
 }