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

package/dist/cad-simple-viewer-AcApSimpleUiChrome-D_0b6okm.js

@@ -0,0 +1,890 @@
+import { AcEdCommand as T, eventBus as y, ACAP_PALETTE_NAMED_TAB as k, acuiPrependToolbarLayoutSwitcher as C, acuiRegisterSimpleUiI18n as L, AcApSettingManager as M, acuiNormalizeSimpleUiOptions as U, AcApDocManager as l, AcUiThemeSync as S, AcApPaletteService as w, AcUiI18n as E, AcUiToolbar as O, acapBindToolbarDocState as A, acuiResolveDockMountTarget as g, acuiResolveToolbarMountTarget as R, acuiMergeToolbarOptionsForLayout as F, acuiResolveToolbarItems as v, acuiToolbarItemsIncludeItem as P, AcEdCommandStack as h, AcUiDockPanel as V, AcUiLayerListView as _, AcUiReviewPaletteView as x, AcUiMeasurementPaletteView as B, AcUiFindPaletteView as N, acuiRemoveUiStylesIfUnused as H } from "./cad-simple-viewer.js";
+import { b as f, n as K, x as D } from "./cad-simple-viewer-AcUiFileOpenSession-Bo3U3wCu.js";
+class z extends T {
+  /**
+   * @param actions - Prepare and open callbacks wired by the plugin.
+   */
+  constructor(e) {
+    super(), this.actions = e;
+  }
+  /**
+   * Ensures the dock panel is ready, then opens the find tab.
+   *
+   * @param _context - Application context (unused).
+   */
+  async execute(e) {
+    this.actions.prepare(), this.actions.toggle();
+  }
+}
+class I {
+  /**
+   * @param dockPanel - Dock panel hosting the layers tab.
+   * @param layersTabId - Tab id registered for the layer list.
+   */
+  constructor(e, t = "layers") {
+    this.dockPanel = e, this.layersTabId = t, this.handleCloseLayerManager = () => {
+      this.hide();
+    }, y.on("close-layer-manager", this.handleCloseLayerManager);
+  }
+  /** Opens the dock panel and activates the layers tab. */
+  toggleFromCommand() {
+    this.dockPanel.hasTab(this.layersTabId) && this.dockPanel.open(this.layersTabId);
+  }
+  /** Closes the dock panel. */
+  hide() {
+    this.dockPanel.close();
+  }
+  /** Refreshes dock panel locale (including tab labels). */
+  refreshLocale() {
+    this.dockPanel.refreshLocale();
+  }
+  /** Removes event listeners. */
+  destroy() {
+    y.off("close-layer-manager", this.handleCloseLayerManager);
+  }
+}
+class G {
+  toggleFromCommand() {
+    var e;
+    (e = this.current) == null || e.toggleFromCommand();
+  }
+  hide() {
+    var e;
+    (e = this.current) == null || e.hide();
+  }
+  refreshLocale() {
+    var e;
+    (e = this.current) == null || e.refreshLocale();
+  }
+}
+class Y extends T {
+  /**
+   * @param actions - Prepare and toggle callbacks wired by the plugin.
+   */
+  constructor(e) {
+    super(), this.actions = e;
+  }
+  /**
+   * Ensures the dock panel is ready, then opens or focuses the layers tab.
+   *
+   * @param _context - Application context (unused).
+   */
+  async execute(e) {
+    this.actions.prepare(), this.actions.toggle();
+  }
+}
+class W extends T {
+  /**
+   * @param actions - Prepare and open callbacks wired by the plugin.
+   */
+  constructor(e) {
+    super(), this.actions = e;
+  }
+  /**
+   * Ensures the dock panel is ready, then opens or focuses the review tab.
+   *
+   * @param _context - Application context (unused).
+   */
+  async execute(e) {
+    this.actions.prepare(), this.actions.toggle();
+  }
+}
+class $ extends T {
+  /**
+   * @param actions - Prepare and open callbacks wired by the plugin.
+   */
+  constructor(e) {
+    super(), this.actions = e;
+  }
+  /**
+   * Ensures the dock panel is ready, then opens or focuses the measurements tab.
+   *
+   * @param _context - Application context (unused).
+   */
+  async execute(e) {
+    this.actions.prepare(), this.actions.toggle();
+  }
+}
+const d = "layers", c = "review", u = "measurements", m = "find";
+class J {
+  /**
+   * @param options - Toolbar, layer manager, dock panel, and host configuration.
+   */
+  constructor(e = {}) {
+    this.options = e, this.layerUiControllerHolder = new G(), this.baseToolbarItems = [], this.toolbarItemsInput = "default", this.toolbarItemsOverridden = !1, this.hasLayerToolbarItem = !1, this.hasMarkupPanelToolbarItem = !1, this.hasMeasurementPanelToolbarItem = !1, this.hasFindToolbarItem = !1, this.dockPanelExplicitlyEnabled = !1, this.toolbarPlacement = "right", this.toolbarCollapsible = !1, this.toolbarEdgeOffset = 8, this.toolbarSideOffset = 0, this.toolbarInCanvasParent = !1, this.toolbarShowLabels = !1, this.toolbarShowChildrenIndicator = !0, this.toolbarShowBorder = !0, this.toolbarShowButtonBorder = !1, this.toolbarShowSeparators = !0, this.toolbarSize = "auto", this.toolbarOverflow = "menu", this.layoutMode = "auto", this.activeLayoutKind = "desktop", this.registeredCommands = [], this.handleLocaleChanged = () => {
+      var t, o, a, r, s, i;
+      this.rebuildToolbarItems(this.activeLayoutKind), (t = this.toolbar) == null || t.setSelectedChild("locale", `locale-${f.currentLocale}`), (o = this.layerListView) == null || o.refreshLocale(), (a = this.reviewPaletteView) == null || a.refreshLocale(), (r = this.measurementPaletteView) == null || r.refreshLocale(), (s = this.findPaletteView) == null || s.refreshLocale(), (i = this.dockPanel) == null || i.refreshLocale(), this.toolbar && (this.toolbar.updateItems(this.baseToolbarItems), this.toolbar.refreshLocale());
+    }, this.handleDocumentActivatedForDock = () => {
+      var t, o;
+      this.hasLayerToolbarItem && this.mountLayerDockUi(), this.hasMarkupPanelToolbarItem && this.mountReviewDockUi(), this.hasMeasurementPanelToolbarItem && this.mountMeasurementDockUi(), this.hasFindToolbarItem && this.mountFindDockUi(), this.tryUpgradeDockMountTarget(), (t = this.dockPanel) == null || t.ensureMounted(), this.ensureViewerToolbar(), this.tryUpgradeToolbarMountTarget(), (o = this.toolbar) == null || o.syncInParentLayout();
+    }, this.paletteHost = {
+      show: (t, o) => {
+        this.ensureDockReady();
+        const a = this.dockPanel;
+        if (!a) return;
+        const r = `hosted-${t.id}`, s = a.isOpen, i = a.activeTab;
+        if (a.removeTab(r), !a.addTab({
+          id: r,
+          label: t.title,
+          content: t.element
+        }))
+          return;
+        a.open(r);
+        const n = a.addCloseListener(o);
+        return {
+          close: () => {
+            n(), a.removeTab(r), s ? i && i !== r && a.open(i) : a.close();
+          }
+        };
+      },
+      openNamedTab: (t) => {
+        var o, a, r, s, i, n, p;
+        switch (t) {
+          case k.layers:
+            return this.prepareLayerDockForCommand(), this.layerUiControllerHolder.toggleFromCommand(), ((o = this.dockPanel) == null ? void 0 : o.hasTab(d)) ?? !1;
+          case k.review:
+            return this.prepareReviewDockForCommand(), (a = this.dockPanel) == null || a.open(c), ((r = this.dockPanel) == null ? void 0 : r.hasTab(c)) ?? !1;
+          case k.measurements:
+            return this.prepareMeasurementDockForCommand(), (s = this.dockPanel) == null || s.open(u), ((i = this.dockPanel) == null ? void 0 : i.hasTab(u)) ?? !1;
+          case k.find:
+            return this.mountFindDockUi(), this.tryUpgradeDockMountTarget(), (n = this.dockPanel) != null && n.hasTab(m) ? (this.dockPanel.open(m), (p = this.findPaletteView) == null || p.focus(), !0) : !1;
+          default:
+            return !1;
+        }
+      }
+    };
+  }
+  /**
+   * 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.
+   */
+  addDockPanelTab(e) {
+    return !e.labelKey && !e.label || (this.ensureDockReady(), !this.dockPanel) || !this.dockPanel.addTab(e) ? !1 : (this.dockPanel.open(e.id), !0);
+  }
+  /** Whether the dock panel is open. */
+  isDockPanelOpen() {
+    var e;
+    return ((e = this.dockPanel) == null ? void 0 : e.isOpen) ?? !1;
+  }
+  /** Whether a dock panel tab with the given id is registered. */
+  hasDockPanelTab(e) {
+    var t;
+    return ((t = this.dockPanel) == null ? void 0 : t.hasTab(e)) ?? !1;
+  }
+  /**
+   * 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.
+   */
+  toggleDockPanelTab(e) {
+    var t;
+    return !((t = this.dockPanel) != null && t.hasTab(e)) || (this.ensureDockReady(), !this.dockPanel) ? !1 : (this.dockPanel.toggle(e), !0);
+  }
+  /**
+   * Opens or closes the dock panel.
+   *
+   * @param open - Target open state.
+   * @returns `true` when applied; `false` when the dock panel is unavailable.
+   */
+  setDockPanelOpen(e) {
+    return e ? (this.ensureDockReady(), this.dockPanel ? (this.dockPanel.open(), !0) : (console.warn(
+      "[SimpleUiChrome] setDockPanelOpen skipped: dock panel is unavailable."
+    ), !1)) : (this.dockPanel && this.dockPanel.close(), !0);
+  }
+  /** Returns the dock panel side, if the dock panel exists. */
+  getDockPanelSide() {
+    var e;
+    return (e = this.dockPanel) == null ? void 0 : e.getSide();
+  }
+  /** Returns the dock panel size in px, if the dock panel exists. */
+  getDockPanelSize() {
+    var e;
+    return (e = this.dockPanel) == null ? void 0 : e.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.
+   */
+  setDockPanelSize(e) {
+    return this.ensureDockReady(), this.dockPanel ? (this.dockPanel.setPanelSize(e), !0) : (console.warn(
+      "[SimpleUiChrome] setDockPanelSize skipped: dock panel is unavailable."
+    ), !1);
+  }
+  /** Returns the toolbar item configuration last passed to {@link setToolbarItems}. */
+  getToolbarItems() {
+    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`.
+   */
+  setToolbarItems(e, t) {
+    if (!this.toolbar) return;
+    this.toolbarItemsOverridden = !0, this.toolbarLayoutSwitcher = t, this.toolbarItemsInput = e;
+    const o = this.resolveBaseToolbarItems(e);
+    this.baseToolbarItems = t ? C(o, t) : o, this.syncLayerToolbarItem(), this.syncReviewToolbarItem(), this.syncMeasurementToolbarItem(), this.syncFindToolbarItem(), this.renderToolbarItems();
+  }
+  /** Returns the viewer toolbar edge placement. */
+  getToolbarPlacement() {
+    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.
+   */
+  setToolbarPlacement(e) {
+    return this.toolbar ? (this.applyToolbarPlacement(e), !0) : (console.warn(
+      "[SimpleUiChrome] setToolbarPlacement skipped: toolbar is unavailable."
+    ), !1);
+  }
+  /** Whether the viewer toolbar is visible. */
+  isToolbarVisible() {
+    var e;
+    return ((e = this.toolbar) == null ? void 0 : e.isVisible) ?? !1;
+  }
+  /**
+   * Shows or hides the viewer toolbar.
+   *
+   * @param visible - Target visibility.
+   * @returns `true` when applied; `false` when the toolbar is unavailable.
+   */
+  setToolbarVisible(e) {
+    var t;
+    return this.toolbar ? (this.toolbar.setVisible(e), e || (t = this.dockPanel) == null || t.close(), !0) : (console.warn(
+      "[SimpleUiChrome] setToolbarVisible skipped: toolbar is unavailable."
+    ), !1);
+  }
+  /** Whether the viewer toolbar is collapsed to its toggle button. */
+  isToolbarCollapsed() {
+    var e;
+    return ((e = this.toolbar) == null ? void 0 : e.isCollapsed) ?? !1;
+  }
+  /**
+   * 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.
+   */
+  setToolbarCollapsed(e) {
+    return this.toolbar ? this.toolbarCollapsible ? (this.toolbar.setCollapsed(e), !0) : (console.warn(
+      "[SimpleUiChrome] setToolbarCollapsed skipped: toolbar is not collapsible."
+    ), !1) : (console.warn(
+      "[SimpleUiChrome] setToolbarCollapsed skipped: toolbar is unavailable."
+    ), !1);
+  }
+  /** Returns the viewer toolbar inset from the canvas edge in px. */
+  getToolbarEdgeOffset() {
+    var e;
+    return ((e = this.toolbar) == null ? void 0 : e.getEdgeOffset()) ?? this.toolbarEdgeOffset;
+  }
+  /** Returns the active UI layout kind (`phone`, `pad`, or `desktop`). */
+  getLayout() {
+    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).
+   */
+  setLayout(e) {
+    var t;
+    return !this.toolbar && e !== this.layoutMode ? (this.layoutMode = e, !0) : this.toolbar ? (this.layoutMode = e, (t = this.unsubscribeLayout) == null || t.call(this), this.unsubscribeLayout = void 0, e === "auto" ? (this.unsubscribeLayout = K((o) => {
+      o !== this.activeLayoutKind && this.applyLayoutKind(o);
+    }), this.applyLayoutKind(D())) : this.applyLayoutKind(e), !0) : !1;
+  }
+  /**
+   * 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.
+   */
+  setToolbarEdgeOffset(e) {
+    return this.toolbar ? (this.toolbarEdgeOffset = Math.max(0, e), this.toolbar.setEdgeOffset(this.toolbarEdgeOffset), !0) : (console.warn(
+      "[SimpleUiChrome] setToolbarEdgeOffset skipped: toolbar is unavailable."
+    ), !1);
+  }
+  /**
+   * Creates UI components, registers commands, and starts theme sync.
+   *
+   * @param commandManager - Command stack used to register UI commands.
+   */
+  start(e) {
+    var s, i, n;
+    L(), this.commandManager = e, M.instance.set("isShowRibbon", !1, { persist: !1 });
+    const t = U(this.options), o = t.host ?? ((s = l.instance.curView) == null ? void 0 : s.container) ?? document.body;
+    this.hostEl = o, this.dockPanelMountTargetOption = (i = this.options.dockPanel) == null ? void 0 : i.mountTarget, this.toolbarMountTargetOption = (n = this.options.toolbar) == null ? void 0 : n.mountTarget, this.layoutMode = t.layout, this.dockPanelExplicitlyEnabled = t.dockPanel.enabled === !0, this.dockPanelDefaults = {
+      defaultOpen: t.dockPanel.defaultOpen ?? !1,
+      defaultSide: t.dockPanel.defaultSide ?? "left",
+      defaultHeight: t.dockPanel.defaultHeight ?? 240,
+      defaultWidth: t.dockPanel.defaultWidth ?? 280
+    }, this.themeSync = new S(o, () => {
+      var p;
+      return (p = this.toolbar) == null ? void 0 : p.refresh();
+    }), this.themeSync.start(), w.setHost(this.paletteHost), this.i18n = new E(), f.events.localeChanged.addEventListener(this.handleLocaleChanged), l.instance.events.documentActivated.addEventListener(
+      this.handleDocumentActivatedForDock
+    );
+    const a = this.layoutMode === "auto" ? D() : this.layoutMode, r = this.isViewerToolbarEnabled();
+    this.applyLayoutKind(a, { skipToolbarApply: !r }), t.shouldCreateDockPanel && this.ensureDockPanel(), this.hasLayerToolbarItem && (this.mountLayerDockUi(), this.ensureLayerCommandRegistered()), this.hasMarkupPanelToolbarItem && (this.mountReviewDockUi(), this.ensureMarkupPanelCommandRegistered()), this.hasMeasurementPanelToolbarItem && (this.mountMeasurementDockUi(), this.ensureMeasurementPanelCommandRegistered()), this.hasFindToolbarItem && (this.mountFindDockUi(), this.ensureFindCommandRegistered()), this.ensureViewerToolbar(o);
+  }
+  /** Whether viewer toolbar creation is allowed (only explicit `false` disables). */
+  isViewerToolbarEnabled() {
+    var e;
+    return ((e = this.options.toolbar) == null ? void 0 : e.enabled) !== !1;
+  }
+  /**
+   * Creates the floating toolbar when enabled and not already present.
+   *
+   * @param host - Plugin theme host; defaults to {@link hostEl}.
+   */
+  ensureViewerToolbar(e) {
+    var r;
+    if (!this.isViewerToolbarEnabled())
+      return;
+    if (this.toolbar) {
+      if (this.toolbar.isRootConnected())
+        return;
+      (r = this.toolbarDocUnbind) == null || r.call(this), this.toolbarDocUnbind = void 0, this.toolbar.destroy(), this.toolbar = void 0, this.toolbarMountEl = void 0;
+    }
+    const t = e ?? this.hostEl;
+    if (!t || !this.i18n)
+      return;
+    const o = this.getToolbarMountEl() ?? t;
+    this.toolbarMountEl = o;
+    const a = this.getMergedToolbarOptions(this.activeLayoutKind);
+    try {
+      this.toolbar = new O({
+        host: o,
+        themeHost: t,
+        placement: this.toolbarPlacement,
+        edgeOffset: this.toolbarEdgeOffset,
+        sideOffset: this.toolbarSideOffset,
+        items: this.baseToolbarItems,
+        i18n: this.i18n,
+        collapsible: this.toolbarCollapsible,
+        defaultCollapsed: a.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: () => {
+          var s;
+          (s = this.dockPanel) == null || s.close();
+        },
+        onExclusiveOpen: () => this.dismissDockForExclusiveChrome(),
+        onCommand: (s) => {
+          l.instance.sendStringToExecute(s);
+        }
+      }), this.toolbarDocUnbind = A(this.toolbar);
+    } catch (s) {
+      console.error("[SimpleUiChrome] Failed to create viewer toolbar:", s);
+      return;
+    }
+    try {
+      this.setLayout(this.layoutMode);
+    } catch (s) {
+      console.warn("[SimpleUiChrome] setLayout failed during toolbar setup:", s);
+    }
+  }
+  /** Resolves the canvas element that receives the viewer toolbar. */
+  getToolbarMountEl() {
+    if (this.hostEl)
+      return this.toolbarInCanvasParent ? g(
+        this.hostEl,
+        this.toolbarMountTargetOption
+      ) : R(
+        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.
+   */
+  tryUpgradeToolbarMountTarget() {
+    var a;
+    if (this.toolbarMountTargetOption || !this.hostEl || !this.toolbar)
+      return;
+    const e = this.getToolbarMountEl();
+    if (!e || e === this.toolbarMountEl)
+      return;
+    const t = (a = l.instance.curView) == null ? void 0 : a.container, o = t == null ? void 0 : t.parentElement;
+    this.toolbarMountEl !== this.hostEl && this.toolbarMountEl !== t && this.toolbarMountEl !== o || (this.toolbar.reparentTo(e), this.toolbarMountEl = e, 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}.
+   */
+  getMergedToolbarOptions(e) {
+    var t, o;
+    return F(
+      e,
+      this.options.toolbar,
+      (o = (t = this.options.layouts) == null ? void 0 : t[e]) == null ? void 0 : o.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.
+   */
+  applyLayoutKind(e, t) {
+    this.activeLayoutKind = e;
+    const o = this.getMergedToolbarOptions(e);
+    this.toolbarPlacement = o.placement ?? "right", this.toolbarCollapsible = o.collapsible ?? !1, this.toolbarEdgeOffset = o.edgeOffset ?? 8, this.toolbarSideOffset = o.sideOffset ?? 0, this.toolbarShowLabels = o.showLabels ?? !1, this.toolbarShowChildrenIndicator = o.showChildrenIndicator ?? !0, this.toolbarShowBorder = o.showBorder ?? !0, this.toolbarShowButtonBorder = o.showButtonBorder ?? !1, this.toolbarShowSeparators = o.showSeparators ?? !0, this.toolbarSize = o.size ?? "auto", this.toolbarOverflow = o.overflow ?? "menu", this.toolbarSubToolbar = o.subToolbar;
+    const a = o.inCanvasParent === !0, r = a !== this.toolbarInCanvasParent;
+    if (this.toolbarInCanvasParent = a, this.rebuildToolbarItems(e, o), this.syncLayerToolbarItem(), this.syncReviewToolbarItem(), this.syncMeasurementToolbarItem(), this.syncFindToolbarItem(), !(t != null && t.skipToolbarApply || !this.toolbar)) {
+      if (this.toolbar.applyViewOptions({
+        placement: this.toolbarPlacement,
+        edgeOffset: this.toolbarEdgeOffset,
+        sideOffset: this.toolbarSideOffset,
+        collapsible: this.toolbarCollapsible,
+        defaultCollapsed: o.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
+      }), r || !this.toolbar.isRootConnected()) {
+        const s = this.getToolbarMountEl();
+        s && (this.toolbar.reparentTo(s), this.toolbarMountEl = s);
+      }
+      this.toolbar.syncInParentLayout();
+    }
+  }
+  /** Context passed when resolving default toolbar presets. */
+  getToolbarContext() {
+    return {
+      getTheme: () => {
+        var e;
+        return ((e = this.themeSync) == null ? void 0 : e.getTheme()) ?? "dark";
+      },
+      setTheme: (e) => {
+        var t;
+        return (t = this.themeSync) == null ? void 0 : t.setTheme(e);
+      },
+      getLocale: () => f.currentLocale,
+      setLocale: (e) => this.setLocale(e),
+      getPlacement: () => this.toolbarPlacement,
+      setPlacement: (e) => {
+        this.applyToolbarPlacement(e);
+      }
+    };
+  }
+  /**
+   * 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.
+   */
+  rebuildToolbarItems(e, t) {
+    if (this.toolbarItemsOverridden) {
+      const a = this.resolveBaseToolbarItems(this.toolbarItemsInput);
+      this.baseToolbarItems = this.toolbarLayoutSwitcher ? C(a, this.toolbarLayoutSwitcher) : a;
+      return;
+    }
+    const o = t ?? this.getMergedToolbarOptions(e);
+    this.toolbarItemsInput = o.items ?? "default", this.baseToolbarItems = v(
+      o,
+      this.getToolbarContext(),
+      e
+    );
+  }
+  /** Resolves raw toolbar input into concrete toolbar items. */
+  resolveBaseToolbarItems(e) {
+    return v(
+      {
+        items: e,
+        appendItems: void 0
+      },
+      this.getToolbarContext(),
+      this.activeLayoutKind
+    );
+  }
+  /** Applies {@link baseToolbarItems} to the toolbar. */
+  renderToolbarItems() {
+    var e;
+    (e = this.toolbar) == null || e.updateItems(this.baseToolbarItems);
+  }
+  /** Mounts or tears down layer UI when the layer toolbar button is added or removed. */
+  syncLayerToolbarItem() {
+    const e = this.hasLayerToolbarItem, t = P(this.baseToolbarItems, "layer");
+    this.hasLayerToolbarItem = t, t && !e ? (this.ensureLayerCommandRegistered(), this.mountLayerDockUi()) : !t && e && (this.teardownLayerUi(), this.unregisterLayerCommand());
+  }
+  /** Mounts or tears down review UI when the markup panel button is added or removed. */
+  syncReviewToolbarItem() {
+    const e = this.hasMarkupPanelToolbarItem, t = P(
+      this.baseToolbarItems,
+      "markup-panel"
+    );
+    this.hasMarkupPanelToolbarItem = t, t && !e ? (this.ensureMarkupPanelCommandRegistered(), this.mountReviewDockUi()) : !t && e && (this.teardownReviewUi(), this.unregisterMarkupPanelCommand());
+  }
+  /** Mounts or tears down measurement UI when the panel button is added or removed. */
+  syncMeasurementToolbarItem() {
+    const e = this.hasMeasurementPanelToolbarItem, t = P(
+      this.baseToolbarItems,
+      "measurement-panel"
+    );
+    this.hasMeasurementPanelToolbarItem = t, t && !e ? (this.ensureMeasurementPanelCommandRegistered(), this.mountMeasurementDockUi()) : !t && e && (this.teardownMeasurementUi(), this.unregisterMeasurementPanelCommand());
+  }
+  /** Mounts or tears down find UI when the find toolbar button is added or removed. */
+  syncFindToolbarItem() {
+    const e = this.hasFindToolbarItem, t = P(this.baseToolbarItems, "find");
+    this.hasFindToolbarItem = t, t && !e ? (this.ensureFindCommandRegistered(), this.mountFindDockUi()) : !t && e && (this.teardownFindUi(), this.unregisterFindCommand());
+  }
+  /** Removes the `layer` command when the layer toolbar button is removed at runtime. */
+  unregisterLayerCommand() {
+    if (!this.commandManager) return;
+    const e = h.SYSTEMT_COMMAND_GROUP_NAME, t = this.registeredCommands.findIndex((o) => o.name === "layer");
+    t !== -1 && (this.commandManager.removeCmd(e, "layer"), this.registeredCommands.splice(t, 1));
+  }
+  /** Registers the `layer` command when a layer button appears at runtime. */
+  ensureLayerCommandRegistered() {
+    this.commandManager && (this.registeredCommands.some((e) => e.name === "layer") || this.registerLayerCommand(this.commandManager));
+  }
+  /** Removes the `markuppanel` command when the review toolbar button is removed. */
+  unregisterMarkupPanelCommand() {
+    if (!this.commandManager) return;
+    const e = h.SYSTEMT_COMMAND_GROUP_NAME, t = this.registeredCommands.findIndex(
+      (o) => o.name === "markuppanel"
+    );
+    t !== -1 && (this.commandManager.removeCmd(e, "markuppanel"), this.registeredCommands.splice(t, 1));
+  }
+  /** Registers the `markuppanel` command when a review button appears at runtime. */
+  ensureMarkupPanelCommandRegistered() {
+    this.commandManager && (this.registeredCommands.some((e) => e.name === "markuppanel") || this.registerMarkupPanelCommand(this.commandManager));
+  }
+  /** Removes the `measurementpanel` command when the measurement panel button is removed. */
+  unregisterMeasurementPanelCommand() {
+    if (!this.commandManager) return;
+    const e = h.SYSTEMT_COMMAND_GROUP_NAME, t = this.registeredCommands.findIndex(
+      (o) => o.name === "measurementpanel"
+    );
+    t !== -1 && (this.commandManager.removeCmd(e, "measurementpanel"), this.registeredCommands.splice(t, 1));
+  }
+  /** Registers the `measurementpanel` command when a panel button appears at runtime. */
+  ensureMeasurementPanelCommandRegistered() {
+    this.commandManager && (this.registeredCommands.some((e) => e.name === "measurementpanel") || this.registerMeasurementPanelCommand(this.commandManager));
+  }
+  /** Removes the `find` command when the find toolbar button is removed. */
+  unregisterFindCommand() {
+    if (!this.commandManager) return;
+    const e = h.SYSTEMT_COMMAND_GROUP_NAME, t = this.registeredCommands.findIndex((o) => o.name === "find");
+    t !== -1 && (this.commandManager.removeCmd(e, "find"), this.registeredCommands.splice(t, 1));
+  }
+  /** Registers the `find` command when a find button appears at runtime. */
+  ensureFindCommandRegistered() {
+    if (!this.commandManager || this.registeredCommands.some((t) => t.name === "find")) return;
+    const e = h.SYSTEMT_COMMAND_GROUP_NAME;
+    this.commandManager.addCommand(
+      e,
+      "find",
+      "find",
+      new z({
+        prepare: () => {
+          this.mountFindDockUi(), this.tryUpgradeDockMountTarget();
+        },
+        toggle: () => {
+          var t, o;
+          (t = this.dockPanel) == null || t.open(m), (o = this.findPaletteView) == null || o.focus();
+        }
+      })
+    ), this.registeredCommands.push({ group: e, name: "find" });
+  }
+  /** Registers the `layer` command with dock preparation wired in. */
+  registerLayerCommand(e) {
+    if (this.registeredCommands.some((o) => o.name === "layer")) return;
+    const t = h.SYSTEMT_COMMAND_GROUP_NAME;
+    e.addCommand(
+      t,
+      "layer",
+      "layer",
+      this.createLayerCommand()
+    ), this.registeredCommands.push({ group: t, name: "layer" });
+  }
+  /** Creates the `layer` command that prepares the dock panel before opening layers. */
+  createLayerCommand() {
+    return new Y({
+      prepare: () => this.prepareLayerDockForCommand(),
+      toggle: () => this.layerUiControllerHolder.toggleFromCommand()
+    });
+  }
+  /** Ensures the dock panel and layers tab exist for the `layer` command. */
+  prepareLayerDockForCommand() {
+    this.mountLayerDockUi(), this.tryUpgradeDockMountTarget();
+  }
+  /** Registers the `markuppanel` command with dock preparation wired in. */
+  registerMarkupPanelCommand(e) {
+    if (this.registeredCommands.some((o) => o.name === "markuppanel")) return;
+    const t = h.SYSTEMT_COMMAND_GROUP_NAME;
+    e.addCommand(
+      t,
+      "markuppanel",
+      "markuppanel",
+      this.createMarkupPanelCommand()
+    ), this.registeredCommands.push({ group: t, name: "markuppanel" });
+  }
+  /** Creates the `markuppanel` command that prepares the dock panel before opening review. */
+  createMarkupPanelCommand() {
+    return new W({
+      prepare: () => this.prepareReviewDockForCommand(),
+      toggle: () => {
+        var e;
+        return (e = this.dockPanel) == null ? void 0 : e.open(c);
+      }
+    });
+  }
+  /** Ensures the dock panel and review tab exist for the `markuppanel` command. */
+  prepareReviewDockForCommand() {
+    this.mountReviewDockUi(), this.tryUpgradeDockMountTarget();
+  }
+  /** Registers the `measurementpanel` command with dock preparation wired in. */
+  registerMeasurementPanelCommand(e) {
+    if (this.registeredCommands.some((o) => o.name === "measurementpanel"))
+      return;
+    const t = h.SYSTEMT_COMMAND_GROUP_NAME;
+    e.addCommand(
+      t,
+      "measurementpanel",
+      "measurementpanel",
+      this.createMeasurementPanelCommand()
+    ), this.registeredCommands.push({ group: t, name: "measurementpanel" });
+  }
+  /** Creates the `measurementpanel` command that prepares the dock before opening. */
+  createMeasurementPanelCommand() {
+    return new $({
+      prepare: () => this.prepareMeasurementDockForCommand(),
+      toggle: () => {
+        var e;
+        return (e = this.dockPanel) == null ? void 0 : e.open(u);
+      }
+    });
+  }
+  /** Ensures the dock panel and measurements tab exist for the command. */
+  prepareMeasurementDockForCommand() {
+    this.mountMeasurementDockUi(), this.tryUpgradeDockMountTarget();
+  }
+  /** Ensures the dock panel exists, tabs are mounted, and mount target is current. */
+  ensureDockReady() {
+    var e;
+    if (!this.dockPanel) {
+      this.prepareDockPanel();
+      return;
+    }
+    this.hasLayerToolbarItem && !this.dockPanel.hasTab(d) && this.mountLayerDockUi(), this.hasMarkupPanelToolbarItem && !this.dockPanel.hasTab(c) && this.mountReviewDockUi(), this.hasMeasurementPanelToolbarItem && !this.dockPanel.hasTab(u) && this.mountMeasurementDockUi(), this.hasFindToolbarItem && !this.dockPanel.hasTab(m) && this.mountFindDockUi(), this.tryUpgradeDockMountTarget(), this.dockPanel.ensureMounted(), (e = this.toolbar) == null || e.syncInParentLayout();
+  }
+  /** Ensures the dock panel exists, is mounted on the current target, and has tabs when applicable. */
+  prepareDockPanel() {
+    this.hasLayerToolbarItem && this.mountLayerDockUi(), this.hasMarkupPanelToolbarItem && this.mountReviewDockUi(), this.hasMeasurementPanelToolbarItem && this.mountMeasurementDockUi(), this.hasFindToolbarItem && this.mountFindDockUi(), this.dockPanel || this.ensureDockPanel(), this.tryUpgradeDockMountTarget();
+  }
+  /** Closes open sub-toolbars when {@link AcUiSubToolbarOptions.replaceOnNested} is set. */
+  dismissStripsForDockPanel() {
+    var e;
+    (e = this.toolbar) != null && e.replaceOnNested && this.toolbar.dismissOpenChildren();
+  }
+  /** Closes the dock panel when {@link AcUiSubToolbarOptions.replaceOnNested} is set. */
+  dismissDockForExclusiveChrome() {
+    var e, t;
+    (e = this.toolbar) != null && e.replaceOnNested && ((t = this.dockPanel) == null || t.close());
+  }
+  /** Ensures the dock panel container exists. */
+  ensureDockPanel() {
+    const e = this.getDockMountEl();
+    !e || !this.i18n || !this.dockPanelDefaults || this.dockPanel || (this.dockPanel = new V({
+      host: e,
+      t: (t) => f.t(t),
+      defaultSide: this.dockPanelDefaults.defaultSide,
+      defaultOpen: this.dockPanelDefaults.defaultOpen,
+      defaultHeight: this.dockPanelDefaults.defaultHeight,
+      defaultWidth: this.dockPanelDefaults.defaultWidth,
+      onOpen: () => this.dismissStripsForDockPanel()
+    }), this.syncToolbarMountAfterDockChange());
+  }
+  /** Resolves the dock mount element (lazy; canvas parent may appear after load). */
+  getDockMountEl() {
+    if (this.hostEl)
+      return g(
+        this.hostEl,
+        this.dockPanelMountTargetOption
+      );
+  }
+  /**
+   * Moves the dock panel from a host fallback to the canvas parent once available.
+   */
+  tryUpgradeDockMountTarget() {
+    if (this.dockPanelMountTargetOption || !this.hostEl || !this.dockPanel)
+      return;
+    const e = g(this.hostEl), t = this.dockPanel.getMountHost();
+    t !== e && (t !== this.hostEl || e === this.hostEl || (this.dockPanel.reparentTo(e), this.refreshLayerDockController(), this.syncToolbarMountAfterDockChange()));
+  }
+  /** Rebinds the layer dock controller after the dock panel moves. */
+  refreshLayerDockController() {
+    var e, t;
+    (e = this.dockPanel) != null && e.hasTab(d) && ((t = this.layerDockController) == null || t.destroy(), this.layerDockController = new I(
+      this.dockPanel,
+      d
+    ), this.layerUiControllerHolder.current = this.layerDockController);
+  }
+  /** Mounts the layer list in the dock panel layers tab. */
+  mountLayerDockUi() {
+    if (!this.hostEl || !this.i18n || (this.ensureDockPanel(), !this.dockPanel)) return;
+    if (this.dockPanel.hasTab(d)) {
+      this.refreshLayerDockController();
+      return;
+    }
+    if (this.layerListView = new _({
+      editor: l.instance,
+      i18n: this.i18n,
+      host: this.hostEl,
+      showHeader: !1
+    }), !this.dockPanel.addTab({
+      id: d,
+      labelKey: "main.dockPanel.tab.layers",
+      content: this.layerListView.element
+    })) {
+      this.layerListView.destroy(), this.layerListView = void 0;
+      return;
+    }
+    this.layerDockController = new I(
+      this.dockPanel,
+      d
+    ), this.layerUiControllerHolder.current = this.layerDockController;
+  }
+  /** Tears down active layer UI without removing the dock shell when other tabs remain. */
+  teardownLayerUi() {
+    var e, t, o;
+    (e = this.dockPanel) == null || e.removeTab(d), (t = this.layerListView) == null || t.destroy(), this.layerListView = void 0, (o = this.layerDockController) == null || o.destroy(), this.layerDockController = void 0, this.layerUiControllerHolder.current = void 0, this.destroyDockIfUnused();
+  }
+  /** Mounts the review palette in the dock panel review tab. */
+  mountReviewDockUi() {
+    if (!this.hostEl || !this.i18n || (this.ensureDockPanel(), !this.dockPanel) || this.dockPanel.hasTab(c))
+      return;
+    this.reviewPaletteView = new x({
+      editor: l.instance,
+      i18n: this.i18n
+    }), this.dockPanel.addTab({
+      id: c,
+      labelKey: "main.dockPanel.tab.review",
+      content: this.reviewPaletteView.element
+    }) || (this.reviewPaletteView.destroy(), this.reviewPaletteView = void 0);
+  }
+  /** Tears down review UI without removing the dock shell when other tabs remain. */
+  teardownReviewUi() {
+    var e, t;
+    (e = this.dockPanel) == null || e.removeTab(c), (t = this.reviewPaletteView) == null || t.destroy(), this.reviewPaletteView = void 0, this.destroyDockIfUnused();
+  }
+  /** Mounts the measurement list in the dock panel measurements tab. */
+  mountMeasurementDockUi() {
+    if (!this.hostEl || !this.i18n || (this.ensureDockPanel(), !this.dockPanel) || this.dockPanel.hasTab(u))
+      return;
+    this.measurementPaletteView = new B({
+      editor: l.instance,
+      i18n: this.i18n
+    }), this.dockPanel.addTab({
+      id: u,
+      labelKey: "main.dockPanel.tab.measurements",
+      content: this.measurementPaletteView.element
+    }) || (this.measurementPaletteView.destroy(), this.measurementPaletteView = void 0);
+  }
+  /** Tears down measurement UI without removing the dock shell when other tabs remain. */
+  teardownMeasurementUi() {
+    var e, t;
+    (e = this.dockPanel) == null || e.removeTab(u), (t = this.measurementPaletteView) == null || t.destroy(), this.measurementPaletteView = void 0, this.destroyDockIfUnused();
+  }
+  /** Mounts the text search view in the dock panel find tab. */
+  mountFindDockUi() {
+    if (!this.hostEl || !this.i18n || (this.ensureDockPanel(), !this.dockPanel) || this.dockPanel.hasTab(m))
+      return;
+    this.findPaletteView = new N({
+      editor: l.instance,
+      i18n: this.i18n
+    }), this.dockPanel.addTab({
+      id: m,
+      labelKey: "main.dockPanel.tab.find",
+      content: this.findPaletteView.element
+    }) || (this.findPaletteView.destroy(), this.findPaletteView = void 0);
+  }
+  /** Tears down find UI without removing the dock shell when other tabs remain. */
+  teardownFindUi() {
+    var e, t;
+    (e = this.dockPanel) == null || e.removeTab(m), (t = this.findPaletteView) == null || t.destroy(), this.findPaletteView = void 0, this.destroyDockIfUnused();
+  }
+  /** Closes and optionally destroys the dock panel when it has no remaining tabs. */
+  destroyDockIfUnused() {
+    this.dockPanel && (this.dockPanel.hasTabs || (this.dockPanel.close(), !this.dockPanelExplicitlyEnabled && (this.dockPanel.destroy(), this.dockPanel = void 0, this.syncToolbarMountAfterDockChange())));
+  }
+  /**
+   * Re-resolves the toolbar mount after dock wrap/unwrap, which can detach a
+   * stale `dock-main` host or change `canvas.parentElement`.
+   */
+  syncToolbarMountAfterDockChange() {
+    if (!this.toolbar || !this.hostEl) return;
+    const e = this.getToolbarMountEl();
+    e && ((e !== this.toolbarMountEl || !this.toolbar.isRootConnected()) && (this.toolbar.reparentTo(e), this.toolbarMountEl = e), this.toolbar.syncInParentLayout());
+  }
+  /** Updates toolbar placement. */
+  applyToolbarPlacement(e) {
+    var t;
+    this.toolbarPlacement = e, (t = this.toolbar) == null || t.setPlacement(e);
+  }
+  /**
+   * Tears down UI, unregisters commands, and removes injected styles if unused.
+   *
+   * @param commandManager - Command stack used to remove registered commands.
+   */
+  dispose(e) {
+    var o, a, r, s, i;
+    const t = e ?? this.commandManager;
+    if (w.setHost(void 0), (o = this.unsubscribeLayout) == null || o.call(this), this.unsubscribeLayout = void 0, f.events.localeChanged.removeEventListener(this.handleLocaleChanged), l.instance.events.documentActivated.removeEventListener(
+      this.handleDocumentActivatedForDock
+    ), t)
+      for (const n of this.registeredCommands)
+        t.removeCmd(n.group, n.name);
+    this.registeredCommands = [], this.teardownLayerUi(), this.teardownReviewUi(), this.teardownMeasurementUi(), this.teardownFindUi(), (a = this.toolbarDocUnbind) == null || a.call(this), this.toolbarDocUnbind = void 0, (r = this.toolbar) == null || r.destroy(), (s = this.dockPanel) == null || s.destroy(), this.toolbar = void 0, this.toolbarMountEl = void 0, this.toolbarMountTargetOption = void 0, this.dockPanel = void 0, this.hostEl = void 0, this.dockPanelMountTargetOption = void 0, this.baseToolbarItems = [], this.toolbarItemsInput = "default", this.toolbarItemsOverridden = !1, this.toolbarLayoutSwitcher = void 0, this.hasLayerToolbarItem = !1, this.hasMarkupPanelToolbarItem = !1, this.hasMeasurementPanelToolbarItem = !1, this.hasFindToolbarItem = !1, this.commandManager = void 0, this.i18n = void 0, (i = this.themeSync) == null || i.stop(), this.themeSync = void 0, M.instance.clearSessionOverride("isShowRibbon"), H();
+  }
+  /** Sets {@link AcApI18n.currentLocale} to one of the supported locales. */
+  setLocale(e) {
+    f.setCurrentLocale(e);
+  }
+}
+export {
+  J as AcApSimpleUiChrome
+};