@suey/rxp-meta 0.0.1

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Evrone <mail@evrone.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/commonjs/base/InnerZustandStoreManager.d.ts

@@ -0,0 +1,14 @@
+export interface InnerStore {
+    value: {};
+}
+export type InnerStoreListener = () => void;
+export type InnerStoreDestroyListener = () => void;
+export declare abstract class InnerZustandStoreManager {
+    private readonly store;
+    private readonly listeners;
+    private readonly unsubscribe;
+    protected updateStore(): void;
+    protected useStoreValue(): {};
+    protected subscribe(listener: InnerStoreListener): InnerStoreDestroyListener;
+    protected destroy(): void;
+}

package/dist/commonjs/base/InnerZustandStoreManager.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InnerZustandStoreManager = void 0;
+const zustand_1 = require("zustand");
+const immer_1 = require("zustand/middleware/immer");
+class InnerZustandStoreManager {
+    store = (0, zustand_1.create)()((0, immer_1.immer)(() => {
+        return {
+            value: {}
+        };
+    }));
+    listeners = new Set();
+    unsubscribe = this.store.subscribe(() => {
+        this.listeners.forEach(listener => listener());
+    });
+    updateStore() {
+        this.store.setState({ value: {} });
+    }
+    useStoreValue() {
+        return this.store(store => store.value);
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    destroy() {
+        this.unsubscribe();
+    }
+}
+exports.InnerZustandStoreManager = InnerZustandStoreManager;

package/dist/commonjs/extension/ExtensionManager.d.ts

@@ -0,0 +1,14 @@
+import type { Extension, ExtensionName, ExtractExtensionContext } from './declare';
+import { InnerZustandStoreManager } from '../base/InnerZustandStoreManager';
+export declare class ExtensionManager<Ext extends Extension> extends InnerZustandStoreManager {
+    private readonly extNameMapStore;
+    defineExtension<DExt extends Ext>(define: DExt): DExt;
+    isExtension<DExt extends Ext>(extension: DExt | any): extension is DExt;
+    hasExtension(extensionName: ExtensionName): boolean;
+    getExtension(extensionName: ExtensionName): Extension<any> | null;
+    registerExtension<DExt extends Ext>(extension: DExt): void;
+    activatedExtension<Context extends ExtractExtensionContext<Ext>>(name: ExtensionName, context: Context): Promise<void>;
+    deactivatedExtension<Context extends ExtractExtensionContext<Ext>>(name: ExtensionName, context: Context): Promise<void>;
+    delExtension<Context extends ExtractExtensionContext<Ext>>(name: ExtensionName, context: Context): Promise<void>;
+    useExtensionsList(): readonly [Extension[]];
+}

package/dist/commonjs/extension/ExtensionManager.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionManager = void 0;
+const InnerZustandStoreManager_1 = require("../base/InnerZustandStoreManager");
+const react_1 = require("react");
+const ExtensionSymbolTag = Symbol('ExtensionSymbolTag');
+class ExtensionManager extends InnerZustandStoreManager_1.InnerZustandStoreManager {
+    extNameMapStore = new Map();
+    defineExtension(define) {
+        if (!Reflect.has(define, 'name'))
+            throw new Error(`Extension name is required`);
+        if (!(typeof define.name === 'symbol') &&
+            !(typeof define.name === 'string'))
+            throw new Error(`Extension name must be symbol or string`);
+        if (!Reflect.has(define, 'version'))
+            throw new Error(`Extension version is required`);
+        if (Reflect.has(define, 'onActivated') && !Reflect.has(define, 'onDeactivated'))
+            throw new Error(`Extension lifecycle: onActivated and onDeactivated must be set at same time`);
+        if (Reflect.has(define, 'onDeactivated') && !Reflect.has(define, 'onActivated'))
+            throw new Error(`Extension lifecycle: onActivated and onDeactivated must be set at same time`);
+        const name = define.name;
+        const version = define.version;
+        const onActivated = define.onActivated;
+        const onDeactivated = define.onDeactivated;
+        const extension = {
+            ...define,
+            onActivated: async (...args) => {
+                if (!this.extNameMapStore.has(name)) {
+                    console.error(`当前扩展还未注册加载, 但却错误得试图激活`);
+                    return;
+                }
+                const lifecycle = this.extNameMapStore.get(name);
+                if (!lifecycle)
+                    return;
+                if (lifecycle.isActivated) {
+                    console.error(`当前扩展已被激活, 但却错误得试图再次激活`);
+                    return;
+                }
+                await onActivated?.call(extension, ...args);
+                lifecycle.isActivated = true;
+            },
+            onDeactivated: async (...args) => {
+                if (!this.extNameMapStore.has(name)) {
+                    console.error(`当前扩展还未注册加载, 但却错误得试图去活`);
+                    return;
+                }
+                const lifecycle = this.extNameMapStore.get(name);
+                if (!lifecycle)
+                    return;
+                if (!lifecycle.isActivated) {
+                    console.error(`当前扩展未被激活, 但却错误得试图去活`);
+                    return;
+                }
+                await onDeactivated?.call(extension, ...args);
+                lifecycle.isActivated = false;
+            }
+        };
+        Reflect.defineProperty(extension, '__TAG__', {
+            enumerable: false,
+            writable: false,
+            value: ExtensionSymbolTag,
+            configurable: false
+        });
+        return extension;
+    }
+    isExtension(extension) {
+        if (typeof extension !== 'object')
+            return false;
+        const hasTAG = Reflect.has(extension, '__TAG__');
+        return hasTAG;
+    }
+    hasExtension(extensionName) {
+        const has = this.extNameMapStore.has(extensionName);
+        const lifecycle = this.extNameMapStore.get(extensionName);
+        if (has && !lifecycle)
+            throw new Error(`数据状态异常`);
+        return has;
+    }
+    getExtension(extensionName) {
+        if (!this.hasExtension(extensionName))
+            return null;
+        return this.extNameMapStore.get(extensionName)?.extension ?? null;
+    }
+    registerExtension(extension) {
+        if (!this.isExtension(extension))
+            throw new Error(`参数非法, 不是一个有效的扩展`);
+        const name = extension.name;
+        if (this.hasExtension(name)) {
+            console.error(`试图重新注册一个已存在得扩展：应该先移除再注册`);
+            return;
+        }
+        const extensionLifecycle = {
+            extension: extension,
+            isActivated: false,
+        };
+        this.extNameMapStore.set(name, extensionLifecycle);
+    }
+    async activatedExtension(name, context) {
+        const lifecycle = this.extNameMapStore.get(name);
+        if (!lifecycle)
+            throw new Error(`试图激活一个不存在得扩展`);
+        if (lifecycle.isActivated)
+            return;
+        if (lifecycle.extension.onActivated)
+            await lifecycle.extension.onActivated(context);
+        lifecycle.isActivated = true;
+    }
+    async deactivatedExtension(name, context) {
+        const lifecycle = this.extNameMapStore.get(name);
+        if (!lifecycle)
+            throw new Error(`试图去活一个不存在得扩展`);
+        if (!lifecycle.isActivated)
+            return;
+        if (lifecycle.extension.onDeactivated)
+            await lifecycle.extension.onDeactivated(context);
+        lifecycle.isActivated = false;
+    }
+    async delExtension(name, context) {
+        const lifecycle = this.extNameMapStore.get(name);
+        if (!lifecycle)
+            throw new Error(`试图删除一个不存在得扩展`);
+        if (lifecycle.isActivated) {
+            if (lifecycle.extension.onDeactivated) {
+                await lifecycle.extension.onDeactivated(context);
+            }
+        }
+        if (!lifecycle.isActivated) {
+            this.extNameMapStore.delete(name);
+        }
+    }
+    useExtensionsList() {
+        const value = this.useStoreValue();
+        const [statusState] = (0, react_1.useState)(() => ({
+            value: void 0
+        }));
+        const [normalState] = (0, react_1.useState)({
+            extensions: [],
+        });
+        if (statusState.value !== value) {
+            statusState.value = value;
+            const extensions = [];
+            for (const ext of this.extNameMapStore.values()) {
+                extensions.push(ext.extension);
+            }
+            normalState.extensions = extensions;
+        }
+        return [normalState.extensions];
+    }
+}
+exports.ExtensionManager = ExtensionManager;

package/dist/commonjs/extension/declare.d.ts

@@ -0,0 +1,13 @@
+export type ExtensionName = string | symbol;
+export interface Extension<Context = any> {
+    readonly name: ExtensionName;
+    readonly version: string | number;
+    readonly meta?: any;
+    readonly onActivated?: (this: this, context: Context) => (void | Promise<void>);
+    readonly onDeactivated?: (this: this, context: Context) => (void | Promise<void>);
+}
+export interface ExtensionWithLifecycle {
+    readonly extension: Extension;
+    isActivated: boolean;
+}
+export type ExtractExtensionContext<Ext extends Extension> = Parameters<Exclude<Ext['onActivated'], undefined>>[0];

package/dist/commonjs/extension/declare.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/commonjs/extension/index.d.ts

@@ -0,0 +1,2 @@
+export type { Extension, ExtensionName, ExtensionWithLifecycle, ExtractExtensionContext } from './declare';
+export { ExtensionManager } from './ExtensionManager';

package/dist/commonjs/extension/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionManager = void 0;
+var ExtensionManager_1 = require("./ExtensionManager");
+Object.defineProperty(exports, "ExtensionManager", { enumerable: true, get: function () { return ExtensionManager_1.ExtensionManager; } });

package/dist/commonjs/index.d.ts

@@ -0,0 +1,3 @@
+export * from './extension';
+export * from './metadata';
+export { Commands } from './rApp';

package/dist/commonjs/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Commands = void 0;
+__exportStar(require("./extension"), exports);
+__exportStar(require("./metadata"), exports);
+var rApp_1 = require("./rApp");
+Object.defineProperty(exports, "Commands", { enumerable: true, get: function () { return rApp_1.Commands; } });

package/dist/commonjs/metadata/MetadataManager.d.ts

@@ -0,0 +1,19 @@
+import type { ExtractSingleEntries, ExtractVectorEntries, ExtractElInArray, MetadataStoreChangeListener, MetadataStoreListenerPayload } from './declare';
+import { InnerZustandStoreManager } from '../base/InnerZustandStoreManager';
+export declare class MetadataManager<MetadataEntries extends Record<string, any>> extends InnerZustandStoreManager {
+    private readonly metadataMap;
+    private readonly metadataChangeListeners;
+    protected triggerMetadataChangeListeners(payload: MetadataStoreListenerPayload): void;
+    subscribeMetadataStoreChanged(listener: MetadataStoreChangeListener): () => void;
+    defineMetadata<MetadataKey extends keyof MetadataEntries>(metadataKey: MetadataKey, metadata: MetadataEntries[MetadataKey]): void;
+    getMetadata<MetadataKey extends keyof MetadataEntries>(metadataKey: MetadataKey): MetadataEntries[MetadataKey] | null;
+    delMetadata<MetadataKey extends keyof MetadataEntries>(metadataKey: MetadataKey): void;
+    defineMetadataInSingle<MetadataKey extends keyof ExtractSingleEntries<MetadataEntries>>(metadataKey: MetadataKey, metadata: MetadataEntries[MetadataKey]): void;
+    defineMetadataInVector<MetadataKey extends keyof ExtractVectorEntries<MetadataEntries>>(metadataKey: MetadataKey, metadata: ExtractElInArray<MetadataEntries[MetadataKey]>): void;
+    delMetadataInVector<MetadataKey extends keyof ExtractVectorEntries<MetadataEntries>>(metadataKey: MetadataKey, metadata: ExtractElInArray<MetadataEntries[MetadataKey]>): void;
+    useMetadata<MetadataKey extends keyof MetadataEntries>(metadataKey: MetadataKey): MetadataEntries[MetadataKey] | null;
+    useOldestMetadataInVector<MetadataKey extends keyof ExtractVectorEntries<MetadataEntries>>(metadataKey: MetadataKey): ExtractElInArray<MetadataEntries[MetadataKey]> | null;
+    useLatestMetadataInVector<MetadataKey extends keyof ExtractVectorEntries<MetadataEntries>>(metadataKey: MetadataKey): ExtractElInArray<MetadataEntries[MetadataKey]> | null;
+    useAllMetadata(): Map<string | number | symbol, any>;
+    hasMetadata<MetadataKey extends keyof MetadataEntries>(metadataKey: MetadataKey): boolean;
+}

package/dist/commonjs/metadata/MetadataManager.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataManager = void 0;
+const react_1 = require("react");
+const InnerZustandStoreManager_1 = require("../base/InnerZustandStoreManager");
+class MetadataManager extends InnerZustandStoreManager_1.InnerZustandStoreManager {
+    metadataMap = new Map();
+    metadataChangeListeners = new Set();
+    triggerMetadataChangeListeners(payload) {
+        this.metadataChangeListeners.forEach(listener => listener(payload));
+    }
+    subscribeMetadataStoreChanged(listener) {
+        this.metadataChangeListeners.add(listener);
+        return () => {
+            this.metadataChangeListeners.delete(listener);
+        };
+    }
+    defineMetadata(metadataKey, metadata) {
+        this.metadataMap.set(metadataKey, metadata);
+        super.updateStore();
+        this.triggerMetadataChangeListeners({
+            action: 'Define',
+            type: 'All',
+            metadataKey: metadataKey,
+            metadata: metadata
+        });
+    }
+    getMetadata(metadataKey) {
+        return (this.metadataMap.get(metadataKey)) ?? null;
+    }
+    delMetadata(metadataKey) {
+        if (!this.hasMetadata(metadataKey))
+            return;
+        this.metadataMap.delete(metadataKey);
+        super.updateStore();
+        this.triggerMetadataChangeListeners({
+            action: 'Remove',
+            type: 'All',
+            metadataKey: metadataKey,
+            metadata: this.metadataMap.get(metadataKey)
+        });
+    }
+    defineMetadataInSingle(metadataKey, metadata) {
+        this.metadataMap.set(metadataKey, metadata);
+        super.updateStore();
+        this.triggerMetadataChangeListeners({
+            action: 'Define',
+            type: 'Single',
+            metadataKey: metadataKey,
+            metadata: metadata
+        });
+    }
+    defineMetadataInVector(metadataKey, metadata) {
+        if (!this.hasMetadata(metadataKey)) {
+            this.metadataMap.set(metadataKey, [metadata]);
+            super.updateStore();
+            this.triggerMetadataChangeListeners({
+                action: 'Define',
+                type: 'Vector',
+                metadataKey: metadataKey,
+                metadata: [metadata]
+            });
+            return;
+        }
+        const vector = this.metadataMap.get(metadataKey);
+        if (!Array.isArray(vector))
+            throw new Error(`defineMetadataInVector: current metadata value is not an array`);
+        const vectorSet = new Set(vector);
+        if (vectorSet.has(metadata))
+            return;
+        vectorSet.add(metadata);
+        const newMetadata = Array.from(vectorSet);
+        this.metadataMap.set(metadataKey, newMetadata);
+        super.updateStore();
+        this.triggerMetadataChangeListeners({
+            action: 'Define',
+            type: 'Vector',
+            metadataKey: metadataKey,
+            metadata: newMetadata
+        });
+    }
+    delMetadataInVector(metadataKey, metadata) {
+        if (!this.hasMetadata(metadataKey))
+            return;
+        const vector = this.metadataMap.get(metadataKey);
+        if (!Array.isArray(vector))
+            throw new Error(`delMetadataInVector: current metadata value is not an array`);
+        if (vector.length === 0) {
+            this.metadataMap.delete(metadataKey);
+            return;
+        }
+        const fVector = vector.filter(v => v !== metadata);
+        if (fVector.length === 0) {
+            this.metadataMap.delete(metadataKey);
+            super.updateStore();
+            this.triggerMetadataChangeListeners({
+                action: 'Remove',
+                type: 'Vector',
+                metadataKey: metadataKey,
+                metadata: []
+            });
+            return;
+        }
+        this.metadataMap.delete(metadataKey);
+        super.updateStore();
+        this.triggerMetadataChangeListeners({
+            action: 'Remove',
+            type: 'Vector',
+            metadataKey: metadataKey,
+            metadata: fVector
+        });
+    }
+    useMetadata(metadataKey) {
+        const [_, setState] = (0, react_1.useState)({});
+        const [normalState] = (0, react_1.useState)(() => ({
+            isMounted: false,
+            data: this.getMetadata(metadataKey),
+            unsubscribe: void 0
+        }));
+        const [syncState] = (0, react_1.useState)(() => ({
+            needSync: false
+        }));
+        const updateState = (0, react_1.useMemo)(() => {
+            const timeout = 20;
+            let timer = void 0;
+            return () => {
+                if (timer)
+                    clearTimeout(timer);
+                timer = setTimeout(() => {
+                    timer = void 0;
+                    if (!normalState.isMounted) {
+                        syncState.needSync = true;
+                        return;
+                    }
+                    setState({});
+                }, timeout);
+            };
+        }, []);
+        if (!normalState.unsubscribe) {
+            normalState.unsubscribe = super.subscribe(() => {
+                const data = this.getMetadata(metadataKey);
+                if (data !== normalState.data) {
+                    normalState.data = data;
+                    updateState();
+                }
+            });
+        }
+        (0, react_1.useLayoutEffect)(() => {
+            normalState.isMounted = true;
+            if (syncState.needSync)
+                updateState();
+            return () => {
+                normalState.isMounted = false;
+                if (normalState.unsubscribe)
+                    normalState.unsubscribe();
+                normalState.unsubscribe = void 0;
+            };
+        }, []);
+        return normalState.data;
+    }
+    useOldestMetadataInVector(metadataKey) {
+        const metadata = this.useMetadata(metadataKey);
+        if (metadata && Array.isArray(metadata))
+            return metadata[0] ?? null;
+        return null;
+    }
+    useLatestMetadataInVector(metadataKey) {
+        const metadata = this.useMetadata(metadataKey);
+        if (metadata && Array.isArray(metadata))
+            return metadata[metadata.length - 1] ?? null;
+        return null;
+    }
+    useAllMetadata() {
+        super.useStoreValue();
+        return this.metadataMap;
+    }
+    hasMetadata(metadataKey) {
+        return this.metadataMap.has(metadataKey);
+    }
+}
+exports.MetadataManager = MetadataManager;

package/dist/commonjs/metadata/declare.d.ts

@@ -0,0 +1,19 @@
+type IsNever<T, SuccessReturnType, FailReturnType> = T extends never ? SuccessReturnType : FailReturnType;
+type IsAny<T, SuccessReturnType, FailReturnType> = IsNever<T, 'yes', 'no'> extends 'no' ? FailReturnType : SuccessReturnType;
+export type ExtractElInArray<T> = IsAny<T, never, T extends (infer U)[] ? U : never>;
+export type ExtractVectorEntries<Entries> = {
+    [Key in keyof Entries as (IsAny<Entries[Key], never, Entries[Key] extends unknown[] ? Key : never>)]: Entries[Key];
+};
+export type ExtractSingleEntries<Entries> = {
+    [Key in keyof Entries as Entries[Key] extends unknown[] ? never : Key]: Entries[Key];
+};
+export type MetadataAction = 'Define' | 'Remove';
+export type MetadataType = 'Vector' | 'Single' | 'All';
+export interface MetadataStoreListenerPayload {
+    action: MetadataAction;
+    type: MetadataType;
+    metadataKey: number | string | symbol;
+    metadata: unknown;
+}
+export type MetadataStoreChangeListener = (payload: MetadataStoreListenerPayload) => void;
+export {};

package/dist/commonjs/metadata/declare.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/commonjs/metadata/index.d.ts

@@ -0,0 +1,2 @@
+export { MetadataManager } from './MetadataManager';
+export type { MetadataAction, MetadataType, MetadataStoreChangeListener, MetadataStoreListenerPayload } from './declare';

package/dist/commonjs/metadata/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataManager = void 0;
+var MetadataManager_1 = require("./MetadataManager");
+Object.defineProperty(exports, "MetadataManager", { enumerable: true, get: function () { return MetadataManager_1.MetadataManager; } });

package/dist/commonjs/rApp.d.ts

@@ -0,0 +1,99 @@
+export declare const Commands: {
+    readonly Ctrl: readonly ["ctrl"];
+    readonly CtrlLeft: readonly [];
+    readonly CtrlRight: readonly [];
+    readonly Command: readonly [];
+    readonly Mod: readonly ["mod"];
+    readonly Option: readonly [];
+    readonly Alt: readonly ["alt"];
+    readonly AltLeft: readonly [];
+    readonly AltRight: readonly [];
+    readonly Shift: readonly [];
+    readonly ShiftLeft: readonly [];
+    readonly ShiftRight: readonly [];
+    readonly Esc: readonly [];
+    readonly Enter: readonly [];
+    readonly Space: readonly [];
+    readonly PageUp: readonly [];
+    readonly PageDown: readonly [];
+    readonly Home: readonly [];
+    readonly End: readonly [];
+    readonly Tab: readonly [];
+    readonly Backspace: readonly [];
+    readonly Delete: readonly [];
+    readonly Insert: readonly [];
+    readonly ArrowUp: readonly [];
+    readonly ArrowDown: readonly [];
+    readonly ArrowLeft: readonly [];
+    readonly ArrowRight: readonly [];
+    readonly PrintScreen: readonly [];
+    readonly F1: readonly [];
+    readonly F2: readonly [];
+    readonly F3: readonly [];
+    readonly F4: readonly [];
+    readonly F5: readonly [];
+    readonly F6: readonly [];
+    readonly F7: readonly [];
+    readonly F8: readonly [];
+    readonly F9: readonly [];
+    readonly F10: readonly [];
+    readonly F11: readonly [];
+    readonly F12: readonly [];
+    readonly Num0: readonly [];
+    readonly Num1: readonly [];
+    readonly Num2: readonly [];
+    readonly Num3: readonly [];
+    readonly Num4: readonly [];
+    readonly Num5: readonly [];
+    readonly Num6: readonly [];
+    readonly Num7: readonly [];
+    readonly Num8: readonly [];
+    readonly Num9: readonly [];
+    readonly Numpad0: readonly [];
+    readonly Numpad1: readonly [];
+    readonly Numpad2: readonly [];
+    readonly Numpad3: readonly [];
+    readonly Numpad4: readonly [];
+    readonly Numpad5: readonly [];
+    readonly Numpad6: readonly [];
+    readonly Numpad7: readonly [];
+    readonly Numpad8: readonly [];
+    readonly Numpad9: readonly [];
+    readonly NumpadAdd: readonly [];
+    readonly NumpadSubtract: readonly [];
+    readonly NumpadMultiply: readonly [];
+    readonly NumpadDivide: readonly [];
+    readonly NumpadDecimal: readonly [];
+    readonly NumpadEnter: readonly [];
+    readonly NumLock: readonly [];
+    readonly ScrollLock: readonly [];
+    readonly Pause: readonly [];
+    readonly CapsLock: readonly [];
+    readonly Windows: readonly [];
+    readonly A: readonly ["a"];
+    readonly B: readonly ["b"];
+    readonly C: readonly ["c"];
+    readonly D: readonly ["d"];
+    readonly E: readonly ["e"];
+    readonly F: readonly ["f"];
+    readonly G: readonly ["g"];
+    readonly H: readonly ["h"];
+    readonly I: readonly ["i"];
+    readonly J: readonly ["j"];
+    readonly K: readonly ["k"];
+    readonly L: readonly ["l"];
+    readonly M: readonly ["m"];
+    readonly N: readonly ["n"];
+    readonly O: readonly ["o"];
+    readonly P: readonly ["p"];
+    readonly Q: readonly ["q"];
+    readonly R: readonly ["r"];
+    readonly S: readonly ["s"];
+    readonly T: readonly ["t"];
+    readonly U: readonly ["u"];
+    readonly V: readonly ["v"];
+    readonly W: readonly ["w"];
+    readonly X: readonly ["x"];
+    readonly Y: readonly ["y"];
+    readonly Z: readonly ["z"];
+};