bruce-models 3.1.3 → 3.1.5

package/dist/bruce-models.umd.js

@@ -4682,539 +4682,6 @@
         EntityType.Update = Update;
     })(exports.EntityType || (exports.EntityType = {}));
 
-    /**
-     * This is a helper for making entity requests based on a grid area.
-     * It will return grid cells based on given view-area then will remember when stuff-
-     * was fully-fetched for those cells to avoid making duplicate requests.
-     */
-    (function (EntityGlobe) {
-        class Cell {
-            constructor() {
-                this.Fetched = false;
-                this.IsFetched = null;
-                this.FetchPageIndex = 0;
-                this.Boundaries = null;
-                this.Fetching = false;
-            }
-            GetBounds() {
-                // Entity data works in -180 to 180 range.
-                function prepareRangeForBounds(range) {
-                    if (range > 180) {
-                        return range - 360;
-                    }
-                    return range;
-                }
-                // Add minor decimal as API crashes when giving it whole numbers.
-                const maxLon = prepareRangeForBounds(this.Boundaries.maxLongitude) + 0.00001;
-                const minLon = prepareRangeForBounds(this.Boundaries.minLongitude) - 0.00001;
-                const maxLat = prepareRangeForBounds(this.Boundaries.maxLatitude) + 0.00001;
-                const minLat = prepareRangeForBounds(this.Boundaries.minLatitude) - 0.00001;
-                return {
-                    east: maxLon,
-                    north: maxLat,
-                    south: minLat,
-                    west: minLon
-                };
-            }
-        }
-        EntityGlobe.Cell = Cell;
-        class Grid {
-            constructor() {
-                this.cells = {};
-            }
-            GetCellsForView(cameraPos, viewRect) {
-                const cells = [];
-                const minLat = viewRect.south;
-                const minLon = viewRect.west;
-                const maxLat = viewRect.north;
-                const maxLon = viewRect.east;
-                const MAX_CELLS = 150;
-                const cellDegreeSize = getCellSizeFromHeight(viewRect.alt);
-                let curMinLon = floorValueToCellSize(cellDegreeSize, minLon);
-                let curMinLat = floorValueToCellSize(cellDegreeSize, minLat);
-                // For larger views we add additional padding because our view-area culling is too strong.
-                if (cellDegreeSize >= 2) {
-                    curMinLon -= cellDegreeSize;
-                    curMinLat -= cellDegreeSize;
-                }
-                let centerX = cameraPos === null || cameraPos === void 0 ? void 0 : cameraPos.longitude;
-                let centerY = cameraPos === null || cameraPos === void 0 ? void 0 : cameraPos.latitude;
-                if (isNaN(centerX) || isNaN(centerY)) {
-                    centerX = (minLon + maxLon) / 2;
-                    centerY = (minLat + maxLat) / 2;
-                }
-                let width = Math.ceil((maxLon - curMinLon) / cellDegreeSize);
-                let height = Math.ceil((maxLat - curMinLat) / cellDegreeSize);
-                // For larger views we add additional padding because our view-area culling is too strong.
-                if (cellDegreeSize >= 2) {
-                    width += 1;
-                    height += 1;
-                }
-                const cellDistances = [];
-                for (let x = 0; x < width; x++) {
-                    for (let y = 0; y < height; y++) {
-                        const lon = x * cellDegreeSize + curMinLon;
-                        const lat = y * cellDegreeSize + curMinLat;
-                        const cellCenterX = lon + cellDegreeSize / 2;
-                        const cellCenterY = lat + cellDegreeSize / 2;
-                        const dist = Math.sqrt(Math.pow(cellCenterX - centerX, 2) + Math.pow(cellCenterY - centerY, 2));
-                        cellDistances.push({ x, y, dist });
-                    }
-                }
-                cellDistances.sort((a, b) => a.dist - b.dist);
-                for (const { x, y } of cellDistances) {
-                    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;
-                    }
-                }
-                return cells;
-            }
-        }
-        EntityGlobe.Grid = Grid;
-    })(exports.EntityGlobe || (exports.EntityGlobe = {}));
-    function floorValueToCellSize(size, value) {
-        return Math.floor(value / size) * size;
-    }
-    function getCellSizeFromHeight(height) {
-        if (height < 1000) {
-            return 0.01;
-        }
-        if (height < 5000) {
-            return 0.025;
-        }
-        else if (height < 10000) {
-            return 0.05;
-        }
-        else if (height < 30000) {
-            return 0.1;
-        }
-        else if (height < 70000) {
-            return 0.2;
-        }
-        else if (height < 100000) {
-            return 0.3;
-        }
-        else if (height < 150000) {
-            return 0.4;
-        }
-        else if (height < 200000) {
-            return 0.5;
-        }
-        else if (height < 300000) {
-            return 0.6;
-        }
-        else if (height < 500000) {
-            return 1;
-        }
-        else if (height < 1000000) {
-            return 1.3;
-        }
-        else if (height < 1200000) {
-            return 1.8;
-        }
-        return 4;
-    }
-    function isCellFetched(cell) {
-        if (cell.Fetched) {
-            return true;
-        }
-        return false;
-    }
-    function getOrCreateCell(cells, cellSize, lon, maxLon, lat, maxLat) {
-        const id = cellSize + "_" + lon + "_" + maxLon + "_" + lat + "_" + maxLat;
-        let cell = cells[id];
-        if (!cell) {
-            cell = cells[id] = new exports.EntityGlobe.Cell();
-            cell.Boundaries = {
-                minLatitude: lat,
-                maxLatitude: maxLat,
-                minLongitude: lon,
-                maxLongitude: maxLon
-            };
-            cell.IsFetched = () => isCellFetched(cell);
-        }
-        return [id, cell];
-    }
-
-    const MAX_AREA_IN_DEGREES = 90;
-    const MAX_RETRY_ATTEMPTS = 1;
-    const RETRY_DELAY_INCREMENT = 500;
-    const REQUEST_PAGE_DELAY = 50;
-    class regMenuItemGetter {
-        constructor(tagIds, minHeight, maxHeight) {
-            this.TagIds = tagIds;
-            this.MinHeight = minHeight;
-            this.MaxHeight = maxHeight;
-        }
-    }
-    function delay(milliseconds) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((res) => {
-                setTimeout(() => {
-                    res();
-                }, milliseconds);
-            });
-        });
-    }
-    (function (EntityFilterGetter) {
-        let EStatus;
-        (function (EStatus) {
-            EStatus["Scanning"] = "SCANNING";
-            EStatus["Loading"] = "LOADING";
-        })(EStatus = EntityFilterGetter.EStatus || (EntityFilterGetter.EStatus = {}));
-        class Getter {
-            get OnUpdate() {
-                if (!this.onUpdate) {
-                    this.onUpdate = new BruceEvent();
-                }
-                return this.onUpdate;
-            }
-            get OnStateUpdate() {
-                if (!this.onStateUpdate) {
-                    this.onStateUpdate = new BruceEvent();
-                }
-                return this.onStateUpdate;
-            }
-            get OnScanUpdate() {
-                if (!this.onScanUpdate) {
-                    this.onScanUpdate = new BruceEvent();
-                }
-                return this.onScanUpdate;
-            }
-            constructor(api, viewPort, typeId, batchSize, attrFilter, viaCdn) {
-                this.onUpdate = null;
-                this.LastStateUpdates = {};
-                this.onStateUpdate = null;
-                this.onScanUpdate = null;
-                this.viewPortChangeRemoval = null;
-                this.cells = null;
-                this.registeredItems = {};
-                this.getterLoopId = 0;
-                this.tagIds = null;
-                this.minHeight = 0;
-                this.maxHeight = 100000;
-                this.viewRect = null;
-                this.viewCenter = null;
-                this.api = api;
-                this.typeId = typeId;
-                this.viaCdn = Boolean(viaCdn);
-                this.batchSize = isNaN(batchSize) ? 300 : batchSize;
-                this.viewPort = viewPort;
-                this.attrFilter = attrFilter;
-                this.updateBounds();
-            }
-            /**
-             * Returns id that represents the combined menu item parameters.
-             * If integrity changes while a request is running, the request will not emit a response.
-             * @returns
-             */
-            getIntegrityId() {
-                return this.tagIds == null ? "" : this.tagIds.join();
-            }
-            viewAreaSub() {
-                this.viewAreaDispose();
-                this.viewPortChangeRemoval = this.viewPort.Updated().Subscribe(() => {
-                    this.updateBounds();
-                    this.startGetterLoop();
-                });
-            }
-            viewAreaDispose() {
-                var _a;
-                (_a = this.viewPortChangeRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
-            }
-            GetMenuItems() {
-                return Object.keys(this.registeredItems);
-            }
-            IncludeMenuItem(menuItemId, layerIds, minHeight, maxHeight) {
-                this.registeredItems[menuItemId] = new regMenuItemGetter(layerIds, minHeight, maxHeight);
-                this.updateState();
-            }
-            ExcludeMenuItem(menuItemId) {
-                this.registeredItems[menuItemId] = null;
-                delete this.registeredItems[menuItemId];
-                this.updateState();
-            }
-            updateBounds() {
-                const viewRect = this.viewPort.GetBounds();
-                const poi = this.viewPort.GetTarget();
-                if (viewRect && poi) {
-                    if (Math.abs(viewRect.west - viewRect.east) > MAX_AREA_IN_DEGREES) {
-                        return;
-                    }
-                    if (Math.abs(viewRect.south - viewRect.north) > MAX_AREA_IN_DEGREES) {
-                        return;
-                    }
-                    this.viewRect = viewRect;
-                    this.viewCenter = poi;
-                }
-            }
-            updateState() {
-                const tagIds = [];
-                const menuItemIds = this.GetMenuItems();
-                let minHeight = null;
-                let maxHeight = null;
-                for (let i = 0; i < menuItemIds.length; i++) {
-                    const menuItem = this.registeredItems[menuItemIds[i]];
-                    if (menuItem) {
-                        if (maxHeight == null || maxHeight < menuItem.MaxHeight) {
-                            maxHeight = menuItem.MaxHeight;
-                        }
-                        if (minHeight == null || minHeight > menuItem.MinHeight) {
-                            minHeight = menuItem.MinHeight;
-                        }
-                        const itemLayerIds = menuItem.TagIds;
-                        if (itemLayerIds) {
-                            for (let j = 0; j < itemLayerIds.length; j++) {
-                                const itemLayerId = itemLayerIds[j];
-                                if (!tagIds.includes(itemLayerId)) {
-                                    tagIds.push(itemLayerId);
-                                }
-                            }
-                        }
-                    }
-                }
-                if (menuItemIds.length > 0) {
-                    // Reset cells so none are marked as fetched.
-                    this.cells = new exports.EntityGlobe.Grid();
-                    this.tagIds = tagIds;
-                    this.minHeight = minHeight;
-                    this.maxHeight = maxHeight;
-                    this.updateBounds();
-                    this.startGetterLoop();
-                    this.viewAreaSub();
-                }
-                else {
-                    this.getterLoopId += 1;
-                    this.viewAreaDispose();
-                }
-            }
-            postStatus(status) {
-                var _a;
-                this.LastStateUpdates[status.msg] = status;
-                (_a = this.onStateUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(status);
-            }
-            startGetterLoop() {
-                // Increase id so that existing loops stop.
-                this.getterLoopId += 1;
-                const loopId = this.getterLoopId;
-                const loopIntegrity = this.getIntegrityId();
-                new Promise(() => __awaiter(this, void 0, void 0, function* () {
-                    var _a, _b, _c, _d, _e, _f, _g, _h;
-                    // Minor delay to stop 50 menu items enabling doing their first request all together.
-                    // This gives it time to recognize only 1 request is needed.
-                    // Would be better to not use this delay but we're on a clock.
-                    yield delay(100);
-                    const MIN_HEIGHT = this.minHeight;
-                    const MAX_HEIGHT = this.maxHeight;
-                    const PAGE_SIZE = this.batchSize;
-                    let retryAttempts = MAX_RETRY_ATTEMPTS;
-                    let retryDelay = 0;
-                    let prevFirstId = "";
-                    let prevLastId = "";
-                    let prevTicks = 0;
-                    while ((!this.viewCenter || !this.viewRect) && this.getterLoopId == loopId) {
-                        yield delay(RETRY_DELAY_INCREMENT);
-                    }
-                    if (this.getterLoopId != loopId) {
-                        return;
-                    }
-                    const alt = this.viewRect.alt;
-                    if (alt > MAX_HEIGHT || (alt < MIN_HEIGHT && MIN_HEIGHT > 0)) {
-                        return;
-                    }
-                    const cells = this.cells.GetCellsForView(this.viewCenter, this.viewRect);
-                    (_a = this.onScanUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(cells);
-                    let curCellIndex = cells.length > 0 ? 0 : null;
-                    let postedScanning = false;
-                    let postedLoading = false;
-                    let total = 0;
-                    while (retryAttempts > 0 && curCellIndex != null) {
-                        if (retryDelay > 0) {
-                            yield delay(retryDelay);
-                        }
-                        if (this.getterLoopId != loopId) {
-                            break;
-                        }
-                        if (!postedScanning) {
-                            this.postStatus({ msg: EStatus.Scanning, revoking: false });
-                            postedScanning = true;
-                        }
-                        const curCell = cells[curCellIndex];
-                        if (curCell.IsFetched()) {
-                            curCell.Fetching = false;
-                            curCellIndex += 1;
-                            if (cells[curCellIndex]) {
-                                cells[curCellIndex].Fetching = true;
-                            }
-                            else {
-                                curCellIndex = null;
-                            }
-                            (_b = this.onScanUpdate) === null || _b === void 0 ? void 0 : _b.Trigger(cells);
-                            continue;
-                        }
-                        try {
-                            let { entities } = yield exports.Entity.GetList({
-                                api: this.api,
-                                filter: {
-                                    pageSize: PAGE_SIZE,
-                                    pageIndex: curCell.FetchPageIndex,
-                                    entityTypeId: this.typeId,
-                                    layerIds: this.tagIds,
-                                    // Any tag specified will be allowed.
-                                    layerIdsOperator: "in",
-                                    bounds: curCell.GetBounds(),
-                                    sortOrder: exports.Api.ESortOrder.Asc,
-                                    entityTypeConditions: this.attrFilter
-                                },
-                                viaCdn: this.viaCdn,
-                                req: {
-                                    noCache: true
-                                }
-                            });
-                            const integrity = this.getIntegrityId();
-                            if (loopIntegrity == integrity && entities) {
-                                (_c = this.onUpdate) === null || _c === void 0 ? void 0 : _c.Trigger(entities);
-                            }
-                            if (this.getterLoopId != loopId) {
-                                break;
-                            }
-                            if (entities.length) {
-                                total += entities.length;
-                            }
-                            if (!postedLoading) {
-                                this.postStatus({ msg: EStatus.Loading, revoking: false });
-                                postedLoading = true;
-                            }
-                            // Only mark as fetched when ALL pages are done.
-                            // Known issue where external sources may return less than page size.
-                            // Right now we're making it as fetched as we're siding with the majority use-case.
-                            if (entities.length <= 0 || entities.length < PAGE_SIZE) {
-                                curCell.Fetched = true;
-                                curCell.Fetching = false;
-                                (_d = this.onScanUpdate) === null || _d === void 0 ? void 0 : _d.Trigger(cells);
-                                continue;
-                            }
-                            // Checking to make sure it's not just the same batch over and over again.
-                            if (entities.length > 0) {
-                                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) {
-                                    prevTicks += 1;
-                                    if (prevTicks > 3) {
-                                        break;
-                                    }
-                                }
-                                else {
-                                    prevFirstId = first;
-                                    prevLastId = last;
-                                    prevTicks = 0;
-                                }
-                            }
-                            curCell.FetchPageIndex++;
-                            // Request passed so let's assume it was server hiccup and refresh counts.
-                            retryAttempts = MAX_RETRY_ATTEMPTS;
-                            retryDelay = 0;
-                        }
-                        catch (e) {
-                            console.error(e);
-                            // Request failed so let's add a delay and try again soon.
-                            retryDelay += RETRY_DELAY_INCREMENT;
-                            retryAttempts -= 1;
-                        }
-                        yield delay(REQUEST_PAGE_DELAY);
-                    }
-                    if (postedLoading) {
-                        this.postStatus({ msg: EStatus.Loading, revoking: true });
-                    }
-                    if (postedScanning) {
-                        this.postStatus({ msg: EStatus.Scanning, revoking: true });
-                    }
-                }));
-            }
-        }
-        EntityFilterGetter.Getter = Getter;
-    })(exports.EntityFilterGetter || (exports.EntityFilterGetter = {}));
-
-    const MAX_AREA_IN_DEGREES$1 = 90;
-    const GETTER_DELAY = 50;
-    (function (BatchedDataGetter) {
-        class Getter {
-            get OnUpdate() {
-                if (!this.onUpdate) {
-                    this.onUpdate = new BruceEvent();
-                }
-                return this.onUpdate;
-            }
-            constructor(data, viewPort, batchSize) {
-                this.viewPortRemoval = null;
-                this.viewRect = null;
-                this.viewCenter = null;
-                this.onUpdate = null;
-                this.data = data;
-                this.viewPort = viewPort;
-                this.batchSize = batchSize;
-            }
-            Start() {
-                this.viewPortRemoval = this.viewPort.Updated().Subscribe(() => {
-                    this.updateViewport();
-                });
-                this.updateViewport();
-            }
-            Dispose() {
-                var _a;
-                (_a = this.viewPortRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
-            }
-            updateViewport() {
-                this.updateBounds();
-                this.startGetterLoop();
-            }
-            updateBounds() {
-                const viewRect = this.viewPort.GetBounds();
-                const poi = this.viewPort.GetTarget();
-                if (viewRect && poi) {
-                    if (Math.abs(viewRect.west - viewRect.east) > MAX_AREA_IN_DEGREES$1) {
-                        return;
-                    }
-                    if (Math.abs(viewRect.south - viewRect.north) > MAX_AREA_IN_DEGREES$1) {
-                        return;
-                    }
-                    this.viewRect = viewRect;
-                    this.viewCenter = poi;
-                }
-            }
-            startGetterLoop() {
-                clearInterval(this.getterInterval);
-                if (!this.viewRect || !this.viewCenter) {
-                    return;
-                }
-                let index = 0;
-                const onTick = () => {
-                    this.processBatch(this.data.slice(index, index + this.batchSize));
-                    index += this.batchSize;
-                    return index >= this.data.length;
-                };
-                if (!onTick()) {
-                    this.getterInterval = setInterval(() => {
-                        if (onTick()) {
-                            clearInterval(this.getterInterval);
-                        }
-                    }, GETTER_DELAY);
-                }
-            }
-            processBatch(batch) {
-                var _a;
-                if (batch.length > 0) {
-                    (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(batch);
-                }
-            }
-        }
-        BatchedDataGetter.Getter = Getter;
-    })(exports.BatchedDataGetter || (exports.BatchedDataGetter = {}));
-
     (function (MathUtils) {
         /**
          * Rounds a number to a given number of decimal places.
@@ -8924,7 +8391,7 @@
         DataSource.GetList = GetList;
     })(exports.DataSource || (exports.DataSource = {}));
 
-    const VERSION = "3.1.3";
+    const VERSION = "3.1.5";
 
     exports.VERSION = VERSION;
     exports.AbstractApi = AbstractApi;