@suey/rxp-meta 0.0.2 → 0.1.0

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

@@ -2,161 +2,136 @@
 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 {
+const index_1 = require("../base/index");
+class MetadataManager {
+    rxpInnerStore = new index_1.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] = (0, react_1.useState)({});
-        const [normalState] = (0, react_1.useState)(() => ({
+        const normalState = (0, react_1.useRef)({
             isMounted: false,
             data: this.getMetadata(metadataKey),
-            unsubscribe: void 0
-        }));
-        const [syncState] = (0, react_1.useState)(() => ({
+            unsubscribe: void 0,
             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);
-            };
+        });
+        const refreshComponent = (0, react_1.useCallback)(() => {
+            if (!normalState.current.isMounted) {
+                normalState.current.needSync = true;
+                return;
+            }
+            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();
                 }
             });
         }
         (0, react_1.useLayoutEffect)(() => {
-            normalState.isMounted = true;
-            if (syncState.needSync)
-                updateState();
+            normalState.current.isMounted = true;
+        }, []);
+        (0, react_1.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);
@@ -171,11 +146,29 @@ class MetadataManager extends InnerZustandStoreManager_1.InnerZustandStoreManage
         return null;
     }
     useAllMetadata() {
-        super.useStoreValue();
+        this.rxpInnerStore.useValueToRenderReactComponent();
         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/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;