bruce-cesium 7.3.4 → 7.3.5

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:
@@ -46914,7 +47376,7 @@ void main() {
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.StyleUtils = {}));
 
-    const VERSION = "7.3.4";
+    const VERSION = "7.3.5";
     /**
      * 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.