bruce-cesium 2.9.8 → 2.9.9

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
-import { BruceEvent, Cartes, ProjectViewTile, Carto, Entity as Entity$1, Geometry, Tileset, MathUtils, LRUCache, ZoomControl, Style, EntityTag, Calculator, EntityLod, EntityType, ClientFile, ObjectUtils, Bounds, EntityRelationType, DelayQueue, BatchedDataGetter, EntityCoords, EntityFilterGetter, EntitySource, MenuItem, EntityRelation, ENVIRONMENT, ProjectView, ProjectViewBookmark, ProjectViewLegacyTile, ProgramKey, Camera, AbstractApi, EntityAttachment, EntityAttachmentType, EntityAttribute } from 'bruce-models';
+import { BruceEvent, Cartes, ProjectViewTile, Carto, Entity as Entity$1, Geometry, Tileset, MathUtils, LRUCache, ZoomControl, Style, EntityTag, Calculator, EntityLod, EntityType, ClientFile, ObjectUtils, Bounds, EntityRelationType, DelayQueue, EntityCoords, Api, EntitySource, MenuItem, EntityRelation, ENVIRONMENT, ProjectView, ProjectViewBookmark, ProjectViewLegacyTile, ProgramKey, Camera, AbstractApi, EntityAttachment, EntityAttachmentType, EntityAttribute } from 'bruce-models';
 import * as Cesium from 'cesium';
-import { Cartographic, Cartesian2, CallbackProperty, Cartesian3, Color, Rectangle, Math as Math$1, JulianDate, HeightReference, DistanceDisplayCondition, NearFarScalar, Entity, HorizontalOrigin, VerticalOrigin, ClassificationType, ArcType, CornerType, ShadowMode, PolygonHierarchy, PolylineGraphics, HeadingPitchRoll, Transforms, ColorBlendMode, Primitive, Cesium3DTileFeature, SceneMode, Cesium3DTileColorBlendMode, HeadingPitchRange, createOsmBuildings, Cesium3DTileStyle, KmlDataSource, OrthographicFrustum, EasingFunction, SceneTransforms, EllipsoidTerrainProvider, CesiumInspector, defined, EllipsoidGeodesic, sampleTerrainMostDetailed, Cesium3DTileset, Model, Matrix4, Matrix3, IonResource, Ion, createWorldTerrain, CesiumTerrainProvider, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, UrlTemplateImageryProvider, TileMapServiceImageryProvider, IonImageryProvider, PolygonPipeline, ColorMaterialProperty, GeometryInstance, ScreenSpaceEventHandler, ScreenSpaceEventType, BoundingSphere, Intersect } from 'cesium';
+import { Cartographic, JulianDate, Cartesian2, CallbackProperty, Cartesian3, Color, Rectangle, Math as Math$1, Entity, Primitive, Cesium3DTileFeature, SceneMode, HeadingPitchRange, Cesium3DTileColorBlendMode, HeightReference, DistanceDisplayCondition, NearFarScalar, HorizontalOrigin, VerticalOrigin, ClassificationType, ArcType, CornerType, ShadowMode, PolygonHierarchy, PolylineGraphics, HeadingPitchRoll, Transforms, ColorBlendMode, createOsmBuildings, Cesium3DTileStyle, KmlDataSource, OrthographicFrustum, EasingFunction, SceneTransforms, PolygonPipeline, Cesium3DTileset, Matrix4, Matrix3, IonResource, Ion, EllipsoidTerrainProvider, CesiumInspector, defined, ColorMaterialProperty, GeometryInstance, EllipsoidGeodesic, sampleTerrainMostDetailed, Model, ScreenSpaceEventHandler, ScreenSpaceEventType, createWorldTerrain, CesiumTerrainProvider, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, UrlTemplateImageryProvider, TileMapServiceImageryProvider, IonImageryProvider, BoundingSphere, Intersect } from 'cesium';
 
 var TIME_LAG = 300;
 var POSITION_CHECK_TIMER = 950;
@@ -73,191 +73,195 @@ function areBoundsEqual(a, b) {
 function arePosEqual(a, b) {
     return a.latitude == b.latitude && a.longitude == b.longitude;
 }
-/**
- * Monitors and emits events when the Cesium view changes.
- */
-var CesiumViewMonitor = /** @class */ (function () {
-    function CesiumViewMonitor(viewer) {
-        var _this = this;
-        this.target = null;
-        this.bounds = null;
-        this.disposed = false;
-        this.updatedEvent = null;
-        this.entity = null;
-        this.viewer = viewer;
-        this.tryEmitUpdate();
-        this.checkInterval = setInterval(function () {
-            _this.updateQueue();
-        }, POSITION_CHECK_TIMER);
-    }
-    Object.defineProperty(CesiumViewMonitor.prototype, "Disposed", {
-        get: function () {
-            return this.disposed;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    CesiumViewMonitor.prototype.createEntity = function () {
-        var _this = this;
-        if (this.entity) {
-            return;
+var CesiumViewMonitor;
+(function (CesiumViewMonitor) {
+    /**
+     * Monitors and emits events when the Cesium view changes.
+     */
+    var Monitor = /** @class */ (function () {
+        function Monitor(viewer) {
+            var _this = this;
+            this.target = null;
+            this.bounds = null;
+            this.disposed = false;
+            this.updatedEvent = null;
+            this.entity = null;
+            this.viewer = viewer;
+            this.tryEmitUpdate();
+            this.checkInterval = setInterval(function () {
+                _this.updateQueue();
+            }, POSITION_CHECK_TIMER);
         }
-        this.entity = this.viewer.entities.add({
-            position: new CallbackProperty(function () {
-                return _this.target ? Cartesian3.fromDegrees(_this.target.longitude, _this.target.latitude) : null;
-            }, false),
-            point: {
-                pixelSize: 8,
-                color: Color.ORANGE
+        Object.defineProperty(Monitor.prototype, "Disposed", {
+            get: function () {
+                return this.disposed;
             },
-            rectangle: {
-                coordinates: new CallbackProperty(function () {
-                    return _this.bounds ? Rectangle.fromDegrees(_this.bounds.west, _this.bounds.south, _this.bounds.east, _this.bounds.north) : null;
-                }, false),
-                material: Color.fromCssColorString('#ff0000').withAlpha(0.4),
-                zIndex: 1
-            }
+            enumerable: false,
+            configurable: true
         });
-    };
-    CesiumViewMonitor.prototype.destroyEntity = function () {
-        if (this.entity && this.viewer.entities.contains(this.entity)) {
-            this.viewer.entities.remove(this.entity);
-        }
-        this.entity = null;
-    };
-    CesiumViewMonitor.prototype.Updated = function () {
-        if (!this.updatedEvent) {
-            this.updatedEvent = new BruceEvent();
-        }
-        return this.updatedEvent;
-    };
-    CesiumViewMonitor.prototype.GetBounds = function () {
-        return this.bounds;
-    };
-    CesiumViewMonitor.prototype.GetTarget = function () {
-        return this.target;
-    };
-    CesiumViewMonitor.prototype.DoUpdate = function () {
-        this.tryEmitUpdate();
-    };
-    CesiumViewMonitor.prototype.Dispose = function () {
-        if (this.disposed) {
-            return;
-        }
-        this.disposed = true;
-        clearInterval(this.checkInterval);
-        this.destroyEntity();
-    };
-    CesiumViewMonitor.prototype.tryDoUpdate = function () {
-        var _a;
-        if (!this.viewer || this.viewer.isDestroyed()) {
-            this.Dispose();
-            return ESearchStatus.LocationMissing;
-        }
-        var viewRect = null;
-        var center = null;
-        var camera = this.viewer.camera;
-        var terrainHeight = this.viewer.scene.globe.getHeight(camera.positionCartographic);
-        var cameraPosition = this.viewer.camera.positionCartographic;
-        // We are almost at the ground, screw horizon, just load around.
-        if (terrainHeight && ((cameraPosition.height - terrainHeight) < DEFAULT_GROUNDED_HEIGHT)) {
-            // View area calculation.
-            viewRect = {};
-            var viewRectRad = netScanViewForBoundaries(this.viewer);
-            if (viewRectRad &&
-                viewRectRad.east &&
-                viewRectRad.west &&
-                viewRectRad.north &&
-                viewRectRad.south) {
-                viewRect.east = Math$1.toDegrees(Math.max(viewRectRad.east, cameraPosition.longitude));
-                viewRect.west = Math$1.toDegrees(Math.min(viewRectRad.west, cameraPosition.longitude));
-                viewRect.south = Math$1.toDegrees(Math.min(viewRectRad.south, cameraPosition.latitude));
-                viewRect.north = Math$1.toDegrees(Math.max(viewRectRad.north, cameraPosition.latitude));
+        Monitor.prototype.createEntity = function () {
+            var _this = this;
+            if (this.entity) {
+                return;
             }
-            else {
-                viewRect.east = cameraPosition.longitude;
-                viewRect.west = cameraPosition.longitude;
-                viewRect.south = cameraPosition.latitude;
-                viewRect.north = cameraPosition.latitude;
+            this.entity = this.viewer.entities.add({
+                position: new CallbackProperty(function () {
+                    return _this.target ? Cartesian3.fromDegrees(_this.target.longitude, _this.target.latitude) : null;
+                }, false),
+                point: {
+                    pixelSize: 8,
+                    color: Color.ORANGE
+                },
+                rectangle: {
+                    coordinates: new CallbackProperty(function () {
+                        return _this.bounds ? Rectangle.fromDegrees(_this.bounds.west, _this.bounds.south, _this.bounds.east, _this.bounds.north) : null;
+                    }, false),
+                    material: Color.fromCssColorString('#ff0000').withAlpha(0.4),
+                    zIndex: 1
+                }
+            });
+        };
+        Monitor.prototype.destroyEntity = function () {
+            if (this.entity && this.viewer.entities.contains(this.entity)) {
+                this.viewer.entities.remove(this.entity);
             }
-            center = {};
-            center.latitude = Math$1.toDegrees(camera.positionCartographic.latitude);
-            center.longitude = Math$1.toDegrees(camera.positionCartographic.longitude);
-        }
-        else {
-            // View area calculation.
-            var windowPosition = new Cartesian2(this.viewer.container.clientWidth / 2, this.viewer.container.clientHeight / 2);
-            var intersection = getAdjustedGroundIntersectionOfCameraRay(this.viewer, windowPosition);
-            var point = null;
-            if (intersection) {
-                point = Cartographic.fromCartesian(intersection, this.viewer.scene.globe.ellipsoid);
+            this.entity = null;
+        };
+        Monitor.prototype.Updated = function () {
+            if (!this.updatedEvent) {
+                this.updatedEvent = new BruceEvent();
             }
-            if (point) {
-                center = {};
-                center.latitude = Math$1.toDegrees(point.latitude);
-                center.longitude = Math$1.toDegrees(point.longitude);
+            return this.updatedEvent;
+        };
+        Monitor.prototype.GetBounds = function () {
+            return this.bounds;
+        };
+        Monitor.prototype.GetTarget = function () {
+            return this.target;
+        };
+        Monitor.prototype.DoUpdate = function () {
+            this.tryEmitUpdate();
+        };
+        Monitor.prototype.Dispose = function () {
+            if (this.disposed) {
+                return;
+            }
+            this.disposed = true;
+            clearInterval(this.checkInterval);
+            this.destroyEntity();
+        };
+        Monitor.prototype.tryDoUpdate = function () {
+            var _a;
+            if (!this.viewer || this.viewer.isDestroyed()) {
+                this.Dispose();
+                return ESearchStatus.LocationMissing;
+            }
+            var viewRect = null;
+            var center = null;
+            var camera = this.viewer.camera;
+            var terrainHeight = this.viewer.scene.globe.getHeight(camera.positionCartographic);
+            var cameraPosition = this.viewer.camera.positionCartographic;
+            // We are almost at the ground, screw horizon, just load around.
+            if (terrainHeight && ((cameraPosition.height - terrainHeight) < DEFAULT_GROUNDED_HEIGHT)) {
+                // View area calculation.
+                viewRect = {};
                 var viewRectRad = netScanViewForBoundaries(this.viewer);
-                if (viewRectRad) {
-                    viewRect = {};
-                    viewRect.east = Math$1.toDegrees(viewRectRad.east);
-                    viewRect.west = Math$1.toDegrees(viewRectRad.west);
-                    viewRect.south = Math$1.toDegrees(viewRectRad.south);
-                    viewRect.north = Math$1.toDegrees(viewRectRad.north);
+                if (viewRectRad &&
+                    viewRectRad.east &&
+                    viewRectRad.west &&
+                    viewRectRad.north &&
+                    viewRectRad.south) {
+                    viewRect.east = Math$1.toDegrees(Math.max(viewRectRad.east, cameraPosition.longitude));
+                    viewRect.west = Math$1.toDegrees(Math.min(viewRectRad.west, cameraPosition.longitude));
+                    viewRect.south = Math$1.toDegrees(Math.min(viewRectRad.south, cameraPosition.latitude));
+                    viewRect.north = Math$1.toDegrees(Math.max(viewRectRad.north, cameraPosition.latitude));
                 }
+                else {
+                    viewRect.east = cameraPosition.longitude;
+                    viewRect.west = cameraPosition.longitude;
+                    viewRect.south = cameraPosition.latitude;
+                    viewRect.north = cameraPosition.latitude;
+                }
+                center = {};
+                center.latitude = Math$1.toDegrees(camera.positionCartographic.latitude);
+                center.longitude = Math$1.toDegrees(camera.positionCartographic.longitude);
             }
-        }
-        // Minimal field of view.
-        if (viewRect) {
-            var centerLong = (viewRect.east + viewRect.west) / 2;
-            var centerLat = (viewRect.north + viewRect.south) / 2;
-            viewRect.east = Math.max(viewRect.east, centerLong + (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
-            viewRect.west = Math.min(viewRect.west, centerLong - (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
-            viewRect.south = Math.min(viewRect.south, centerLat - (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
-            viewRect.north = Math.max(viewRect.north, centerLat + (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
-            viewRect.alt = (_a = this.viewer.scene.camera.positionCartographic) === null || _a === void 0 ? void 0 : _a.height;
-        }
-        if (center && viewRect) {
-            if ((!this.target || (this.target && !arePosEqual(this.target, center))) ||
-                (!this.bounds || (this.bounds && !areBoundsEqual(this.bounds, viewRect)))) {
-                this.target = center;
-                this.bounds = viewRect;
-                return ESearchStatus.LocationChanged;
+            else {
+                // View area calculation.
+                var windowPosition = new Cartesian2(this.viewer.container.clientWidth / 2, this.viewer.container.clientHeight / 2);
+                var intersection = getAdjustedGroundIntersectionOfCameraRay(this.viewer, windowPosition);
+                var point = null;
+                if (intersection) {
+                    point = Cartographic.fromCartesian(intersection, this.viewer.scene.globe.ellipsoid);
+                }
+                if (point) {
+                    center = {};
+                    center.latitude = Math$1.toDegrees(point.latitude);
+                    center.longitude = Math$1.toDegrees(point.longitude);
+                    var viewRectRad = netScanViewForBoundaries(this.viewer);
+                    if (viewRectRad) {
+                        viewRect = {};
+                        viewRect.east = Math$1.toDegrees(viewRectRad.east);
+                        viewRect.west = Math$1.toDegrees(viewRectRad.west);
+                        viewRect.south = Math$1.toDegrees(viewRectRad.south);
+                        viewRect.north = Math$1.toDegrees(viewRectRad.north);
+                    }
+                }
             }
-            return ESearchStatus.LocationFound;
-        }
-        return ESearchStatus.LocationMissing;
-    };
-    CesiumViewMonitor.prototype.tryEmitUpdate = function () {
-        var _a;
-        var searchResult = this.tryDoUpdate();
-        if (searchResult == ESearchStatus.LocationChanged) {
-            var interest = {
-                bounds: this.bounds,
-                target: this.target
-            };
-            //this.createEntity();
-            (_a = this.updatedEvent) === null || _a === void 0 ? void 0 : _a.Trigger(interest);
-        }
-        else if (searchResult == ESearchStatus.LocationMissing) {
-            this.updateQueue();
-        }
-    };
-    CesiumViewMonitor.prototype.queuePosition = function (lag) {
-        var _this = this;
-        if (this.pendingTimeout) {
-            clearTimeout(this.pendingTimeout);
-        }
-        this.pendingTimeout = setTimeout(function () {
-            if (!_this.disposed) {
-                _this.tryEmitUpdate();
+            // Minimal field of view.
+            if (viewRect) {
+                var centerLong = (viewRect.east + viewRect.west) / 2;
+                var centerLat = (viewRect.north + viewRect.south) / 2;
+                viewRect.east = Math.max(viewRect.east, centerLong + (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
+                viewRect.west = Math.min(viewRect.west, centerLong - (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
+                viewRect.south = Math.min(viewRect.south, centerLat - (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
+                viewRect.north = Math.max(viewRect.north, centerLat + (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
+                viewRect.alt = (_a = this.viewer.scene.camera.positionCartographic) === null || _a === void 0 ? void 0 : _a.height;
+            }
+            if (center && viewRect) {
+                if ((!this.target || (this.target && !arePosEqual(this.target, center))) ||
+                    (!this.bounds || (this.bounds && !areBoundsEqual(this.bounds, viewRect)))) {
+                    this.target = center;
+                    this.bounds = viewRect;
+                    return ESearchStatus.LocationChanged;
+                }
+                return ESearchStatus.LocationFound;
             }
-        }, lag);
-    };
-    CesiumViewMonitor.prototype.updateQueue = function () {
-        this.queuePosition(TIME_LAG);
-    };
-    return CesiumViewMonitor;
-}());
+            return ESearchStatus.LocationMissing;
+        };
+        Monitor.prototype.tryEmitUpdate = function () {
+            var _a;
+            var searchResult = this.tryDoUpdate();
+            if (searchResult == ESearchStatus.LocationChanged) {
+                var interest = {
+                    bounds: this.bounds,
+                    target: this.target
+                };
+                //this.createEntity();
+                (_a = this.updatedEvent) === null || _a === void 0 ? void 0 : _a.Trigger(interest);
+            }
+            else if (searchResult == ESearchStatus.LocationMissing) {
+                this.updateQueue();
+            }
+        };
+        Monitor.prototype.queuePosition = function (lag) {
+            var _this = this;
+            if (this.pendingTimeout) {
+                clearTimeout(this.pendingTimeout);
+            }
+            this.pendingTimeout = setTimeout(function () {
+                if (!_this.disposed) {
+                    _this.tryEmitUpdate();
+                }
+            }, lag);
+        };
+        Monitor.prototype.updateQueue = function () {
+            this.queuePosition(TIME_LAG);
+        };
+        return Monitor;
+    }());
+    CesiumViewMonitor.Monitor = Monitor;
+})(CesiumViewMonitor || (CesiumViewMonitor = {}));
 
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation. All rights reserved.
@@ -7583,6 +7587,94 @@ var EntitiesRenderManager;
     EntitiesRenderManager.Manager = Manager;
 })(EntitiesRenderManager || (EntitiesRenderManager = {}));
 
+var MAX_AREA_IN_DEGREES = 90;
+var GETTER_DELAY = 50;
+/**
+ * This is a batched "arbitrary data" getter.
+ * You feed it an array of data, then it will emit that data in batches when the view changes.
+ */
+var BatchedDataGetter;
+(function (BatchedDataGetter) {
+    var Getter = /** @class */ (function () {
+        function Getter(data, viewPort, batchSize) {
+            this.viewPortRemoval = null;
+            this.viewRect = null;
+            this.viewCenter = null;
+            this.onUpdate = null;
+            this.data = data;
+            this.viewPort = viewPort;
+            this.batchSize = batchSize;
+        }
+        Object.defineProperty(Getter.prototype, "OnUpdate", {
+            get: function () {
+                if (!this.onUpdate) {
+                    this.onUpdate = new BruceEvent();
+                }
+                return this.onUpdate;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Getter.prototype.Start = function () {
+            var _this = this;
+            this.viewPortRemoval = this.viewPort.Updated().Subscribe(function () {
+                _this.updateViewport();
+            });
+            this.updateViewport();
+        };
+        Getter.prototype.Dispose = function () {
+            var _a;
+            (_a = this.viewPortRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+        };
+        Getter.prototype.updateViewport = function () {
+            this.updateBounds();
+            this.startGetterLoop();
+        };
+        Getter.prototype.updateBounds = function () {
+            var viewRect = this.viewPort.GetBounds();
+            var 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;
+            }
+        };
+        Getter.prototype.startGetterLoop = function () {
+            var _this = this;
+            clearInterval(this.getterInterval);
+            if (!this.viewRect || !this.viewCenter) {
+                return;
+            }
+            var index = 0;
+            var onTick = function () {
+                _this.processBatch(_this.data.slice(index, index + _this.batchSize));
+                index += _this.batchSize;
+                return index >= _this.data.length;
+            };
+            if (!onTick()) {
+                this.getterInterval = setInterval(function () {
+                    if (onTick()) {
+                        clearInterval(_this.getterInterval);
+                    }
+                }, GETTER_DELAY);
+            }
+        };
+        Getter.prototype.processBatch = function (batch) {
+            var _a;
+            if (batch.length > 0) {
+                (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(batch);
+            }
+        };
+        return Getter;
+    }());
+    BatchedDataGetter.Getter = Getter;
+})(BatchedDataGetter || (BatchedDataGetter = {}));
+
 var BATCH_SIZE$1 = 500;
 var CHECK_BATCH_SIZE$1 = 250;
 /**
@@ -9615,6 +9707,521 @@ var TilesetCadRenderManager;
     TilesetCadRenderManager.Manager = Manager;
 })(TilesetCadRenderManager || (TilesetCadRenderManager = {}));
 
+/**
+ * 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.
+ */
+var EntityGlobe;
+(function (EntityGlobe) {
+    var Cell = /** @class */ (function () {
+        function Cell() {
+            this.Fetched = false;
+            this.IsFetched = null;
+            this.FetchPageIndex = 0;
+            this.Boundaries = null;
+            this.Fetching = false;
+        }
+        Cell.prototype.GetBounds = function () {
+            // 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.
+            var maxLon = prepareRangeForBounds(this.Boundaries.maxLongitude) + 0.00001;
+            var minLon = prepareRangeForBounds(this.Boundaries.minLongitude) - 0.00001;
+            var maxLat = prepareRangeForBounds(this.Boundaries.maxLatitude) + 0.00001;
+            var minLat = prepareRangeForBounds(this.Boundaries.minLatitude) - 0.00001;
+            return {
+                east: maxLon,
+                north: maxLat,
+                south: minLat,
+                west: minLon
+            };
+        };
+        return Cell;
+    }());
+    EntityGlobe.Cell = Cell;
+    var Grid = /** @class */ (function () {
+        function Grid() {
+            this.cells = {};
+        }
+        Grid.prototype.GetCellsForView = function (cameraPos, viewRect) {
+            var cells = [];
+            var minLat = viewRect.south;
+            var minLon = viewRect.west;
+            var maxLat = viewRect.north;
+            var maxLon = viewRect.east;
+            var MAX_CELLS = 150;
+            var cellDegreeSize = getCellSizeFromHeight(viewRect.alt);
+            var curMinLon = floorValueToCellSize(cellDegreeSize, minLon);
+            var 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;
+            }
+            var centerX = cameraPos === null || cameraPos === void 0 ? void 0 : cameraPos.longitude;
+            var centerY = cameraPos === null || cameraPos === void 0 ? void 0 : cameraPos.latitude;
+            if (isNaN(centerX) || isNaN(centerY)) {
+                centerX = (minLon + maxLon) / 2;
+                centerY = (minLat + maxLat) / 2;
+            }
+            var width = Math.ceil((maxLon - curMinLon) / cellDegreeSize);
+            var 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;
+            }
+            var cellDistances = [];
+            for (var x = 0; x < width; x++) {
+                for (var y = 0; y < height; y++) {
+                    var lon = x * cellDegreeSize + curMinLon;
+                    var lat = y * cellDegreeSize + curMinLat;
+                    var cellCenterX = lon + cellDegreeSize / 2;
+                    var cellCenterY = lat + cellDegreeSize / 2;
+                    var dist = Math.sqrt(Math.pow(cellCenterX - centerX, 2) + Math.pow(cellCenterY - centerY, 2));
+                    cellDistances.push({ x: x, y: y, dist: dist });
+                }
+            }
+            cellDistances.sort(function (a, b) { return a.dist - b.dist; });
+            for (var _i = 0, cellDistances_1 = cellDistances; _i < cellDistances_1.length; _i++) {
+                var _a = cellDistances_1[_i], x = _a.x, y = _a.y;
+                var lon = x * cellDegreeSize + curMinLon;
+                var lat = y * cellDegreeSize + curMinLat;
+                var _b = getOrCreateCell(this.cells, cellDegreeSize, lon, lon + cellDegreeSize, lat, lat + cellDegreeSize), cell = _b[1];
+                cells.push(cell);
+                if (cells.length >= MAX_CELLS) {
+                    break;
+                }
+            }
+            return cells;
+        };
+        return Grid;
+    }());
+    EntityGlobe.Grid = Grid;
+})(EntityGlobe || (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) {
+    var id = cellSize + "_" + lon + "_" + maxLon + "_" + lat + "_" + maxLat;
+    var cell = cells[id];
+    if (!cell) {
+        cell = cells[id] = new EntityGlobe.Cell();
+        cell.Boundaries = {
+            minLatitude: lat,
+            maxLatitude: maxLat,
+            minLongitude: lon,
+            maxLongitude: maxLon
+        };
+        cell.IsFetched = function () { return isCellFetched(cell); };
+    }
+    return [id, cell];
+}
+
+var MAX_AREA_IN_DEGREES$1 = 90;
+var MAX_RETRY_ATTEMPTS = 1;
+var RETRY_DELAY_INCREMENT = 500;
+var REQUEST_PAGE_DELAY = 50;
+var regMenuItemGetter = /** @class */ (function () {
+    function regMenuItemGetter(tagIds, minHeight, maxHeight) {
+        this.TagIds = tagIds;
+        this.MinHeight = minHeight;
+        this.MaxHeight = maxHeight;
+    }
+    return regMenuItemGetter;
+}());
+function delay(milliseconds) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, new Promise(function (res) {
+                    setTimeout(function () {
+                        res();
+                    }, milliseconds);
+                })];
+        });
+    });
+}
+/**
+ * This is a batched entity getter.
+ * It will scan for entity records in a view-area and emit them in batches.
+ * It will restart scanning if the camera moves.
+ */
+var EntityFilterGetter;
+(function (EntityFilterGetter) {
+    var EStatus;
+    (function (EStatus) {
+        EStatus["Scanning"] = "SCANNING";
+        EStatus["Loading"] = "LOADING";
+    })(EStatus = EntityFilterGetter.EStatus || (EntityFilterGetter.EStatus = {}));
+    var Getter = /** @class */ (function () {
+        function Getter(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();
+        }
+        Object.defineProperty(Getter.prototype, "OnUpdate", {
+            get: function () {
+                if (!this.onUpdate) {
+                    this.onUpdate = new BruceEvent();
+                }
+                return this.onUpdate;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(Getter.prototype, "OnStateUpdate", {
+            get: function () {
+                if (!this.onStateUpdate) {
+                    this.onStateUpdate = new BruceEvent();
+                }
+                return this.onStateUpdate;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(Getter.prototype, "OnScanUpdate", {
+            get: function () {
+                if (!this.onScanUpdate) {
+                    this.onScanUpdate = new BruceEvent();
+                }
+                return this.onScanUpdate;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        /**
+         * 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
+         */
+        Getter.prototype.getIntegrityId = function () {
+            return this.tagIds == null ? "" : this.tagIds.join();
+        };
+        Getter.prototype.viewAreaSub = function () {
+            var _this = this;
+            this.viewAreaDispose();
+            this.viewPortChangeRemoval = this.viewPort.Updated().Subscribe(function () {
+                _this.updateBounds();
+                _this.startGetterLoop();
+            });
+        };
+        Getter.prototype.viewAreaDispose = function () {
+            var _a;
+            (_a = this.viewPortChangeRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+        };
+        Getter.prototype.GetMenuItems = function () {
+            return Object.keys(this.registeredItems);
+        };
+        Getter.prototype.IncludeMenuItem = function (menuItemId, layerIds, minHeight, maxHeight) {
+            this.registeredItems[menuItemId] = new regMenuItemGetter(layerIds, minHeight, maxHeight);
+            this.updateState();
+        };
+        Getter.prototype.ExcludeMenuItem = function (menuItemId) {
+            this.registeredItems[menuItemId] = null;
+            delete this.registeredItems[menuItemId];
+            this.updateState();
+        };
+        Getter.prototype.updateBounds = function () {
+            var viewRect = this.viewPort.GetBounds();
+            var 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;
+            }
+        };
+        Getter.prototype.updateState = function () {
+            var tagIds = [];
+            var menuItemIds = this.GetMenuItems();
+            var minHeight = null;
+            var maxHeight = null;
+            for (var i = 0; i < menuItemIds.length; i++) {
+                var 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;
+                    }
+                    var itemLayerIds = menuItem.TagIds;
+                    if (itemLayerIds) {
+                        for (var j = 0; j < itemLayerIds.length; j++) {
+                            var 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 EntityGlobe.Grid();
+                this.tagIds = tagIds;
+                this.minHeight = minHeight;
+                this.maxHeight = maxHeight;
+                this.updateBounds();
+                this.startGetterLoop();
+                this.viewAreaSub();
+            }
+            else {
+                this.getterLoopId += 1;
+                this.viewAreaDispose();
+            }
+        };
+        Getter.prototype.postStatus = function (status) {
+            var _a;
+            this.LastStateUpdates[status.msg] = status;
+            (_a = this.onStateUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(status);
+        };
+        Getter.prototype.startGetterLoop = function () {
+            var _this = this;
+            // Increase id so that existing loops stop.
+            this.getterLoopId += 1;
+            var loopId = this.getterLoopId;
+            var loopIntegrity = this.getIntegrityId();
+            new Promise(function () { return __awaiter(_this, void 0, void 0, function () {
+                var MIN_HEIGHT, MAX_HEIGHT, PAGE_SIZE, retryAttempts, retryDelay, prevFirstId, prevLastId, prevTicks, alt, cells, curCellIndex, postedScanning, postedLoading, total, curCell, entities, integrity, first, last, e_1;
+                var _a, _b, _c, _d, _e, _f, _g, _h;
+                return __generator(this, function (_j) {
+                    switch (_j.label) {
+                        case 0: 
+                        // 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.
+                        return [4 /*yield*/, delay(100)];
+                        case 1:
+                            // 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.
+                            _j.sent();
+                            MIN_HEIGHT = this.minHeight;
+                            MAX_HEIGHT = this.maxHeight;
+                            PAGE_SIZE = this.batchSize;
+                            retryAttempts = MAX_RETRY_ATTEMPTS;
+                            retryDelay = 0;
+                            prevFirstId = "";
+                            prevLastId = "";
+                            prevTicks = 0;
+                            _j.label = 2;
+                        case 2:
+                            if (!((!this.viewCenter || !this.viewRect) && this.getterLoopId == loopId)) return [3 /*break*/, 4];
+                            return [4 /*yield*/, delay(RETRY_DELAY_INCREMENT)];
+                        case 3:
+                            _j.sent();
+                            return [3 /*break*/, 2];
+                        case 4:
+                            if (this.getterLoopId != loopId) {
+                                return [2 /*return*/];
+                            }
+                            alt = this.viewRect.alt;
+                            if (alt > MAX_HEIGHT || (alt < MIN_HEIGHT && MIN_HEIGHT > 0)) {
+                                return [2 /*return*/];
+                            }
+                            cells = this.cells.GetCellsForView(this.viewCenter, this.viewRect);
+                            (_a = this.onScanUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(cells);
+                            curCellIndex = cells.length > 0 ? 0 : null;
+                            postedScanning = false;
+                            postedLoading = false;
+                            total = 0;
+                            _j.label = 5;
+                        case 5:
+                            if (!(retryAttempts > 0 && curCellIndex != null)) return [3 /*break*/, 13];
+                            if (!(retryDelay > 0)) return [3 /*break*/, 7];
+                            return [4 /*yield*/, delay(retryDelay)];
+                        case 6:
+                            _j.sent();
+                            _j.label = 7;
+                        case 7:
+                            if (this.getterLoopId != loopId) {
+                                return [3 /*break*/, 13];
+                            }
+                            if (!postedScanning) {
+                                this.postStatus({ msg: EStatus.Scanning, revoking: false });
+                                postedScanning = true;
+                            }
+                            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);
+                                return [3 /*break*/, 5];
+                            }
+                            _j.label = 8;
+                        case 8:
+                            _j.trys.push([8, 10, , 11]);
+                            return [4 /*yield*/, Entity$1.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: Api.ESortOrder.Asc,
+                                        entityTypeConditions: this.attrFilter
+                                    },
+                                    viaCdn: this.viaCdn,
+                                    req: {
+                                        noCache: true
+                                    }
+                                })];
+                        case 9:
+                            entities = (_j.sent()).entities;
+                            integrity = this.getIntegrityId();
+                            if (loopIntegrity == integrity && entities) {
+                                (_c = this.onUpdate) === null || _c === void 0 ? void 0 : _c.Trigger(entities);
+                            }
+                            if (this.getterLoopId != loopId) {
+                                return [3 /*break*/, 13];
+                            }
+                            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);
+                                return [3 /*break*/, 5];
+                            }
+                            // Checking to make sure it's not just the same batch over and over again.
+                            if (entities.length > 0) {
+                                first = (_f = (_e = entities[0]) === null || _e === void 0 ? void 0 : _e.Bruce) === null || _f === void 0 ? void 0 : _f.ID;
+                                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) {
+                                        return [3 /*break*/, 13];
+                                    }
+                                }
+                                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;
+                            return [3 /*break*/, 11];
+                        case 10:
+                            e_1 = _j.sent();
+                            console.error(e_1);
+                            // Request failed so let's add a delay and try again soon.
+                            retryDelay += RETRY_DELAY_INCREMENT;
+                            retryAttempts -= 1;
+                            return [3 /*break*/, 11];
+                        case 11: return [4 /*yield*/, delay(REQUEST_PAGE_DELAY)];
+                        case 12:
+                            _j.sent();
+                            return [3 /*break*/, 5];
+                        case 13:
+                            if (postedLoading) {
+                                this.postStatus({ msg: EStatus.Loading, revoking: true });
+                            }
+                            if (postedScanning) {
+                                this.postStatus({ msg: EStatus.Scanning, revoking: true });
+                            }
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        };
+        return Getter;
+    }());
+    EntityFilterGetter.Getter = Getter;
+})(EntityFilterGetter || (EntityFilterGetter = {}));
+
 function createFilterGetterCacheKey(params) {
     var cacheKey = "";
     cacheKey += params.api.GetBaseUrl();
@@ -11729,7 +12336,7 @@ var MenuItemManager;
             }
             this.visualsRegister = visualsRegister;
             this.sharedGetters = new SharedGetters.Cache();
-            this.sharedMonitor = new CesiumViewMonitor(this.viewer);
+            this.sharedMonitor = new CesiumViewMonitor.Monitor(this.viewer);
         }
         Object.defineProperty(Manager.prototype, "Getters", {
             get: function () {
@@ -17568,7 +18175,7 @@ var ViewerUtils;
     ViewerUtils.CreateWidgets = CreateWidgets;
 })(ViewerUtils || (ViewerUtils = {}));
 
-var VERSION$1 = "2.9.8";
+var VERSION$1 = "2.9.9";
 
 export { VERSION$1 as VERSION, CesiumViewMonitor, ViewerUtils, MenuItemManager, EntityRenderEngine, MenuItemCreator, VisualsRegister, RenderManager, EntitiesIdsRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, TilesetCadRenderManager, TilesetArbRenderManager, TilesetEntitiesRenderManager, TilesetOsmRenderManager, TilesetPointcloudRenderManager, TilesetGooglePhotosRenderManager, DataSourceStaticKmlManager, RelationsRenderManager, SharedGetters, CesiumParabola, EntityLabel, ViewRenderEngine, TileRenderEngine, TilesetRenderEngine, CESIUM_INSPECTOR_KEY, ViewUtils, DrawingUtils, MeasureUtils, EntityUtils, Draw3dPolygon, Draw3dPolyline };
 //# sourceMappingURL=bruce-cesium.es5.js.map