bruce-cesium 7.6.2 → 7.6.3

package/dist/bruce-cesium.umd.js

@@ -16387,6 +16387,10 @@
                 this.zoomControl = [];
                 // Scenario for retrieving Entities.
                 this.scenario = null;
+                // Hand-off key of the data currently drawn, or null when it is unknown or nothing is drawn.
+                this.drawnKey = null;
+                // How the drawn entities were last told to look, see getDrawnSettingsSignature.
+                this.drawnSettings = null;
                 // Type IDs that we'll allow to be rendered when receiving Entities.
                 // This might be exactly the Menu Item Type ID because of local data sources.
                 this.allowedTypeIDs = [];
@@ -16445,9 +16449,26 @@
                         if (this.disposed) {
                             return;
                         }
+                        // Landing on the data already drawn re-applies settings instead of removing and re-fetching it.
+                        const nextKey = shouldRender ? Manager.GetHandoffKey(this.item) : null;
+                        const keepDrawn = nextKey != null && nextKey === this.drawnKey;
+                        const restyle = keepDrawn && this.drawnSettings !== this.getDrawnSettingsSignature();
+                        this.drawnKey = nextKey;
+                        this.drawnSettings = this.getDrawnSettingsSignature();
                         this.unsetGetter();
                         (_a = this.viewMonitorRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
                         this.viewMonitorRemoval = null;
+                        if (keepDrawn) {
+                            this.setGetter();
+                            this.viewMonitorRemoval = this.monitor.Updated().Subscribe(() => {
+                                var _a;
+                                (_a = this.entityCheckQueue) === null || _a === void 0 ? void 0 : _a.Call();
+                            });
+                            if (restyle) {
+                                this.ReRender({ entityIds: Object.keys(this.renderedEntities), force: true });
+                            }
+                            return;
+                        }
                         clearInterval(this.renderQueueInterval);
                         this.renderQueueInterval = null;
                         this.renderQueue = [];
@@ -16481,6 +16502,18 @@
                     }
                 })();
             }
+            /*
+             * Everything about how drawn entities look that applying the item's settings can change.
+             */
+            getDrawnSettingsSignature() {
+                var _a;
+                return JSON.stringify({
+                    zoomControl: exports.RenderManager.GetZoomControlSignature(this.zoomControl),
+                    renderPriority: (_a = this.renderPriority) !== null && _a !== void 0 ? _a : null,
+                    historicDrawTrack: Boolean(this.item.historicDrawTrack),
+                    historicInterpolation: Boolean(this.item.historicInterpolation)
+                });
+            }
             applyItemSettings() {
                 var _a, _b, _c, _d, _e, _f;
                 // Reset allowed list if there's change.
@@ -16856,10 +16889,13 @@
                         console.warn("Geojson rendering does not support multiple zoom controls. Only the first one will be used.");
                         this.zoomControl = [this.zoomControl[0]];
                     }
+                    this.drawnSettings = this.getDrawnSettingsSignature();
                     changed = true;
                 }
                 if (scenario != null) {
                     this.scenario = scenario;
+                    // The drawn records now belong to a scenario the item does not name.
+                    this.drawnKey = null;
                     changed = true;
                 }
                 if (changed) {
@@ -16874,6 +16910,16 @@
                     this.doEntityCheck(entityIds);
                 }
             }
+            /**
+             * Switches to another of the item's own styles, restyling what is drawn without re-creating it.
+             */
+            SwapStyle(item) {
+                if (this.disposed) {
+                    return;
+                }
+                this.item = item;
+                this.UpdateSettings({ zoomControl: item.CameraZoomSettings });
+            }
             /**
              * Narrows a camera-driven check to the entities whose zoom band could actually have changed.
              * @param ids
@@ -17627,6 +17673,8 @@
             AdoptHandoff(payload) {
                 var _a;
                 const { shouldRender } = this.applyItemSettings();
+                this.drawnKey = shouldRender ? Manager.GetHandoffKey(this.item) : null;
+                this.drawnSettings = this.getDrawnSettingsSignature();
                 this.visualsManager.ReassignMenuItem({
                     fromMenuItemId: payload.sourceMenuItemId,
                     toMenuItemId: this.item.id,
@@ -18002,6 +18050,16 @@
                     this.doEntityCheck(entityIds);
                 }
             }
+            /**
+             * Switches to another of the item's own styles, restyling what is drawn without re-creating it.
+             */
+            SwapStyle(item) {
+                if (this.disposed) {
+                    return;
+                }
+                this.item = item;
+                this.UpdateSettings({ zoomControl: item.CameraZoomSettings });
+            }
             async doEntityCheck(ids, force = false) {
                 var _a, _b;
                 const api = this.apiGetter.getApi();
@@ -18702,6 +18760,16 @@
                     this.onGetterUpdate(entityIds);
                 }
             }
+            /**
+             * Switches to another of the item's own styles, restyling what is drawn without re-creating it.
+             */
+            SwapStyle(item) {
+                if (this.disposed) {
+                    return;
+                }
+                this.item = item;
+                this.UpdateSettings({ zoomControl: item.CameraZoomSettings });
+            }
             /*
              * The lane this item reads through, or null when it does not follow the clock.
              */
@@ -19161,6 +19229,16 @@
                     this.onGetterUpdate(entityId, true);
                 }
             }
+            /**
+             * Switches to another of the item's own styles, restyling what is drawn without re-creating it.
+             */
+            SwapStyle(item) {
+                if (this.disposed) {
+                    return;
+                }
+                this.item = item;
+                this.UpdateSettings({ zoomControl: item.CameraZoomSettings });
+            }
             renderEntity(entity, force = false) {
                 // Waiting for prior call to finish resolving.
                 // This avoids race conditions against two sets of overlapping Entities.
@@ -23030,6 +23108,21 @@
                 }
                 return children;
             }
+            /**
+             * Switches to another of the item's own styles, restyling the loaded tileset without reloading it.
+             */
+            SwapStyle(item) {
+                var _a;
+                if (this.disposed) {
+                    return;
+                }
+                this.item = item;
+                // Before the tileset loads this only stores the pick, and the styler's Init reads the new item.
+                this.styler.UpdateStyleMapping({
+                    styleMapping: (_a = item.StyleMapping) !== null && _a !== void 0 ? _a : [],
+                    fallbackStyleId: item.styleId
+                });
+            }
             Dispose() {
                 var _a;
                 if (this.disposed) {
@@ -24757,6 +24850,16 @@
                     this.doEntityCheck(entityIds);
                 }
             }
+            /**
+             * Switches to another of the item's own styles, restyling what is drawn without re-creating it.
+             */
+            SwapStyle(item) {
+                if (this.disposed) {
+                    return;
+                }
+                this.item = item;
+                this.UpdateSettings({ zoomControl: item.CameraZoomSettings });
+            }
             async doEntityCheck(ids, force = false) {
                 var _a, _b, _c, _d;
                 if (this.isRunningCheck) {
@@ -26666,6 +26769,21 @@
                     }
                 }
             }
+            /**
+             * Switches to another of the item's own styles, restyling the loaded tileset without reloading it.
+             */
+            SwapStyle(item) {
+                if (this.disposed) {
+                    return;
+                }
+                this.item = item;
+                if (Manager.NeedsStyler(item)) {
+                    this.styler.UpdateStyleMapping({
+                        styleMapping: [],
+                        fallbackStyleId: item.styleId
+                    });
+                }
+            }
             Dispose() {
                 var _a;
                 if (this.disposed) {
@@ -27915,6 +28033,23 @@
                     this.viewer.zoomTo(this.cTileset, new Cesium.HeadingPitchRange(0.0, -0.5, this.cTileset.boundingSphere.radius / 4.0));
                 }
             }
+            /**
+             * Switches to another of the item's own styles, restyling the loaded tileset without reloading it.
+             */
+            SwapStyle(item) {
+                var _a;
+                if (this.disposed) {
+                    return;
+                }
+                // Copied for the same reason the constructor copies it.
+                this.item = JSON.parse(JSON.stringify(item));
+                if (this.item.ApplyStyles || this.item.Type == BModels.MenuItem.EType.IonTileset) {
+                    this.styler.UpdateStyleMapping({
+                        styleMapping: (_a = this.item.StyleMapping) !== null && _a !== void 0 ? _a : [],
+                        fallbackStyleId: this.item.styleId
+                    });
+                }
+            }
             Dispose() {
                 if (this.disposed) {
                     return;
@@ -31440,6 +31575,149 @@
         AssemblyRenderManager.Manager = Manager;
     })(exports.AssemblyRenderManager || (exports.AssemblyRenderManager = {}));
 
+    (function (MenuItemStyles) {
+        // Tileset items whose render manager applies styleId through a Styler.
+        const TILESET_TYPES = [
+            BModels.MenuItem.EType.CadTileset,
+            BModels.MenuItem.EType.ArbTileset,
+            BModels.MenuItem.EType.IonTileset,
+            BModels.MenuItem.EType.EntityTileset
+        ];
+        // Items whose style lives on their zoom control rows.
+        const ZOOM_CONTROL_TYPES = [
+            BModels.MenuItem.EType.Entities,
+            BModels.MenuItem.EType.Entity,
+            BModels.MenuItem.EType.EntitiesIds,
+            BModels.MenuItem.EType.EntitiesLoaded,
+            BModels.MenuItem.EType.DataLab
+        ];
+        /**
+         * Returns the ordered styles a user can swap between for the item, or an empty array when it offers no choice.
+         */
+        function GetStyleIds(item) {
+            var _a;
+            if (isStyledTileset(item)) {
+                return cleanIds(item.styleIds);
+            }
+            if (ZOOM_CONTROL_TYPES.includes(item === null || item === void 0 ? void 0 : item.Type)) {
+                return cleanIds((_a = getVisibleRow(item.CameraZoomSettings)) === null || _a === void 0 ? void 0 : _a.StyleIDs);
+            }
+            return [];
+        }
+        MenuItemStyles.GetStyleIds = GetStyleIds;
+        /**
+         * Returns the style the item currently renders with, from styleId or its one non-hidden zoom row.
+         */
+        function GetStyleId(item) {
+            var _a;
+            if (TILESET_TYPES.includes(item === null || item === void 0 ? void 0 : item.Type)) {
+                return item.styleId;
+            }
+            if (ZOOM_CONTROL_TYPES.includes(item === null || item === void 0 ? void 0 : item.Type)) {
+                return (_a = getVisibleRow(item.CameraZoomSettings)) === null || _a === void 0 ? void 0 : _a.StyleID;
+            }
+            return undefined;
+        }
+        MenuItemStyles.GetStyleId = GetStyleId;
+        /**
+         * Returns a copy of the item rendering with the given style, or null when that style is not one of its options.
+         */
+        function WithStyleId(item, styleId) {
+            const styleIds = GetStyleIds(item);
+            const picked = styleIds.find(x => isSameId(x, styleId));
+            if (picked == null) {
+                return null;
+            }
+            if (isStyledTileset(item)) {
+                return { ...item, styleId: picked };
+            }
+            const zItem = item;
+            const visible = getVisibleRow(zItem.CameraZoomSettings);
+            return {
+                ...zItem,
+                CameraZoomSettings: zItem.CameraZoomSettings.map(row => {
+                    if (row !== visible) {
+                        return row;
+                    }
+                    // An inline style would win over the picked ID.
+                    const next = { ...row, StyleID: picked };
+                    delete next.Style;
+                    return next;
+                })
+            };
+        }
+        MenuItemStyles.WithStyleId = WithStyleId;
+        /**
+         * Returns the item on the first of its styles unless it already uses one, or the same object when it has none.
+         */
+        function Resolve(item) {
+            var _a;
+            const styleIds = GetStyleIds(item);
+            if (!styleIds.length) {
+                return item;
+            }
+            const current = GetStyleId(item);
+            if (current != null && styleIds.some(x => isSameId(x, current))) {
+                return item;
+            }
+            return (_a = WithStyleId(item, styleIds[0])) !== null && _a !== void 0 ? _a : item;
+        }
+        MenuItemStyles.Resolve = Resolve;
+        /**
+         * Returns a copy on the style a bookmark alternation picked, or the item itself when that is not an option.
+         */
+        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;
+            }
+            return (_c = WithStyleId(item, picked)) !== null && _c !== void 0 ? _c : item;
+        }
+        MenuItemStyles.ApplyAlternation = ApplyAlternation;
+        /**
+         * Returns true when the two items differ by nothing but which of their styles is picked.
+         */
+        function IsStyleChangeOnly(from, to) {
+            if (!from || !to || from.Type !== to.Type) {
+                return false;
+            }
+            const toStyleId = GetStyleId(to);
+            if (toStyleId == null || isSameId(GetStyleId(from), toStyleId)) {
+                return false;
+            }
+            const moved = WithStyleId(from, toStyleId);
+            // A false mismatch only costs the in-place swap, so key order is not normalized.
+            return Boolean(moved) && JSON.stringify(moved) === JSON.stringify(to);
+        }
+        MenuItemStyles.IsStyleChangeOnly = IsStyleChangeOnly;
+        function isStyledTileset(item) {
+            if (!TILESET_TYPES.includes(item === null || item === void 0 ? void 0 : item.Type)) {
+                return false;
+            }
+            // These two only run a Styler when asked to.
+            if (item.Type === BModels.MenuItem.EType.ArbTileset || item.Type === BModels.MenuItem.EType.EntityTileset) {
+                return Boolean(item.ApplyStyles);
+            }
+            return true;
+        }
+        function getVisibleRow(rows) {
+            const visible = (rows !== null && rows !== void 0 ? rows : []).filter(x => x && x.DisplayType !== BModels.ZoomControl.EDisplayType.Hidden);
+            return visible.length === 1 ? visible[0] : null;
+        }
+        function cleanIds(ids) {
+            return (ids !== null && ids !== void 0 ? ids : []).filter(x => x != null && x !== "");
+        }
+        /*
+         * Compares style references, which can be an ID typed as a string or a number.
+         */
+        function isSameId(a, b) {
+            return a != null && b != null && String(a) === String(b);
+        }
+    })(exports.MenuItemStyles || (exports.MenuItemStyles = {}));
+
     /**
      * Util to batch Tileset and Root Entity coord requests between Menu Items.
      * This avoids per-menu-item requests and allows for them to request together if enabled within N ms of each other.
@@ -31680,6 +31958,8 @@
             constructor(params) {
                 this.items = [];
                 this.pendingHandoffPool = [];
+                // The settings bookmark alternations overwrite on a view's items, as that view authored them.
+                this.authoredAlternations = new WeakMap();
                 this.onUpdate = null;
                 // Segments discovered so far per menu item ID.
                 this.seriesSegments = new Map();
@@ -31735,7 +32015,7 @@
              * @returns
              */
             RenderItem(params) {
-                var _a, _b, _c, _d, _e, _f, _g;
+                var _a, _b, _c, _d, _e, _f, _g, _h;
                 if (this.viewer.isDestroyed()) {
                     return null;
                 }
@@ -31759,13 +32039,21 @@
                 if (params.modelSpace == null) {
                     params.modelSpace = false;
                 }
+                // 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) };
                 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 picked style changed, so what is drawn gets restyled rather than rebuilt.
+                    if (exports.MenuItemStyles.IsStyleChangeOnly(rItem.item, params.item) && this.isStyleSwapCapable(rItem.renderManager)) {
+                        rItem.renderManager.SwapStyle(params.item);
+                        rItem.item = params.item;
+                        create = false;
+                    }
                     // This means we're updating an entities menu item re-using the same id.
                     // Eg: a bookmark swap that keeps the same item but changes tags, style, or zoom settings.
-                    if (rItem.type == BModels.MenuItem.EType.Entities && params.item.Type == BModels.MenuItem.EType.Entities) {
+                    else if (rItem.type == BModels.MenuItem.EType.Entities && params.item.Type == BModels.MenuItem.EType.Entities) {
                         rItem.renderManager.Init({
                             item: params.item,
                         });
@@ -32100,7 +32388,17 @@
                 // We no longer support folder items being both a folder and an action.
                 // Now an item must have no action to be a folder.
                 const isFolder = !params.item.Type || params.item.Type == BModels.MenuItem.EType.None;
-                if (params.item.Children && params.recursive != false && isFolder) {
+                const isRadioFolder = isFolder && Boolean(params.item.childrenAsRadios);
+                if (((_f = params.item.Children) === null || _f === void 0 ? void 0 : _f.length) && params.recursive != false && isRadioFolder) {
+                    const picked = this.pickRadioChild(params.item.Children, params.preferredIds);
+                    const others = params.item.Children.filter(x => x !== picked && this.items.some(y => y.id === x.id));
+                    const childId = this.renderInPlaceOf(others.map(x => x.id), () => this.RenderItem({
+                        ...params,
+                        item: picked
+                    }));
+                    rItem.childIds = childId ? [childId] : [];
+                }
+                else if (params.item.Children && params.recursive != false && isFolder) {
                     for (let i = 0; i < params.item.Children.length; i++) {
                         const childId = this.RenderItem({
                             ...params,
@@ -32109,8 +32407,8 @@
                         rItem.childIds.push(childId);
                     }
                 }
-                if (rItem.renderManager && !((_f = rItem.renderManager) === null || _f === void 0 ? void 0 : _f.Disposed)) {
-                    (_g = this.onUpdate) === null || _g === void 0 ? void 0 : _g.Trigger({ isEnabling: true, itemId: rItem.id });
+                if (rItem.renderManager && !((_g = rItem.renderManager) === null || _g === void 0 ? void 0 : _g.Disposed)) {
+                    (_h = this.onUpdate) === null || _h === void 0 ? void 0 : _h.Trigger({ isEnabling: true, itemId: rItem.id });
                 }
                 return rItem.id;
             }
@@ -32159,9 +32457,74 @@
                     (_b = this.onUpdate) === null || _b === void 0 ? void 0 : _b.Trigger({ isEnabling: false, itemId: item.id });
                 }
             }
+            /**
+             * Replaces enabled menu items with another, which reuses their graphics where both draw the same data.
+             */
+            SwapItem(params) {
+                const { fromIds, item, modelSpace } = params;
+                const parents = this.items.filter(x => x.childIds.some(id => fromIds.includes(id)));
+                const id = this.renderInPlaceOf(fromIds, () => this.RenderItem({
+                    item,
+                    modelSpace
+                }));
+                // Keeps a radio folder's removal reaching the child that replaced its old one.
+                for (const parent of parents) {
+                    const kept = parent.childIds.filter(x => !fromIds.includes(x));
+                    parent.childIds = id && !kept.includes(id) ? kept.concat(id) : kept;
+                }
+                return id;
+            }
+            /**
+             * Restyles an enabled menu item in place with another of its own styles, returning false when it cannot.
+             */
+            SetItemStyle(params) {
+                var _a;
+                const { menuItemId, styleId } = params;
+                const rItem = this.items.find(x => x.id === menuItemId);
+                if (!rItem || !this.isStyleSwapCapable(rItem.renderManager) || rItem.renderManager.Disposed) {
+                    return false;
+                }
+                const next = exports.MenuItemStyles.WithStyleId(rItem.item, styleId);
+                if (!next) {
+                    return false;
+                }
+                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;
+            }
+            /*
+             * Picks the child the caller asked for, else the one already enabled, else the first.
+             */
+            pickRadioChild(children, preferredIds) {
+                var _a, _b;
+                return ((_b = (_a = children.find(x => preferredIds === null || preferredIds === void 0 ? void 0 : preferredIds.includes(x.id))) !== null && _a !== void 0 ? _a : children.find(x => this.items.some(y => y.id === x.id))) !== null && _b !== void 0 ? _b : children[0]);
+            }
+            /*
+             * Removes the items so the render can claim their graphics, then disposes whatever it left unclaimed.
+             */
+            renderInPlaceOf(removeIds, render) {
+                const pooledBefore = new Set(this.pendingHandoffPool);
+                for (const id of removeIds) {
+                    this.RemoveItemById({
+                        menuItemId: id,
+                        allowHandoff: true
+                    });
+                }
+                const pooled = this.pendingHandoffPool.filter(x => !pooledBefore.has(x));
+                try {
+                    return render();
+                }
+                finally {
+                    this.disposePooled(x => pooled.includes(x));
+                }
+            }
             isHandoffCapable(renderManager) {
                 return Boolean(renderManager) && typeof renderManager.PrepareHandoff === "function";
             }
+            isStyleSwapCapable(renderManager) {
+                return Boolean(renderManager) && typeof renderManager.SwapStyle === "function";
+            }
             // Resolves the hand-off key a menu item's data would have.
             computeHandoffKey(item, modelSpace) {
                 if (item.Type === BModels.MenuItem.EType.CadTileset) {
@@ -32237,12 +32600,15 @@
             }
             // Disposes everything left unclaimed in the pending-hand-off pool.
             FlushPendingHandoffs() {
+                this.disposePooled(() => true);
+            }
+            disposePooled(match) {
                 var _a;
                 if (!this.pendingHandoffPool.length) {
                     return;
                 }
-                const pool = this.pendingHandoffPool;
-                this.pendingHandoffPool = [];
+                const pool = this.pendingHandoffPool.filter(match);
+                this.pendingHandoffPool = this.pendingHandoffPool.filter(x => !match(x));
                 for (const item of pool) {
                     try {
                         (_a = item.renderManager) === null || _a === void 0 ? void 0 : _a.Dispose();
@@ -32253,6 +32619,26 @@
                     this.ClearSeriesSegments(item.id);
                 }
             }
+            /**
+             * Returns the tags and attenuation the item's view authored, before any bookmark wrote over them.
+             */
+            GetAuthoredAlternation(item) {
+                var _a;
+                let authored = this.authoredAlternations.get(item);
+                if (!authored) {
+                    const eItem = item;
+                    const tItem = item;
+                    authored = JSON.parse(JSON.stringify({
+                        id: item.id,
+                        Type: item.Type,
+                        BruceEntity: { SelectedExpandLayers: (_a = eItem.BruceEntity) === null || _a === void 0 ? void 0 : _a.SelectedExpandLayers },
+                        attenuation: tItem.attenuation,
+                        attenuationMax: tItem.attenuationMax
+                    }));
+                    this.authoredAlternations.set(item, authored);
+                }
+                return authored;
+            }
             GetEnabledItemIds() {
                 return this.items.map(x => x.id);
             }
@@ -33316,6 +33702,7 @@
     })(exports.EMenuItemState || (exports.EMenuItemState = {}));
     // Icons are inline so the library stays dependency free.
     const ICON_CHECK = `<svg viewBox="0 0 11 8" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M1 4L4 7L10 1" stroke="white" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>`;
+    const ICON_RADIO = `<svg viewBox="0 0 12 12" fill="none" xmlns="http://www.w3.org/2000/svg"><circle cx="6" cy="6" r="3.5" fill="white"/></svg>`;
     const ICON_PARTIAL_CHECK = `<svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M8 12H16" stroke="white" stroke-width="4" stroke-linecap="round" stroke-linejoin="round"/></svg>`;
     const ICON_CHEV_DOWN = `<svg viewBox="0 0 16 9" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M15 1L8 8L1 1" stroke="white" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>`;
     const ICON_CHEV_RIGHT = `<svg viewBox="0 0 10 17" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M1.5 1.5L8.5 8.5L1.5 15.5" stroke="white" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>`;
@@ -33519,6 +33906,10 @@
                 margin-right: 8px;
             }
 
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem >.NextspaceMenuItemRowCheckbox[is-radio="true"] {
+                border-radius: 50%;
+            }
+
             .NextspaceMenuItemRow >.NextspaceMenuItemRowItem >.NextspaceMenuItemRowToggle {
                 margin-right: 3px;
             }
@@ -33769,13 +34160,15 @@
             }
             return this._waitedForView ? "No view is loaded." : "Loading..";
         }
-        _renderRow(item, depth, parent) {
+        _renderRow(item, depth, parent, radioParent) {
             var _a;
             if (!(item === null || item === void 0 ? void 0 : item.id)) {
                 return;
             }
             const isFolder = !item.Type || item.Type === BModels.MenuItem.EType.None;
-            const children = item.hideChildren ? [] : ((_a = item.Children) !== null && _a !== void 0 ? _a : []);
+            const isRadioFolder = isFolder && Boolean(item.childrenAsRadios);
+            // Radios are the folder's whole point, so they show even when the folder also hides its children.
+            const children = item.hideChildren && !isRadioFolder ? [] : ((_a = item.Children) !== null && _a !== void 0 ? _a : []);
             const hasChildren = children.length > 0;
             const row = document.createElement("div");
             row.className = "NextspaceMenuItemRow";
@@ -33807,8 +34200,9 @@
             }
             const checkbox = document.createElement("div");
             checkbox.className = "NextspaceMenuItemRowCheckbox";
+            checkbox.setAttribute("is-radio", radioParent ? "true" : "false");
             checkbox.onclick = () => {
-                this._toggleItem(item);
+                this._toggleItem(item, radioParent);
             };
             itemElement.appendChild(checkbox);
             const title = document.createElement("div");
@@ -33858,10 +34252,11 @@
                 itemElement,
                 checkboxElement: checkbox,
                 countElement: count,
-                childrenElement
+                childrenElement,
+                radioParent
             });
             for (const child of children) {
-                this._renderRow(child, depth + 1, childrenElement);
+                this._renderRow(child, depth + 1, childrenElement, isRadioFolder ? item : undefined);
             }
         }
         _getOpen(itemId, depth) {
@@ -33896,7 +34291,10 @@
             for (const row of Array.from(this._rows.values())) {
                 const state = this._resolveState(row.item, enabledIds);
                 row.itemElement.setAttribute("is-enabled", state === exports.EMenuItemState.Disabled ? "false" : "true");
-                if (state === exports.EMenuItemState.Enabled) {
+                if (row.radioParent && state !== exports.EMenuItemState.Disabled) {
+                    row.checkboxElement.innerHTML = ICON_RADIO;
+                }
+                else if (state === exports.EMenuItemState.Enabled) {
                     row.checkboxElement.innerHTML = ICON_CHECK;
                 }
                 else if (state === exports.EMenuItemState.ChildEnabled) {
@@ -33911,17 +34309,33 @@
          * Works out a single item's state, rolling up children so a folder can report a partial state.
          */
         _resolveState(item, enabledIds) {
-            var _a;
+            var _a, _b;
             const isFolder = !item.Type || item.Type === BModels.MenuItem.EType.None;
             if (!isFolder) {
                 return enabledIds.has(item.id) ? exports.EMenuItemState.Enabled : exports.EMenuItemState.Disabled;
             }
+            // Only one radio is ever enabled, so the folder is as enabled as that one.
+            if (item.childrenAsRadios && ((_a = item.Children) === null || _a === void 0 ? void 0 : _a.length)) {
+                const states = item.Children.map(x => this._resolveState(x, enabledIds));
+                if (states.includes(exports.EMenuItemState.Enabled)) {
+                    return exports.EMenuItemState.Enabled;
+                }
+                return states.includes(exports.EMenuItemState.ChildEnabled) ? exports.EMenuItemState.ChildEnabled : exports.EMenuItemState.Disabled;
+            }
             // Folders derive from the leaves below them rather than their own enabled flag.
             let actionCount = 0;
             let enabledActionCount = 0;
             const traverse = (current) => {
-                var _a;
+                var _a, _b;
                 const currentIsFolder = !current.Type || current.Type === BModels.MenuItem.EType.None;
+                // A radio folder counts as one choice rather than as each of its radios.
+                if (currentIsFolder && current.childrenAsRadios && ((_a = current.Children) === null || _a === void 0 ? void 0 : _a.length)) {
+                    actionCount += 1;
+                    if (this._resolveState(current, enabledIds) === exports.EMenuItemState.Enabled) {
+                        enabledActionCount += 1;
+                    }
+                    return;
+                }
                 if (!currentIsFolder) {
                     actionCount += 1;
                     if (enabledIds.has(current.id)) {
@@ -33929,11 +34343,11 @@
                     }
                     return;
                 }
-                if ((_a = current.Children) === null || _a === void 0 ? void 0 : _a.length) {
+                if ((_b = current.Children) === null || _b === void 0 ? void 0 : _b.length) {
                     current.Children.forEach(traverse);
                 }
             };
-            (_a = item.Children) === null || _a === void 0 ? void 0 : _a.forEach(traverse);
+            (_b = item.Children) === null || _b === void 0 ? void 0 : _b.forEach(traverse);
             if (actionCount <= 0) {
                 return enabledIds.has(item.id) ? exports.EMenuItemState.Enabled : exports.EMenuItemState.Disabled;
             }
@@ -33959,7 +34373,7 @@
                 row.countElement.textContent = count.toLocaleString();
             }
         }
-        _toggleItem(item) {
+        _toggleItem(item, radioParent) {
             var _a;
             const manager = (_a = this._widget) === null || _a === void 0 ? void 0 : _a._getManager();
             if (!manager) {
@@ -33967,7 +34381,21 @@
             }
             const enabledIds = new Set(manager.GetEnabledItemIds());
             const state = this._resolveState(item, enabledIds);
-            if (state === exports.EMenuItemState.Enabled) {
+            // A radio stays picked until another one is, the folder's own checkbox turns them all off.
+            if (radioParent && state === exports.EMenuItemState.Enabled) {
+                return;
+            }
+            let siblingIds = [];
+            if (radioParent && state === exports.EMenuItemState.Disabled) {
+                siblingIds = radioParent.Children.filter(x => x !== item).flatMap(x => this._getEnabledIdsUnder(x, enabledIds));
+            }
+            if (siblingIds.length) {
+                manager.SwapItem({
+                    fromIds: siblingIds,
+                    item
+                });
+            }
+            else if (state === exports.EMenuItemState.Enabled) {
                 this._disableItem(item);
             }
             else {
@@ -33977,6 +34405,16 @@
             }
             this._stateQueue.Call(true);
         }
+        /*
+         * Returns the highest enabled ids at or below the item, since removing one removes everything under it.
+         */
+        _getEnabledIdsUnder(item, enabledIds) {
+            var _a;
+            if (enabledIds.has(item.id)) {
+                return [item.id];
+            }
+            return ((_a = item.Children) !== null && _a !== void 0 ? _a : []).flatMap(x => this._getEnabledIdsUnder(x, enabledIds));
+        }
         _disableItem(item) {
             var _a, _b;
             const manager = (_a = this._widget) === null || _a === void 0 ? void 0 : _a._getManager();
@@ -35505,33 +35943,50 @@
             }
             const renderedItemIds = [];
             if ((menuItems === null || menuItems === void 0 ? void 0 : menuItems.length) && (enabledIds === null || enabledIds === void 0 ? void 0 : enabledIds.length)) {
-                const traverseItems = async (item) => {
+                const alternateItems = (item) => {
+                    var _a, _b, _c, _d;
+                    // The project view menu item contains the instruction to enable tags, the bookmark specifies which ones.
+                    if (item.Type == BModels.MenuItem.EType.Entities && ((_a = item.BruceEntity) === null || _a === void 0 ? void 0 : _a.ExpandLayers)) {
+                        const eItem = item;
+                        // A setting the bookmark leaves out gets the view's own value back, not the last bookmark's.
+                        const authored = manager.GetAuthoredAlternation(item);
+                        const eItemAlt = alternations[item.id];
+                        const tags = (_b = eItemAlt === null || eItemAlt === void 0 ? void 0 : eItemAlt.BruceEntity) === null || _b === void 0 ? void 0 : _b.SelectedExpandLayers;
+                        eItem.BruceEntity = {
+                            ...eItem.BruceEntity,
+                            SelectedExpandLayers: tags !== undefined ? tags : (_c = authored.BruceEntity) === null || _c === void 0 ? void 0 : _c.SelectedExpandLayers,
+                        };
+                    }
+                    else if (item.Type == BModels.MenuItem.EType.EntityTileset) {
+                        const tItem = item;
+                        const authored = manager.GetAuthoredAlternation(item);
+                        const tItemAlt = alternations[item.id];
+                        const hasAttenuation = (tItemAlt === null || tItemAlt === void 0 ? void 0 : tItemAlt.attenuation) !== undefined || (tItemAlt === null || tItemAlt === void 0 ? void 0 : tItemAlt.attenuationMax) !== undefined;
+                        const source = hasAttenuation ? tItemAlt : authored;
+                        tItem.attenuation = source.attenuation;
+                        tItem.attenuationMax = source.attenuationMax;
+                    }
+                    (_d = item.Children) === null || _d === void 0 ? void 0 : _d.forEach(alternateItems);
+                };
+                /*
+                 * Lays each picked style over a copy, so it never stays on the view's item for a later bookmark.
+                 */
+                const styleItems = (item) => {
                     var _a;
-                    if (alternations[item.id]) {
-                        // The only alternation we support right now is tag menu item ones.
-                        // The project view menu item contains the instruction to enable tags, the bookmark specifies which ones.
-                        if (item.Type == BModels.MenuItem.EType.Entities) {
-                            const eItem = item;
-                            if (eItem.BruceEntity.ExpandLayers) {
-                                const eItemAlt = alternations[item.id];
-                                eItem.BruceEntity = {
-                                    ...eItem.BruceEntity,
-                                    SelectedExpandLayers: (_a = eItemAlt.BruceEntity) === null || _a === void 0 ? void 0 : _a.SelectedExpandLayers,
-                                };
-                            }
-                        }
-                        else if (item.Type == BModels.MenuItem.EType.EntityTileset) {
-                            const tItem = item;
-                            const tItemAlt = alternations[item.id];
-                            tItem.attenuation = tItemAlt.attenuation;
-                            tItem.attenuationMax = tItemAlt.attenuationMax;
-                        }
+                    let next = alternations[item.id] ? exports.MenuItemStyles.ApplyAlternation(item, alternations[item.id]) : item;
+                    const children = (_a = item.Children) === null || _a === void 0 ? void 0 : _a.map(styleItems);
+                    if (children === null || children === void 0 ? void 0 : children.some((child, i) => child !== item.Children[i])) {
+                        next = { ...next, Children: children };
                     }
+                    return next;
+                };
+                const traverseItems = async (item) => {
                     if (enabledIds.includes(item.id)) {
                         const itemId = await manager.RenderItem({
                             item: item,
                             getters: getters,
-                            modelSpace: contentType === BModels.ProjectViewBookmark.EContentType.WEB_3D_MODEL_SPACE
+                            modelSpace: contentType === BModels.ProjectViewBookmark.EContentType.WEB_3D_MODEL_SPACE,
+                            preferredIds: enabledIds
                         });
                         renderedItemIds.push(itemId);
                     }
@@ -35541,8 +35996,11 @@
                         }
                     }
                 };
-                for (let i = 0; i < menuItems.length; i++) {
-                    await traverseItems(menuItems[i]);
+                // Tag and attenuation alternations write into the view's items, since Navigator's tag tree reads them back.
+                menuItems.forEach(alternateItems);
+                const styled = menuItems.map(styleItems);
+                for (let i = 0; i < styled.length; i++) {
+                    await traverseItems(styled[i]);
                 }
             }
             return {
@@ -54978,7 +55436,7 @@ void main() {
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.StyleUtils = {}));
 
-    const VERSION = "7.6.2";
+    const VERSION = "7.6.3";
     /**
      * 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.