bruce-cesium 7.6.7 → 7.6.9

package/dist/bruce-cesium.umd.js

@@ -16525,18 +16525,70 @@
         }
         MenuItemStyleOverlay.With = With;
         /**
-         * Returns true when the two items differ by nothing but their overlay.
+         * Returns the style a bookmark laid on this one item, or null when it carries none.
+         */
+        function GetItemStyle(item) {
+            var _a, _b;
+            return (_b = (_a = item === null || item === void 0 ? void 0 : item.style) === null || _a === void 0 ? void 0 : _a.style) !== null && _b !== void 0 ? _b : null;
+        }
+        MenuItemStyleOverlay.GetItemStyle = GetItemStyle;
+        /**
+         * Returns the Style record a bookmark laid on this one item, or null when it names none.
+         */
+        function GetItemStyleId(item) {
+            var _a;
+            const styleId = (_a = item === null || item === void 0 ? void 0 : item.style) === null || _a === void 0 ? void 0 : _a.styleId;
+            return styleId == null || styleId === "" || styleId == -1 ? null : styleId;
+        }
+        MenuItemStyleOverlay.GetItemStyleId = GetItemStyleId;
+        /**
+         * Returns a copy carrying the given bookmark style, inline or by record, or without one for null.
+         */
+        function WithItemStyle(item, itemStyle) {
+            const has = Boolean(itemStyle === null || itemStyle === void 0 ? void 0 : itemStyle.style) || (itemStyle === null || itemStyle === void 0 ? void 0 : itemStyle.styleId) != null;
+            if (!item || (!has && !item.style)) {
+                return item;
+            }
+            const next = { ...item };
+            if (has) {
+                next.style = { ...itemStyle };
+            }
+            else {
+                delete next.style;
+            }
+            return next;
+        }
+        MenuItemStyleOverlay.WithItemStyle = WithItemStyle;
+        /**
+         * Returns the overlay an item renders with: its inline or loaded bookmark style, under the scene-wide one.
+         */
+        function Effective(item, overlay, record) {
+            var _a, _b;
+            const own = (_b = (_a = GetItemStyle(item)) !== null && _a !== void 0 ? _a : record) !== null && _b !== void 0 ? _b : null;
+            // Either alone is used as it is, so an unchanged overlay still compares equal.
+            return own ? Merge(own, overlay) : overlay;
+        }
+        MenuItemStyleOverlay.Effective = Effective;
+        /**
+         * Returns a copy without its overlay or bookmark style, so what else two items differ by can be compared.
+         */
+        function Strip(item) {
+            return With(WithItemStyle(item, null), null);
+        }
+        MenuItemStyleOverlay.Strip = Strip;
+        /**
+         * Returns true when the two items differ by nothing but their overlay or bookmark style.
          */
         function IsChangeOnly(from, to) {
             if (!from || !to || from.Type !== to.Type) {
                 return false;
             }
-            const toOverlay = Get(to);
-            if (JSON.stringify(Get(from)) === JSON.stringify(toOverlay)) {
+            const sameOverlay = JSON.stringify(Get(from)) === JSON.stringify(Get(to));
+            if (sameOverlay && JSON.stringify(from.style) === JSON.stringify(to.style)) {
                 return false;
             }
-            // A false mismatch only costs the in-place swap, so key order is not normalized.
-            return JSON.stringify(With(from, toOverlay)) === JSON.stringify(to);
+            // Removing keys keeps the order of the rest, so the two compare as text.
+            return JSON.stringify(Strip(from)) === JSON.stringify(Strip(to));
         }
         MenuItemStyleOverlay.IsChangeOnly = IsChangeOnly;
         /*
@@ -20634,6 +20686,8 @@
             this.fallbackStyle = null;
             // Laid over whichever style each feature resolves, so it only changes the fields it sets.
             this.styleOverlay = null;
+            // The tileset's blend before an overlay's colours replaced it, put back once no overlay colours it.
+            this.blendBeforeOverlay = null;
             this.styleFallbackLoaded = false;
             this.loadingCounter = 0;
             // Entity IDs -> boolean to indicate if we should override the feature colour.
@@ -20692,7 +20746,12 @@
             this.monitor = monitor;
             this.viewer = viewer;
             this.api = api;
+            // A tileset handed in fresh still has its own blend, so nothing is left to put back on it.
+            if (cTileset !== this.cTileset) {
+                this.blendBeforeOverlay = null;
+            }
             this.cTileset = cTileset;
+            this.applyOverlayBlend();
             this.bakedAttributes = getBakedAttributes(cTileset);
             this.register = register;
             this.menuItemId = menuItemId;
@@ -20824,6 +20883,7 @@
             // Left as it is when a caller omits it, so a mapping change keeps the scene-wide style.
             if (params.styleOverlay !== undefined) {
                 this.styleOverlay = params.styleOverlay;
+                this.applyOverlayBlend();
             }
             if (params.scenario != null) {
                 if (!this.shouldUpdateRegoStates && !!this.scenario) {
@@ -20913,6 +20973,25 @@
             }
             this.queueTilesetFeatureStyle(regos, highPriority);
         }
+        /*
+         * Replaces the tileset's own colours while an overlay sets a model fill, so features show exactly what it maps to.
+         */
+        applyOverlayBlend() {
+            var _a, _b, _c, _d;
+            if (!this.cTileset || ((_b = (_a = this.cTileset).isDestroyed) === null || _b === void 0 ? void 0 : _b.call(_a))) {
+                return;
+            }
+            const fill = (_d = (_c = this.styleOverlay) === null || _c === void 0 ? void 0 : _c.modelStyle) === null || _d === void 0 ? void 0 : _d.fillColor;
+            const colours = Array.isArray(fill) ? fill.length > 0 : fill != null;
+            if (colours && this.blendBeforeOverlay == null) {
+                this.blendBeforeOverlay = this.cTileset.colorBlendMode;
+                this.cTileset.colorBlendMode = Cesium.Cesium3DTileColorBlendMode.REPLACE;
+            }
+            else if (!colours && this.blendBeforeOverlay != null) {
+                this.cTileset.colorBlendMode = this.blendBeforeOverlay;
+                this.blendBeforeOverlay = null;
+            }
+        }
         /**
          * Calculates the current progress % and updates the progress if there is a change.
          */
@@ -31983,17 +32062,21 @@
         }
         MenuItemStyles.Resolve = Resolve;
         /**
-         * Returns a copy on the style a bookmark alternation picked, or the item itself when that is not an option.
+         * Returns a copy on the style a bookmark alternation picked and carrying any style it laid on the item.
          */
         function ApplyAlternation(item, alternation) {
             var _a, _b, _c;
             // Alternations are partial items and may carry no Type, so the pick is read from whichever field is present.
             const alt = alternation;
             const picked = (_a = alt === null || alt === void 0 ? void 0 : alt.styleId) !== null && _a !== void 0 ? _a : (_b = getVisibleRow(alt === null || alt === void 0 ? void 0 : alt.CameraZoomSettings)) === null || _b === void 0 ? void 0 : _b.StyleID;
-            if (picked == null) {
-                return item;
+            const next = picked == null ? item : ((_c = WithStyleId(item, picked)) !== null && _c !== void 0 ? _c : item);
+            // A style laid by record need not be one of the item's own, unlike the pick.
+            const itemStyle = alternation === null || alternation === void 0 ? void 0 : alternation.style;
+            const laid = exports.MenuItemStyleOverlay.GetItemStyle(alternation) || exports.MenuItemStyleOverlay.GetItemStyleId(alternation);
+            if (laid == null) {
+                return next;
             }
-            return (_c = WithStyleId(item, picked)) !== null && _c !== void 0 ? _c : item;
+            return exports.MenuItemStyleOverlay.WithItemStyle(next, itemStyle);
         }
         MenuItemStyles.ApplyAlternation = ApplyAlternation;
         /**
@@ -32285,6 +32368,9 @@
                 // Laid over each item's own style where it can take one, including items rendered after it was set.
                 this.styleOverlay = null;
                 this.styleOverlayCounter = 0;
+                // Style records bookmark styles name by ID, loaded once each; null for one that failed to load.
+                this.itemStyleRecords = new Map();
+                this.itemStyleRecordsLoading = new Set();
                 this.onUpdate = null;
                 // Segments discovered so far per menu item ID.
                 this.seriesSegments = new Map();
@@ -32367,14 +32453,15 @@
                 // An item with a style set renders its first style unless the caller already picked one of them.
                 params = { ...params, item: exports.MenuItemStyles.Resolve(params.item) };
                 // The overlay rides on the rendered copy, so the view's item never carries it.
-                params = { ...params, item: exports.MenuItemStyleOverlay.With(params.item, this.styleOverlay) };
+                const effective = this.getEffectiveOverlay(params.item, this.styleOverlay);
+                params = { ...params, item: exports.MenuItemStyleOverlay.With(params.item, effective) };
                 let rItem = this.items.find(x => x.id == params.item.id);
                 let create = true;
                 // Item already exists so we'll check if we should re-create it.
                 if (rItem) {
-                    // Only the style pick or overlay changed, so the drawn graphics are restyled, not rebuilt.
-                    const aligned = exports.MenuItemStyleOverlay.With(rItem.item, exports.MenuItemStyleOverlay.Get(params.item));
-                    const pickOnly = exports.MenuItemStyles.IsStyleChangeOnly(aligned, params.item);
+                    // Only the style pick, overlay or bookmark style changed, so the graphics are restyled, not rebuilt.
+                    const stripped = exports.MenuItemStyleOverlay.Strip(params.item);
+                    const pickOnly = exports.MenuItemStyles.IsStyleChangeOnly(exports.MenuItemStyleOverlay.Strip(rItem.item), stripped);
                     const restyleOnly = pickOnly || exports.MenuItemStyleOverlay.IsChangeOnly(rItem.item, params.item);
                     if (restyleOnly && this.isStyleSwapCapable(rItem.renderManager)) {
                         rItem.renderManager.SwapStyle(params.item);
@@ -32814,10 +32901,13 @@
                 if (!rItem || !this.isStyleSwapCapable(rItem.renderManager) || rItem.renderManager.Disposed) {
                     return false;
                 }
-                const next = exports.MenuItemStyles.WithStyleId(rItem.item, styleId);
-                if (!next) {
+                const picked = exports.MenuItemStyles.WithStyleId(rItem.item, styleId);
+                if (!picked) {
                     return false;
                 }
+                // A Style record a bookmark laid is drawn over the pick, so picking one of the item's own takes it off.
+                const chosen = exports.MenuItemStyleOverlay.WithItemStyle(picked, null);
+                const next = exports.MenuItemStyleOverlay.With(chosen, this.getEffectiveOverlay(chosen, this.styleOverlay));
                 rItem.renderManager.SwapStyle(next);
                 rItem.item = next;
                 (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger({ isEnabling: true, itemId: rItem.id });
@@ -32849,7 +32939,7 @@
                 }
                 this.styleOverlay = overlay;
                 for (const rItem of this.items) {
-                    const next = exports.MenuItemStyleOverlay.With(rItem.item, overlay);
+                    const next = exports.MenuItemStyleOverlay.With(rItem.item, this.getEffectiveOverlay(rItem.item, overlay));
                     // Setting the same overlay again would otherwise restyle every feature for nothing.
                     const unchanged = JSON.stringify(exports.MenuItemStyleOverlay.Get(next)) === JSON.stringify(exports.MenuItemStyleOverlay.Get(rItem.item));
                     if (unchanged ||
@@ -32862,6 +32952,81 @@
                     (_c = this.onUpdate) === null || _c === void 0 ? void 0 : _c.Trigger({ isEnabling: true, itemId: rItem.id });
                 }
             }
+            /**
+             * Lays an inline style or any Style record on one enabled item under the scene-wide one; neither clears it.
+             */
+            SetItemStyleOverlay(params) {
+                var _a;
+                const rItem = this.items.find(x => x.id === params.menuItemId);
+                let itemStyle = null;
+                if (params.style) {
+                    itemStyle = { style: params.style };
+                }
+                else if (params.styleId != null) {
+                    itemStyle = { styleId: params.styleId };
+                }
+                if (!rItem ||
+                    !this.isStyleSwapCapable(rItem.renderManager) ||
+                    rItem.renderManager.Disposed ||
+                    (itemStyle && !exports.MenuItemStyleOverlay.Supports(rItem.item))) {
+                    return false;
+                }
+                const styled = exports.MenuItemStyleOverlay.WithItemStyle(rItem.item, itemStyle);
+                const next = exports.MenuItemStyleOverlay.With(styled, this.getEffectiveOverlay(styled, this.styleOverlay));
+                rItem.renderManager.SwapStyle(next);
+                rItem.item = next;
+                (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger({ isEnabling: true, itemId: rItem.id });
+                return true;
+            }
+            /*
+             * Returns the overlay the item renders with, starting the load of a record it names that is not loaded yet.
+             */
+            getEffectiveOverlay(item, overlay) {
+                const styleId = exports.MenuItemStyleOverlay.GetItemStyle(item) ? null : exports.MenuItemStyleOverlay.GetItemStyleId(item);
+                if (styleId != null && !this.itemStyleRecords.has(String(styleId))) {
+                    this.loadItemStyleRecord(styleId);
+                }
+                const record = styleId != null ? this.itemStyleRecords.get(String(styleId)) : null;
+                return exports.MenuItemStyleOverlay.Effective(item, overlay, record !== null && record !== void 0 ? record : undefined);
+            }
+            /*
+             * Loads a record a bookmark style names, then restyles every enabled item that names it.
+             */
+            async loadItemStyleRecord(styleId) {
+                var _a, _b;
+                const key = String(styleId);
+                if (this.itemStyleRecordsLoading.has(key)) {
+                    return;
+                }
+                this.itemStyleRecordsLoading.add(key);
+                let settings = null;
+                // A record that fails to load leaves the item on its own style.
+                try {
+                    const { style } = await BModels.Style.Get({
+                        api: this.getters.GetBruceApi(),
+                        styleId
+                    });
+                    settings = (_a = style === null || style === void 0 ? void 0 : style.Settings) !== null && _a !== void 0 ? _a : null;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+                this.itemStyleRecordsLoading.delete(key);
+                this.itemStyleRecords.set(key, settings);
+                for (const rItem of this.items) {
+                    if (String(exports.MenuItemStyleOverlay.GetItemStyleId(rItem.item)) !== key ||
+                        exports.MenuItemStyleOverlay.GetItemStyle(rItem.item) ||
+                        !this.isStyleSwapCapable(rItem.renderManager) ||
+                        rItem.renderManager.Disposed) {
+                        continue;
+                    }
+                    const effective = this.getEffectiveOverlay(rItem.item, this.styleOverlay);
+                    const next = exports.MenuItemStyleOverlay.With(rItem.item, effective);
+                    rItem.renderManager.SwapStyle(next);
+                    rItem.item = next;
+                    (_b = this.onUpdate) === null || _b === void 0 ? void 0 : _b.Trigger({ isEnabling: true, itemId: rItem.id });
+                }
+            }
             /*
              * Picks the child the caller asked for, else the one already enabled, else the first.
              */
@@ -56371,7 +56536,7 @@ void main() {
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.StyleUtils = {}));
 
-    const VERSION = "7.6.7";
+    const VERSION = "7.6.9";
     /**
      * 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.