bruce-cesium 7.3.4 → 7.3.6

package/dist/bruce-cesium.umd.js

@@ -182,6 +182,37 @@
             };
         }
         DrawingUtils.PointAcrossPolyline = PointAcrossPolyline;
+        const _sampledTerrain = new BModels.LRUCache(4000);
+        const _samplingTerrain = new Map();
+        // How precisely a sample is keyed. Roughly a metre, well under the resolution of any terrain we
+        // serve, so a camera that has not really moved asks the same question.
+        const SAMPLE_KEY_DECIMALS = 5;
+        // Identity for the provider a sample came from. Keyed on the object rather than on the tileset it
+        // was built from, so swapping terrain invalidates every height held against the old one.
+        const _providerIds = new WeakMap();
+        let _nextProviderId = 1;
+        /*
+         * Returns a stable id for a terrain provider, assigning one on first sight.
+         */
+        function terrainProviderId(provider) {
+            if (!provider) {
+                return 0;
+            }
+            let id = _providerIds.get(provider);
+            if (id == null) {
+                id = _nextProviderId++;
+                _providerIds.set(provider, id);
+            }
+            return id;
+        }
+        /**
+         * Empties the sampled terrain heights. For a terrain provider swap, or a test.
+         */
+        function ClearSampledTerrain() {
+            _sampledTerrain.Clear();
+            _samplingTerrain.clear();
+        }
+        DrawingUtils.ClearSampledTerrain = ClearSampledTerrain;
         /**
          * Returns terrain height from current viewer's provider.
          * On error or flat terrain, it will return 0.
@@ -205,17 +236,36 @@
                         height: 0
                     };
                 }
-                const sample = await Cesium.sampleTerrainMostDetailed(viewer.scene.terrainProvider, [Cesium.Cartographic.fromCartesian(pos3d)]);
-                const height = (sample === null || sample === void 0 ? void 0 : sample.length) ? sample[0].height : null;
-                if (isNaN(height)) {
-                    return {
-                        height: 0,
-                        error: "NaN"
-                    };
-                }
-                return {
-                    height: height
-                };
+                const carto = Cesium.Cartographic.fromCartesian(pos3d);
+                const key = `${terrainProviderId(viewer.scene.terrainProvider)}`
+                    + `_${carto.longitude.toFixed(SAMPLE_KEY_DECIMALS)}`
+                    + `_${carto.latitude.toFixed(SAMPLE_KEY_DECIMALS)}`;
+                const held = _sampledTerrain.Get(key);
+                if (held != null) {
+                    return { height: held };
+                }
+                // Two callers on the same point wait on the one sample rather than each asking for it.
+                const sampling = _samplingTerrain.get(key);
+                if (sampling) {
+                    return sampling;
+                }
+                const prom = Cesium.sampleTerrainMostDetailed(viewer.scene.terrainProvider, [carto])
+                    .then((sample) => {
+                    const height = (sample === null || sample === void 0 ? void 0 : sample.length) ? sample[0].height : null;
+                    if (height == null || isNaN(height)) {
+                        return {
+                            height: 0,
+                            error: "NaN"
+                        };
+                    }
+                    _sampledTerrain.Set(key, height);
+                    return { height: height };
+                })
+                    .finally(() => {
+                    _samplingTerrain.delete(key);
+                });
+                _samplingTerrain.set(key, prom);
+                return prom;
             }
             catch (e) {
                 return {
@@ -10993,6 +11043,22 @@
             return Math.round(minMs + ((maxMs - minMs) * progress));
         }
         HistoricFetchOrder.IntervalFor = IntervalFor;
+        /**
+         * Returns the cadence for a set of this size on a clock running at this rate.
+         * @param entityCount
+         * @param multiplier the viewer clock's, ie. scene seconds per real second
+         */
+        function IntervalForClock(entityCount, multiplier) {
+            const bySize = IntervalFor(entityCount);
+            const rate = Math.abs(multiplier);
+            if (!(rate > 0)) {
+                return HistoricFetchOrder.MAX_INTERVAL_MS;
+            }
+            // How long one second of scene time takes to pass, which is how often a record can appear.
+            const perRecord = 1000 / rate;
+            return Math.min(HistoricFetchOrder.MAX_INTERVAL_MS, Math.max(bySize, perRecord));
+        }
+        HistoricFetchOrder.IntervalForClock = IntervalForClock;
         // Upper bounds in metres for the distance bands, nearest first.
         HistoricFetchOrder.DEFAULT_BANDS = [500, 2000, 10000, 50000];
         /**
@@ -11375,7 +11441,8 @@
          * Returns how long to wait between refreshes for a set of this size.
          */
         IntervalFor(entityCount) {
-            return HistoricFetchOrder.IntervalFor(entityCount);
+            var _a, _b, _c;
+            return HistoricFetchOrder.IntervalForClock(entityCount, (_c = (_b = (_a = this.params.viewer) === null || _a === void 0 ? void 0 : _a.clock) === null || _b === void 0 ? void 0 : _b.multiplier) !== null && _c !== void 0 ? _c : 1);
         }
         /**
          * Fetches whatever the current clock range needs that is not already held.
@@ -13685,6 +13752,7 @@
                 this.renderQueueForceFlags = [];
                 this.reRenderState = new EntityReRenderMaintainState();
                 const { viewer, apiGetter, monitor, item, register: visualsManager } = params;
+                this.sharedHistoric = params.sharedHistoric;
                 this.viewer = viewer;
                 this.apiGetter = apiGetter;
                 this.monitor = monitor;
@@ -13819,6 +13887,51 @@
                     this.onGetterUpdate(entityIds);
                 }
             }
+            /*
+             * The lane this item reads through, or null when it does not follow the clock.
+             */
+            getHistoricLane() {
+                var _a, _b, _c;
+                if (!this.sharedHistoric ||
+                    (!((_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historic) && !((_b = this.item.BruceEntity) === null || _b === void 0 ? void 0 : _b.historicAttrKey))) {
+                    return null;
+                }
+                if (!this.historicLane) {
+                    const historicKey = (_c = this.item.BruceEntity) === null || _c === void 0 ? void 0 : _c.historicAttrKey;
+                    this.historicLane = this.sharedHistoric.GetOrCreateLane({
+                        baseUrl: this.apiGetter.getApi().GetBaseUrl(),
+                        attrKey: historicKey,
+                        getMinIntervalMs: () => this.historicGatherer.IntervalFor(Object.keys(this.renderedEntities).length),
+                        subscribeToChanges: (onChanged) => {
+                            var _a;
+                            const feed = (_a = this.apiGetter.getApi()) === null || _a === void 0 ? void 0 : _a.RecordChangeFeed;
+                            if (!feed) {
+                                return null;
+                            }
+                            return feed.Subscribe({
+                                concepts: [BModels.AccountConcept.EConcept.ENTITY],
+                                actions: ["C", "U"]
+                            }, (event) => {
+                                if (typeof event.data === "string" && event.data) {
+                                    onChanged(event.data);
+                                }
+                            });
+                        },
+                        isFeedConnected: () => { var _a, _b; return Boolean((_b = (_a = this.apiGetter.getApi()) === null || _a === void 0 ? void 0 : _a.RecordChangeFeed) === null || _b === void 0 ? void 0 : _b.IsConnected); },
+                        read: (entityIds, at) => BModels.Entity.GetListByIds({
+                            api: this.apiGetter.getApi(),
+                            entityIds: entityIds,
+                            historicPoint: new Date(at).toISOString(),
+                            historicKey: historicKey,
+                            expandSources: true,
+                            expandLocation: true,
+                            migrated: true,
+                            maxSearchTimeSec: 60 * 5,
+                        }).then(res => res.entities || [])
+                    });
+                }
+                return this.historicLane;
+            }
             async onGetterUpdate(entityIds, force = false) {
                 var _a, _b;
                 if (this.disposed || this.viewer.isDestroyed() || !(entityIds === null || entityIds === void 0 ? void 0 : entityIds.length)) {
@@ -13840,25 +13953,23 @@
                     if (!apiIds.length) {
                         return;
                     }
-                    const api = this.apiGetter.getApi();
                     const revisions = this.reRenderState.captureApiRevisions(apiIds);
-                    let newDateTime = null;
-                    if (this.item.BruceEntity.historic || this.item.BruceEntity.historicAttrKey) {
-                        newDateTime = Cesium.JulianDate.toDate(this.viewer.clock.currentTime).toISOString();
-                    }
-                    const { entities } = await BModels.Entity.GetListByIds({
-                        api,
-                        entityIds: apiIds,
-                        historicPoint: newDateTime,
-                        historicKey: this.item.BruceEntity.historicAttrKey,
-                        expandSources: true,
-                        expandLocation: true,
-                        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,
-                    });
+                    const lane = this.getHistoricLane();
+                    const entities = lane
+                        ? await lane.Request({
+                            subscriberId: this.item.id,
+                            entityIds: apiIds,
+                            at: Cesium.JulianDate.toDate(this.viewer.clock.currentTime).getTime(),
+                            force: force
+                        })
+                        : (await BModels.Entity.GetListByIds({
+                            api: this.apiGetter.getApi(),
+                            entityIds: apiIds,
+                            expandSources: true,
+                            expandLocation: true,
+                            migrated: true,
+                            maxSearchTimeSec: 60 * 5,
+                        })).entities;
                     const resolved = this.reRenderState.filterCurrentApiEntities({
                         entities,
                         revisions
@@ -14074,6 +14185,7 @@
                         return;
                     }
                     prevTick = currentTick;
+                    queue.delay = this.historicGatherer.IntervalFor(Object.keys(this.renderedEntities).length);
                     queue.Call();
                 });
                 this.viewerDateTimeChangeRemoval = () => {
@@ -14086,9 +14198,11 @@
                 };
             }
             viewerDateTimeDispose() {
-                var _a;
+                var _a, _b;
                 (_a = this.viewerDateTimeChangeRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
                 this.viewerDateTimeChangeRemoval = null;
+                // Whatever this item was waiting on is nobody's answer now.
+                (_b = this.historicLane) === null || _b === void 0 ? void 0 : _b.Drop(this.item.id);
             }
         }
         EntitiesIdsRenderManager.Manager = Manager;
@@ -19498,6 +19612,351 @@
         DataLabRenderManager.Manager = Manager;
     })(exports.DataLabRenderManager || (exports.DataLabRenderManager = {}));
 
+    /**
+     * The shared read path for Entities whose position comes from the clock.
+     */
+    var SharedHistoricGetters;
+    (function (SharedHistoricGetters) {
+        // The floor between two reads on a lane, so a fast server is not read from as fast as it answers.
+        SharedHistoricGetters.DEFAULT_MIN_INTERVAL_MS = 250;
+        // How far from a held answer's instant it still answers a new ask.
+        SharedHistoricGetters.DEFAULT_FRESH_MS = 200;
+        // How slow the idle backoff is allowed to make a lane.
+        SharedHistoricGetters.DEFAULT_MAX_INTERVAL_MS = 3000;
+        // How many unchanged reads it takes to reach that, doubling the wait each time.
+        SharedHistoricGetters.IDLE_DOUBLINGS = 6;
+        // The idle cap while a record change feed is connected.
+        SharedHistoricGetters.FEED_MAX_INTERVAL_MS = 15000;
+        /*
+         * What an Entity looks like to the idle check: where it is, how it is turned, and when it was last written.
+         */
+        function SignatureOf(entity) {
+            const bruce = entity === null || entity === void 0 ? void 0 : entity.Bruce;
+            if (!bruce) {
+                return "";
+            }
+            const location = bruce.Location;
+            const transform = bruce.Transform;
+            return [
+                bruce.Updated || "",
+                location ? `${location.latitude},${location.longitude},${location.altitude}` : "",
+                transform ? `${transform.heading},${transform.pitch},${transform.roll}` : ""
+            ].join("|");
+        }
+        SharedHistoricGetters.SignatureOf = SignatureOf;
+        /**
+         * One read path, shared by every manager reading the same Entities the same way.
+         */
+        class Lane {
+            constructor(params) {
+                this.params = params;
+                // Subscriber to their one outstanding ask.
+                this.pending = new Map();
+                this.inFlight = false;
+                this.lastSentAt = 0;
+                this.pumpTimeout = null;
+                // Set between an ask arriving and the pump running, so asks made in the same turn merge.
+                this.pumpScheduled = false;
+                this.disposed = false;
+                // The last answer, kept so an ask that lands beside it is served rather than sent.
+                this.held = null;
+                // Entity id to what it looked like on the last read, for deciding whether anything moved.
+                this.heldSignatures = {};
+                // How many reads in a row have come back saying the same thing.
+                this.idleReads = 0;
+                // Entity internal id to its id, for matching what the feed reports against what is held.
+                this.heldInternalIds = new Map();
+                this.feedRemoval = null;
+                this.feedWired = false;
+            }
+            /**
+             * Asks for these Entities at this instant, resolving with them however the lane gets there:
+             * from the held answer, from a read already about to happen, or from one this ask starts.
+             */
+            Request(ask) {
+                if (this.disposed) {
+                    return Promise.resolve([]);
+                }
+                this.wireFeed();
+                if (ask.force) {
+                    this.idleReads = 0;
+                }
+                const fresh = this.freshAnswerFor(ask);
+                if (fresh) {
+                    return Promise.resolve(fresh);
+                }
+                return new Promise((resolve, reject) => {
+                    // Whoever was waiting on this subscriber's previous ask is answered by this one, so
+                    // they are handed the newer read rather than left hanging on a dropped request.
+                    const superseded = this.pending.get(ask.subscriberId);
+                    this.pending.set(ask.subscriberId, {
+                        ask,
+                        resolve: (entities) => {
+                            superseded === null || superseded === void 0 ? void 0 : superseded.resolve(entities);
+                            resolve(entities);
+                        },
+                        reject: (error) => {
+                            superseded === null || superseded === void 0 ? void 0 : superseded.reject(error);
+                            reject(error);
+                        }
+                    });
+                    this.schedulePump();
+                });
+            }
+            /**
+             * Forgets a subscriber, for a manager that has been disposed while it was waiting.
+             */
+            Drop(subscriberId) {
+                const waiter = this.pending.get(subscriberId);
+                if (waiter) {
+                    this.pending.delete(subscriberId);
+                    waiter.resolve([]);
+                }
+            }
+            /**
+             * Tells the lane that records it holds have changed, so its next read happens on the caller's
+             * cadence rather than behind whatever backoff a quiet spell had earned.
+             */
+            NotifyChanged() {
+                if (this.disposed) {
+                    return;
+                }
+                this.idleReads = 0;
+                this.schedulePump();
+            }
+            /**
+             * The same, for a feed event naming Entity internal ids as ranges.
+             * @param rangeString as reported by the record change feed.
+             */
+            NotifyChangedRange(rangeString) {
+                if (this.disposed || !rangeString || !this.heldInternalIds.size) {
+                    return;
+                }
+                for (const internalId of Array.from(this.heldInternalIds.keys())) {
+                    if (BModels.RecordChangeFeed.isEntityInternalIdInRangeString(rangeString, internalId)) {
+                        this.NotifyChanged();
+                        return;
+                    }
+                }
+            }
+            Dispose() {
+                var _a;
+                this.disposed = true;
+                (_a = this.feedRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+                this.feedRemoval = null;
+                if (this.pumpTimeout != null) {
+                    clearTimeout(this.pumpTimeout);
+                    this.pumpTimeout = null;
+                }
+                for (const waiter of Array.from(this.pending.values())) {
+                    waiter.resolve([]);
+                }
+                this.pending.clear();
+                this.held = null;
+                this.heldSignatures = {};
+                this.heldInternalIds.clear();
+            }
+            /**
+             * How many reads in a row have come back unchanged, which is what the wait is scaled by.
+             */
+            get IdleReads() {
+                return this.idleReads;
+            }
+            /**
+             * The wait the lane would apply before its next read,
+             * ie. the caller's cadence after however far the idle backoff has widened it.
+             */
+            get IntervalMs() {
+                return this.intervalNow();
+            }
+            /**
+             * What the lane is currently holding, for a caller that wants it without asking for a read.
+             */
+            get Held() {
+                return this.held;
+            }
+            /*
+             * The wait before the next read: the caller's cadence, widened while nothing is changing.
+             */
+            intervalNow() {
+                var _a, _b, _c;
+                const base = this.params.getMinIntervalMs
+                    ? this.params.getMinIntervalMs() : SharedHistoricGetters.DEFAULT_MIN_INTERVAL_MS;
+                if (!this.idleReads) {
+                    return base;
+                }
+                const maxInterval = (_a = this.params.maxIntervalMs) !== null && _a !== void 0 ? _a : (((_c = (_b = this.params).isFeedConnected) === null || _c === void 0 ? void 0 : _c.call(_b)) ? SharedHistoricGetters.FEED_MAX_INTERVAL_MS : SharedHistoricGetters.DEFAULT_MAX_INTERVAL_MS);
+                const widened = base * Math.pow(2, Math.min(this.idleReads, SharedHistoricGetters.IDLE_DOUBLINGS));
+                return Math.min(Math.max(base, maxInterval), widened);
+            }
+            /*
+             * Returns the held answer when it covers this ask, or null when a read is needed.
+             */
+            freshAnswerFor(ask) {
+                var _a;
+                const freshMs = (_a = this.params.freshMs) !== null && _a !== void 0 ? _a : SharedHistoricGetters.DEFAULT_FRESH_MS;
+                if (ask.force || !this.held || Math.abs(ask.at - this.held.at) > freshMs) {
+                    return null;
+                }
+                const entities = [];
+                for (const entityId of ask.entityIds) {
+                    const entity = this.held.byId[entityId];
+                    // A partial answer is not an answer: the Entity may simply never have been asked for.
+                    if (!entity) {
+                        return null;
+                    }
+                    entities.push(entity);
+                }
+                return entities;
+            }
+            /*
+             * Subscribes to the record change feed, on the first ask that finds one.
+             */
+            wireFeed() {
+                if (this.feedWired || !this.params.subscribeToChanges) {
+                    return;
+                }
+                const removal = this.params.subscribeToChanges((rangeString) => this.NotifyChangedRange(rangeString));
+                if (!removal) {
+                    return;
+                }
+                this.feedWired = true;
+                this.feedRemoval = removal;
+            }
+            /*
+             * Runs the pump at the end of this turn rather than during it.
+             */
+            schedulePump() {
+                if (this.pumpScheduled || this.disposed) {
+                    return;
+                }
+                this.pumpScheduled = true;
+                Promise.resolve().then(() => {
+                    this.pumpScheduled = false;
+                    this.pump();
+                });
+            }
+            /*
+             * Sends the next read when there is one to send and the lane is free to send it.
+             */
+            pump() {
+                var _a;
+                if (this.disposed || this.inFlight || !this.pending.size) {
+                    return;
+                }
+                const now = ((_a = this.params.now) !== null && _a !== void 0 ? _a : Date.now)();
+                const waitFor = (this.lastSentAt + this.intervalNow()) - now;
+                if (waitFor > 0) {
+                    // The pending map keeps absorbing asks meanwhile, so what eventually goes is the
+                    // union of everything wanted during the wait rather than the ask that started it.
+                    if (this.pumpTimeout == null) {
+                        this.pumpTimeout = setTimeout(() => {
+                            this.pumpTimeout = null;
+                            this.pump();
+                        }, waitFor);
+                    }
+                    return;
+                }
+                // Taken now rather than when each ask arrived, which is what makes an overtaken ask cost
+                // nothing: it is simply part of this read instead of a read of its own.
+                const waiters = Array.from(this.pending.values());
+                this.pending.clear();
+                const entityIds = [];
+                const seen = {};
+                let at = 0;
+                for (const waiter of waiters) {
+                    at = Math.max(at, waiter.ask.at);
+                    for (const entityId of waiter.ask.entityIds) {
+                        if (entityId && !seen[entityId]) {
+                            seen[entityId] = true;
+                            entityIds.push(entityId);
+                        }
+                    }
+                }
+                if (!entityIds.length) {
+                    for (const waiter of waiters) {
+                        waiter.resolve([]);
+                    }
+                    return;
+                }
+                this.inFlight = true;
+                this.lastSentAt = now;
+                this.params.read(entityIds, at).then((entities) => {
+                    var _a, _b, _c;
+                    const signatureOf = (_a = this.params.signatureOf) !== null && _a !== void 0 ? _a : SignatureOf;
+                    const byId = {};
+                    let changed = false;
+                    for (const entity of entities || []) {
+                        const id = (_b = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _b === void 0 ? void 0 : _b.ID;
+                        if (!id) {
+                            continue;
+                        }
+                        byId[id] = entity;
+                        const internalId = (_c = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _c === void 0 ? void 0 : _c.InternalID;
+                        if (internalId != null) {
+                            this.heldInternalIds.set(internalId, id);
+                        }
+                        const signature = signatureOf(entity);
+                        // An Entity read for the first time is not a change: there is nothing it differs
+                        // from, and counting it as one would restart the backoff on every widened set.
+                        if (this.heldSignatures[id] != null && this.heldSignatures[id] !== signature) {
+                            changed = true;
+                        }
+                        this.heldSignatures[id] = signature;
+                    }
+                    this.idleReads = changed ? 0 : this.idleReads + 1;
+                    this.held = { at, byId };
+                    for (const waiter of waiters) {
+                        waiter.resolve(waiter.ask.entityIds.map(id => byId[id]).filter(x => !!x));
+                    }
+                }).catch((error) => {
+                    for (const waiter of waiters) {
+                        waiter.reject(error);
+                    }
+                }).finally(() => {
+                    this.inFlight = false;
+                    this.schedulePump();
+                });
+            }
+        }
+        SharedHistoricGetters.Lane = Lane;
+        /**
+         * The lanes in play, keyed so that two managers reading the same Entities the same way land on the same one.
+         */
+        class Cache {
+            constructor() {
+                this.lanes = {};
+            }
+            /**
+             * Returns the lane for this endpoint and attribute key, creating it on first use.
+             * @param params
+             */
+            GetOrCreateLane(params) {
+                const key = `${params.baseUrl}|${params.attrKey || ""}`;
+                let lane = this.lanes[key];
+                if (!lane) {
+                    lane = new Lane({
+                        read: params.read,
+                        getMinIntervalMs: params.getMinIntervalMs,
+                        freshMs: params.freshMs,
+                        maxIntervalMs: params.maxIntervalMs,
+                        subscribeToChanges: params.subscribeToChanges,
+                        isFeedConnected: params.isFeedConnected
+                    });
+                    this.lanes[key] = lane;
+                }
+                return lane;
+            }
+            Dispose() {
+                for (const key of Object.keys(this.lanes)) {
+                    this.lanes[key].Dispose();
+                }
+                this.lanes = {};
+            }
+        }
+        SharedHistoricGetters.Cache = Cache;
+    })(SharedHistoricGetters || (SharedHistoricGetters = {}));
+
     const DEFAULT_GROUNDED_HEIGHT = 300;
     const MINIMUM_VIEW_AREA_SIZE_DEGREES = 0.01;
     const NET_STEP_PERCENT = 5;
@@ -24824,6 +25283,7 @@
                 }
                 this.visualsRegister = visualsRegister;
                 this.sharedGetters = new exports.SharedGetters.Cache();
+                this.sharedHistoric = new SharedHistoricGetters.Cache();
                 this.sharedMonitor = new exports.CesiumViewMonitor.Monitor(this.viewer);
                 this.tilesetInitQueue = new InitQueueTileset(this.getters);
             }
@@ -24832,7 +25292,7 @@
              * This will dispose all render managers and unregister all menu items.
              */
             Dispose(params) {
-                var _a, _b;
+                var _a, _b, _c;
                 const { disposeRegister } = params !== null && params !== void 0 ? params : {};
                 for (let i = 0; i < this.items.length; i++) {
                     const item = this.items[i];
@@ -24847,6 +25307,7 @@
                 this.FlushPendingHandoffs();
                 this.tilesetInitQueue.Dispose();
                 (_b = this.sharedMonitor) === null || _b === void 0 ? void 0 : _b.Dispose();
+                (_c = this.sharedHistoric) === null || _c === void 0 ? void 0 : _c.Dispose();
                 if (this.visualsRegister && disposeRegister != false) {
                     this.visualsRegister.Dispose();
                 }
@@ -25054,7 +25515,8 @@
                                 register: this.visualsRegister,
                                 apiGetter: params.apiGetter,
                                 monitor: this.sharedMonitor,
-                                item: params.item
+                                item: params.item,
+                                sharedHistoric: this.sharedHistoric
                             });
                             break;
                         case BModels.MenuItem.EType.Entity:
@@ -33005,12 +33467,11 @@
         }
     }
 
-    var ECursor;
     (function (ECursor) {
         ECursor["Select"] = "select";
         ECursor["Pan"] = "pan";
         ECursor["Measure"] = "measure";
-    })(ECursor || (ECursor = {}));
+    })(exports.ECursor || (exports.ECursor = {}));
     var ESecondaryCursor;
     (function (ESecondaryCursor) {
         ESecondaryCursor["None"] = "none";
@@ -33024,15 +33485,33 @@
         constructor(params) {
             super(params);
             this.STYLESHEET_ID = "nextspace-cursorbar-stylesheet";
-            this._selectedCursor = ECursor.Select;
+            this._selectedCursor = exports.ECursor.Select;
             this._selectedSecondaryCursor = ESecondaryCursor.None;
             this.OnCursorChange = new BModels.BruceEvent();
             this._generateStyles();
             this._generateElement();
-            if (this._selectedCursor == ECursor.Select || this._selectedSecondaryCursor == ESecondaryCursor.Select) {
+            if (this._selectedCursor == exports.ECursor.Select || this._selectedSecondaryCursor == ESecondaryCursor.Select) {
                 this._listenSelection();
             }
         }
+        /**
+         * @param cursor
+         */
+        SetCursor(cursor) {
+            if (cursor == this._selectedCursor) {
+                return;
+            }
+            this._disposeMeasureTool();
+            this._disposeCesiumEvent();
+            this._selectedCursor = cursor;
+            this._selectedSecondaryCursor = ESecondaryCursor.None;
+            this._secondary.style.display = "none";
+            if (cursor == exports.ECursor.Select) {
+                this._listenSelection();
+            }
+            this._updateControls();
+            this.OnCursorChange.Trigger(cursor);
+        }
         Dispose() {
             var _a, _b;
             super.Dispose();
@@ -33283,8 +33762,8 @@
                 <path d="M11.0706 25L9 7L23 17.8592L15.3135 18.3375L11.0706 25Z" fill="white" stroke="white" strokeLinejoin="round"/>
             </svg>
         `;
-            this._generateControl("Select", ECursor.Select, () => {
-                this._selectedCursor = ECursor.Select;
+            this._generateControl("Select", exports.ECursor.Select, () => {
+                this._selectedCursor = exports.ECursor.Select;
                 this._secondary.style.display = "none";
                 this._listenSelection();
                 this.OnCursorChange.Trigger(this._selectedCursor);
@@ -33296,10 +33775,10 @@
                 <path d="M15.5652 6C14.9172 6 14.3913 6.51692 14.3913 7.15385V14.4615H13.6087V8.69231C13.6087 8.05538 13.0828 7.53846 12.4348 7.53846C11.7868 7.53846 11.2609 8.05538 11.2609 8.69231V14.4615V16.7692V19.6734C11.2609 19.6734 9.0069 18.2402 7.87211 17.7548C7.55594 17.6194 7.22575 17.5385 6.89079 17.5385C5.1401 17.5385 5 19.0769 5 19.0769L8.13043 21.3846L10.6357 24.3398C11.5279 25.3922 12.85 26 14.243 26H19.8696C21.5983 26 23 24.6223 23 22.9231V14.4615V11C23 10.3631 22.4741 9.84615 21.8261 9.84615C21.1781 9.84615 20.6522 10.3631 20.6522 11V14.4615H19.8696V8.69231C19.8696 8.05538 19.3437 7.53846 18.6957 7.53846C18.0477 7.53846 17.5217 8.05538 17.5217 8.69231V14.4615H16.7391V7.15385C16.7391 6.51692 16.2132 6 15.5652 6Z" fill="white"/>
             </svg>
         `;
-            this._generateControl("Pan", ECursor.Pan, () => {
-                this._selectedCursor = this._selectedCursor == ECursor.Pan ? ECursor.Select : ECursor.Pan;
+            this._generateControl("Pan", exports.ECursor.Pan, () => {
+                this._selectedCursor = this._selectedCursor == exports.ECursor.Pan ? exports.ECursor.Select : exports.ECursor.Pan;
                 this._secondary.style.display = "none";
-                if (this._selectedCursor == ECursor.Select) {
+                if (this._selectedCursor == exports.ECursor.Select) {
                     this._listenSelection();
                 }
                 this.OnCursorChange.Trigger(this._selectedCursor);
@@ -33311,17 +33790,17 @@
                 <path d="M26.5044 8.88032C26.1735 8.54947 23.4505 5.8265 23.1197 5.49564C22.4588 4.83479 21.3876 4.83479 20.7267 5.49564C20.6878 5.53457 20.4449 5.77742 20.0557 6.16666L21.6753 7.78623C22.0061 8.11708 22.0061 8.65186 21.6753 8.98271C21.5103 9.14771 21.2936 9.23064 21.077 9.23064C20.8604 9.23064 20.6438 9.14771 20.4788 8.98271L18.8592 7.36314C18.4581 7.76423 18.0063 8.21608 17.5172 8.70517L18.2906 9.47857C18.6214 9.80942 18.6214 10.3442 18.2906 10.6751C18.1256 10.8401 17.909 10.923 17.6923 10.923C17.4757 10.923 17.2591 10.8401 17.0941 10.6751L16.3207 9.90165C15.8875 10.3349 15.4381 10.7842 14.9787 11.2437L16.5982 12.8632C16.9291 13.1941 16.9291 13.7289 16.5982 14.0597C16.4332 14.2247 16.2166 14.3077 16 14.3077C15.7834 14.3077 15.5668 14.2247 15.4018 14.0597L13.7822 12.4402C13.3363 12.8861 12.8869 13.3354 12.4402 13.7822L13.2136 14.5556C13.5444 14.8864 13.5444 15.4212 13.2136 15.7521C13.0486 15.9171 12.8319 16 12.6153 16C12.3987 16 12.1821 15.9171 12.0171 15.7521L11.2437 14.9787C10.7842 15.4381 10.3349 15.8875 9.90165 16.3207L11.5212 17.9403C11.8521 18.2711 11.8521 18.8059 11.5212 19.1368C11.3562 19.3018 11.1396 19.3847 10.923 19.3847C10.7064 19.3847 10.4897 19.3018 10.3247 19.1368L8.70517 17.5172C8.21608 18.0063 7.76423 18.4581 7.36314 18.8592L8.13654 19.6326C8.46739 19.9635 8.46739 20.4982 8.13654 20.8291C7.97154 20.9941 7.75492 21.077 7.5383 21.077C7.32168 21.077 7.10506 20.9941 6.94006 20.8291L6.16666 20.0557C5.77742 20.4449 5.53457 20.6878 5.49564 20.7267C4.83479 21.3876 4.83479 22.4588 5.49564 23.1197C5.8265 23.4505 8.54947 26.1735 8.88032 26.5044C9.54118 27.1652 10.6124 27.1652 11.2733 26.5044C11.6041 26.1735 26.1735 11.6041 26.5044 11.2733C27.1652 10.6124 27.1652 9.54118 26.5044 8.88032Z" fill="white"/>
             </svg>
         `;
-            this._generateControl("Measure", ECursor.Measure, () => {
+            this._generateControl("Measure", exports.ECursor.Measure, () => {
                 this._selectedSecondaryCursor = ESecondaryCursor.Pan;
-                this._selectedCursor = this._selectedCursor == ECursor.Measure ? ECursor.Select : ECursor.Measure;
-                if (this._selectedCursor == ECursor.Measure) {
+                this._selectedCursor = this._selectedCursor == exports.ECursor.Measure ? exports.ECursor.Select : exports.ECursor.Measure;
+                if (this._selectedCursor == exports.ECursor.Measure) {
                     this._generateMeasureSecondary();
                     this._updateSecondary();
                 }
                 else {
                     this._secondary.style.display = "none";
                 }
-                if (this._selectedCursor == ECursor.Select) {
+                if (this._selectedCursor == exports.ECursor.Select) {
                     this._listenSelection();
                 }
                 this.OnCursorChange.Trigger(this._selectedCursor);
@@ -46914,7 +47393,7 @@ void main() {
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.StyleUtils = {}));
 
-    const VERSION = "7.3.4";
+    const VERSION = "7.3.6";
     /**
      * 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.