bruce-cesium 7.1.0 → 7.1.2

package/dist/lib/widgets/tabs-left-panel/widget-left-panel-tab-menu-items.js

@@ -0,0 +1,759 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WidgetLeftPanelTabMenuItems = exports.EMenuItemState = void 0;
+const Cesium = require("cesium");
+const bruce_models_1 = require("bruce-models");
+const widget_left_panel_tab_1 = require("./widget-left-panel-tab");
+const entity_utils_1 = require("../../utils/entity-utils");
+/**
+ * Enabled state of a menu item row.
+ * Folders roll up their children, so they can sit between fully on and fully off.
+ */
+var EMenuItemState;
+(function (EMenuItemState) {
+    EMenuItemState["Enabled"] = "enabled";
+    EMenuItemState["Disabled"] = "disabled";
+    EMenuItemState["ChildEnabled"] = "child-enabled";
+})(EMenuItemState = 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_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>`;
+const ICON_FLY_TO = `<svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M20.5926 2.12617L2.49072 12.5694C1.78383 12.9756 1.87366 13.9597 2.57664 14.2566L6.72815 15.9984L17.9486 6.10975C18.1634 5.91838 18.468 6.21129 18.2844 6.4339L8.87616 17.8964V21.0403C8.87616 21.962 9.98921 22.3252 10.536 21.6574L13.016 18.6385L17.8822 20.6771C18.4367 20.9115 19.0694 20.5639 19.171 19.9663L21.9829 3.09473C22.1157 2.30583 21.2682 1.73563 20.5926 2.12617Z" fill="white"/></svg>`;
+// Elbow connector drawn instead of a chevron on leaf rows below the root level.
+const ICON_BRACKET = `<svg viewBox="0 0 11 13" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M1 1V10C1 11.1046 1.89543 12 3 12H10" stroke="rgb(131, 141, 150)" stroke-linecap="round" stroke-linejoin="round"/></svg>`;
+// Menu item types backed by a tileset, so a fly-to can fall back to the tileset's bounding sphere.
+const TILESET_TYPES = [
+    bruce_models_1.MenuItem.EType.CadTileset,
+    bruce_models_1.MenuItem.EType.PointCloud,
+    bruce_models_1.MenuItem.EType.EntityTileset,
+    bruce_models_1.MenuItem.EType.ArbTileset,
+    bruce_models_1.MenuItem.EType.IonTileset,
+    bruce_models_1.MenuItem.EType.Osm,
+    bruce_models_1.MenuItem.EType.GooglePhotoTileset
+];
+const OPEN_STATE_STORAGE_PREFIX = "NextspaceMenuItemOpen_";
+// How long to wait for a view before declaring there isn't one.
+const NO_VIEW_GRACE_MS = 5000;
+const PANEL_WIDTH_STORAGE_KEY = "NextspaceMenuItemsPanelWidth";
+// Matches the panel's resize range in the full Navigator experience.
+const PANEL_DEFAULT_WIDTH = 320;
+const PANEL_MIN_WIDTH = 280;
+const PANEL_MAX_WIDTH = 700;
+/**
+ * Left panel tab listing the project view's menu items as a checkbox tree.
+ * Toggling a row renders or removes that layer in the scene.
+ */
+class WidgetLeftPanelTabMenuItems extends widget_left_panel_tab_1.WidgetLeftPanelTab.ATab {
+    constructor(params) {
+        var _a, _b, _c, _d;
+        super(params);
+        this.STYLESHEET_ID = "nextspace-left-panel-tab-menu-items-stylesheet";
+        this._menuItems = [];
+        // Every menu item the manager has rendered while this tab has been alive.
+        this._managerItems = new Map();
+        // Set once the grace period for a view to appear has elapsed.
+        this._waitedForView = false;
+        this._rows = new Map();
+        // Identifies the newest load, so a slow response for an older view can't overwrite a newer one.
+        this._loadToken = 0;
+        // Rows currently mid fly-to, so a double click doesn't stack camera moves.
+        this._flying = new Set();
+        this._disposed = false;
+        this._generateStyles();
+        this._generateElement();
+        this._stateQueue = new bruce_models_1.DelayQueue(() => {
+            this._updateStates();
+        });
+        this._countQueue = new bruce_models_1.DelayQueue(() => {
+            this._updateCounts();
+        });
+        this._viewIdChangeRemoval = (_b = (_a = this._widget) === null || _a === void 0 ? void 0 : _a.OnViewIdChange) === null || _b === void 0 ? void 0 : _b.Subscribe(() => {
+            this._loadMenuItems();
+        });
+        const manager = (_c = this._widget) === null || _c === void 0 ? void 0 : _c._getManager();
+        if (manager) {
+            this._menuUpdateRemoval = manager.OnUpdate.Subscribe(() => {
+                // A newly rendered item can add a row, not just change an existing one's state.
+                if (this._snapshotManagerItems() && !this._menuItems.length) {
+                    this._renderTree();
+                }
+                this._stateQueue.Call();
+            });
+            this._visualUpdateRemoval = (_d = manager.VisualsRegister) === null || _d === void 0 ? void 0 : _d.OnUpdate.Subscribe(() => {
+                this._countQueue.Call();
+            });
+        }
+        this._snapshotManagerItems();
+        this._loadMenuItems();
+        this._applyPanelWidth(this._getStoredWidth());
+        // Without a view we can't tell "still starting up" from "there is no view", so give it a moment.
+        this._noViewTimer = setTimeout(() => {
+            this._waitedForView = true;
+            if (!this._disposed && !this._menuItems.length && !this._managerItems.size) {
+                this._renderTree();
+            }
+        }, NO_VIEW_GRACE_MS);
+    }
+    Dispose() {
+        var _a, _b, _c, _d, _e;
+        this._disposed = true;
+        clearTimeout(this._noViewTimer);
+        this._endResize();
+        // The panel container is shared with the other tabs, so its overrides don't outlive this one.
+        if (this.Container) {
+            this.Container.style.padding = "";
+        }
+        (_a = this._viewIdChangeRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+        (_b = this._menuUpdateRemoval) === null || _b === void 0 ? void 0 : _b.call(this);
+        (_c = this._visualUpdateRemoval) === null || _c === void 0 ? void 0 : _c.call(this);
+        (_d = this._stateQueue) === null || _d === void 0 ? void 0 : _d.Dispose();
+        (_e = this._countQueue) === null || _e === void 0 ? void 0 : _e.Dispose();
+        this._rows.clear();
+        super.Dispose();
+    }
+    _generateStyles() {
+        if (document.getElementById(this.STYLESHEET_ID)) {
+            return;
+        }
+        const style = document.createElement("style");
+        style.id = this.STYLESHEET_ID;
+        style.innerHTML = `
+            .NextspaceLeftPanelTabMenuItems * {
+                box-sizing: border-box;
+            }
+
+            .NextspaceLeftPanelTabMenuItems {
+                color: #fff;
+                display: flex;
+                flex-direction: column;
+                flex-grow: 1;
+                flex-shrink: 1;
+                font-family: Arial, sans-serif;
+                overflow: hidden;
+                padding: 30px 20px 12px 20px;
+                width: 100%;
+            }
+
+            .NextspaceLeftPanelTabMenuItems >.NextspaceLeftPanelTabMenuItemsTitleBar {
+                align-items: center;
+                color: #fff;
+                display: flex;
+                font-size: 17px;
+                font-weight: 500;
+                justify-content: center;
+                letter-spacing: -.005em;
+                line-height: 20px;
+                margin-bottom: 15px;
+            }
+
+            .NextspaceLeftPanelTabMenuItems >.NextspaceLeftPanelTabMenuItemsTitleBreaker {
+                background-color: #000;
+                flex-shrink: 0;
+                height: 2px;
+                margin-bottom: 15px;
+            }
+
+            .NextspaceLeftPanelTabMenuItems >.NextspaceLeftPanelTabMenuItemsScrollBox {
+                flex-grow: 1;
+                flex-shrink: 1;
+                overflow: auto;
+                padding-right: 10px;
+            }
+
+            .NextspaceLeftPanelTabMenuItems >.NextspaceLeftPanelTabMenuItemsTip {
+                color: #fff;
+                font-size: 13px;
+                opacity: .7;
+            }
+
+            .NextspaceLeftPanelTabMenuItemsResizeHandle {
+                bottom: 0;
+                cursor: col-resize;
+                position: absolute;
+                right: 0;
+                top: 0;
+                width: 8px;
+                z-index: 3;
+            }
+
+            .NextspaceMenuItemRow {
+                border-bottom: 2px solid #121619;
+                width: 100%;
+            }
+
+            .NextspaceMenuItemRow[show-children="true"] {
+                border-bottom: none;
+            }
+
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem {
+                align-items: center;
+                display: flex;
+                height: 40px;
+                user-select: none;
+            }
+
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem >.NextspaceMenuItemRowCheckbox,
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem >.NextspaceMenuItemRowToggle,
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem >.NextspaceMenuItemRowBracket {
+                align-items: center;
+                color: #fff;
+                cursor: pointer;
+                display: flex;
+                flex-shrink: 0;
+                height: 18px;
+                justify-content: center;
+                width: 18px;
+            }
+
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem >.NextspaceMenuItemRowCheckbox >svg,
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem >.NextspaceMenuItemRowToggle >svg,
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem >.NextspaceMenuItemRowBracket >svg {
+                height: 12px;
+                width: 12px;
+            }
+
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem >.NextspaceMenuItemRowCheckbox {
+                border: 1.5px solid #fff;
+                border-radius: 2px;
+                margin-right: 8px;
+            }
+
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem >.NextspaceMenuItemRowToggle {
+                margin-right: 3px;
+            }
+
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem >.NextspaceMenuItemRowTitle {
+                color: #fff;
+                font-size: 14px;
+                margin-right: 8px;
+                overflow: hidden;
+                text-overflow: ellipsis;
+                white-space: nowrap;
+            }
+
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem >.NextspaceMenuItemRowCount {
+                background: rgba(0, 175, 250, .2);
+                border-radius: 11px;
+                color: #18ffff;
+                cursor: pointer;
+                flex-shrink: 0;
+                font-size: 12px;
+                margin-right: 3px;
+                padding: 5px 8px;
+            }
+
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem >.NextspaceMenuItemRowQuickBar {
+                display: flex;
+                flex-shrink: 0;
+                margin-left: auto;
+            }
+
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem >.NextspaceMenuItemRowQuickBar >.NextspaceMenuItemRowQuickBarButton {
+                align-items: center;
+                cursor: pointer;
+                display: flex;
+                height: 20px;
+                justify-content: center;
+                margin-left: 4px;
+                opacity: .7;
+                transition: .3s ease;
+                width: 20px;
+            }
+
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem >.NextspaceMenuItemRowQuickBar >.NextspaceMenuItemRowQuickBarButton:hover {
+                opacity: 1;
+            }
+
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem >.NextspaceMenuItemRowQuickBar >.NextspaceMenuItemRowQuickBarButton[is-disabled="true"] {
+                cursor: default;
+                opacity: .3;
+            }
+
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem >.NextspaceMenuItemRowQuickBar svg {
+                height: 18px;
+                width: 18px;
+            }
+
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem[is-enabled="false"] >.NextspaceMenuItemRowCount,
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem[is-enabled="false"] >.NextspaceMenuItemRowTitle,
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem[is-enabled="false"] >.NextspaceMenuItemRowCheckbox,
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem[is-enabled="false"] >.NextspaceMenuItemRowToggle {
+                opacity: .5;
+            }
+
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowItem[is-enabled="false"] >.NextspaceMenuItemRowQuickBar {
+                opacity: 0;
+                pointer-events: none;
+            }
+
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowDescription {
+                font-size: 12px;
+                margin: 0 0 8px 0;
+                opacity: .7;
+            }
+
+            .NextspaceMenuItemRow >.NextspaceMenuItemRowChildren {
+                border-top: 2px solid #121619;
+                display: flex;
+                flex-direction: column;
+            }
+
+            .NextspaceMenuItemRow[show-children="false"] >.NextspaceMenuItemRowChildren {
+                display: none;
+            }
+        `;
+        document.head.appendChild(style);
+    }
+    _generateElement() {
+        const element = document.createElement("div");
+        element.className = "NextspaceLeftPanelTabMenuItems";
+        const titleBar = document.createElement("div");
+        titleBar.className = "NextspaceLeftPanelTabMenuItemsTitleBar";
+        titleBar.textContent = "Menu";
+        element.appendChild(titleBar);
+        const breaker = document.createElement("div");
+        breaker.className = "NextspaceLeftPanelTabMenuItemsTitleBreaker";
+        element.appendChild(breaker);
+        const tip = document.createElement("div");
+        tip.className = "NextspaceLeftPanelTabMenuItemsTip";
+        tip.textContent = "Loading...";
+        element.appendChild(tip);
+        this._tip = tip;
+        const scrollBox = document.createElement("div");
+        scrollBox.className = "NextspaceLeftPanelTabMenuItemsScrollBox";
+        element.appendChild(scrollBox);
+        this._scrollBox = scrollBox;
+        // Positions against the panel container, which is the nearest positioned ancestor.
+        const resizeHandle = document.createElement("div");
+        resizeHandle.className = "NextspaceLeftPanelTabMenuItemsResizeHandle";
+        resizeHandle.onmousedown = (e) => {
+            this._startResize(e);
+        };
+        element.appendChild(resizeHandle);
+        this.Container.appendChild(element);
+        this._element = element;
+    }
+    _getStoredWidth() {
+        try {
+            const stored = parseInt(window.localStorage.getItem(PANEL_WIDTH_STORAGE_KEY), 10);
+            if (!isNaN(stored)) {
+                return stored;
+            }
+        }
+        catch (e) {
+            // Storage can be unavailable (private mode, blocked cookies). The default width still works.
+        }
+        return PANEL_DEFAULT_WIDTH;
+    }
+    /**
+     * Sizes the shared panel container to this tab's width, clamped to the allowed range.
+     */
+    _applyPanelWidth(width) {
+        const clamped = Math.min(PANEL_MAX_WIDTH, Math.max(PANEL_MIN_WIDTH, width));
+        if (this.Container) {
+            this.Container.style.width = clamped + "px";
+            // Padding lives on this tab's own element instead, so the resize handle can reach the panel edge.
+            this.Container.style.padding = "0";
+        }
+        return clamped;
+    }
+    _startResize(e) {
+        e.preventDefault();
+        const startX = e.clientX;
+        const startWidth = this.Container ? this.Container.offsetWidth : PANEL_DEFAULT_WIDTH;
+        this._onResizeMove = (moveEvent) => {
+            this._applyPanelWidth(startWidth + (moveEvent.clientX - startX));
+        };
+        this._onResizeUp = () => {
+            const finalWidth = this._applyPanelWidth(this.Container ? this.Container.offsetWidth : PANEL_DEFAULT_WIDTH);
+            try {
+                window.localStorage.setItem(PANEL_WIDTH_STORAGE_KEY, String(finalWidth));
+            }
+            catch (err) {
+                console.warn(err);
+            }
+            this._endResize();
+        };
+        window.addEventListener("mousemove", this._onResizeMove);
+        window.addEventListener("mouseup", this._onResizeUp);
+    }
+    _endResize() {
+        if (this._onResizeMove) {
+            window.removeEventListener("mousemove", this._onResizeMove);
+            this._onResizeMove = null;
+        }
+        if (this._onResizeUp) {
+            window.removeEventListener("mouseup", this._onResizeUp);
+            this._onResizeUp = null;
+        }
+    }
+    async _loadMenuItems() {
+        var _a, _b, _c, _d;
+        const viewId = (_a = this._widget) === null || _a === void 0 ? void 0 : _a.ViewId;
+        const token = ++this._loadToken;
+        let menuItems = [];
+        try {
+            if (viewId) {
+                const api = (_b = this._widget._getApiGetters()) === null || _b === void 0 ? void 0 : _b.GetBruceApi();
+                const data = await bruce_models_1.ProjectView.Get({
+                    viewId,
+                    api
+                });
+                const settings = (_c = data === null || data === void 0 ? void 0 : data.view) === null || _c === void 0 ? void 0 : _c.Settings;
+                menuItems = (_d = settings === null || settings === void 0 ? void 0 : settings.menuItems) !== null && _d !== void 0 ? _d : [];
+            }
+        }
+        catch (e) {
+            console.error(e);
+            menuItems = [];
+        }
+        if (this._disposed || token !== this._loadToken) {
+            return;
+        }
+        this._menuItems = menuItems;
+        this._renderTree();
+        this._updateStates();
+        this._updateCounts();
+    }
+    /**
+     * Records any menu items the manager has rendered that we haven't seen before.
+     * Returns whether anything new was added.
+     */
+    _snapshotManagerItems() {
+        var _a, _b, _c;
+        const manager = (_a = this._widget) === null || _a === void 0 ? void 0 : _a._getManager();
+        if (!manager) {
+            return false;
+        }
+        let added = false;
+        for (const id of (_b = manager.GetEnabledItemIds()) !== null && _b !== void 0 ? _b : []) {
+            if (this._managerItems.has(id)) {
+                continue;
+            }
+            const item = (_c = manager.GetEnabledItem(id)) === null || _c === void 0 ? void 0 : _c.item;
+            if (item === null || item === void 0 ? void 0 : item.id) {
+                this._managerItems.set(id, item);
+                added = true;
+            }
+        }
+        return added;
+    }
+    /**
+     * The view's menu items once there are any, otherwise whatever the manager has rendered.
+     */
+    _getTreeItems() {
+        if (this._menuItems.length) {
+            return this._menuItems;
+        }
+        return Array.from(this._managerItems.values());
+    }
+    _renderTree() {
+        this._rows.clear();
+        this._scrollBox.innerHTML = "";
+        const items = this._getTreeItems();
+        if (!items.length) {
+            this._tip.textContent = this._getEmptyText();
+            this._tip.style.display = "block";
+            return;
+        }
+        this._tip.style.display = "none";
+        for (const item of items) {
+            this._renderRow(item, 0, this._scrollBox);
+        }
+    }
+    _getEmptyText() {
+        var _a;
+        if ((_a = this._widget) === null || _a === void 0 ? void 0 : _a.ViewId) {
+            return "This project view has no menu items.";
+        }
+        return this._waitedForView ? "No view is loaded." : "Loading..";
+    }
+    _renderRow(item, depth, parent) {
+        var _a;
+        if (!(item === null || item === void 0 ? void 0 : item.id)) {
+            return;
+        }
+        const isFolder = !item.Type || item.Type === bruce_models_1.MenuItem.EType.None;
+        const children = item.hideChildren ? [] : ((_a = item.Children) !== null && _a !== void 0 ? _a : []);
+        const hasChildren = children.length > 0;
+        const row = document.createElement("div");
+        row.className = "NextspaceMenuItemRow";
+        row.setAttribute("menu-item-id", item.id);
+        const itemElement = document.createElement("div");
+        itemElement.className = "NextspaceMenuItemRowItem";
+        itemElement.style.paddingLeft = (depth * 15) + "px";
+        row.appendChild(itemElement);
+        if (hasChildren) {
+            const toggle = document.createElement("div");
+            toggle.className = "NextspaceMenuItemRowToggle";
+            toggle.onclick = () => {
+                this._setOpen(item.id, depth, row.getAttribute("show-children") !== "true", row, toggle);
+            };
+            itemElement.appendChild(toggle);
+            const opened = this._getOpen(item.id, depth);
+            row.setAttribute("show-children", opened ? "true" : "false");
+            toggle.innerHTML = opened ? ICON_CHEV_DOWN : ICON_CHEV_RIGHT;
+        }
+        else if (depth > 0) {
+            const bracket = document.createElement("div");
+            bracket.className = "NextspaceMenuItemRowBracket";
+            bracket.innerHTML = ICON_BRACKET;
+            itemElement.appendChild(bracket);
+            row.setAttribute("show-children", "false");
+        }
+        else {
+            row.setAttribute("show-children", "false");
+        }
+        const checkbox = document.createElement("div");
+        checkbox.className = "NextspaceMenuItemRowCheckbox";
+        checkbox.onclick = () => {
+            this._toggleItem(item);
+        };
+        itemElement.appendChild(checkbox);
+        const title = document.createElement("div");
+        title.className = "NextspaceMenuItemRowTitle";
+        title.textContent = item.Caption || "Unnamed Menu Item";
+        title.title = item.Caption || "Unnamed Menu Item";
+        itemElement.appendChild(title);
+        // Folders have no visuals of their own, so a count would always read zero.
+        let count = null;
+        if (!isFolder) {
+            count = document.createElement("div");
+            count.className = "NextspaceMenuItemRowCount";
+            count.style.display = "none";
+            count.onclick = () => {
+                this._selectItemEntities(item);
+            };
+            itemElement.appendChild(count);
+        }
+        const quickBar = document.createElement("div");
+        quickBar.className = "NextspaceMenuItemRowQuickBar";
+        itemElement.appendChild(quickBar);
+        if (!isFolder) {
+            const flyTo = document.createElement("div");
+            flyTo.className = "NextspaceMenuItemRowQuickBarButton";
+            flyTo.title = "Fly to";
+            flyTo.innerHTML = ICON_FLY_TO;
+            flyTo.onclick = () => {
+                this._flyToItem(item, flyTo);
+            };
+            quickBar.appendChild(flyTo);
+        }
+        if (item.Description) {
+            const description = document.createElement("p");
+            description.className = "NextspaceMenuItemRowDescription";
+            description.style.paddingLeft = (depth * 15) + "px";
+            description.textContent = item.Description;
+            row.appendChild(description);
+        }
+        const childrenElement = document.createElement("div");
+        childrenElement.className = "NextspaceMenuItemRowChildren";
+        row.appendChild(childrenElement);
+        parent.appendChild(row);
+        this._rows.set(item.id, {
+            item,
+            depth,
+            element: row,
+            itemElement,
+            checkboxElement: checkbox,
+            countElement: count,
+            childrenElement
+        });
+        for (const child of children) {
+            this._renderRow(child, depth + 1, childrenElement);
+        }
+    }
+    _getOpen(itemId, depth) {
+        try {
+            return window.localStorage.getItem(OPEN_STATE_STORAGE_PREFIX + itemId + depth) === "true";
+        }
+        catch (e) {
+            // Storage can be unavailable (private mode, blocked cookies). Not worth failing the tree over.
+            return false;
+        }
+    }
+    _setOpen(itemId, depth, open, row, toggle) {
+        row.setAttribute("show-children", open ? "true" : "false");
+        toggle.innerHTML = open ? ICON_CHEV_DOWN : ICON_CHEV_RIGHT;
+        try {
+            window.localStorage.setItem(OPEN_STATE_STORAGE_PREFIX + itemId + depth, open ? "true" : "false");
+        }
+        catch (e) {
+            console.warn(e);
+        }
+    }
+    /**
+     * Resolves each row's state from what the manager currently has rendered.
+     */
+    _updateStates() {
+        var _a;
+        const manager = (_a = this._widget) === null || _a === void 0 ? void 0 : _a._getManager();
+        if (!manager || this._disposed) {
+            return;
+        }
+        const enabledIds = new Set(manager.GetEnabledItemIds());
+        for (const row of Array.from(this._rows.values())) {
+            const state = this._resolveState(row.item, enabledIds);
+            row.itemElement.setAttribute("is-enabled", state === EMenuItemState.Disabled ? "false" : "true");
+            if (state === EMenuItemState.Enabled) {
+                row.checkboxElement.innerHTML = ICON_CHECK;
+            }
+            else if (state === EMenuItemState.ChildEnabled) {
+                row.checkboxElement.innerHTML = ICON_PARTIAL_CHECK;
+            }
+            else {
+                row.checkboxElement.innerHTML = "";
+            }
+        }
+    }
+    /**
+     * Works out a single item's state, rolling up children so a folder can report a partial state.
+     */
+    _resolveState(item, enabledIds) {
+        var _a;
+        const isFolder = !item.Type || item.Type === bruce_models_1.MenuItem.EType.None;
+        if (!isFolder) {
+            return enabledIds.has(item.id) ? EMenuItemState.Enabled : 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;
+            const currentIsFolder = !current.Type || current.Type === bruce_models_1.MenuItem.EType.None;
+            if (!currentIsFolder) {
+                actionCount += 1;
+                if (enabledIds.has(current.id)) {
+                    enabledActionCount += 1;
+                }
+                return;
+            }
+            if ((_a = current.Children) === null || _a === void 0 ? void 0 : _a.length) {
+                current.Children.forEach(traverse);
+            }
+        };
+        (_a = item.Children) === null || _a === void 0 ? void 0 : _a.forEach(traverse);
+        if (actionCount <= 0) {
+            return enabledIds.has(item.id) ? EMenuItemState.Enabled : EMenuItemState.Disabled;
+        }
+        if (enabledActionCount <= 0) {
+            return EMenuItemState.Disabled;
+        }
+        return enabledActionCount >= actionCount ? EMenuItemState.Enabled : EMenuItemState.ChildEnabled;
+    }
+    _updateCounts() {
+        var _a, _b;
+        const register = (_b = (_a = this._widget) === null || _a === void 0 ? void 0 : _a._getManager()) === null || _b === void 0 ? void 0 : _b.VisualsRegister;
+        if (!register || this._disposed) {
+            return;
+        }
+        for (const row of Array.from(this._rows.values())) {
+            if (!row.countElement) {
+                continue;
+            }
+            const count = register.GetRegos({
+                menuItemId: row.item.id
+            }).length;
+            row.countElement.style.display = count > 0 ? "block" : "none";
+            row.countElement.textContent = count.toLocaleString();
+        }
+    }
+    _toggleItem(item) {
+        var _a;
+        const manager = (_a = this._widget) === null || _a === void 0 ? void 0 : _a._getManager();
+        if (!manager) {
+            return;
+        }
+        const enabledIds = new Set(manager.GetEnabledItemIds());
+        const state = this._resolveState(item, enabledIds);
+        if (state === EMenuItemState.Enabled) {
+            this._disableItem(item);
+        }
+        else {
+            manager.RenderItem({
+                item
+            });
+        }
+        this._stateQueue.Call(true);
+    }
+    _disableItem(item) {
+        var _a, _b;
+        const manager = (_a = this._widget) === null || _a === void 0 ? void 0 : _a._getManager();
+        if (!manager) {
+            return;
+        }
+        if ((_b = item.Children) === null || _b === void 0 ? void 0 : _b.length) {
+            item.Children.forEach((child) => this._disableItem(child));
+        }
+        manager.RemoveItemById({
+            menuItemId: item.id
+        });
+    }
+    _selectItemEntities(item) {
+        var _a, _b;
+        const register = (_b = (_a = this._widget) === null || _a === void 0 ? void 0 : _a._getManager()) === null || _b === void 0 ? void 0 : _b.VisualsRegister;
+        if (!register) {
+            return;
+        }
+        const entityIds = register.GetRegos({
+            menuItemId: item.id
+        }).map(x => x.entityId);
+        if (!entityIds.length) {
+            return;
+        }
+        register.ClearSelected();
+        register.SetSelected({
+            selected: true,
+            entityIds,
+            menuItemId: item.id
+        });
+    }
+    /**
+     * Flies the camera to a menu item's contents.
+     * Tileset-backed items fall back to the tileset's own bounds when no entity visuals are registered.
+     */
+    async _flyToItem(item, button) {
+        var _a, _b, _c, _d;
+        if (this._flying.has(item.id)) {
+            return;
+        }
+        const manager = (_a = this._widget) === null || _a === void 0 ? void 0 : _a._getManager();
+        const viewer = (_b = this._widget) === null || _b === void 0 ? void 0 : _b._getViewer();
+        if (!manager || !viewer) {
+            return;
+        }
+        this._flying.add(item.id);
+        button.setAttribute("is-disabled", "true");
+        try {
+            const regos = manager.VisualsRegister.GetRegos({
+                menuItemId: item.id
+            }).filter(x => !!(x === null || x === void 0 ? void 0 : x.visual) && !(x.visual instanceof Cesium.Cesium3DTileFeature));
+            let tileset = null;
+            if (!regos.length && TILESET_TYPES.indexOf(item.Type) >= 0) {
+                const enabled = manager.GetEnabledItem(item.id);
+                tileset = (_d = (_c = enabled === null || enabled === void 0 ? void 0 : enabled.renderManager) === null || _c === void 0 ? void 0 : _c.Tileset) !== null && _d !== void 0 ? _d : null;
+            }
+            const entityIds = regos.map(x => x.entityId);
+            if (!entityIds.length && !tileset) {
+                return;
+            }
+            await entity_utils_1.EntityUtils.FlyTo({
+                viewer,
+                manager,
+                entityIds: entityIds.length ? entityIds : null,
+                tileset
+            });
+        }
+        catch (e) {
+            console.error(e);
+        }
+        finally {
+            this._flying.delete(item.id);
+            button.setAttribute("is-disabled", "false");
+        }
+    }
+}
+exports.WidgetLeftPanelTabMenuItems = WidgetLeftPanelTabMenuItems;
+//# sourceMappingURL=widget-left-panel-tab-menu-items.js.map