@mlightcad/cad-simple-viewer 1.8.0-preview.3 → 1.8.0-preview.4

package/lib/ui/AcApSimpleUiChrome.js

@@ -0,0 +1,1308 @@
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import { ACAP_PALETTE_NAMED_TAB, AcApDocManager, AcApPaletteService, AcApSettingManager } from '../app';
+import { acapBindToolbarDocState } from '../command/AcApToolbarDocBind';
+import { AcApFindUiCmd, AcApLayerUiCmd, AcApMarkupPanelUiCmd, AcApMeasurementPanelUiCmd, AcUiLayerDockController, AcUiLayerUiControllerHolder } from '../command/ui';
+import { AcEdCommandStack, acedGetUiLayout, acedSubscribeUiLayout } from '../editor';
+import { AcApI18n } from '../i18n';
+import { AcUiI18n, acuiRegisterSimpleUiI18n } from '../i18n/AcUiI18n';
+import { AcUiFindPaletteView } from './AcUiFindPaletteView';
+import { AcUiLayerListView } from './AcUiLayerListView';
+import { AcUiMeasurementPaletteView } from './AcUiMeasurementPaletteView';
+import { acuiNormalizeSimpleUiOptions } from './acuiNormalizeSimpleUiOptions';
+import { AcUiReviewPaletteView } from './AcUiReviewPaletteView';
+import { acuiRemoveUiStylesIfUnused } from './AcUiSimpleUiStyles';
+import { AcUiThemeSync } from './AcUiThemeSync';
+import { AcUiDockPanel } from './dock/AcUiDockPanel';
+import { acuiToolbarItemsIncludeItem } from './toolbar';
+import { AcUiToolbar } from './toolbar/AcUiToolbar';
+import { acuiMergeToolbarOptionsForLayout, acuiPrependToolbarLayoutSwitcher, acuiResolveDockMountTarget, acuiResolveToolbarItems, acuiResolveToolbarMountTarget } from './toolbar/simpleUiPresets';
+var LAYERS_TAB_ID = 'layers';
+var REVIEW_TAB_ID = 'review';
+var MEASUREMENTS_TAB_ID = 'measurements';
+var FIND_TAB_ID = 'find';
+/**
+ * Built-in plain-DOM chrome: toolbar, layer manager, and review palette.
+ *
+ * Registers the `layer`, `markuppanel`, and `measurementpanel` commands when
+ * the toolbar includes those buttons, injects shared UI styles, and keeps
+ * theme and locale in sync with {@link AcApI18n} and the `COLORTHEME` system
+ * variable.
+ *
+ * Supports responsive chrome via {@link AcUiSimpleUiOptions.layout} and
+ * {@link AcUiSimpleUiOptions.layouts}: phone (bottom full-width bar),
+ * pad, and desktop (default right-side toolbar). Use {@link getLayout} and
+ * {@link setLayout} to read or override the active layout at runtime.
+ */
+var AcApSimpleUiChrome = /** @class */ (function () {
+    /**
+     * @param options - Toolbar, layer manager, dock panel, and host configuration.
+     */
+    function AcApSimpleUiChrome(options) {
+        if (options === void 0) { options = {}; }
+        var _this = this;
+        this.options = options;
+        /** Mutable delegate for the registered `layer` command. */
+        this.layerUiControllerHolder = new AcUiLayerUiControllerHolder();
+        /** Resolved toolbar items before layer action wiring. */
+        this.baseToolbarItems = [];
+        /** Raw toolbar items configuration last applied via {@link setToolbarItems}. */
+        this.toolbarItemsInput = 'default';
+        /**
+         * When true, {@link setToolbarItems} replaced the layout-derived item list.
+         * Layout switches still update chrome (placement, size, labels) but keep
+         * this item list until the next {@link setToolbarItems} call.
+         */
+        this.toolbarItemsOverridden = false;
+        /** Whether the toolbar includes a layer button. */
+        this.hasLayerToolbarItem = false;
+        /** Whether the toolbar includes a markup panel / review button. */
+        this.hasMarkupPanelToolbarItem = false;
+        /** Whether the toolbar includes a measurement panel button. */
+        this.hasMeasurementPanelToolbarItem = false;
+        /** Whether the toolbar includes a find (text search) button. */
+        this.hasFindToolbarItem = false;
+        /** Whether {@link dockPanel} was explicitly enabled in options. */
+        this.dockPanelExplicitlyEnabled = false;
+        /** Current toolbar edge placement (mutable via toolbar settings button). */
+        this.toolbarPlacement = 'right';
+        /** Whether the viewer toolbar supports collapse/expand. */
+        this.toolbarCollapsible = false;
+        /** Inset of the viewer toolbar from the canvas edge in px. */
+        this.toolbarEdgeOffset = 8;
+        /** Cross-axis inset of the viewer toolbar from host edges in px. */
+        this.toolbarSideOffset = 0;
+        /**
+         * When true, the toolbar is a flex sibling of the canvas in the canvas parent.
+         */
+        this.toolbarInCanvasParent = false;
+        /** Whether the main toolbar shows labels below icons. */
+        this.toolbarShowLabels = false;
+        /** Whether parent buttons with children show a corner triangle. */
+        this.toolbarShowChildrenIndicator = true;
+        /** Whether the toolbar container border is shown. */
+        this.toolbarShowBorder = true;
+        /** Whether each toolbar button draws a permanent outer border. */
+        this.toolbarShowButtonBorder = false;
+        /** Whether toolbar separator dividers are shown. */
+        this.toolbarShowSeparators = true;
+        /** Toolbar sizing along the layout axis (`auto` or `stretch`). */
+        this.toolbarSize = 'auto';
+        /** Overflow behavior when buttons exceed host bounds. */
+        this.toolbarOverflow = 'menu';
+        /** Layout mode from plugin options (`auto` or forced kind). */
+        this.layoutMode = 'auto';
+        /** Active resolved layout kind after merging defaults. */
+        this.activeLayoutKind = 'desktop';
+        /** Commands registered during {@link start} for cleanup on {@link dispose}. */
+        this.registeredCommands = [];
+        /** Refreshes toolbar, layer, and review UI when the app locale changes. */
+        this.handleLocaleChanged = function () {
+            var _a, _b, _c, _d, _e, _f;
+            _this.rebuildToolbarItems(_this.activeLayoutKind);
+            (_a = _this.toolbar) === null || _a === void 0 ? void 0 : _a.setSelectedChild('locale', "locale-".concat(AcApI18n.currentLocale));
+            (_b = _this.layerListView) === null || _b === void 0 ? void 0 : _b.refreshLocale();
+            (_c = _this.reviewPaletteView) === null || _c === void 0 ? void 0 : _c.refreshLocale();
+            (_d = _this.measurementPaletteView) === null || _d === void 0 ? void 0 : _d.refreshLocale();
+            (_e = _this.findPaletteView) === null || _e === void 0 ? void 0 : _e.refreshLocale();
+            (_f = _this.dockPanel) === null || _f === void 0 ? void 0 : _f.refreshLocale();
+            if (_this.toolbar) {
+                _this.toolbar.updateItems(_this.baseToolbarItems);
+                _this.toolbar.refreshLocale();
+            }
+        };
+        /** Re-resolves mount targets after the viewer view becomes available. */
+        this.handleDocumentActivatedForDock = function () {
+            var _a, _b;
+            if (_this.hasLayerToolbarItem) {
+                _this.mountLayerDockUi();
+            }
+            if (_this.hasMarkupPanelToolbarItem) {
+                _this.mountReviewDockUi();
+            }
+            if (_this.hasMeasurementPanelToolbarItem) {
+                _this.mountMeasurementDockUi();
+            }
+            if (_this.hasFindToolbarItem) {
+                _this.mountFindDockUi();
+            }
+            _this.tryUpgradeDockMountTarget();
+            (_a = _this.dockPanel) === null || _a === void 0 ? void 0 : _a.ensureMounted();
+            _this.ensureViewerToolbar();
+            _this.tryUpgradeToolbarMountTarget();
+            (_b = _this.toolbar) === null || _b === void 0 ? void 0 : _b.syncInParentLayout();
+        };
+        /**
+         * Shows command panels from `AcApPaletteService` (e.g. `pdftext`) as dock
+         * panel tabs while their command runs. Closing the dock ends the command;
+         * the dock is restored afterwards (closed, or on its previous tab).
+         */
+        this.paletteHost = {
+            show: function (content, onUserClose) {
+                _this.ensureDockReady();
+                var dock = _this.dockPanel;
+                if (!dock)
+                    return undefined;
+                var tabId = "hosted-".concat(content.id);
+                var wasOpen = dock.isOpen;
+                var previousTab = dock.activeTab;
+                dock.removeTab(tabId);
+                if (!dock.addTab({
+                    id: tabId,
+                    label: content.title,
+                    content: content.element
+                })) {
+                    return undefined;
+                }
+                dock.open(tabId);
+                var removeListener = dock.addCloseListener(onUserClose);
+                return {
+                    close: function () {
+                        removeListener();
+                        dock.removeTab(tabId);
+                        if (!wasOpen)
+                            dock.close();
+                        else if (previousTab && previousTab !== tabId)
+                            dock.open(previousTab);
+                    }
+                };
+            },
+            openNamedTab: function (id) {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+                switch (id) {
+                    case ACAP_PALETTE_NAMED_TAB.layers:
+                        _this.prepareLayerDockForCommand();
+                        _this.layerUiControllerHolder.toggleFromCommand();
+                        return (_b = (_a = _this.dockPanel) === null || _a === void 0 ? void 0 : _a.hasTab(LAYERS_TAB_ID)) !== null && _b !== void 0 ? _b : false;
+                    case ACAP_PALETTE_NAMED_TAB.review:
+                        _this.prepareReviewDockForCommand();
+                        (_c = _this.dockPanel) === null || _c === void 0 ? void 0 : _c.open(REVIEW_TAB_ID);
+                        return (_e = (_d = _this.dockPanel) === null || _d === void 0 ? void 0 : _d.hasTab(REVIEW_TAB_ID)) !== null && _e !== void 0 ? _e : false;
+                    case ACAP_PALETTE_NAMED_TAB.measurements:
+                        _this.prepareMeasurementDockForCommand();
+                        (_f = _this.dockPanel) === null || _f === void 0 ? void 0 : _f.open(MEASUREMENTS_TAB_ID);
+                        return (_h = (_g = _this.dockPanel) === null || _g === void 0 ? void 0 : _g.hasTab(MEASUREMENTS_TAB_ID)) !== null && _h !== void 0 ? _h : false;
+                    case ACAP_PALETTE_NAMED_TAB.find:
+                        _this.mountFindDockUi();
+                        _this.tryUpgradeDockMountTarget();
+                        if (!((_j = _this.dockPanel) === null || _j === void 0 ? void 0 : _j.hasTab(FIND_TAB_ID)))
+                            return false;
+                        _this.dockPanel.open(FIND_TAB_ID);
+                        (_k = _this.findPaletteView) === null || _k === void 0 ? void 0 : _k.focus();
+                        return true;
+                    default:
+                        return false;
+                }
+            }
+        };
+    }
+    /**
+     * Adds a tab to the dock panel and opens it.
+     * Creates the dock panel container when it does not exist yet.
+     *
+     * @param tab - Tab definition.
+     * @returns Whether the tab was added.
+     */
+    AcApSimpleUiChrome.prototype.addDockPanelTab = function (tab) {
+        if (!tab.labelKey && !tab.label)
+            return false;
+        this.ensureDockReady();
+        if (!this.dockPanel)
+            return false;
+        if (!this.dockPanel.addTab(tab))
+            return false;
+        this.dockPanel.open(tab.id);
+        return true;
+    };
+    /** Whether the dock panel is open. */
+    AcApSimpleUiChrome.prototype.isDockPanelOpen = function () {
+        var _a, _b;
+        return (_b = (_a = this.dockPanel) === null || _a === void 0 ? void 0 : _a.isOpen) !== null && _b !== void 0 ? _b : false;
+    };
+    /** Whether a dock panel tab with the given id is registered. */
+    AcApSimpleUiChrome.prototype.hasDockPanelTab = function (tabId) {
+        var _a, _b;
+        return (_b = (_a = this.dockPanel) === null || _a === void 0 ? void 0 : _a.hasTab(tabId)) !== null && _b !== void 0 ? _b : false;
+    };
+    /**
+     * Opens the dock panel and activates a tab, or closes the panel when that tab
+     * is already active.
+     *
+     * @param tabId - Tab to toggle.
+     * @returns `true` when applied; `false` when the tab or dock panel is unavailable.
+     */
+    AcApSimpleUiChrome.prototype.toggleDockPanelTab = function (tabId) {
+        var _a;
+        if (!((_a = this.dockPanel) === null || _a === void 0 ? void 0 : _a.hasTab(tabId))) {
+            return false;
+        }
+        this.ensureDockReady();
+        if (!this.dockPanel) {
+            return false;
+        }
+        this.dockPanel.toggle(tabId);
+        return true;
+    };
+    /**
+     * Opens or closes the dock panel.
+     *
+     * @param open - Target open state.
+     * @returns `true` when applied; `false` when the dock panel is unavailable.
+     */
+    AcApSimpleUiChrome.prototype.setDockPanelOpen = function (open) {
+        if (open) {
+            this.ensureDockReady();
+            if (!this.dockPanel) {
+                console.warn('[SimpleUiChrome] setDockPanelOpen skipped: dock panel is unavailable.');
+                return false;
+            }
+            this.dockPanel.open();
+            return true;
+        }
+        if (!this.dockPanel) {
+            return true;
+        }
+        this.dockPanel.close();
+        return true;
+    };
+    /** Returns the dock panel side, if the dock panel exists. */
+    AcApSimpleUiChrome.prototype.getDockPanelSide = function () {
+        var _a;
+        return (_a = this.dockPanel) === null || _a === void 0 ? void 0 : _a.getSide();
+    };
+    /** Returns the dock panel size in px, if the dock panel exists. */
+    AcApSimpleUiChrome.prototype.getDockPanelSize = function () {
+        var _a;
+        return (_a = this.dockPanel) === null || _a === void 0 ? void 0 : _a.getSize();
+    };
+    /**
+     * Sets the dock panel width or height in px.
+     *
+     * @param size - Target size in px.
+     * @returns `true` when applied; `false` when the dock panel is unavailable.
+     */
+    AcApSimpleUiChrome.prototype.setDockPanelSize = function (size) {
+        this.ensureDockReady();
+        if (!this.dockPanel) {
+            console.warn('[SimpleUiChrome] setDockPanelSize skipped: dock panel is unavailable.');
+            return false;
+        }
+        this.dockPanel.setPanelSize(size);
+        return true;
+    };
+    /** Returns the toolbar item configuration last passed to {@link setToolbarItems}. */
+    AcApSimpleUiChrome.prototype.getToolbarItems = function () {
+        return this.toolbarItemsInput;
+    };
+    /**
+     * Replaces the entire toolbar item list at runtime.
+     *
+     * Unlike `toolbar.appendItems`, this replaces the full `items` collection.
+     * Preset references and `'default'` are resolved using the same rules as
+     * initial plugin load. Subsequent {@link setLayout} / auto viewport switches
+     * keep this list and only update toolbar chrome.
+     *
+     * @param items - Full toolbar layout definition.
+     * @param layoutSwitcher - Optional layout submenu button prepended before `items`.
+     */
+    AcApSimpleUiChrome.prototype.setToolbarItems = function (items, layoutSwitcher) {
+        if (!this.toolbar)
+            return;
+        this.toolbarItemsOverridden = true;
+        this.toolbarLayoutSwitcher = layoutSwitcher;
+        this.toolbarItemsInput = items;
+        var resolved = this.resolveBaseToolbarItems(items);
+        this.baseToolbarItems = layoutSwitcher
+            ? acuiPrependToolbarLayoutSwitcher(resolved, layoutSwitcher)
+            : resolved;
+        this.syncLayerToolbarItem();
+        this.syncReviewToolbarItem();
+        this.syncMeasurementToolbarItem();
+        this.syncFindToolbarItem();
+        this.renderToolbarItems();
+    };
+    /** Returns the viewer toolbar edge placement. */
+    AcApSimpleUiChrome.prototype.getToolbarPlacement = function () {
+        return this.toolbarPlacement;
+    };
+    /**
+     * Moves the viewer toolbar to another host edge.
+     *
+     * @param placement - Target edge placement.
+     * @returns `true` when applied; `false` when the toolbar is unavailable.
+     */
+    AcApSimpleUiChrome.prototype.setToolbarPlacement = function (placement) {
+        if (!this.toolbar) {
+            console.warn('[SimpleUiChrome] setToolbarPlacement skipped: toolbar is unavailable.');
+            return false;
+        }
+        this.applyToolbarPlacement(placement);
+        return true;
+    };
+    /** Whether the viewer toolbar is visible. */
+    AcApSimpleUiChrome.prototype.isToolbarVisible = function () {
+        var _a, _b;
+        return (_b = (_a = this.toolbar) === null || _a === void 0 ? void 0 : _a.isVisible) !== null && _b !== void 0 ? _b : false;
+    };
+    /**
+     * Shows or hides the viewer toolbar.
+     *
+     * @param visible - Target visibility.
+     * @returns `true` when applied; `false` when the toolbar is unavailable.
+     */
+    AcApSimpleUiChrome.prototype.setToolbarVisible = function (visible) {
+        var _a;
+        if (!this.toolbar) {
+            console.warn('[SimpleUiChrome] setToolbarVisible skipped: toolbar is unavailable.');
+            return false;
+        }
+        this.toolbar.setVisible(visible);
+        if (!visible) {
+            (_a = this.dockPanel) === null || _a === void 0 ? void 0 : _a.close();
+        }
+        return true;
+    };
+    /** Whether the viewer toolbar is collapsed to its toggle button. */
+    AcApSimpleUiChrome.prototype.isToolbarCollapsed = function () {
+        var _a, _b;
+        return (_b = (_a = this.toolbar) === null || _a === void 0 ? void 0 : _a.isCollapsed) !== null && _b !== void 0 ? _b : false;
+    };
+    /**
+     * Collapses or expands the viewer toolbar when {@link toolbar.collapsible} is enabled.
+     *
+     * @param collapsed - Target collapsed state.
+     * @returns `true` when applied; `false` when the toolbar is unavailable or not collapsible.
+     */
+    AcApSimpleUiChrome.prototype.setToolbarCollapsed = function (collapsed) {
+        if (!this.toolbar) {
+            console.warn('[SimpleUiChrome] setToolbarCollapsed skipped: toolbar is unavailable.');
+            return false;
+        }
+        if (!this.toolbarCollapsible) {
+            console.warn('[SimpleUiChrome] setToolbarCollapsed skipped: toolbar is not collapsible.');
+            return false;
+        }
+        this.toolbar.setCollapsed(collapsed);
+        return true;
+    };
+    /** Returns the viewer toolbar inset from the canvas edge in px. */
+    AcApSimpleUiChrome.prototype.getToolbarEdgeOffset = function () {
+        var _a, _b;
+        return (_b = (_a = this.toolbar) === null || _a === void 0 ? void 0 : _a.getEdgeOffset()) !== null && _b !== void 0 ? _b : this.toolbarEdgeOffset;
+    };
+    /** Returns the active UI layout kind (`phone`, `pad`, or `desktop`). */
+    AcApSimpleUiChrome.prototype.getLayout = function () {
+        return this.activeLayoutKind;
+    };
+    /**
+     * Sets layout mode and reapplies toolbar chrome for the target kind.
+     *
+     * When `mode` is `'auto'`, subscribes to viewport media queries via
+     * {@link acedSubscribeUiLayout} and switches toolbar configuration when
+     * {@link acedGetUiLayout} changes. Forced modes stop auto subscription.
+     *
+     * @param mode - `'auto'` or a fixed {@link AcEdUiLayoutKind}.
+     * @returns `true` when the mode was stored or applied; `false` when the
+     *   toolbar is unavailable and the mode could not be applied (except when only
+     *   updating stored mode before toolbar creation).
+     */
+    AcApSimpleUiChrome.prototype.setLayout = function (mode) {
+        var _this = this;
+        var _a;
+        if (!this.toolbar && mode !== this.layoutMode) {
+            this.layoutMode = mode;
+            return true;
+        }
+        if (!this.toolbar)
+            return false;
+        this.layoutMode = mode;
+        (_a = this.unsubscribeLayout) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.unsubscribeLayout = undefined;
+        if (mode === 'auto') {
+            this.unsubscribeLayout = acedSubscribeUiLayout(function (kind) {
+                if (kind !== _this.activeLayoutKind) {
+                    _this.applyLayoutKind(kind);
+                }
+            });
+            this.applyLayoutKind(acedGetUiLayout());
+        }
+        else {
+            this.applyLayoutKind(mode);
+        }
+        return true;
+    };
+    /**
+     * Sets the viewer toolbar inset from the canvas edge.
+     *
+     * @param offset - Distance in px (clamped to >= 0).
+     * @returns `true` when applied; `false` when the toolbar is unavailable.
+     */
+    AcApSimpleUiChrome.prototype.setToolbarEdgeOffset = function (offset) {
+        if (!this.toolbar) {
+            console.warn('[SimpleUiChrome] setToolbarEdgeOffset skipped: toolbar is unavailable.');
+            return false;
+        }
+        this.toolbarEdgeOffset = Math.max(0, offset);
+        this.toolbar.setEdgeOffset(this.toolbarEdgeOffset);
+        return true;
+    };
+    /**
+     * Creates UI components, registers commands, and starts theme sync.
+     *
+     * @param commandManager - Command stack used to register UI commands.
+     */
+    AcApSimpleUiChrome.prototype.start = function (commandManager) {
+        var _this = this;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        acuiRegisterSimpleUiI18n();
+        this.commandManager = commandManager;
+        // This shell has no command ribbon; keep the draw-style overlay available
+        // without persisting isShowRibbon into shared localStorage.
+        AcApSettingManager.instance.set('isShowRibbon', false, { persist: false });
+        var resolvedOptions = acuiNormalizeSimpleUiOptions(this.options);
+        var host = (_c = (_a = resolvedOptions.host) !== null && _a !== void 0 ? _a : (_b = AcApDocManager.instance.curView) === null || _b === void 0 ? void 0 : _b.container) !== null && _c !== void 0 ? _c : document.body;
+        this.hostEl = host;
+        this.dockPanelMountTargetOption = (_d = this.options.dockPanel) === null || _d === void 0 ? void 0 : _d.mountTarget;
+        this.toolbarMountTargetOption = (_e = this.options.toolbar) === null || _e === void 0 ? void 0 : _e.mountTarget;
+        this.layoutMode = resolvedOptions.layout;
+        this.dockPanelExplicitlyEnabled = resolvedOptions.dockPanel.enabled === true;
+        this.dockPanelDefaults = {
+            defaultOpen: (_f = resolvedOptions.dockPanel.defaultOpen) !== null && _f !== void 0 ? _f : false,
+            defaultSide: (_g = resolvedOptions.dockPanel.defaultSide) !== null && _g !== void 0 ? _g : 'left',
+            defaultHeight: (_h = resolvedOptions.dockPanel.defaultHeight) !== null && _h !== void 0 ? _h : 240,
+            defaultWidth: (_j = resolvedOptions.dockPanel.defaultWidth) !== null && _j !== void 0 ? _j : 280
+        };
+        this.themeSync = new AcUiThemeSync(host, function () { var _a; return (_a = _this.toolbar) === null || _a === void 0 ? void 0 : _a.refresh(); });
+        this.themeSync.start();
+        AcApPaletteService.setHost(this.paletteHost);
+        this.i18n = new AcUiI18n();
+        AcApI18n.events.localeChanged.addEventListener(this.handleLocaleChanged);
+        AcApDocManager.instance.events.documentActivated.addEventListener(this.handleDocumentActivatedForDock);
+        var initialLayout = this.layoutMode === 'auto' ? acedGetUiLayout() : this.layoutMode;
+        var toolbarEnabled = this.isViewerToolbarEnabled();
+        this.applyLayoutKind(initialLayout, { skipToolbarApply: !toolbarEnabled });
+        if (resolvedOptions.shouldCreateDockPanel) {
+            this.ensureDockPanel();
+        }
+        // applyLayoutKind → syncLayerToolbarItem / syncReviewToolbarItem /
+        // syncMeasurementToolbarItem may already have registered these; use
+        // ensure* so start stays idempotent.
+        if (this.hasLayerToolbarItem) {
+            this.mountLayerDockUi();
+            this.ensureLayerCommandRegistered();
+        }
+        if (this.hasMarkupPanelToolbarItem) {
+            this.mountReviewDockUi();
+            this.ensureMarkupPanelCommandRegistered();
+        }
+        if (this.hasMeasurementPanelToolbarItem) {
+            this.mountMeasurementDockUi();
+            this.ensureMeasurementPanelCommandRegistered();
+        }
+        if (this.hasFindToolbarItem) {
+            this.mountFindDockUi();
+            this.ensureFindCommandRegistered();
+        }
+        this.ensureViewerToolbar(host);
+    };
+    /** Whether viewer toolbar creation is allowed (only explicit `false` disables). */
+    AcApSimpleUiChrome.prototype.isViewerToolbarEnabled = function () {
+        var _a;
+        return ((_a = this.options.toolbar) === null || _a === void 0 ? void 0 : _a.enabled) !== false;
+    };
+    /**
+     * Creates the floating toolbar when enabled and not already present.
+     *
+     * @param host - Plugin theme host; defaults to {@link hostEl}.
+     */
+    AcApSimpleUiChrome.prototype.ensureViewerToolbar = function (host) {
+        var _this = this;
+        var _a, _b;
+        if (!this.isViewerToolbarEnabled()) {
+            return;
+        }
+        if (this.toolbar) {
+            if (this.toolbar.isRootConnected()) {
+                return;
+            }
+            (_a = this.toolbarDocUnbind) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.toolbarDocUnbind = undefined;
+            this.toolbar.destroy();
+            this.toolbar = undefined;
+            this.toolbarMountEl = undefined;
+        }
+        var mountHost = host !== null && host !== void 0 ? host : this.hostEl;
+        if (!mountHost || !this.i18n) {
+            return;
+        }
+        var toolbarMountEl = (_b = this.getToolbarMountEl()) !== null && _b !== void 0 ? _b : mountHost;
+        this.toolbarMountEl = toolbarMountEl;
+        var mergedToolbar = this.getMergedToolbarOptions(this.activeLayoutKind);
+        try {
+            this.toolbar = new AcUiToolbar({
+                host: toolbarMountEl,
+                themeHost: mountHost,
+                placement: this.toolbarPlacement,
+                edgeOffset: this.toolbarEdgeOffset,
+                sideOffset: this.toolbarSideOffset,
+                items: this.baseToolbarItems,
+                i18n: this.i18n,
+                collapsible: this.toolbarCollapsible,
+                defaultCollapsed: mergedToolbar.defaultCollapsed,
+                showLabels: this.toolbarShowLabels,
+                showChildrenIndicator: this.toolbarShowChildrenIndicator,
+                size: this.toolbarSize,
+                overflow: this.toolbarOverflow,
+                showBorder: this.toolbarShowBorder,
+                showButtonBorder: this.toolbarShowButtonBorder,
+                showSeparators: this.toolbarShowSeparators,
+                inCanvasParent: this.toolbarInCanvasParent,
+                subToolbar: this.toolbarSubToolbar,
+                onCollapse: function () {
+                    var _a;
+                    (_a = _this.dockPanel) === null || _a === void 0 ? void 0 : _a.close();
+                },
+                onExclusiveOpen: function () { return _this.dismissDockForExclusiveChrome(); },
+                onCommand: function (command) {
+                    AcApDocManager.instance.sendStringToExecute(command);
+                }
+            });
+            this.toolbarDocUnbind = acapBindToolbarDocState(this.toolbar);
+        }
+        catch (error) {
+            console.error('[SimpleUiChrome] Failed to create viewer toolbar:', error);
+            return;
+        }
+        try {
+            this.setLayout(this.layoutMode);
+        }
+        catch (error) {
+            console.warn('[SimpleUiChrome] setLayout failed during toolbar setup:', error);
+        }
+    };
+    /** Resolves the canvas element that receives the viewer toolbar. */
+    AcApSimpleUiChrome.prototype.getToolbarMountEl = function () {
+        if (!this.hostEl)
+            return undefined;
+        if (this.toolbarInCanvasParent) {
+            return acuiResolveDockMountTarget(this.hostEl, this.toolbarMountTargetOption);
+        }
+        return acuiResolveToolbarMountTarget(this.hostEl, this.toolbarMountTargetOption);
+    };
+    /**
+     * Moves the toolbar from a host or inner-canvas fallback to the preferred
+     * mount (typically the canvas parent) once the view is available.
+     */
+    AcApSimpleUiChrome.prototype.tryUpgradeToolbarMountTarget = function () {
+        var _a;
+        if (this.toolbarMountTargetOption || !this.hostEl || !this.toolbar) {
+            return;
+        }
+        var preferred = this.getToolbarMountEl();
+        if (!preferred || preferred === this.toolbarMountEl) {
+            return;
+        }
+        var canvasContainer = (_a = AcApDocManager.instance.curView) === null || _a === void 0 ? void 0 : _a.container;
+        var canvasParent = canvasContainer === null || canvasContainer === void 0 ? void 0 : canvasContainer.parentElement;
+        if (this.toolbarMountEl !== this.hostEl &&
+            this.toolbarMountEl !== canvasContainer &&
+            this.toolbarMountEl !== canvasParent) {
+            return;
+        }
+        this.toolbar.reparentTo(preferred);
+        this.toolbarMountEl = preferred;
+        this.toolbar.syncInParentLayout();
+    };
+    /**
+     * Merges built-in, top-level, and per-layout toolbar options for a kind.
+     *
+     * @param kind - Layout kind to resolve options for.
+     * @returns Merged {@link AcUiToolbarOptions} used by {@link applyLayoutKind}.
+     */
+    AcApSimpleUiChrome.prototype.getMergedToolbarOptions = function (kind) {
+        var _a, _b;
+        return acuiMergeToolbarOptionsForLayout(kind, this.options.toolbar, (_b = (_a = this.options.layouts) === null || _a === void 0 ? void 0 : _a[kind]) === null || _b === void 0 ? void 0 : _b.toolbar);
+    };
+    /**
+     * Applies toolbar configuration for a layout kind and refreshes dock wiring.
+     *
+     * Chrome always comes from merged layout options. Item lists come from those
+     * options unless {@link setToolbarItems} has replaced them at runtime.
+     *
+     * @param kind - Target layout kind.
+     * @param options - When `skipToolbarApply` is true, only updates resolved state.
+     */
+    AcApSimpleUiChrome.prototype.applyLayoutKind = function (kind, options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        this.activeLayoutKind = kind;
+        var toolbarOpts = this.getMergedToolbarOptions(kind);
+        this.toolbarPlacement = (_a = toolbarOpts.placement) !== null && _a !== void 0 ? _a : 'right';
+        this.toolbarCollapsible = (_b = toolbarOpts.collapsible) !== null && _b !== void 0 ? _b : false;
+        this.toolbarEdgeOffset = (_c = toolbarOpts.edgeOffset) !== null && _c !== void 0 ? _c : 8;
+        this.toolbarSideOffset = (_d = toolbarOpts.sideOffset) !== null && _d !== void 0 ? _d : 0;
+        this.toolbarShowLabels = (_e = toolbarOpts.showLabels) !== null && _e !== void 0 ? _e : false;
+        this.toolbarShowChildrenIndicator =
+            (_f = toolbarOpts.showChildrenIndicator) !== null && _f !== void 0 ? _f : true;
+        this.toolbarShowBorder = (_g = toolbarOpts.showBorder) !== null && _g !== void 0 ? _g : true;
+        this.toolbarShowButtonBorder = (_h = toolbarOpts.showButtonBorder) !== null && _h !== void 0 ? _h : false;
+        this.toolbarShowSeparators = (_j = toolbarOpts.showSeparators) !== null && _j !== void 0 ? _j : true;
+        this.toolbarSize = (_k = toolbarOpts.size) !== null && _k !== void 0 ? _k : 'auto';
+        this.toolbarOverflow = (_l = toolbarOpts.overflow) !== null && _l !== void 0 ? _l : 'menu';
+        this.toolbarSubToolbar = toolbarOpts.subToolbar;
+        var nextInCanvasParent = toolbarOpts.inCanvasParent === true;
+        var inCanvasParentChanged = nextInCanvasParent !== this.toolbarInCanvasParent;
+        this.toolbarInCanvasParent = nextInCanvasParent;
+        this.rebuildToolbarItems(kind, toolbarOpts);
+        this.syncLayerToolbarItem();
+        this.syncReviewToolbarItem();
+        this.syncMeasurementToolbarItem();
+        this.syncFindToolbarItem();
+        if ((options === null || options === void 0 ? void 0 : options.skipToolbarApply) || !this.toolbar) {
+            return;
+        }
+        // Unwrap/wrap before remounting so overlay resolution never sees a
+        // transient `toolbar-main` as `canvas.parentElement`.
+        this.toolbar.applyViewOptions({
+            placement: this.toolbarPlacement,
+            edgeOffset: this.toolbarEdgeOffset,
+            sideOffset: this.toolbarSideOffset,
+            collapsible: this.toolbarCollapsible,
+            defaultCollapsed: toolbarOpts.defaultCollapsed,
+            showLabels: this.toolbarShowLabels,
+            showChildrenIndicator: this.toolbarShowChildrenIndicator,
+            size: this.toolbarSize,
+            overflow: this.toolbarOverflow,
+            showBorder: this.toolbarShowBorder,
+            showButtonBorder: this.toolbarShowButtonBorder,
+            showSeparators: this.toolbarShowSeparators,
+            subToolbar: this.toolbarSubToolbar,
+            inCanvasParent: this.toolbarInCanvasParent,
+            items: this.baseToolbarItems
+        });
+        if (inCanvasParentChanged || !this.toolbar.isRootConnected()) {
+            var preferred = this.getToolbarMountEl();
+            if (preferred) {
+                this.toolbar.reparentTo(preferred);
+                this.toolbarMountEl = preferred;
+            }
+        }
+        this.toolbar.syncInParentLayout();
+    };
+    /** Context passed when resolving default toolbar presets. */
+    AcApSimpleUiChrome.prototype.getToolbarContext = function () {
+        var _this = this;
+        return {
+            getTheme: function () { var _a, _b; return (_b = (_a = _this.themeSync) === null || _a === void 0 ? void 0 : _a.getTheme()) !== null && _b !== void 0 ? _b : 'dark'; },
+            setTheme: function (theme) { var _a; return (_a = _this.themeSync) === null || _a === void 0 ? void 0 : _a.setTheme(theme); },
+            getLocale: function () { return AcApI18n.currentLocale; },
+            setLocale: function (locale) { return _this.setLocale(locale); },
+            getPlacement: function () { return _this.toolbarPlacement; },
+            setPlacement: function (placement) {
+                _this.applyToolbarPlacement(placement);
+            }
+        };
+    };
+    /**
+     * Resolves {@link baseToolbarItems} from a runtime override or layout options.
+     *
+     * @param kind - Layout kind used for `'default'` and preset expansion.
+     * @param toolbarOpts - Merged options for `kind`; fetched when omitted.
+     */
+    AcApSimpleUiChrome.prototype.rebuildToolbarItems = function (kind, toolbarOpts) {
+        var _a;
+        if (this.toolbarItemsOverridden) {
+            var resolved = this.resolveBaseToolbarItems(this.toolbarItemsInput);
+            this.baseToolbarItems = this.toolbarLayoutSwitcher
+                ? acuiPrependToolbarLayoutSwitcher(resolved, this.toolbarLayoutSwitcher)
+                : resolved;
+            return;
+        }
+        var merged = toolbarOpts !== null && toolbarOpts !== void 0 ? toolbarOpts : this.getMergedToolbarOptions(kind);
+        this.toolbarItemsInput = (_a = merged.items) !== null && _a !== void 0 ? _a : 'default';
+        this.baseToolbarItems = acuiResolveToolbarItems(merged, this.getToolbarContext(), kind);
+    };
+    /** Resolves raw toolbar input into concrete toolbar items. */
+    AcApSimpleUiChrome.prototype.resolveBaseToolbarItems = function (items) {
+        return acuiResolveToolbarItems({
+            items: items,
+            appendItems: undefined
+        }, this.getToolbarContext(), this.activeLayoutKind);
+    };
+    /** Applies {@link baseToolbarItems} to the toolbar. */
+    AcApSimpleUiChrome.prototype.renderToolbarItems = function () {
+        var _a;
+        (_a = this.toolbar) === null || _a === void 0 ? void 0 : _a.updateItems(this.baseToolbarItems);
+    };
+    /** Mounts or tears down layer UI when the layer toolbar button is added or removed. */
+    AcApSimpleUiChrome.prototype.syncLayerToolbarItem = function () {
+        var hadLayer = this.hasLayerToolbarItem;
+        var hasLayer = acuiToolbarItemsIncludeItem(this.baseToolbarItems, 'layer');
+        this.hasLayerToolbarItem = hasLayer;
+        if (hasLayer && !hadLayer) {
+            this.ensureLayerCommandRegistered();
+            this.mountLayerDockUi();
+        }
+        else if (!hasLayer && hadLayer) {
+            this.teardownLayerUi();
+            this.unregisterLayerCommand();
+        }
+    };
+    /** Mounts or tears down review UI when the markup panel button is added or removed. */
+    AcApSimpleUiChrome.prototype.syncReviewToolbarItem = function () {
+        var hadReview = this.hasMarkupPanelToolbarItem;
+        var hasReview = acuiToolbarItemsIncludeItem(this.baseToolbarItems, 'markup-panel');
+        this.hasMarkupPanelToolbarItem = hasReview;
+        if (hasReview && !hadReview) {
+            this.ensureMarkupPanelCommandRegistered();
+            this.mountReviewDockUi();
+        }
+        else if (!hasReview && hadReview) {
+            this.teardownReviewUi();
+            this.unregisterMarkupPanelCommand();
+        }
+    };
+    /** Mounts or tears down measurement UI when the panel button is added or removed. */
+    AcApSimpleUiChrome.prototype.syncMeasurementToolbarItem = function () {
+        var hadPanel = this.hasMeasurementPanelToolbarItem;
+        var hasPanel = acuiToolbarItemsIncludeItem(this.baseToolbarItems, 'measurement-panel');
+        this.hasMeasurementPanelToolbarItem = hasPanel;
+        if (hasPanel && !hadPanel) {
+            this.ensureMeasurementPanelCommandRegistered();
+            this.mountMeasurementDockUi();
+        }
+        else if (!hasPanel && hadPanel) {
+            this.teardownMeasurementUi();
+            this.unregisterMeasurementPanelCommand();
+        }
+    };
+    /** Mounts or tears down find UI when the find toolbar button is added or removed. */
+    AcApSimpleUiChrome.prototype.syncFindToolbarItem = function () {
+        var hadFind = this.hasFindToolbarItem;
+        var hasFind = acuiToolbarItemsIncludeItem(this.baseToolbarItems, 'find');
+        this.hasFindToolbarItem = hasFind;
+        if (hasFind && !hadFind) {
+            this.ensureFindCommandRegistered();
+            this.mountFindDockUi();
+        }
+        else if (!hasFind && hadFind) {
+            this.teardownFindUi();
+            this.unregisterFindCommand();
+        }
+    };
+    /** Removes the `layer` command when the layer toolbar button is removed at runtime. */
+    AcApSimpleUiChrome.prototype.unregisterLayerCommand = function () {
+        if (!this.commandManager)
+            return;
+        var group = AcEdCommandStack.SYSTEMT_COMMAND_GROUP_NAME;
+        var index = this.registeredCommands.findIndex(function (cmd) { return cmd.name === 'layer'; });
+        if (index === -1)
+            return;
+        this.commandManager.removeCmd(group, 'layer');
+        this.registeredCommands.splice(index, 1);
+    };
+    /** Registers the `layer` command when a layer button appears at runtime. */
+    AcApSimpleUiChrome.prototype.ensureLayerCommandRegistered = function () {
+        if (!this.commandManager)
+            return;
+        if (this.registeredCommands.some(function (cmd) { return cmd.name === 'layer'; }))
+            return;
+        this.registerLayerCommand(this.commandManager);
+    };
+    /** Removes the `markuppanel` command when the review toolbar button is removed. */
+    AcApSimpleUiChrome.prototype.unregisterMarkupPanelCommand = function () {
+        if (!this.commandManager)
+            return;
+        var group = AcEdCommandStack.SYSTEMT_COMMAND_GROUP_NAME;
+        var index = this.registeredCommands.findIndex(function (cmd) { return cmd.name === 'markuppanel'; });
+        if (index === -1)
+            return;
+        this.commandManager.removeCmd(group, 'markuppanel');
+        this.registeredCommands.splice(index, 1);
+    };
+    /** Registers the `markuppanel` command when a review button appears at runtime. */
+    AcApSimpleUiChrome.prototype.ensureMarkupPanelCommandRegistered = function () {
+        if (!this.commandManager)
+            return;
+        if (this.registeredCommands.some(function (cmd) { return cmd.name === 'markuppanel'; }))
+            return;
+        this.registerMarkupPanelCommand(this.commandManager);
+    };
+    /** Removes the `measurementpanel` command when the measurement panel button is removed. */
+    AcApSimpleUiChrome.prototype.unregisterMeasurementPanelCommand = function () {
+        if (!this.commandManager)
+            return;
+        var group = AcEdCommandStack.SYSTEMT_COMMAND_GROUP_NAME;
+        var index = this.registeredCommands.findIndex(function (cmd) { return cmd.name === 'measurementpanel'; });
+        if (index === -1)
+            return;
+        this.commandManager.removeCmd(group, 'measurementpanel');
+        this.registeredCommands.splice(index, 1);
+    };
+    /** Registers the `measurementpanel` command when a panel button appears at runtime. */
+    AcApSimpleUiChrome.prototype.ensureMeasurementPanelCommandRegistered = function () {
+        if (!this.commandManager)
+            return;
+        if (this.registeredCommands.some(function (cmd) { return cmd.name === 'measurementpanel'; })) {
+            return;
+        }
+        this.registerMeasurementPanelCommand(this.commandManager);
+    };
+    /** Removes the `find` command when the find toolbar button is removed. */
+    AcApSimpleUiChrome.prototype.unregisterFindCommand = function () {
+        if (!this.commandManager)
+            return;
+        var group = AcEdCommandStack.SYSTEMT_COMMAND_GROUP_NAME;
+        var index = this.registeredCommands.findIndex(function (cmd) { return cmd.name === 'find'; });
+        if (index === -1)
+            return;
+        this.commandManager.removeCmd(group, 'find');
+        this.registeredCommands.splice(index, 1);
+    };
+    /** Registers the `find` command when a find button appears at runtime. */
+    AcApSimpleUiChrome.prototype.ensureFindCommandRegistered = function () {
+        var _this = this;
+        if (!this.commandManager)
+            return;
+        if (this.registeredCommands.some(function (cmd) { return cmd.name === 'find'; }))
+            return;
+        var group = AcEdCommandStack.SYSTEMT_COMMAND_GROUP_NAME;
+        this.commandManager.addCommand(group, 'find', 'find', new AcApFindUiCmd({
+            prepare: function () {
+                _this.mountFindDockUi();
+                _this.tryUpgradeDockMountTarget();
+            },
+            toggle: function () {
+                var _a, _b;
+                (_a = _this.dockPanel) === null || _a === void 0 ? void 0 : _a.open(FIND_TAB_ID);
+                (_b = _this.findPaletteView) === null || _b === void 0 ? void 0 : _b.focus();
+            }
+        }));
+        this.registeredCommands.push({ group: group, name: 'find' });
+    };
+    /** Registers the `layer` command with dock preparation wired in. */
+    AcApSimpleUiChrome.prototype.registerLayerCommand = function (commandManager) {
+        if (this.registeredCommands.some(function (cmd) { return cmd.name === 'layer'; }))
+            return;
+        var group = AcEdCommandStack.SYSTEMT_COMMAND_GROUP_NAME;
+        commandManager.addCommand(group, 'layer', 'layer', this.createLayerCommand());
+        this.registeredCommands.push({ group: group, name: 'layer' });
+    };
+    /** Creates the `layer` command that prepares the dock panel before opening layers. */
+    AcApSimpleUiChrome.prototype.createLayerCommand = function () {
+        var _this = this;
+        return new AcApLayerUiCmd({
+            prepare: function () { return _this.prepareLayerDockForCommand(); },
+            toggle: function () { return _this.layerUiControllerHolder.toggleFromCommand(); }
+        });
+    };
+    /** Ensures the dock panel and layers tab exist for the `layer` command. */
+    AcApSimpleUiChrome.prototype.prepareLayerDockForCommand = function () {
+        this.mountLayerDockUi();
+        this.tryUpgradeDockMountTarget();
+    };
+    /** Registers the `markuppanel` command with dock preparation wired in. */
+    AcApSimpleUiChrome.prototype.registerMarkupPanelCommand = function (commandManager) {
+        if (this.registeredCommands.some(function (cmd) { return cmd.name === 'markuppanel'; }))
+            return;
+        var group = AcEdCommandStack.SYSTEMT_COMMAND_GROUP_NAME;
+        commandManager.addCommand(group, 'markuppanel', 'markuppanel', this.createMarkupPanelCommand());
+        this.registeredCommands.push({ group: group, name: 'markuppanel' });
+    };
+    /** Creates the `markuppanel` command that prepares the dock panel before opening review. */
+    AcApSimpleUiChrome.prototype.createMarkupPanelCommand = function () {
+        var _this = this;
+        return new AcApMarkupPanelUiCmd({
+            prepare: function () { return _this.prepareReviewDockForCommand(); },
+            toggle: function () { var _a; return (_a = _this.dockPanel) === null || _a === void 0 ? void 0 : _a.open(REVIEW_TAB_ID); }
+        });
+    };
+    /** Ensures the dock panel and review tab exist for the `markuppanel` command. */
+    AcApSimpleUiChrome.prototype.prepareReviewDockForCommand = function () {
+        this.mountReviewDockUi();
+        this.tryUpgradeDockMountTarget();
+    };
+    /** Registers the `measurementpanel` command with dock preparation wired in. */
+    AcApSimpleUiChrome.prototype.registerMeasurementPanelCommand = function (commandManager) {
+        if (this.registeredCommands.some(function (cmd) { return cmd.name === 'measurementpanel'; })) {
+            return;
+        }
+        var group = AcEdCommandStack.SYSTEMT_COMMAND_GROUP_NAME;
+        commandManager.addCommand(group, 'measurementpanel', 'measurementpanel', this.createMeasurementPanelCommand());
+        this.registeredCommands.push({ group: group, name: 'measurementpanel' });
+    };
+    /** Creates the `measurementpanel` command that prepares the dock before opening. */
+    AcApSimpleUiChrome.prototype.createMeasurementPanelCommand = function () {
+        var _this = this;
+        return new AcApMeasurementPanelUiCmd({
+            prepare: function () { return _this.prepareMeasurementDockForCommand(); },
+            toggle: function () { var _a; return (_a = _this.dockPanel) === null || _a === void 0 ? void 0 : _a.open(MEASUREMENTS_TAB_ID); }
+        });
+    };
+    /** Ensures the dock panel and measurements tab exist for the command. */
+    AcApSimpleUiChrome.prototype.prepareMeasurementDockForCommand = function () {
+        this.mountMeasurementDockUi();
+        this.tryUpgradeDockMountTarget();
+    };
+    /** Ensures the dock panel exists, tabs are mounted, and mount target is current. */
+    AcApSimpleUiChrome.prototype.ensureDockReady = function () {
+        var _a;
+        if (!this.dockPanel) {
+            this.prepareDockPanel();
+            return;
+        }
+        if (this.hasLayerToolbarItem && !this.dockPanel.hasTab(LAYERS_TAB_ID)) {
+            this.mountLayerDockUi();
+        }
+        if (this.hasMarkupPanelToolbarItem &&
+            !this.dockPanel.hasTab(REVIEW_TAB_ID)) {
+            this.mountReviewDockUi();
+        }
+        if (this.hasMeasurementPanelToolbarItem &&
+            !this.dockPanel.hasTab(MEASUREMENTS_TAB_ID)) {
+            this.mountMeasurementDockUi();
+        }
+        if (this.hasFindToolbarItem && !this.dockPanel.hasTab(FIND_TAB_ID)) {
+            this.mountFindDockUi();
+        }
+        this.tryUpgradeDockMountTarget();
+        this.dockPanel.ensureMounted();
+        (_a = this.toolbar) === null || _a === void 0 ? void 0 : _a.syncInParentLayout();
+    };
+    /** Ensures the dock panel exists, is mounted on the current target, and has tabs when applicable. */
+    AcApSimpleUiChrome.prototype.prepareDockPanel = function () {
+        if (this.hasLayerToolbarItem) {
+            this.mountLayerDockUi();
+        }
+        if (this.hasMarkupPanelToolbarItem) {
+            this.mountReviewDockUi();
+        }
+        if (this.hasMeasurementPanelToolbarItem) {
+            this.mountMeasurementDockUi();
+        }
+        if (this.hasFindToolbarItem) {
+            this.mountFindDockUi();
+        }
+        if (!this.dockPanel) {
+            this.ensureDockPanel();
+        }
+        this.tryUpgradeDockMountTarget();
+    };
+    /** Closes open sub-toolbars when {@link AcUiSubToolbarOptions.replaceOnNested} is set. */
+    AcApSimpleUiChrome.prototype.dismissStripsForDockPanel = function () {
+        var _a;
+        if ((_a = this.toolbar) === null || _a === void 0 ? void 0 : _a.replaceOnNested) {
+            this.toolbar.dismissOpenChildren();
+        }
+    };
+    /** Closes the dock panel when {@link AcUiSubToolbarOptions.replaceOnNested} is set. */
+    AcApSimpleUiChrome.prototype.dismissDockForExclusiveChrome = function () {
+        var _a, _b;
+        if ((_a = this.toolbar) === null || _a === void 0 ? void 0 : _a.replaceOnNested) {
+            (_b = this.dockPanel) === null || _b === void 0 ? void 0 : _b.close();
+        }
+    };
+    /** Ensures the dock panel container exists. */
+    AcApSimpleUiChrome.prototype.ensureDockPanel = function () {
+        var _this = this;
+        var mountEl = this.getDockMountEl();
+        if (!mountEl || !this.i18n || !this.dockPanelDefaults) {
+            return;
+        }
+        if (this.dockPanel) {
+            return;
+        }
+        this.dockPanel = new AcUiDockPanel({
+            host: mountEl,
+            t: function (key) { return AcApI18n.t(key); },
+            defaultSide: this.dockPanelDefaults.defaultSide,
+            defaultOpen: this.dockPanelDefaults.defaultOpen,
+            defaultHeight: this.dockPanelDefaults.defaultHeight,
+            defaultWidth: this.dockPanelDefaults.defaultWidth,
+            onOpen: function () { return _this.dismissStripsForDockPanel(); }
+        });
+        this.syncToolbarMountAfterDockChange();
+    };
+    /** Resolves the dock mount element (lazy; canvas parent may appear after load). */
+    AcApSimpleUiChrome.prototype.getDockMountEl = function () {
+        if (!this.hostEl)
+            return undefined;
+        return acuiResolveDockMountTarget(this.hostEl, this.dockPanelMountTargetOption);
+    };
+    /**
+     * Moves the dock panel from a host fallback to the canvas parent once available.
+     */
+    AcApSimpleUiChrome.prototype.tryUpgradeDockMountTarget = function () {
+        if (this.dockPanelMountTargetOption || !this.hostEl || !this.dockPanel) {
+            return;
+        }
+        var preferred = acuiResolveDockMountTarget(this.hostEl);
+        var current = this.dockPanel.getMountHost();
+        if (current === preferred) {
+            return;
+        }
+        // Only upgrade from the host fallback to the canvas parent.
+        if (current !== this.hostEl || preferred === this.hostEl) {
+            return;
+        }
+        this.dockPanel.reparentTo(preferred);
+        this.refreshLayerDockController();
+        this.syncToolbarMountAfterDockChange();
+    };
+    /** Rebinds the layer dock controller after the dock panel moves. */
+    AcApSimpleUiChrome.prototype.refreshLayerDockController = function () {
+        var _a, _b;
+        if (!((_a = this.dockPanel) === null || _a === void 0 ? void 0 : _a.hasTab(LAYERS_TAB_ID))) {
+            return;
+        }
+        (_b = this.layerDockController) === null || _b === void 0 ? void 0 : _b.destroy();
+        this.layerDockController = new AcUiLayerDockController(this.dockPanel, LAYERS_TAB_ID);
+        this.layerUiControllerHolder.current = this.layerDockController;
+    };
+    /** Mounts the layer list in the dock panel layers tab. */
+    AcApSimpleUiChrome.prototype.mountLayerDockUi = function () {
+        if (!this.hostEl || !this.i18n)
+            return;
+        this.ensureDockPanel();
+        if (!this.dockPanel)
+            return;
+        if (this.dockPanel.hasTab(LAYERS_TAB_ID)) {
+            this.refreshLayerDockController();
+            return;
+        }
+        this.layerListView = new AcUiLayerListView({
+            editor: AcApDocManager.instance,
+            i18n: this.i18n,
+            host: this.hostEl,
+            showHeader: false
+        });
+        var added = this.dockPanel.addTab({
+            id: LAYERS_TAB_ID,
+            labelKey: 'main.dockPanel.tab.layers',
+            content: this.layerListView.element
+        });
+        if (!added) {
+            this.layerListView.destroy();
+            this.layerListView = undefined;
+            return;
+        }
+        this.layerDockController = new AcUiLayerDockController(this.dockPanel, LAYERS_TAB_ID);
+        this.layerUiControllerHolder.current = this.layerDockController;
+    };
+    /** Tears down active layer UI without removing the dock shell when other tabs remain. */
+    AcApSimpleUiChrome.prototype.teardownLayerUi = function () {
+        var _a, _b, _c;
+        (_a = this.dockPanel) === null || _a === void 0 ? void 0 : _a.removeTab(LAYERS_TAB_ID);
+        (_b = this.layerListView) === null || _b === void 0 ? void 0 : _b.destroy();
+        this.layerListView = undefined;
+        (_c = this.layerDockController) === null || _c === void 0 ? void 0 : _c.destroy();
+        this.layerDockController = undefined;
+        this.layerUiControllerHolder.current = undefined;
+        this.destroyDockIfUnused();
+    };
+    /** Mounts the review palette in the dock panel review tab. */
+    AcApSimpleUiChrome.prototype.mountReviewDockUi = function () {
+        if (!this.hostEl || !this.i18n)
+            return;
+        this.ensureDockPanel();
+        if (!this.dockPanel)
+            return;
+        if (this.dockPanel.hasTab(REVIEW_TAB_ID)) {
+            return;
+        }
+        this.reviewPaletteView = new AcUiReviewPaletteView({
+            editor: AcApDocManager.instance,
+            i18n: this.i18n
+        });
+        var added = this.dockPanel.addTab({
+            id: REVIEW_TAB_ID,
+            labelKey: 'main.dockPanel.tab.review',
+            content: this.reviewPaletteView.element
+        });
+        if (!added) {
+            this.reviewPaletteView.destroy();
+            this.reviewPaletteView = undefined;
+        }
+    };
+    /** Tears down review UI without removing the dock shell when other tabs remain. */
+    AcApSimpleUiChrome.prototype.teardownReviewUi = function () {
+        var _a, _b;
+        (_a = this.dockPanel) === null || _a === void 0 ? void 0 : _a.removeTab(REVIEW_TAB_ID);
+        (_b = this.reviewPaletteView) === null || _b === void 0 ? void 0 : _b.destroy();
+        this.reviewPaletteView = undefined;
+        this.destroyDockIfUnused();
+    };
+    /** Mounts the measurement list in the dock panel measurements tab. */
+    AcApSimpleUiChrome.prototype.mountMeasurementDockUi = function () {
+        if (!this.hostEl || !this.i18n)
+            return;
+        this.ensureDockPanel();
+        if (!this.dockPanel)
+            return;
+        if (this.dockPanel.hasTab(MEASUREMENTS_TAB_ID)) {
+            return;
+        }
+        this.measurementPaletteView = new AcUiMeasurementPaletteView({
+            editor: AcApDocManager.instance,
+            i18n: this.i18n
+        });
+        var added = this.dockPanel.addTab({
+            id: MEASUREMENTS_TAB_ID,
+            labelKey: 'main.dockPanel.tab.measurements',
+            content: this.measurementPaletteView.element
+        });
+        if (!added) {
+            this.measurementPaletteView.destroy();
+            this.measurementPaletteView = undefined;
+        }
+    };
+    /** Tears down measurement UI without removing the dock shell when other tabs remain. */
+    AcApSimpleUiChrome.prototype.teardownMeasurementUi = function () {
+        var _a, _b;
+        (_a = this.dockPanel) === null || _a === void 0 ? void 0 : _a.removeTab(MEASUREMENTS_TAB_ID);
+        (_b = this.measurementPaletteView) === null || _b === void 0 ? void 0 : _b.destroy();
+        this.measurementPaletteView = undefined;
+        this.destroyDockIfUnused();
+    };
+    /** Mounts the text search view in the dock panel find tab. */
+    AcApSimpleUiChrome.prototype.mountFindDockUi = function () {
+        if (!this.hostEl || !this.i18n)
+            return;
+        this.ensureDockPanel();
+        if (!this.dockPanel)
+            return;
+        if (this.dockPanel.hasTab(FIND_TAB_ID)) {
+            return;
+        }
+        this.findPaletteView = new AcUiFindPaletteView({
+            editor: AcApDocManager.instance,
+            i18n: this.i18n
+        });
+        var added = this.dockPanel.addTab({
+            id: FIND_TAB_ID,
+            labelKey: 'main.dockPanel.tab.find',
+            content: this.findPaletteView.element
+        });
+        if (!added) {
+            this.findPaletteView.destroy();
+            this.findPaletteView = undefined;
+        }
+    };
+    /** Tears down find UI without removing the dock shell when other tabs remain. */
+    AcApSimpleUiChrome.prototype.teardownFindUi = function () {
+        var _a, _b;
+        (_a = this.dockPanel) === null || _a === void 0 ? void 0 : _a.removeTab(FIND_TAB_ID);
+        (_b = this.findPaletteView) === null || _b === void 0 ? void 0 : _b.destroy();
+        this.findPaletteView = undefined;
+        this.destroyDockIfUnused();
+    };
+    /** Closes and optionally destroys the dock panel when it has no remaining tabs. */
+    AcApSimpleUiChrome.prototype.destroyDockIfUnused = function () {
+        if (!this.dockPanel)
+            return;
+        if (this.dockPanel.hasTabs)
+            return;
+        this.dockPanel.close();
+        if (this.dockPanelExplicitlyEnabled)
+            return;
+        this.dockPanel.destroy();
+        this.dockPanel = undefined;
+        this.syncToolbarMountAfterDockChange();
+    };
+    /**
+     * Re-resolves the toolbar mount after dock wrap/unwrap, which can detach a
+     * stale `dock-main` host or change `canvas.parentElement`.
+     */
+    AcApSimpleUiChrome.prototype.syncToolbarMountAfterDockChange = function () {
+        if (!this.toolbar || !this.hostEl)
+            return;
+        var preferred = this.getToolbarMountEl();
+        if (!preferred)
+            return;
+        if (preferred !== this.toolbarMountEl || !this.toolbar.isRootConnected()) {
+            this.toolbar.reparentTo(preferred);
+            this.toolbarMountEl = preferred;
+        }
+        this.toolbar.syncInParentLayout();
+    };
+    /** Updates toolbar placement. */
+    AcApSimpleUiChrome.prototype.applyToolbarPlacement = function (placement) {
+        var _a;
+        this.toolbarPlacement = placement;
+        (_a = this.toolbar) === null || _a === void 0 ? void 0 : _a.setPlacement(placement);
+    };
+    /**
+     * Tears down UI, unregisters commands, and removes injected styles if unused.
+     *
+     * @param commandManager - Command stack used to remove registered commands.
+     */
+    AcApSimpleUiChrome.prototype.dispose = function (commandManager) {
+        var e_1, _a;
+        var _b, _c, _d, _e, _f;
+        var stack = commandManager !== null && commandManager !== void 0 ? commandManager : this.commandManager;
+        AcApPaletteService.setHost(undefined);
+        (_b = this.unsubscribeLayout) === null || _b === void 0 ? void 0 : _b.call(this);
+        this.unsubscribeLayout = undefined;
+        AcApI18n.events.localeChanged.removeEventListener(this.handleLocaleChanged);
+        AcApDocManager.instance.events.documentActivated.removeEventListener(this.handleDocumentActivatedForDock);
+        if (stack) {
+            try {
+                for (var _g = __values(this.registeredCommands), _h = _g.next(); !_h.done; _h = _g.next()) {
+                    var cmd = _h.value;
+                    stack.removeCmd(cmd.group, cmd.name);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_h && !_h.done && (_a = _g.return)) _a.call(_g);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+        this.registeredCommands = [];
+        this.teardownLayerUi();
+        this.teardownReviewUi();
+        this.teardownMeasurementUi();
+        this.teardownFindUi();
+        (_c = this.toolbarDocUnbind) === null || _c === void 0 ? void 0 : _c.call(this);
+        this.toolbarDocUnbind = undefined;
+        (_d = this.toolbar) === null || _d === void 0 ? void 0 : _d.destroy();
+        (_e = this.dockPanel) === null || _e === void 0 ? void 0 : _e.destroy();
+        this.toolbar = undefined;
+        this.toolbarMountEl = undefined;
+        this.toolbarMountTargetOption = undefined;
+        this.dockPanel = undefined;
+        this.hostEl = undefined;
+        this.dockPanelMountTargetOption = undefined;
+        this.baseToolbarItems = [];
+        this.toolbarItemsInput = 'default';
+        this.toolbarItemsOverridden = false;
+        this.toolbarLayoutSwitcher = undefined;
+        this.hasLayerToolbarItem = false;
+        this.hasMarkupPanelToolbarItem = false;
+        this.hasMeasurementPanelToolbarItem = false;
+        this.hasFindToolbarItem = false;
+        this.commandManager = undefined;
+        this.i18n = undefined;
+        (_f = this.themeSync) === null || _f === void 0 ? void 0 : _f.stop();
+        this.themeSync = undefined;
+        AcApSettingManager.instance.clearSessionOverride('isShowRibbon');
+        acuiRemoveUiStylesIfUnused();
+    };
+    /** Sets {@link AcApI18n.currentLocale} to one of the supported locales. */
+    AcApSimpleUiChrome.prototype.setLocale = function (locale) {
+        AcApI18n.setCurrentLocale(locale);
+    };
+    return AcApSimpleUiChrome;
+}());
+export { AcApSimpleUiChrome };
+//# sourceMappingURL=AcApSimpleUiChrome.js.map