@formily-design/shared 1.0.0

package/esm/event.d.ts

@@ -0,0 +1,96 @@
+import { Subscribable, ISubscriber } from './subscribable';
+export type EventOptions = boolean | (AddEventListenerOptions & EventListenerOptions & {
+    mode?: 'onlyOne' | 'onlyParent' | 'onlyChild';
+});
+export type EventContainer = Window | HTMLElement | HTMLDocument;
+export type EventDriverContainer = HTMLElement | HTMLDocument;
+export interface IEventEffect<T> {
+    (engine: T): void;
+}
+export interface IEventDriver {
+    container: EventDriverContainer;
+    contentWindow: Window;
+    attach(container: EventDriverContainer): void;
+    detach(container: EventDriverContainer): void;
+    dispatch<T extends ICustomEvent<any> = any>(event: T): void | boolean;
+    subscribe<T extends ICustomEvent<any> = any>(subscriber: ISubscriber<T>): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventOptions): void;
+    addEventListener(type: any, listener: any, options: any): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventOptions): void;
+    removeEventListener(type: any, listener: any, options?: any): void;
+    batchAddEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventOptions): void;
+    batchAddEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventOptions): void;
+    batchAddEventListener(type: any, listener: any, options?: any): void;
+    batchRemoveEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventOptions): void;
+    batchRemoveEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventOptions): void;
+    batchRemoveEventListener(type: any, listener: any, options: any): void;
+}
+export interface IEventDriverClass<T> {
+    new (engine: T, context?: any): IEventDriver;
+}
+export interface ICustomEvent<EventData = any, EventContext = any> {
+    type: string;
+    data?: EventData;
+    context?: EventContext;
+}
+export interface CustomEventClass {
+    new (...args: any[]): any;
+}
+export interface IEventProps<T = Event> {
+    drivers?: IEventDriverClass<T>[];
+    effects?: IEventEffect<T>[];
+}
+/**
+ * 事件驱动器基类
+ */
+export declare class EventDriver<Engine extends Event = Event, Context = any> implements IEventDriver {
+    engine: Engine;
+    container: EventDriverContainer;
+    contentWindow: Window;
+    context: Context;
+    constructor(engine: Engine, context?: Context);
+    dispatch<T extends ICustomEvent<any> = any>(event: T): boolean;
+    subscribe<T extends ICustomEvent<any> = any>(subscriber: ISubscriber<T>): {
+        (): void;
+        [UNSUBSCRIBE_ID_SYMBOL]: number;
+    };
+    subscribeTo<T extends CustomEventClass>(type: T, subscriber: ISubscriber<InstanceType<T>>): {
+        (): void;
+        [UNSUBSCRIBE_ID_SYMBOL]: number;
+    };
+    subscribeWith<T extends ICustomEvent = ICustomEvent>(type: string | string[], subscriber: ISubscriber<T>): {
+        (): void;
+        [UNSUBSCRIBE_ID_SYMBOL]: number;
+    };
+    attach(container: EventDriverContainer): void;
+    detach(container: EventDriverContainer): void;
+    eventTarget(type: string): Window | EventDriverContainer;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventOptions): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventOptions): void;
+    batchAddEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventOptions): void;
+    batchAddEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventOptions): void;
+    batchRemoveEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventOptions): void;
+    batchRemoveEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventOptions): void;
+}
+/**
+ * 事件引擎
+ */
+export declare class Event extends Subscribable<ICustomEvent<any>> {
+    private drivers;
+    private containers;
+    constructor(props?: IEventProps);
+    subscribeTo<T extends CustomEventClass>(type: T, subscriber: ISubscriber<InstanceType<T>>): {
+        (): void;
+        [UNSUBSCRIBE_ID_SYMBOL]: number;
+    };
+    subscribeWith<T extends ICustomEvent = ICustomEvent>(type: string | string[], subscriber: ISubscriber<T>): {
+        (): void;
+        [UNSUBSCRIBE_ID_SYMBOL]: number;
+    };
+    attachEvents(container: EventContainer, contentWindow?: Window, context?: any): any;
+    detachEvents(container?: EventContainer): any;
+}

package/esm/event.js

@@ -0,0 +1,213 @@
+import { isArr, isWindow } from './types';
+import { Subscribable } from './subscribable';
+import { globalThisPolyfill } from './globalThisPolyfill';
+const ATTACHED_SYMBOL = Symbol('ATTACHED_SYMBOL');
+const EVENTS_SYMBOL = Symbol('__EVENTS_SYMBOL__');
+const EVENTS_ONCE_SYMBOL = Symbol('EVENTS_ONCE_SYMBOL');
+const EVENTS_BATCH_SYMBOL = Symbol('EVENTS_BATCH_SYMBOL');
+const DRIVER_INSTANCES_SYMBOL = Symbol('DRIVER_INSTANCES_SYMBOL');
+const isOnlyMode = (mode) => mode === 'onlyOne' || mode === 'onlyChild' || mode === 'onlyParent';
+/**
+ * 事件驱动器基类
+ */
+export class EventDriver {
+    constructor(engine, context) {
+        this.container = document;
+        this.contentWindow = globalThisPolyfill;
+        this.engine = engine;
+        this.context = context;
+    }
+    dispatch(event) {
+        return this.engine.dispatch(event, this.context);
+    }
+    subscribe(subscriber) {
+        return this.engine.subscribe(subscriber);
+    }
+    subscribeTo(type, subscriber) {
+        return this.engine.subscribeTo(type, subscriber);
+    }
+    subscribeWith(type, subscriber) {
+        return this.engine.subscribeWith(type, subscriber);
+    }
+    attach(container) {
+        console.error('attach must implement.');
+    }
+    detach(container) {
+        console.error('attach must implement.');
+    }
+    eventTarget(type) {
+        var _a;
+        if (type === 'resize' || type === 'scroll') {
+            if (this.container === ((_a = this.contentWindow) === null || _a === void 0 ? void 0 : _a.document)) {
+                return this.contentWindow;
+            }
+        }
+        return this.container;
+    }
+    addEventListener(type, listener, options) {
+        var _a, _b, _c, _d;
+        const target = this.eventTarget(type);
+        if (isOnlyMode(options === null || options === void 0 ? void 0 : options.mode)) {
+            target[EVENTS_ONCE_SYMBOL] = target[EVENTS_ONCE_SYMBOL] || {};
+            const constructor = this['constructor'];
+            constructor[EVENTS_ONCE_SYMBOL] = constructor[EVENTS_ONCE_SYMBOL] || {};
+            const handler = target[EVENTS_ONCE_SYMBOL][type];
+            const container = constructor[EVENTS_ONCE_SYMBOL][type];
+            if (!handler) {
+                if (container) {
+                    if (options.mode === 'onlyChild') {
+                        if (container.contains(target)) {
+                            container.removeEventListener(type, container[EVENTS_ONCE_SYMBOL][type], options);
+                            delete container[EVENTS_ONCE_SYMBOL][type];
+                        }
+                    }
+                    else if (options.mode === 'onlyParent') {
+                        if (container.contains(target))
+                            return;
+                    }
+                }
+                target.addEventListener(type, listener, options);
+                target[EVENTS_ONCE_SYMBOL][type] = listener;
+                constructor[EVENTS_ONCE_SYMBOL][type] = target;
+            }
+        }
+        else {
+            target[EVENTS_SYMBOL] = target[EVENTS_SYMBOL] || {};
+            target[EVENTS_SYMBOL][type] = target[EVENTS_SYMBOL][type] || new Map();
+            if (!((_b = (_a = target[EVENTS_SYMBOL][type]) === null || _a === void 0 ? void 0 : _a.get) === null || _b === void 0 ? void 0 : _b.call(_a, listener))) {
+                target.addEventListener(type, listener, options);
+                (_d = (_c = target[EVENTS_SYMBOL][type]) === null || _c === void 0 ? void 0 : _c.set) === null || _d === void 0 ? void 0 : _d.call(_c, listener, true);
+            }
+        }
+    }
+    removeEventListener(type, listener, options) {
+        var _a, _b;
+        const target = this.eventTarget(type);
+        if (isOnlyMode(options === null || options === void 0 ? void 0 : options.mode)) {
+            const constructor = this['constructor'];
+            constructor[EVENTS_ONCE_SYMBOL] = constructor[EVENTS_ONCE_SYMBOL] || {};
+            target[EVENTS_ONCE_SYMBOL] = target[EVENTS_ONCE_SYMBOL] || {};
+            delete constructor[EVENTS_ONCE_SYMBOL][type];
+            delete target[EVENTS_ONCE_SYMBOL][type];
+            target.removeEventListener(type, listener, options);
+        }
+        else {
+            target[EVENTS_SYMBOL] = target[EVENTS_SYMBOL] || {};
+            target[EVENTS_SYMBOL][type] = target[EVENTS_SYMBOL][type] || new Map();
+            (_b = (_a = target[EVENTS_SYMBOL][type]) === null || _a === void 0 ? void 0 : _a.delete) === null || _b === void 0 ? void 0 : _b.call(_a, listener);
+            target.removeEventListener(type, listener, options);
+        }
+    }
+    batchAddEventListener(type, listener, options) {
+        this.engine[DRIVER_INSTANCES_SYMBOL] =
+            this.engine[DRIVER_INSTANCES_SYMBOL] || [];
+        if (!this.engine[DRIVER_INSTANCES_SYMBOL].includes(this)) {
+            this.engine[DRIVER_INSTANCES_SYMBOL].push(this);
+        }
+        this.engine[DRIVER_INSTANCES_SYMBOL].forEach((driver) => {
+            const target = driver.eventTarget(type);
+            target[EVENTS_BATCH_SYMBOL] = target[EVENTS_BATCH_SYMBOL] || {};
+            if (!target[EVENTS_BATCH_SYMBOL][type]) {
+                target.addEventListener(type, listener, options);
+                target[EVENTS_BATCH_SYMBOL][type] = listener;
+            }
+        });
+    }
+    batchRemoveEventListener(type, listener, options) {
+        this.engine[DRIVER_INSTANCES_SYMBOL] =
+            this.engine[DRIVER_INSTANCES_SYMBOL] || [];
+        this.engine[DRIVER_INSTANCES_SYMBOL].forEach((driver) => {
+            const target = driver.eventTarget(type);
+            target[EVENTS_BATCH_SYMBOL] = target[EVENTS_BATCH_SYMBOL] || {};
+            target.removeEventListener(type, listener, options);
+            delete target[EVENTS_BATCH_SYMBOL][type];
+        });
+    }
+}
+/**
+ * 事件引擎
+ */
+export class Event extends Subscribable {
+    constructor(props) {
+        super();
+        this.drivers = [];
+        this.containers = [];
+        if (isArr(props === null || props === void 0 ? void 0 : props.effects)) {
+            props.effects.forEach((plugin) => {
+                plugin(this);
+            });
+        }
+        if (isArr(props === null || props === void 0 ? void 0 : props.drivers)) {
+            this.drivers = props.drivers;
+        }
+    }
+    subscribeTo(type, subscriber) {
+        return this.subscribe((event) => {
+            if (type && event instanceof type) {
+                return subscriber(event);
+            }
+        });
+    }
+    subscribeWith(type, subscriber) {
+        return this.subscribe((event) => {
+            if (isArr(type)) {
+                if (type.includes(event === null || event === void 0 ? void 0 : event.type)) {
+                    return subscriber(event);
+                }
+            }
+            else {
+                if (type && (event === null || event === void 0 ? void 0 : event.type) === type) {
+                    return subscriber(event);
+                }
+            }
+        });
+    }
+    attachEvents(container, contentWindow = globalThisPolyfill, context) {
+        if (!container)
+            return;
+        if (isWindow(container)) {
+            return this.attachEvents(container.document, container, context);
+        }
+        if (container[ATTACHED_SYMBOL])
+            return;
+        container[ATTACHED_SYMBOL] = this.drivers.map((EventDriver) => {
+            const driver = new EventDriver(this, context);
+            driver.contentWindow = contentWindow;
+            driver.container = container;
+            driver.attach(container);
+            return driver;
+        });
+        if (!this.containers.includes(container)) {
+            this.containers.push(container);
+        }
+    }
+    detachEvents(container) {
+        if (!container) {
+            this.containers.forEach((container) => {
+                this.detachEvents(container);
+            });
+            return;
+        }
+        if (isWindow(container)) {
+            return this.detachEvents(container.document);
+        }
+        if (!container[ATTACHED_SYMBOL])
+            return;
+        container[ATTACHED_SYMBOL].forEach((driver) => {
+            driver.detach(container);
+        });
+        this[DRIVER_INSTANCES_SYMBOL] = this[DRIVER_INSTANCES_SYMBOL] || [];
+        this[DRIVER_INSTANCES_SYMBOL] = this[DRIVER_INSTANCES_SYMBOL].reduce((drivers, driver) => {
+            if (driver.container === container) {
+                driver.detach(container);
+                return drivers;
+            }
+            return drivers.concat(driver);
+        }, []);
+        this.containers = this.containers.filter((item) => item !== container);
+        delete container[ATTACHED_SYMBOL];
+        delete container[EVENTS_SYMBOL];
+        delete container[EVENTS_ONCE_SYMBOL];
+        delete container[EVENTS_BATCH_SYMBOL];
+    }
+}

package/esm/globalThisPolyfill.d.ts

@@ -0,0 +1 @@
+export declare const globalThisPolyfill: Window;

package/esm/globalThisPolyfill.js

@@ -0,0 +1,22 @@
+function getGlobalThis() {
+    try {
+        if (typeof self !== 'undefined') {
+            return self;
+        }
+    }
+    catch (e) { }
+    try {
+        if (typeof globalThisPolyfill !== 'undefined') {
+            return globalThisPolyfill;
+        }
+    }
+    catch (e) { }
+    try {
+        if (typeof global !== 'undefined') {
+            return global;
+        }
+    }
+    catch (e) { }
+    return Function('return this')();
+}
+export const globalThisPolyfill = getGlobalThis();

package/esm/index.d.ts

@@ -0,0 +1,17 @@
+export * from './event';
+export * from './scroller';
+export * from './subscribable';
+export * from './coordinate';
+export * from './types';
+export * from './uid';
+export * from './clone';
+export * from './instanceof';
+export * from './lru';
+export * from './compose';
+export * from './array';
+export * from './keycode';
+export * from './animation';
+export * from './request-idle';
+export * from './element';
+export * from './globalThisPolyfill';
+export * from './observer';

package/esm/index.js

@@ -0,0 +1,17 @@
+export * from './event';
+export * from './scroller';
+export * from './subscribable';
+export * from './coordinate';
+export * from './types';
+export * from './uid';
+export * from './clone';
+export * from './instanceof';
+export * from './lru';
+export * from './compose';
+export * from './array';
+export * from './keycode';
+export * from './animation';
+export * from './request-idle';
+export * from './element';
+export * from './globalThisPolyfill';
+export * from './observer';

package/esm/instanceof.d.ts

@@ -0,0 +1 @@
+export declare const instOf: (value: any, cls: any) => boolean;

package/esm/instanceof.js

@@ -0,0 +1,11 @@
+import { isStr, isFn } from './types';
+import { globalThisPolyfill } from './globalThisPolyfill';
+export const instOf = (value, cls) => {
+    if (isFn(cls))
+        return value instanceof cls;
+    if (isStr(cls))
+        return globalThisPolyfill[cls]
+            ? value instanceof globalThisPolyfill[cls]
+            : false;
+    return false;
+};

package/esm/keycode.d.ts

@@ -0,0 +1,147 @@
+export declare enum KeyCode {
+    Backspace = "Backspace",
+    Tab = "Tab",
+    Enter = "Enter",
+    Shift = "Shift",
+    Control = "Control",
+    Alt = "Alt",
+    CapsLock = "CapsLock",
+    Escape = "Escape",
+    Space = " ",
+    PageUp = "PageUp",
+    PageDown = "PageDown",
+    End = "End",
+    Home = "Home",
+    ArrowLeft = "ArrowLeft",
+    ArrowUp = "ArrowUp",
+    ArrowRight = "ArrowRight",
+    ArrowDown = "ArrowDown",
+    Left = "Left",
+    Up = "Up",
+    Right = "Right",
+    Down = "Down",
+    Insert = "Insert",
+    Delete = "Delete",
+    Zero = "0",
+    ClosedParen = ")",
+    One = "1",
+    ExclamationMark = "!",
+    Two = "2",
+    AtSign = "@",
+    Three = "3",
+    PoundSign = "\u00A3",
+    Hash = "#",
+    Four = "4",
+    DollarSign = "$",
+    Five = "5",
+    PercentSign = "%",
+    Six = "6",
+    Caret = "^",
+    Hat = "^",
+    Seven = "7",
+    Ampersand = "&",
+    Eight = "8",
+    Star = "*",
+    Asterisk = "*",
+    Nine = "9",
+    OpenParen = "(",
+    a = "a",
+    b = "b",
+    c = "c",
+    d = "d",
+    e = "e",
+    f = "f",
+    g = "g",
+    h = "h",
+    i = "i",
+    j = "j",
+    k = "k",
+    l = "l",
+    m = "m",
+    n = "n",
+    o = "o",
+    p = "p",
+    q = "q",
+    r = "r",
+    s = "s",
+    t = "t",
+    u = "u",
+    v = "v",
+    w = "w",
+    x = "x",
+    y = "y",
+    z = "z",
+    A = "A",
+    B = "B",
+    C = "C",
+    D = "D",
+    E = "E",
+    F = "F",
+    G = "G",
+    H = "H",
+    I = "I",
+    J = "J",
+    K = "K",
+    L = "L",
+    M = "M",
+    N = "N",
+    O = "O",
+    P = "P",
+    Q = "Q",
+    R = "R",
+    S = "S",
+    T = "T",
+    U = "U",
+    V = "V",
+    W = "W",
+    X = "X",
+    Y = "Y",
+    Z = "Z",
+    Meta = "Meta",
+    LeftWindowKey = "Meta",
+    RightWindowKey = "Meta",
+    Numpad0 = "0",
+    Numpad1 = "1",
+    Numpad2 = "2",
+    Numpad3 = "3",
+    Numpad4 = "4",
+    Numpad5 = "5",
+    Numpad6 = "6",
+    Numpad7 = "7",
+    Numpad8 = "8",
+    Numpad9 = "9",
+    Multiply = "*",
+    Add = "+",
+    Subtract = "-",
+    DecimalPoint = ".",
+    MSDecimalPoint = "Decimal",
+    Divide = "/",
+    F1 = "F1",
+    F2 = "F2",
+    F3 = "F3",
+    F4 = "F4",
+    F5 = "F5",
+    F6 = "F6",
+    F7 = "F7",
+    F8 = "F8",
+    F9 = "F9",
+    F10 = "F10",
+    F11 = "F11",
+    F12 = "F12",
+    NumLock = "NumLock",
+    ScrollLock = "ScrollLock",
+    SemiColon = ";",
+    Equals = "=",
+    Comma = ",",
+    Dash = "-",
+    Period = ".",
+    UnderScore = "_",
+    PlusSign = "+",
+    ForwardSlash = "/",
+    Tilde = "~",
+    GraveAccent = "`",
+    OpenBracket = "[",
+    ClosedBracket = "]",
+    Quote = "'"
+}
+export declare const getKeyCodeFromEvent: (event: KeyboardEvent) => KeyCode;

package/esm/keycode.js

@@ -0,0 +1,150 @@
+export var KeyCode;
+(function (KeyCode) {
+    KeyCode["Backspace"] = "Backspace";
+    KeyCode["Tab"] = "Tab";
+    KeyCode["Enter"] = "Enter";
+    KeyCode["Shift"] = "Shift";
+    KeyCode["Control"] = "Control";
+    KeyCode["Alt"] = "Alt";
+    KeyCode["CapsLock"] = "CapsLock";
+    KeyCode["Escape"] = "Escape";
+    KeyCode["Space"] = " ";
+    KeyCode["PageUp"] = "PageUp";
+    KeyCode["PageDown"] = "PageDown";
+    KeyCode["End"] = "End";
+    KeyCode["Home"] = "Home";
+    KeyCode["ArrowLeft"] = "ArrowLeft";
+    KeyCode["ArrowUp"] = "ArrowUp";
+    KeyCode["ArrowRight"] = "ArrowRight";
+    KeyCode["ArrowDown"] = "ArrowDown";
+    KeyCode["Left"] = "Left";
+    KeyCode["Up"] = "Up";
+    KeyCode["Right"] = "Right";
+    KeyCode["Down"] = "Down";
+    KeyCode["Insert"] = "Insert";
+    KeyCode["Delete"] = "Delete";
+    KeyCode["Zero"] = "0";
+    KeyCode["ClosedParen"] = ")";
+    KeyCode["One"] = "1";
+    KeyCode["ExclamationMark"] = "!";
+    KeyCode["Two"] = "2";
+    KeyCode["AtSign"] = "@";
+    KeyCode["Three"] = "3";
+    KeyCode["PoundSign"] = "\u00A3";
+    KeyCode["Hash"] = "#";
+    KeyCode["Four"] = "4";
+    KeyCode["DollarSign"] = "$";
+    KeyCode["Five"] = "5";
+    KeyCode["PercentSign"] = "%";
+    KeyCode["Six"] = "6";
+    KeyCode["Caret"] = "^";
+    KeyCode["Hat"] = "^";
+    KeyCode["Seven"] = "7";
+    KeyCode["Ampersand"] = "&";
+    KeyCode["Eight"] = "8";
+    KeyCode["Star"] = "*";
+    KeyCode["Asterisk"] = "*";
+    KeyCode["Nine"] = "9";
+    KeyCode["OpenParen"] = "(";
+    KeyCode["a"] = "a";
+    KeyCode["b"] = "b";
+    KeyCode["c"] = "c";
+    KeyCode["d"] = "d";
+    KeyCode["e"] = "e";
+    KeyCode["f"] = "f";
+    KeyCode["g"] = "g";
+    KeyCode["h"] = "h";
+    KeyCode["i"] = "i";
+    KeyCode["j"] = "j";
+    KeyCode["k"] = "k";
+    KeyCode["l"] = "l";
+    KeyCode["m"] = "m";
+    KeyCode["n"] = "n";
+    KeyCode["o"] = "o";
+    KeyCode["p"] = "p";
+    KeyCode["q"] = "q";
+    KeyCode["r"] = "r";
+    KeyCode["s"] = "s";
+    KeyCode["t"] = "t";
+    KeyCode["u"] = "u";
+    KeyCode["v"] = "v";
+    KeyCode["w"] = "w";
+    KeyCode["x"] = "x";
+    KeyCode["y"] = "y";
+    KeyCode["z"] = "z";
+    KeyCode["A"] = "A";
+    KeyCode["B"] = "B";
+    KeyCode["C"] = "C";
+    KeyCode["D"] = "D";
+    KeyCode["E"] = "E";
+    KeyCode["F"] = "F";
+    KeyCode["G"] = "G";
+    KeyCode["H"] = "H";
+    KeyCode["I"] = "I";
+    KeyCode["J"] = "J";
+    KeyCode["K"] = "K";
+    KeyCode["L"] = "L";
+    KeyCode["M"] = "M";
+    KeyCode["N"] = "N";
+    KeyCode["O"] = "O";
+    KeyCode["P"] = "P";
+    KeyCode["Q"] = "Q";
+    KeyCode["R"] = "R";
+    KeyCode["S"] = "S";
+    KeyCode["T"] = "T";
+    KeyCode["U"] = "U";
+    KeyCode["V"] = "V";
+    KeyCode["W"] = "W";
+    KeyCode["X"] = "X";
+    KeyCode["Y"] = "Y";
+    KeyCode["Z"] = "Z";
+    KeyCode["Meta"] = "Meta";
+    KeyCode["LeftWindowKey"] = "Meta";
+    KeyCode["RightWindowKey"] = "Meta";
+    KeyCode["Numpad0"] = "0";
+    KeyCode["Numpad1"] = "1";
+    KeyCode["Numpad2"] = "2";
+    KeyCode["Numpad3"] = "3";
+    KeyCode["Numpad4"] = "4";
+    KeyCode["Numpad5"] = "5";
+    KeyCode["Numpad6"] = "6";
+    KeyCode["Numpad7"] = "7";
+    KeyCode["Numpad8"] = "8";
+    KeyCode["Numpad9"] = "9";
+    KeyCode["Multiply"] = "*";
+    KeyCode["Add"] = "+";
+    KeyCode["Subtract"] = "-";
+    KeyCode["DecimalPoint"] = ".";
+    KeyCode["MSDecimalPoint"] = "Decimal";
+    KeyCode["Divide"] = "/";
+    KeyCode["F1"] = "F1";
+    KeyCode["F2"] = "F2";
+    KeyCode["F3"] = "F3";
+    KeyCode["F4"] = "F4";
+    KeyCode["F5"] = "F5";
+    KeyCode["F6"] = "F6";
+    KeyCode["F7"] = "F7";
+    KeyCode["F8"] = "F8";
+    KeyCode["F9"] = "F9";
+    KeyCode["F10"] = "F10";
+    KeyCode["F11"] = "F11";
+    KeyCode["F12"] = "F12";
+    KeyCode["NumLock"] = "NumLock";
+    KeyCode["ScrollLock"] = "ScrollLock";
+    KeyCode["SemiColon"] = ";";
+    KeyCode["Equals"] = "=";
+    KeyCode["Comma"] = ",";
+    KeyCode["Dash"] = "-";
+    KeyCode["Period"] = ".";
+    KeyCode["UnderScore"] = "_";
+    KeyCode["PlusSign"] = "+";
+    KeyCode["ForwardSlash"] = "/";
+    KeyCode["Tilde"] = "~";
+    KeyCode["GraveAccent"] = "`";
+    KeyCode["OpenBracket"] = "[";
+    KeyCode["ClosedBracket"] = "]";
+    KeyCode["Quote"] = "'";
+})(KeyCode || (KeyCode = {}));
+export const getKeyCodeFromEvent = (event) => {
+    return event.key;
+};