bruce-models 2.1.0 → 2.1.2

package/dist/bruce-models.umd.js

@@ -3140,259 +3140,125 @@
     });
     });
 
-    (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;
-    })(exports.ObjectUtils || (exports.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_" + exports.ObjectUtils.UId();
-            }
-            this.id = id;
             this.store = localforage.createInstance({
-                name: id
-            });
-        }
-        get Id() {
-            return this.id;
-        }
-        GetItems() {
-            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);
-                                }
-                            }
-                        }
-                        this.items = raw;
-                    }
-                }
-                return this.items;
-            });
-        }
-        GetKeys() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return (yield this.GetItems()).map(x => "" + x.key);
+                name: CACHE_VERSION_PREFIX + id,
             });
+            this.inMemoryPromises = {};
+            this.keyVersions = {};
         }
-        Set(key, value, duration) {
+        Set(key, value, duration = 300000) {
             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);
-                            }
+                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);
                         }
-                        catch (e) {
-                            console.warn(e);
+                    })
+                        .catch((error) => {
+                        if (this.keyVersions[key] === currentVersion) {
+                            this.Set(key, error, duration);
                         }
-                    }));
-                    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;
                 }
-                this.store.setItem(this.id, []);
-                this.items = [];
-                this.memory = Object.create(null);
+                if (Date.now() > item.expiry) {
+                    yield this.store.removeItem(key);
+                    return 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");
             });
         }
     }
@@ -4636,6 +4502,20 @@
         Color.ColorFromStr = ColorFromStr;
     })(exports.Color || (exports.Color = {}));
 
+    (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;
+    })(exports.ObjectUtils || (exports.ObjectUtils = {}));
+
     /**
      * Utility to help with parsing and wrapping Bruce paths.
      */
@@ -7106,6 +6986,7 @@
                 this.IsFetched = null;
                 this.FetchPageIndex = 0;
                 this.Boundaries = null;
+                this.Fetching = false;
             }
             GetBounds() {
                 // Entity data works in -180 to 180 range.
@@ -7132,93 +7013,47 @@
         class Grid {
             constructor() {
                 this.cells = {};
-                this.patches = [];
             }
             GetCellsForView(viewRect) {
+                const cells = [];
+                const minLat = viewRect.south;
+                const minLon = viewRect.west;
+                const maxLat = viewRect.north;
+                const maxLon = viewRect.east;
                 const MAX_CELLS = 150;
-                const { south: minLat, west: minLon, north: maxLat, east: maxLon } = viewRect;
                 const cellDegreeSize = getCellSizeFromHeight(viewRect.alt);
-                const [curMinLon, curMinLat] = [minLon, minLat].map((v) => floorValueToCellSize(cellDegreeSize, v));
-                const [width, height] = [maxLon - curMinLon, maxLat - curMinLat].map((v) => v / cellDegreeSize);
-                const ids = [];
-                const cells = [];
-                let max = [curMinLon, curMinLat];
-                const intersections = this.intersections(viewRect);
-                const addCell = (x, y) => {
-                    const lon1 = x * cellDegreeSize + curMinLon;
-                    const lat1 = y * cellDegreeSize + curMinLat;
-                    const lon2 = lon1 + cellDegreeSize;
-                    const lat2 = lat1 + cellDegreeSize;
-                    const [id, cell] = getOrCreateCell(this.cells, cellDegreeSize, lon1, lon2, lat1, lat2);
-                    /*
-                    {
-                        const cell_bounds = { south: lat1, west: lon1, north: lat2, east: lon2 };
-                        const subcells = [];
-                        for (const id of intersections) {
-                            const c = this.cells[id].GetBounds();
-                            if (contains(c, cell_bounds)) {
-                                cell.Fetched = true;
-                                return;
-                            }
-                            if (intersects(c, cell_bounds)) {
-                                const cropped = crop(c, cell.GetBounds());
-                                subcells.push(cropped);
-                            }
-                        }
-                        let filled = 0;
-                        while (subcells.length > 0) {
-                            const c = subcells.pop();
-                            filled += area(c);
-                            for (const s of subcells) {
-                                filled -= intersection(s, c);
-                            }
-                        }
-                        if (filled + Number.EPSILON * 2 > area(cell.GetBounds())) {
-                            cell.Fetched = true;
-                            return;
-                        }
-
-                        let [x2, y2] = max;
-                        x2 = Math.max(x2, lon2);
-                        y2 = Math.max(y2, lat2);
-                        max = [x2, y2];
-                    }
-                    */
-                    ids.push(id);
-                    cells.push(cell);
-                    cells[id] = cell;
-                };
+                const curMinLon = floorValueToCellSize(cellDegreeSize, minLon);
+                const curMinLat = floorValueToCellSize(cellDegreeSize, minLat);
+                const width = (maxLon - curMinLon) / cellDegreeSize;
+                const height = (maxLat - curMinLat) / cellDegreeSize;
+                const centerX = (minLon + maxLon) / 2;
+                const centerY = (minLat + maxLat) / 2;
                 for (let x = 0; x < width; x++) {
                     for (let y = 0; y < height; y++) {
-                        addCell(x, y);
-                        if (cells.length >= MAX_CELLS) {
+                        const lon = x * cellDegreeSize + curMinLon;
+                        const lat = y * cellDegreeSize + curMinLat;
+                        const [id, cell] = getOrCreateCell(this.cells, cellDegreeSize, lon, lon + cellDegreeSize, lat, lat + cellDegreeSize);
+                        cells.push(cell);
+                        if (cells.length > MAX_CELLS) {
                             break;
                         }
                     }
                 }
-                const [x2, y2] = max;
-                if (x2 != curMinLon && y2 != curMinLat) {
-                    this.patches.push([{ west: curMinLon, east: x2, south: curMinLat, north: y2 }, ids]);
-                }
+                // Sort cells so that the ones closest to the center are first
+                cells.sort((a, b) => {
+                    const aCenterX = (a.Boundaries.minLongitude + a.Boundaries.maxLongitude) / 2;
+                    const aCenterY = (a.Boundaries.minLatitude + a.Boundaries.maxLatitude) / 2;
+                    const bCenterX = (b.Boundaries.minLongitude + b.Boundaries.maxLongitude) / 2;
+                    const bCenterY = (b.Boundaries.minLatitude + b.Boundaries.maxLatitude) / 2;
+                    const aDist = Math.sqrt(Math.pow(aCenterX - centerX, 2) + Math.pow(aCenterY - centerY, 2));
+                    const bDist = Math.sqrt(Math.pow(bCenterX - centerX, 2) + Math.pow(bCenterY - centerY, 2));
+                    return aDist - bDist;
+                });
                 return cells;
             }
-            intersections(withRect) {
-                return this.patches
-                    .filter(([rect, _]) => intersects(rect, withRect))
-                    .map(([_, ids]) => ids)
-                    .reduce((all, ids) => {
-                    all.push(...ids);
-                    return all;
-                }, []);
-            }
         }
         EntityGlobe.Grid = Grid;
     })(exports.EntityGlobe || (exports.EntityGlobe = {}));
-    function intersects(l, r) {
-        const { west: w, south: s, north: n, east: e } = l;
-        const { west: wr, south: sr, north: nr, east: er } = r;
-        return !(e <= wr || w >= er || n <= sr || s >= nr);
-    }
     function floorValueToCellSize(size, value) {
         return Math.floor(value / size) * size;
     }
@@ -7452,6 +7287,7 @@
                     let retryDelay = 0;
                     let prevFirstId = "";
                     let prevLastId = "";
+                    let prevTicks = 0;
                     while ((!this.viewCenter || !this.viewRect) && this.getterLoopId == loopId) {
                         yield delay(RETRY_DELAY_INCREMENT);
                     }
@@ -7481,8 +7317,12 @@
                         }
                         const curCell = cells[curCellIndex];
                         if (curCell.IsFetched()) {
+                            curCell.Fetching = false;
                             curCellIndex += 1;
-                            if (!cells[curCellIndex]) {
+                            if (cells[curCellIndex]) {
+                                cells[curCellIndex].Fetching = true;
+                            }
+                            else {
                                 curCellIndex = null;
                             }
                             (_b = this.onScanUpdate) === null || _b === void 0 ? void 0 : _b.Trigger(cells);
@@ -7522,6 +7362,7 @@
                             // Only mark as fetched when ALL pages are done.
                             if (entities.length <= 0) {
                                 curCell.Fetched = true;
+                                curCell.Fetching = false;
                                 (_d = this.onScanUpdate) === null || _d === void 0 ? void 0 : _d.Trigger(cells);
                                 continue;
                             }
@@ -7530,11 +7371,15 @@
                                 const first = (_f = (_e = entities[0]) === null || _e === void 0 ? void 0 : _e.Bruce) === null || _f === void 0 ? void 0 : _f.ID;
                                 const last = (_h = (_g = entities[entities.length - 1]) === null || _g === void 0 ? void 0 : _g.Bruce) === null || _h === void 0 ? void 0 : _h.ID;
                                 if (prevFirstId == first && prevLastId == last) {
-                                    break;
+                                    prevTicks += 1;
+                                    if (prevTicks > 3) {
+                                        break;
+                                    }
                                 }
                                 else {
                                     prevFirstId = first;
                                     prevLastId = last;
+                                    prevTicks = 0;
                                 }
                             }
                             curCell.FetchPageIndex++;
@@ -7543,7 +7388,7 @@
                             retryDelay = 0;
                         }
                         catch (e) {
-                            console.log(e);
+                            console.error(e);
                             // Request failed so let's add a delay and try again soon.
                             retryDelay += RETRY_DELAY_INCREMENT;
                             retryAttempts -= 1;