@suey/rxp-meta 0.0.3 → 0.1.1

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;
+    }
+}

package/dist/esm/src/metadata/MetadataManager.js

@@ -1,150 +1,134 @@
-import { useCallback, useLayoutEffect, useState } from 'react';
-import { InnerZustandStoreManager } from '../base/InnerZustandStoreManager';
-export class MetadataManager extends InnerZustandStoreManager {
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react';
+import { RxpInnerStore } from '../base/index';
+export class MetadataManager {
+    rxpInnerStore = new RxpInnerStore();
     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);
-        };
+    constructor() {
+        this.metadataMap.clear();
     }
     defineMetadata(metadataKey, metadata) {
         this.metadataMap.set(metadataKey, metadata);
-        super.updateStore();
-        this.triggerMetadataChangeListeners({
-            action: 'Define',
-            type: 'All',
-            metadataKey: metadataKey,
-            metadata: metadata
-        });
+        this.rxpInnerStore.update();
+        return () => {
+            this.delMetadata(metadataKey);
+        };
     }
     getMetadata(metadataKey) {
         return (this.metadataMap.get(metadataKey)) ?? null;
     }
+    getMetadataLatestInVector(metadataKey) {
+        return (this.metadataMap.get(metadataKey) ?? [])[this.metadataMap.get(metadataKey)?.length - 1] ?? null;
+    }
+    getMetadataOldestInVector(metadataKey) {
+        return (this.metadataMap.get(metadataKey) ?? [])[0] ?? 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)
-        });
+        this.rxpInnerStore.update();
     }
     defineMetadataInSingle(metadataKey, metadata) {
         this.metadataMap.set(metadataKey, metadata);
-        super.updateStore();
-        this.triggerMetadataChangeListeners({
-            action: 'Define',
-            type: 'Single',
-            metadataKey: metadataKey,
-            metadata: metadata
-        });
+        this.rxpInnerStore.update();
+        return () => {
+            this.delMetadata(metadataKey);
+        };
     }
     defineMetadataInVector(metadataKey, metadata) {
-        if (!this.hasMetadata(metadataKey)) {
-            this.metadataMap.set(metadataKey, [metadata]);
-            super.updateStore();
-            this.triggerMetadataChangeListeners({
-                action: 'Define',
-                type: 'Vector',
-                metadataKey: metadataKey,
-                metadata: [metadata]
+        let hasThisMetadata = false;
+        if (this.hasMetadata(metadataKey)) {
+            const vector = this.metadataMap.get(metadataKey);
+            if (!Array.isArray(vector))
+                throw new Error(`defineMetadataInVector: current metadata value is not an array`);
+            const newVector = vector.map(v => {
+                if (v === metadata)
+                    hasThisMetadata = true;
+                return v;
             });
-            return;
+            if (!hasThisMetadata) {
+                newVector.push(metadata);
+                this.metadataMap.set(metadataKey, newVector);
+                this.rxpInnerStore.update();
+            }
         }
-        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
-        });
+        else {
+            this.metadataMap.set(metadataKey, [metadata]);
+            this.rxpInnerStore.update();
+        }
+        return () => this.delMetadataInVector(metadataKey, metadata);
     }
     delMetadataInVector(metadataKey, metadata) {
         if (!this.hasMetadata(metadataKey))
             return;
-        const vector = this.metadataMap.get(metadataKey);
+        let hasThisMetadata = false;
+        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);
+            this.rxpInnerStore.update();
             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.set(metadataKey, fVector);
-        super.updateStore();
-        this.triggerMetadataChangeListeners({
-            action: 'Remove',
-            type: 'Vector',
-            metadataKey: metadataKey,
-            metadata: fVector
+        const fVector = vector.filter(v => {
+            const isThisMetadata = (v === metadata);
+            if (isThisMetadata)
+                hasThisMetadata = true;
+            return !isThisMetadata;
         });
+        if (hasThisMetadata) {
+            if (fVector.length === 0) {
+                this.metadataMap.delete(metadataKey);
+                this.rxpInnerStore.update();
+                return;
+            }
+            this.metadataMap.set(metadataKey, fVector);
+            this.rxpInnerStore.update();
+        }
     }
     useMetadata(metadataKey) {
         const [_, setState] = useState({});
-        const [normalState] = useState(() => ({
+        const normalState = useRef({
             isMounted: false,
             data: this.getMetadata(metadataKey),
-            unsubscribe: void 0
-        }));
-        const [syncState] = useState(() => ({
+            unsubscribe: void 0,
             needSync: false
-        }));
-        const updateState = useCallback(() => {
-            if (!normalState.isMounted) {
-                syncState.needSync = true;
+        });
+        const refreshComponent = useCallback(() => {
+            if (!normalState.current.isMounted) {
+                normalState.current.needSync = true;
                 return;
             }
-            setState({});
+            setState(() => ({}));
         }, []);
-        if (!normalState.unsubscribe) {
-            normalState.unsubscribe = super.subscribe(() => {
+        if (!normalState.current.isMounted || !normalState.current.unsubscribe) {
+            if (normalState.current.unsubscribe)
+                normalState.current.unsubscribe();
+            normalState.current.data = this.getMetadata(metadataKey);
+            normalState.current.unsubscribe = this.rxpInnerStore.subscribe(() => {
                 const data = this.getMetadata(metadataKey);
-                if (data !== normalState.data) {
-                    normalState.data = data;
-                    updateState();
+                if (data !== normalState.current.data) {
+                    normalState.current.data = data;
+                    refreshComponent();
                 }
             });
         }
         useLayoutEffect(() => {
-            normalState.isMounted = true;
-            if (syncState.needSync)
-                updateState();
+            normalState.current.isMounted = true;
+        }, []);
+        useEffect(() => {
+            if (normalState.current.needSync)
+                setState(() => ({}));
             return () => {
-                normalState.isMounted = false;
-                if (normalState.unsubscribe)
-                    normalState.unsubscribe();
-                normalState.unsubscribe = void 0;
+                normalState.current.isMounted = false;
+                if (normalState.current.unsubscribe)
+                    normalState.current.unsubscribe();
+                normalState.current.unsubscribe = void 0;
+                normalState.current.data = null;
+                normalState.current.needSync = false;
             };
         }, []);
-        return normalState.data;
+        return normalState.current.data;
     }
     useOldestMetadataInVector(metadataKey) {
         const metadata = this.useMetadata(metadataKey);
@@ -159,10 +143,28 @@ export class MetadataManager extends InnerZustandStoreManager {
         return null;
     }
     useAllMetadata() {
-        super.useStoreValue();
+        this.rxpInnerStore.useValueToRenderReactComponent();
         return this.metadataMap;
     }
     hasMetadata(metadataKey) {
         return this.metadataMap.has(metadataKey);
     }
+    useFollowMetadata(metadataKey, metadata) {
+        useEffect(() => {
+            const destroy = this.defineMetadata(metadataKey, metadata);
+            return destroy;
+        }, [metadataKey, metadata]);
+    }
+    useFollowMetadataInVector(metadataKey, metadata) {
+        useEffect(() => {
+            const destroy = this.defineMetadataInVector(metadataKey, metadata);
+            return destroy;
+        }, [metadataKey, metadata]);
+    }
+    useFollowMetadataInSingle(metadataKey, metadata) {
+        useEffect(() => {
+            const destroy = this.defineMetadataInSingle(metadataKey, metadata);
+            return destroy;
+        }, [metadataKey, metadata]);
+    }
 }