@suey/rxp-meta 0.2.3 → 0.2.4

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/extension/declare.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export { ExtensionManager } from './ExtensionManager';

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

@@ -0,0 +1,153 @@
+import { useEffect, useRef, useState } from 'react';
+import { RxpInnerStore } from '../base/index';
+export class MetadataManager {
+    rxpInnerStore = new RxpInnerStore();
+    metadataMap = new Map();
+    constructor() {
+        this.metadataMap.clear();
+    }
+    defineMetadata(metadataKey, metadata) {
+        this.metadataMap.set(metadataKey, 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);
+        this.rxpInnerStore.update();
+    }
+    defineMetadataInSingle(metadataKey, metadata) {
+        this.metadataMap.set(metadataKey, metadata);
+        this.rxpInnerStore.update();
+        return () => {
+            this.delMetadata(metadataKey);
+        };
+    }
+    defineMetadataInVector(metadataKey, 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, metadata];
+            this.metadataMap.set(metadataKey, newVector);
+            this.rxpInnerStore.update();
+        }
+        else {
+            this.metadataMap.set(metadataKey, [metadata]);
+            this.rxpInnerStore.update();
+        }
+        return () => this.delMetadataInVector(metadataKey, metadata);
+    }
+    delMetadataInVector(metadataKey, metadata) {
+        if (!this.hasMetadata(metadataKey))
+            return;
+        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 => {
+            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 = useRef({
+            data: this.getMetadata(metadataKey),
+            unsubscribe: void 0,
+        });
+        useEffect(() => {
+            normalState.current.unsubscribe = this.rxpInnerStore.subscribe(() => {
+                const data = this.getMetadata(metadataKey);
+                if (data !== normalState.current.data) {
+                    normalState.current.data = data;
+                    setState(() => ({}));
+                }
+            });
+            const data = this.getMetadata(metadataKey);
+            if (data !== normalState.current.data) {
+                normalState.current.data = data;
+                setState(() => ({}));
+            }
+            return () => {
+                if (normalState.current.unsubscribe)
+                    normalState.current.unsubscribe();
+                normalState.current.unsubscribe = void 0;
+                normalState.current.data = null;
+            };
+        }, []);
+        return normalState.current.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() {
+        this.rxpInnerStore.useValueToRenderReactComponent();
+        return this.metadataMap;
+    }
+    hasMetadata(metadataKey) {
+        return this.metadataMap.has(metadataKey);
+    }
+    hasMetadataInVector(metadataKey, metadata) {
+        const vec = this.metadataMap.get(metadataKey);
+        if (!Array.isArray(vec))
+            return false;
+        return vec.some(value => value === metadata);
+    }
+    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]);
+    }
+}

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

@@ -0,0 +1,167 @@
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react';
+import { InnerZustandStoreManager } from '../base/InnerZustandStoreManager';
+export class MetadataManager extends InnerZustandStoreManager {
+    metadataMap = new Map();
+    defineMetadata(metadataKey, metadata) {
+        this.metadataMap.set(metadataKey, metadata);
+        super.updateStore();
+        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();
+    }
+    defineMetadataInSingle(metadataKey, metadata) {
+        this.metadataMap.set(metadataKey, metadata);
+        super.updateStore();
+        return () => {
+            this.delMetadata(metadataKey);
+        };
+    }
+    defineMetadataInVector(metadataKey, 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.filter(v => {
+                const isThisMetadata = (v === metadata);
+                if (isThisMetadata)
+                    hasThisMetadata = true;
+                return !isThisMetadata;
+            });
+            if (!hasThisMetadata) {
+                newVector.push(metadata);
+                this.metadataMap.set(metadataKey, newVector);
+                super.updateStore();
+            }
+        }
+        else {
+            this.metadataMap.set(metadataKey, [metadata]);
+            super.updateStore();
+        }
+        return () => this.delMetadataInVector(metadataKey, metadata);
+    }
+    delMetadataInVector(metadataKey, metadata) {
+        if (!this.hasMetadata(metadataKey))
+            return;
+        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);
+            super.updateStore();
+            return;
+        }
+        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);
+                super.updateStore();
+                return;
+            }
+            this.metadataMap.set(metadataKey, fVector);
+            super.updateStore();
+        }
+    }
+    useMetadata(metadataKey) {
+        const [_, setState] = useState({});
+        const normalState = useRef({
+            isMounted: false,
+            data: this.getMetadata(metadataKey),
+            unsubscribe: void 0,
+            needSync: false
+        });
+        const refreshComponent = useCallback(() => {
+            if (!normalState.current.isMounted) {
+                normalState.current.needSync = true;
+                return;
+            }
+            setState(() => ({}));
+        }, []);
+        if (!normalState.current.isMounted || !normalState.current.unsubscribe) {
+            if (normalState.current.unsubscribe)
+                normalState.current.unsubscribe();
+            normalState.current.data = this.getMetadata(metadataKey);
+            normalState.current.unsubscribe = super.subscribe(() => {
+                const data = this.getMetadata(metadataKey);
+                if (data !== normalState.current.data) {
+                    normalState.current.data = data;
+                    refreshComponent();
+                }
+            });
+        }
+        useLayoutEffect(() => {
+            normalState.current.isMounted = true;
+        }, []);
+        useEffect(() => {
+            if (normalState.current.needSync)
+                setState(() => ({}));
+            return () => {
+                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.current.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.useStoreValueToRerenderComponent();
+        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]);
+    }
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export { MetadataManager } from './MetadataManager';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suey/rxp-meta",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "author": "suey",
   "private": false,
   "description": "扩展包",