@fluid-topics/ft-wc-utils 1.2.73 → 1.3.1

package/build/CacheRegistry.d.ts

@@ -5,26 +5,32 @@ export declare class ClearCacheEvent extends CustomEvent<{
 }> {
     constructor(clearedKeys: string[]);
 }
-export type CachedContent<T = any> = undefined | CancelablePromise<T> | T | Error;
-export declare class CacheRegistry<T = any> extends WithEventBus {
-    private loaders;
+type CachedContentStatus = "REGISTERED" | "LOADING" | "RESOLVED" | "ERROR";
+export type CachedContent = {
+    loader: () => Promise<any>;
+    final: boolean;
+    status: CachedContentStatus;
+    promise?: CancelablePromise<any>;
+    value?: any;
+    error?: Error;
+    clearTimeout?: number;
+};
+export declare class CacheRegistry extends WithEventBus {
     private content;
-    private clearTimeouts;
-    private finalContent;
-    register(key: string, loader: () => Promise<T>): void;
-    registerFinal(key: string, loader: () => Promise<T>): void;
-    clearAll(dispatchEvent?: boolean): void;
+    register(key: string, loader: () => Promise<any>, final?: boolean): void;
+    registerFinal(key: string, loader: () => Promise<any>): void;
+    clearAll(dispatchEvent?: boolean): string[];
     clear(key: string, dispatchEvent?: boolean): string | undefined;
     private forceClear;
     private clearClearTimeout;
-    set(key: string, value: T): void;
-    setFinal(key: string, value: T): void;
-    get<U = T>(key: string, loader?: () => Promise<U>, ttl?: number): Promise<U>;
-    private isResolvedValue;
-    getNow<U = T>(key: string): U | undefined;
+    set(key: string, value: any, final?: boolean): void;
+    setFinal(key: string, value: any): void;
+    get<U = any>(key: string, loader?: () => Promise<U>, ttl?: number): Promise<U>;
+    isRegistered(key: string): boolean;
+    getNow<U = any>(key: string): U | undefined;
     has(key: string): boolean;
     resolvedKeys(): Array<string>;
-    resolvedValues(): Array<T>;
+    resolvedValues<U = any>(): Array<U>;
     keys(): Array<string>;
-    values(): Array<CachedContent<T>>;
 }
+export {};

package/build/CacheRegistry.js

@@ -1,4 +1,4 @@
-import { cancelable, CancelablePromise } from "./CancelablePromise";
+import { cancelable } from "./CancelablePromise";
 import { WithEventBus } from "./events";
 export class ClearCacheEvent extends CustomEvent {
     constructor(clearedKeys) {
@@ -8,22 +8,21 @@ export class ClearCacheEvent extends CustomEvent {
 export class CacheRegistry extends WithEventBus {
     constructor() {
         super(...arguments);
-        this.loaders = {};
         this.content = {};
-        this.clearTimeouts = {};
-        this.finalContent = new Set();
     }
-    register(key, loader) {
-        this.loaders[key] = loader;
-        this.finalContent.delete(key);
+    register(key, loader, final = false) {
+        var _a;
+        const content = this.content[key];
+        const status = (_a = content === null || content === void 0 ? void 0 : content.status) !== null && _a !== void 0 ? _a : "REGISTERED";
+        this.content[key] = { ...content, loader, final, status };
     }
     registerFinal(key, loader) {
-        this.loaders[key] = loader;
-        this.finalContent.add(key);
+        this.forceClear(key); // Force the final content to be reloaded when the loader changes
+        this.register(key, loader, true);
     }
     clearAll(dispatchEvent = true) {
         const clearedKeys = [];
-        for (let key in this.content) {
+        for (const key in this.content) {
             if (this.clear(key, false) != undefined) {
                 clearedKeys.push(key);
             }
@@ -31,9 +30,10 @@ export class CacheRegistry extends WithEventBus {
         if (dispatchEvent && clearedKeys.length > 0) {
             this.dispatchEvent(new ClearCacheEvent(clearedKeys));
         }
+        return clearedKeys;
     }
     clear(key, dispatchEvent = true) {
-        if (!this.finalContent.has(key)) {
+        if (this.content[key] && !this.content[key].final) {
             this.forceClear(key);
             if (dispatchEvent) {
                 this.dispatchEvent(new ClearCacheEvent([key]));
@@ -43,73 +43,91 @@ export class CacheRegistry extends WithEventBus {
         return undefined;
     }
     forceClear(key) {
-        this.clearClearTimeout(key);
-        if (this.content[key] instanceof CancelablePromise) {
-            this.content[key].cancel();
+        var _a;
+        const content = this.content[key];
+        if (content) {
+            this.clearClearTimeout(key);
+            (_a = content.promise) === null || _a === void 0 ? void 0 : _a.cancel();
+            this.content[key] = {
+                loader: content.loader,
+                final: content.final,
+                status: "REGISTERED",
+            };
         }
-        delete this.content[key];
     }
     clearClearTimeout(key) {
-        if (this.clearTimeouts[key] != null) {
-            window.clearTimeout(this.clearTimeouts[key]);
-            delete this.clearTimeouts[key];
+        var _a, _b, _c;
+        if (((_a = this.content[key]) === null || _a === void 0 ? void 0 : _a.clearTimeout) != null) {
+            window.clearTimeout((_b = this.content[key]) === null || _b === void 0 ? void 0 : _b.clearTimeout);
+            (_c = this.content[key]) === null || _c === void 0 ? true : delete _c.clearTimeout;
         }
     }
-    set(key, value) {
+    set(key, value, final = false) {
         this.forceClear(key);
-        this.register(key, async () => value);
-        this.content[key] = value;
+        const loader = async () => value;
+        const status = "RESOLVED";
+        this.content[key] = { loader, final, status, value };
     }
     setFinal(key, value) {
-        this.forceClear(key);
-        this.registerFinal(key, async () => value);
-        this.content[key] = value;
+        return this.set(key, value, true);
     }
     async get(key, loader, ttl) {
-        if (this.content[key] === undefined) {
-            loader = loader !== null && loader !== void 0 ? loader : this.loaders[key];
-            if (loader == undefined) {
+        if (!this.isRegistered(key)) {
+            if (!loader) {
                 throw new Error("Unknown cache key " + key);
             }
-            const cancelablePromise = cancelable(loader());
-            this.content[key] = cancelablePromise;
-            return cancelablePromise
-                .then(v => {
-                this.content[key] = v;
-                if (ttl != null) {
-                    this.clearClearTimeout(key);
-                    this.clearTimeouts[key] = window.setTimeout(() => this.clear(key), ttl);
-                }
-                return v;
-            });
+            this.register(key, loader);
         }
-        if (this.content[key] instanceof Error) {
-            throw this.content[key];
+        const content = this.content[key];
+        switch (content.status) {
+            case "ERROR":
+                throw content.error;
+            case "LOADING":
+                return content.promise;
+            case "RESOLVED":
+                return content.value;
+            case "REGISTERED":
+                loader = loader !== null && loader !== void 0 ? loader : content.loader;
+                content.status = "LOADING";
+                content.promise = cancelable(loader());
+                return content.promise
+                    .then(value => {
+                    content.status = "RESOLVED";
+                    content.value = value;
+                    if (ttl != null) {
+                        this.clearClearTimeout(key);
+                        content.clearTimeout = window.setTimeout(() => this.clear(key), ttl);
+                    }
+                    return value;
+                })
+                    .catch(error => {
+                    var _a;
+                    if (!((_a = content.promise) === null || _a === void 0 ? void 0 : _a.isCanceled)) {
+                        content.status = "ERROR";
+                        content.error = error;
+                    }
+                    throw error;
+                });
         }
-        return this.content[key];
     }
-    isResolvedValue(value) {
-        return value != null && !(value instanceof Promise) && !(value instanceof Error);
+    isRegistered(key) {
+        return this.content[key] != undefined;
     }
     getNow(key) {
-        if (this.isResolvedValue(this.content[key])) {
-            return this.content[key];
-        }
-        return undefined;
+        var _a;
+        return (_a = this.content[key]) === null || _a === void 0 ? void 0 : _a.value;
     }
     has(key) {
-        return this.content[key] != null;
+        var _a, _b;
+        return ((_a = this.content[key]) === null || _a === void 0 ? void 0 : _a.status) === "RESOLVED" || ((_b = this.content[key]) === null || _b === void 0 ? void 0 : _b.status) === "LOADING";
     }
     resolvedKeys() {
-        return Object.keys(this.content).filter(key => this.isResolvedValue(this.content[key]));
+        return Object.keys(this.content).filter(key => { var _a; return ((_a = this.content[key]) === null || _a === void 0 ? void 0 : _a.status) === "RESOLVED"; });
     }
     resolvedValues() {
-        return Object.values(this.content).filter(value => this.isResolvedValue(value));
+        return this.resolvedKeys().map(key => this.content[key].value);
     }
     keys() {
         return Object.keys(this.content);
     }
-    values() {
-        return Object.values(this.content);
-    }
 }