bruce-cesium 6.6.0 → 6.6.2

package/dist/bruce-cesium.umd.js

@@ -12835,6 +12835,23 @@
             }, milliseconds);
         });
     }
+    function createBoundsPolygonGeometry(bounds) {
+        const ring = [
+            `${bounds.west},${bounds.south}`,
+            `${bounds.west},${bounds.north}`,
+            `${bounds.east},${bounds.north}`,
+            `${bounds.east},${bounds.south}`,
+            `${bounds.west},${bounds.south}`
+        ].join(" ");
+        return {
+            Polygon: [
+                {
+                    Facing: BModels.Geometry.EPolygonRingType.Boundaries,
+                    LinearRing: ring
+                }
+            ]
+        };
+    }
     /**
      * This is a batched entity getter.
      * It will scan for entity records in a view-area and emit them in batches.
@@ -12893,7 +12910,7 @@
                 // We use this for refreshing historic data without having to repeat geographic queries.
                 this.gatheredIntegrity = null;
                 this.gatheredEntityIds = [];
-                const { api, viewer, viewPort, typeIds, schemaId, batchSize, attrFilter, historicAttrKey, historicInterpolation, historic, viaCdn, scenario } = params;
+                const { api, viewer, viewPort, typeIds, schemaId, batchSize, attrFilter, historicAttrKey, historicInterpolation, historic, viaCdn, scenario, dataLab } = params;
                 this.api = api;
                 this.typeIds = typeIds;
                 this.schemaId = schemaId;
@@ -12904,6 +12921,7 @@
                 this.batchSize = isNaN(batchSize) ? 300 : batchSize;
                 this.viewPort = viewPort;
                 this.attrFilter = attrFilter;
+                this.dataLab = dataLab;
                 this.viewer = viewer;
                 this.scenario = scenario ? scenario : 0;
                 this.updateBounds();
@@ -12928,6 +12946,9 @@
                 if (this.typeIds) {
                     integrity += this.typeIds.join();
                 }
+                if (this.dataLab) {
+                    integrity += JSON.stringify(this.dataLab);
+                }
                 return integrity;
             }
             viewAreaSub() {
@@ -13034,6 +13055,22 @@
                 delete this.registeredItems[menuItemId];
                 this.updateState(true);
             }
+            Dispose() {
+                var _a, _b, _c, _d;
+                this.registeredItems = {};
+                this.getterLoopId += 1;
+                for (const key in this.getterLoopAbortControllers) {
+                    this.getterLoopAbortControllers[key].abort();
+                }
+                this.getterLoopAbortControllers = {};
+                (_a = this.historicRefreshAbortController) === null || _a === void 0 ? void 0 : _a.abort();
+                this.historicRefreshAbortController = null;
+                this.viewAreaDispose();
+                this.viewerDateTimeDispose();
+                (_b = this.onUpdate) === null || _b === void 0 ? void 0 : _b.Clear();
+                (_c = this.onStateUpdate) === null || _c === void 0 ? void 0 : _c.Clear();
+                (_d = this.onScanUpdate) === null || _d === void 0 ? void 0 : _d.Clear();
+            }
             updateBounds() {
                 const viewRect = this.viewPort.GetBounds();
                 const poi = this.viewPort.GetTarget();
@@ -13104,6 +13141,68 @@
                 this.LastStateUpdates[status.msg] = status;
                 (_a = this.onStateUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(status);
             }
+            createDataLabQuery(bounds) {
+                var _a;
+                const dataLab = this.dataLab;
+                const userItems = (dataLab === null || dataLab === void 0 ? void 0 : dataLab.queryItems) ? JSON.parse(JSON.stringify(dataLab.queryItems)) : [];
+                const primaryKey = BModels.DataLab.EReqKey.Primary;
+                const baseQuery = (dataLab === null || dataLab === void 0 ? void 0 : dataLab.query) ? JSON.parse(JSON.stringify(dataLab.query)) : {};
+                const basePrimary = (_a = baseQuery === null || baseQuery === void 0 ? void 0 : baseQuery[primaryKey]) !== null && _a !== void 0 ? _a : {};
+                const items = [
+                    {
+                        LogicOperator: "AND",
+                        AttributeValue: {
+                            AttributePath: "Bruce/Boundaries",
+                            OperandA: createBoundsPolygonGeometry(bounds),
+                            Operator: "intersects",
+                            ValueOption: "CONST"
+                        },
+                        key: "attribute"
+                    }
+                ];
+                if (userItems.length) {
+                    items.push({
+                        LogicOperator: "AND",
+                        Items: [],
+                        key: "subquery",
+                        Subquery: {
+                            Items: userItems
+                        }
+                    });
+                }
+                baseQuery[primaryKey] = {
+                    ...basePrimary,
+                    Items: items
+                };
+                baseQuery.Expand = "location,source";
+                return baseQuery;
+            }
+            async getDataLabResponse(params) {
+                var _a;
+                const { bounds, pageIndex, pageSize, abortSignal } = params;
+                const skip = pageIndex * pageSize;
+                const data = await BModels.DataLab.Run({
+                    api: this.api,
+                    query: this.createDataLabQuery(bounds),
+                    skip,
+                    load: pageSize,
+                    migrated: true,
+                    req: {
+                        noCache: true,
+                        abortSignal
+                    }
+                });
+                const entities = (_a = data.entities) !== null && _a !== void 0 ? _a : [];
+                const totalCount = data.totalCount;
+                const nextPage = totalCount != null
+                    ? skip + entities.length < totalCount
+                    : entities.length >= pageSize;
+                return {
+                    entities,
+                    nextPage,
+                    nextPageUrl: null
+                };
+            }
             startGetterLoop() {
                 // Increase id so that existing loops stop.
                 this.getterLoopId += 1;
@@ -13182,13 +13281,24 @@
                                 nextPage: false,
                                 nextPageUrl: null
                             };
-                            await exports.SharedGetters.Queue.Run("Loading Entities from Menu Item that loads Entity Type: " + this.typeIds, async () => {
+                            const queueName = this.dataLab
+                                ? "Loading DataLab Entities from Menu Item"
+                                : "Loading Entities from Menu Item that loads Entity Type: " + this.typeIds;
+                            await exports.SharedGetters.Queue.Run(queueName, async () => {
                                 var _a;
                                 if (abortController.signal.aborted || !((_a = this.GetMenuItems()) === null || _a === void 0 ? void 0 : _a.length)) {
                                     return;
                                 }
+                                if (this.dataLab) {
+                                    response = await this.getDataLabResponse({
+                                        bounds: curCell.GetBounds(),
+                                        pageIndex: curCell.FetchPageIndex,
+                                        pageSize: PAGE_SIZE,
+                                        abortSignal: abortController.signal
+                                    });
+                                }
                                 // API gave us a URL to use.
-                                if (curCell.FetchURL) {
+                                else if (curCell.FetchURL) {
                                     const tmpResponse = await this.api.get(curCell.FetchURL, {
                                         abortSignal: abortController.signal,
                                         noCache: true
@@ -13458,6 +13568,9 @@
         cacheKey += params.historicAttrKey ? params.historicAttrKey : "";
         cacheKey += params.historic ? "true" : "false";
         cacheKey += params.scenario ? params.scenario : 0;
+        if (params.dataLab) {
+            cacheKey += JSON.stringify(params.dataLab);
+        }
         if (params.historicAttrKey) {
             cacheKey += params.historicInterpolation ? "true" : "false";
         }
@@ -13488,6 +13601,7 @@
                         historicInterpolation: params.historicInterpolation,
                         viaCdn: params.cdn,
                         scenario: params.scenario,
+                        dataLab: params.dataLab,
                     });
                     this.data[cacheKey] = getter;
                     /**
@@ -14825,6 +14939,8 @@
         TilesetCadRenderManager.Manager = Manager;
     })(exports.TilesetCadRenderManager || (exports.TilesetCadRenderManager = {}));
 
+    const BATCH_SIZE$3 = 500;
+    const CHECK_BATCH_SIZE$2 = 250;
     (function (DataLabRenderManager) {
         class Manager {
             get Disposed() {
@@ -14832,7 +14948,18 @@
             }
             constructor(params) {
                 this.getter = null;
+                this.getterSub = null;
                 this.disposed = false;
+                this.renderedEntities = {};
+                this.entityCheckQueue = null;
+                this.entityCheckQueueIds = [];
+                this.isRunningCheck = false;
+                this.viewMonitorRemoval = null;
+                this.renderQueue = [];
+                this.renderQueueInterval = null;
+                this.reRenderState = new EntityReRenderMaintainState();
+                this.zoomControl = [];
+                this.queryLoadId = 0;
                 const { viewer, item, apiGetter, monitor, visualsRegister } = params;
                 this.viewer = viewer;
                 this.item = item;
@@ -14840,13 +14967,54 @@
                 this.monitor = monitor;
                 this.visualsManager = visualsRegister;
             }
-            Init() {
+            Init(params) {
                 var _a;
                 if (this.disposed) {
                     throw new Error("This manager has already been disposed.");
                 }
-                if (!((_a = this.item.CameraZoomSettings) === null || _a === void 0 ? void 0 : _a.length)) {
-                    this.item.CameraZoomSettings = [
+                if (params === null || params === void 0 ? void 0 : params.item) {
+                    this.item = params.item;
+                }
+                this.queryLoadId += 1;
+                const loadId = this.queryLoadId;
+                this.unsetGetter();
+                (_a = this.viewMonitorRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+                this.viewMonitorRemoval = null;
+                clearInterval(this.renderQueueInterval);
+                this.renderQueueInterval = null;
+                this.renderQueue = [];
+                this.renderedEntities = {};
+                this.ensureSettings();
+                this.visualsManager.RemoveRegos({
+                    menuItemId: this.item.id
+                });
+                this.setEntityCheckQueue();
+                (async () => {
+                    var _a, _b, _c, _d;
+                    try {
+                        const { query } = await BModels.DataLab.Get({
+                            api: this.apiGetter.getApi(),
+                            queryId: this.item.DataLabQueryID,
+                            req: {
+                                noCache: true
+                            }
+                        });
+                        if (this.disposed || loadId != this.queryLoadId) {
+                            return;
+                        }
+                        const queryItems = (_d = (_b = (_a = query === null || query === void 0 ? void 0 : query.PrimarySelectionCriteria) === null || _a === void 0 ? void 0 : _a.Items) !== null && _b !== void 0 ? _b : (_c = query === null || query === void 0 ? void 0 : query[BModels.DataLab.EReqKey.Primary]) === null || _c === void 0 ? void 0 : _c.Items) !== null && _d !== void 0 ? _d : [];
+                        this.setGetter(queryItems);
+                    }
+                    catch (e) {
+                        console.error("Failed to initialise DataLab render manager:", e);
+                    }
+                })();
+            }
+            ensureSettings() {
+                var _a;
+                this.zoomControl = this.item.CameraZoomSettings;
+                if (!((_a = this.zoomControl) === null || _a === void 0 ? void 0 : _a.length)) {
+                    this.zoomControl = [
                         {
                             MinZoom: 0,
                             MaxZoom: 200000,
@@ -14856,17 +15024,74 @@
                             StyleID: 0
                         }
                     ];
+                    this.item.CameraZoomSettings = this.zoomControl;
                 }
                 this.renderPriority = this.item.renderPriority;
                 if (this.renderPriority == null) {
                     this.renderPriority = 3;
                 }
-                // Perform the initial query and subscribe to updates
-                this.getter = new BatchedDataGetter.Getter([this.item.DataLabQueryID], this.monitor, 1);
-                this.getter.OnUpdate.Subscribe((queryIds) => {
-                    this.onGetterUpdate(queryIds[0]);
+            }
+            setGetter(queryItems) {
+                this.unsetGetter();
+                this.getter = new EntityFilterGetter.Getter({
+                    api: this.apiGetter.getApi(),
+                    attrFilter: {},
+                    batchSize: BATCH_SIZE$3,
+                    typeIds: null,
+                    viewPort: this.monitor,
+                    viewer: this.viewer,
+                    dataLab: {
+                        queryItems: queryItems !== null && queryItems !== void 0 ? queryItems : []
+                    }
                 });
-                this.getter.Start();
+                const minMax = exports.RenderManager.GetZoomMinMax({
+                    zoomControl: this.zoomControl
+                });
+                this.getter.IncludeMenuItem(this.item.id, null, [], minMax[0], minMax[1]);
+                this.getterSub = this.getter.OnUpdate.Subscribe((data) => {
+                    var _a;
+                    if (!((_a = data === null || data === void 0 ? void 0 : data.entities) === null || _a === void 0 ? void 0 : _a.length)) {
+                        return;
+                    }
+                    this.distributeForRender(data.entities);
+                });
+            }
+            unsetGetter() {
+                var _a, _b, _c;
+                (_a = this.getter) === null || _a === void 0 ? void 0 : _a.ExcludeMenuItem(this.item.id);
+                (_b = this.getterSub) === null || _b === void 0 ? void 0 : _b.call(this);
+                this.getterSub = null;
+                (_c = this.getter) === null || _c === void 0 ? void 0 : _c.Dispose();
+                this.getter = null;
+            }
+            setEntityCheckQueue() {
+                var _a, _b;
+                (_a = this.entityCheckQueue) === null || _a === void 0 ? void 0 : _a.Dispose();
+                this.entityCheckQueue = null;
+                const displayItems = this.zoomControl ? this.zoomControl.filter(x => x.DisplayType != BModels.ZoomControl.EDisplayType.Hidden) : [];
+                const shouldCheck = displayItems.length > 1;
+                this.entityCheckQueue = new BModels.DelayQueue(() => {
+                    this.doEntityCheck(Object.keys(this.renderedEntities));
+                }, shouldCheck ? 3000 : 30000);
+                (_b = this.viewMonitorRemoval) === null || _b === void 0 ? void 0 : _b.call(this);
+                this.viewMonitorRemoval = this.monitor.Updated().Subscribe(() => {
+                    var _a;
+                    (_a = this.entityCheckQueue) === null || _a === void 0 ? void 0 : _a.Call();
+                });
+            }
+            preventCurrentCheckApiRefresh(entityIds) {
+                var _a;
+                this.reRenderState.markSkipForCurrentRun(entityIds, this.isRunningCheck);
+                if ((_a = this.entityCheckQueueIds) === null || _a === void 0 ? void 0 : _a.length) {
+                    const lookup = {};
+                    for (let i = 0; i < entityIds.length; i++) {
+                        const id = entityIds[i];
+                        if (id) {
+                            lookup[id] = true;
+                        }
+                    }
+                    this.entityCheckQueueIds = this.entityCheckQueueIds.filter(id => !lookup[id]);
+                }
             }
             Dispose() {
                 if (this.disposed) {
@@ -14875,87 +15100,289 @@
                 this.doDispose();
             }
             doDispose() {
-                var _a;
+                var _a, _b;
                 this.disposed = true;
-                (_a = this.getter) === null || _a === void 0 ? void 0 : _a.Dispose();
+                this.queryLoadId += 1;
+                this.unsetGetter();
+                (_a = this.entityCheckQueue) === null || _a === void 0 ? void 0 : _a.Dispose();
+                this.entityCheckQueue = null;
+                (_b = this.viewMonitorRemoval) === null || _b === void 0 ? void 0 : _b.call(this);
+                this.viewMonitorRemoval = null;
+                clearInterval(this.renderQueueInterval);
+                this.renderQueueInterval = null;
+                this.renderQueue = [];
+                this.entityCheckQueueIds = [];
                 this.visualsManager.RemoveRegos({
                     menuItemId: this.item.id
                 });
             }
-            async onGetterUpdate(queryId) {
-                var _a;
-                if (this.disposed || this.viewer.isDestroyed()) {
+            async ReRender(params) {
+                let { entityIds, force, entities, maintain } = params;
+                if (this.disposed) {
                     return;
                 }
+                if (entities && !entityIds) {
+                    entityIds = entities.map(x => { var _a; return (_a = x.Bruce) === null || _a === void 0 ? void 0 : _a.ID; });
+                }
+                if (entityIds == null) {
+                    entityIds = Object.keys(this.renderedEntities);
+                }
+                entityIds = entityIds.filter((x, index) => !!x && entityIds.indexOf(x) === index);
+                if (!entityIds.length) {
+                    return;
+                }
+                if (entities === null || entities === void 0 ? void 0 : entities.length) {
+                    entities = [].concat(entities).filter(x => { var _a; return entityIds.includes((_a = x.Bruce) === null || _a === void 0 ? void 0 : _a.ID); });
+                    if (force) {
+                        this.reRenderState.bumpApiRevisions(entityIds);
+                        this.preventCurrentCheckApiRefresh(entityIds);
+                    }
+                }
+                if (maintain === true && (entities === null || entities === void 0 ? void 0 : entities.length)) {
+                    this.reRenderState.setMaintainedEntities(entities);
+                }
+                else if (maintain !== true) {
+                    this.reRenderState.clearMaintainedEntities(entityIds);
+                }
+                this.visualsManager.MarkStale({
+                    entityIds: entityIds,
+                    menuItemIds: [this.item.id]
+                });
+                if (entities === null || entities === void 0 ? void 0 : entities.length) {
+                    if (force) {
+                        await this.renderDataLabEntities(entities, true);
+                    }
+                    else {
+                        this.distributeForRender(entities);
+                    }
+                }
+                else {
+                    await this.doEntityCheck(entityIds, force);
+                }
+            }
+            UpdateSettings(params) {
+                const { zoomControl, queueRerender } = params;
+                if (this.disposed) {
+                    return;
+                }
+                if (zoomControl === null || zoomControl === void 0 ? void 0 : zoomControl.length) {
+                    this.zoomControl = zoomControl;
+                    this.item.CameraZoomSettings = zoomControl;
+                    this.setEntityCheckQueue();
+                }
+                if (queueRerender != false) {
+                    const entityIds = Object.keys(this.renderedEntities);
+                    this.visualsManager.MarkStale({
+                        entityIds,
+                        menuItemIds: [this.item.id]
+                    });
+                    this.doEntityCheck(entityIds);
+                }
+            }
+            async doEntityCheck(ids, force = false) {
+                var _a, _b, _c, _d;
+                if (this.isRunningCheck) {
+                    this.entityCheckQueueIds = this.entityCheckQueueIds.concat(ids);
+                    (_a = this.entityCheckQueue) === null || _a === void 0 ? void 0 : _a.Call();
+                    return;
+                }
+                ids = ids.concat(this.entityCheckQueueIds);
+                this.entityCheckQueueIds = [];
+                ids = ids.filter((id, index) => {
+                    return id && ids.indexOf(id) === index;
+                });
+                if (!ids.length) {
+                    return;
+                }
+                this.isRunningCheck = true;
+                const runId = this.reRenderState.startCheckRun();
+                const api = this.apiGetter.getApi();
                 try {
-                    const api = this.apiGetter.getApi();
-                    const result = await BModels.DataLab.Get({ api, queryId });
-                    const query = result.query;
-                    const queryResult = await BModels.DataLab.Run({ api, query: {
-                            [BModels.DataLab.EReqKey.Primary]: {
-                                Items: ((_a = query === null || query === void 0 ? void 0 : query.PrimarySelectionCriteria) === null || _a === void 0 ? void 0 : _a.Items) || [],
+                    if (this.disposed) {
+                        return;
+                    }
+                    const maintained = this.reRenderState.getMaintainedEntities(ids);
+                    const maintainedLookup = {};
+                    for (let i = 0; i < maintained.length; i++) {
+                        const id = (_c = (_b = maintained[i]) === null || _b === void 0 ? void 0 : _b.Bruce) === null || _c === void 0 ? void 0 : _c.ID;
+                        if (id) {
+                            maintainedLookup[id] = true;
+                        }
+                    }
+                    if (maintained.length) {
+                        if (force) {
+                            await this.renderDataLabEntities(maintained, true);
+                        }
+                        else {
+                            this.distributeForRender(maintained);
+                        }
+                    }
+                    let apiIds = ids.filter((id) => {
+                        return !maintainedLookup[id] && !this.reRenderState.shouldSkipInRun(id, runId);
+                    });
+                    const checkBatch = async () => {
+                        apiIds = this.reRenderState.filterNonSkippedIds(apiIds, runId);
+                        const entityIds = apiIds.splice(0, CHECK_BATCH_SIZE$2);
+                        if (!entityIds.length) {
+                            return;
+                        }
+                        const revisions = this.reRenderState.captureApiRevisions(entityIds);
+                        const { entities } = await BModels.Entity.GetListByIds({
+                            api,
+                            entityIds,
+                            expandSources: true,
+                            expandLocation: true,
+                            migrated: true,
+                            maxSearchTimeSec: 60 * 2
+                        });
+                        if (this.disposed) {
+                            return;
+                        }
+                        const resolved = this.reRenderState.filterCurrentApiEntities({
+                            entities,
+                            revisions,
+                            runId
+                        });
+                        if (resolved.length) {
+                            if (force) {
+                                await this.renderDataLabEntities(resolved, true);
                             }
-                        } });
-                    this.renderDataLabEntities(queryResult.entities || []);
+                            else {
+                                this.distributeForRender(resolved);
+                            }
+                        }
+                    };
+                    while (apiIds.length > 0) {
+                        await checkBatch();
+                    }
+                }
+                catch (e) {
+                    console.error(e);
                 }
-                catch (error) {
-                    console.error("Failed to perform query or render DataLab entities:", error);
+                finally {
+                    this.isRunningCheck = false;
+                    if (this.entityCheckQueueIds.length) {
+                        (_d = this.entityCheckQueue) === null || _d === void 0 ? void 0 : _d.Call(true);
+                    }
                 }
             }
-            async renderDataLabEntities(entities) {
-                if (this.disposed || this.viewer.isDestroyed()) {
+            distributeForRender(entities) {
+                if (this.disposed || !(entities === null || entities === void 0 ? void 0 : entities.length)) {
                     return;
                 }
-                const { updated, entities: cEntities } = await exports.EntityRenderEngine.Render({
-                    viewer: this.viewer,
-                    apiGetter: this.apiGetter,
-                    entities,
-                    menuItemId: this.item.id,
-                    visualRegister: this.visualsManager,
-                    zoomControl: this.item.CameraZoomSettings
-                });
+                this.renderQueue = this.renderQueue.concat(entities);
+                if (!this.renderQueueInterval && this.renderQueue.length) {
+                    this.renderQueueInterval = setInterval(() => {
+                        const batch = this.deduplicateEntities(this.renderQueue.splice(0, BATCH_SIZE$3));
+                        this.renderDataLabEntities(batch);
+                        if (this.renderQueue.length <= 0) {
+                            clearInterval(this.renderQueueInterval);
+                            this.renderQueueInterval = null;
+                        }
+                    }, 50);
+                }
+            }
+            deduplicateEntities(entities) {
+                var _a;
+                const entityMap = new Map();
                 for (let i = 0; i < entities.length; i++) {
                     const entity = entities[i];
-                    const id = entity.Bruce.ID;
-                    const cEntity = cEntities.get(id);
-                    if (cEntity) {
-                        const rego = this.visualsManager.GetRego({
-                            entityId: id,
-                            menuItemId: this.item.id
-                        });
-                        if (!rego) {
-                            this.visualsManager.AddRego({
-                                rego: {
-                                    canEdit: true,
+                    const id = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID;
+                    if (id) {
+                        entityMap.set(id, entity);
+                    }
+                }
+                return Array.from(entityMap.values());
+            }
+            async renderDataLabEntities(entities, force = false) {
+                var _a, _b, _c;
+                if (this.disposed || this.viewer.isDestroyed() || !(entities === null || entities === void 0 ? void 0 : entities.length)) {
+                    return;
+                }
+                try {
+                    const { updated, entities: cEntities } = await exports.EntityRenderEngine.Render({
+                        viewer: this.viewer,
+                        apiGetter: this.apiGetter,
+                        entities,
+                        menuItemId: this.item.id,
+                        visualRegister: this.visualsManager,
+                        zoomControl: this.zoomControl,
+                        force
+                    });
+                    if (this.disposed) {
+                        return;
+                    }
+                    for (let i = 0; i < entities.length; i++) {
+                        const entity = entities[i];
+                        const id = entity.Bruce.ID;
+                        const cEntity = cEntities.get(id);
+                        this.renderedEntities[id] = !!cEntity;
+                        if (cEntity) {
+                            const rego = this.visualsManager.GetRego({
+                                entityId: id,
+                                menuItemId: this.item.id
+                            });
+                            const canEdit = !((_a = entity.Bruce.Outline) === null || _a === void 0 ? void 0 : _a.find(x => x.Baseline && !x.Editable));
+                            const visual = rego === null || rego === void 0 ? void 0 : rego.visual;
+                            if (!visual || visual != cEntity) {
+                                this.visualsManager.AddRego({
+                                    rego: {
+                                        canEdit,
+                                        entityId: id,
+                                        schema: entity.Bruce.Schema,
+                                        menuItemId: this.item.id,
+                                        menuItemType: this.item.Type,
+                                        visual: cEntity,
+                                        priority: this.renderPriority,
+                                        entityTypeId: entity.Bruce["EntityType.ID"],
+                                        accountId: this.apiGetter.accountId,
+                                        tagIds: entity.Bruce["Layer.ID"] ? [].concat(entity.Bruce["Layer.ID"]) : [],
+                                        name: cEntity.name,
+                                        cdn: this.item.cdnEnabled,
+                                        outline: entity.Bruce.Outline
+                                    },
+                                    requestRender: false
+                                });
+                            }
+                            else if (updated.get(id) && rego) {
+                                rego.name = cEntity.name;
+                                rego.visual = cEntity;
+                                rego.entityTypeId = entity.Bruce["EntityType.ID"];
+                                rego.tagIds = entity.Bruce["Layer.ID"] ? [].concat(entity.Bruce["Layer.ID"]) : [];
+                                rego.outline = (_b = entity.Bruce) === null || _b === void 0 ? void 0 : _b.Outline;
+                                rego.cdn = this.item.cdnEnabled;
+                                rego.schema = (_c = entity.Bruce) === null || _c === void 0 ? void 0 : _c.Schema;
+                                rego.canEdit = canEdit;
+                                if (rego.stale) {
+                                    this.visualsManager.RefreshMark({
+                                        rego
+                                    });
+                                    this.visualsManager.ForceUpdate({
+                                        entityIds: [id],
+                                        refreshColors: true,
+                                        requestRender: false
+                                    });
+                                }
+                                this.visualsManager.OnUpdate.Trigger({
+                                    type: exports.VisualsRegister.EVisualUpdateType.Update,
                                     entityId: id,
-                                    menuItemId: this.item.id,
-                                    menuItemType: this.item.Type,
-                                    visual: cEntity,
-                                    priority: this.renderPriority,
-                                    entityTypeId: entity.Bruce["EntityType.ID"],
-                                    accountId: this.apiGetter.accountId,
-                                    name: cEntity.name
-                                },
+                                    rego: rego
+                                });
+                            }
+                        }
+                        else {
+                            this.visualsManager.RemoveRegos({
+                                entityId: id,
+                                menuItemId: this.item.id,
                                 requestRender: false
                             });
                         }
                     }
-                    else {
-                        this.visualsManager.RemoveRegos({
-                            entityId: id,
-                            menuItemId: this.item.id,
-                            requestRender: false
-                        });
-                    }
+                    this.viewer.scene.requestRender();
                 }
-                this.viewer.scene.requestRender();
-            }
-            async ReRender() {
-                if (this.disposed) {
-                    return;
+                catch (e) {
+                    console.error("Failed to render DataLab entities:", e);
                 }
-                // Re-perform the query and render again
-                await this.onGetterUpdate(this.item.DataLabQueryID);
             }
         }
         DataLabRenderManager.Manager = Manager;
@@ -15344,7 +15771,7 @@
     })(exports.CesiumViewMonitor || (exports.CesiumViewMonitor = {}));
 
     const MAX_BATCHES = 2;
-    const BATCH_SIZE$3 = 1000;
+    const BATCH_SIZE$4 = 1000;
     const BATCH_DELAY = 200;
     const MAX_RANGE = 3000;
     (function (TilesetOsmRenderManager) {
@@ -15558,7 +15985,7 @@
                                     const isClose = this.getIsVisualWithinRange(feature, MAX_RANGE);
                                     if (isClose) {
                                         batch.push(feature);
-                                        if (batch.length >= BATCH_SIZE$3) {
+                                        if (batch.length >= BATCH_SIZE$4) {
                                             return batch;
                                         }
                                     }
@@ -15708,7 +16135,7 @@
                             delete this._loadedCesiumEntities[key];
                             this.totalLoaded -= 1;
                             removed += 1;
-                            if (removed >= BATCH_SIZE$3) {
+                            if (removed >= BATCH_SIZE$4) {
                                 return true;
                             }
                         }
@@ -35430,7 +35857,7 @@
         }
     }
 
-    const VERSION = "6.6.0";
+    const VERSION = "6.6.2";
     /**
      * Updates the environment instance used by bruce-cesium to one specified.
      * This can be used to ensure that the instance a parent is referencing is shared between bruce-cesium, bruce-models, and the parent app.