@suey/rxp-meta 0.0.2 → 0.1.0

package/dist/esm/src/extension/At.js

@@ -0,0 +1,109 @@
+import { InnerZustandStoreManager } from '../base/InnerZustandStoreManager';
+import { ExtensionErrors } from '../constants';
+export const ExtensionSymbolTag = Symbol('ExtensionSymbolTag');
+export const ExtensionSymbolTagKey = Symbol('__TAG__');
+export class ExtensionManager extends InnerZustandStoreManager {
+    defineExtension(define) {
+        if (!Reflect.has(define, 'name'))
+            throw new Error(ExtensionErrors.ExtensionNameIsRequired);
+        if (!(typeof define.name === 'string'))
+            throw new Error(ExtensionErrors.ExtensionNameMustBeString);
+        if (!Reflect.has(define, 'version'))
+            throw new Error(ExtensionErrors.ExtensionVersionIsRequired);
+        if (!(typeof define.version === 'string'))
+            throw new Error(ExtensionErrors.ExtensionVersionMustBeString);
+        if (!Reflect.has(define, 'onActivated'))
+            throw new Error(ExtensionErrors.ExtensionOnActivatedIsRequired);
+        if (typeof define.onActivated !== 'function')
+            throw new Error(ExtensionErrors.ExtensionOnActivatedMustBeFunction);
+        const name = define['name'];
+        const version = define['version'];
+        const extensionInnerInstance = {
+            name: name,
+            version: version,
+            isRegistered: false,
+            isUnregistered: false,
+            isActivated: false,
+            isDeactivated: false,
+        };
+        const that = this;
+        const onInstalled = function () {
+        };
+        const extension = {
+            get name() {
+                return extensionInnerInstance.name;
+            },
+            get version() {
+                return extensionInnerInstance.version;
+            },
+            get isInstalled() {
+                return extensionInnerInstance.isRegistered;
+            },
+            get isUninstalled() {
+                return extensionInnerInstance.isUnregistered;
+            },
+            get isActivated() {
+                return extensionInnerInstance.isActivated;
+            },
+            get isDeactivated() {
+                return extensionInnerInstance.isDeactivated;
+            },
+            meta: define['meta'] ?? void 0,
+            get onInstalled() {
+                return onInstalled;
+            },
+            get onUninstalled() {
+                return () => {
+                };
+            },
+            get onActivated() {
+                return () => {
+                    return () => {
+                    };
+                };
+            },
+            get onDeactivated() {
+                return () => {
+                };
+            }
+        };
+        Reflect.defineProperty(extension, ExtensionSymbolTagKey, {
+            enumerable: false,
+            writable: false,
+            value: ExtensionSymbolTag,
+            configurable: false
+        });
+        return extension;
+    }
+    isExtension(extension) {
+        if (typeof extension !== 'object' || extension === null)
+            return false;
+        if (!Reflect.has(extension, ExtensionSymbolTagKey))
+            return false;
+        const tag = Reflect.get(extension, ExtensionSymbolTagKey);
+        return tag === ExtensionSymbolTag;
+    }
+    registerExtension(extensionName) {
+        if (!(typeof extensionName === 'string'))
+            throw new Error(ExtensionErrors.ExtensionNameMustBeString);
+        if (!this.isExtension(extensionName))
+            throw new Error(ExtensionErrors.ExtensionIsNotExist);
+        const extension = this.getExtension(extensionName);
+        if (!extension)
+            throw new Error(ExtensionErrors.ExtensionIsNotExist);
+        extension.onInstalled?.();
+    }
+    unregisterExtension() {
+    }
+    activatedExtension() {
+    }
+    deactivatedExtension() {
+    }
+    getExtension(extensionName) {
+    }
+    getExtensions() {
+    }
+    useExtensionsList() {
+    }
+}
+0;

package/dist/esm/src/extension/ExtensionManager.js

@@ -1,70 +1,51 @@
-import { InnerZustandStoreManager } from '../base/InnerZustandStoreManager';
 import { useState } from 'react';
+import { RxpInnerStore } from '../base/index';
 const ExtensionSymbolTag = Symbol('ExtensionSymbolTag');
-export class ExtensionManager extends 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;
+export class Extension {
+    __TAG__ = ExtensionSymbolTag;
+    isActivated = false;
+    name;
+    version;
+    meta;
+    onActivated;
+    onDeactivated;
+    constructor(options) {
+        const { name, version, meta, onActivated, onDeactivated } = options;
+        this.name = name;
+        this.version = version;
+        this.meta = meta;
+        this.onActivated = onActivated;
+        this.onDeactivated = onDeactivated;
     }
-    isExtension(extension) {
+    getIsActivated() {
+        return this.isActivated;
+    }
+    async activated() {
+        await this.onActivated();
+        this.isActivated = true;
+    }
+    async deactivated() {
+        await this.onDeactivated?.();
+        this.isActivated = false;
+    }
+    static isExtension(extension) {
         if (typeof extension !== 'object')
             return false;
         const hasTAG = Reflect.has(extension, '__TAG__');
-        return hasTAG;
+        if (!hasTAG)
+            return false;
+        const tag = Reflect.get(extension, '__TAG__');
+        return tag === ExtensionSymbolTag;
+    }
+}
+export class ExtensionManager {
+    rxpInnerStore = new RxpInnerStore();
+    extNameMapStore = new Map();
+    defineExtension(define) {
+        return new Extension(define);
+    }
+    isExtension(extension) {
+        return Extension.isExtension(extension);
     }
     hasExtension(extensionName) {
         const has = this.extNameMapStore.has(extensionName);
@@ -76,7 +57,7 @@ export class ExtensionManager extends InnerZustandStoreManager {
     getExtension(extensionName) {
         if (!this.hasExtension(extensionName))
             return null;
-        return this.extNameMapStore.get(extensionName)?.extension ?? null;
+        return this.extNameMapStore.get(extensionName) ?? null;
     }
     registerExtension(extension) {
         if (!this.isExtension(extension))
@@ -86,47 +67,31 @@ export class ExtensionManager extends InnerZustandStoreManager {
             console.error(`试图重新注册一个已存在得扩展：应该先移除再注册`);
             return;
         }
-        const extensionLifecycle = {
-            extension: extension,
-            isActivated: false,
-        };
-        this.extNameMapStore.set(name, extensionLifecycle);
+        this.extNameMapStore.set(name, extension);
+        this.rxpInnerStore.update();
     }
-    async activatedExtension(name, context) {
-        const lifecycle = this.extNameMapStore.get(name);
-        if (!lifecycle)
+    async activatedExtension(name) {
+        const extension = this.extNameMapStore.get(name);
+        if (!extension)
             throw new Error(`试图激活一个不存在得扩展`);
-        if (lifecycle.isActivated)
-            return;
-        if (lifecycle.extension.onActivated)
-            await lifecycle.extension.onActivated(context);
-        lifecycle.isActivated = true;
+        return extension.activated();
     }
-    async deactivatedExtension(name, context) {
-        const lifecycle = this.extNameMapStore.get(name);
-        if (!lifecycle)
+    async deactivatedExtension(name) {
+        const extension = this.extNameMapStore.get(name);
+        if (!extension)
             throw new Error(`试图去活一个不存在得扩展`);
-        if (!lifecycle.isActivated)
-            return;
-        if (lifecycle.extension.onDeactivated)
-            await lifecycle.extension.onDeactivated(context);
-        lifecycle.isActivated = false;
+        return extension.deactivated();
     }
-    async delExtension(name, context) {
-        const lifecycle = this.extNameMapStore.get(name);
-        if (!lifecycle)
+    async delExtension(name) {
+        const extension = this.extNameMapStore.get(name);
+        if (!extension)
             throw new Error(`试图删除一个不存在得扩展`);
-        if (lifecycle.isActivated) {
-            if (lifecycle.extension.onDeactivated) {
-                await lifecycle.extension.onDeactivated(context);
-            }
-        }
-        if (!lifecycle.isActivated) {
-            this.extNameMapStore.delete(name);
-        }
+        extension.deactivated();
+        this.extNameMapStore.delete(name);
+        this.rxpInnerStore.update();
     }
     useExtensionsList() {
-        const value = this.useStoreValue();
+        const value = this.rxpInnerStore.useValueToRenderReactComponent();
         const [statusState] = useState(() => ({
             value: void 0
         }));
@@ -135,12 +100,11 @@ export class ExtensionManager extends InnerZustandStoreManager {
         });
         if (statusState.value !== value) {
             statusState.value = value;
-            const extensions = [];
-            for (const ext of this.extNameMapStore.values()) {
-                extensions.push(ext.extension);
-            }
-            normalState.extensions = extensions;
+            normalState.extensions = [...this.extNameMapStore.values()];
         }
         return [normalState.extensions];
     }
+    getExtensions() {
+        return [...this.extNameMapStore.values()];
+    }
 }

package/dist/esm/src/extension/ExtensionManager.old.js

@@ -0,0 +1,152 @@
+import { InnerZustandStoreManager } from '../base/InnerZustandStoreManager';
+import { useState } from 'react';
+const ExtensionSymbolTag = Symbol('ExtensionSymbolTag');
+export class ExtensionManager extends InnerZustandStoreManager {
+    extNameMapStore = new Map();
+    defineExtension(define) {
+        if (!Reflect.has(define, 'name'))
+            throw new Error(`Extension name is required`);
+        if (!(typeof define.name === 'string'))
+            throw new Error(`Extension name must be 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.useStoreValueToRerenderComponent();
+        const [statusState] = useState(() => ({
+            value: void 0
+        }));
+        const [normalState] = 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];
+    }
+    getExtensions() {
+        const extensions = [];
+        for (const ext of this.extNameMapStore.values()) {
+            extensions.push(ext.extension);
+        }
+        return extensions;
+    }
+}