@suey/rxp-meta 0.2.3 → 0.3.0

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

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataManager = void 0;
+const react_1 = require("react");
+const index_1 = require("../base/index");
+class MetadataManager {
+    rxpInnerStore = new index_1.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) {
+        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`);
+            this.metadataMap.set(metadataKey, [...vector, metadata]);
+            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 metadataIsDeleted = 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 newVector = vector.filter(v => {
+            if (metadataIsDeleted)
+                return true;
+            if (v === metadata) {
+                metadataIsDeleted = true;
+                return false;
+            }
+            return true;
+        });
+        if (metadataIsDeleted) {
+            if (newVector.length === 0) {
+                this.metadataMap.delete(metadataKey);
+                this.rxpInnerStore.update();
+                return;
+            }
+            this.metadataMap.set(metadataKey, newVector);
+            this.rxpInnerStore.update();
+            return;
+        }
+    }
+    useMetadata(metadataKey) {
+        const [_, setState] = (0, react_1.useState)({});
+        const normalState = (0, react_1.useRef)({
+            data: this.getMetadata(metadataKey),
+            unsubscribe: void 0,
+        });
+        (0, react_1.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.includes(metadata);
+    }
+    useFollowMetadata(metadataKey, metadata) {
+        (0, react_1.useEffect)(() => {
+            const destroy = this.defineMetadata(metadataKey, metadata);
+            return destroy;
+        }, [metadataKey, metadata]);
+    }
+    useFollowMetadataInVector(metadataKey, metadata) {
+        (0, react_1.useEffect)(() => {
+            const destroy = this.defineMetadataInVector(metadataKey, metadata);
+            return destroy;
+        }, [metadataKey, metadata]);
+    }
+    useFollowMetadataInSingle(metadataKey, metadata) {
+        (0, react_1.useEffect)(() => {
+            const destroy = this.defineMetadataInSingle(metadataKey, metadata);
+            return destroy;
+        }, [metadataKey, metadata]);
+    }
+}
+exports.MetadataManager = MetadataManager;

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

@@ -0,0 +1,171 @@
+"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();
+    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] = (0, react_1.useState)({});
+        const normalState = (0, react_1.useRef)({
+            isMounted: false,
+            data: this.getMetadata(metadataKey),
+            unsubscribe: void 0,
+            needSync: false
+        });
+        const refreshComponent = (0, react_1.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();
+                }
+            });
+        }
+        (0, react_1.useLayoutEffect)(() => {
+            normalState.current.isMounted = true;
+        }, []);
+        (0, react_1.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) {
+        (0, react_1.useEffect)(() => {
+            const destroy = this.defineMetadata(metadataKey, metadata);
+            return destroy;
+        }, [metadataKey, metadata]);
+    }
+    useFollowMetadataInVector(metadataKey, metadata) {
+        (0, react_1.useEffect)(() => {
+            const destroy = this.defineMetadataInVector(metadataKey, metadata);
+            return destroy;
+        }, [metadataKey, metadata]);
+    }
+    useFollowMetadataInSingle(metadataKey, metadata) {
+        (0, react_1.useEffect)(() => {
+            const destroy = this.defineMetadataInSingle(metadataKey, metadata);
+            return destroy;
+        }, [metadataKey, metadata]);
+    }
+}
+exports.MetadataManager = MetadataManager;

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

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

package/dist/commonjs/src/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/esm/index.js

@@ -0,0 +1,2 @@
+export * from './src/extension';
+export * from './src/metadata';

package/dist/esm/src/base/InnerZustandStoreManager.js

@@ -0,0 +1,31 @@
+import { create } from 'zustand';
+import { immer } from 'zustand/middleware/immer';
+export class InnerZustandStoreManager {
+    store = create()(immer(() => ({
+        value: {}
+    })));
+    listeners = new Set();
+    unsubscribeListeners = this.store.subscribe(() => {
+        this.listeners.forEach(listener => listener());
+    });
+    updateStore() {
+        this.store.setState(() => ({ value: {} }));
+    }
+    useStoreValueToRerenderComponent() {
+        return this.store(store => store.value);
+    }
+    unsubscribe(listener) {
+        this.listeners.delete(listener);
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.unsubscribe(listener);
+    }
+    destroy() {
+        this.listeners.clear();
+        this.unsubscribeListeners();
+    }
+    getListenerCount() {
+        return this.listeners.size;
+    }
+}

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

@@ -0,0 +1 @@
+export * from './rxpInnerStore';

package/dist/esm/src/base/rxpInnerStore.js

@@ -0,0 +1,62 @@
+import { useCallback, useLayoutEffect, useRef, useState } from 'react';
+export class RxpInnerStore {
+    store = {
+        value: {},
+        listeners: new Set(),
+        live: true,
+    };
+    triggerEffects = async () => {
+        if (!this.store.live)
+            return;
+        this.store.listeners.forEach(listener => {
+            if (typeof listener === 'function')
+                listener();
+        });
+    };
+    update() {
+        if (!this.store.live)
+            return;
+        this.store.value = {};
+        this.triggerEffects().catch(err => {
+        });
+    }
+    unsubscribe(listener) {
+        if (!this.store.live)
+            return false;
+        if (typeof listener !== 'function')
+            return false;
+        return this.store.listeners.delete(listener);
+    }
+    subscribe(listener) {
+        if (!this.store.live)
+            return () => { };
+        if (typeof listener !== 'function')
+            return () => { };
+        this.store.listeners.add(listener);
+        return () => this.unsubscribe(listener);
+    }
+    destroy() {
+        this.store.listeners.clear();
+        this.store.live = false;
+    }
+    revive() {
+        this.store.live = true;
+    }
+    getListenerCount() {
+        return this.store.listeners.size;
+    }
+    useValueToRenderReactComponent() {
+        const [_, setState] = useState({});
+        const destroySubscribe = useRef();
+        const refresh = useCallback(() => setState(() => ({})), []);
+        useLayoutEffect(() => {
+            destroySubscribe.current = this.subscribe(refresh);
+            return () => {
+                if (destroySubscribe.current)
+                    destroySubscribe.current();
+                destroySubscribe.current = void 0;
+            };
+        }, []);
+        return [this.store.value];
+    }
+}

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

@@ -0,0 +1,22 @@
+export var ExtensionErrors;
+(function (ExtensionErrors) {
+    ExtensionErrors["ExtensionNameIsRequired"] = "Extension name is required";
+    ExtensionErrors["ExtensionNameMustBeString"] = "Extension name must be string";
+    ExtensionErrors["ExtensionVersionIsRequired"] = "Extension version is required";
+    ExtensionErrors["ExtensionVersionMustBeString"] = "Extension version must be string";
+    ExtensionErrors["ExtensionOnActivatedIsRequired"] = "Extension onActivated is required";
+    ExtensionErrors["ExtensionOnActivatedMustBeFunction"] = "Extension onActivated must be function";
+    ExtensionErrors["ExtensionIsNotExist"] = "Extension is not exist";
+})(ExtensionErrors || (ExtensionErrors = {}));
+export var MetadataErrors;
+(function (MetadataErrors) {
+    MetadataErrors["MetadataKeyIsRequired"] = "Metadata key is required";
+    MetadataErrors["MetadataKeyMustBeString"] = "Metadata key must be string";
+    MetadataErrors["MetadataKeyMustBeSymbol"] = "Metadata key must be symbol";
+    MetadataErrors["MetadataKeyMustBeNumber"] = "Metadata key must be number";
+    MetadataErrors["MetadataKeyMustBeBoolean"] = "Metadata key must be boolean";
+    MetadataErrors["MetadataKeyMustBeFunction"] = "Metadata key must be function";
+    MetadataErrors["MetadataKeyMustBeObject"] = "Metadata key must be object";
+    MetadataErrors["MetadataKeyMustBeArray"] = "Metadata key must be array";
+})(MetadataErrors || (MetadataErrors = {}));
+;

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

@@ -0,0 +1,110 @@
+import { useState } from 'react';
+import { RxpInnerStore } from '../base/index';
+const ExtensionSymbolTag = Symbol('ExtensionSymbolTag');
+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;
+    }
+    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__');
+        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);
+        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) ?? null;
+    }
+    registerExtension(extension) {
+        if (!this.isExtension(extension))
+            throw new Error(`参数非法, 不是一个有效的扩展`);
+        const name = extension.name;
+        if (this.hasExtension(name)) {
+            console.error(`试图重新注册一个已存在得扩展：应该先移除再注册`);
+            return;
+        }
+        this.extNameMapStore.set(name, extension);
+        this.rxpInnerStore.update();
+    }
+    async activatedExtension(name) {
+        const extension = this.extNameMapStore.get(name);
+        if (!extension)
+            throw new Error(`试图激活一个不存在得扩展`);
+        return extension.activated();
+    }
+    async deactivatedExtension(name) {
+        const extension = this.extNameMapStore.get(name);
+        if (!extension)
+            throw new Error(`试图去活一个不存在得扩展`);
+        return extension.deactivated();
+    }
+    async delExtension(name) {
+        const extension = this.extNameMapStore.get(name);
+        if (!extension)
+            throw new Error(`试图删除一个不存在得扩展`);
+        extension.deactivated();
+        this.extNameMapStore.delete(name);
+        this.rxpInnerStore.update();
+    }
+    useExtensionsList() {
+        const value = this.rxpInnerStore.useValueToRenderReactComponent();
+        const [statusState] = useState(() => ({
+            value: void 0
+        }));
+        const [normalState] = useState({
+            extensions: [],
+        });
+        if (statusState.value !== value) {
+            statusState.value = value;
+            normalState.extensions = [...this.extNameMapStore.values()];
+        }
+        return [normalState.extensions];
+    }
+    getExtensions() {
+        return [...this.extNameMapStore.values()];
+    }
+}