bruce-cesium 5.4.5 → 5.4.7

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
 import { BruceEvent, Cartes, Entity as Entity$1, Carto, Geometry, MathUtils, LRUCache, Api, Calculator, ClientFile, EntityTag, EntityType, ObjectUtils, Style, ProjectViewTile, DelayQueue, EntityLod, Bounds, ZoomControl, EntityRelationType, ENVIRONMENT, EntityHistoricData, Tileset, EntityCoords, DataLab, EntitySource, MenuItem, EntityRelation, ProgramKey, ProjectView, ProjectViewBookmark, Camera, ProjectViewLegacyTile, EntityAttachment, EntityAttachmentType, EntityAttribute, AbstractApi, Session } from 'bruce-models';
 import * as Cesium from 'cesium';
-import { Cartographic, Cartesian2, Math as Math$1, Cartesian3, CallbackProperty, Color, HeightReference, Rectangle, JulianDate, Entity, DistanceDisplayCondition, HorizontalOrigin, VerticalOrigin, ConstantProperty, ClassificationType, ConstantPositionProperty, ArcType, CornerType, ShadowMode, PolygonHierarchy, PolylineGraphics, ColorMaterialProperty, ColorBlendMode, HeadingPitchRoll, Transforms, Model, SceneMode, Primitive, Cesium3DTileFeature, GeoJsonDataSource, Cesium3DTileStyle, HeadingPitchRange, Cesium3DTileColorBlendMode, Ion, KmlDataSource, SceneTransforms, OrthographicFrustum, EasingFunction, NearFarScalar, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, CesiumInspector, defined, ClockRange, Cesium3DTileset, Matrix4, Matrix3, IonResource, EllipsoidGeodesic, sampleTerrainMostDetailed, PolygonPipeline, BoundingSphere, GeometryInstance, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, ScreenSpaceEventHandler, ScreenSpaceEventType, Quaternion, CzmlDataSource, Intersect, Fullscreen } from 'cesium';
+import { Cartographic, Cartesian2, Math as Math$1, Cartesian3, CallbackProperty, Color, HeightReference, Rectangle, JulianDate, Entity, DistanceDisplayCondition, ClassificationType, ArcType, CornerType, ShadowMode, ConstantProperty, ConstantPositionProperty, PolygonHierarchy, PolylineGraphics, ColorMaterialProperty, HorizontalOrigin, VerticalOrigin, ColorBlendMode, HeadingPitchRoll, Transforms, Model, Primitive, Cesium3DTileFeature, SceneMode, GeoJsonDataSource, Cesium3DTileStyle, HeadingPitchRange, Ion, Cesium3DTileColorBlendMode, KmlDataSource, OrthographicFrustum, EasingFunction, NearFarScalar, SceneTransforms, Cesium3DTileset, Matrix4, Matrix3, IonResource, EllipsoidTerrainProvider, CesiumInspector, defined, ClockRange, EllipsoidGeodesic, sampleTerrainMostDetailed, PolygonPipeline, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, BoundingSphere, GeometryInstance, Quaternion, ScreenSpaceEventHandler, ScreenSpaceEventType, CzmlDataSource, Intersect, Fullscreen } from 'cesium';
 
 const TIME_LAG = 300;
 const POSITION_CHECK_TIMER = 950;
@@ -1152,10 +1152,15 @@ var CesiumAnimatedProperty;
             this.lastCalcSeriesTime = null;
             this.lastCalcOrient = null;
             this.lastCalcOrientTime = null;
+            // Indicates that the first time we get a GetValue position, we need to animate into it.
+            this.animateFromPos3d = null;
+            this.animateFromPos3dTimeStart = null;
             this.viewer = params.viewer;
             this.positions = params.posses;
             this.pitch = params.pitch;
             this.roll = params.roll;
+            this.animateFromPos3d = params.animateFromPos3d;
+            this.animateFromPos3dTimeStart = Date.now();
             this.processHeadings();
             // Order positions by date.
             this.positions.sort((a, b) => {
@@ -1189,19 +1194,28 @@ var CesiumAnimatedProperty;
             if (!now) {
                 now = this.viewer.clock.currentTime;
             }
-            const nowTime = JulianDate.toDate(now);
-            if (this.lastCalcTime == nowTime.getTime()) {
+            const nowTimeMs = JulianDate.toDate(now).getTime();
+            // Skip calculation if time hasn't changed.
+            if (this.lastCalcTime === nowTimeMs) {
+                if (this.animateFromPos3d) {
+                    // We emit an interpolated position if we're animating from the start position.
+                    const interpolatedPos = this.interpolateToStartPos3d(this.animateFromPos3dTimeStart, Date.now());
+                    if (Cartesian3.equals(interpolatedPos, this.animateFromPos3d)) {
+                        this.animateFromPos3d = null;
+                    }
+                    return interpolatedPos;
+                }
                 return this.lastCalcPos3d;
             }
             const calculate = () => {
                 // See if we're before the first position.
-                if (nowTime.getTime() <= this.positions[0].dateTime.getTime()) {
+                if (nowTimeMs <= this.positions[0].dateTime.getTime()) {
                     this.lastCalcPosIndexLast = 0;
                     this.lastCalcPosIndexNext = 0;
                     return this.positions[0].pos3d;
                 }
                 // See if we're after the last position.
-                if (nowTime.getTime() >= this.positions[this.positions.length - 1].dateTime.getTime()) {
+                if (nowTimeMs >= this.positions[this.positions.length - 1].dateTime.getTime()) {
                     this.lastCalcPosIndexLast = this.positions.length - 1;
                     this.lastCalcPosIndexNext = this.positions.length - 1;
                     return this.positions[this.positions.length - 1].pos3d;
@@ -1210,7 +1224,7 @@ var CesiumAnimatedProperty;
                 let lastIndex = 0;
                 for (let i = 1; i < this.positions.length; i++) {
                     let pos = this.positions[i];
-                    if (nowTime.getTime() >= pos.dateTime.getTime()) {
+                    if (nowTimeMs >= pos.dateTime.getTime()) {
                         lastIndex = i;
                     }
                     else {
@@ -1226,12 +1240,43 @@ var CesiumAnimatedProperty;
                     return last.pos3d;
                 }
                 this.lastCalcPosIndexNext = lastIndex + 1;
-                let progress = (nowTime.getTime() - last.dateTime.getTime()) / (next.dateTime.getTime() - last.dateTime.getTime());
+                let progress = (nowTimeMs - last.dateTime.getTime()) / (next.dateTime.getTime() - last.dateTime.getTime());
                 return Cartesian3.lerp(last.pos3d, next.pos3d, progress, new Cartesian3());
             };
-            this.lastCalcTime = nowTime.getTime();
+            this.lastCalcTime = nowTimeMs;
             this.lastCalcPos3d = calculate();
-            return this.lastCalcPos3d;
+            let pos3d = this.lastCalcPos3d;
+            // We emit an interpolated position if we're animating from the start position.
+            if (this.animateFromPos3d && Cartes.ValidateCartes3(this.lastCalcPos3d)) {
+                if (Cartesian3.equals(this.animateFromPos3d, this.lastCalcPos3d)) {
+                    this.animateFromPos3d = null;
+                }
+                else if (this.animateFromPos3d) {
+                    pos3d = this.interpolateToStartPos3d(this.animateFromPos3dTimeStart, Date.now());
+                    if (Cartesian3.equals(pos3d, this.animateFromPos3d)) {
+                        this.animateFromPos3d = null;
+                    }
+                }
+            }
+            return pos3d;
+        }
+        /**
+         * Interpolates between the start position and the last calculated position.
+         * This lets us animate in the series positions.
+         * @param nowMs
+         */
+        interpolateToStartPos3d(startMs, nowMs) {
+            const startPos = this.animateFromPos3d;
+            const targetPos = this.lastCalcPos3d;
+            if (!startPos || !targetPos) {
+                return startPos ? startPos : targetPos;
+            }
+            const duration = nowMs - startMs;
+            let progress = duration / 300; // 300ms duration.
+            if (progress > 1) {
+                progress = 1;
+            }
+            return Cartesian3.lerp(startPos, targetPos, progress, new Cartesian3());
         }
         /**
          * Returns a series of positions to use for rendering the path.
@@ -1414,6 +1459,9 @@ var CesiumAnimatedProperty;
             // Cache for calculated values.
             this.lastCalcTime = null;
             this.lastCalcPos3d = null;
+            this.lastCalcPosApplyOverTime = false;
+            this.lastCalcPos3dApplyOverTimeTarget = null;
+            this.lastCalcPos3dApplyOverTimeTimeStart = null;
             this.lastCalcHeading = null;
             this.removal = null;
             // Track the timeline range for which we have data.
@@ -1511,17 +1559,75 @@ var CesiumAnimatedProperty;
             const nowTimeMs = nowTime.getTime();
             // Skip calculation if time hasn't changed.
             if (this.lastCalcTime === nowTimeMs) {
+                // If we're currently mid-animation, we need to update the position over time.
+                if (this.lastCalcPosApplyOverTime) {
+                    const interpolatedPos = this.interpolatePos3dOverTime(this.lastCalcPos3dApplyOverTimeTimeStart, Date.now());
+                    if (Cartesian3.equals(interpolatedPos, this.lastCalcPos3dApplyOverTimeTarget)) {
+                        this.lastCalcPosApplyOverTime = false;
+                        this.lastCalcPos3d = interpolatedPos;
+                    }
+                    this.onUpdate(interpolatedPos, this.lastCalcHeading);
+                }
                 return;
             }
             // Calculate position.
             const position = this.calculatePosition(nowTimeMs);
+            // Calculate what position to emit.
+            let pos3d = null;
             // Update cache values.
             this.lastCalcTime = nowTimeMs;
-            this.lastCalcPos3d = position.pos3d;
+            if (position.applyOverTime && Cartes.ValidateCartes3(this.lastCalcPos3d)) {
+                if (Cartesian3.equals(this.lastCalcPos3d, position.pos3d)) {
+                    pos3d = position.pos3d;
+                    this.lastCalcPosApplyOverTime = false;
+                }
+                else if (Cartesian3.equals(this.lastCalcPos3dApplyOverTimeTarget, position.pos3d)) {
+                    pos3d = this.interpolatePos3dOverTime(this.lastCalcPos3dApplyOverTimeTimeStart, Date.now());
+                    if (Cartesian3.equals(pos3d, this.lastCalcPos3dApplyOverTimeTarget)) {
+                        this.lastCalcPos3d = pos3d;
+                        this.lastCalcPosApplyOverTime = false;
+                    }
+                }
+                else {
+                    if (!this.lastCalcPosApplyOverTime) {
+                        this.lastCalcPos3dApplyOverTimeTimeStart = Date.now();
+                    }
+                    this.lastCalcPosApplyOverTime = true;
+                    this.lastCalcPos3dApplyOverTimeTarget = position.pos3d;
+                    pos3d = this.interpolatePos3dOverTime(this.lastCalcPos3dApplyOverTimeTimeStart, Date.now());
+                }
+            }
+            else {
+                this.lastCalcPos3d = position.pos3d;
+                pos3d = position.pos3d;
+            }
             // Calculate heading.
-            this.lastCalcHeading = this.calculateHeading(nowTimeMs, position.indexLast, position.indexNext);
+            const posses = this.positions;
+            const lastPos = posses[position.indexLast];
+            const nextPos = posses[position.indexNext];
+            if (lastPos && nextPos) {
+                this.lastCalcHeading = this.calculateHeading(nowTimeMs, lastPos, nextPos);
+            }
             // Provide the calculated values to the caller.
-            this.onUpdate(this.lastCalcPos3d, this.lastCalcHeading);
+            this.onUpdate(pos3d, this.lastCalcHeading);
+        }
+        /**
+         * Interpolates the position over time between the last and target positions.
+         * This is used when we reach a boundary position so to smoothly animate to it, we move from the current position to it.
+         * @param nowMs
+         */
+        interpolatePos3dOverTime(prevMs, nowMs) {
+            const lastPos = this.lastCalcPos3d;
+            const targetPos = this.lastCalcPos3dApplyOverTimeTarget;
+            if (!lastPos || !targetPos) {
+                return lastPos ? lastPos : targetPos;
+            }
+            const duration = nowMs - prevMs;
+            let progress = duration / 300; // 300ms duration.
+            if (progress > 1) {
+                progress = 1;
+            }
+            return Cartesian3.lerp(lastPos, targetPos, progress, new Cartesian3());
         }
         /**
          * Pre-process headings in the series.
@@ -1553,7 +1659,8 @@ var CesiumAnimatedProperty;
                 return {
                     pos3d: new Cartesian3(),
                     indexLast: -1,
-                    indexNext: -1
+                    indexNext: -1,
+                    applyOverTime: false
                 };
             }
             // See if we're before the first position.
@@ -1561,7 +1668,8 @@ var CesiumAnimatedProperty;
                 return {
                     pos3d: posses[0].pos3d,
                     indexLast: 0,
-                    indexNext: 0
+                    indexNext: 0,
+                    applyOverTime: true
                 };
             }
             // See if we're after the last position.
@@ -1570,7 +1678,8 @@ var CesiumAnimatedProperty;
                 return {
                     pos3d: posses[lastIndex].pos3d,
                     indexLast: lastIndex,
-                    indexNext: lastIndex
+                    indexNext: lastIndex,
+                    applyOverTime: true
                 };
             }
             // Binary search to find the closest position.
@@ -1596,7 +1705,8 @@ var CesiumAnimatedProperty;
                 return {
                     pos3d: last.pos3d,
                     indexLast: lastIndex,
-                    indexNext: lastIndex
+                    indexNext: lastIndex,
+                    applyOverTime: true
                 };
             }
             // Interpolate between the two closest positions.
@@ -1607,25 +1717,18 @@ var CesiumAnimatedProperty;
             return {
                 pos3d: interpolatedPos,
                 indexLast: lastIndex,
-                indexNext: nextIndex
+                indexNext: nextIndex,
+                applyOverTime: false
             };
         }
         /**
          * Calculate the heading at the given time.
          */
-        calculateHeading(currentTimeMs, lastIndex, nextIndex) {
-            const posses = this.positions;
-            // Ensure valid indices.
-            if (lastIndex < 0 || nextIndex < 0 ||
-                lastIndex >= posses.length || nextIndex >= posses.length) {
-                return null;
-            }
-            const lastPos = posses[lastIndex];
-            const nextPos = posses[nextIndex];
+        calculateHeading(currentTimeMs, lastPos, nextPos) {
             // If the heading is present and not null, interpolate or use it directly.
             if (lastPos.heading !== null && nextPos.heading !== null) {
                 // If they're the same position or same time, just return the heading.
-                if (lastIndex === nextIndex ||
+                if (lastPos === nextPos ||
                     lastPos.dateTime.getTime() === nextPos.dateTime.getTime()) {
                     return lastPos.heading;
                 }
@@ -1645,16 +1748,16 @@ var CesiumAnimatedProperty;
             }
             // If no valid heading is available, calculate based on movement direction.
             else {
-                const previousPos = lastPos.pos3d;
-                const currentPos = nextPos.pos3d;
-                if (!previousPos || isNaN(previousPos.x) ||
-                    !currentPos || isNaN(currentPos.x)) {
+                const prevPos3d = lastPos.pos3d;
+                const nextPos3d = nextPos.pos3d;
+                if (!prevPos3d || isNaN(prevPos3d.x) ||
+                    !nextPos3d || isNaN(nextPos3d.x)) {
                     return null;
                 }
                 // Flatten to avoid orientation changes due to height differences.
-                const adjustedPointPrev = Cartographic.fromCartesian(previousPos);
+                const adjustedPointPrev = Cartographic.fromCartesian(prevPos3d);
                 const adjustedPos3dPrev = Cartesian3.fromRadians(adjustedPointPrev.longitude, adjustedPointPrev.latitude, 0);
-                const adjustedPointNext = Cartographic.fromCartesian(currentPos);
+                const adjustedPointNext = Cartographic.fromCartesian(nextPos3d);
                 const adjustedPos3dNext = Cartesian3.fromRadians(adjustedPointNext.longitude, adjustedPointNext.latitude, 0);
                 // Check if the positions are too close.
                 if (Cartesian3.distance(adjustedPos3dPrev, adjustedPos3dNext) < 0.05) {
@@ -1665,14 +1768,24 @@ var CesiumAnimatedProperty;
                 if (direction.x === 0 && direction.y === 0 && direction.z === 0) {
                     return null;
                 }
-                // Calculate heading from the direction vector.
+                // Normalize the direction vector.
                 Cartesian3.normalize(direction, direction);
-                // Convert the direction to a heading angle.
-                const east = Cartesian3.UNIT_X;
-                const north = Cartesian3.UNIT_Y;
-                const heading = Math.atan2(Cartesian3.dot(direction, east), Cartesian3.dot(direction, north));
-                // Convert to degrees.
-                return (Math$1.toDegrees(heading) + 360) % 360;
+                // Calculate heading in the ENU (East-North-Up).
+                // First, get the local ENU frame at the midpoint.
+                const midPoint = Cartesian3.midpoint(adjustedPos3dPrev, adjustedPos3dNext, new Cartesian3());
+                // Convert direction from ECEF to ENU.
+                // We need to create a transform from ECEF to ENU at our position.
+                const transform = Transforms.eastNorthUpToFixedFrame(midPoint);
+                const inverseTransform = Matrix4.inverseTransformation(transform, new Matrix4());
+                // Transform our direction vector to local ENU.
+                const localDirection = Matrix4.multiplyByPointAsVector(inverseTransform, direction, new Cartesian3());
+                Cartesian3.normalize(localDirection, localDirection);
+                // Now calculate the heading in the ENU frame (clockwise from north).
+                // atan2(east, north) gives us the angle in the east-north plane measured clockwise from north.
+                const heading = Math.atan2(localDirection.x, localDirection.y);
+                // Convert to degrees and ensure it's in the range [0, 360].
+                const headingDegrees = (Math$1.toDegrees(heading) + 360) % 360;
+                return headingDegrees;
             }
         }
     }
@@ -4554,12 +4667,14 @@ var EntityRenderEnginePoint;
                         // Unset width/height.
                         cEntity.billboard.width = undefined;
                         cEntity.billboard.height = undefined;
+                        const prevPos3d = GetCValue(params.viewer, cEntity.position);
                         // If we have a series of time-based positions then we'll animate as time changes.
                         const series = CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
                         if (series.length > 1) {
                             animatePosition = new CesiumAnimatedProperty.AnimatePositionSeries({
                                 posses: series,
-                                viewer: params.viewer
+                                viewer: params.viewer,
+                                animateFromPos3d: prevPos3d
                             });
                             cEntity.position = new CallbackProperty(() => animatePosition.GetValue(), false);
                         }
@@ -4571,7 +4686,6 @@ var EntityRenderEnginePoint;
                                 returnHeightRef: heightRef,
                                 allowRendered: false
                             });
-                            const prevPos3d = GetCValue(params.viewer, cEntity.position);
                             if (!prevPos3d || !Cartesian3.equals(prevPos3d, pos3d)) {
                                 animatePosition = new CesiumAnimatedProperty.AnimatePosition({
                                     durationMs: 200,
@@ -4877,12 +4991,14 @@ var EntityRenderEnginePoint;
                 cEntity.billboard.heightReference = new ConstantProperty(heightRef);
                 cEntity.billboard.distanceDisplayCondition = new ConstantProperty(EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance));
                 cEntity.billboard.disableDepthTestDistance = new ConstantProperty(disableDepthTest ? Number.POSITIVE_INFINITY : undefined);
+                const prevPos3d = GetCValue(params.viewer, cEntity.position);
                 // If we have a series of time-based positions then we'll animate as time changes.
                 const series = CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
                 if (series.length > 1) {
                     animatePosition = new CesiumAnimatedProperty.AnimatePositionSeries({
                         posses: series,
-                        viewer: params.viewer
+                        viewer: params.viewer,
+                        animateFromPos3d: prevPos3d
                     });
                     cEntity.position = new CallbackProperty(() => animatePosition.GetValue(), false);
                 }
@@ -4894,7 +5010,6 @@ var EntityRenderEnginePoint;
                         returnHeightRef: heightRef,
                         allowRendered: false
                     });
-                    const prevPos3d = GetCValue(params.viewer, cEntity.position);
                     if (!prevPos3d || !Cartesian3.equals(prevPos3d, pos3d)) {
                         animatePosition = new CesiumAnimatedProperty.AnimatePosition({
                             durationMs: 200,
@@ -6474,6 +6589,7 @@ var EntityRenderEngineModel3d;
             cEntity.model.colorBlendAmount = new ConstantProperty(blendAmount);
             cEntity.model.colorBlendMode = new ConstantProperty(blendMode);
             cEntity.model.distanceDisplayCondition = new ConstantProperty(EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance));
+            const prevPos3d = GetCValue(params.viewer, cEntity.position);
             // If we have a series of time-based positions then we'll animate as time changes.
             const series = CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
             if (series.length > 1) {
@@ -6481,12 +6597,12 @@ var EntityRenderEngineModel3d;
                     posses: series,
                     viewer: params.viewer,
                     pitch: pitch,
-                    roll: roll
+                    roll: roll,
+                    animateFromPos3d: prevPos3d
                 });
                 cEntity.position = new CallbackProperty(() => animatePosition.GetValue(), false);
             }
             else {
-                const prevPos3d = GetCValue(params.viewer, cEntity.position);
                 const posChanged = !prevPos3d || !Cartesian3.equals(prevPos3d, pos3d);
                 if (posChanged) {
                     animatePosition = new CesiumAnimatedProperty.AnimatePosition({
@@ -14395,36 +14511,54 @@ var EntitiesIdsRenderManager;
          * @param entities
          */
         async getHistoricInfo(entities) {
-            const startTmp = JulianDate.toDate(this.viewer.clock.startTime);
-            const stopTmp = JulianDate.toDate(this.viewer.clock.stopTime);
+            // Time padding in milliseconds (15 seconds).
+            // Helps account for desync between client and server.
+            const TIME_PADDING_MS = 15000;
+            const minDateTimeStr = this.viewer.clock.startTime.toString();
+            const maxDateTimeStr = this.viewer.clock.stopTime.toString();
+            const minDateTime = new Date(minDateTimeStr).getTime();
+            const maxDateTime = new Date(maxDateTimeStr).getTime();
             let rangesToRequest = [{
-                    start: startTmp.toISOString(),
-                    stop: stopTmp.toISOString()
+                    start: minDateTime,
+                    stop: maxDateTime
                 }];
             // If we already have cached data, determine what ranges we're missing.
-            if (this.lastHistoricMin && this.lastHistoricMax && Object.keys(this.entitiesHistoric).length >= entities.length) {
-                const cachedStart = new Date(this.lastHistoricMin).getTime();
-                const cachedStop = new Date(this.lastHistoricMax).getTime();
-                const newStart = startTmp.getTime();
-                const newStop = stopTmp.getTime();
+            if (Object.keys(this.entitiesHistoric).length >= entities.length) {
+                let foundMinDateTime = null;
+                let foundMaxDateTime = null;
+                // Find the min/max based on cached data.
+                // Since we set the values sorted, we only have to check the first and last records for each entity.
+                for (const entityId of Object.keys(this.entitiesHistoric)) {
+                    const records = this.entitiesHistoric[entityId] || [];
+                    if (records.length) {
+                        const dateTime = new Date(records[0].dateTime).getTime();
+                        if (foundMinDateTime == null || dateTime < foundMinDateTime) {
+                            foundMinDateTime = dateTime;
+                        }
+                        const dateTime2 = new Date(records[records.length - 1].dateTime).getTime();
+                        if (foundMaxDateTime == null || dateTime2 > foundMaxDateTime) {
+                            foundMaxDateTime = dateTime2;
+                        }
+                    }
+                }
                 // Complete overlap - we already have all the data.
-                if (newStart >= cachedStart && newStop <= cachedStop) {
+                if (foundMinDateTime != null && foundMaxDateTime != null && foundMinDateTime <= minDateTime && foundMaxDateTime >= maxDateTime) {
                     return [false, this.entitiesHistoric];
                 }
                 // Calculate missing ranges.
                 rangesToRequest = [];
                 // Check if we need data before our cached range.
-                if (newStart < cachedStart) {
+                if (foundMinDateTime != null && foundMinDateTime > minDateTime) {
                     rangesToRequest.push({
-                        start: startTmp.toISOString(),
-                        stop: new Date(cachedStart).toISOString()
+                        start: minDateTime,
+                        stop: new Date(foundMinDateTime).getTime()
                     });
                 }
                 // Check if we need data after our cached range.
-                if (newStop > cachedStop) {
+                if (foundMaxDateTime != null && foundMaxDateTime < maxDateTime) {
                     rangesToRequest.push({
-                        start: new Date(cachedStop).toISOString(),
-                        stop: stopTmp.toISOString()
+                        start: new Date(foundMaxDateTime).getTime(),
+                        stop: maxDateTime
                     });
                 }
             }
@@ -14435,17 +14569,12 @@ var EntitiesIdsRenderManager;
                 if (this.disposed) {
                     break;
                 }
-                // Add padding to ensure we get all data.
-                const start = new Date(range.start);
-                const stop = new Date(range.stop);
-                start.setSeconds(start.getSeconds() - 1);
-                stop.setSeconds(stop.getSeconds() + 1);
-                const paddedStartStr = start.toISOString();
-                const paddedStopStr = stop.toISOString();
+                const start = new Date(range.start - TIME_PADDING_MS);
+                const stop = new Date(range.stop + TIME_PADDING_MS);
                 const historicData = await EntityHistoricData.GetList({
                     attrKey: this.item.BruceEntity.historicAttrKey,
-                    dateTimeFrom: paddedStartStr,
-                    dateTimeTo: paddedStopStr,
+                    dateTimeFrom: start.toISOString(),
+                    dateTimeTo: stop.toISOString(),
                     entityIds: entityIds,
                     api: this.apiGetter.getApi()
                 });
@@ -14479,9 +14608,6 @@ var EntitiesIdsRenderManager;
                 }
             }
             if (!this.disposed) {
-                // Update our cache boundaries.
-                this.lastHistoricMin = startTmp.toISOString();
-                this.lastHistoricMax = stopTmp.toISOString();
                 this.entitiesHistoric = combined;
             }
             return [rangesToRequest.length > 0, combined];
@@ -14703,969 +14829,873 @@ var EntityRenderManager;
     EntityRenderManager.Manager = Manager;
 })(EntityRenderManager || (EntityRenderManager = {}));
 
-/**
- * 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) {
-    class Cell {
-        constructor() {
-            this.Fetched = false;
-            this.IsFetched = null;
-            this.FetchPageIndex = 0;
-            // Optional URL to use instead of default URL generation.
-            // This is typically a response from the API to use this specific URL for the next page.
-            this.FetchURL = null;
-            this.Boundaries = null;
-            this.Fetching = false;
+class EntityGatherer {
+    get OnQueueProgress() {
+        if (!this._onQueueProgress) {
+            this._onQueueProgress = new BruceEvent();
         }
-        GetBounds() {
-            // Entity data works in -180 to 180 range.
-            function prepareRangeForBounds(range) {
-                if (range > 180) {
-                    return range - 360;
-                }
-                return range;
-            }
-            // Add minor decimal as API crashes when giving it whole numbers.
-            const maxLon = prepareRangeForBounds(this.Boundaries.maxLongitude);
-            const minLon = prepareRangeForBounds(this.Boundaries.minLongitude);
-            const maxLat = prepareRangeForBounds(this.Boundaries.maxLatitude);
-            const minLat = prepareRangeForBounds(this.Boundaries.minLatitude);
-            return {
-                east: maxLon,
-                north: maxLat,
-                south: minLat,
-                west: minLon
-            };
+        return this._onQueueProgress;
+    }
+    constructor(api, viewer, emitEntities) {
+        this.disposed = false;
+        this.expandSources = false;
+        this.historic = null;
+        this.hDisposals = [];
+        // Last date-time taken from the clock.
+        this.lastDateTime = null;
+        // Last date-time range taken from the clock.
+        this.lastDateTimeMin = null;
+        this.lastDateTimeMax = null;
+        // Entity ID -> last resolved date time.
+        // Helps determine if a slow resolved request can still be applied while we wait for the next one.
+        this.lastFoundDateTimes = new Map();
+        // ID of Entity IDs that need to be requested.
+        this.eIdQueue = [];
+        // All IDs that have ever been queued.
+        // When nothing is in queue, we'll re-request the existing IDs based on timeline changes.
+        this.allEIds = new Set();
+        // Indicates a tick is active.
+        // When true, we won't bother calling onTick again.
+        this.runningTick = false;
+        // Entity ID -> Entity blob.
+        // This is a tool that lets developers set their own JSON blobs instead of requesting data from API.
+        this.entityDataOverrides = new Map();
+        // 0 - 100 % progress callback for the queue.
+        // Only called if at least 1 Entity is in the queue at start of the tick.
+        this._onQueueProgress = null;
+        this.api = api;
+        this.viewer = viewer;
+        this.emitEntities = emitEntities;
+    }
+    SetEntityDataOverride(eId, entity) {
+        if (this.disposed) {
+            return;
+        }
+        if (entity) {
+            this.entityDataOverrides.set(eId, entity);
+        }
+        else {
+            this.entityDataOverrides.delete(eId);
         }
     }
-    EntityGlobe.Cell = Cell;
-    class Grid {
-        constructor() {
-            this.cells = {};
+    /**
+     * Initializes or updates the manager with given new state settings.
+     * @param historic
+     * @param expandSources
+     * @returns
+     */
+    Init(historic, expandSources) {
+        if (historic == null || historic == undefined) {
+            historic = this.historic;
         }
-        GetCellsForView(cameraPos, viewRect) {
-            const cells = [];
-            const minLat = viewRect.south;
-            const minLon = viewRect.west;
-            const maxLat = viewRect.north;
-            const maxLon = viewRect.east;
-            const MAX_CELLS = 150;
-            const cellDegreeSize = getCellSizeFromHeight(viewRect.alt);
-            // console.log("cell size", cellDegreeSize, "height", viewRect.alt);
-            let curMinLon = floorValueToCellSize(cellDegreeSize, minLon);
-            let curMinLat = floorValueToCellSize(cellDegreeSize, minLat);
-            // For larger views we add additional padding because our view-area culling is too strong.
-            if (cellDegreeSize >= 2) {
-                curMinLon -= cellDegreeSize;
-                curMinLat -= cellDegreeSize;
-            }
-            let centerX = cameraPos === null || cameraPos === void 0 ? void 0 : cameraPos.longitude;
-            let centerY = cameraPos === null || cameraPos === void 0 ? void 0 : cameraPos.latitude;
-            if (isNaN(centerX) || isNaN(centerY)) {
-                centerX = (minLon + maxLon) / 2;
-                centerY = (minLat + maxLat) / 2;
-            }
-            let width = Math.ceil((maxLon - curMinLon) / cellDegreeSize);
-            let height = Math.ceil((maxLat - curMinLat) / cellDegreeSize);
-            // For larger views we add additional padding because our view-area culling is too strong.
-            if (cellDegreeSize >= 2) {
-                width += 1;
-                height += 1;
-            }
-            const cellDistances = [];
-            for (let x = 0; x < width; x++) {
-                for (let y = 0; y < height; y++) {
-                    const lon = x * cellDegreeSize + curMinLon;
-                    const lat = y * cellDegreeSize + curMinLat;
-                    const cellCenterX = lon + cellDegreeSize / 2;
-                    const cellCenterY = lat + cellDegreeSize / 2;
-                    const dist = Math.sqrt(Math.pow(cellCenterX - centerX, 2) + Math.pow(cellCenterY - centerY, 2));
-                    cellDistances.push({ x, y, dist });
-                }
-            }
-            cellDistances.sort((a, b) => a.dist - b.dist);
-            for (const { x, y } of cellDistances) {
-                const lon = x * cellDegreeSize + curMinLon;
-                const lat = y * cellDegreeSize + curMinLat;
-                const [id, cell] = getOrCreateCell(this.cells, cellDegreeSize, lon, lon + cellDegreeSize, lat, lat + cellDegreeSize);
-                cells.push(cell);
-                if (cells.length >= MAX_CELLS) {
-                    break;
+        if (expandSources == null || expandSources == undefined) {
+            expandSources = this.expandSources;
+        }
+        if (historic === this.historic && expandSources === this.expandSources) {
+            return;
+        }
+        this.historic = historic;
+        this.expandSources = expandSources;
+        if (this.historic) {
+            // 4 ticks per second.
+            // The fastest data we are working with is 5 times per second.
+            let tickDelay = new DelayQueue(() => {
+                this.onTick(false);
+            }, 250, true);
+            this.hDisposals.push(() => {
+                if (tickDelay) {
+                    tickDelay.Dispose();
+                }
+                tickDelay = null;
+            });
+            // React to clock changes and request new Entities.
+            this.hDisposals.push(this.viewer.clock.onTick.addEventListener(() => {
+                if (tickDelay) {
+                    tickDelay.Call();
                 }
-            }
-            return cells;
+            }));
+            // Since the timeline range can change even without it ticking we have to check it occasionally.
+            let rangeCheckInterval = setInterval(() => {
+                this.checkRange(false);
+            }, 800);
+            this.hDisposals.push(() => {
+                if (rangeCheckInterval) {
+                    clearInterval(rangeCheckInterval);
+                }
+                rangeCheckInterval = null;
+            });
         }
+        else {
+            this.hDisposals.forEach((d) => d());
+            this.hDisposals = [];
+        }
+        this.checkRange(true);
     }
-    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.04;
+    Empty() {
+        if (this.disposed) {
+            return;
+        }
+        this.eIdQueue = [];
+        this.allEIds.clear();
+        this.lastFoundDateTimes.clear();
+        this.lastDateTime = null;
     }
-    else if (height < 10000) {
-        return 0.15;
+    ReQueueAll() {
+        if (this.disposed) {
+            return;
+        }
+        this.eIdQueue = Array.from(this.allEIds);
     }
-    else if (height < 30000) {
-        return 0.5;
+    Queue(entityIds, topOfQueue = false) {
+        if (this.disposed || !(entityIds === null || entityIds === void 0 ? void 0 : entityIds.length)) {
+            return;
+        }
+        let changes = 0;
+        for (let i = 0; i < entityIds.length; i++) {
+            const eId = entityIds[i];
+            const index = this.eIdQueue.indexOf(eId);
+            if (topOfQueue) {
+                // If we want it to be at the top of the queue, remove it from the queue first.
+                if (index !== -1) {
+                    this.eIdQueue.splice(index, 1);
+                }
+                this.eIdQueue.unshift(eId);
+                changes += 1;
+            }
+            else if (index === -1) {
+                this.eIdQueue.push(eId);
+                changes += 1;
+            }
+            // Flag that we've seen this ID.
+            this.allEIds.add(entityIds[i]);
+        }
+        if (!changes) {
+            return;
+        }
+        this.onTick(false);
     }
-    else if (height < 70000) {
-        return 0.5;
+    Dispose() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        this.hDisposals.forEach((d) => d());
+        this.hDisposals = [];
     }
-    else if (height < 100000) {
-        return 1;
+    checkRange(force) {
+        const min = this.viewer.clock.startTime.toString();
+        const max = this.viewer.clock.stopTime.toString();
+        if (force || this.lastDateTimeMin !== min || this.lastDateTimeMax !== max) {
+            this.lastDateTimeMin = min;
+            this.lastDateTimeMax = max;
+            // Changed, so we can pretend it's a clock tick and request new Entities.
+            this.onTick(true);
+        }
     }
-    else if (height < 150000) {
-        return 1;
+    onTick(force) {
+        if (this.runningTick) {
+            return;
+        }
+        const rTime = this.viewer.clock.currentTime.toString();
+        if (!force && !this.eIdQueue.length && this.historic && this.lastDateTime === rTime) {
+            return;
+        }
+        this.lastDateTime = rTime;
+        (async () => {
+            this.runningTick = true;
+            let rerun = false;
+            try {
+                const handleResponse = async (entities) => {
+                    var _a, _b;
+                    if (!(entities === null || entities === void 0 ? void 0 : entities.length)) {
+                        return;
+                    }
+                    // Lazy substitution of the entity data overrides.
+                    if (this.entityDataOverrides.size) {
+                        for (let i = 0; i < entities.length; i++) {
+                            const entity = entities[i];
+                            const eId = entity.Bruce.ID;
+                            if (this.entityDataOverrides.has(eId)) {
+                                entities[i] = this.entityDataOverrides.get(eId);
+                            }
+                        }
+                    }
+                    // Gather all Tag IDs from found Entities.
+                    let tagIds = new Set();
+                    for (let i = 0; i < entities.length; i++) {
+                        const entity = entities[i];
+                        if ((_b = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a["Layer.ID"]) === null || _b === void 0 ? void 0 : _b.length) {
+                            const eTagIds = entity.Bruce["Layer.ID"];
+                            for (let j = 0; j < eTagIds.length; j++) {
+                                const tagId = eTagIds[j];
+                                if (tagId) {
+                                    tagIds.add(tagId);
+                                }
+                            }
+                        }
+                    }
+                    // Gather records.
+                    let tags = [];
+                    if (tagIds.size) {
+                        tags = (await EntityTag.GetListByIds({
+                            tagIds: Array.from(tagIds),
+                            api: this.api
+                        })).tags;
+                    }
+                    // 0 = rTime is still the current time.
+                    // 1 = rTime is in the future.
+                    // -1 = rTime is in the past.
+                    let changeDir = 0;
+                    if (this.lastDateTime !== this.viewer.clock.currentTime.toString()) {
+                        changeDir = this.lastDateTime < this.viewer.clock.currentTime.toString() ? 1 : -1;
+                    }
+                    let toEmit;
+                    if (this.historic) {
+                        // We can emit Entities if the last resolved time (per Entity) isn't newer than rTime.
+                        // We compare using the changeDir to determine if we should emit or not.
+                        toEmit = entities.filter((e) => {
+                            const lastFoundDateTime = this.lastFoundDateTimes.get(e.id);
+                            if (lastFoundDateTime) {
+                                if (changeDir === 1) {
+                                    return lastFoundDateTime <= rTime;
+                                }
+                                else if (changeDir === -1) {
+                                    return lastFoundDateTime >= rTime;
+                                }
+                            }
+                            return true;
+                        });
+                        // Update the last found date times for the filtered Entities.
+                        toEmit.forEach((e) => {
+                            this.lastFoundDateTimes.set(e.id, rTime);
+                        });
+                    }
+                    else {
+                        // If we're not historic, we can just emit everything.
+                        toEmit = entities;
+                    }
+                    this.emitEntities(toEmit, tags);
+                };
+                const QUEUE_BATCH_SIZE = 500;
+                const requestedIds = [];
+                // If we have a queue, we need to request those first.
+                if (this.eIdQueue.length) {
+                    const total = this.eIdQueue.length;
+                    let done = 0;
+                    while (this.eIdQueue.length && !this.disposed) {
+                        if (this.historic && this.lastDateTime !== rTime) {
+                            break;
+                        }
+                        const batch = this.eIdQueue.splice(0, QUEUE_BATCH_SIZE);
+                        const { entities } = await Entity$1.GetListByIds({
+                            entityIds: batch,
+                            historicPoint: this.historic ? rTime : null,
+                            expandSources: this.expandSources,
+                            api: this.api
+                        });
+                        handleResponse(entities);
+                        requestedIds.push(...batch);
+                        done += batch.length;
+                        if (this._onQueueProgress) {
+                            let progress = (done / total) * 100;
+                            if (progress > 100) {
+                                progress = 100;
+                            }
+                            if (progress < 0) {
+                                progress = 0;
+                            }
+                            this._onQueueProgress.Trigger(progress);
+                        }
+                    }
+                    if (this._onQueueProgress) {
+                        this._onQueueProgress.Trigger(100);
+                    }
+                }
+                // Now run through all IDs that we've seen and request them.
+                // We'll skip those that we just requested.
+                let allEIds = Array.from(this.allEIds);
+                if (requestedIds.length) {
+                    allEIds = allEIds.filter((eId) => requestedIds.indexOf(eId) === -1);
+                }
+                if (allEIds.length) {
+                    while (allEIds.length && !this.disposed && !this.eIdQueue.length) {
+                        if (this.historic && this.lastDateTime !== rTime) {
+                            break;
+                        }
+                        const batch = allEIds.splice(0, QUEUE_BATCH_SIZE);
+                        const { entities } = await Entity$1.GetListByIds({
+                            entityIds: batch,
+                            historicPoint: this.historic ? rTime : null,
+                            expandSources: this.expandSources,
+                            api: this.api
+                        });
+                        handleResponse(entities);
+                        requestedIds.push(...batch);
+                    }
+                }
+                // If we had leftovers because we stopped early, we need to re-run the tick.
+                if (this.eIdQueue.length || allEIds.length) {
+                    rerun = true;
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+            finally {
+                this.runningTick = false;
+            }
+            if (rerun) {
+                this.onTick(true);
+            }
+        })();
     }
-    else if (height < 200000) {
-        return 1.5;
-    }
-    else if (height < 300000) {
-        return 1.5;
-    }
-    else if (height < 500000) {
-        return 3;
-    }
-    else if (height < 1000000) {
-        return 3;
-    }
-    else if (height < 1200000) {
-        return 4;
-    }
-    else if (height < 2000000) {
-        return 6;
-    }
-    else if (height < 3000000) {
-        return 20;
-    }
-    return 35;
-}
-function isCellFetched(cell) {
-    if (cell.Fetched) {
-        return true;
-    }
-    return false;
-}
-function getOrCreateCell(cells, cellSize, lon, maxLon, lat, maxLat) {
-    const id = cellSize + "_" + lon + "_" + maxLon + "_" + lat + "_" + maxLat;
-    let cell = cells[id];
-    if (!cell) {
-        cell = cells[id] = new EntityGlobe.Cell();
-        cell.Boundaries = {
-            minLatitude: lat,
-            maxLatitude: maxLat,
-            minLongitude: lon,
-            maxLongitude: maxLon
-        };
-        cell.IsFetched = () => isCellFetched(cell);
-    }
-    return [id, cell];
 }
 
-const MAX_AREA_IN_DEGREES$1 = 90;
-const MAX_RETRY_ATTEMPTS = 1;
-const RETRY_DELAY_INCREMENT = 500;
-const REQUEST_PAGE_DELAY = 50;
-class regMenuItemGetter {
-    constructor(typeId, tagIds, minHeight, maxHeight) {
-        this.TypeId = typeId;
-        this.TagIds = tagIds;
-        this.MinHeight = minHeight;
-        this.MaxHeight = maxHeight;
+// ND-1641. BOOKMARKS - (DEMO) View does not match bookmark.
+// We have some evil hard-coded style mappings that need to be fixed.
+// These exist within legacy project views.
+function correctStyle(style) {
+    if (style && !style.Settings && !style.ID) {
+        return {
+            ID: -1,
+            Name: "Unknown",
+            Settings: {
+                ...style
+            },
+            Type: Style.EType.Entity
+        };
     }
+    return style;
 }
-async function delay(milliseconds) {
-    return new Promise((res) => {
-        setTimeout(() => {
-            res();
-        }, milliseconds);
-    });
+function colorToCColor$3(color) {
+    return new Color(color.red ? color.red / 255 : 0, color.green ? color.green / 255 : 0, color.blue ? color.blue / 255 : 0, color.alpha);
 }
-/**
- * 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) {
-    let EStatus;
-    (function (EStatus) {
-        EStatus["Scanning"] = "SCANNING";
-        EStatus["Loading"] = "LOADING";
-    })(EStatus = EntityFilterGetter.EStatus || (EntityFilterGetter.EStatus = {}));
-    class Getter {
-        get OnUpdate() {
-            if (!this.onUpdate) {
-                this.onUpdate = new BruceEvent();
-            }
-            return this.onUpdate;
+class TilesetStyler {
+    constructor() {
+        this.disposed = false;
+        // Indicates if the styler has been loaded/initialized and is ready to style.
+        this.loaded = false;
+        // Indicates that all mappings have been loaded.
+        this.styleMappingLoaded = false;
+        // Map of Entity Type ID -> boolean to indicate if the style mapping has been loaded.
+        this.styleMappingsLoaded = new Map();
+        // Dictionary of Entity Type ID -> Set of Entity IDs that are pending styling.
+        // Once the style is loaded, we can queue the set for styling.
+        this.stylePendingEntityIds = new Map();
+        this.fallbackStyle = null;
+        this.loadingCounter = 0;
+        // Entity IDs -> boolean to indicate if we should override the feature colour.
+        this.overrideFeatureColor = new Map();
+        this.scenario = 0;
+        // Indicates that we should expand the sources of the Entity.
+        this.expandSources = false;
+        // Indicates that we are retrieving historic records.
+        // This means that the current scene's time is included in the request.
+        this.historic = false;
+        // More expensive process.
+        // When an Entity is styled, the rego is reviewed and updated if needed.
+        // This is currently used for scenarios, and off by default to keep other processes faster.
+        this.shouldUpdateRegoStates = false;
+        // Entity ID -> styled status.
+        // Helps us emit progress events.
+        this.styledEntityIds = new Map();
+        // % progress for how many Entities have been styled so far.
+        // This can change as Tiles load in and more queue.
+        this._styleProgress = 0;
+        this._styleProgressQueue = new DelayQueue(() => {
+            this.updateStyleProgress();
+        }, 250);
+        // Event for when the style progress changes.
+        this.OnStyleProgress = new BruceEvent();
+    }
+    get Disposed() {
+        return this.disposed;
+    }
+    get Loaded() {
+        return this.loaded;
+    }
+    get StyleProgress() {
+        return this._styleProgress;
+    }
+    Init(params) {
+        var _a;
+        let { viewer, api, cTileset, fallbackStyleId, styleMapping, expandSources, menuItemId, register, scenario, historic } = params;
+        this.viewer = viewer;
+        this.api = api;
+        this.cTileset = cTileset;
+        this.register = register;
+        this.menuItemId = menuItemId;
+        this.historic = Boolean(historic);
+        if (expandSources != null) {
+            this.expandSources = expandSources;
         }
-        get OnStateUpdate() {
-            if (!this.onStateUpdate) {
-                this.onStateUpdate = new BruceEvent();
-            }
-            return this.onStateUpdate;
+        if (fallbackStyleId != null) {
+            this.fallbackStyleId = fallbackStyleId;
         }
-        get OnScanUpdate() {
-            if (!this.onScanUpdate) {
-                this.onScanUpdate = new BruceEvent();
+        if (styleMapping) {
+            this.styleMapping = styleMapping;
+            if (this.styleMapping) {
+                // Dereference.
+                this.styleMapping = JSON.parse(JSON.stringify(this.styleMapping));
+            }
+            // ND-1641. BOOKMARKS - (DEMO) View does not match bookmark.
+            // We have some evil hard-coded style mappings that need to be fixed.
+            // These exist within legacy project views.
+            // Update: This now also lets people have a style mapping without a real style record.
+            if ((_a = this.styleMapping) === null || _a === void 0 ? void 0 : _a.length) {
+                for (let i = 0; i < this.styleMapping.length; i++) {
+                    const mapItem = this.styleMapping[i];
+                    const mapStyle = mapItem.style ? mapItem.style : mapItem.Style;
+                    this.styleMapping[i].style = correctStyle(mapStyle);
+                }
             }
-            return this.onScanUpdate;
         }
-        get isLooping() {
-            return this.looping > 0;
+        if (scenario != null) {
+            this.scenario = scenario;
         }
-        constructor(params) {
-            this.onUpdate = null;
-            this.LastStateUpdates = {};
-            this.onStateUpdate = null;
-            this.onScanUpdate = null;
-            this.viewPortChangeRemoval = null;
-            this.viewPortDelayQueue = null;
-            this.viewerDateTimeChangeRemoval = null;
-            this.cells = null;
-            this.registeredItems = {};
-            this.getterLoopId = 0;
-            this.getterLoopAbortControllers = {};
-            this.looping = 0;
-            this.tagIds = null;
-            this.minHeight = 0;
-            this.maxHeight = 100000;
-            this.viewRect = null;
-            this.viewCenter = null;
-            this.scenario = 0;
-            this.historicRefreshAbortController = null;
-            // Entity IDs found for the latest integrity.
-            // 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;
-            this.api = api;
-            this.typeIds = typeIds;
-            this.schemaId = schemaId;
-            this.historic = Boolean(historic);
-            this.historicAttrKey = historicAttrKey;
-            this.historicInterpolation = Boolean(historicInterpolation);
-            this.viaCdn = Boolean(viaCdn);
-            this.batchSize = isNaN(batchSize) ? 300 : batchSize;
-            this.viewPort = viewPort;
-            this.attrFilter = attrFilter;
-            this.viewer = viewer;
-            this.scenario = scenario ? scenario : 0;
-            this.updateBounds();
+        if (!!scenario) {
+            this.shouldUpdateRegoStates = 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
-         */
-        getIntegrityId() {
-            let integrity = this.tagIds == null ? "" : this.tagIds.join();
-            if (this.historicAttrKey) {
-                integrity += "isHistoric";
-                integrity += this.historicAttrKey;
+        else if (this.historic) {
+            this.shouldUpdateRegoStates = true;
+        }
+        this.entityGatherer = new EntityGatherer(this.api, this.viewer, (entities, tags) => {
+            if (!(entities === null || entities === void 0 ? void 0 : entities.length)) {
+                return;
             }
-            else if (this.historic) {
-                integrity += "isHistoric";
+            for (let i = 0; i < entities.length; i++) {
+                const entity = entities[i];
+                const feature = this.getEntityRego(entity.Bruce.ID);
+                if (feature) {
+                    const eTags = tags.filter(t => { var _a, _b, _c, _d; return ((_b = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a["Layer.ID"]) === null || _b === void 0 ? void 0 : _b.length) && ((_d = (_c = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _c === void 0 ? void 0 : _c["Layer.ID"]) === null || _d === void 0 ? void 0 : _d.includes(t.ID)); });
+                    this.styleTilesetFeatureFullData(feature, entity, eTags);
+                }
             }
-            if (this.scenario) {
-                integrity += this.scenario;
+        });
+        this.loaded = true;
+        this.loadStyles();
+    }
+    /**
+     * Updates style mapping and fallback style.
+     * This will trigger a re-style of all entities, and will stop existing style loads.
+     * @param params
+     */
+    UpdateStyleMapping(params) {
+        var _a;
+        if (params.styleMapping) {
+            // Dereference.
+            params.styleMapping = JSON.parse(JSON.stringify(params.styleMapping));
+            this.styleMapping = params.styleMapping;
+            // ND-1641. BOOKMARKS - (DEMO) View does not match bookmark.
+            // We have some evil hard-coded style mappings that need to be fixed.
+            // These exist within legacy project views.
+            // Update: This now also lets people have a style mapping without a real style record.
+            if ((_a = this.styleMapping) === null || _a === void 0 ? void 0 : _a.length) {
+                for (let i = 0; i < this.styleMapping.length; i++) {
+                    const mapItem = this.styleMapping[i];
+                    const mapStyle = mapItem.style ? mapItem.style : mapItem.Style;
+                    this.styleMapping[i].style = correctStyle(mapStyle);
+                }
             }
-            if (this.typeIds) {
-                integrity += this.typeIds.join();
+        }
+        if (!isNaN(params.fallbackStyleId) && params.fallbackStyleId != null) {
+            this.fallbackStyleId = params.fallbackStyleId;
+        }
+        if (params.fallbackStyle) {
+            this.fallbackStyle = params.fallbackStyle;
+        }
+        else {
+            this.fallbackStyle = null;
+        }
+        if (params.scenario != null) {
+            this.scenario = params.scenario;
+            if (!this.shouldUpdateRegoStates && !!this.scenario) {
+                this.shouldUpdateRegoStates = true;
             }
-            return integrity;
         }
-        viewAreaSub() {
-            this.viewAreaDispose();
-            // We'll avoid restarting the scanner too often.
-            this.viewPortDelayQueue = new DelayQueue(() => {
-                this.updateBounds();
-                this.startGetterLoop();
-            }, 2000);
-            this.viewPortChangeRemoval = this.viewPort.Updated().Subscribe(() => {
-                var _a;
-                (_a = this.viewPortDelayQueue) === null || _a === void 0 ? void 0 : _a.Call();
+        if (params.historic != null) {
+            this.historic = params.historic;
+            if (params.historic || this.historic != params.historic) {
+                this.shouldUpdateRegoStates = true;
+            }
+        }
+        // Reload styles.
+        if (this.loaded) {
+            this.styledEntityIds.clear();
+            this.styleMappingsLoaded.clear();
+            this.loadStyles();
+            this._styleProgressQueue.Call(true);
+            // Putting all rendered things back into the queue.
+            const regos = this.register.GetRegos({
+                menuItemId: this.menuItemId
             });
+            this.QueueEntities(regos);
         }
-        viewAreaDispose() {
-            var _a, _b;
-            (_a = this.viewPortChangeRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
-            this.viewPortChangeRemoval = null;
-            (_b = this.viewPortDelayQueue) === null || _b === void 0 ? void 0 : _b.Dispose();
-            this.viewPortDelayQueue = null;
+    }
+    /**
+     * Updates a cache of Entity objects to use when styling.
+     * When a cache is available, a request won't be performed to get that Entity's data.
+     * @param entityIds
+     * @param entities If an object is not available for a supplied Entity ID, then the cache for it is removed.
+     */
+    SetEntityCache(entityIds, entities) {
+        // Turn the Entities array into an accessible dictionary.
+        const newDataMap = new Map();
+        if (entities) {
+            for (let i = 0; i < entities.length; i++) {
+                const entity = entities[i];
+                if (entity.Bruce) {
+                    newDataMap.set(entity.Bruce.ID, entity);
+                }
+            }
         }
-        /**
-         * Monitors the Cesium viewer and updates the historic data filter values.
-         * If there is no historic attr set, this will do nothing.
-         */
-        viewerDateTimeSub() {
-            if ((!this.historicAttrKey && !this.historic) || this.viewerDateTimeChangeRemoval) {
-                return;
+        // Update the cache for each supplied Entity ID.
+        for (let i = 0; i < entityIds.length; i++) {
+            const entityId = entityIds[i];
+            this.entityGatherer.SetEntityDataOverride(entityId, newDataMap.get(entityId));
+        }
+    }
+    QueueEntities(regos, highPriority = false) {
+        if (!this.loaded) {
+            // Mark as pending?
+            return;
+        }
+        for (let i = 0; i < regos.length; i++) {
+            const rego = regos[i];
+            this.overrideFeatureColor.set(rego.entityId, true);
+            // We set a default colour right away to avoid race conditions at later times.
+            CesiumEntityStyler.BakeDefaultColor({
+                entity: rego.visual,
+                viewer: this.viewer,
+                override: false
+            });
+        }
+        this.queueTilesetFeatureStyle(regos, highPriority);
+    }
+    /**
+     * Calculates the current progress % and updates the progress if there is a change.
+     */
+    updateStyleProgress() {
+        if (this.disposed) {
+            return;
+        }
+        const total = this.overrideFeatureColor.size;
+        const styled = this.styledEntityIds.size;
+        let progress = 100;
+        if (styled < total) {
+            progress = Math.round((styled / total) * 100);
+            if (progress < 0) {
+                progress = 0;
             }
-            // This is multiplied by the speed of animation to figure
-            // out how many animation "ticks" before we allow an update.
-            let INTERVAL_WHILE_ANIMATING = 2.5 * 1000;
-            let INTERVAL_WHILE_NOT_ANIMATING = 1000;
-            if (this.historicInterpolation) {
-                INTERVAL_WHILE_ANIMATING = 6 * 1000;
-                INTERVAL_WHILE_NOT_ANIMATING = 3.5 * 1000;
+            else if (progress > 100) {
+                progress = 100;
             }
-            let lastUpdateTime = null;
-            let delayQueue = new DelayQueue(() => {
-                try {
-                    // If the timeline is animating then we'll wait longer to update.
-                    if (this.viewer.clock.shouldAnimate && lastUpdateTime) {
-                        if (Math.abs(new Date().getTime() - lastUpdateTime) < INTERVAL_WHILE_ANIMATING) {
-                            return;
-                        }
-                    }
-                    const current = this.historicAttrDateTime;
-                    this.updateHistoricDateTime();
-                    if (current != this.historicAttrDateTime) {
-                        this.emitHistoricData();
-                    }
-                }
-                catch (e) {
-                    console.error(e);
-                }
-            }, INTERVAL_WHILE_NOT_ANIMATING);
-            let postUpdateRemoval = this.viewer.scene.postUpdate.addEventListener(() => {
-                if (delayQueue) {
-                    delayQueue.Call();
-                }
-            });
-            this.viewerDateTimeChangeRemoval = () => {
-                delayQueue === null || delayQueue === void 0 ? void 0 : delayQueue.Dispose();
-                postUpdateRemoval === null || postUpdateRemoval === void 0 ? void 0 : postUpdateRemoval();
-                delayQueue = null;
-                postUpdateRemoval = null;
-            };
         }
-        updateHistoricDateTime() {
-            if (!this.historicAttrKey && !this.historic) {
-                this.historicAttrDateTime = null;
-                return;
+        if (this._styleProgress != progress) {
+            this._styleProgress = progress;
+            this.OnStyleProgress.Trigger(progress);
+        }
+    }
+    getEntityRego(entityId) {
+        return this.register.GetRego({
+            entityId,
+            menuItemId: this.menuItemId
+        });
+    }
+    Dispose() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        this._styleProgressQueue.Dispose();
+        this.disposeGatherer();
+    }
+    async loadStyles() {
+        var _a, _b;
+        const counter = ++this.loadingCounter;
+        this.styleMappingLoaded = false;
+        this.styleMappingsLoaded.clear();
+        // Apply state changes.
+        this.entityGatherer.Empty();
+        this.entityGatherer.Init(this.historic, this.expandSources);
+        let fallbackStyleId = this.fallbackStyleId;
+        if (fallbackStyleId && fallbackStyleId > 0) {
+            try {
+                let { style: data } = await Style.Get({
+                    api: this.api,
+                    styleId: fallbackStyleId
+                });
+                this.fallbackStyle = data;
             }
-            const isChanged = (before, after) => {
-                if (before && !after) {
-                    return true;
-                }
-                if (!before && after) {
-                    return true;
-                }
-                // Change must be at least 0.1 seconds.
-                return Math.abs(before.getTime() - after.getTime()) > 100;
-            };
-            const oldDateTime = this.historicAttrDateTime ? new Date(this.historicAttrDateTime) : null;
-            const newDateTime = JulianDate.toDate(this.viewer.clock.currentTime);
-            if (isChanged(oldDateTime, newDateTime)) {
-                this.historicAttrDateTime = newDateTime.toISOString();
+            catch (e) {
+                console.error(e);
             }
         }
-        viewerDateTimeDispose() {
-            var _a;
-            (_a = this.viewerDateTimeChangeRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
-            this.viewerDateTimeChangeRemoval = null;
+        if (this.loadingCounter != counter) {
+            return;
         }
-        GetMenuItems() {
-            return Object.keys(this.registeredItems);
+        // Load styles in the style mapping
+        let styleMapping = this.styleMapping;
+        if (!styleMapping) {
+            styleMapping = [];
         }
-        IncludeMenuItem(menuItemId, typeId, layerIds, minHeight, maxHeight) {
-            this.registeredItems[menuItemId] = new regMenuItemGetter(typeId, layerIds, minHeight, maxHeight);
-            this.updateState();
+        this.styleMapping = styleMapping;
+        // Append all found entity-types.
+        // That way we can mark them as loaded instead of just the ones in the style mapping.
+        try {
+            const modelTree = (_b = (_a = this.cTileset) === null || _a === void 0 ? void 0 : _a.extensions) === null || _b === void 0 ? void 0 : _b.modelTree;
+            if (modelTree) {
+                const entityTypeIds = this.getEntityTypeIdsFromModelTree(modelTree);
+                for (let i = 0; i < entityTypeIds.length; i++) {
+                    const entityTypeId = entityTypeIds[i];
+                    if (styleMapping.findIndex(x => x.EntityTypeID == entityTypeId) <= -1) {
+                        styleMapping.push({
+                            EntityTypeID: entityTypeId,
+                            StyleID: this.fallbackStyle ? fallbackStyleId : 0,
+                            style: this.fallbackStyle
+                        });
+                    }
+                }
+            }
         }
-        ExcludeMenuItem(menuItemId) {
-            this.registeredItems[menuItemId] = null;
-            delete this.registeredItems[menuItemId];
-            this.updateState(true);
+        catch (e) {
+            console.error(e);
         }
-        updateBounds() {
-            const viewRect = this.viewPort.GetBounds();
-            const poi = this.viewPort.GetTarget();
-            if (viewRect && poi) {
-                if (Math.abs(viewRect.west - viewRect.east) > MAX_AREA_IN_DEGREES$1) {
-                    return;
-                }
-                if (Math.abs(viewRect.south - viewRect.north) > MAX_AREA_IN_DEGREES$1) {
-                    return;
+        // Before we start the loop we'll do a single request for the needed Entity Types.
+        // This will be aimed at rows that don't specify a Style and if the default fallback-
+        //is set to 0 (using the default of the Entity Type).
+        const typeMap = new Map();
+        const typeIds = styleMapping.map(x => x.StyleID == -1 || Boolean(x.style) ? null : x.EntityTypeID).filter(x => !!x);
+        if (typeIds.length) {
+            // We'll split up into batches of 50.
+            // Since we add the type IDs as query params I am paranoid of hitting the limit.
+            const splits = Math.ceil(typeIds.length / 50);
+            const batchSize = 50;
+            for (let i = 0; i < splits; i++) {
+                const batch = typeIds.slice(i * batchSize, (i + 1) * batchSize);
+                const { entityTypes } = await EntityType.GetList({
+                    api: this.api,
+                    entityTypeIds: batch
+                });
+                for (let i = 0; i < entityTypes.length; i++) {
+                    const entityType = entityTypes[i];
+                    typeMap.set(entityType.ID, entityType);
                 }
-                this.viewRect = viewRect;
-                this.viewCenter = poi;
             }
         }
-        updateState(onlyIfLooping = false) {
-            const tagIds = [];
-            const typeIds = [];
-            const menuItemIds = this.GetMenuItems();
-            let minHeight = null;
-            let maxHeight = null;
-            for (let i = 0; i < menuItemIds.length; i++) {
-                const menuItem = this.registeredItems[menuItemIds[i]];
-                if (menuItem) {
-                    if (maxHeight == null || maxHeight < menuItem.MaxHeight) {
-                        maxHeight = menuItem.MaxHeight;
+        for (let i = 0; i < styleMapping.length; i++) {
+            if (this.disposed) {
+                break;
+            }
+            let styleMap = styleMapping[i];
+            if (!styleMap.style && styleMap.StyleID != -1) {
+                let styleId = styleMap.StyleID;
+                // Get default style of the entity type, if
+                //no default is already specified.
+                if (!styleId && !this.fallbackStyle) {
+                    try {
+                        let entityType = typeMap.get(styleMap.EntityTypeID);
+                        // If the map excluded the type for whatever reason we'll load it now.
+                        if (!entityType) {
+                            entityType = (await EntityType.Get({
+                                api: this.api,
+                                entityTypeId: styleMap.EntityTypeID
+                            })).entityType;
+                        }
+                        styleId = entityType === null || entityType === void 0 ? void 0 : entityType["DisplaySetting.ID"];
                     }
-                    if (minHeight == null || minHeight > menuItem.MinHeight) {
-                        minHeight = menuItem.MinHeight;
+                    catch (e) {
+                        console.error(e);
                     }
-                    const itemLayerIds = menuItem.TagIds;
-                    if (itemLayerIds) {
-                        for (let j = 0; j < itemLayerIds.length; j++) {
-                            const itemLayerId = itemLayerIds[j];
-                            if (!tagIds.includes(itemLayerId)) {
-                                tagIds.push(itemLayerId);
-                            }
+                }
+                if (styleId) {
+                    try {
+                        let { style: data } = await Style.Get({
+                            api: this.api,
+                            styleId
+                        });
+                        if (data) {
+                            styleMap.style = data;
+                            styleMap.StyleID = styleId;
                         }
                     }
-                    const itemTypeId = menuItem.TypeId;
-                    if (itemTypeId) {
-                        if (!typeIds.includes(itemTypeId)) {
-                            typeIds.push(itemTypeId);
-                        }
+                    catch (e) {
+                        console.error(e);
                     }
                 }
+                if (this.loadingCounter != counter) {
+                    return;
+                }
             }
-            if (menuItemIds.length > 0 && (!onlyIfLooping || this.isLooping)) {
-                // Reset cells so none are marked as fetched.
-                this.cells = new EntityGlobe.Grid();
-                this.tagIds = tagIds;
-                this.typeIds = typeIds;
-                this.minHeight = minHeight;
-                this.maxHeight = maxHeight;
-                this.updateBounds();
-                this.updateHistoricDateTime();
-                this.startGetterLoop();
-                this.viewAreaSub();
-                this.viewerDateTimeSub();
+            this.styleMappingsLoaded.set(styleMap.EntityTypeID, true);
+            if (this.loaded) {
+                // If we have a bunch of Entities that were waiting for the style to load,
+                // then we can pass them to the gatherer now.
+                const relatedIds = this.stylePendingEntityIds.get(styleMap.EntityTypeID);
+                if (relatedIds) {
+                    this.entityGatherer.Queue(Array.from(relatedIds));
+                    this.stylePendingEntityIds.delete(styleMap.EntityTypeID);
+                }
             }
-            else {
-                this.getterLoopId += 1;
-                this.viewAreaDispose();
-                this.viewerDateTimeDispose();
+        }
+        if (this.loadingCounter != counter) {
+            return;
+        }
+        this.styleMappingLoaded = true;
+        if (!this.disposed && this.loaded) {
+            if (this.loadingCounter != counter) {
+                return;
+            }
+            // Queue all Entities that are pending styling.
+            const pendingKeys = this.stylePendingEntityIds.keys();
+            for (const key of pendingKeys) {
+                const relatedIds = this.stylePendingEntityIds[key];
+                if (relatedIds) {
+                    this.entityGatherer.Queue(Array.from(relatedIds));
+                }
             }
+            this.stylePendingEntityIds.clear();
         }
-        postStatus(status) {
-            var _a;
-            this.LastStateUpdates[status.msg] = status;
-            (_a = this.onStateUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(status);
+    }
+    disposeGatherer() {
+        if (this.entityGatherer) {
+            this.entityGatherer.Dispose();
+            this.entityGatherer = null;
         }
-        startGetterLoop() {
-            // Increase id so that existing loops stop.
-            this.getterLoopId += 1;
-            const loopId = this.getterLoopId;
-            const loopIntegrity = this.getIntegrityId();
-            // Abort any existing loops that don't match the current loop.
-            // We tried using integrity, however we want to interrupt when user moves camera quickly.
-            // So it's better to use the loop ID.
-            const abortId = String(loopId);
-            {
-                const newAbortControllers = {};
-                for (const key in this.getterLoopAbortControllers) {
-                    this.getterLoopAbortControllers[key].abort();
+    }
+    getEntityTypeIdsFromModelTree(modelTree) {
+        const entityTypeIds = [];
+        this.digEntityTypeIdsFromModelTreeBranch(modelTree, entityTypeIds);
+        return entityTypeIds;
+    }
+    digEntityTypeIdsFromModelTreeBranch(branch, arr) {
+        if (branch) {
+            // Does not yet include this entity type id.
+            if (branch.typeId && !arr.includes(branch.typeId)) {
+                arr.push(branch.typeId);
+            }
+            if (branch.children) {
+                for (let i = 0; i < branch.children.length; i++) {
+                    let child = branch.children[i];
+                    this.digEntityTypeIdsFromModelTreeBranch(child, arr);
                 }
-                this.getterLoopAbortControllers = newAbortControllers;
             }
-            const abortController = this.getterLoopAbortControllers[abortId] = new AbortController();
-            this.looping += 1;
-            (async () => {
-                var _a, _b, _c, _d, _e, _f, _g, _h;
-                // Larger initial delay for the first loops because terrain is likely loading in.
-                // We also delay because if we enable 50 Menu Items at the same time, common requests we be made if we wait a bit.
-                // Eg: same entity type will be grouped into the same filter getter instance.
-                await delay(loopId <= 3 ? 800 : 300);
-                const MIN_HEIGHT = this.minHeight;
-                const MAX_HEIGHT = this.maxHeight;
-                const PAGE_SIZE = this.batchSize;
-                let retryAttempts = MAX_RETRY_ATTEMPTS;
-                let retryDelay = 0;
-                let prevFirstId = "";
-                let prevLastId = "";
-                let prevTicks = 0;
-                while ((!this.viewCenter || !this.viewRect) && this.getterLoopId == loopId) {
-                    await delay(RETRY_DELAY_INCREMENT);
+        }
+    }
+    queueTilesetFeatureStyle(entities, highPriority) {
+        const needsDataIds = [];
+        for (const rego of entities) {
+            if (!this.overrideFeatureColor.has(rego.entityId)) {
+                this.overrideFeatureColor.set(rego.entityId, false);
+            }
+            const typeId = rego.entityTypeId || "";
+            if (this.styleMappingLoaded || this.styleMappingsLoaded.get(typeId)) {
+                if (this.getTilesetFeatureNeedsFullData(typeId)) {
+                    needsDataIds.push(rego.entityId);
                 }
-                if (this.getterLoopId != loopId) {
-                    return;
+                else {
+                    this.styleTilesetFeature(rego);
                 }
-                const alt = this.viewRect.alt;
-                if (alt > MAX_HEIGHT || (alt < MIN_HEIGHT && MIN_HEIGHT > 0)) {
-                    return;
+            }
+            else {
+                if (!this.stylePendingEntityIds.has(typeId)) {
+                    this.stylePendingEntityIds.set(typeId, new Set());
                 }
-                const cells = this.cells.GetCellsForView(this.viewCenter, this.viewRect);
-                (_a = this.onScanUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(cells);
-                let curCellIndex = cells.length > 0 ? 0 : null;
-                let postedScanning = false;
-                let postedLoading = false;
-                let total = 0;
-                while (retryAttempts > 0 && curCellIndex != null) {
-                    if (retryDelay > 0) {
-                        await delay(retryDelay);
-                    }
-                    if (this.getterLoopId != loopId) {
-                        break;
-                    }
-                    if (!postedScanning) {
-                        this.postStatus({ msg: EStatus.Scanning, revoking: false });
-                        postedScanning = true;
-                    }
-                    const curCell = cells[curCellIndex];
-                    if (curCell.IsFetched()) {
-                        curCell.Fetching = false;
-                        curCellIndex += 1;
-                        if (cells[curCellIndex]) {
-                            cells[curCellIndex].Fetching = true;
-                        }
-                        else {
-                            curCellIndex = null;
-                        }
-                        (_b = this.onScanUpdate) === null || _b === void 0 ? void 0 : _b.Trigger(cells);
-                        continue;
-                    }
-                    try {
-                        let response = {
-                            entities: [],
-                            nextPage: false,
-                            nextPageUrl: null
-                        };
-                        await SharedGetters.Queue.Run("Loading Entities from Menu Item that loads Entity Type: " + this.typeIds, async () => {
-                            var _a;
-                            if (abortController.signal.aborted || !((_a = this.GetMenuItems()) === null || _a === void 0 ? void 0 : _a.length)) {
-                                return;
-                            }
-                            // API gave us a URL to use.
-                            if (curCell.FetchURL) {
-                                const tmpResponse = await this.api.get(curCell.FetchURL, {
-                                    abortSignal: abortController.signal,
-                                    noCache: true
-                                });
-                                // Same mapping as bruce-models doing Entity.GetList.
-                                response = {
-                                    entities: tmpResponse.Items ? tmpResponse.Items : [],
-                                    nextPage: tmpResponse.NextPage,
-                                    nextPageUrl: tmpResponse.NextPageURL
-                                };
-                            }
-                            else {
-                                response = await Entity$1.GetList({
-                                    api: this.api,
-                                    scenario: this.scenario,
-                                    historicKey: this.historicAttrKey,
-                                    historicPoint: (this.historicAttrKey || this.historic) ? this.historicAttrDateTime : null,
-                                    schemaId: this.schemaId,
-                                    filter: {
-                                        pageSize: PAGE_SIZE,
-                                        pageIndex: curCell.FetchPageIndex,
-                                        entityTypeId: this.typeIds,
-                                        layerIds: this.tagIds,
-                                        // Any tag specified will be allowed.
-                                        layerIdsOperator: "in",
-                                        bounds: curCell.GetBounds(),
-                                        sortOrder: Api.ESortOrder.Asc,
-                                        entityTypeConditions: this.attrFilter
-                                    },
-                                    viaCdn: this.viaCdn,
-                                    migrated: true,
-                                    // If we're taking 2+ minutes to make a query, it's a dud.
-                                    // This is a timeout imposed on our DB and not external sources.
-                                    // Honestly could lower down to 30 seconds, but we'll keep it high for now.
-                                    maxSearchTimeSec: 60 * 2,
-                                    req: {
-                                        // If we are passing in an abort, we MUST pass in noCache.
-                                        // Otherwise we will cache an aborted request.
-                                        noCache: true,
-                                        abortSignal: abortController.signal
-                                    }
-                                });
-                            }
-                        });
-                        const entities = response.entities;
-                        const integrity = this.getIntegrityId();
-                        if (loopIntegrity == integrity && entities) {
-                            (_c = this.onUpdate) === null || _c === void 0 ? void 0 : _c.Trigger(entities);
-                        }
-                        if (this.gatheredIntegrity != integrity) {
-                            this.gatheredIntegrity = integrity;
-                            this.gatheredEntityIds = [];
-                        }
-                        // Add to the integrity list for any new IDs found.
-                        // This lets us keep track of all IDs we've found within the same integrity for historic data.
-                        if (this.historicAttrKey || this.historic) {
-                            for (let i = 0; i < entities.length; i++) {
-                                const entity = entities[i];
-                                if (!this.gatheredEntityIds.includes(entity.Bruce.ID)) {
-                                    this.gatheredEntityIds.push(entity.Bruce.ID);
-                                }
-                            }
-                        }
-                        if (this.getterLoopId != loopId) {
-                            break;
-                        }
-                        if (entities.length) {
-                            total += entities.length;
-                        }
-                        if (!postedLoading) {
-                            this.postStatus({ msg: EStatus.Loading, revoking: false });
-                            postedLoading = true;
-                        }
-                        // Only mark as fetched when ALL pages are done.
-                        // Known issue where external sources may return less than page size.
-                        // Right now we're making it as fetched as we're siding with the majority use-case.
-                        if (
-                        // API explicity says no more pages.
-                        response.nextPage === false ||
-                            // API didn't explicity say anything so we guess based on size of response.
-                            (response.nextPage == null &&
-                                (entities.length <= 0 || entities.length < PAGE_SIZE))) {
-                            curCell.Fetched = true;
-                            curCell.Fetching = false;
-                            (_d = this.onScanUpdate) === null || _d === void 0 ? void 0 : _d.Trigger(cells);
-                            continue;
-                        }
-                        // Checking to make sure it's not just the same batch over and over again.
-                        if (entities.length > 0) {
-                            const first = (_f = (_e = entities[0]) === null || _e === void 0 ? void 0 : _e.Bruce) === null || _f === void 0 ? void 0 : _f.ID;
-                            const last = (_h = (_g = entities[entities.length - 1]) === null || _g === void 0 ? void 0 : _g.Bruce) === null || _h === void 0 ? void 0 : _h.ID;
-                            if (prevFirstId == first && prevLastId == last) {
-                                prevTicks += 1;
-                                if (prevTicks > 3) {
-                                    break;
-                                }
-                            }
-                            else {
-                                prevFirstId = first;
-                                prevLastId = last;
-                                prevTicks = 0;
-                            }
-                        }
-                        // Using URL if specified.
-                        // If not then we'll just manually paginate.
-                        curCell.FetchURL = response.nextPageUrl;
-                        curCell.FetchPageIndex++;
-                        // Request passed so let's assume it was server hiccup and refresh counts.
-                        retryAttempts = MAX_RETRY_ATTEMPTS;
-                        retryDelay = 0;
-                    }
-                    catch (e) {
-                        // Ignore abort errors.
-                        if (e && typeof e === "object" && e.name == "AbortError") {
-                            // console.debug("Aborted entity-filter-getter request.");
-                            break;
-                        }
-                        console.error(e);
-                        if (this.getterLoopId != loopId) {
-                            break;
-                        }
-                        // Request failed so let's add a delay and try again soon.
-                        retryDelay += RETRY_DELAY_INCREMENT;
-                        retryAttempts -= 1;
-                    }
-                    await delay(REQUEST_PAGE_DELAY);
-                }
-                if (postedLoading) {
-                    this.postStatus({ msg: EStatus.Loading, revoking: true });
-                }
-                if (postedScanning) {
-                    this.postStatus({ msg: EStatus.Scanning, revoking: true });
-                }
-            })().then(() => {
-                this.looping -= 1;
-            }).catch(() => {
-                this.looping -= 1;
-            });
-        }
-        /**
-         * Gets the historic state of found Entities for the current date times and emits them.
-         * Since geometry searches are tied to the base Entity, we don't have to re-scan the viewport.
-         */
-        emitHistoricData() {
-            if (!this.GetMenuItems().length) {
-                return;
-            }
-            let integrity = this.getIntegrityId();
-            // Gathered ID does't match current one.
-            if (this.gatheredIntegrity != integrity) {
-                return;
+                this.stylePendingEntityIds.get(typeId).add(rego.entityId);
             }
-            const historicAttrDateTime = this.historicAttrDateTime;
-            const SCAN_BATCH_SIZE = 1000;
-            if (this.historicRefreshAbortController) {
-                this.historicRefreshAbortController.abort();
-                this.historicRefreshAbortController = null;
-            }
-            (async () => {
-                var _a;
-                try {
-                    // Loop through all IDs we've found and get their historic records.
-                    for (let i = 0; i < this.gatheredEntityIds.length; i += SCAN_BATCH_SIZE) {
-                        let batch = this.gatheredEntityIds.slice(i, i + SCAN_BATCH_SIZE);
-                        if (!batch.length) {
-                            break;
-                        }
-                        // Controller we can use to abort the request when a new loop starts.
-                        const controller = this.historicRefreshAbortController = new AbortController();
-                        let entities = [];
-                        await SharedGetters.Queue.Run("Refreshing historic data in Menu Item that loads Entity Type: " + this.typeIds, async () => {
-                            var _a;
-                            if (controller.signal.aborted || !((_a = this.GetMenuItems()) === null || _a === void 0 ? void 0 : _a.length)) {
-                                return;
-                            }
-                            entities = (await Entity$1.GetList({
-                                api: this.api,
-                                scenario: this.scenario,
-                                historicKey: this.historicAttrKey,
-                                historicPoint: historicAttrDateTime,
-                                schemaId: this.schemaId,
-                                filter: {
-                                    pageSize: batch.length,
-                                    pageIndex: 0,
-                                    entityTypeId: this.typeIds,
-                                    layerIds: this.tagIds,
-                                    layerIdsOperator: "in",
-                                    sortOrder: Api.ESortOrder.Asc,
-                                    entityTypeConditions: {
-                                        "ID": {
-                                            "in": batch
-                                        }
-                                    },
-                                },
-                                viaCdn: this.viaCdn,
-                                migrated: true,
-                                // If we're taking 5+ minutes to make a query, it's a dud.
-                                // This is a timeout imposed on our DB and not external sources.
-                                // Honestly could lower down to 30 seconds, but we'll keep it high for now.
-                                maxSearchTimeSec: 60 * 5,
-                                req: {
-                                    // If we are passing in an abort, we MUST pass in noCache.
-                                    // Otherwise we will cache an aborted request.
-                                    noCache: true,
-                                    abortSignal: controller.signal
-                                }
-                            })).entities;
-                        });
-                        // Date changed.
-                        if (this.historicAttrDateTime != historicAttrDateTime) {
-                            break;
-                        }
-                        // Integrity changed.
-                        if (this.gatheredIntegrity != integrity) {
-                            break;
-                        }
-                        // No Menu Items.
-                        if (!this.GetMenuItems().length) {
-                            break;
-                        }
-                        (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(entities);
-                    }
-                }
-                catch (e) {
-                    // Ignore abort errors.
-                    if (e && typeof e === "object" && e.name == "AbortError") {
-                        // console.debug("Aborted entity-filter-getter historic refresh request.");
-                        return;
-                    }
-                    console.error(e);
-                }
-            })();
+        }
+        if (needsDataIds.length) {
+            this.entityGatherer.Queue(needsDataIds, highPriority);
         }
     }
-    EntityFilterGetter.Getter = Getter;
-})(EntityFilterGetter || (EntityFilterGetter = {}));
-
-function createFilterGetterCacheKey(params) {
-    let cacheKey = "";
-    cacheKey += params.api.GetBaseUrl();
-    // Not including Type ID in the cache key now.
-    // This allows us to re-use the same getter between Entity Types.
-    // cacheKey += params.typeId;
-    cacheKey += params.batchSize;
-    cacheKey += String(params.cdn);
-    cacheKey += params.schemaId ? params.schemaId : "";
-    cacheKey += JSON.stringify(params.tagIds ? params.tagIds : []);
-    cacheKey += params.historicAttrKey ? params.historicAttrKey : "";
-    cacheKey += params.historic ? "true" : "false";
-    cacheKey += params.scenario ? params.scenario : 0;
-    if (params.historicAttrKey) {
-        cacheKey += params.historicInterpolation ? "true" : "false";
+    styleTilesetFeature(entity) {
+        this.styleTilesetFeatureFullData(entity, null, []);
     }
-    // This could potentially crash, but if it crashes here then it would crash during API request anyways.
-    cacheKey += JSON.stringify(params.attrFilter ? params.attrFilter : {});
-    return cacheKey;
-}
-var SharedGetters;
-(function (SharedGetters) {
-    class Cache {
-        constructor() {
-            this.data = {};
+    styleTilesetFeatureFullData(entity, data, tags) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const visual = entity.visual;
+        if (!visual || !(visual instanceof Cesium3DTileFeature)) {
+            return;
         }
-        GetOrCreateFilterGetter(params) {
-            params.cdn = Boolean(params.cdn);
-            const cacheKey = createFilterGetterCacheKey(params);
-            let getter = this.data[cacheKey];
-            if (!getter) {
-                getter = new EntityFilterGetter.Getter({
-                    api: params.api,
-                    viewer: params.viewer,
-                    viewPort: params.monitor,
-                    typeIds: !params.typeId ? null : typeof params.typeId == "string" ? [params.typeId] : params.typeId,
-                    schemaId: params.schemaId,
-                    batchSize: params.batchSize,
-                    attrFilter: params.attrFilter,
-                    historic: params.historic,
-                    historicAttrKey: params.historicAttrKey,
-                    historicInterpolation: params.historicInterpolation,
-                    viaCdn: params.cdn,
-                    scenario: params.scenario,
+        const style = this.getTilesetFeatureStyle(entity.entityTypeId);
+        const bColor = style && ((_a = style.modelStyle) === null || _a === void 0 ? void 0 : _a.fillColor) ? Calculator.GetColor(style.modelStyle.fillColor, data, tags) : null;
+        let cColor = null;
+        if (bColor == null) {
+            cColor = Color.WHITE;
+        }
+        else {
+            cColor = colorToCColor$3(bColor);
+        }
+        const override = this.overrideFeatureColor.get(entity.entityId) == true;
+        CesiumEntityStyler.SetDefaultColor({
+            color: cColor,
+            entity: visual,
+            viewer: this.viewer,
+            override: override
+        });
+        this.overrideFeatureColor.set(entity.entityId, true);
+        this.styledEntityIds.set(entity.entityId, true);
+        this._styleProgressQueue.Call();
+        // Since we only need to update it for scenarios right now.
+        // We'll avoid doing it if not needed, eg: first render and no scenario (same state as default).
+        if (this.shouldUpdateRegoStates && (override || ((_b = data === null || data === void 0 ? void 0 : data.Bruce) === null || _b === void 0 ? void 0 : _b.Scenario) || this.historic)) {
+            // Update the Entity's rego state.
+            let changed = false;
+            // Changed scenario.
+            if (entity.scenario != ((_c = data === null || data === void 0 ? void 0 : data.Bruce) === null || _c === void 0 ? void 0 : _c.Scenario)) {
+                entity.scenario = (_d = data === null || data === void 0 ? void 0 : data.Bruce) === null || _d === void 0 ? void 0 : _d.Scenario;
+                changed = true;
+            }
+            // Changed historic.
+            if ((data && isHistoricMetadataChanged(entity, data)) || (!data && ((_e = entity.historicLayers) === null || _e === void 0 ? void 0 : _e.length) && !((_g = (_f = data.Bruce) === null || _f === void 0 ? void 0 : _f.HistoricLayers) === null || _g === void 0 ? void 0 : _g.length))) {
+                entity.historicLayers = (_h = data === null || data === void 0 ? void 0 : data.Bruce) === null || _h === void 0 ? void 0 : _h.HistoricLayers;
+                changed = true;
+            }
+            // Something changed, trigger a rego update.
+            // This lets UI know when the rego has changed.
+            if (changed) {
+                this.register.OnUpdate.Trigger({
+                    type: VisualsRegister.EVisualUpdateType.Update,
+                    entityId: entity.entityId,
+                    rego: entity
                 });
-                this.data[cacheKey] = getter;
-                /**
-                 * Debug option.
-                 * This will display the bounds of the cells that are being fetched.
-                 */
-                if (params.viewer && params.debugShowBounds) {
-                    // Cell id -> entity.
-                    const cellCache = {};
-                    const cellPrefix = ObjectUtils.UId(10) + "_";
-                    getter.OnScanUpdate.Subscribe((cells) => {
-                        if (window.ON_SCAN_UPDATE_PAUSED == true) {
-                            return;
-                        }
-                        const curCellIds = [];
-                        let fetchingCellId = null;
-                        const fetchedCells = {};
-                        cells.forEach((cell) => {
-                            var _a;
-                            const bounds = cell.GetBounds();
-                            const id = cellPrefix + bounds.east + "_" + bounds.north + "_" + bounds.south + "_" + bounds.west;
-                            curCellIds.push(id);
-                            fetchedCells[id] = cell.IsFetched();
-                            fetchingCellId = cell.Fetching ? id : fetchingCellId;
-                            let material = null;
-                            if (fetchedCells[id]) {
-                                material = Color.LIGHTGREEN.clone().withAlpha(0.3);
-                            }
-                            else if (fetchingCellId == id) {
-                                material = Color.LIGHTBLUE.clone().withAlpha(0.3);
-                            }
-                            else {
-                                material = Color.GOLD.clone().withAlpha(0.3);
-                            }
-                            if (cellCache[id]) {
-                                const rect = (_a = cellCache[id]) === null || _a === void 0 ? void 0 : _a.rectangle;
-                                if (rect) {
-                                    rect.material = material;
-                                }
-                                return;
-                            }
-                            const rect = new Rectangle(Math$1.toRadians(bounds.west), Math$1.toRadians(bounds.south), Math$1.toRadians(bounds.east), Math$1.toRadians(bounds.north));
-                            const entity = params.viewer.entities.add(new Entity({
-                                id: id,
-                                rectangle: {
-                                    coordinates: rect,
-                                    fill: true,
-                                    //material: Cesium.Color.fromRandom().withAlpha(0.3),
-                                    material: material,
-                                    zIndex: 0
-                                },
-                                // point: {
-                                //     pixelSize: 15,
-                                //     outlineColor: Cesium.Color.WHITE,
-                                //     outlineWidth: 2,
-                                //     color: Cesium.Color.fromRandom().withAlpha(0.5),
-                                //     heightReference: Cesium.HeightReference.CLAMP_TO_GROUND
-                                // },
-                                position: Cartesian3.fromRadians((rect.east + rect.west) / 2, (rect.north + rect.south) / 2)
-                            }));
-                            cellCache[id] = entity;
-                        });
-                        Object.keys(cellCache).forEach((id) => {
-                            if (curCellIds.indexOf(id) == -1) {
-                                const entity = cellCache[id];
-                                if (entity && params.viewer.entities.contains(entity)) {
-                                    params.viewer.entities.remove(entity);
-                                }
-                                delete cellCache[id];
-                            }
-                        });
-                    });
-                }
             }
-            return getter;
         }
     }
-    SharedGetters.Cache = Cache;
-    /**
-     * To avoid performing multiple expensive queries at the same time,
-     * we'll have the getters work through a queue of requests.
-     */
-    let Queue;
-    (function (Queue) {
-        const queue = [];
-        let isProcessing = false;
-        /**
-         * Called to run a provided function.
-         * When the function is complete, the next function in the queue will be called.
-         * This function will resolve when the provided function is complete.
-         * If the provided function crashes, the error bubbles up to the caller.
-         * @param name
-         * @param call
-         */
-        function Run(name, call) {
-            // console.debug(`Queueing: ${name}`);
-            return new Promise((resolve, reject) => {
-                queue.push(async () => {
-                    try {
-                        // console.debug(`Running: ${name}`);
-                        const result = await call();
-                        resolve(result);
-                    }
-                    catch (error) {
-                        reject(error);
-                    }
-                    finally {
-                        // Process the next function in the queue.
-                        queue.shift();
-                        // If there are more functions in the queue, process the next one.
-                        if (queue.length > 0) {
-                            processNext();
-                        }
-                        // No more items to process.
-                        else {
-                            isProcessing = false;
-                        }
-                    }
-                });
-                if (!isProcessing) {
-                    // If not currently processing, start processing the queue.
-                    isProcessing = true;
-                    processNext();
-                }
-            });
+    getTilesetFeatureStyle(entityTypeId) {
+        var _a, _b, _c, _d;
+        // Locate what style is applicable to the feature.
+        let style = null;
+        if (entityTypeId) {
+            style = ((_b = (_a = this.styleMapping.find(x => x.EntityTypeID == entityTypeId)) === null || _a === void 0 ? void 0 : _a.style) === null || _b === void 0 ? void 0 : _b.Settings);
         }
-        Queue.Run = Run;
-        async function processNext() {
-            const nextCall = queue[0];
-            if (nextCall) {
-                // Call the next function in the queue.
-                await nextCall();
-            }
+        if (!style) {
+            style = ((_c = this.fallbackStyle) === null || _c === void 0 ? void 0 : _c.Settings);
+        }
+        if (!style || !((_d = style === null || style === void 0 ? void 0 : style.modelStyle) === null || _d === void 0 ? void 0 : _d.customize)) {
+            return null;
+        }
+        return style;
+    }
+    getTilesetFeatureNeedsFullData(entityTypeId) {
+        var _a;
+        if (this.historic) {
+            // Unfortunately when we are working with historic we have to request the entity.
+            // This is because we need to know if a record exists at the point in time.
+            return true;
+        }
+        const style = this.getTilesetFeatureStyle(entityTypeId);
+        if (!style) {
+            return false;
         }
-    })(Queue = SharedGetters.Queue || (SharedGetters.Queue = {}));
-})(SharedGetters || (SharedGetters = {}));
-
-function colorToCColor$3(color) {
-    return new Color(color.red ? color.red / 255 : 0, color.green ? color.green / 255 : 0, color.blue ? color.blue / 255 : 0, color.alpha);
+        const fill = (_a = style === null || style === void 0 ? void 0 : style.modelStyle) === null || _a === void 0 ? void 0 : _a.fillColor;
+        if (!fill || fill.length <= 0) {
+            return false;
+        }
+        return fill[0].type != 0;
+    }
 }
+
 /**
  * Returns if a given tileset is alive and in the scene.
  * @param viewer
@@ -15684,22 +15714,6 @@ function isAlive$2(viewer, cTileset) {
     }
     return viewer.scene.primitives.contains(cTileset);
 }
-// ND-1641. BOOKMARKS - (DEMO) View does not match bookmark.
-// We have some evil hard-coded style mappings that need to be fixed.
-// These exist within legacy project views.
-function correctStyle(style) {
-    if (style && !style.Settings && !style.ID) {
-        return {
-            ID: -1,
-            Name: "Unknown",
-            Settings: {
-                ...style
-            },
-            Type: Style.EType.Entity
-        };
-    }
-    return style;
-}
 const VIEWER_WATCH_KEY = "bruce-viewer-watch";
 const WATCH_KEY = "bruce-tileset-watch";
 /**
@@ -16060,693 +16074,896 @@ var TilesetRenderEngine;
         else if (etc === null || etc === void 0 ? void 0 : etc.ExternalTilesetURL) {
             loadUrl = etc.ExternalTilesetURL;
         }
-        if (!loadUrl && tileset) {
-            const api = apiGetter.getApi(accountId);
-            await api.Loading;
-            loadUrl = Tileset.GetFileUrl({
-                file: "tileset.json",
-                tilesetId: (tileset === null || tileset === void 0 ? void 0 : tileset.ID) ? tileset.ID : params.tileset.id,
-                viaCdn: false,
-                legacy: true,
-                cacheToken: tileset.GenerateVersion,
-                api: api
-            });
+        if (!loadUrl && tileset) {
+            const api = apiGetter.getApi(accountId);
+            await api.Loading;
+            loadUrl = Tileset.GetFileUrl({
+                file: "tileset.json",
+                tilesetId: (tileset === null || tileset === void 0 ? void 0 : tileset.ID) ? tileset.ID : params.tileset.id,
+                viaCdn: false,
+                legacy: true,
+                cacheToken: tileset.GenerateVersion,
+                api: api
+            });
+        }
+        if (viaCdn && (tileset === null || tileset === void 0 ? void 0 : tileset.ID) && !ionId && !(etc === null || etc === void 0 ? void 0 : etc.ExternalTilesetURL)) {
+            const api = apiGetter.getApi(accountId);
+            await api.Loading;
+            if (api.GetCdnBaseUrl()) {
+                /*
+                 const rootFile = tileset.RootFileName ? tileset.RootFileName : "tileset.json";
+                 loadUrl = api.LegacyTilesetCdnUrl
+                     .replace("<TILESETID>", tileset.ID)
+                     .replace("<FILEPATH>", rootFile)
+                     .replace("<ACCOUNT>", accountId);
+                 */
+                loadUrl = Tileset.GetFileUrl({
+                    file: "tileset.json",
+                    tilesetId: (tileset === null || tileset === void 0 ? void 0 : tileset.ID) ? tileset.ID : params.tileset.id,
+                    viaCdn: true,
+                    legacy: true,
+                    cacheToken: params.tileset.generateVersion,
+                    api: api
+                });
+            }
+        }
+        const cTileset = await createTileset(loadUrl, {
+            backFaceCulling: backFaceCulling === true
+        }, noMemoryLimit);
+        viewer.scene.primitives.add(cTileset);
+        OnTilesetReady(cTileset).then(() => {
+            var _a;
+            try {
+                if (!isAlive$2(viewer, cTileset)) {
+                    return;
+                }
+                if (noMemoryLimit != true) {
+                    (_a = GetMemoryWatcher(params.viewer)) === null || _a === void 0 ? void 0 : _a.Watch(cTileset);
+                }
+                if (tileset) {
+                    let settings = tileset.Settings;
+                    settings = {
+                        ...settings
+                    };
+                    let origin = settings.origin;
+                    origin = {
+                        ...origin
+                    };
+                    let etc = settings.etc;
+                    etc = {
+                        ...etc
+                    };
+                    let positionOffset = settings.positionOffset;
+                    positionOffset = {
+                        ...positionOffset
+                    };
+                    const rotation = settings.rotation;
+                    ApplySettings({
+                        cTileset,
+                        settings: {
+                            attenuation: visual.attenuation != false,
+                            colorMask: visual.colorMask,
+                            maximumAttenuation: visual.attenuationMax,
+                            maxScreenSpaceError: visual.maximumScreenSpaceError
+                        }
+                    });
+                    ApplyPosition({
+                        cTileset: cTileset,
+                        position: {
+                            transform: rotation ? {
+                                heading: rotation.z,
+                                pitch: rotation.x,
+                                roll: rotation.y,
+                                scale: EnsureNumber(origin === null || origin === void 0 ? void 0 : origin.scale, 1),
+                                z: EnsureNumber(positionOffset === null || positionOffset === void 0 ? void 0 : positionOffset.altitude),
+                                x: EnsureNumber(positionOffset === null || positionOffset === void 0 ? void 0 : positionOffset.latitude),
+                                y: EnsureNumber(positionOffset === null || positionOffset === void 0 ? void 0 : positionOffset.longitude)
+                            } : null,
+                            location: (origin === null || origin === void 0 ? void 0 : origin.latitude) ? {
+                                latitude: origin.latitude,
+                                longitude: origin.longitude,
+                                altitude: origin.altitude
+                            } : null,
+                            isLegacy: true,
+                            legacyProps: {
+                                rotate: etc.dontRotate != true,
+                                transform: etc.dontTransform != true,
+                                usingBoundingBox: etc.usingBoundingBox != false
+                            }
+                        }
+                    });
+                    params.viewer.scene.requestRender();
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+        });
+        return cTileset;
+    }
+    TilesetRenderEngine.RenderLegacy = RenderLegacy;
+    // Util for styling Tileset features.
+    // Also used to flag historic metadata based on timeline changes.
+    class Styler extends TilesetStyler {
+    }
+    TilesetRenderEngine.Styler = Styler;
+    /**
+     * 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 tilesets in the viewer.
+     * This will regulate their max memory param.
+     * As more get watched their memory will be reduced.
+     */
+    class MemoryWatcher {
+        constructor(viewer) {
+            this.watched = [];
+            this.viewer = viewer;
+        }
+        distributeMemory() {
+            this.clean();
+            // Total 1gb as default.
+            // We'll need to allow user to change this somehow.
+            const maxMemory = TilesetRenderEngine.MAX_TILESET_MEMORY;
+            // Minimum memory in MB per tileset.
+            const minMemory = 80;
+            const totalPerTileset = Math.max(this.watched.length ? maxMemory / this.watched.length : maxMemory, minMemory);
+            this.watched.forEach(x => {
+                // Newer Cesium killed this property.
+                // TODO: Check if it's needed then.
+                x["maximumMemoryUsage"] = totalPerTileset;
+            });
+        }
+        destroy() {
+            this.watched = [];
+        }
+        /**
+         * Remove all dead tilesets.
+         */
+        clean() {
+            // Remove all dead tilesets.
+            this.watched = this.watched.filter(x => isAlive$2(this.viewer, x));
+            // Check if viewer is destroyed.
+            if (!this.viewer || this.viewer.isDestroyed()) {
+                this.destroy();
+            }
+        }
+        Watch(tileset) {
+            if (!tileset) {
+                return;
+            }
+            if (!tileset[WATCH_KEY]) {
+                tileset[WATCH_KEY] = ObjectUtils.UId();
+            }
+            const index = this.watched.findIndex(x => x[WATCH_KEY] === tileset[WATCH_KEY]);
+            if (index >= 0) {
+                return;
+            }
+            this.watched.push(tileset);
+            this.distributeMemory();
+        }
+        Unwatch(tileset) {
+            if (!tileset) {
+                return;
+            }
+            if (!tileset[WATCH_KEY]) {
+                tileset[WATCH_KEY] = ObjectUtils.UId();
+            }
+            const index = this.watched.findIndex(x => (x === null || x === void 0 ? void 0 : x[WATCH_KEY]) === tileset[WATCH_KEY]);
+            if (index > -1) {
+                this.watched.splice(index, 1);
+            }
+            this.distributeMemory();
+        }
+    }
+    TilesetRenderEngine.MemoryWatcher = MemoryWatcher;
+    function GetMemoryWatcher(viewer) {
+        // If viewer is dead return nothing.
+        if (!viewer || viewer.isDestroyed()) {
+            return null;
+        }
+        if (!viewer[VIEWER_WATCH_KEY]) {
+            viewer[VIEWER_WATCH_KEY] = new MemoryWatcher(viewer);
+        }
+        return viewer[VIEWER_WATCH_KEY];
+    }
+    TilesetRenderEngine.GetMemoryWatcher = GetMemoryWatcher;
+})(TilesetRenderEngine || (TilesetRenderEngine = {}));
+
+/**
+ * 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) {
+    class Cell {
+        constructor() {
+            this.Fetched = false;
+            this.IsFetched = null;
+            this.FetchPageIndex = 0;
+            // Optional URL to use instead of default URL generation.
+            // This is typically a response from the API to use this specific URL for the next page.
+            this.FetchURL = null;
+            this.Boundaries = null;
+            this.Fetching = false;
+        }
+        GetBounds() {
+            // Entity data works in -180 to 180 range.
+            function prepareRangeForBounds(range) {
+                if (range > 180) {
+                    return range - 360;
+                }
+                return range;
+            }
+            // Add minor decimal as API crashes when giving it whole numbers.
+            const maxLon = prepareRangeForBounds(this.Boundaries.maxLongitude);
+            const minLon = prepareRangeForBounds(this.Boundaries.minLongitude);
+            const maxLat = prepareRangeForBounds(this.Boundaries.maxLatitude);
+            const minLat = prepareRangeForBounds(this.Boundaries.minLatitude);
+            return {
+                east: maxLon,
+                north: maxLat,
+                south: minLat,
+                west: minLon
+            };
+        }
+    }
+    EntityGlobe.Cell = Cell;
+    class Grid {
+        constructor() {
+            this.cells = {};
         }
-        if (viaCdn && (tileset === null || tileset === void 0 ? void 0 : tileset.ID) && !ionId && !(etc === null || etc === void 0 ? void 0 : etc.ExternalTilesetURL)) {
-            const api = apiGetter.getApi(accountId);
-            await api.Loading;
-            if (api.GetCdnBaseUrl()) {
-                /*
-                 const rootFile = tileset.RootFileName ? tileset.RootFileName : "tileset.json";
-                 loadUrl = api.LegacyTilesetCdnUrl
-                     .replace("<TILESETID>", tileset.ID)
-                     .replace("<FILEPATH>", rootFile)
-                     .replace("<ACCOUNT>", accountId);
-                 */
-                loadUrl = Tileset.GetFileUrl({
-                    file: "tileset.json",
-                    tilesetId: (tileset === null || tileset === void 0 ? void 0 : tileset.ID) ? tileset.ID : params.tileset.id,
-                    viaCdn: true,
-                    legacy: true,
-                    cacheToken: params.tileset.generateVersion,
-                    api: api
-                });
+        GetCellsForView(cameraPos, viewRect) {
+            const cells = [];
+            const minLat = viewRect.south;
+            const minLon = viewRect.west;
+            const maxLat = viewRect.north;
+            const maxLon = viewRect.east;
+            const MAX_CELLS = 150;
+            const cellDegreeSize = getCellSizeFromHeight(viewRect.alt);
+            // console.log("cell size", cellDegreeSize, "height", viewRect.alt);
+            let curMinLon = floorValueToCellSize(cellDegreeSize, minLon);
+            let curMinLat = floorValueToCellSize(cellDegreeSize, minLat);
+            // For larger views we add additional padding because our view-area culling is too strong.
+            if (cellDegreeSize >= 2) {
+                curMinLon -= cellDegreeSize;
+                curMinLat -= cellDegreeSize;
             }
-        }
-        const cTileset = await createTileset(loadUrl, {
-            backFaceCulling: backFaceCulling === true
-        }, noMemoryLimit);
-        viewer.scene.primitives.add(cTileset);
-        OnTilesetReady(cTileset).then(() => {
-            var _a;
-            try {
-                if (!isAlive$2(viewer, cTileset)) {
-                    return;
-                }
-                if (noMemoryLimit != true) {
-                    (_a = GetMemoryWatcher(params.viewer)) === null || _a === void 0 ? void 0 : _a.Watch(cTileset);
+            let centerX = cameraPos === null || cameraPos === void 0 ? void 0 : cameraPos.longitude;
+            let centerY = cameraPos === null || cameraPos === void 0 ? void 0 : cameraPos.latitude;
+            if (isNaN(centerX) || isNaN(centerY)) {
+                centerX = (minLon + maxLon) / 2;
+                centerY = (minLat + maxLat) / 2;
+            }
+            let width = Math.ceil((maxLon - curMinLon) / cellDegreeSize);
+            let height = Math.ceil((maxLat - curMinLat) / cellDegreeSize);
+            // For larger views we add additional padding because our view-area culling is too strong.
+            if (cellDegreeSize >= 2) {
+                width += 1;
+                height += 1;
+            }
+            const cellDistances = [];
+            for (let x = 0; x < width; x++) {
+                for (let y = 0; y < height; y++) {
+                    const lon = x * cellDegreeSize + curMinLon;
+                    const lat = y * cellDegreeSize + curMinLat;
+                    const cellCenterX = lon + cellDegreeSize / 2;
+                    const cellCenterY = lat + cellDegreeSize / 2;
+                    const dist = Math.sqrt(Math.pow(cellCenterX - centerX, 2) + Math.pow(cellCenterY - centerY, 2));
+                    cellDistances.push({ x, y, dist });
                 }
-                if (tileset) {
-                    let settings = tileset.Settings;
-                    settings = {
-                        ...settings
-                    };
-                    let origin = settings.origin;
-                    origin = {
-                        ...origin
-                    };
-                    let etc = settings.etc;
-                    etc = {
-                        ...etc
-                    };
-                    let positionOffset = settings.positionOffset;
-                    positionOffset = {
-                        ...positionOffset
-                    };
-                    const rotation = settings.rotation;
-                    ApplySettings({
-                        cTileset,
-                        settings: {
-                            attenuation: visual.attenuation != false,
-                            colorMask: visual.colorMask,
-                            maximumAttenuation: visual.attenuationMax,
-                            maxScreenSpaceError: visual.maximumScreenSpaceError
-                        }
-                    });
-                    ApplyPosition({
-                        cTileset: cTileset,
-                        position: {
-                            transform: rotation ? {
-                                heading: rotation.z,
-                                pitch: rotation.x,
-                                roll: rotation.y,
-                                scale: EnsureNumber(origin === null || origin === void 0 ? void 0 : origin.scale, 1),
-                                z: EnsureNumber(positionOffset === null || positionOffset === void 0 ? void 0 : positionOffset.altitude),
-                                x: EnsureNumber(positionOffset === null || positionOffset === void 0 ? void 0 : positionOffset.latitude),
-                                y: EnsureNumber(positionOffset === null || positionOffset === void 0 ? void 0 : positionOffset.longitude)
-                            } : null,
-                            location: (origin === null || origin === void 0 ? void 0 : origin.latitude) ? {
-                                latitude: origin.latitude,
-                                longitude: origin.longitude,
-                                altitude: origin.altitude
-                            } : null,
-                            isLegacy: true,
-                            legacyProps: {
-                                rotate: etc.dontRotate != true,
-                                transform: etc.dontTransform != true,
-                                usingBoundingBox: etc.usingBoundingBox != false
-                            }
-                        }
-                    });
-                    params.viewer.scene.requestRender();
+            }
+            cellDistances.sort((a, b) => a.dist - b.dist);
+            for (const { x, y } of cellDistances) {
+                const lon = x * cellDegreeSize + curMinLon;
+                const lat = y * cellDegreeSize + curMinLat;
+                const [id, cell] = getOrCreateCell(this.cells, cellDegreeSize, lon, lon + cellDegreeSize, lat, lat + cellDegreeSize);
+                cells.push(cell);
+                if (cells.length >= MAX_CELLS) {
+                    break;
                 }
             }
-            catch (e) {
-                console.error(e);
+            return cells;
+        }
+    }
+    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.04;
+    }
+    else if (height < 10000) {
+        return 0.15;
+    }
+    else if (height < 30000) {
+        return 0.5;
+    }
+    else if (height < 70000) {
+        return 0.5;
+    }
+    else if (height < 100000) {
+        return 1;
+    }
+    else if (height < 150000) {
+        return 1;
+    }
+    else if (height < 200000) {
+        return 1.5;
+    }
+    else if (height < 300000) {
+        return 1.5;
+    }
+    else if (height < 500000) {
+        return 3;
+    }
+    else if (height < 1000000) {
+        return 3;
+    }
+    else if (height < 1200000) {
+        return 4;
+    }
+    else if (height < 2000000) {
+        return 6;
+    }
+    else if (height < 3000000) {
+        return 20;
+    }
+    return 35;
+}
+function isCellFetched(cell) {
+    if (cell.Fetched) {
+        return true;
+    }
+    return false;
+}
+function getOrCreateCell(cells, cellSize, lon, maxLon, lat, maxLat) {
+    const id = cellSize + "_" + lon + "_" + maxLon + "_" + lat + "_" + maxLat;
+    let cell = cells[id];
+    if (!cell) {
+        cell = cells[id] = new EntityGlobe.Cell();
+        cell.Boundaries = {
+            minLatitude: lat,
+            maxLatitude: maxLat,
+            minLongitude: lon,
+            maxLongitude: maxLon
+        };
+        cell.IsFetched = () => isCellFetched(cell);
+    }
+    return [id, cell];
+}
+
+const MAX_AREA_IN_DEGREES$1 = 90;
+const MAX_RETRY_ATTEMPTS = 1;
+const RETRY_DELAY_INCREMENT = 500;
+const REQUEST_PAGE_DELAY = 50;
+class regMenuItemGetter {
+    constructor(typeId, tagIds, minHeight, maxHeight) {
+        this.TypeId = typeId;
+        this.TagIds = tagIds;
+        this.MinHeight = minHeight;
+        this.MaxHeight = maxHeight;
+    }
+}
+async function delay(milliseconds) {
+    return new Promise((res) => {
+        setTimeout(() => {
+            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) {
+    let EStatus;
+    (function (EStatus) {
+        EStatus["Scanning"] = "SCANNING";
+        EStatus["Loading"] = "LOADING";
+    })(EStatus = EntityFilterGetter.EStatus || (EntityFilterGetter.EStatus = {}));
+    class Getter {
+        get OnUpdate() {
+            if (!this.onUpdate) {
+                this.onUpdate = new BruceEvent();
             }
-        });
-        return cTileset;
-    }
-    TilesetRenderEngine.RenderLegacy = RenderLegacy;
-    class Styler {
-        constructor() {
-            this.disposed = false;
-            // Indicates if the styler has been loaded/initialized and is ready to style.
-            this.loaded = false;
-            this.styleMappingLoaded = false;
-            this.styleMappingsLoaded = {};
-            this.fallbackStyle = null;
-            this.expandSources = false;
-            this.loadingCounter = 0;
-            // Dictionary of Entity ID -> boolean to indicate which Entities have been styled.
-            // This is used to determine if the Style colour needs to be overriden or not.
-            this.styledEntityIds = {};
-            // Dictionary of Entity ID -> boolean to indicate which Entities have had full Entity data loaded.
-            // This is used to determine what Entities need to be re-requested when the scene time changes.
-            this.styledWithAttrEntityIds = {};
-            this.scenario = 0;
-            // Indicates that we are retrieving historic records.
-            // This means that the current scene's time is included in the request.
-            this.historic = false;
-            this.viewerDateTimeChangeRemoval = null;
-            this.historicRefreshAbortController = null;
-            // More expensive process.
-            // When an Entity is styled, the rego is reviewed and updated if needed.
-            // This is currently used for scenarios, and off by default to keep other processes faster.
-            this.shouldUpdateRegoStates = false;
-            this.runningQueues = 0;
-            this.recordLoadQueue = [];
-            this.recordCheckQueue = [];
-            // % progress for how many Entities have been styled so far.
-            // This can change as Tiles load in and more queue.
-            this._styleProgress = 0;
-            this._styleProgressQueue = new DelayQueue(() => {
-                this.updateStyleProgress();
-            }, 250);
-            // Event for when the style progress changes.
-            this.OnStyleProgress = new BruceEvent();
-            // Cache of Entity objects to use when styling instead of requesting them.
-            this.entityDataCache = {};
+            return this.onUpdate;
         }
-        get Disposed() {
-            return this.disposed;
+        get OnStateUpdate() {
+            if (!this.onStateUpdate) {
+                this.onStateUpdate = new BruceEvent();
+            }
+            return this.onStateUpdate;
         }
-        get Loaded() {
-            return this.loaded;
+        get OnScanUpdate() {
+            if (!this.onScanUpdate) {
+                this.onScanUpdate = new BruceEvent();
+            }
+            return this.onScanUpdate;
         }
-        get StyleProgress() {
-            return this._styleProgress;
+        get isLooping() {
+            return this.looping > 0;
         }
-        Init(params) {
-            var _a;
-            let { viewer, api, cTileset, fallbackStyleId, styleMapping, expandSources, menuItemId, register, scenario, historic } = params;
-            this.viewer = viewer;
+        constructor(params) {
+            this.onUpdate = null;
+            this.LastStateUpdates = {};
+            this.onStateUpdate = null;
+            this.onScanUpdate = null;
+            this.viewPortChangeRemoval = null;
+            this.viewPortDelayQueue = null;
+            this.viewerDateTimeChangeRemoval = null;
+            this.cells = null;
+            this.registeredItems = {};
+            this.getterLoopId = 0;
+            this.getterLoopAbortControllers = {};
+            this.looping = 0;
+            this.tagIds = null;
+            this.minHeight = 0;
+            this.maxHeight = 100000;
+            this.viewRect = null;
+            this.viewCenter = null;
+            this.scenario = 0;
+            this.historicRefreshAbortController = null;
+            // Entity IDs found for the latest integrity.
+            // 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;
             this.api = api;
-            this.cTileset = cTileset;
-            this.register = register;
-            this.menuItemId = menuItemId;
+            this.typeIds = typeIds;
+            this.schemaId = schemaId;
             this.historic = Boolean(historic);
-            if (expandSources != null) {
-                this.expandSources = expandSources;
-            }
-            if (fallbackStyleId != null) {
-                this.fallbackStyleId = fallbackStyleId;
-            }
-            if (styleMapping) {
-                this.styleMapping = styleMapping;
-                if (this.styleMapping) {
-                    // Dereference.
-                    this.styleMapping = JSON.parse(JSON.stringify(this.styleMapping));
-                }
-                // ND-1641. BOOKMARKS - (DEMO) View does not match bookmark.
-                // We have some evil hard-coded style mappings that need to be fixed.
-                // These exist within legacy project views.
-                // Update: This now also lets people have a style mapping without a real style record.
-                if ((_a = this.styleMapping) === null || _a === void 0 ? void 0 : _a.length) {
-                    for (let i = 0; i < this.styleMapping.length; i++) {
-                        const mapItem = this.styleMapping[i];
-                        const mapStyle = mapItem.style ? mapItem.style : mapItem.Style;
-                        this.styleMapping[i].style = correctStyle(mapStyle);
-                    }
-                }
-            }
-            if (scenario != null) {
-                this.scenario = scenario;
-            }
-            if (!!scenario) {
-                this.shouldUpdateRegoStates = true;
-            }
-            else if (this.historic) {
-                this.shouldUpdateRegoStates = true;
-            }
-            this.loadStyles();
-            this.viewerDateTimeSub();
-            this.loaded = true;
+            this.historicAttrKey = historicAttrKey;
+            this.historicInterpolation = Boolean(historicInterpolation);
+            this.viaCdn = Boolean(viaCdn);
+            this.batchSize = isNaN(batchSize) ? 300 : batchSize;
+            this.viewPort = viewPort;
+            this.attrFilter = attrFilter;
+            this.viewer = viewer;
+            this.scenario = scenario ? scenario : 0;
+            this.updateBounds();
         }
         /**
-         * Updates style mapping and fallback style.
-         * This will trigger a re-style of all entities, and will stop existing style loads.
-         * @param params
+         * 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
          */
-        UpdateStyleMapping(params) {
-            var _a;
-            if (params.styleMapping) {
-                // Dereference.
-                params.styleMapping = JSON.parse(JSON.stringify(params.styleMapping));
-                this.styleMapping = params.styleMapping;
-                // ND-1641. BOOKMARKS - (DEMO) View does not match bookmark.
-                // We have some evil hard-coded style mappings that need to be fixed.
-                // These exist within legacy project views.
-                // Update: This now also lets people have a style mapping without a real style record.
-                if ((_a = this.styleMapping) === null || _a === void 0 ? void 0 : _a.length) {
-                    for (let i = 0; i < this.styleMapping.length; i++) {
-                        const mapItem = this.styleMapping[i];
-                        const mapStyle = mapItem.style ? mapItem.style : mapItem.Style;
-                        this.styleMapping[i].style = correctStyle(mapStyle);
-                    }
-                }
-            }
-            if (!isNaN(params.fallbackStyleId) && params.fallbackStyleId != null) {
-                this.fallbackStyleId = params.fallbackStyleId;
-            }
-            if (params.fallbackStyle) {
-                this.fallbackStyle = params.fallbackStyle;
-            }
-            else {
-                this.fallbackStyle = null;
-            }
-            if (params.expandSources != null) {
-                this.expandSources = params.expandSources;
+        getIntegrityId() {
+            let integrity = this.tagIds == null ? "" : this.tagIds.join();
+            if (this.historicAttrKey) {
+                integrity += "isHistoric";
+                integrity += this.historicAttrKey;
             }
-            if (params.scenario != null) {
-                this.scenario = params.scenario;
-                if (!this.shouldUpdateRegoStates && !!this.scenario) {
-                    this.shouldUpdateRegoStates = true;
-                }
+            else if (this.historic) {
+                integrity += "isHistoric";
             }
-            if (params.historic != null) {
-                this.historic = params.historic;
-                if (params.historic || this.historic != params.historic) {
-                    this.shouldUpdateRegoStates = true;
-                }
-                if (params.historic) {
-                    this.viewerDateTimeSub();
-                }
-                else {
-                    this.viewerDateTimeDispose();
-                }
+            if (this.scenario) {
+                integrity += this.scenario;
             }
-            if (this.loaded) {
-                // Empty queues.
-                // Requeue all.
-                this.recordLoadQueue = [];
-                this.recordCheckQueue = [];
-                const regos = this.register.GetRegos({
-                    menuItemId: this.menuItemId
-                });
-                // Reset progress.
-                this._styleProgressQueue.Call(true);
-                this.styleMappingLoaded = false;
-                this.styleMappingsLoaded = {};
-                this.QueueEntities(regos);
-                this.loadStyles();
+            if (this.typeIds) {
+                integrity += this.typeIds.join();
             }
+            return integrity;
+        }
+        viewAreaSub() {
+            this.viewAreaDispose();
+            // We'll avoid restarting the scanner too often.
+            this.viewPortDelayQueue = new DelayQueue(() => {
+                this.updateBounds();
+                this.startGetterLoop();
+            }, 2000);
+            this.viewPortChangeRemoval = this.viewPort.Updated().Subscribe(() => {
+                var _a;
+                (_a = this.viewPortDelayQueue) === null || _a === void 0 ? void 0 : _a.Call();
+            });
+        }
+        viewAreaDispose() {
+            var _a, _b;
+            (_a = this.viewPortChangeRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.viewPortChangeRemoval = null;
+            (_b = this.viewPortDelayQueue) === null || _b === void 0 ? void 0 : _b.Dispose();
+            this.viewPortDelayQueue = null;
         }
         /**
-         * Updates a cache of Entity objects to use when styling.
-         * When a cache is available, a request won't be performed to get that Entity's data.
-         * @param entityIds
-         * @param entities If an object is not available for a supplied Entity ID, then the cache for it is removed.
+         * Monitors the Cesium viewer and updates the historic data filter values.
+         * If there is no historic attr set, this will do nothing.
          */
-        SetEntityCache(entityIds, entities) {
-            // Turn the Entities array into an accessible dictionary.
-            const newDataMap = {};
-            if (entities) {
-                for (let i = 0; i < entities.length; i++) {
-                    const entity = entities[i];
-                    if (entity.Bruce) {
-                        newDataMap[entity.Bruce.ID] = entity;
+        viewerDateTimeSub() {
+            if ((!this.historicAttrKey && !this.historic) || this.viewerDateTimeChangeRemoval) {
+                return;
+            }
+            // This is multiplied by the speed of animation to figure
+            // out how many animation "ticks" before we allow an update.
+            let INTERVAL_WHILE_ANIMATING = 2.5 * 1000;
+            let INTERVAL_WHILE_NOT_ANIMATING = 1000;
+            if (this.historicInterpolation) {
+                INTERVAL_WHILE_ANIMATING = 6 * 1000;
+                INTERVAL_WHILE_NOT_ANIMATING = 3.5 * 1000;
+            }
+            let lastUpdateTime = null;
+            let delayQueue = new DelayQueue(() => {
+                try {
+                    // If the timeline is animating then we'll wait longer to update.
+                    if (this.viewer.clock.shouldAnimate && lastUpdateTime) {
+                        if (Math.abs(new Date().getTime() - lastUpdateTime) < INTERVAL_WHILE_ANIMATING) {
+                            return;
+                        }
+                    }
+                    const current = this.historicAttrDateTime;
+                    this.updateHistoricDateTime();
+                    if (current != this.historicAttrDateTime) {
+                        this.emitHistoricData();
                     }
                 }
-            }
-            // Update the cache for each supplied Entity ID.
-            for (let i = 0; i < entityIds.length; i++) {
-                const entityId = entityIds[i];
-                if (newDataMap[entityId]) {
-                    this.entityDataCache[entityId] = newDataMap[entityId];
+                catch (e) {
+                    console.error(e);
                 }
-                else {
-                    delete this.entityDataCache[entityId];
+            }, INTERVAL_WHILE_NOT_ANIMATING);
+            let postUpdateRemoval = this.viewer.scene.postUpdate.addEventListener(() => {
+                if (delayQueue) {
+                    delayQueue.Call();
                 }
-            }
+            });
+            this.viewerDateTimeChangeRemoval = () => {
+                delayQueue === null || delayQueue === void 0 ? void 0 : delayQueue.Dispose();
+                postUpdateRemoval === null || postUpdateRemoval === void 0 ? void 0 : postUpdateRemoval();
+                delayQueue = null;
+                postUpdateRemoval = null;
+            };
         }
-        QueueEntities(entities, highPriority = false) {
-            if (!this.loaded) {
+        updateHistoricDateTime() {
+            if (!this.historicAttrKey && !this.historic) {
+                this.historicAttrDateTime = null;
                 return;
             }
-            // We set a default colour right away to avoid race conditions at later times.
-            for (let i = 0; i < entities.length; i++) {
-                const entity = entities[i];
-                this.styledEntityIds[entity.entityId] = true;
-                CesiumEntityStyler.BakeDefaultColor({
-                    entity: entity.visual,
-                    viewer: this.viewer,
-                    override: false
-                });
-            }
-            for (let i = 0; i < entities.length; i++) {
-                const entity = entities[i];
-                this.queueTilesetFeatureStyle(entity, highPriority);
-            }
-            if (this.recordLoadQueue.length > 0) {
-                this.processQueue();
+            const isChanged = (before, after) => {
+                if (before && !after) {
+                    return true;
+                }
+                if (!before && after) {
+                    return true;
+                }
+                // Change must be at least 0.1 seconds.
+                return Math.abs(before.getTime() - after.getTime()) > 100;
+            };
+            const oldDateTime = this.historicAttrDateTime ? new Date(this.historicAttrDateTime) : null;
+            const newDateTime = JulianDate.toDate(this.viewer.clock.currentTime);
+            if (isChanged(oldDateTime, newDateTime)) {
+                this.historicAttrDateTime = newDateTime.toISOString();
             }
         }
-        async processQueue() {
-            var _a, _b;
-            const MAX_BATCHES = 2;
-            const BATCH_DELAY = 200;
-            if (this.runningQueues >= MAX_BATCHES) {
-                return;
-            }
-            else if (this.disposed) {
-                return;
-            }
-            this.runningQueues += 1;
-            let batch = [];
-            let rerun = false;
-            try {
-                batch = this.getEntityIdsForQueue();
-                if (batch.length > 0) {
-                    let entities = [];
-                    {
-                        // Constructing new array of IDs for any ones that don't have cached data.
-                        const batchToRequest = [];
-                        // Check cache for available Entities.
-                        for (let i = 0; i < batch.length; i++) {
-                            const entityId = batch[i];
-                            const entity = this.entityDataCache[entityId];
-                            if (entity) {
-                                entities.push(entity);
-                            }
-                            else {
-                                batchToRequest.push(entityId);
-                            }
-                        }
-                        if (batchToRequest.length) {
-                            const dateTime = this.historic ? this.historicAttrDateTime : null;
-                            const { entities: response } = await Entity$1.GetListByIds({
-                                api: this.api,
-                                entityIds: batchToRequest,
-                                migrated: true,
-                                expandSources: this.expandSources,
-                                scenario: this.scenario,
-                                historicPoint: dateTime
-                            });
-                            // See if the historic date is the same.
-                            // If not, then we have to re-add the Entities to the queue and re-run.
-                            const curDateTime = this.historic ? this.historicAttrDateTime : null;
-                            if (curDateTime == dateTime) {
-                                // Add all found Entities to the list.
-                                entities.push(...response);
-                            }
-                            else {
-                                rerun = true;
-                            }
-                        }
+        viewerDateTimeDispose() {
+            var _a;
+            (_a = this.viewerDateTimeChangeRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.viewerDateTimeChangeRemoval = null;
+        }
+        GetMenuItems() {
+            return Object.keys(this.registeredItems);
+        }
+        IncludeMenuItem(menuItemId, typeId, layerIds, minHeight, maxHeight) {
+            this.registeredItems[menuItemId] = new regMenuItemGetter(typeId, layerIds, minHeight, maxHeight);
+            this.updateState();
+        }
+        ExcludeMenuItem(menuItemId) {
+            this.registeredItems[menuItemId] = null;
+            delete this.registeredItems[menuItemId];
+            this.updateState(true);
+        }
+        updateBounds() {
+            const viewRect = this.viewPort.GetBounds();
+            const poi = this.viewPort.GetTarget();
+            if (viewRect && poi) {
+                if (Math.abs(viewRect.west - viewRect.east) > MAX_AREA_IN_DEGREES$1) {
+                    return;
+                }
+                if (Math.abs(viewRect.south - viewRect.north) > MAX_AREA_IN_DEGREES$1) {
+                    return;
+                }
+                this.viewRect = viewRect;
+                this.viewCenter = poi;
+            }
+        }
+        updateState(onlyIfLooping = false) {
+            const tagIds = [];
+            const typeIds = [];
+            const menuItemIds = this.GetMenuItems();
+            let minHeight = null;
+            let maxHeight = null;
+            for (let i = 0; i < menuItemIds.length; i++) {
+                const menuItem = this.registeredItems[menuItemIds[i]];
+                if (menuItem) {
+                    if (maxHeight == null || maxHeight < menuItem.MaxHeight) {
+                        maxHeight = menuItem.MaxHeight;
                     }
-                    if (rerun) {
-                        this.recordLoadQueue = this.recordLoadQueue.concat(batch);
+                    if (minHeight == null || minHeight > menuItem.MinHeight) {
+                        minHeight = menuItem.MinHeight;
                     }
-                    else {
-                        // Quick access dictionary of Entity ID -> Entities.
-                        const entityMap = {};
-                        // Gather all Tag IDs from found Entities.
-                        let tagIds = [];
-                        for (let i = 0; i < entities.length; i++) {
-                            const entity = entities[i];
-                            entityMap[entity.Bruce.ID] = entity;
-                            if ((_b = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a["Layer.ID"]) === null || _b === void 0 ? void 0 : _b.length) {
-                                const eTagIds = entity.Bruce["Layer.ID"];
-                                for (let j = 0; j < eTagIds.length; j++) {
-                                    tagIds.push(eTagIds[j]);
-                                }
+                    const itemLayerIds = menuItem.TagIds;
+                    if (itemLayerIds) {
+                        for (let j = 0; j < itemLayerIds.length; j++) {
+                            const itemLayerId = itemLayerIds[j];
+                            if (!tagIds.includes(itemLayerId)) {
+                                tagIds.push(itemLayerId);
                             }
                         }
-                        // Turn into unique list.
-                        if (tagIds.length) {
-                            tagIds = tagIds.filter((v, i, a) => a.indexOf(v) === i);
-                        }
-                        // Gather records.
-                        let tags = [];
-                        if (tagIds.length) {
-                            tags = (await EntityTag.GetListByIds({
-                                tagIds: tagIds,
-                                api: this.api
-                            })).tags;
-                        }
-                        for (let i = 0; i < batch.length; i++) {
-                            const entityId = batch[i];
-                            const record = entityMap[entityId];
-                            const feature = this.getEntityRego(entityId);
-                            if (feature) {
-                                const eTags = tags.filter(t => { var _a, _b, _c, _d; return ((_b = (_a = record === null || record === void 0 ? void 0 : record.Bruce) === null || _a === void 0 ? void 0 : _a["Layer.ID"]) === null || _b === void 0 ? void 0 : _b.length) && ((_d = (_c = record === null || record === void 0 ? void 0 : record.Bruce) === null || _c === void 0 ? void 0 : _c["Layer.ID"]) === null || _d === void 0 ? void 0 : _d.includes(t.ID)); });
-                                this.styleTilesetFeatureFullData(feature, record, eTags);
-                            }
+                    }
+                    const itemTypeId = menuItem.TypeId;
+                    if (itemTypeId) {
+                        if (!typeIds.includes(itemTypeId)) {
+                            typeIds.push(itemTypeId);
                         }
-                        rerun = rerun || batch.length > 0;
-                        this.viewer.scene.requestRender();
                     }
                 }
             }
-            finally {
-                setTimeout(() => {
-                    this.runningQueues -= 1;
-                    if (rerun || this.recordLoadQueue.length > 0) {
-                        this.processQueue();
-                    }
-                }, BATCH_DELAY);
-            }
-            this.viewer.scene.requestRender();
-        }
-        getEntityIdsForQueue() {
-            const BATCH_SIZE = this.expandSources ? 100 : 500;
-            return this.recordLoadQueue.splice(0, BATCH_SIZE);
-        }
-        /**
-         * Calculates the current progress % and updates the progress if there is a change.
-         */
-        updateStyleProgress() {
-            if (this.disposed) {
-                return;
-            }
-            let progress = 100; // Done when idling.
-            if (this.recordCheckQueue.length || this.recordLoadQueue.length) {
-                const total = Object.keys(this.styledEntityIds).length;
-                // Done is the total minus the amount left.
-                // We have to ensure the same ID isn't counted within or across these arrays as well.
-                const uniqueSet = new Set(this.recordCheckQueue.concat(this.recordLoadQueue));
-                const done = total - uniqueSet.size;
-                progress = done / total * 100;
-                // Round to 2dp, 0, or 100.
-                if (progress < 0) {
-                    progress = 0;
-                }
-                else if (progress < 100) {
-                    progress = Math.round(progress * 100) / 100;
-                }
-                else if (progress > 100) {
-                    progress = 100;
-                }
+            if (menuItemIds.length > 0 && (!onlyIfLooping || this.isLooping)) {
+                // Reset cells so none are marked as fetched.
+                this.cells = new EntityGlobe.Grid();
+                this.tagIds = tagIds;
+                this.typeIds = typeIds;
+                this.minHeight = minHeight;
+                this.maxHeight = maxHeight;
+                this.updateBounds();
+                this.updateHistoricDateTime();
+                this.startGetterLoop();
+                this.viewAreaSub();
+                this.viewerDateTimeSub();
             }
-            if (this._styleProgress != progress) {
-                this._styleProgress = progress;
-                this.OnStyleProgress.Trigger(progress);
+            else {
+                this.getterLoopId += 1;
+                this.viewAreaDispose();
+                this.viewerDateTimeDispose();
             }
         }
-        getEntityRego(entityId) {
-            return this.register.GetRego({
-                entityId,
-                menuItemId: this.menuItemId
-            });
-        }
-        Dispose() {
-            if (this.disposed) {
-                return;
-            }
-            this.disposed = true;
-            clearInterval(this.queueLoadInterval);
-            clearInterval(this.queueCheckInterval);
-            this._styleProgressQueue.Dispose();
-            this.viewerDateTimeDispose();
+        postStatus(status) {
+            var _a;
+            this.LastStateUpdates[status.msg] = status;
+            (_a = this.onStateUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(status);
         }
-        async loadStyles() {
-            var _a, _b;
-            const counter = ++this.loadingCounter;
-            this.styleMappingLoaded = false;
-            this.styleMappingsLoaded = {};
-            let fallbackStyleId = this.fallbackStyleId;
-            if (fallbackStyleId && fallbackStyleId > 0) {
-                try {
-                    let { style: data } = await Style.Get({
-                        api: this.api,
-                        styleId: fallbackStyleId
-                    });
-                    this.fallbackStyle = data;
-                }
-                catch (e) {
-                    console.error(e);
+        startGetterLoop() {
+            // Increase id so that existing loops stop.
+            this.getterLoopId += 1;
+            const loopId = this.getterLoopId;
+            const loopIntegrity = this.getIntegrityId();
+            // Abort any existing loops that don't match the current loop.
+            // We tried using integrity, however we want to interrupt when user moves camera quickly.
+            // So it's better to use the loop ID.
+            const abortId = String(loopId);
+            {
+                const newAbortControllers = {};
+                for (const key in this.getterLoopAbortControllers) {
+                    this.getterLoopAbortControllers[key].abort();
                 }
+                this.getterLoopAbortControllers = newAbortControllers;
             }
-            if (this.loadingCounter != counter) {
-                return;
-            }
-            // Load styles in the style mapping
-            let styleMapping = this.styleMapping;
-            if (!styleMapping) {
-                styleMapping = [];
-            }
-            this.styleMapping = styleMapping;
-            // Append all found entity-types.
-            // That way we can mark them as loaded instead of just the ones in the style mapping.
-            try {
-                const modelTree = (_b = (_a = this.cTileset) === null || _a === void 0 ? void 0 : _a.extensions) === null || _b === void 0 ? void 0 : _b.modelTree;
-                if (modelTree) {
-                    const entityTypeIds = this.getEntityTypeIdsFromModelTree(modelTree);
-                    for (let i = 0; i < entityTypeIds.length; i++) {
-                        const entityTypeId = entityTypeIds[i];
-                        if (styleMapping.findIndex(x => x.EntityTypeID == entityTypeId) <= -1) {
-                            styleMapping.push({
-                                EntityTypeID: entityTypeId,
-                                StyleID: this.fallbackStyle ? fallbackStyleId : 0,
-                                style: this.fallbackStyle
-                            });
-                        }
-                    }
+            const abortController = this.getterLoopAbortControllers[abortId] = new AbortController();
+            this.looping += 1;
+            (async () => {
+                var _a, _b, _c, _d, _e, _f, _g, _h;
+                // Larger initial delay for the first loops because terrain is likely loading in.
+                // We also delay because if we enable 50 Menu Items at the same time, common requests we be made if we wait a bit.
+                // Eg: same entity type will be grouped into the same filter getter instance.
+                await delay(loopId <= 3 ? 800 : 300);
+                const MIN_HEIGHT = this.minHeight;
+                const MAX_HEIGHT = this.maxHeight;
+                const PAGE_SIZE = this.batchSize;
+                let retryAttempts = MAX_RETRY_ATTEMPTS;
+                let retryDelay = 0;
+                let prevFirstId = "";
+                let prevLastId = "";
+                let prevTicks = 0;
+                while ((!this.viewCenter || !this.viewRect) && this.getterLoopId == loopId) {
+                    await delay(RETRY_DELAY_INCREMENT);
                 }
-            }
-            catch (e) {
-                console.error(e);
-            }
-            // Before we start the loop we'll do a single request for the needed Entity Types.
-            // This will be aimed at rows that don't specify a Style and if the default fallback-
-            //is set to 0 (using the default of the Entity Type).
-            const typeMap = new Map();
-            const typeIds = styleMapping.map(x => x.StyleID == -1 || Boolean(x.style) ? null : x.EntityTypeID).filter(x => !!x);
-            if (typeIds.length) {
-                // We'll split up into batches of 50.
-                // Since we add the type IDs as query params I am paranoid of hitting the limit.
-                const splits = Math.ceil(typeIds.length / 50);
-                const batchSize = 50;
-                for (let i = 0; i < splits; i++) {
-                    const batch = typeIds.slice(i * batchSize, (i + 1) * batchSize);
-                    const { entityTypes } = await EntityType.GetList({
-                        api: this.api,
-                        entityTypeIds: batch
-                    });
-                    for (let i = 0; i < entityTypes.length; i++) {
-                        const entityType = entityTypes[i];
-                        typeMap.set(entityType.ID, entityType);
-                    }
+                if (this.getterLoopId != loopId) {
+                    return;
                 }
-            }
-            for (let i = 0; i < styleMapping.length; i++) {
-                if (this.disposed) {
-                    break;
+                const alt = this.viewRect.alt;
+                if (alt > MAX_HEIGHT || (alt < MIN_HEIGHT && MIN_HEIGHT > 0)) {
+                    return;
                 }
-                let styleMap = styleMapping[i];
-                if (!styleMap.style && styleMap.StyleID != -1) {
-                    let styleId = styleMap.StyleID;
-                    // Get default style of the entity type, if
-                    //no default is already specified.
-                    if (!styleId && !this.fallbackStyle) {
-                        try {
-                            let entityType = typeMap.get(styleMap.EntityTypeID);
-                            // If the map excluded the type for whatever reason we'll load it now.
-                            if (!entityType) {
-                                entityType = (await EntityType.Get({
+                const cells = this.cells.GetCellsForView(this.viewCenter, this.viewRect);
+                (_a = this.onScanUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(cells);
+                let curCellIndex = cells.length > 0 ? 0 : null;
+                let postedScanning = false;
+                let postedLoading = false;
+                let total = 0;
+                while (retryAttempts > 0 && curCellIndex != null) {
+                    if (retryDelay > 0) {
+                        await delay(retryDelay);
+                    }
+                    if (this.getterLoopId != loopId) {
+                        break;
+                    }
+                    if (!postedScanning) {
+                        this.postStatus({ msg: EStatus.Scanning, revoking: false });
+                        postedScanning = true;
+                    }
+                    const curCell = cells[curCellIndex];
+                    if (curCell.IsFetched()) {
+                        curCell.Fetching = false;
+                        curCellIndex += 1;
+                        if (cells[curCellIndex]) {
+                            cells[curCellIndex].Fetching = true;
+                        }
+                        else {
+                            curCellIndex = null;
+                        }
+                        (_b = this.onScanUpdate) === null || _b === void 0 ? void 0 : _b.Trigger(cells);
+                        continue;
+                    }
+                    try {
+                        let response = {
+                            entities: [],
+                            nextPage: false,
+                            nextPageUrl: null
+                        };
+                        await SharedGetters.Queue.Run("Loading Entities from Menu Item that loads Entity Type: " + this.typeIds, async () => {
+                            var _a;
+                            if (abortController.signal.aborted || !((_a = this.GetMenuItems()) === null || _a === void 0 ? void 0 : _a.length)) {
+                                return;
+                            }
+                            // API gave us a URL to use.
+                            if (curCell.FetchURL) {
+                                const tmpResponse = await this.api.get(curCell.FetchURL, {
+                                    abortSignal: abortController.signal,
+                                    noCache: true
+                                });
+                                // Same mapping as bruce-models doing Entity.GetList.
+                                response = {
+                                    entities: tmpResponse.Items ? tmpResponse.Items : [],
+                                    nextPage: tmpResponse.NextPage,
+                                    nextPageUrl: tmpResponse.NextPageURL
+                                };
+                            }
+                            else {
+                                response = await Entity$1.GetList({
                                     api: this.api,
-                                    entityTypeId: styleMap.EntityTypeID
-                                })).entityType;
+                                    scenario: this.scenario,
+                                    historicKey: this.historicAttrKey,
+                                    historicPoint: (this.historicAttrKey || this.historic) ? this.historicAttrDateTime : null,
+                                    schemaId: this.schemaId,
+                                    filter: {
+                                        pageSize: PAGE_SIZE,
+                                        pageIndex: curCell.FetchPageIndex,
+                                        entityTypeId: this.typeIds,
+                                        layerIds: this.tagIds,
+                                        // Any tag specified will be allowed.
+                                        layerIdsOperator: "in",
+                                        bounds: curCell.GetBounds(),
+                                        sortOrder: Api.ESortOrder.Asc,
+                                        entityTypeConditions: this.attrFilter
+                                    },
+                                    viaCdn: this.viaCdn,
+                                    migrated: true,
+                                    // If we're taking 2+ minutes to make a query, it's a dud.
+                                    // This is a timeout imposed on our DB and not external sources.
+                                    // Honestly could lower down to 30 seconds, but we'll keep it high for now.
+                                    maxSearchTimeSec: 60 * 2,
+                                    req: {
+                                        // If we are passing in an abort, we MUST pass in noCache.
+                                        // Otherwise we will cache an aborted request.
+                                        noCache: true,
+                                        abortSignal: abortController.signal
+                                    }
+                                });
+                            }
+                        });
+                        const entities = response.entities;
+                        const integrity = this.getIntegrityId();
+                        if (loopIntegrity == integrity && entities) {
+                            (_c = this.onUpdate) === null || _c === void 0 ? void 0 : _c.Trigger(entities);
+                        }
+                        if (this.gatheredIntegrity != integrity) {
+                            this.gatheredIntegrity = integrity;
+                            this.gatheredEntityIds = [];
+                        }
+                        // Add to the integrity list for any new IDs found.
+                        // This lets us keep track of all IDs we've found within the same integrity for historic data.
+                        if (this.historicAttrKey || this.historic) {
+                            for (let i = 0; i < entities.length; i++) {
+                                const entity = entities[i];
+                                if (!this.gatheredEntityIds.includes(entity.Bruce.ID)) {
+                                    this.gatheredEntityIds.push(entity.Bruce.ID);
+                                }
                             }
-                            styleId = entityType === null || entityType === void 0 ? void 0 : entityType["DisplaySetting.ID"];
                         }
-                        catch (e) {
-                            console.error(e);
+                        if (this.getterLoopId != loopId) {
+                            break;
                         }
-                    }
-                    if (styleId) {
-                        try {
-                            let { style: data } = await Style.Get({
-                                api: this.api,
-                                styleId
-                            });
-                            if (data) {
-                                styleMap.style = data;
-                                styleMap.StyleID = styleId;
-                            }
+                        if (entities.length) {
+                            total += entities.length;
                         }
-                        catch (e) {
-                            console.error(e);
+                        if (!postedLoading) {
+                            this.postStatus({ msg: EStatus.Loading, revoking: false });
+                            postedLoading = true;
                         }
-                    }
-                    if (this.loadingCounter != counter) {
-                        return;
-                    }
-                }
-                this.styleMappingsLoaded[styleMap.EntityTypeID] = true;
-                if (this.loaded) {
-                    this.processTilesetFeatureCheckQueue();
-                    this.processQueue();
-                }
-            }
-            if (this.loadingCounter != counter) {
-                return;
-            }
-            this.styleMappingLoaded = true;
-            if (!this.disposed && this.loaded) {
-                await this.processTilesetFeatureCheckQueue();
-                if (this.loadingCounter != counter) {
-                    return;
-                }
-                this.processQueue();
-            }
-        }
-        /**
-         * Monitors the Cesium viewer and updates the historic data filter values.
-         * If there is no historic attr set, this will do nothing.
-         */
-        viewerDateTimeSub() {
-            if (!this.historic || this.viewerDateTimeChangeRemoval) {
-                return;
-            }
-            // This is multiplied by the speed of animation to figure
-            // out how many animation "ticks" before we allow an update.
-            const INTERVAL_WHILE_ANIMATING = 2.5 * 1000;
-            const INTERVAL_WHILE_NOT_ANIMATING = 1000;
-            let lastUpdateTime = null;
-            let delayQueue = new DelayQueue(() => {
-                try {
-                    // If the timeline is animating then we'll wait longer to update.
-                    if (this.viewer.clock.shouldAnimate && lastUpdateTime) {
-                        if (Math.abs(new Date().getTime() - lastUpdateTime) < INTERVAL_WHILE_ANIMATING) {
-                            return;
+                        // 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 (
+                        // API explicity says no more pages.
+                        response.nextPage === false ||
+                            // API didn't explicity say anything so we guess based on size of response.
+                            (response.nextPage == null &&
+                                (entities.length <= 0 || entities.length < PAGE_SIZE))) {
+                            curCell.Fetched = true;
+                            curCell.Fetching = false;
+                            (_d = this.onScanUpdate) === null || _d === void 0 ? void 0 : _d.Trigger(cells);
+                            continue;
+                        }
+                        // Checking to make sure it's not just the same batch over and over again.
+                        if (entities.length > 0) {
+                            const first = (_f = (_e = entities[0]) === null || _e === void 0 ? void 0 : _e.Bruce) === null || _f === void 0 ? void 0 : _f.ID;
+                            const last = (_h = (_g = entities[entities.length - 1]) === null || _g === void 0 ? void 0 : _g.Bruce) === null || _h === void 0 ? void 0 : _h.ID;
+                            if (prevFirstId == first && prevLastId == last) {
+                                prevTicks += 1;
+                                if (prevTicks > 3) {
+                                    break;
+                                }
+                            }
+                            else {
+                                prevFirstId = first;
+                                prevLastId = last;
+                                prevTicks = 0;
+                            }
                         }
+                        // Using URL if specified.
+                        // If not then we'll just manually paginate.
+                        curCell.FetchURL = response.nextPageUrl;
+                        curCell.FetchPageIndex++;
+                        // Request passed so let's assume it was server hiccup and refresh counts.
+                        retryAttempts = MAX_RETRY_ATTEMPTS;
+                        retryDelay = 0;
                     }
-                    const current = this.historicAttrDateTime;
-                    this.updateHistoricDateTime();
-                    if (current != this.historicAttrDateTime) {
-                        this.emitHistoricData();
+                    catch (e) {
+                        // Ignore abort errors.
+                        if (e && typeof e === "object" && e.name == "AbortError") {
+                            // console.debug("Aborted entity-filter-getter request.");
+                            break;
+                        }
+                        console.error(e);
+                        if (this.getterLoopId != loopId) {
+                            break;
+                        }
+                        // Request failed so let's add a delay and try again soon.
+                        retryDelay += RETRY_DELAY_INCREMENT;
+                        retryAttempts -= 1;
                     }
+                    await delay(REQUEST_PAGE_DELAY);
                 }
-                catch (e) {
-                    console.error(e);
+                if (postedLoading) {
+                    this.postStatus({ msg: EStatus.Loading, revoking: true });
                 }
-            }, INTERVAL_WHILE_NOT_ANIMATING);
-            let postUpdateRemoval = this.viewer.scene.postUpdate.addEventListener(() => {
-                if (delayQueue) {
-                    delayQueue.Call();
+                if (postedScanning) {
+                    this.postStatus({ msg: EStatus.Scanning, revoking: true });
                 }
+            })().then(() => {
+                this.looping -= 1;
+            }).catch(() => {
+                this.looping -= 1;
             });
-            this.viewerDateTimeChangeRemoval = () => {
-                delayQueue === null || delayQueue === void 0 ? void 0 : delayQueue.Dispose();
-                postUpdateRemoval === null || postUpdateRemoval === void 0 ? void 0 : postUpdateRemoval();
-                delayQueue = null;
-                postUpdateRemoval = null;
-            };
-        }
-        updateHistoricDateTime() {
-            if (!this.historic) {
-                this.historicAttrDateTime = null;
-                return;
-            }
-            const isChanged = (before, after) => {
-                if (before && !after) {
-                    return true;
-                }
-                if (!before && after) {
-                    return true;
-                }
-                // Change must be at least 0.1 seconds.
-                return Math.abs(before.getTime() - after.getTime()) > 100;
-            };
-            const oldDateTime = this.historicAttrDateTime ? new Date(this.historicAttrDateTime) : null;
-            const newDateTime = JulianDate.toDate(this.viewer.clock.currentTime);
-            if (isChanged(oldDateTime, newDateTime)) {
-                this.historicAttrDateTime = newDateTime.toISOString();
-            }
-        }
-        viewerDateTimeDispose() {
-            var _a;
-            (_a = this.viewerDateTimeChangeRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
-            this.viewerDateTimeChangeRemoval = null;
         }
         /**
          * Gets the historic state of found Entities for the current date times and emits them.
          * Since geometry searches are tied to the base Entity, we don't have to re-scan the viewport.
          */
         emitHistoricData() {
-            if (this.disposed) {
+            if (!this.GetMenuItems().length) {
+                return;
+            }
+            let integrity = this.getIntegrityId();
+            // Gathered ID does't match current one.
+            if (this.gatheredIntegrity != integrity) {
                 return;
             }
             const historicAttrDateTime = this.historicAttrDateTime;
@@ -16756,29 +16973,34 @@ var TilesetRenderEngine;
                 this.historicRefreshAbortController = null;
             }
             (async () => {
-                var _a, _b;
+                var _a;
                 try {
-                    const gatheredEntityIds = Object.keys(this.styledWithAttrEntityIds);
                     // Loop through all IDs we've found and get their historic records.
-                    for (let i = 0; i < gatheredEntityIds.length; i += SCAN_BATCH_SIZE) {
-                        let batch = gatheredEntityIds.slice(i, i + SCAN_BATCH_SIZE);
+                    for (let i = 0; i < this.gatheredEntityIds.length; i += SCAN_BATCH_SIZE) {
+                        let batch = this.gatheredEntityIds.slice(i, i + SCAN_BATCH_SIZE);
                         if (!batch.length) {
                             break;
                         }
                         // Controller we can use to abort the request when a new loop starts.
                         const controller = this.historicRefreshAbortController = new AbortController();
                         let entities = [];
-                        await SharedGetters.Queue.Run("Refreshing historic data in Menu Item that loads a Tileset.", async () => {
-                            if (controller.signal.aborted || this.disposed) {
+                        await SharedGetters.Queue.Run("Refreshing historic data in Menu Item that loads Entity Type: " + this.typeIds, async () => {
+                            var _a;
+                            if (controller.signal.aborted || !((_a = this.GetMenuItems()) === null || _a === void 0 ? void 0 : _a.length)) {
                                 return;
                             }
                             entities = (await Entity$1.GetList({
                                 api: this.api,
                                 scenario: this.scenario,
+                                historicKey: this.historicAttrKey,
                                 historicPoint: historicAttrDateTime,
+                                schemaId: this.schemaId,
                                 filter: {
                                     pageSize: batch.length,
                                     pageIndex: 0,
+                                    entityTypeId: this.typeIds,
+                                    layerIds: this.tagIds,
+                                    layerIdsOperator: "in",
                                     sortOrder: Api.ESortOrder.Asc,
                                     entityTypeConditions: {
                                         "ID": {
@@ -16786,6 +17008,7 @@ var TilesetRenderEngine;
                                         }
                                     },
                                 },
+                                viaCdn: this.viaCdn,
                                 migrated: true,
                                 // If we're taking 5+ minutes to make a query, it's a dud.
                                 // This is a timeout imposed on our DB and not external sources.
@@ -16803,331 +17026,211 @@ var TilesetRenderEngine;
                         if (this.historicAttrDateTime != historicAttrDateTime) {
                             break;
                         }
-                        // Gather all Tag IDs from found Entities.
-                        let tagIds = [];
-                        for (let i = 0; i < entities.length; i++) {
-                            const entity = entities[i];
-                            if ((_b = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a["Layer.ID"]) === null || _b === void 0 ? void 0 : _b.length) {
-                                const eTagIds = entity.Bruce["Layer.ID"];
-                                for (let j = 0; j < eTagIds.length; j++) {
-                                    tagIds.push(eTagIds[j]);
-                                }
-                            }
-                        }
-                        // Turn into unique list.
-                        if (tagIds.length) {
-                            tagIds = tagIds.filter((v, i, a) => a.indexOf(v) === i);
-                        }
-                        // Gather records.
-                        let tags = [];
-                        if (tagIds.length) {
-                            tags = (await EntityTag.GetListByIds({
-                                tagIds: tagIds,
-                                api: this.api
-                            })).tags;
-                        }
-                        // Date changed.
-                        if (this.historicAttrDateTime != historicAttrDateTime) {
+                        // Integrity changed.
+                        if (this.gatheredIntegrity != integrity) {
                             break;
                         }
-                        // Style the Entities.
-                        for (let i = 0; i < entities.length; i++) {
-                            const entity = entities[i];
-                            const feature = this.getEntityRego(entity.Bruce.ID);
-                            if (feature) {
-                                const eTags = tags.filter(t => { var _a, _b, _c, _d; return ((_b = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a["Layer.ID"]) === null || _b === void 0 ? void 0 : _b.length) && ((_d = (_c = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _c === void 0 ? void 0 : _c["Layer.ID"]) === null || _d === void 0 ? void 0 : _d.includes(t.ID)); });
-                                this.styleTilesetFeatureFullData(feature, entity, eTags);
-                            }
+                        // No Menu Items.
+                        if (!this.GetMenuItems().length) {
+                            break;
                         }
+                        (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(entities);
                     }
                 }
                 catch (e) {
                     // Ignore abort errors.
                     if (e && typeof e === "object" && e.name == "AbortError") {
+                        // console.debug("Aborted entity-filter-getter historic refresh request.");
                         return;
                     }
                     console.error(e);
                 }
             })();
         }
-        getEntityTypeIdsFromModelTree(modelTree) {
-            const entityTypeIds = [];
-            this.digEntityTypeIdsFromModelTreeBranch(modelTree, entityTypeIds);
-            return entityTypeIds;
-        }
-        digEntityTypeIdsFromModelTreeBranch(branch, arr) {
-            if (branch) {
-                // Does not yet include this entity type id.
-                if (branch.typeId && !arr.includes(branch.typeId)) {
-                    arr.push(branch.typeId);
-                }
-                if (branch.children) {
-                    for (let i = 0; i < branch.children.length; i++) {
-                        let child = branch.children[i];
-                        this.digEntityTypeIdsFromModelTreeBranch(child, arr);
-                    }
-                }
-            }
+    }
+    EntityFilterGetter.Getter = Getter;
+})(EntityFilterGetter || (EntityFilterGetter = {}));
+
+function createFilterGetterCacheKey(params) {
+    let cacheKey = "";
+    cacheKey += params.api.GetBaseUrl();
+    // Not including Type ID in the cache key now.
+    // This allows us to re-use the same getter between Entity Types.
+    // cacheKey += params.typeId;
+    cacheKey += params.batchSize;
+    cacheKey += String(params.cdn);
+    cacheKey += params.schemaId ? params.schemaId : "";
+    cacheKey += JSON.stringify(params.tagIds ? params.tagIds : []);
+    cacheKey += params.historicAttrKey ? params.historicAttrKey : "";
+    cacheKey += params.historic ? "true" : "false";
+    cacheKey += params.scenario ? params.scenario : 0;
+    if (params.historicAttrKey) {
+        cacheKey += params.historicInterpolation ? "true" : "false";
+    }
+    // This could potentially crash, but if it crashes here then it would crash during API request anyways.
+    cacheKey += JSON.stringify(params.attrFilter ? params.attrFilter : {});
+    return cacheKey;
+}
+var SharedGetters;
+(function (SharedGetters) {
+    class Cache {
+        constructor() {
+            this.data = {};
         }
-        async processTilesetFeatureCheckQueue() {
-            const BATCH_CHECK_SIZE = 1000;
-            return new Promise((res) => {
-                clearInterval(this.queueCheckInterval);
-                this.queueCheckInterval = setInterval(() => {
-                    if (this.disposed) {
-                        clearInterval(this.queueCheckInterval);
-                        res();
-                        return;
-                    }
-                    // Construct batch for loaded styles.
-                    let batch = [];
-                    if (this.styleMappingLoaded) {
-                        batch = this.recordCheckQueue.splice(0, BATCH_CHECK_SIZE);
-                    }
-                    else {
-                        for (let i = 0; i < this.recordCheckQueue.length; i++) {
-                            const entityId = this.recordCheckQueue[i];
-                            const entity = this.getEntityRego(entityId);
-                            if (entity) {
-                                const entityTypeId = entity.entityTypeId;
-                                if (entityTypeId) {
-                                    if (this.styleMappingsLoaded[entityTypeId] == true) {
-                                        batch.push(entityId);
-                                    }
-                                }
+        GetOrCreateFilterGetter(params) {
+            params.cdn = Boolean(params.cdn);
+            const cacheKey = createFilterGetterCacheKey(params);
+            let getter = this.data[cacheKey];
+            if (!getter) {
+                getter = new EntityFilterGetter.Getter({
+                    api: params.api,
+                    viewer: params.viewer,
+                    viewPort: params.monitor,
+                    typeIds: !params.typeId ? null : typeof params.typeId == "string" ? [params.typeId] : params.typeId,
+                    schemaId: params.schemaId,
+                    batchSize: params.batchSize,
+                    attrFilter: params.attrFilter,
+                    historic: params.historic,
+                    historicAttrKey: params.historicAttrKey,
+                    historicInterpolation: params.historicInterpolation,
+                    viaCdn: params.cdn,
+                    scenario: params.scenario,
+                });
+                this.data[cacheKey] = getter;
+                /**
+                 * Debug option.
+                 * This will display the bounds of the cells that are being fetched.
+                 */
+                if (params.viewer && params.debugShowBounds) {
+                    // Cell id -> entity.
+                    const cellCache = {};
+                    const cellPrefix = ObjectUtils.UId(10) + "_";
+                    getter.OnScanUpdate.Subscribe((cells) => {
+                        if (window.ON_SCAN_UPDATE_PAUSED == true) {
+                            return;
+                        }
+                        const curCellIds = [];
+                        let fetchingCellId = null;
+                        const fetchedCells = {};
+                        cells.forEach((cell) => {
+                            var _a;
+                            const bounds = cell.GetBounds();
+                            const id = cellPrefix + bounds.east + "_" + bounds.north + "_" + bounds.south + "_" + bounds.west;
+                            curCellIds.push(id);
+                            fetchedCells[id] = cell.IsFetched();
+                            fetchingCellId = cell.Fetching ? id : fetchingCellId;
+                            let material = null;
+                            if (fetchedCells[id]) {
+                                material = Color.LIGHTGREEN.clone().withAlpha(0.3);
                             }
-                            if (batch.length >= BATCH_CHECK_SIZE) {
-                                break;
+                            else if (fetchingCellId == id) {
+                                material = Color.LIGHTBLUE.clone().withAlpha(0.3);
                             }
-                        }
-                        for (let i = 0; i < batch.length; i++) {
-                            const entityId = batch[i];
-                            const index = this.recordCheckQueue.findIndex(x => x == entityId);
-                            if (index > -1) {
-                                this.recordCheckQueue.splice(index, 1);
+                            else {
+                                material = Color.GOLD.clone().withAlpha(0.3);
                             }
-                        }
-                    }
-                    if (batch.length) {
-                        for (let i = 0; i < batch.length; i++) {
-                            const entityId = batch[i];
-                            const entity = this.getEntityRego(entityId);
-                            if (entity) {
-                                this.queueTilesetFeatureStyle(entity, false);
+                            if (cellCache[id]) {
+                                const rect = (_a = cellCache[id]) === null || _a === void 0 ? void 0 : _a.rectangle;
+                                if (rect) {
+                                    rect.material = material;
+                                }
+                                return;
                             }
-                        }
-                        this.viewer.scene.requestRender();
-                    }
-                    else {
-                        clearInterval(this.queueCheckInterval);
-                        res();
-                    }
-                }, 50);
-            });
-        }
-        queueTilesetFeatureStyle(entity, highPriority) {
-            // Add to the style dict if not already there.
-            // This helps us know the styling progress for things that have loaded in so far.
-            if (!this.styledEntityIds[entity.entityId]) {
-                this.styledEntityIds[entity.entityId] = null;
-            }
-            if (this.styleMappingLoaded || this.styleMappingsLoaded[entity.entityTypeId] == true) {
-                const needsData = this.getTilesetFeatureNeedsFullData(entity.entityId, entity.entityTypeId);
-                if (needsData) {
-                    if (!this.recordLoadQueue.find(x => x == entity.entityId)) {
-                        this.recordLoadQueue.push(entity.entityId);
-                    }
-                }
-                else {
-                    this.styleTilesetFeature(entity);
-                }
-            }
-            else {
-                if (highPriority) {
-                    this.recordCheckQueue.unshift(entity.entityId);
-                }
-                else {
-                    this.recordCheckQueue.push(entity.entityId);
-                }
-            }
-        }
-        styleTilesetFeature(entity) {
-            this.styleTilesetFeatureFullData(entity, null, []);
-        }
-        styleTilesetFeatureFullData(entity, data, tags) {
-            var _a, _b, _c, _d, _e, _f, _g, _h;
-            const visual = entity.visual;
-            if (!visual || !(visual instanceof Cesium3DTileFeature)) {
-                return;
-            }
-            const style = this.getTilesetFeatureStyle(entity.entityId, entity.entityTypeId);
-            const bColor = style && ((_a = style.modelStyle) === null || _a === void 0 ? void 0 : _a.fillColor) ? Calculator.GetColor(style.modelStyle.fillColor, data, tags) : null;
-            let cColor = null;
-            if (bColor == null) {
-                cColor = Color.WHITE;
-            }
-            else {
-                cColor = colorToCColor$3(bColor);
-            }
-            const override = this.styledEntityIds[entity.entityId] == true;
-            CesiumEntityStyler.SetDefaultColor({
-                color: cColor,
-                entity: visual,
-                viewer: this.viewer,
-                override: override
-            });
-            this.styledEntityIds[entity.entityId] = true;
-            if (data) {
-                this.styledWithAttrEntityIds[entity.entityId] = true;
-            }
-            else {
-                delete this.styledWithAttrEntityIds[entity.entityId];
-            }
-            this._styleProgressQueue.Call();
-            // Since we only need to update it for scenarios right now.
-            // We'll avoid doing it if not needed, eg: first render and no scenario (same state as default).
-            if (this.shouldUpdateRegoStates && (override || ((_b = data === null || data === void 0 ? void 0 : data.Bruce) === null || _b === void 0 ? void 0 : _b.Scenario) || this.historic)) {
-                // Update the Entity's rego state.
-                let changed = false;
-                // Changed scenario.
-                if (entity.scenario != ((_c = data === null || data === void 0 ? void 0 : data.Bruce) === null || _c === void 0 ? void 0 : _c.Scenario)) {
-                    entity.scenario = (_d = data === null || data === void 0 ? void 0 : data.Bruce) === null || _d === void 0 ? void 0 : _d.Scenario;
-                    changed = true;
-                }
-                // Changed historic.
-                if ((data && isHistoricMetadataChanged(entity, data)) || (!data && ((_e = entity.historicLayers) === null || _e === void 0 ? void 0 : _e.length) && !((_g = (_f = data.Bruce) === null || _f === void 0 ? void 0 : _f.HistoricLayers) === null || _g === void 0 ? void 0 : _g.length))) {
-                    entity.historicLayers = (_h = data === null || data === void 0 ? void 0 : data.Bruce) === null || _h === void 0 ? void 0 : _h.HistoricLayers;
-                    changed = true;
-                }
-                // Something changed, trigger a rego update.
-                // This lets UI know when the rego has changed.
-                if (changed) {
-                    this.register.OnUpdate.Trigger({
-                        type: VisualsRegister.EVisualUpdateType.Update,
-                        entityId: entity.entityId,
-                        rego: entity
+                            const rect = new Rectangle(Math$1.toRadians(bounds.west), Math$1.toRadians(bounds.south), Math$1.toRadians(bounds.east), Math$1.toRadians(bounds.north));
+                            const entity = params.viewer.entities.add(new Entity({
+                                id: id,
+                                rectangle: {
+                                    coordinates: rect,
+                                    fill: true,
+                                    //material: Cesium.Color.fromRandom().withAlpha(0.3),
+                                    material: material,
+                                    zIndex: 0
+                                },
+                                // point: {
+                                //     pixelSize: 15,
+                                //     outlineColor: Cesium.Color.WHITE,
+                                //     outlineWidth: 2,
+                                //     color: Cesium.Color.fromRandom().withAlpha(0.5),
+                                //     heightReference: Cesium.HeightReference.CLAMP_TO_GROUND
+                                // },
+                                position: Cartesian3.fromRadians((rect.east + rect.west) / 2, (rect.north + rect.south) / 2)
+                            }));
+                            cellCache[id] = entity;
+                        });
+                        Object.keys(cellCache).forEach((id) => {
+                            if (curCellIds.indexOf(id) == -1) {
+                                const entity = cellCache[id];
+                                if (entity && params.viewer.entities.contains(entity)) {
+                                    params.viewer.entities.remove(entity);
+                                }
+                                delete cellCache[id];
+                            }
+                        });
                     });
                 }
             }
-        }
-        getTilesetFeatureStyle(entityId, entityTypeId) {
-            var _a, _b, _c, _d;
-            // Locate what style is applicable to the feature.
-            let style = null;
-            if (entityTypeId) {
-                style = ((_b = (_a = this.styleMapping.find(x => x.EntityTypeID == entityTypeId)) === null || _a === void 0 ? void 0 : _a.style) === null || _b === void 0 ? void 0 : _b.Settings);
-            }
-            if (!style) {
-                style = ((_c = this.fallbackStyle) === null || _c === void 0 ? void 0 : _c.Settings);
-            }
-            if (!style || !((_d = style === null || style === void 0 ? void 0 : style.modelStyle) === null || _d === void 0 ? void 0 : _d.customize)) {
-                return null;
-            }
-            return style;
-        }
-        getTilesetFeatureNeedsFullData(entityId, entityTypeId) {
-            var _a;
-            if (this.historic) {
-                // Unfortunately when we are working with historic we have to request the entity.
-                // This is because we need to know if a record exists at the point in time.
-                return true;
-            }
-            const style = this.getTilesetFeatureStyle(entityId, entityTypeId);
-            if (!style) {
-                return false;
-            }
-            const fill = (_a = style === null || style === void 0 ? void 0 : style.modelStyle) === null || _a === void 0 ? void 0 : _a.fillColor;
-            if (!fill || fill.length <= 0) {
-                return false;
-            }
-            return fill[0].type != 0;
+            return getter;
         }
     }
-    TilesetRenderEngine.Styler = Styler;
-    /**
-     * 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;
+    SharedGetters.Cache = Cache;
     /**
-     * Watches tilesets in the viewer.
-     * This will regulate their max memory param.
-     * As more get watched their memory will be reduced.
+     * To avoid performing multiple expensive queries at the same time,
+     * we'll have the getters work through a queue of requests.
      */
-    class MemoryWatcher {
-        constructor(viewer) {
-            this.watched = [];
-            this.viewer = viewer;
-        }
-        distributeMemory() {
-            this.clean();
-            // Total 1gb as default.
-            // We'll need to allow user to change this somehow.
-            const maxMemory = TilesetRenderEngine.MAX_TILESET_MEMORY;
-            // Minimum memory in MB per tileset.
-            const minMemory = 80;
-            const totalPerTileset = Math.max(this.watched.length ? maxMemory / this.watched.length : maxMemory, minMemory);
-            this.watched.forEach(x => {
-                // Newer Cesium killed this property.
-                // TODO: Check if it's needed then.
-                x["maximumMemoryUsage"] = totalPerTileset;
-            });
-        }
-        destroy() {
-            this.watched = [];
-        }
+    let Queue;
+    (function (Queue) {
+        const queue = [];
+        let isProcessing = false;
         /**
-         * Remove all dead tilesets.
+         * Called to run a provided function.
+         * When the function is complete, the next function in the queue will be called.
+         * This function will resolve when the provided function is complete.
+         * If the provided function crashes, the error bubbles up to the caller.
+         * @param name
+         * @param call
          */
-        clean() {
-            // Remove all dead tilesets.
-            this.watched = this.watched.filter(x => isAlive$2(this.viewer, x));
-            // Check if viewer is destroyed.
-            if (!this.viewer || this.viewer.isDestroyed()) {
-                this.destroy();
-            }
-        }
-        Watch(tileset) {
-            if (!tileset) {
-                return;
-            }
-            if (!tileset[WATCH_KEY]) {
-                tileset[WATCH_KEY] = ObjectUtils.UId();
-            }
-            const index = this.watched.findIndex(x => x[WATCH_KEY] === tileset[WATCH_KEY]);
-            if (index >= 0) {
-                return;
-            }
-            this.watched.push(tileset);
-            this.distributeMemory();
+        function Run(name, call) {
+            // console.debug(`Queueing: ${name}`);
+            return new Promise((resolve, reject) => {
+                queue.push(async () => {
+                    try {
+                        // console.debug(`Running: ${name}`);
+                        const result = await call();
+                        resolve(result);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                    finally {
+                        // Process the next function in the queue.
+                        queue.shift();
+                        // If there are more functions in the queue, process the next one.
+                        if (queue.length > 0) {
+                            processNext();
+                        }
+                        // No more items to process.
+                        else {
+                            isProcessing = false;
+                        }
+                    }
+                });
+                if (!isProcessing) {
+                    // If not currently processing, start processing the queue.
+                    isProcessing = true;
+                    processNext();
+                }
+            });
         }
-        Unwatch(tileset) {
-            if (!tileset) {
-                return;
-            }
-            if (!tileset[WATCH_KEY]) {
-                tileset[WATCH_KEY] = ObjectUtils.UId();
-            }
-            const index = this.watched.findIndex(x => (x === null || x === void 0 ? void 0 : x[WATCH_KEY]) === tileset[WATCH_KEY]);
-            if (index > -1) {
-                this.watched.splice(index, 1);
+        Queue.Run = Run;
+        async function processNext() {
+            const nextCall = queue[0];
+            if (nextCall) {
+                // Call the next function in the queue.
+                await nextCall();
             }
-            this.distributeMemory();
-        }
-    }
-    TilesetRenderEngine.MemoryWatcher = MemoryWatcher;
-    function GetMemoryWatcher(viewer) {
-        // If viewer is dead return nothing.
-        if (!viewer || viewer.isDestroyed()) {
-            return null;
-        }
-        if (!viewer[VIEWER_WATCH_KEY]) {
-            viewer[VIEWER_WATCH_KEY] = new MemoryWatcher(viewer);
         }
-        return viewer[VIEWER_WATCH_KEY];
-    }
-    TilesetRenderEngine.GetMemoryWatcher = GetMemoryWatcher;
-})(TilesetRenderEngine || (TilesetRenderEngine = {}));
+    })(Queue = SharedGetters.Queue || (SharedGetters.Queue = {}));
+})(SharedGetters || (SharedGetters = {}));
 
 /**
  * Manager for rendering CAD tilesets.
@@ -17353,6 +17456,7 @@ var TilesetCadRenderManager;
             if (!content) {
                 return;
             }
+            const regosToQueue = new Map();
             for (let i = 0; i < content.featuresLength; i++) {
                 const feature = content.getFeature(i);
                 let rego = this.mapTilesetFeature(feature, load);
@@ -17361,9 +17465,10 @@ var TilesetCadRenderManager;
                     feature.show = true;
                     continue;
                 }
-                if (this.styler) {
-                    this.styler.QueueEntities([rego]);
-                }
+                regosToQueue.set(rego.entityId, rego);
+            }
+            if (this.styler && regosToQueue.size) {
+                this.styler.QueueEntities(Array.from(regosToQueue.values()));
             }
             this.viewer.scene.requestRender();
         }
@@ -17636,6 +17741,9 @@ var TilesetCadRenderManager;
             const api = this.getters.GetBruceApi({
                 accountId: accountId
             });
+            // Time padding in milliseconds (15 seconds).
+            // Helps account for desync between client and server.
+            const TIME_PADDING_MS = 15000;
             // 'start-stop' time string that maps to a pending request.
             // Helps us avoid repeated requests that are the same.
             const pendingRequests = new Map();
@@ -17679,29 +17787,32 @@ var TilesetCadRenderManager;
              * @returns
              */
             const checkTimelineRange = async () => {
-                const minDateTime = this.viewer.clock.startTime.toString();
-                const maxDateTime = this.viewer.clock.stopTime.toString();
+                // Current timeline range.
+                const minDateTime = new Date(this.viewer.clock.startTime.toString()).getTime();
+                const maxDateTime = new Date(this.viewer.clock.stopTime.toString()).getTime();
+                // What we have loaded.
+                const range = this.historicAnimation.getDateRange();
+                const foundMinDateTime = (range === null || range === void 0 ? void 0 : range.minDate) ? range.minDate.getTime() : null;
+                const foundMaxDateTime = (range === null || range === void 0 ? void 0 : range.maxDate) ? range.maxDate.getTime() : null;
                 // See if the current range is within the range we already have.
                 if (this.historicPosses.length > 0 &&
-                    this.historicPossesMinDateTime &&
-                    this.historicPossesMaxDateTime &&
-                    minDateTime >= this.historicPossesMinDateTime &&
-                    maxDateTime <= this.historicPossesMaxDateTime) {
+                    foundMinDateTime &&
+                    foundMaxDateTime &&
+                    minDateTime >= foundMinDateTime &&
+                    maxDateTime <= foundMaxDateTime) {
                     return;
                 }
                 // See if the requested range is before or after the range we have.
-                const fetchBefore = !this.historicPossesMinDateTime || minDateTime < this.historicPossesMinDateTime;
-                const fetchAfter = !this.historicPossesMaxDateTime || maxDateTime > this.historicPossesMaxDateTime;
+                const fetchBefore = !foundMinDateTime || minDateTime < foundMinDateTime;
+                const fetchAfter = !foundMaxDateTime || maxDateTime > foundMaxDateTime;
                 if (!fetchBefore && !fetchAfter) {
                     // Already have the data we need.
                     return;
                 }
                 // No known range so we need to fetch the whole thing.
-                if (!this.historicPossesMinDateTime || !this.historicPossesMaxDateTime) {
-                    const startTmp = JulianDate.toDate(this.viewer.clock.startTime);
-                    const stopTmp = JulianDate.toDate(this.viewer.clock.stopTime);
-                    const startStr = new Date(startTmp.getTime() - 1000).toISOString();
-                    const stopStr = new Date(stopTmp.getTime() + 1000).toISOString();
+                if (!foundMinDateTime || !foundMaxDateTime) {
+                    const startStr = new Date(minDateTime - TIME_PADDING_MS).toISOString();
+                    const stopStr = new Date(maxDateTime + TIME_PADDING_MS).toISOString();
                     const newPositions = await getPossesForRange(startStr, stopStr);
                     if (this.disposed) {
                         return;
@@ -17709,22 +17820,17 @@ var TilesetCadRenderManager;
                     if (this.historicAnimation && this.historicAnimation.addPositions) {
                         this.historicAnimation.addPositions(newPositions);
                     }
-                    this.historicPossesMinDateTime = minDateTime;
-                    this.historicPossesMaxDateTime = maxDateTime;
                 }
                 else {
                     // The data we want is before the range we've currently loaded.
                     if (fetchBefore) {
                         // Calculate the missing difference and request it.
-                        const startTmp = JulianDate.toDate(this.viewer.clock.startTime);
-                        const stopTmp = new Date(this.historicPossesMinDateTime);
-                        const startStr = new Date(startTmp.getTime() - 1000).toISOString();
-                        const stopStr = stopTmp.toISOString();
-                        getPossesForRange(startStr, stopStr).then(newPositions => {
+                        const startStr = new Date(minDateTime - TIME_PADDING_MS).toISOString();
+                        const stopStr = new Date(foundMinDateTime + TIME_PADDING_MS).toISOString();
+                        getPossesForRange(startStr, stopStr).then((newPositions) => {
                             if (this.disposed) {
                                 return;
                             }
-                            this.historicPossesMinDateTime = minDateTime;
                             if (this.historicAnimation && this.historicAnimation.addPositions) {
                                 this.historicAnimation.addPositions(newPositions);
                             }
@@ -17733,15 +17839,12 @@ var TilesetCadRenderManager;
                     // The data we want is after the range we've currently loaded.
                     if (fetchAfter) {
                         // Calculate the missing difference and request it.
-                        const startTmp = new Date(this.historicPossesMaxDateTime);
-                        const stopTmp = JulianDate.toDate(this.viewer.clock.stopTime);
-                        const startStr = startTmp.toISOString();
-                        const stopStr = new Date(stopTmp.getTime() + 1000).toISOString();
-                        getPossesForRange(startStr, stopStr).then(newPositions => {
+                        const startStr = new Date(foundMaxDateTime - TIME_PADDING_MS).toISOString();
+                        const stopStr = new Date(maxDateTime + TIME_PADDING_MS).toISOString();
+                        getPossesForRange(startStr, stopStr).then((newPositions) => {
                             if (this.disposed) {
                                 return;
                             }
-                            this.historicPossesMaxDateTime = maxDateTime;
                             if (this.historicAnimation && this.historicAnimation.addPositions) {
                                 this.historicAnimation.addPositions(newPositions);
                             }
@@ -17755,8 +17858,6 @@ var TilesetCadRenderManager;
              * @returns
              */
             const getInitialPosses = async () => {
-                const minDateTime = this.viewer.clock.startTime.toString();
-                const maxDateTime = this.viewer.clock.stopTime.toString();
                 this.historicPossesLoadingProm = new Promise(async (res) => {
                     try {
                         if (this.disposed) {
@@ -17773,8 +17874,6 @@ var TilesetCadRenderManager;
                             return;
                         }
                         this.historicPosses = positions;
-                        this.historicPossesMinDateTime = minDateTime;
-                        this.historicPossesMaxDateTime = maxDateTime;
                         res(positions);
                     }
                     catch (e) {
@@ -17800,6 +17899,13 @@ var TilesetCadRenderManager;
                         if (this.disposed) {
                             return;
                         }
+                        // Reverse heading .
+                        // Not sure if calc or model is the issue.
+                        // This is all for a single demo until we figure out how we configure assemblies for this anyways.
+                        heading = heading + 180;
+                        if (heading > 360) {
+                            heading = heading - 360;
+                        }
                         // Jank code that hacks the position to be different.
                         // This can mess up our panels so we'll need to disable editing until a better system is in place.
                         const location = Cartographic.fromCartesian(pos3d);
@@ -18592,13 +18698,17 @@ var TilesetEntitiesRenderManager;
             if (!content) {
                 return;
             }
+            const regosToQueue = new Map();
             for (let i = 0; i < content.featuresLength; i++) {
                 const feature = content.getFeature(i);
                 const rego = this.mapTilesetFeature(feature);
-                if ((rego === null || rego === void 0 ? void 0 : rego.entityId) && this.styler) {
-                    this.styler.QueueEntities([rego]);
+                if (rego === null || rego === void 0 ? void 0 : rego.entityId) {
+                    regosToQueue.set(rego.entityId, rego);
                 }
             }
+            if (this.styler && regosToQueue.size) {
+                this.styler.QueueEntities(Array.from(regosToQueue.values()));
+            }
             this.viewer.scene.requestRender();
         }
         mapTilesetFeature(feature) {
@@ -19151,13 +19261,17 @@ var TilesetArbRenderManager;
             if (!content) {
                 return;
             }
+            const regosToQueue = new Map();
             for (let i = 0; i < content.featuresLength; i++) {
                 const feature = content.getFeature(i);
                 let rego = this.mapTilesetFeature(feature);
-                if ((rego === null || rego === void 0 ? void 0 : rego.entityId) && this.styler) {
-                    this.styler.QueueEntities([rego]);
+                if (rego === null || rego === void 0 ? void 0 : rego.entityId) {
+                    regosToQueue.set(rego.entityId, rego);
                 }
             }
+            if (this.styler && regosToQueue.size) {
+                this.styler.QueueEntities(Array.from(regosToQueue.values()));
+            }
             this.viewer.scene.requestRender();
         }
         mapTilesetFeature(feature) {
@@ -30644,7 +30758,7 @@ class WidgetViewBar extends Widget.AWidget {
     }
 }
 
-const VERSION = "5.4.5";
+const VERSION = "5.4.7";
 
 export { VERSION, CesiumViewMonitor, ViewerUtils, ViewerEventTracker, MenuItemManager, isHistoricMetadataChanged, EntityRenderEngine, EntityRenderEnginePoint, EntityRenderEnginePolyline, EntityRenderEnginePolygon, EntityRenderEngineModel3d, MenuItemCreator, VisualsRegister, RenderManager, EntitiesIdsRenderManager, DataLabRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, TilesetCadRenderManager, TilesetArbRenderManager, TilesetEntitiesRenderManager, TilesetOsmRenderManager, TilesetPointcloudRenderManager, TilesetGooglePhotosRenderManager, DataSourceStaticKmlManager, GoogleSearchRenderManager, RelationsRenderManager, SharedGetters, CesiumParabola, EntityLabel, ViewRenderEngine, TileRenderEngine, TilesetRenderEngine, CESIUM_INSPECTOR_KEY, CESIUM_TIMELINE_KEY, CESIUM_TIMELINE_LIVE_KEY, CESIUM_TIMELINE_LIVE_PADDING_FORWARD_KEY, CESIUM_TIMELINE_LIVE_PADDING_BACKWARD_KEY, CESIUM_TIMELINE_INTERVAL_KEY, ViewUtils, DrawingUtils, MeasureUtils, EntityUtils, CesiumEntityStyler, CesiumAnimatedProperty, CesiumAnimatedInOut, Draw3dPolygon, Draw3dPolyline, MeasureCreator, Walkthrough, Widget, VIEWER_BOOKMARKS_WIDGET_KEY, WidgetBookmarks, WidgetBranding, WidgetCursorBar, WidgetEmbeddedInfoView, WidgetInfoView, WidgetNavCompass$$1 as WidgetNavCompass, VIEWER_VIEW_BAR_WIDGET_KEY, WidgetViewBar, WidgetControlViewBar, WidgetControlViewBarSearch, VIEWER_LEFT_PANEL_WIDGET_KEY, VIEWER_LEFT_PANEL_CSS_VAR_LEFT, WidgetLeftPanel, WidgetLeftPanelTab, WidgetLeftPanelTabBookmarks };
 //# sourceMappingURL=bruce-cesium.es5.js.map