bruce-cesium 6.5.9 → 6.6.1

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
-import { Cartes, Entity as Entity$1, Calculator, EntityRelationType, EntityType, Style, ENVIRONMENT, ProjectViewTile, DelayQueue, LRUCache, BruceEvent, ObjectUtils, Geometry, EntityHistoricData, EntityLod, ZoomControl, EntityTag, Tileset, Api, EntityCoords, DataLab, EntitySource, ClientFile, MenuItem, EntityRelation, ProgramKey, Carto, Bounds, ProjectView, ProjectViewBookmark, Camera, ProjectViewLegacyTile, AbstractApi, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, Session } from 'bruce-models';
+import { Cartes, Entity as Entity$1, Calculator, EntityRelationType, EntityType, Style, ENVIRONMENT, ProjectViewTile, DelayQueue, LRUCache, BruceEvent, ObjectUtils, Geometry, EntityHistoricData, EntityLod, ZoomControl, EntityTag, Tileset, Api, DataLab, EntityCoords, EntitySource, ClientFile, MenuItem, EntityRelation, ProgramKey, Bounds, Carto, ProjectView, ProjectViewBookmark, ProjectViewLegacyTile, Camera, AbstractApi, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, Session } from 'bruce-models';
 import * as Cesium from 'cesium';
-import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, DistanceDisplayCondition, HeightReference, ColorBlendMode, HeadingPitchRoll, Math as Math$1, Transforms, ShadowMode, Cartesian3, ClassificationType, Model, HorizontalOrigin, VerticalOrigin, ConstantPositionProperty, ArcType, CornerType, PolygonHierarchy, PolylineGraphics, Cartesian2, SceneTransforms, NearFarScalar, JulianDate, Quaternion, Matrix3, Rectangle, KmlDataSource, GeoJsonDataSource, SceneMode, Cesium3DTileStyle, HeadingPitchRange, Cesium3DTileColorBlendMode, Ion, Cesium3DTileset, Matrix4, IonResource, OrthographicFrustum, EasingFunction, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, PolygonPipeline, BoundingSphere, GeometryInstance, CesiumInspector, ClockRange, ScreenSpaceEventHandler, ScreenSpaceEventType, Intersect, CzmlDataSource, Fullscreen } from 'cesium';
+import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, Math as Math$1, Cartesian3, JulianDate, Quaternion, Transforms, HeadingPitchRoll, Matrix4, DistanceDisplayCondition, HeightReference, ColorBlendMode, ShadowMode, ClassificationType, Model, HorizontalOrigin, VerticalOrigin, ConstantPositionProperty, PolygonHierarchy, PolylineGraphics, ArcType, CornerType, Cartesian2, SceneTransforms, NearFarScalar, Matrix3, Rectangle, KmlDataSource, GeoJsonDataSource, SceneMode, Cesium3DTileStyle, HeadingPitchRange, Cesium3DTileColorBlendMode, Ion, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, IonResource, Cesium3DTileset, OrthographicFrustum, EasingFunction, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, BoundingSphere, GeometryInstance, PolygonPipeline, CesiumInspector, ClockRange, ScreenSpaceEventHandler, ScreenSpaceEventType, Intersect, CzmlDataSource, Fullscreen } from 'cesium';
 
 /**
  * Ensures a number is returned from a given value.
@@ -11926,6 +11926,66 @@ function isAlive$2(viewer, cTileset) {
 }
 const VIEWER_WATCH_KEY = "bruce-viewer-watch";
 const WATCH_KEY = "bruce-tileset-watch";
+const VIEWER_DATE_RANGE_WATCH_KEY = "bruce-viewer-date-range-watch";
+const DATE_RANGE_WATCH_KEY = "bruce-tileset-date-range-watch";
+function parseDate(value) {
+    if (!value) {
+        return null;
+    }
+    const date = value instanceof Date ? value : new Date(value);
+    if (isNaN(date.getTime())) {
+        return null;
+    }
+    return date;
+}
+function getTilesetDateRange(tileset) {
+    var _a, _b, _c;
+    const settings = (_a = tileset === null || tileset === void 0 ? void 0 : tileset.settings) !== null && _a !== void 0 ? _a : tileset === null || tileset === void 0 ? void 0 : tileset.Settings;
+    const visual = (settings === null || settings === void 0 ? void 0 : settings.visual) || (settings === null || settings === void 0 ? void 0 : settings.Visual);
+    const start = parseDate((_b = settings === null || settings === void 0 ? void 0 : settings.dateStart) !== null && _b !== void 0 ? _b : visual === null || visual === void 0 ? void 0 : visual.dateStart);
+    const end = parseDate((_c = settings === null || settings === void 0 ? void 0 : settings.dateEnd) !== null && _c !== void 0 ? _c : visual === null || visual === void 0 ? void 0 : visual.dateEnd);
+    if ((!start && !end) || (start && end && end < start)) {
+        return null;
+    }
+    return { start, end };
+}
+function isDateInRange(date, range) {
+    const time = date.getTime();
+    if (range.start && time < range.start.getTime()) {
+        return false;
+    }
+    if (range.end && time > range.end.getTime()) {
+        return false;
+    }
+    return true;
+}
+function watchTilesetDateRange(viewer, cTileset, tileset) {
+    TilesetRenderEngine.WatchDateRange(viewer, cTileset, tileset);
+}
+function isDateRangeWatchAlive(viewer, renderObject) {
+    if (!viewer || viewer.isDestroyed() || !renderObject) {
+        return false;
+    }
+    if (typeof renderObject.isDestroyed === "function" && renderObject.isDestroyed()) {
+        return false;
+    }
+    if (typeof renderObject.setVisible === "function") {
+        return true;
+    }
+    if (typeof renderObject.isDestroyed !== "function") {
+        return true;
+    }
+    return isAlive$2(viewer, renderObject);
+}
+function setDateRangeVisible(renderObject, visible) {
+    if (typeof renderObject.setVisible === "function") {
+        renderObject.setVisible(visible);
+    }
+    else {
+        renderObject.show = visible;
+    }
+    renderObject._bruceDateRangeVisible = visible;
+}
 /**
  * Creates and returns a tileset instance from a given url.
  * This is made to handle the difference between old and new cesium versions.
@@ -12197,6 +12257,7 @@ var TilesetRenderEngine;
             }
             const cTileset = await createTileset(loadUrl, null, params.noMemoryLimit);
             params.viewer.scene.primitives.add(cTileset);
+            watchTilesetDateRange(params.viewer, cTileset, params.tileset);
             OnTilesetReady(cTileset).then(() => {
                 var _a, _b, _c, _d;
                 try {
@@ -12243,6 +12304,7 @@ var TilesetRenderEngine;
             }
             const cTileset = await createTileset(loadUrl, null, params.noMemoryLimit);
             params.viewer.scene.primitives.add(cTileset);
+            watchTilesetDateRange(params.viewer, cTileset, params.tileset);
             return cTileset;
         }
         else if (params.tileset.type == Tileset.EType.PointCloud) {
@@ -12258,6 +12320,7 @@ var TilesetRenderEngine;
             }
             const cTileset = await createTileset(loadUrl, null, params.noMemoryLimit);
             params.viewer.scene.primitives.add(cTileset);
+            watchTilesetDateRange(params.viewer, cTileset, params.tileset);
             OnTilesetReady(cTileset).then(() => {
                 var _a;
                 try {
@@ -12346,6 +12409,7 @@ var TilesetRenderEngine;
             backFaceCulling: backFaceCulling === true
         }, noMemoryLimit);
         viewer.scene.primitives.add(cTileset);
+        watchTilesetDateRange(viewer, cTileset, tileset);
         OnTilesetReady(cTileset).then(() => {
             var _a;
             try {
@@ -12422,11 +12486,110 @@ var TilesetRenderEngine;
     class Styler extends TilesetStyler {
     }
     TilesetRenderEngine.Styler = Styler;
+    function GetTilesetDateRange(tileset) {
+        return getTilesetDateRange(tileset);
+    }
+    TilesetRenderEngine.GetTilesetDateRange = GetTilesetDateRange;
+    function WatchDateRange(viewer, renderObject, tileset) {
+        var _a;
+        const range = getTilesetDateRange(tileset);
+        if (!range) {
+            return;
+        }
+        (_a = GetDateRangeWatcher(viewer)) === null || _a === void 0 ? void 0 : _a.Watch(renderObject, range);
+    }
+    TilesetRenderEngine.WatchDateRange = WatchDateRange;
+    function UnwatchDateRange(viewer, renderObject) {
+        var _a;
+        (_a = viewer === null || viewer === void 0 ? void 0 : viewer[VIEWER_DATE_RANGE_WATCH_KEY]) === null || _a === void 0 ? void 0 : _a.Unwatch(renderObject);
+    }
+    TilesetRenderEngine.UnwatchDateRange = UnwatchDateRange;
     /**
      * The maximum memory in MB that can be used by all tilesets.
      * This is distributed evenly between all loaded tilesets.
      */
     TilesetRenderEngine.MAX_TILESET_MEMORY = 1024;
+    /**
+     * Watches tileset date cutoffs and toggles their primitive visibility based on the viewer clock.
+     */
+    class DateRangeWatcher {
+        constructor(viewer) {
+            this.watched = [];
+            this.clockRemoval = null;
+            this.viewer = viewer;
+            this.clockRemoval = viewer.clock.onTick.addEventListener(() => {
+                this.update();
+            });
+        }
+        clean() {
+            this.watched = this.watched.filter(x => isDateRangeWatchAlive(this.viewer, x));
+            if (!this.viewer || this.viewer.isDestroyed()) {
+                this.destroy();
+            }
+        }
+        updateTileset(tileset) {
+            if (!(tileset === null || tileset === void 0 ? void 0 : tileset._bruceDateRange) || !isDateRangeWatchAlive(this.viewer, tileset)) {
+                return false;
+            }
+            const currentDate = JulianDate.toDate(this.viewer.clock.currentTime);
+            const shouldShow = isDateInRange(currentDate, tileset._bruceDateRange);
+            if (tileset._bruceDateRangeVisible === shouldShow && (typeof tileset.setVisible === "function" || tileset.show === shouldShow)) {
+                return false;
+            }
+            setDateRangeVisible(tileset, shouldShow);
+            return true;
+        }
+        update() {
+            this.clean();
+            let changed = false;
+            this.watched.forEach(x => {
+                changed = this.updateTileset(x) || changed;
+            });
+            if (changed) {
+                this.viewer.scene.requestRender();
+            }
+        }
+        destroy() {
+            var _a;
+            (_a = this.clockRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.clockRemoval = null;
+            this.watched = [];
+        }
+        Watch(tileset, range) {
+            if (!tileset) {
+                return;
+            }
+            if (!(range === null || range === void 0 ? void 0 : range.start) && !(range === null || range === void 0 ? void 0 : range.end)) {
+                this.Unwatch(tileset);
+                return;
+            }
+            if (!tileset[DATE_RANGE_WATCH_KEY]) {
+                tileset[DATE_RANGE_WATCH_KEY] = ObjectUtils.UId();
+            }
+            tileset._bruceDateRange = range;
+            const index = this.watched.findIndex(x => x[DATE_RANGE_WATCH_KEY] === tileset[DATE_RANGE_WATCH_KEY]);
+            if (index < 0) {
+                this.watched.push(tileset);
+            }
+            if (this.updateTileset(tileset)) {
+                this.viewer.scene.requestRender();
+            }
+        }
+        Unwatch(tileset) {
+            if (!tileset) {
+                return;
+            }
+            if (!tileset[DATE_RANGE_WATCH_KEY]) {
+                tileset[DATE_RANGE_WATCH_KEY] = ObjectUtils.UId();
+            }
+            const index = this.watched.findIndex(x => (x === null || x === void 0 ? void 0 : x[DATE_RANGE_WATCH_KEY]) === tileset[DATE_RANGE_WATCH_KEY]);
+            if (index > -1) {
+                this.watched.splice(index, 1);
+            }
+            tileset._bruceDateRange = null;
+        }
+    }
+    TilesetRenderEngine.DateRangeWatcher = DateRangeWatcher;
     /**
      * Watches tilesets in the viewer.
      * This will regulate their max memory param.
@@ -12480,9 +12643,11 @@ var TilesetRenderEngine;
             this.distributeMemory();
         }
         Unwatch(tileset) {
+            var _a, _b;
             if (!tileset) {
                 return;
             }
+            (_b = (_a = this.viewer) === null || _a === void 0 ? void 0 : _a[VIEWER_DATE_RANGE_WATCH_KEY]) === null || _b === void 0 ? void 0 : _b.Unwatch(tileset);
             if (!tileset[WATCH_KEY]) {
                 tileset[WATCH_KEY] = ObjectUtils.UId();
             }
@@ -12505,6 +12670,17 @@ var TilesetRenderEngine;
         return viewer[VIEWER_WATCH_KEY];
     }
     TilesetRenderEngine.GetMemoryWatcher = GetMemoryWatcher;
+    function GetDateRangeWatcher(viewer) {
+        // If viewer is dead return nothing.
+        if (!viewer || viewer.isDestroyed()) {
+            return null;
+        }
+        if (!viewer[VIEWER_DATE_RANGE_WATCH_KEY]) {
+            viewer[VIEWER_DATE_RANGE_WATCH_KEY] = new DateRangeWatcher(viewer);
+        }
+        return viewer[VIEWER_DATE_RANGE_WATCH_KEY];
+    }
+    TilesetRenderEngine.GetDateRangeWatcher = GetDateRangeWatcher;
 })(TilesetRenderEngine || (TilesetRenderEngine = {}));
 
 /**
@@ -12676,6 +12852,236 @@ function getOrCreateCell(cells, cellSize, lon, maxLon, lat, maxLat) {
     return [id, cell];
 }
 
+const DEFAULT_GROUNDED_HEIGHT = 300;
+const MINIMUM_VIEW_AREA_SIZE_DEGREES = 0.01;
+const NET_STEP_PERCENT = 5;
+const BORDER_STEPS = 3;
+function isDefined(value) {
+    return value !== null && value !== undefined;
+}
+function netScanViewForBoundaries(viewer, center) {
+    let maxLong = -2 * Math.PI;
+    let minLong = 2 * Math.PI;
+    let maxLat = -2 * Math.PI;
+    let minLat = 2 * Math.PI;
+    let found = 0;
+    const updateMinMax = (lon, lat) => {
+        if (lon < -Math.PI || lon > Math.PI || lat < -Math.PI / 2 || lat > Math.PI / 2) {
+            return;
+        }
+        maxLong = Math.max(maxLong, lon);
+        maxLat = Math.max(maxLat, lat);
+        minLong = Math.min(minLong, lon);
+        minLat = Math.min(minLat, lat);
+    };
+    const updateMinMaxForPoint = (stepX, stepY) => {
+        const x = Math.round((viewer.container.clientWidth / 100) * (stepX * NET_STEP_PERCENT));
+        const y = Math.round((viewer.container.clientHeight / 100) * (stepY * NET_STEP_PERCENT));
+        const winPos = new Cartesian2(x, y);
+        try {
+            const intersection = getAdjustedGroundIntersectionOfCameraRay(viewer, winPos);
+            if (intersection) {
+                const point = Cartographic.fromCartesian(intersection, viewer.scene.globe.ellipsoid);
+                updateMinMax(point.longitude, point.latitude);
+                found++;
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+    };
+    updateMinMaxForPoint(BORDER_STEPS, BORDER_STEPS);
+    updateMinMaxForPoint((100 / NET_STEP_PERCENT) - BORDER_STEPS, BORDER_STEPS);
+    updateMinMaxForPoint(BORDER_STEPS, (100 / NET_STEP_PERCENT) - BORDER_STEPS);
+    updateMinMaxForPoint((100 / NET_STEP_PERCENT) - BORDER_STEPS, (100 / NET_STEP_PERCENT) - BORDER_STEPS);
+    updateMinMaxForPoint(BORDER_STEPS * 2, BORDER_STEPS * 2);
+    updateMinMaxForPoint((100 / NET_STEP_PERCENT) - BORDER_STEPS * 2, BORDER_STEPS * 2);
+    updateMinMaxForPoint(BORDER_STEPS * 2, (100 / NET_STEP_PERCENT) - BORDER_STEPS * 2);
+    updateMinMaxForPoint((100 / NET_STEP_PERCENT) - BORDER_STEPS * 2, (100 / NET_STEP_PERCENT) - BORDER_STEPS * 2);
+    if (center && found <= 0) {
+        updateMinMax(Math$1.toRadians(center.longitude), Math$1.toRadians(center.latitude));
+        found += 1;
+        const size = viewer.camera.positionCartographic.height;
+        const pitch = viewer.camera.pitch;
+        const distance = size / Math.tan(pitch);
+        const p1 = offsetPoint({
+            altitude: center.altitude,
+            latitude: center.latitude,
+            longitude: center.longitude
+        }, distance, 45);
+        const p2 = offsetPoint({
+            altitude: center.altitude,
+            latitude: center.latitude,
+            longitude: center.longitude
+        }, -distance, 45);
+        if (isDefined(p1 === null || p1 === void 0 ? void 0 : p1.latitude) && isDefined(p1 === null || p1 === void 0 ? void 0 : p1.longitude)) {
+            updateMinMax(Math$1.toRadians(p1.longitude), Math$1.toRadians(p1.latitude));
+        }
+        if (isDefined(p2 === null || p2 === void 0 ? void 0 : p2.latitude) && isDefined(p2 === null || p2 === void 0 ? void 0 : p2.longitude)) {
+            updateMinMax(Math$1.toRadians(p2.longitude), Math$1.toRadians(p2.latitude));
+        }
+    }
+    if (found > 0) {
+        return {
+            east: maxLong,
+            west: minLong,
+            north: maxLat,
+            south: minLat
+        };
+    }
+    return null;
+}
+function offsetPoint(point, distance, heading) {
+    const radius = 6371e3;
+    const delta = distance / radius;
+    const theta = Math$1.toRadians(heading);
+    const phi1 = Math$1.toRadians(point.latitude);
+    const lambda1 = Math$1.toRadians(point.longitude);
+    const sinPhi2 = Math.sin(phi1) * Math.cos(delta) + Math.cos(phi1) * Math.sin(delta) * Math.cos(theta);
+    const phi2 = Math.asin(sinPhi2);
+    const y = Math.sin(theta) * Math.sin(delta) * Math.cos(phi1);
+    const x = Math.cos(delta) - Math.sin(phi1) * sinPhi2;
+    const lambda2 = lambda1 + Math.atan2(y, x);
+    return {
+        altitude: point.altitude,
+        latitude: Math$1.toDegrees(phi2),
+        longitude: Math$1.toDegrees(lambda2)
+    };
+}
+function offsetPos3d(pos3d, distance, heading) {
+    const carto = Cartographic.fromCartesian(pos3d);
+    const newCarto = offsetPoint({
+        altitude: carto.height,
+        latitude: Math$1.toDegrees(carto.latitude),
+        longitude: Math$1.toDegrees(carto.longitude)
+    }, distance, heading);
+    return Cartesian3.fromDegrees(newCarto.longitude, newCarto.latitude, newCarto.altitude);
+}
+function getAdjustedGroundIntersectionOfCameraRay(viewer, screenPos) {
+    const ray = viewer.camera.getPickRay(screenPos);
+    const intersection = ray ? viewer.scene.globe.pick(ray, viewer.scene) : null;
+    return intersection || null;
+}
+function getGroundCenterOfCameraRay(viewer, screenPos) {
+    var _a, _b;
+    const ray = viewer.camera.getPickRay(screenPos);
+    const intersection = ray ? viewer.scene.globe.pick(ray, viewer.scene) : null;
+    if (intersection) {
+        return intersection;
+    }
+    const cameraHeight = viewer.camera.positionCartographic.height;
+    if (!isNaN(cameraHeight) && isDefined(cameraHeight) && ((_b = (_a = viewer.camera) === null || _a === void 0 ? void 0 : _a.position) === null || _b === void 0 ? void 0 : _b.clone)) {
+        const cameraPos3d = viewer.camera.position.clone();
+        const pitch = viewer.camera.pitch;
+        const distance = cameraHeight / Math.tan(pitch);
+        return offsetPos3d(cameraPos3d, -distance, Math$1.toDegrees(viewer.camera.heading));
+    }
+    return null;
+}
+var ViewGroundArea;
+(function (ViewGroundArea) {
+    function ToBboxPolygon(bounds) {
+        return `${bounds.west},${bounds.south} ${bounds.west},${bounds.north} ${bounds.east},${bounds.north} ${bounds.east},${bounds.south}`;
+    }
+    ViewGroundArea.ToBboxPolygon = ToBboxPolygon;
+    function NormalizeBounds(bounds, altitude) {
+        if (!bounds ||
+            !isDefined(bounds.east) ||
+            !isDefined(bounds.west) ||
+            !isDefined(bounds.north) ||
+            !isDefined(bounds.south)) {
+            return null;
+        }
+        const viewRect = { ...bounds };
+        const centerLong = (viewRect.east + viewRect.west) / 2;
+        const 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));
+        if (isDefined(altitude)) {
+            viewRect.alt = altitude;
+        }
+        return viewRect;
+    }
+    ViewGroundArea.NormalizeBounds = NormalizeBounds;
+    async function GetViewArea(viewer) {
+        var _a, _b;
+        if (!viewer || viewer.isDestroyed()) {
+            return null;
+        }
+        if (!viewer.container || ((_a = viewer.container.style) === null || _a === void 0 ? void 0 : _a.display) == "none") {
+            return null;
+        }
+        let viewRect = null;
+        let center = null;
+        const camera = viewer.camera;
+        const terrData = await DrawingUtils.GetTerrainHeight({
+            pos3d: camera.position,
+            viewer
+        });
+        const cameraPosition = viewer.camera.positionCartographic;
+        const terrHeight = terrData.error ? cameraPosition.height + DEFAULT_GROUNDED_HEIGHT : terrData.height;
+        if (terrHeight && ((cameraPosition.height - terrHeight) < DEFAULT_GROUNDED_HEIGHT)) {
+            viewRect = {};
+            const viewRectRad = netScanViewForBoundaries(viewer);
+            if (viewRectRad &&
+                isDefined(viewRectRad.east) &&
+                isDefined(viewRectRad.west) &&
+                isDefined(viewRectRad.north) &&
+                isDefined(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 = Math$1.toDegrees(cameraPosition.longitude);
+                viewRect.west = Math$1.toDegrees(cameraPosition.longitude);
+                viewRect.south = Math$1.toDegrees(cameraPosition.latitude);
+                viewRect.north = Math$1.toDegrees(cameraPosition.latitude);
+            }
+            center = {
+                altitude: camera.positionCartographic.height,
+                latitude: Math$1.toDegrees(camera.positionCartographic.latitude),
+                longitude: Math$1.toDegrees(camera.positionCartographic.longitude)
+            };
+        }
+        else {
+            const windowPosition = new Cartesian2(viewer.container.clientWidth / 2, viewer.container.clientHeight / 2);
+            const intersection = getGroundCenterOfCameraRay(viewer, windowPosition);
+            let point = null;
+            if (intersection) {
+                point = Cartographic.fromCartesian(intersection, viewer.scene.globe.ellipsoid);
+            }
+            if (point) {
+                center = {
+                    altitude: point.height,
+                    latitude: Math$1.toDegrees(point.latitude),
+                    longitude: Math$1.toDegrees(point.longitude)
+                };
+                const viewRectRad = netScanViewForBoundaries(viewer, center);
+                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);
+                }
+            }
+        }
+        viewRect = NormalizeBounds(viewRect, (_b = viewer.scene.camera.positionCartographic) === null || _b === void 0 ? void 0 : _b.height);
+        if (center && viewRect) {
+            return {
+                bounds: viewRect,
+                target: center
+            };
+        }
+        return null;
+    }
+    ViewGroundArea.GetViewArea = GetViewArea;
+})(ViewGroundArea || (ViewGroundArea = {}));
+
 const MAX_AREA_IN_DEGREES$1 = 90;
 const MAX_RETRY_ATTEMPTS = 1;
 const RETRY_DELAY_INCREMENT = 500;
@@ -12753,7 +13159,7 @@ var EntityFilterGetter;
             // We use this for refreshing historic data without having to repeat geographic queries.
             this.gatheredIntegrity = null;
             this.gatheredEntityIds = [];
-            const { api, viewer, viewPort, typeIds, schemaId, batchSize, attrFilter, historicAttrKey, historicInterpolation, historic, viaCdn, scenario } = params;
+            const { api, viewer, viewPort, typeIds, schemaId, batchSize, attrFilter, historicAttrKey, historicInterpolation, historic, viaCdn, scenario, dataLab } = params;
             this.api = api;
             this.typeIds = typeIds;
             this.schemaId = schemaId;
@@ -12764,6 +13170,7 @@ var EntityFilterGetter;
             this.batchSize = isNaN(batchSize) ? 300 : batchSize;
             this.viewPort = viewPort;
             this.attrFilter = attrFilter;
+            this.dataLab = dataLab;
             this.viewer = viewer;
             this.scenario = scenario ? scenario : 0;
             this.updateBounds();
@@ -12788,6 +13195,9 @@ var EntityFilterGetter;
             if (this.typeIds) {
                 integrity += this.typeIds.join();
             }
+            if (this.dataLab) {
+                integrity += JSON.stringify(this.dataLab);
+            }
             return integrity;
         }
         viewAreaSub() {
@@ -12894,6 +13304,22 @@ var EntityFilterGetter;
             delete this.registeredItems[menuItemId];
             this.updateState(true);
         }
+        Dispose() {
+            var _a, _b, _c, _d;
+            this.registeredItems = {};
+            this.getterLoopId += 1;
+            for (const key in this.getterLoopAbortControllers) {
+                this.getterLoopAbortControllers[key].abort();
+            }
+            this.getterLoopAbortControllers = {};
+            (_a = this.historicRefreshAbortController) === null || _a === void 0 ? void 0 : _a.abort();
+            this.historicRefreshAbortController = null;
+            this.viewAreaDispose();
+            this.viewerDateTimeDispose();
+            (_b = this.onUpdate) === null || _b === void 0 ? void 0 : _b.Clear();
+            (_c = this.onStateUpdate) === null || _c === void 0 ? void 0 : _c.Clear();
+            (_d = this.onScanUpdate) === null || _d === void 0 ? void 0 : _d.Clear();
+        }
         updateBounds() {
             const viewRect = this.viewPort.GetBounds();
             const poi = this.viewPort.GetTarget();
@@ -12964,6 +13390,67 @@ var EntityFilterGetter;
             this.LastStateUpdates[status.msg] = status;
             (_a = this.onStateUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(status);
         }
+        createDataLabQuery(bounds) {
+            var _a;
+            const dataLab = this.dataLab;
+            const userItems = (dataLab === null || dataLab === void 0 ? void 0 : dataLab.queryItems) ? JSON.parse(JSON.stringify(dataLab.queryItems)) : [];
+            const primaryKey = DataLab.EReqKey.Primary;
+            const baseQuery = (dataLab === null || dataLab === void 0 ? void 0 : dataLab.query) ? JSON.parse(JSON.stringify(dataLab.query)) : {};
+            const basePrimary = (_a = baseQuery === null || baseQuery === void 0 ? void 0 : baseQuery[primaryKey]) !== null && _a !== void 0 ? _a : {};
+            const items = [
+                {
+                    LogicOperator: "AND",
+                    AttributeValue: {
+                        AttributePath: "Bruce/Boundaries",
+                        OperandA: ViewGroundArea.ToBboxPolygon(bounds),
+                        Operator: "intersects"
+                    },
+                    key: "attribute"
+                }
+            ];
+            if (userItems.length) {
+                items.push({
+                    LogicOperator: "AND",
+                    Items: [],
+                    key: "subquery",
+                    Subquery: {
+                        Items: userItems
+                    }
+                });
+            }
+            baseQuery[primaryKey] = {
+                ...basePrimary,
+                Items: items
+            };
+            baseQuery.Expand = "location,source";
+            return baseQuery;
+        }
+        async getDataLabResponse(params) {
+            var _a;
+            const { bounds, pageIndex, pageSize, abortSignal } = params;
+            const skip = pageIndex * pageSize;
+            const data = await DataLab.Run({
+                api: this.api,
+                query: this.createDataLabQuery(bounds),
+                skip,
+                load: pageSize,
+                migrated: true,
+                req: {
+                    noCache: true,
+                    abortSignal
+                }
+            });
+            const entities = (_a = data.entities) !== null && _a !== void 0 ? _a : [];
+            const totalCount = data.totalCount;
+            const nextPage = totalCount != null
+                ? skip + entities.length < totalCount
+                : entities.length >= pageSize;
+            return {
+                entities,
+                nextPage,
+                nextPageUrl: null
+            };
+        }
         startGetterLoop() {
             // Increase id so that existing loops stop.
             this.getterLoopId += 1;
@@ -13042,13 +13529,24 @@ var EntityFilterGetter;
                             nextPage: false,
                             nextPageUrl: null
                         };
-                        await SharedGetters.Queue.Run("Loading Entities from Menu Item that loads Entity Type: " + this.typeIds, async () => {
+                        const queueName = this.dataLab
+                            ? "Loading DataLab Entities from Menu Item"
+                            : "Loading Entities from Menu Item that loads Entity Type: " + this.typeIds;
+                        await SharedGetters.Queue.Run(queueName, async () => {
                             var _a;
                             if (abortController.signal.aborted || !((_a = this.GetMenuItems()) === null || _a === void 0 ? void 0 : _a.length)) {
                                 return;
                             }
+                            if (this.dataLab) {
+                                response = await this.getDataLabResponse({
+                                    bounds: curCell.GetBounds(),
+                                    pageIndex: curCell.FetchPageIndex,
+                                    pageSize: PAGE_SIZE,
+                                    abortSignal: abortController.signal
+                                });
+                            }
                             // API gave us a URL to use.
-                            if (curCell.FetchURL) {
+                            else if (curCell.FetchURL) {
                                 const tmpResponse = await this.api.get(curCell.FetchURL, {
                                     abortSignal: abortController.signal,
                                     noCache: true
@@ -13318,6 +13816,9 @@ function createFilterGetterCacheKey(params) {
     cacheKey += params.historicAttrKey ? params.historicAttrKey : "";
     cacheKey += params.historic ? "true" : "false";
     cacheKey += params.scenario ? params.scenario : 0;
+    if (params.dataLab) {
+        cacheKey += JSON.stringify(params.dataLab);
+    }
     if (params.historicAttrKey) {
         cacheKey += params.historicInterpolation ? "true" : "false";
     }
@@ -13349,6 +13850,7 @@ var SharedGetters;
                     historicInterpolation: params.historicInterpolation,
                     viaCdn: params.cdn,
                     scenario: params.scenario,
+                    dataLab: params.dataLab,
                 });
                 this.data[cacheKey] = getter;
                 /**
@@ -14691,6 +15193,8 @@ var TilesetCadRenderManager;
     TilesetCadRenderManager.Manager = Manager;
 })(TilesetCadRenderManager || (TilesetCadRenderManager = {}));
 
+const BATCH_SIZE$3 = 500;
+const CHECK_BATCH_SIZE$2 = 250;
 var DataLabRenderManager;
 (function (DataLabRenderManager) {
     class Manager {
@@ -14699,7 +15203,18 @@ var DataLabRenderManager;
         }
         constructor(params) {
             this.getter = null;
+            this.getterSub = null;
             this.disposed = false;
+            this.renderedEntities = {};
+            this.entityCheckQueue = null;
+            this.entityCheckQueueIds = [];
+            this.isRunningCheck = false;
+            this.viewMonitorRemoval = null;
+            this.renderQueue = [];
+            this.renderQueueInterval = null;
+            this.reRenderState = new EntityReRenderMaintainState();
+            this.zoomControl = [];
+            this.queryLoadId = 0;
             const { viewer, item, apiGetter, monitor, visualsRegister } = params;
             this.viewer = viewer;
             this.item = item;
@@ -14707,13 +15222,54 @@ var DataLabRenderManager;
             this.monitor = monitor;
             this.visualsManager = visualsRegister;
         }
-        Init() {
+        Init(params) {
             var _a;
             if (this.disposed) {
                 throw new Error("This manager has already been disposed.");
             }
-            if (!((_a = this.item.CameraZoomSettings) === null || _a === void 0 ? void 0 : _a.length)) {
-                this.item.CameraZoomSettings = [
+            if (params === null || params === void 0 ? void 0 : params.item) {
+                this.item = params.item;
+            }
+            this.queryLoadId += 1;
+            const loadId = this.queryLoadId;
+            this.unsetGetter();
+            (_a = this.viewMonitorRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.viewMonitorRemoval = null;
+            clearInterval(this.renderQueueInterval);
+            this.renderQueueInterval = null;
+            this.renderQueue = [];
+            this.renderedEntities = {};
+            this.ensureSettings();
+            this.visualsManager.RemoveRegos({
+                menuItemId: this.item.id
+            });
+            this.setEntityCheckQueue();
+            (async () => {
+                var _a, _b, _c, _d;
+                try {
+                    const { query } = await DataLab.Get({
+                        api: this.apiGetter.getApi(),
+                        queryId: this.item.DataLabQueryID,
+                        req: {
+                            noCache: true
+                        }
+                    });
+                    if (this.disposed || loadId != this.queryLoadId) {
+                        return;
+                    }
+                    const queryItems = (_d = (_b = (_a = query === null || query === void 0 ? void 0 : query.PrimarySelectionCriteria) === null || _a === void 0 ? void 0 : _a.Items) !== null && _b !== void 0 ? _b : (_c = query === null || query === void 0 ? void 0 : query[DataLab.EReqKey.Primary]) === null || _c === void 0 ? void 0 : _c.Items) !== null && _d !== void 0 ? _d : [];
+                    this.setGetter(queryItems);
+                }
+                catch (e) {
+                    console.error("Failed to initialise DataLab render manager:", e);
+                }
+            })();
+        }
+        ensureSettings() {
+            var _a;
+            this.zoomControl = this.item.CameraZoomSettings;
+            if (!((_a = this.zoomControl) === null || _a === void 0 ? void 0 : _a.length)) {
+                this.zoomControl = [
                     {
                         MinZoom: 0,
                         MaxZoom: 200000,
@@ -14723,17 +15279,74 @@ var DataLabRenderManager;
                         StyleID: 0
                     }
                 ];
+                this.item.CameraZoomSettings = this.zoomControl;
             }
             this.renderPriority = this.item.renderPriority;
             if (this.renderPriority == null) {
                 this.renderPriority = 3;
             }
-            // Perform the initial query and subscribe to updates
-            this.getter = new BatchedDataGetter.Getter([this.item.DataLabQueryID], this.monitor, 1);
-            this.getter.OnUpdate.Subscribe((queryIds) => {
-                this.onGetterUpdate(queryIds[0]);
+        }
+        setGetter(queryItems) {
+            this.unsetGetter();
+            this.getter = new EntityFilterGetter.Getter({
+                api: this.apiGetter.getApi(),
+                attrFilter: {},
+                batchSize: BATCH_SIZE$3,
+                typeIds: null,
+                viewPort: this.monitor,
+                viewer: this.viewer,
+                dataLab: {
+                    queryItems: queryItems !== null && queryItems !== void 0 ? queryItems : []
+                }
             });
-            this.getter.Start();
+            const minMax = RenderManager.GetZoomMinMax({
+                zoomControl: this.zoomControl
+            });
+            this.getter.IncludeMenuItem(this.item.id, null, [], minMax[0], minMax[1]);
+            this.getterSub = this.getter.OnUpdate.Subscribe((data) => {
+                var _a;
+                if (!((_a = data === null || data === void 0 ? void 0 : data.entities) === null || _a === void 0 ? void 0 : _a.length)) {
+                    return;
+                }
+                this.distributeForRender(data.entities);
+            });
+        }
+        unsetGetter() {
+            var _a, _b, _c;
+            (_a = this.getter) === null || _a === void 0 ? void 0 : _a.ExcludeMenuItem(this.item.id);
+            (_b = this.getterSub) === null || _b === void 0 ? void 0 : _b.call(this);
+            this.getterSub = null;
+            (_c = this.getter) === null || _c === void 0 ? void 0 : _c.Dispose();
+            this.getter = null;
+        }
+        setEntityCheckQueue() {
+            var _a, _b;
+            (_a = this.entityCheckQueue) === null || _a === void 0 ? void 0 : _a.Dispose();
+            this.entityCheckQueue = null;
+            const displayItems = this.zoomControl ? this.zoomControl.filter(x => x.DisplayType != ZoomControl.EDisplayType.Hidden) : [];
+            const shouldCheck = displayItems.length > 1;
+            this.entityCheckQueue = new DelayQueue(() => {
+                this.doEntityCheck(Object.keys(this.renderedEntities));
+            }, shouldCheck ? 3000 : 30000);
+            (_b = this.viewMonitorRemoval) === null || _b === void 0 ? void 0 : _b.call(this);
+            this.viewMonitorRemoval = this.monitor.Updated().Subscribe(() => {
+                var _a;
+                (_a = this.entityCheckQueue) === null || _a === void 0 ? void 0 : _a.Call();
+            });
+        }
+        preventCurrentCheckApiRefresh(entityIds) {
+            var _a;
+            this.reRenderState.markSkipForCurrentRun(entityIds, this.isRunningCheck);
+            if ((_a = this.entityCheckQueueIds) === null || _a === void 0 ? void 0 : _a.length) {
+                const lookup = {};
+                for (let i = 0; i < entityIds.length; i++) {
+                    const id = entityIds[i];
+                    if (id) {
+                        lookup[id] = true;
+                    }
+                }
+                this.entityCheckQueueIds = this.entityCheckQueueIds.filter(id => !lookup[id]);
+            }
         }
         Dispose() {
             if (this.disposed) {
@@ -14742,321 +15355,293 @@ var DataLabRenderManager;
             this.doDispose();
         }
         doDispose() {
-            var _a;
+            var _a, _b;
             this.disposed = true;
-            (_a = this.getter) === null || _a === void 0 ? void 0 : _a.Dispose();
+            this.queryLoadId += 1;
+            this.unsetGetter();
+            (_a = this.entityCheckQueue) === null || _a === void 0 ? void 0 : _a.Dispose();
+            this.entityCheckQueue = null;
+            (_b = this.viewMonitorRemoval) === null || _b === void 0 ? void 0 : _b.call(this);
+            this.viewMonitorRemoval = null;
+            clearInterval(this.renderQueueInterval);
+            this.renderQueueInterval = null;
+            this.renderQueue = [];
+            this.entityCheckQueueIds = [];
             this.visualsManager.RemoveRegos({
                 menuItemId: this.item.id
             });
         }
-        async onGetterUpdate(queryId) {
-            var _a;
-            if (this.disposed || this.viewer.isDestroyed()) {
+        async ReRender(params) {
+            let { entityIds, force, entities, maintain } = params;
+            if (this.disposed) {
                 return;
             }
-            try {
-                const api = this.apiGetter.getApi();
-                const result = await DataLab.Get({ api, queryId });
-                const query = result.query;
-                const queryResult = await DataLab.Run({ api, query: {
-                        [DataLab.EReqKey.Primary]: {
-                            Items: ((_a = query === null || query === void 0 ? void 0 : query.PrimarySelectionCriteria) === null || _a === void 0 ? void 0 : _a.Items) || [],
-                        }
-                    } });
-                this.renderDataLabEntities(queryResult.entities || []);
+            if (entities && !entityIds) {
+                entityIds = entities.map(x => { var _a; return (_a = x.Bruce) === null || _a === void 0 ? void 0 : _a.ID; });
             }
-            catch (error) {
-                console.error("Failed to perform query or render DataLab entities:", error);
+            if (entityIds == null) {
+                entityIds = Object.keys(this.renderedEntities);
             }
-        }
-        async renderDataLabEntities(entities) {
-            if (this.disposed || this.viewer.isDestroyed()) {
+            entityIds = entityIds.filter((x, index) => !!x && entityIds.indexOf(x) === index);
+            if (!entityIds.length) {
                 return;
             }
-            const { updated, entities: cEntities } = await EntityRenderEngine.Render({
-                viewer: this.viewer,
-                apiGetter: this.apiGetter,
-                entities,
-                menuItemId: this.item.id,
-                visualRegister: this.visualsManager,
-                zoomControl: this.item.CameraZoomSettings
+            if (entities === null || entities === void 0 ? void 0 : entities.length) {
+                entities = [].concat(entities).filter(x => { var _a; return entityIds.includes((_a = x.Bruce) === null || _a === void 0 ? void 0 : _a.ID); });
+                if (force) {
+                    this.reRenderState.bumpApiRevisions(entityIds);
+                    this.preventCurrentCheckApiRefresh(entityIds);
+                }
+            }
+            if (maintain === true && (entities === null || entities === void 0 ? void 0 : entities.length)) {
+                this.reRenderState.setMaintainedEntities(entities);
+            }
+            else if (maintain !== true) {
+                this.reRenderState.clearMaintainedEntities(entityIds);
+            }
+            this.visualsManager.MarkStale({
+                entityIds: entityIds,
+                menuItemIds: [this.item.id]
             });
-            for (let i = 0; i < entities.length; i++) {
-                const entity = entities[i];
-                const id = entity.Bruce.ID;
-                const cEntity = cEntities.get(id);
-                if (cEntity) {
-                    const rego = this.visualsManager.GetRego({
-                        entityId: id,
-                        menuItemId: this.item.id
-                    });
-                    if (!rego) {
-                        this.visualsManager.AddRego({
-                            rego: {
-                                canEdit: true,
-                                entityId: id,
-                                menuItemId: this.item.id,
-                                menuItemType: this.item.Type,
-                                visual: cEntity,
-                                priority: this.renderPriority,
-                                entityTypeId: entity.Bruce["EntityType.ID"],
-                                accountId: this.apiGetter.accountId,
-                                name: cEntity.name
-                            },
-                            requestRender: false
-                        });
-                    }
+            if (entities === null || entities === void 0 ? void 0 : entities.length) {
+                if (force) {
+                    await this.renderDataLabEntities(entities, true);
                 }
                 else {
-                    this.visualsManager.RemoveRegos({
-                        entityId: id,
-                        menuItemId: this.item.id,
-                        requestRender: false
-                    });
+                    this.distributeForRender(entities);
                 }
             }
-            this.viewer.scene.requestRender();
+            else {
+                await this.doEntityCheck(entityIds, force);
+            }
         }
-        async ReRender() {
+        UpdateSettings(params) {
+            const { zoomControl, queueRerender } = params;
             if (this.disposed) {
                 return;
             }
-            // Re-perform the query and render again
-            await this.onGetterUpdate(this.item.DataLabQueryID);
-        }
-    }
-    DataLabRenderManager.Manager = Manager;
-})(DataLabRenderManager || (DataLabRenderManager = {}));
-
-const DEFAULT_GROUNDED_HEIGHT = 300;
-const MINIMUM_VIEW_AREA_SIZE_DEGREES = 0.01;
-const NET_STEP_PERCENT = 5;
-const BORDER_STEPS = 3;
-function isDefined(value) {
-    return value !== null && value !== undefined;
-}
-function netScanViewForBoundaries(viewer, center) {
-    let maxLong = -2 * Math.PI;
-    let minLong = 2 * Math.PI;
-    let maxLat = -2 * Math.PI;
-    let minLat = 2 * Math.PI;
-    let found = 0;
-    const updateMinMax = (lon, lat) => {
-        if (lon < -Math.PI || lon > Math.PI || lat < -Math.PI / 2 || lat > Math.PI / 2) {
-            return;
-        }
-        maxLong = Math.max(maxLong, lon);
-        maxLat = Math.max(maxLat, lat);
-        minLong = Math.min(minLong, lon);
-        minLat = Math.min(minLat, lat);
-    };
-    const updateMinMaxForPoint = (stepX, stepY) => {
-        const x = Math.round((viewer.container.clientWidth / 100) * (stepX * NET_STEP_PERCENT));
-        const y = Math.round((viewer.container.clientHeight / 100) * (stepY * NET_STEP_PERCENT));
-        const winPos = new Cartesian2(x, y);
-        try {
-            const intersection = getAdjustedGroundIntersectionOfCameraRay(viewer, winPos);
-            if (intersection) {
-                const point = Cartographic.fromCartesian(intersection, viewer.scene.globe.ellipsoid);
-                updateMinMax(point.longitude, point.latitude);
-                found++;
+            if (zoomControl === null || zoomControl === void 0 ? void 0 : zoomControl.length) {
+                this.zoomControl = zoomControl;
+                this.item.CameraZoomSettings = zoomControl;
+                this.setEntityCheckQueue();
+            }
+            if (queueRerender != false) {
+                const entityIds = Object.keys(this.renderedEntities);
+                this.visualsManager.MarkStale({
+                    entityIds,
+                    menuItemIds: [this.item.id]
+                });
+                this.doEntityCheck(entityIds);
             }
         }
-        catch (e) {
-            console.error(e);
-        }
-    };
-    updateMinMaxForPoint(BORDER_STEPS, BORDER_STEPS);
-    updateMinMaxForPoint((100 / NET_STEP_PERCENT) - BORDER_STEPS, BORDER_STEPS);
-    updateMinMaxForPoint(BORDER_STEPS, (100 / NET_STEP_PERCENT) - BORDER_STEPS);
-    updateMinMaxForPoint((100 / NET_STEP_PERCENT) - BORDER_STEPS, (100 / NET_STEP_PERCENT) - BORDER_STEPS);
-    updateMinMaxForPoint(BORDER_STEPS * 2, BORDER_STEPS * 2);
-    updateMinMaxForPoint((100 / NET_STEP_PERCENT) - BORDER_STEPS * 2, BORDER_STEPS * 2);
-    updateMinMaxForPoint(BORDER_STEPS * 2, (100 / NET_STEP_PERCENT) - BORDER_STEPS * 2);
-    updateMinMaxForPoint((100 / NET_STEP_PERCENT) - BORDER_STEPS * 2, (100 / NET_STEP_PERCENT) - BORDER_STEPS * 2);
-    if (center && found <= 0) {
-        updateMinMax(Math$1.toRadians(center.longitude), Math$1.toRadians(center.latitude));
-        found += 1;
-        const size = viewer.camera.positionCartographic.height;
-        const pitch = viewer.camera.pitch;
-        const distance = size / Math.tan(pitch);
-        const p1 = offsetPoint({
-            altitude: center.altitude,
-            latitude: center.latitude,
-            longitude: center.longitude
-        }, distance, 45);
-        const p2 = offsetPoint({
-            altitude: center.altitude,
-            latitude: center.latitude,
-            longitude: center.longitude
-        }, -distance, 45);
-        if (isDefined(p1 === null || p1 === void 0 ? void 0 : p1.latitude) && isDefined(p1 === null || p1 === void 0 ? void 0 : p1.longitude)) {
-            updateMinMax(Math$1.toRadians(p1.longitude), Math$1.toRadians(p1.latitude));
-        }
-        if (isDefined(p2 === null || p2 === void 0 ? void 0 : p2.latitude) && isDefined(p2 === null || p2 === void 0 ? void 0 : p2.longitude)) {
-            updateMinMax(Math$1.toRadians(p2.longitude), Math$1.toRadians(p2.latitude));
-        }
-    }
-    if (found > 0) {
-        return {
-            east: maxLong,
-            west: minLong,
-            north: maxLat,
-            south: minLat
-        };
-    }
-    return null;
-}
-function offsetPoint(point, distance, heading) {
-    const radius = 6371e3;
-    const delta = distance / radius;
-    const theta = Math$1.toRadians(heading);
-    const phi1 = Math$1.toRadians(point.latitude);
-    const lambda1 = Math$1.toRadians(point.longitude);
-    const sinPhi2 = Math.sin(phi1) * Math.cos(delta) + Math.cos(phi1) * Math.sin(delta) * Math.cos(theta);
-    const phi2 = Math.asin(sinPhi2);
-    const y = Math.sin(theta) * Math.sin(delta) * Math.cos(phi1);
-    const x = Math.cos(delta) - Math.sin(phi1) * sinPhi2;
-    const lambda2 = lambda1 + Math.atan2(y, x);
-    return {
-        altitude: point.altitude,
-        latitude: Math$1.toDegrees(phi2),
-        longitude: Math$1.toDegrees(lambda2)
-    };
-}
-function offsetPos3d(pos3d, distance, heading) {
-    const carto = Cartographic.fromCartesian(pos3d);
-    const newCarto = offsetPoint({
-        altitude: carto.height,
-        latitude: Math$1.toDegrees(carto.latitude),
-        longitude: Math$1.toDegrees(carto.longitude)
-    }, distance, heading);
-    return Cartesian3.fromDegrees(newCarto.longitude, newCarto.latitude, newCarto.altitude);
-}
-function getAdjustedGroundIntersectionOfCameraRay(viewer, screenPos) {
-    const ray = viewer.camera.getPickRay(screenPos);
-    const intersection = ray ? viewer.scene.globe.pick(ray, viewer.scene) : null;
-    return intersection || null;
-}
-function getGroundCenterOfCameraRay(viewer, screenPos) {
-    var _a, _b;
-    const ray = viewer.camera.getPickRay(screenPos);
-    const intersection = ray ? viewer.scene.globe.pick(ray, viewer.scene) : null;
-    if (intersection) {
-        return intersection;
-    }
-    const cameraHeight = viewer.camera.positionCartographic.height;
-    if (!isNaN(cameraHeight) && isDefined(cameraHeight) && ((_b = (_a = viewer.camera) === null || _a === void 0 ? void 0 : _a.position) === null || _b === void 0 ? void 0 : _b.clone)) {
-        const cameraPos3d = viewer.camera.position.clone();
-        const pitch = viewer.camera.pitch;
-        const distance = cameraHeight / Math.tan(pitch);
-        return offsetPos3d(cameraPos3d, -distance, Math$1.toDegrees(viewer.camera.heading));
-    }
-    return null;
-}
-var ViewGroundArea;
-(function (ViewGroundArea) {
-    function ToBboxPolygon(bounds) {
-        return `${bounds.west},${bounds.south} ${bounds.west},${bounds.north} ${bounds.east},${bounds.north} ${bounds.east},${bounds.south}`;
-    }
-    ViewGroundArea.ToBboxPolygon = ToBboxPolygon;
-    function NormalizeBounds(bounds, altitude) {
-        if (!bounds ||
-            !isDefined(bounds.east) ||
-            !isDefined(bounds.west) ||
-            !isDefined(bounds.north) ||
-            !isDefined(bounds.south)) {
-            return null;
-        }
-        const viewRect = { ...bounds };
-        const centerLong = (viewRect.east + viewRect.west) / 2;
-        const 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));
-        if (isDefined(altitude)) {
-            viewRect.alt = altitude;
-        }
-        return viewRect;
-    }
-    ViewGroundArea.NormalizeBounds = NormalizeBounds;
-    async function GetViewArea(viewer) {
-        var _a, _b;
-        if (!viewer || viewer.isDestroyed()) {
-            return null;
-        }
-        if (!viewer.container || ((_a = viewer.container.style) === null || _a === void 0 ? void 0 : _a.display) == "none") {
-            return null;
-        }
-        let viewRect = null;
-        let center = null;
-        const camera = viewer.camera;
-        const terrData = await DrawingUtils.GetTerrainHeight({
-            pos3d: camera.position,
-            viewer
-        });
-        const cameraPosition = viewer.camera.positionCartographic;
-        const terrHeight = terrData.error ? cameraPosition.height + DEFAULT_GROUNDED_HEIGHT : terrData.height;
-        if (terrHeight && ((cameraPosition.height - terrHeight) < DEFAULT_GROUNDED_HEIGHT)) {
-            viewRect = {};
-            const viewRectRad = netScanViewForBoundaries(viewer);
-            if (viewRectRad &&
-                isDefined(viewRectRad.east) &&
-                isDefined(viewRectRad.west) &&
-                isDefined(viewRectRad.north) &&
-                isDefined(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));
+        async doEntityCheck(ids, force = false) {
+            var _a, _b, _c, _d;
+            if (this.isRunningCheck) {
+                this.entityCheckQueueIds = this.entityCheckQueueIds.concat(ids);
+                (_a = this.entityCheckQueue) === null || _a === void 0 ? void 0 : _a.Call();
+                return;
             }
-            else {
-                viewRect.east = Math$1.toDegrees(cameraPosition.longitude);
-                viewRect.west = Math$1.toDegrees(cameraPosition.longitude);
-                viewRect.south = Math$1.toDegrees(cameraPosition.latitude);
-                viewRect.north = Math$1.toDegrees(cameraPosition.latitude);
+            ids = ids.concat(this.entityCheckQueueIds);
+            this.entityCheckQueueIds = [];
+            ids = ids.filter((id, index) => {
+                return id && ids.indexOf(id) === index;
+            });
+            if (!ids.length) {
+                return;
+            }
+            this.isRunningCheck = true;
+            const runId = this.reRenderState.startCheckRun();
+            const api = this.apiGetter.getApi();
+            try {
+                if (this.disposed) {
+                    return;
+                }
+                const maintained = this.reRenderState.getMaintainedEntities(ids);
+                const maintainedLookup = {};
+                for (let i = 0; i < maintained.length; i++) {
+                    const id = (_c = (_b = maintained[i]) === null || _b === void 0 ? void 0 : _b.Bruce) === null || _c === void 0 ? void 0 : _c.ID;
+                    if (id) {
+                        maintainedLookup[id] = true;
+                    }
+                }
+                if (maintained.length) {
+                    if (force) {
+                        await this.renderDataLabEntities(maintained, true);
+                    }
+                    else {
+                        this.distributeForRender(maintained);
+                    }
+                }
+                let apiIds = ids.filter((id) => {
+                    return !maintainedLookup[id] && !this.reRenderState.shouldSkipInRun(id, runId);
+                });
+                const checkBatch = async () => {
+                    apiIds = this.reRenderState.filterNonSkippedIds(apiIds, runId);
+                    const entityIds = apiIds.splice(0, CHECK_BATCH_SIZE$2);
+                    if (!entityIds.length) {
+                        return;
+                    }
+                    const revisions = this.reRenderState.captureApiRevisions(entityIds);
+                    const { entities } = await Entity$1.GetListByIds({
+                        api,
+                        entityIds,
+                        expandSources: true,
+                        expandLocation: true,
+                        migrated: true,
+                        maxSearchTimeSec: 60 * 2
+                    });
+                    if (this.disposed) {
+                        return;
+                    }
+                    const resolved = this.reRenderState.filterCurrentApiEntities({
+                        entities,
+                        revisions,
+                        runId
+                    });
+                    if (resolved.length) {
+                        if (force) {
+                            await this.renderDataLabEntities(resolved, true);
+                        }
+                        else {
+                            this.distributeForRender(resolved);
+                        }
+                    }
+                };
+                while (apiIds.length > 0) {
+                    await checkBatch();
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+            finally {
+                this.isRunningCheck = false;
+                if (this.entityCheckQueueIds.length) {
+                    (_d = this.entityCheckQueue) === null || _d === void 0 ? void 0 : _d.Call(true);
+                }
             }
-            center = {
-                altitude: camera.positionCartographic.height,
-                latitude: Math$1.toDegrees(camera.positionCartographic.latitude),
-                longitude: Math$1.toDegrees(camera.positionCartographic.longitude)
-            };
         }
-        else {
-            const windowPosition = new Cartesian2(viewer.container.clientWidth / 2, viewer.container.clientHeight / 2);
-            const intersection = getGroundCenterOfCameraRay(viewer, windowPosition);
-            let point = null;
-            if (intersection) {
-                point = Cartographic.fromCartesian(intersection, viewer.scene.globe.ellipsoid);
+        distributeForRender(entities) {
+            if (this.disposed || !(entities === null || entities === void 0 ? void 0 : entities.length)) {
+                return;
             }
-            if (point) {
-                center = {
-                    altitude: point.height,
-                    latitude: Math$1.toDegrees(point.latitude),
-                    longitude: Math$1.toDegrees(point.longitude)
-                };
-                const viewRectRad = netScanViewForBoundaries(viewer, center);
-                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);
+            this.renderQueue = this.renderQueue.concat(entities);
+            if (!this.renderQueueInterval && this.renderQueue.length) {
+                this.renderQueueInterval = setInterval(() => {
+                    const batch = this.deduplicateEntities(this.renderQueue.splice(0, BATCH_SIZE$3));
+                    this.renderDataLabEntities(batch);
+                    if (this.renderQueue.length <= 0) {
+                        clearInterval(this.renderQueueInterval);
+                        this.renderQueueInterval = null;
+                    }
+                }, 50);
+            }
+        }
+        deduplicateEntities(entities) {
+            var _a;
+            const entityMap = new Map();
+            for (let i = 0; i < entities.length; i++) {
+                const entity = entities[i];
+                const id = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID;
+                if (id) {
+                    entityMap.set(id, entity);
                 }
             }
+            return Array.from(entityMap.values());
         }
-        viewRect = NormalizeBounds(viewRect, (_b = viewer.scene.camera.positionCartographic) === null || _b === void 0 ? void 0 : _b.height);
-        if (center && viewRect) {
-            return {
-                bounds: viewRect,
-                target: center
-            };
+        async renderDataLabEntities(entities, force = false) {
+            var _a, _b, _c;
+            if (this.disposed || this.viewer.isDestroyed() || !(entities === null || entities === void 0 ? void 0 : entities.length)) {
+                return;
+            }
+            try {
+                const { updated, entities: cEntities } = await EntityRenderEngine.Render({
+                    viewer: this.viewer,
+                    apiGetter: this.apiGetter,
+                    entities,
+                    menuItemId: this.item.id,
+                    visualRegister: this.visualsManager,
+                    zoomControl: this.zoomControl,
+                    force
+                });
+                if (this.disposed) {
+                    return;
+                }
+                for (let i = 0; i < entities.length; i++) {
+                    const entity = entities[i];
+                    const id = entity.Bruce.ID;
+                    const cEntity = cEntities.get(id);
+                    this.renderedEntities[id] = !!cEntity;
+                    if (cEntity) {
+                        const rego = this.visualsManager.GetRego({
+                            entityId: id,
+                            menuItemId: this.item.id
+                        });
+                        const canEdit = !((_a = entity.Bruce.Outline) === null || _a === void 0 ? void 0 : _a.find(x => x.Baseline && !x.Editable));
+                        const visual = rego === null || rego === void 0 ? void 0 : rego.visual;
+                        if (!visual || visual != cEntity) {
+                            this.visualsManager.AddRego({
+                                rego: {
+                                    canEdit,
+                                    entityId: id,
+                                    schema: entity.Bruce.Schema,
+                                    menuItemId: this.item.id,
+                                    menuItemType: this.item.Type,
+                                    visual: cEntity,
+                                    priority: this.renderPriority,
+                                    entityTypeId: entity.Bruce["EntityType.ID"],
+                                    accountId: this.apiGetter.accountId,
+                                    tagIds: entity.Bruce["Layer.ID"] ? [].concat(entity.Bruce["Layer.ID"]) : [],
+                                    name: cEntity.name,
+                                    cdn: this.item.cdnEnabled,
+                                    outline: entity.Bruce.Outline
+                                },
+                                requestRender: false
+                            });
+                        }
+                        else if (updated.get(id) && rego) {
+                            rego.name = cEntity.name;
+                            rego.visual = cEntity;
+                            rego.entityTypeId = entity.Bruce["EntityType.ID"];
+                            rego.tagIds = entity.Bruce["Layer.ID"] ? [].concat(entity.Bruce["Layer.ID"]) : [];
+                            rego.outline = (_b = entity.Bruce) === null || _b === void 0 ? void 0 : _b.Outline;
+                            rego.cdn = this.item.cdnEnabled;
+                            rego.schema = (_c = entity.Bruce) === null || _c === void 0 ? void 0 : _c.Schema;
+                            rego.canEdit = canEdit;
+                            if (rego.stale) {
+                                this.visualsManager.RefreshMark({
+                                    rego
+                                });
+                                this.visualsManager.ForceUpdate({
+                                    entityIds: [id],
+                                    refreshColors: true,
+                                    requestRender: false
+                                });
+                            }
+                            this.visualsManager.OnUpdate.Trigger({
+                                type: VisualsRegister.EVisualUpdateType.Update,
+                                entityId: id,
+                                rego: rego
+                            });
+                        }
+                    }
+                    else {
+                        this.visualsManager.RemoveRegos({
+                            entityId: id,
+                            menuItemId: this.item.id,
+                            requestRender: false
+                        });
+                    }
+                }
+                this.viewer.scene.requestRender();
+            }
+            catch (e) {
+                console.error("Failed to render DataLab entities:", e);
+            }
         }
-        return null;
     }
-    ViewGroundArea.GetViewArea = GetViewArea;
-})(ViewGroundArea || (ViewGroundArea = {}));
+    DataLabRenderManager.Manager = Manager;
+})(DataLabRenderManager || (DataLabRenderManager = {}));
 
 const TIME_LAG = 300;
 const POSITION_CHECK_TIMER = 950;
@@ -15213,7 +15798,7 @@ var CesiumViewMonitor;
 })(CesiumViewMonitor || (CesiumViewMonitor = {}));
 
 const MAX_BATCHES = 2;
-const BATCH_SIZE$3 = 1000;
+const BATCH_SIZE$4 = 1000;
 const BATCH_DELAY = 200;
 const MAX_RANGE = 3000;
 var TilesetOsmRenderManager;
@@ -15428,7 +16013,7 @@ var TilesetOsmRenderManager;
                                 const isClose = this.getIsVisualWithinRange(feature, MAX_RANGE);
                                 if (isClose) {
                                     batch.push(feature);
-                                    if (batch.length >= BATCH_SIZE$3) {
+                                    if (batch.length >= BATCH_SIZE$4) {
                                         return batch;
                                     }
                                 }
@@ -15578,7 +16163,7 @@ var TilesetOsmRenderManager;
                         delete this._loadedCesiumEntities[key];
                         this.totalLoaded -= 1;
                         removed += 1;
-                        if (removed >= BATCH_SIZE$3) {
+                        if (removed >= BATCH_SIZE$4) {
                             return true;
                         }
                     }
@@ -16342,6 +16927,10 @@ var XGridsRenderEngine;
                 }
             }
         });
+        if (typeof (obj === null || obj === void 0 ? void 0 : obj.setVisible) === "function") {
+            obj.setVisible(true);
+        }
+        TilesetRenderEngine.WatchDateRange(viewer, obj, tileset);
         // Highest LOD.
         obj.setStartLod(0);
         // Max distance for rendering.
@@ -16361,6 +16950,7 @@ var XGridsRenderEngine;
             console.warn("[XGridsRenderEngine] Remove() LCCRender library not available.");
             return;
         }
+        TilesetRenderEngine.UnwatchDateRange(viewer, renderObject);
         LCCRender.unload(renderObject);
     }
     XGridsRenderEngine.Remove = Remove;
@@ -35360,7 +35950,7 @@ class WidgetViewBar extends Widget.AWidget {
     }
 }
 
-const VERSION = "6.5.9";
+const VERSION = "6.6.1";
 /**
  * Updates the environment instance used by bruce-cesium to one specified.
  * This can be used to ensure that the instance a parent is referencing is shared between bruce-cesium, bruce-models, and the parent app.