bruce-models 6.6.2 → 6.6.4

package/dist/bruce-models.umd.js

@@ -40,6 +40,7 @@
         (function (ECacheKey) {
             ECacheKey["Id"] = ":";
             ECacheKey["ListId"] = "::";
+            ECacheKey["FilterId"] = ":f:";
             ECacheKey["Assembly"] = "assembly";
             ECacheKey["Entity"] = "entity";
             ECacheKey["EntityType"] = "entitytype";
@@ -155,9 +156,63 @@
         Api.PrepReqParams = PrepReqParams;
     })(exports.Api || (exports.Api = {}));
 
+    /**
+     * A simple LRU cache implementation.
+     * LRU cache is a cache that evicts the least recently used item when it is full.
+     */
+    class LRUCache {
+        constructor(capacity) {
+            this.capacity = capacity;
+            this.cache = new Map();
+        }
+        /**
+         * Get a value from the cache.
+         * @param key
+         * @returns
+         */
+        Get(key) {
+            const value = this.cache.get(key);
+            if (value) {
+                this.cache.delete(key);
+                this.cache.set(key, value);
+            }
+            return value;
+        }
+        /**
+         * Set a value in the cache.
+         * @param key
+         * @param value
+         */
+        Set(key, value) {
+            if (this.capacity <= 0) {
+                // Empty cache.
+                // Means we were configured to not cache anything.
+                this.cache.clear();
+                return;
+            }
+            else if (this.cache.size >= this.capacity) {
+                const leastRecentlyUsedKey = this.cache.keys().next().value;
+                this.cache.delete(leastRecentlyUsedKey);
+            }
+            this.cache.set(key, value);
+        }
+        Entries() {
+            return this.cache.entries();
+        }
+        Clear() {
+            this.cache.clear();
+        }
+        Delete(key) {
+            return this.cache.delete(key);
+        }
+        Keys() {
+            return this.cache.keys();
+        }
+    }
+
     class CacheControl {
         constructor(id) {
-            this.memory = new Map();
+            this.memory = new LRUCache(20000);
             this.Disabled = false;
             if (!id) {
                 id = "default";
@@ -184,7 +239,7 @@
                 data,
                 expires
             };
-            this.memory.set(id, record);
+            this.memory.Set(id, record);
         }
         /**
          * Returns the item with the given id.
@@ -196,7 +251,7 @@
                 return null;
             }
             id = String(id);
-            let record = this.memory.get(id);
+            let record = this.memory.Get(id);
             if (!record) {
                 return {
                     data: null,
@@ -204,7 +259,7 @@
                 };
             }
             if (record.expires < Date.now()) {
-                this.memory.delete(id);
+                this.memory.Delete(id);
                 return {
                     data: null,
                     found: false
@@ -219,7 +274,7 @@
          * Removes all items from the cache.
          */
         Clear() {
-            this.memory.clear();
+            this.memory.Clear();
         }
         /**
          * Removes the item with the given id.
@@ -227,7 +282,7 @@
          */
         Remove(id) {
             id = String(id);
-            this.memory.delete(id);
+            this.memory.Delete(id);
         }
         /**
          * Removes all items that match the callback.
@@ -235,10 +290,10 @@
          * @param callback
          */
         RemoveBy(callback) {
-            const memoryKeys = Array.from(this.memory.keys());
+            const memoryKeys = Array.from(this.memory.Keys());
             for (const key of memoryKeys) {
                 if (callback(key)) {
-                    this.memory.delete(key);
+                    this.memory.Delete(key);
                 }
             }
         }
@@ -6166,54 +6221,6 @@
         return full;
     }
 
-    /**
-     * A simple LRU cache implementation.
-     * LRU cache is a cache that evicts the least recently used item when it is full.
-     */
-    class LRUCache {
-        constructor(capacity) {
-            this.capacity = capacity;
-            this.cache = new Map();
-        }
-        /**
-         * Get a value from the cache.
-         * @param key
-         * @returns
-         */
-        Get(key) {
-            const value = this.cache.get(key);
-            if (value) {
-                this.cache.delete(key);
-                this.cache.set(key, value);
-            }
-            return value;
-        }
-        /**
-         * Set a value in the cache.
-         * @param key
-         * @param value
-         */
-        Set(key, value) {
-            if (this.capacity <= 0) {
-                // Empty cache.
-                // Means we were configured to not cache anything.
-                this.cache.clear();
-                return;
-            }
-            else if (this.cache.size >= this.capacity) {
-                const leastRecentlyUsedKey = this.cache.keys().next().value;
-                this.cache.delete(leastRecentlyUsedKey);
-            }
-            this.cache.set(key, value);
-        }
-        Entries() {
-            return this.cache.entries();
-        }
-        Clear() {
-            this.cache.clear();
-        }
-    }
-
     (function (EntityAttachmentType) {
         // Known attachment types.
         let EType;
@@ -6838,10 +6845,28 @@
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetBruceApi();
                 }
-                const data = yield api.POST("entity/getlods", filter, reqParams);
-                return {
-                    lods: data.Items
-                };
+                const cacheKey = GetLodsFilterCacheKey(filter);
+                const cache = api.GetCacheItem(cacheKey, reqParams);
+                if (cache === null || cache === void 0 ? void 0 : cache.found) {
+                    return yield cache.data;
+                }
+                const prom = new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const data = yield api.POST("entity/getlods", filter, reqParams);
+                        res({
+                            lods: data.Items || []
+                        });
+                    }
+                    catch (e) {
+                        rej(e);
+                    }
+                }));
+                api.SetCacheItem({
+                    key: cacheKey,
+                    value: prom,
+                    req: reqParams
+                });
+                return yield prom;
             });
         }
         EntityLod.GetLods = GetLods;
@@ -6942,6 +6967,7 @@
                     "ClientFile.ID": params["ClientFile.ID"]
                 }, exports.Api.PrepReqParams(reqParams));
                 api.Cache.Remove(GetEntityListKey(entityId));
+                api.Cache.RemoveByStartsWith(exports.Api.ECacheKey.Lod + exports.Api.ECacheKey.FilterId);
                 return res;
             });
         }
@@ -6967,6 +6993,7 @@
                     Items: [{ "LODCategory.Key": lodCategoryId, "Level": level }]
                 }, exports.Api.PrepReqParams(reqParams));
                 api.Cache.Remove(GetEntityListKey(entityId));
+                api.Cache.RemoveByStartsWith(exports.Api.ECacheKey.Lod + exports.Api.ECacheKey.FilterId);
             });
         }
         EntityLod.Delete = Delete;
@@ -7013,6 +7040,25 @@
             return exports.Api.ECacheKey.Lod + exports.Api.ECacheKey.Entity + entityId;
         }
         EntityLod.GetEntityListKey = GetEntityListKey;
+        /**
+         * Returns cache identifier for a GetLods filter.
+         * @param filter
+         * @returns
+         */
+        function GetLodsFilterCacheKey(filter) {
+            const filterStr = JSON.stringify({
+                strict: Boolean(filter.strict),
+                externalSources: Boolean(filter.externalSources),
+                items: filter.Items.map(item => ({
+                    entityId: item.entityId || "",
+                    categoryId: item.categoryId || "",
+                    group: item.group || "DEFAULT",
+                    level: item.level || 0
+                }))
+            });
+            return exports.Api.ECacheKey.Lod + exports.Api.ECacheKey.FilterId + btoa(filterStr);
+        }
+        EntityLod.GetLodsFilterCacheKey = GetLodsFilterCacheKey;
     })(exports.EntityLod || (exports.EntityLod = {}));
 
     (function (EntityLodCategory) {
@@ -16078,7 +16124,7 @@
     })(exports.Tracking || (exports.Tracking = {}));
 
     // This is updated with the package.json version on build.
-    const VERSION = "6.6.2";
+    const VERSION = "6.6.4";
 
     exports.VERSION = VERSION;
     exports.AbstractApi = AbstractApi;