flexdesk 0.17.14 → 0.17.16

package/dist/{chunk-MADMGRX2.js → chunk-PGZ4EHSE.js}

@@ -5,6 +5,9 @@ import {
 // src/ui/components/managed_window.js
 var DEFAULT_WINDOW_STORAGE_KEY = "flexdesk.managedWindows.v1";
 var _storageKey = DEFAULT_WINDOW_STORAGE_KEY;
+var DEFAULT_MAX_SAVED_WINDOWS = 50;
+var MINTED_ID_PREFIX = "twm-mw-";
+var _maxSavedWindows = DEFAULT_MAX_SAVED_WINDOWS;
 var BASE_Z_INDEX = 6e3;
 var MAX_Z_INDEX = 6999;
 var TOP_BAR_HEIGHT = 35;
@@ -17,6 +20,7 @@ var SNAP_EDGE = 12;
 var DEFAULT_ICON = "web_asset";
 var _zIndexCounter = 0;
 var _activeWindows = /* @__PURE__ */ new Map();
+var _escAnswered = /* @__PURE__ */ new WeakSet();
 function _collectFocusable(root) {
   if (!root) return [];
   const sel = [
@@ -39,7 +43,11 @@ function _loadState() {
   if (_stateCache) return _stateCache;
   try {
     const raw = localStorage.getItem(_storageKey);
-    _stateCache = raw ? JSON.parse(raw) : {};
+    const parsed = raw ? JSON.parse(raw) : {};
+    _stateCache = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    for (const k of Object.keys(_stateCache)) {
+      if (k.startsWith(MINTED_ID_PREFIX)) delete _stateCache[k];
+    }
   } catch {
     _stateCache = {};
   }
@@ -59,9 +67,50 @@ function _getWindowState(id) {
 }
 function _setWindowState(id, windowState) {
   const state = _loadState();
-  state[id] = windowState;
+  let latest = 0;
+  for (const k of Object.keys(state)) latest = Math.max(latest, Number(state[k]?.u) || 0);
+  for (const k of Object.keys(state)) {
+    if (!(Number(state[k]?.u) > 0) && state[k] && typeof state[k] === "object") {
+      state[k] = { ...state[k], u: ++latest };
+    }
+  }
+  state[id] = { ...windowState, u: latest + 1 };
+  const ids = Object.keys(state);
+  if (ids.length > _maxSavedWindows) {
+    ids.sort((a, b) => (Number(state[a]?.u) || 0) - (Number(state[b]?.u) || 0));
+    for (const k of ids.slice(0, ids.length - _maxSavedWindows)) delete state[k];
+  }
   _saveState(state);
 }
+function _focusFirstIn(root) {
+  if (!root) return false;
+  const sel = [
+    "a[href]",
+    "button:not([disabled])",
+    'input:not([disabled]):not([type="hidden"])',
+    "select:not([disabled])",
+    "textarea:not([disabled])",
+    '[contenteditable="true"]',
+    '[tabindex]:not([tabindex="-1"])'
+  ].join(",");
+  for (const el2 of root.querySelectorAll(sel)) {
+    if (el2.hidden || el2.closest("[hidden]")) continue;
+    try {
+      el2.focus({ preventScroll: true });
+    } catch {
+      continue;
+    }
+    if (el2.ownerDocument.activeElement === el2) return true;
+  }
+  return false;
+}
+function _escAnswerer() {
+  const visible = Array.from(_activeWindows.values()).filter((w) => w.isVisible && !w.isMinimized && w.element).sort((a, b) => b.zIndex - a.zIndex);
+  if (visible[0]?.modal) return visible[0];
+  const active = document.activeElement;
+  const holder = active ? visible.find((w) => w.element.contains(active)) : null;
+  return holder || visible.find((w) => w.modal) || null;
+}
 var ManagedWindow = class {
   /**
    * @param {Object} options
@@ -99,6 +148,15 @@ var ManagedWindow = class {
    *   away.
    * @param {Array} [options.titlebarButtons] - Extra buttons left of
    *   minimize: `{icon, title, onClick}`.
+   * @param {boolean} [options.persistGeometry=true] - Save and restore this
+   *   window's position and size under its id. Pass false for a window whose
+   *   id is minted per opening, so it never writes an entry.
+   * @param {boolean|'window'} [options.focusOnOpen=true] - When the window
+   *   opens, move focus to the first focusable element of its content (the
+   *   window itself when it has none; always the window itself with
+   *   `'window'`), and on close give focus back to the element that had it
+   *   before, if that element is still in the document and focus is still in
+   *   this window or nowhere.
    */
   constructor(options) {
     this.id = options.id;
@@ -135,6 +193,10 @@ var ManagedWindow = class {
     this._minimizeTimer = null;
     this._restoreTimer = null;
     this.titlebarButtons = Array.isArray(options.titlebarButtons) ? options.titlebarButtons : [];
+    this.persistGeometry = options.persistGeometry ?? true;
+    this.focusOnOpen = options.focusOnOpen ?? true;
+    this._returnFocusTo = null;
+    this._closed = false;
     this.element = null;
     this.backdropElement = null;
     this.contentContainer = null;
@@ -159,6 +221,10 @@ var ManagedWindow = class {
    * Show the window.
    */
   show() {
+    if (this._closed) {
+      console.warn(`[ManagedWindow] show() on closed window "${this.id}"; build a new ManagedWindow to reopen it`);
+      return;
+    }
     if (this.isVisible && !this.isMinimized) {
       if (this.element && this.element.style.display === "none") {
         this.element.style.display = "";
@@ -166,6 +232,7 @@ var ManagedWindow = class {
       this.bringToFront();
       return;
     }
+    let opened = false;
     if (!this.element) {
       this._build();
       this._restoreState();
@@ -190,9 +257,36 @@ var ManagedWindow = class {
       }
       this._installContainerResizeObserver();
       this.isVisible = true;
+      opened = true;
     }
     this.bringToFront();
     document.addEventListener("keydown", this._boundOnKeyDown);
+    if (opened && this.focusOnOpen) this._moveFocusIn();
+  }
+  /** BUG-0053. Focus into the content on open, remembering where it was. */
+  _moveFocusIn() {
+    const active = document.activeElement;
+    this._returnFocusTo = active && active !== document.body && !this.element.contains(active) ? active : null;
+    if (this.focusOnOpen !== "window" && _focusFirstIn(this.contentContainer)) return;
+    try {
+      this.element.focus({ preventScroll: true });
+    } catch {
+    }
+  }
+  /** BUG-0053. Give focus back on close — only when it is still in this
+   *  window (or nowhere): a window closed while the user works elsewhere
+   *  must not pull focus away from where they are. */
+  _returnFocus() {
+    const back = this._returnFocusTo;
+    this._returnFocusTo = null;
+    if (!back || !back.isConnected) return;
+    const active = document.activeElement;
+    const held = !active || active === document.body || this.element && this.element.contains(active);
+    if (!held) return;
+    try {
+      back.focus({ preventScroll: true });
+    } catch {
+    }
   }
   /**
    * Hide/close the window.
@@ -219,6 +313,7 @@ var ManagedWindow = class {
     if (this.onClose) {
       this.onClose();
     }
+    if (this.focusOnOpen) this._returnFocus();
     if (this.element && this.element.parentNode) {
       this.element.parentNode.removeChild(this.element);
     }
@@ -235,6 +330,38 @@ var ManagedWindow = class {
     window.dispatchEvent(new CustomEvent("managed-window-closed", {
       detail: { id: this.id, container: this.container }
     }));
+    this._release();
+  }
+  /** BUG-0053. A closed window leaves the registry and lets go of what it
+   *  held: its content, its DOM and every consumer callback (an `onClose`
+   *  typically captures its owner). Until now the registry kept all of it
+   *  alive until the same id opened again, and `get(id)` answered with the
+   *  dead window. */
+  _release() {
+    if (_activeWindows.get(this.id) === this) _activeWindows.delete(this.id);
+    this._closed = true;
+    if (!this._dragState && !this._resizeState) {
+      document.removeEventListener("pointermove", this._boundOnPointerMove);
+      document.removeEventListener("pointerup", this._boundOnPointerUp);
+      document.removeEventListener("pointercancel", this._boundOnPointerUp);
+    }
+    this.content = null;
+    this.element = null;
+    this.contentContainer = null;
+    this.backdropElement = null;
+    this.onClose = null;
+    this.beforeClose = null;
+    this.onMinimize = null;
+    this.onMaximize = null;
+    this.snapController = null;
+    this.dragHost = null;
+    this.dragBounds = null;
+    this.titlebarButtons = [];
+  }
+  /** True once the window has closed. A closed window cannot be shown
+   *  again; `ManagedWindow.get(id)` no longer returns it. */
+  get isClosed() {
+    return this._closed;
   }
   /**
    * Minimize to taskbar with animation.
@@ -521,6 +648,7 @@ var ManagedWindow = class {
       this.element.classList.add("twm-managed-window--modal");
     }
     this.element.setAttribute("data-window-id", this.id);
+    this.element.tabIndex = -1;
     const topbar = document.createElement("div");
     topbar.className = "twm-managed-window__topbar";
     const icon = document.createElement("span");
@@ -613,7 +741,15 @@ var ManagedWindow = class {
     if (this.canMaximize) {
       topbar.addEventListener("dblclick", () => this.toggleMaximize());
     }
-    this.element.addEventListener("pointerdown", () => this.bringToFront());
+    this.element.addEventListener("pointerdown", () => {
+      this.bringToFront();
+      if (this.element && !this.element.contains(document.activeElement)) {
+        try {
+          this.element.focus({ preventScroll: true });
+        } catch {
+        }
+      }
+    });
   }
   _addResizeHandles() {
     const directions = ["n", "s", "e", "w", "ne", "nw", "se", "sw"];
@@ -883,7 +1019,7 @@ var ManagedWindow = class {
     const bounds = this._bounds();
     const maxWidth = bounds.width;
     const maxHeight = bounds.height;
-    const saved = this.modal ? null : _getWindowState(this.id);
+    const saved = this.modal || !this.persistGeometry ? null : _getWindowState(this.id);
     if (saved) {
       this.x = saved.x ?? this.x;
       this.y = saved.y ?? this.y;
@@ -904,7 +1040,7 @@ var ManagedWindow = class {
     }
   }
   _saveCurrentState() {
-    if (this.modal) return;
+    if (this.modal || !this.persistGeometry || this._closed) return;
     _setWindowState(this.id, {
       x: this._preMaximizeState?.x ?? this.x,
       y: this._preMaximizeState?.y ?? this.y,
@@ -1183,11 +1319,15 @@ var ManagedWindow = class {
   _onKeyDown(e) {
     if (!this.isVisible || this.isMinimized) return;
     const topWindow = Array.from(_activeWindows.values()).filter((w) => w.isVisible && !w.isMinimized).sort((a, b) => b.zIndex - a.zIndex)[0];
-    if (topWindow !== this) return;
     if (e.key === "Escape") {
-      this.close();
+      if (e.defaultPrevented || e.isComposing || _escAnswered.has(e)) return;
+      if (_escAnswerer() === this) {
+        _escAnswered.add(e);
+        this.close();
+      }
       return;
     }
+    if (topWindow !== this) return;
     if (e.key === "Tab" && this.modal && this.element) {
       const focusables = _collectFocusable(this.element);
       if (focusables.length === 0) {
@@ -1219,9 +1359,15 @@ var ManagedWindow = class {
    *
    * @param {object} [opts]
    * @param {string} [opts.storageKey=DEFAULT_WINDOW_STORAGE_KEY]
+   * @param {number} [opts.maxSavedWindows=DEFAULT_MAX_SAVED_WINDOWS] How many
+   *   ids keep saved geometry; the least recently saved go first.
    */
-  static configure({ storageKey = DEFAULT_WINDOW_STORAGE_KEY } = {}) {
+  static configure({
+    storageKey = DEFAULT_WINDOW_STORAGE_KEY,
+    maxSavedWindows = DEFAULT_MAX_SAVED_WINDOWS
+  } = {}) {
     _storageKey = storageKey;
+    _maxSavedWindows = Math.max(1, Math.floor(maxSavedWindows) || DEFAULT_MAX_SAVED_WINDOWS);
     _stateCache = null;
   }
   /** @returns {string} The localStorage key window geometry uses. */
@@ -1894,6 +2040,7 @@ function isRowActivation(ev, gesture = "click", { scope = null } = {}) {
 
 export {
   DEFAULT_WINDOW_STORAGE_KEY,
+  DEFAULT_MAX_SAVED_WINDOWS,
   ManagedWindow,
   ToggleField,
   isHexColor,
@@ -1910,4 +2057,4 @@ export {
   endsTextSelection,
   isRowActivation
 };
-//# sourceMappingURL=chunk-MADMGRX2.js.map
+//# sourceMappingURL=chunk-PGZ4EHSE.js.map