bruce-models 2.1.0 → 2.1.1

package/dist/bruce-models.es5.js

@@ -3146,260 +3146,125 @@ module.exports = localforage_js;
 });
 });
 
-var ObjectUtils;
-(function (ObjectUtils) {
-    /**
-     * Generates a Bruce compatible UID.
-     * @returns
-     */
-    function UId() {
-        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
-            const r = Math.random() * 16 | 0, v = c == "x" ? r : (r & 0x3 | 0x8);
-            return v.toString(16);
-        });
-    }
-    ObjectUtils.UId = UId;
-})(ObjectUtils || (ObjectUtils = {}));
-
-class CacheDictionary {
+const CACHE_VERSION_PREFIX = "v2_";
+class CacheUtil {
     constructor(id) {
-        this.memory = Object.create(null);
-        if (!id) {
-            id = "BRUCE_UI_MODELS_CACHE_DICT_" + ObjectUtils.UId();
-        }
-        this.id = id;
         this.store = localforage.createInstance({
-            name: id
+            name: CACHE_VERSION_PREFIX + id,
         });
+        this.inMemoryPromises = {};
+        this.keyVersions = {};
     }
-    get Id() {
-        return this.id;
-    }
-    GetItems() {
+    Set(key, value, duration = 300000) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.items == null) {
-                const raw = yield this.store.getItem(this.id);
-                if (raw == null) {
-                    this.items = [];
-                }
-                else {
-                    // Check if any are expired.
-                    // We can clean this every first time we load.
-                    const now = new Date().getTime();
-                    for (const item of raw) {
-                        if (item.duration > -1 && (now - item.created) / 1000 > item.duration) {
-                            if (item.inMemory) {
-                                this.memory[item.key] = null;
-                                delete this.memory[item.key];
-                            }
-                            else {
-                                yield this.store.removeItem(item.key);
-                            }
-                        }
+            if (value instanceof Promise) {
+                this.inMemoryPromises[key] = value;
+                const currentVersion = (this.keyVersions[key] = (this.keyVersions[key] || 0) + 1);
+                value
+                    .then((resolvedValue) => {
+                    if (this.keyVersions[key] === currentVersion) {
+                        this.Set(key, resolvedValue, duration);
                     }
-                    this.items = raw;
-                }
-            }
-            return this.items;
-        });
-    }
-    GetKeys() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (yield this.GetItems()).map(x => "" + x.key);
-        });
-    }
-    Set(key, value, duration) {
-        return __awaiter(this, void 0, void 0, function* () {
-            key = "" + key;
-            const items = yield this.GetItems();
-            const itemIndex = items.findIndex(x => x.key == key);
-            if (itemIndex > -1) {
-                const item = items[itemIndex];
-                if (item.inMemory) {
-                    this.memory[item.key] = null;
-                    delete this.memory[item.key];
-                }
-                else {
-                    yield this.store.removeItem(item.key);
-                }
-                items.splice(itemIndex, 1);
-            }
-            const item = {
-                key: key,
-                duration: duration,
-                created: new Date().getTime(),
-                inMemory: false
-            };
-            // Short duration, keep in memory.
-            if (duration < 60) {
-                item.inMemory = true;
-                this.memory[item.key] = value;
-            }
-            // Let's resolve and store the value in local-storage.
-            // If resolution crashes then we'll keep retaining that in memory.
-            else if (value instanceof Promise) {
-                value.then((x) => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        const items = yield this.GetItems();
-                        const item = items.find(x => x.key == key);
-                        if (!item) {
-                            console.log("Item was removed from cache before promise resolved.", key, items);
-                            return;
-                        }
-                        try {
-                            yield this.store.setItem(item.key, x);
-                            item.inMemory = false;
-                            this.memory[item.key] = null;
-                            delete this.memory[item.key];
-                            yield this.store.setItem(this.id, items);
-                        }
-                        catch (e) {
-                            console.warn(e);
-                        }
+                })
+                    .catch((error) => {
+                    if (this.keyVersions[key] === currentVersion) {
+                        this.Set(key, error, duration);
                     }
-                    catch (e) {
-                        console.warn(e);
-                    }
-                }));
-                item.inMemory = true;
-                this.memory[item.key] = value;
+                })
+                    .finally(() => {
+                    delete this.inMemoryPromises[key];
+                });
             }
-            if (!item.inMemory) {
-                try {
-                    yield this.store.setItem(item.key, value);
-                }
-                catch (e) {
-                    item.inMemory = true;
-                    this.memory[item.key] = value;
-                    console.warn(e);
-                }
+            else {
+                const item = {
+                    value,
+                    expiry: Date.now() + duration,
+                };
+                yield this.store.setItem(key, item);
             }
-            items.push(item);
-            yield this.store.setItem(this.id, items);
-            this.items = items;
         });
     }
-    Remove(key) {
+    Get(key) {
         return __awaiter(this, void 0, void 0, function* () {
-            key = "" + key;
-            const items = yield this.GetItems();
-            const index = items.findIndex(x => x.key == key);
-            if (index >= 0) {
-                const item = items[index];
-                if (item.inMemory) {
-                    this.memory[item.key] = null;
-                    delete this.memory[item.key];
-                }
-                else {
-                    this.store.removeItem(item.key);
-                }
-                items.splice(index, 1);
-                this.store.setItem(this.id, items);
+            if (this.inMemoryPromises[key]) {
+                return this.inMemoryPromises[key];
             }
-            this.items = items;
-        });
-    }
-    Clear() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const items = yield this.GetItems();
-            for (const item of items) {
-                if (item.inMemory) {
-                    this.store.removeItem(item.key);
-                }
+            const item = (yield this.store.getItem(key));
+            if (!item) {
+                return null;
+            }
+            if (Date.now() > item.expiry) {
+                yield this.store.removeItem(key);
+                return null;
             }
-            this.store.setItem(this.id, []);
-            this.items = [];
-            this.memory = Object.create(null);
+            return item.value;
         });
     }
-    GetData(key) {
+    ClearCache(pattern, mode = "equals") {
         return __awaiter(this, void 0, void 0, function* () {
-            key = "" + key;
-            const item = (yield this.GetItems()).find(x => x.key == key);
-            const isExpired = item == null || item.duration > -1 && (new Date().getTime() - item.created) / 1000 > item.duration;
-            if (isExpired) {
-                this.Remove(key);
-                return null;
+            const keys = yield this.store.keys();
+            const checkFuncs = {
+                equals: (key) => key === pattern,
+                contains: (key) => key.includes(pattern),
+                startswith: (key) => key.startsWith(pattern),
+            };
+            const check = checkFuncs[mode];
+            if (!check) {
+                throw new Error("Invalid mode");
             }
-            if (item.inMemory) {
-                return this.memory[item.key];
+            for (const key of keys) {
+                if (check(key)) {
+                    yield this.store.removeItem(key);
+                }
             }
-            const raw = yield this.store.getItem(item.key);
-            if (raw == null) {
-                return null;
+            for (const key in this.inMemoryPromises) {
+                if (check(key)) {
+                    delete this.inMemoryPromises[key];
+                    this.keyVersions[key]++;
+                }
             }
-            return raw;
         });
     }
 }
 class CacheControl {
     constructor(id) {
         this.Disabled = false;
-        this.data = new CacheDictionary(id);
+        this.data = new CacheUtil(id);
     }
     /**
      * @param id
      * @param data
      * @param duration seconds to keep the data in cache. -1 for infinite.
      */
-    Set(id, data, duration = -1) {
+    Set(id, data, duration = 300) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.data.Set(id, data, duration);
+            const durationMs = duration === -1 ? undefined : duration * 1000;
+            return this.data.Set(String(id), data, durationMs);
         });
     }
     Get(id) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.data.GetData(id);
+            return (yield this.data.Get(String(id)));
         });
     }
     Clear() {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.data.Clear();
+            return this.data.ClearCache("");
         });
     }
     Remove(id) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.data.Remove(id);
+            return this.data.ClearCache(String(id), "equals");
         });
     }
     RemoveByStartsWith(text) {
         return __awaiter(this, void 0, void 0, function* () {
-            const items = [...(yield this.data.GetItems())];
-            for (const item of items) {
-                if (item.key.startsWith(text)) {
-                    yield this.data.Remove(item.key);
-                }
-            }
+            return this.data.ClearCache(text, "startswith");
         });
     }
     RemoveByContains(text) {
         return __awaiter(this, void 0, void 0, function* () {
-            const items = [...(yield this.data.GetItems())];
-            for (const item of items) {
-                if (item.key.includes(text)) {
-                    yield this.data.Remove(item.key);
-                }
-            }
-        });
-    }
-    GetKeys() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.Disabled) {
-                return [];
-            }
-            const items = yield this.data.GetItems();
-            return items.map(x => x.key);
-        });
-    }
-    GetValues() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.Disabled) {
-                return [];
-            }
-            const items = yield this.data.GetItems();
-            const keys = items.map(x => x.key);
-            const values = yield Promise.all(keys.map(key => this.data.GetData(key)));
-            return values.filter(x => x != null);
+            return this.data.ClearCache(text, "contains");
         });
     }
 }
@@ -4658,6 +4523,21 @@ var Color;
     Color.ColorFromStr = ColorFromStr;
 })(Color || (Color = {}));
 
+var ObjectUtils;
+(function (ObjectUtils) {
+    /**
+     * Generates a Bruce compatible UID.
+     * @returns
+     */
+    function UId() {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+            const r = Math.random() * 16 | 0, v = c == "x" ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    }
+    ObjectUtils.UId = UId;
+})(ObjectUtils || (ObjectUtils = {}));
+
 /**
  * Utility to help with parsing and wrapping Bruce paths.
  */