@akilli/editor-src 5.1.8 → 5.2.0

package/base/AlignCommand.js

@@ -12,7 +12,7 @@ export default class AlignCommand extends Command {
      * @param {string} alignment
      */
     constructor(editor, alignment) {
-        if (!Alignment.values().includes(alignment)) {
+        if (!Object.values(Alignment).includes(alignment)) {
             throw new TypeError('Invalid argument');
         }
 
@@ -27,7 +27,7 @@ export default class AlignCommand extends Command {
         const element = this.editor.dom.getActiveElement();
 
         if (element?.hasAttribute('data-alignable')) {
-            this.editor.dom.removeClass(element, ...Alignment.values());
+            this.editor.dom.removeClass(element, ...Object.values(Alignment));
             this.#alignment !== Alignment.NONE && element.classList.add(this.#alignment);
         }
     }

package/base/AlignableListener.js

@@ -1,6 +1,6 @@
 import Alignment from './Alignment.js';
-import Key from './Key.js';
 import Listener from './Listener.js';
+import { AlignKeyMap, isAlignKey } from './Key.js';
 
 export default class AlignableListener extends Listener {
     /**
@@ -28,18 +28,11 @@ export default class AlignableListener extends Listener {
      * @return {void}
      */
     keydown(event) {
-        const map = {
-            [Key.ARROWUP]: Alignment.NONE,
-            [Key.ARROWLEFT]: Alignment.LEFT,
-            [Key.ARROWDOWN]: Alignment.CENTER,
-            [Key.ARROWRIGHT]: Alignment.RIGHT,
-        };
-
-        if (event.target === event.currentTarget && Key.isEventFor(event, Object.keys(map), { shift: true })) {
+        if (event.target === event.currentTarget && isAlignKey(event)) {
             event.preventDefault();
             event.stopPropagation();
-            this.editor.dom.removeClass(event.target, ...Alignment.values());
-            map[event.key] !== Alignment.NONE && event.target.classList.add(map[event.key]);
+            this.editor.dom.removeClass(event.target, ...Object.values(Alignment));
+            AlignKeyMap[event.key] !== Alignment.NONE && event.target.classList.add(AlignKeyMap[event.key]);
         }
     }
 }

package/base/Alignment.js

@@ -1,36 +1,9 @@
-export default class Alignment {
-    /**
-     * @return {string}
-     */
-    static get NONE() {
-        return 'none';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get LEFT() {
-        return 'left';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get CENTER() {
-        return 'center';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get RIGHT() {
-        return 'right';
-    }
-
-    /**
-     * @return {string[]}
-     */
-    static values() {
-        return [this.NONE, this.LEFT, this.CENTER, this.RIGHT];
-    }
-}
+/**
+ * @enum {string}
+ */
+export default Object.freeze({
+    NONE: 'none',
+    LEFT: 'left',
+    CENTER: 'center',
+    RIGHT: 'right',
+});

package/base/BarListener.js

@@ -1,4 +1,4 @@
-import Key from './Key.js';
+import Key, { isBarNavKey } from './Key.js';
 import Listener from './Listener.js';
 
 /**
@@ -34,7 +34,7 @@ export default class BarListener extends Listener {
      * @return {void}
      */
     keydown(event) {
-        if (Key.isEventFor(event, [Key.ARROWLEFT, Key.ARROWRIGHT, Key.HOME, Key.END])) {
+        if (isBarNavKey(event)) {
             const prev = event.target.previousElementSibling;
             const next = event.target.nextElementSibling;
             const first = event.target.parentElement.firstElementChild;

package/base/DeletableListener.js

@@ -1,4 +1,4 @@
-import Key from './Key.js';
+import Key, { isKey } from './Key.js';
 import Listener from './Listener.js';
 
 export default class DeletableListener extends Listener {
@@ -27,7 +27,7 @@ export default class DeletableListener extends Listener {
      * @return {void}
      */
     keydown(event) {
-        if (event.target === event.currentTarget && Key.isEventFor(event, Key.DEL, { ctrl: true })) {
+        if (event.target === event.currentTarget && isKey(event, Key.DEL, { ctrl: true })) {
             this.editor.dom.delete(event.target);
             event.preventDefault();
             event.stopPropagation();

package/base/Dom.js

@@ -344,7 +344,7 @@ export default class Dom {
      * @return {void}
      */
     sort(element, sorting) {
-        if (!(element instanceof HTMLElement) || !Sorting.values().includes(sorting)) {
+        if (!(element instanceof HTMLElement) || !Object.values(Sorting).includes(sorting)) {
             throw new TypeError('Invalid argument');
         }
 

package/base/EditableListener.js

@@ -1,4 +1,4 @@
-import Key from './Key.js';
+import Key, { isFormatKey, isKey } from './Key.js';
 import Listener from './Listener.js';
 import TagName from './TagName.js';
 
@@ -30,10 +30,10 @@ export default class EditableListener extends Listener {
      * @return {void}
      */
     keydown(event) {
-        if (Key.isEventFor(event, Key.ENTER, { shift: true }) && !this.editor.tags.allowed(event.target, TagName.BR)) {
+        if (isKey(event, Key.ENTER, { shift: true }) && !this.editor.tags.allowed(event.target, TagName.BR)) {
             event.preventDefault();
             event.stopPropagation();
-        } else if (Key.isEventFor(event, Key.ENTER)) {
+        } else if (isKey(event, Key.ENTER)) {
             event.preventDefault();
             event.stopPropagation();
             const enter = this.editor.tags.get(event.target)?.enter;
@@ -56,14 +56,14 @@ export default class EditableListener extends Listener {
                 }
             }
         } else if (
-            Key.isEventFor(event, Key.BACKSPACE) &&
+            isKey(event, Key.BACKSPACE) &&
             !event.target.textContent &&
             event.target.hasAttribute('data-deletable')
         ) {
             this.editor.dom.delete(event.target);
             event.preventDefault();
             event.stopPropagation();
-        } else if (/^[A-Z]$/.test(event.key) && Key.isEventFor(event, event.key, { alt: true, shift: true })) {
+        } else if (isFormatKey(event)) {
             event.preventDefault();
             event.stopPropagation();
             this.editor.formatbar.querySelector(`${TagName.BUTTON}[data-key=${event.key.toLowerCase()}]`)?.click();

package/base/Key.js

@@ -1,258 +1,173 @@
-export default class Key {
-    /**
-     * @return {string}
-     */
-    static get A() {
-        return 'a';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get ARROWDOWN() {
-        return 'ArrowDown';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get ARROWLEFT() {
-        return 'ArrowLeft';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get ARROWRIGHT() {
-        return 'ArrowRight';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get ARROWUP() {
-        return 'ArrowUp';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get B() {
-        return 'b';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get BACKSPACE() {
-        return 'Backspace';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get C() {
-        return 'c';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get D() {
-        return 'd';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get DEL() {
-        return 'Delete';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get E() {
-        return 'e';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get END() {
-        return 'End';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get ENTER() {
-        return 'Enter';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get F() {
-        return 'f';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get G() {
-        return 'g';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get HOME() {
-        return 'Home';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get I() {
-        return 'i';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get J() {
-        return 'j';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get K() {
-        return 'k';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get L() {
-        return 'l';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get M() {
-        return 'm';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get O() {
-        return 'o';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get Q() {
-        return 'q';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get R() {
-        return 'r';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get S() {
-        return 's';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get SPACE() {
-        return ' ';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get T() {
-        return 't';
-    }
-
-    /**
-     * @return {string}
-     */
-    static get TAB() {
-        return 'Tab';
-    }
+import Alignment from './Alignment.js';
+import Sorting from './Sorting.js';
+
+/**
+ * @enum {string}
+ */
+const Key = Object.freeze({
+    A: 'a',
+    ARROWDOWN: 'ArrowDown',
+    ARROWLEFT: 'ArrowLeft',
+    ARROWRIGHT: 'ArrowRight',
+    ARROWUP: 'ArrowUp',
+    B: 'b',
+    BACKSPACE: 'Backspace',
+    C: 'c',
+    D: 'd',
+    DEL: 'Delete',
+    E: 'e',
+    END: 'End',
+    ENTER: 'Enter',
+    F: 'f',
+    G: 'g',
+    HOME: 'Home',
+    I: 'i',
+    J: 'j',
+    K: 'k',
+    L: 'l',
+    M: 'm',
+    O: 'o',
+    Q: 'q',
+    R: 'r',
+    S: 's',
+    SPACE: ' ',
+    T: 't',
+    TAB: 'Tab',
+    U: 'u',
+    V: 'v',
+    W: 'w',
+    X: 'x',
+    Y: 'y',
+    Z: 'z',
+});
+
+export default Key;
+
+/**
+ * @type {string[]}
+ */
+export const ArrowKeys = Object.freeze([Key.ARROWLEFT, Key.ARROWRIGHT, Key.ARROWUP, Key.ARROWDOWN]);
+
+/**
+ * @type {string[]}
+ */
+export const NavKeys = Object.freeze([Key.HOME, Key.ARROWUP, Key.ARROWDOWN, Key.END]);
+
+/**
+ * @type {string[]}
+ */
+export const BarNavKeys = Object.freeze([Key.HOME, Key.ARROWLEFT, Key.ARROWRIGHT, Key.END]);
+
+/**
+ * @type {Object<Key, Alignment>}
+ */
+export const AlignKeyMap = Object.freeze({
+    [Key.ARROWUP]: Alignment.NONE,
+    [Key.ARROWLEFT]: Alignment.LEFT,
+    [Key.ARROWDOWN]: Alignment.CENTER,
+    [Key.ARROWRIGHT]: Alignment.RIGHT,
+});
+
+/**
+ * @type {Object<Key, Sorting>}
+ */
+export const SortKeyMap = Object.freeze({
+    [Key.HOME]: Sorting.FIRST,
+    [Key.ARROWUP]: Sorting.PREV,
+    [Key.ARROWDOWN]: Sorting.NEXT,
+    [Key.END]: Sorting.LAST,
+});
+
+/**
+ * Indicates if keyboard event was triggered for given key combination
+ *
+ * @param {KeyboardEvent} event
+ * @param {string} key
+ * @param {boolean} alt
+ * @param {boolean} ctrl
+ * @param {boolean} shift
+ * @return {boolean}
+ */
+export function isKey(event, key, { alt = false, ctrl = false, shift = false } = {}) {
+    return event.key === key && event.altKey === alt && event.ctrlKey === ctrl && event.shiftKey === shift;
+}
 
-    /**
-     * @return {string}
-     */
-    static get U() {
-        return 'u';
-    }
+/**
+ * Indicates if keyboard event was triggered for any of the given key combinations
+ *
+ * @param {KeyboardEvent} event
+ * @param {string[]} key
+ * @param {boolean} alt
+ * @param {boolean} ctrl
+ * @param {boolean} shift
+ * @return {boolean}
+ */
+export function isAnyKey(event, key, { alt = false, ctrl = false, shift = false } = {}) {
+    return (
+        Array.isArray(key) &&
+        key.includes(event.key) &&
+        event.altKey === alt &&
+        event.ctrlKey === ctrl &&
+        event.shiftKey === shift
+    );
+}
 
-    /**
-     * @return {string}
-     */
-    static get V() {
-        return 'v';
-    }
+/**
+ * Indicates if keyboard event was triggered for given arrow key combination
+ *
+ * @param {KeyboardEvent} event
+ * @return {boolean}
+ */
+export function isArrowKey(event) {
+    return isAnyKey(event, ArrowKeys);
+}
 
-    /**
-     * @return {string}
-     */
-    static get W() {
-        return 'w';
-    }
+/**
+ * Indicates if keyboard event was triggered for given navigation key combination
+ *
+ * @param {KeyboardEvent} event
+ * @return {boolean}
+ */
+export function isNavKey(event) {
+    return isAnyKey(event, NavKeys);
+}
 
-    /**
-     * @return {string}
-     */
-    static get X() {
-        return 'x';
-    }
+/**
+ * Indicates if keyboard event was triggered for given bar navigation key combination
+ *
+ * @param {KeyboardEvent} event
+ * @return {boolean}
+ */
+export function isBarNavKey(event) {
+    return isAnyKey(event, BarNavKeys);
+}
 
-    /**
-     * @return {string}
-     */
-    static get Y() {
-        return 'y';
-    }
+/**
+ * Indicates if keyboard event was triggered for given aligment key combination
+ *
+ * @param {KeyboardEvent} event
+ * @return {boolean}
+ */
+export function isAlignKey(event) {
+    return isAnyKey(event, Object.keys(AlignKeyMap), { shift: true });
+}
 
-    /**
-     * @return {string}
-     */
-    static get Z() {
-        return 'z';
-    }
+/**
+ * Indicates if keyboard event was triggered for given sorting key combination
+ *
+ * @param {KeyboardEvent} event
+ * @return {boolean}
+ */
+export function isSortKey(event) {
+    return isAnyKey(event, Object.keys(SortKeyMap), { ctrl: true });
+}
 
-    /**
-     * Indicates if keyboard event was triggered for given key combination
-     *
-     * @param {KeyboardEvent} event
-     * @param {string|string[]} key
-     * @param {boolean} alt
-     * @param {boolean} ctrl
-     * @param {boolean} shift
-     * @return {boolean}
-     */
-    static isEventFor(event, key, { alt = false, ctrl = false, shift = false } = {}) {
-        return (
-            ((Array.isArray(key) && key.includes(event.key)) || event.key === key) &&
-            event.altKey === alt &&
-            event.ctrlKey === ctrl &&
-            event.shiftKey === shift
-        );
-    }
+/**
+ * Indicates if keyboard event was triggered for given format key combination
+ *
+ * @param {KeyboardEvent} event
+ * @return {boolean}
+ */
+export function isFormatKey(event) {
+    return /^[A-Z]$/.test(event.key) && isKey(event, event.key, { alt: true, shift: true });
 }

package/base/NavigableListener.js

@@ -1,4 +1,4 @@
-import Key from './Key.js';
+import Key, { isNavKey } from './Key.js';
 import Listener from './Listener.js';
 
 export default class NavigableListener extends Listener {
@@ -28,11 +28,7 @@ export default class NavigableListener extends Listener {
      * @return {void}
      */
     keydown(event) {
-        if (
-            event.target === event.currentTarget &&
-            Key.isEventFor(event, [Key.ARROWUP, Key.ARROWDOWN, Key.HOME, Key.END]) &&
-            this.#enabled(event.target)
-        ) {
+        if (event.target === event.currentTarget && isNavKey(event) && this.#enabled(event.target)) {
             const prev = event.target.previousElementSibling;
             const next = event.target.nextElementSibling;
             const first = event.target.parentElement.firstElementChild;

package/base/SlotableListener.js

@@ -1,4 +1,4 @@
-import Key from './Key.js';
+import Key, { isKey } from './Key.js';
 import Listener from './Listener.js';
 import TagName from './TagName.js';
 
@@ -30,9 +30,9 @@ export default class SlotableListener extends Listener {
      * @return {void}
      */
     keydown(event) {
-        if (Key.isEventFor(event, Key.BACKSPACE) && event.target.matches(':only-child')) {
+        if (isKey(event, Key.BACKSPACE) && event.target.matches(':only-child')) {
             this.editor.dom.delete(event.target.parentElement);
-        } else if (!Key.isEventFor(event, Key.TAB) && !Key.isEventFor(event, Key.TAB, { shift: true })) {
+        } else if (!isKey(event, Key.TAB) && !isKey(event, Key.TAB, { shift: true })) {
             event.preventDefault();
             event.stopPropagation();
         }

package/base/SortCommand.js

@@ -12,7 +12,7 @@ export default class SortCommand extends Command {
      * @param {string} sorting
      */
     constructor(editor, sorting) {
-        if (!Sorting.values().includes(sorting)) {
+        if (!Object.values(Sorting).includes(sorting)) {
             throw new TypeError('Invalid argument');
         }
 

package/base/SortableListener.js

@@ -1,7 +1,6 @@
-import Key from './Key.js';
 import Listener from './Listener.js';
-import Sorting from './Sorting.js';
 import TagName from './TagName.js';
+import { SortKeyMap, isSortKey } from './Key.js';
 
 export default class SortableListener extends Listener {
     /**
@@ -32,15 +31,8 @@ export default class SortableListener extends Listener {
      * @return {void}
      */
     keydown(event) {
-        const map = {
-            [Key.HOME]: Sorting.FIRST,
-            [Key.ARROWUP]: Sorting.PREV,
-            [Key.ARROWDOWN]: Sorting.NEXT,
-            [Key.END]: Sorting.LAST,
-        };
-
-        if (event.target === event.currentTarget && Key.isEventFor(event, Object.keys(map), { ctrl: true })) {
-            this.editor.dom.sort(event.target, map[event.key]);
+        if (event.target === event.currentTarget && isSortKey(event)) {
+            this.editor.dom.sort(event.target, SortKeyMap[event.key]);
             event.preventDefault();
             event.stopPropagation();
         }