flexdesk 0.4.1 → 0.4.3

package/dist/tiles.js

@@ -3,8 +3,8 @@ import {
 } from "./chunk-O5OHMWBB.js";
 import {
   openRawTracesWindow
-} from "./chunk-XKDTIT4Q.js";
-import "./chunk-QIU5S2RU.js";
+} from "./chunk-4RGQSRMC.js";
+import "./chunk-P4AALM3A.js";
 import "./chunk-LH5TSOZW.js";
 import "./chunk-FL5KFNQH.js";
 import {

package/dist/widgets.js

@@ -21,7 +21,7 @@ import {
 import {
   DataTable,
   createRafResizeObserver
-} from "./chunk-QIU5S2RU.js";
+} from "./chunk-P4AALM3A.js";
 import {
   ManagedWindow
 } from "./chunk-LH5TSOZW.js";

package/dist/wm.js

@@ -2335,7 +2335,9 @@ function mountTileBreadcrumb(kind, props, ctx) {
       console.error("[breadcrumb] no WM available \u2014 click ignored", k);
       return;
     }
-    if (typeof wm.navigate === "function") {
+    if (typeof wm.navigateUp === "function") {
+      wm.navigateUp(k, p, { ctx });
+    } else if (typeof wm.navigate === "function") {
       wm.navigate(k, p, { ctx, dest: "origin" });
     } else if (typeof wm.openInPrimary === "function") {
       wm.openInPrimary(k, p);
@@ -2902,7 +2904,7 @@ var TileRenderer = class {
                 <button class="twm-leaf__btn" data-action="split-v" title="Split vertically (Alt+V)">
                     <span class="material-symbols-outlined">splitscreen_add</span>
                 </button>
-                <button class="twm-leaf__btn" data-action="promote" title="Float this pane as a window (Alt+F)">
+                <button class="twm-leaf__btn" data-action="promote" title="Float this ${this.ctx.wm?.floatActiveTab ? "tab" : "pane"} as a window (Alt+F)">
                     <span class="material-symbols-outlined">web_asset</span>
                 </button>`}
             <button class="twm-leaf__btn" data-action="close" title="Close (Alt+W)">
@@ -3979,7 +3981,8 @@ var WindowManager = class _WindowManager {
     snapPromotion = false,
     promoteInPlace = false,
     tabLayout = null,
-    backToOpenList = false
+    backToOpenList = false,
+    floatActiveTab = false
   }) {
     if (!taxonomy) throw new Error("WindowManager: a taxonomy is required");
     if (!content || typeof content.mount !== "function") {
@@ -3995,6 +3998,7 @@ var WindowManager = class _WindowManager {
     this.eventBus = eventBus || null;
     this.onChange = onChange || (() => {
     });
+    this.floatActiveTab = !!floatActiveTab;
     this._rootLeaf = () => {
       const kind = this.taxonomy.root;
       return {
@@ -4006,6 +4010,12 @@ var WindowManager = class _WindowManager {
     this.snapPromotion = !!snapPromotion;
     this.promoteInPlace = !!promoteInPlace;
     this.backToOpenList = !!backToOpenList;
+    this._backWindowId = null;
+    const doc = rootEl?.ownerDocument || globalThis.document;
+    doc?.addEventListener?.("pointerdown", (e) => {
+      const el = e.target?.closest?.("[data-window-id]");
+      this._backWindowId = el && this._windowToLeaf.has(el.getAttribute("data-window-id")) ? el.getAttribute("data-window-id") : null;
+    }, true);
     this._snapCtl = null;
     this.desktops = new DesktopManager({
       seed: this._rootLeaf,
@@ -4150,55 +4160,42 @@ var WindowManager = class _WindowManager {
    *  methods (openFromContext / openInLeaf / navigateActiveTab) —
    *  they all record history by default. */
   navigateBack() {
-    const tree = this._tree();
-    const focusedId = tree.focusedLeafId;
-    const primaryId = tree.primaryLeafId();
-    const focusedLeaf = focusedId ? tree.get(focusedId) : null;
-    const focusedKind = focusedLeaf?.content?.kind || "";
-    const id = focusedId && focusedKind && !focusedKind.startsWith("panel:") && focusedKind !== "window-placeholder" ? focusedId : primaryId;
-    if (!id) return;
-    const prior = tree.popActiveTabHistory?.(id);
-    if (prior && prior.kind) {
-      const leafNow = tree.get(id);
-      const curKind = leafNow?.content?.kind;
-      const curTopNav = curKind ? this.taxonomy.topNavFor(curKind) : null;
-      if (prior.topNav && curTopNav && prior.topNav !== curTopNav) {
-        tree.swapToPage?.(
-          id,
-          {
-            kind: prior.kind,
-            props: prior.props || {},
-            title: prior.title || _tabTitle(prior.kind, prior.props)
-          },
-          curTopNav,
-          prior.topNav,
-          { recordHistory: false }
-        );
-      } else {
-        tree.replaceActiveTabContent(
-          id,
-          { kind: prior.kind, props: prior.props || {} },
-          prior.title || _tabTitle(prior.kind, prior.props),
-          { recordHistory: false }
-        );
-      }
-      tree.focus(id);
-      this.renderer.render();
-      this._persist();
-      this._notifyChange("navigate-back");
-      return;
-    }
-    if (this.backToOpenList && this._backToOpenList(id)) return;
-    const leaf = tree.get(id);
-    if (!leaf?.content) return;
-    const { kind, props } = leaf.content;
-    const up = this.taxonomy.parentOf(kind, props);
-    if (up) {
-      this.navigateActiveTab(id, up.kind, up.props);
-      return;
-    }
-    const parent = this.taxonomy.parentKindFor(kind);
-    if (parent) this.navigateActiveTab(id, parent);
+    const scope = this._backScope();
+    if (!scope) return;
+    if (scope.leafId && this._popTabHistory(scope.leafId)) return;
+    if (this._returnToOpenList(scope)) return;
+    const active = this._scopeActiveTab(scope);
+    if (!active) return;
+    const up = this.taxonomy.parentOf(active.kind, active.props || {});
+    const parentKind = up ? up.kind : this.taxonomy.parentKindFor(active.kind);
+    if (parentKind) this._navigateInScope(scope, parentKind, up ? up.props || {} : {});
+  }
+  /**
+   * C35. CLIMB TO A LEVEL: what a breadcrumb crumb means.
+   *
+   * `navigate` goes to exactly the target. A crumb says something different:
+   * "take me up to this level of where I am". From a record, the level it
+   * names is usually a list of the record's own section, and when such a list
+   * is already open that is the SAME request Backspace makes, so it goes
+   * through the same rule, `_returnToOpenList`, and closes the record onto the
+   * open list instead of turning the record into a second copy of it.
+   *
+   * Every crumb calls this, so no crumb needs to know whether it is the
+   * immediate parent. A crumb that names an entity (an epic above a story), a
+   * record with no list of its section open, or content that is not a record
+   * navigates in place, exactly as `navigate(…, { dest: 'origin' })` would.
+   *
+   * @param {string} kind
+   * @param {object} [props]
+   * @param {{ctx?: object}} [opts]  the crumb's tile or window context
+   */
+  navigateUp(kind, props = {}, { ctx = null } = {}) {
+    const scope = this._scopeFromCtx(ctx);
+    if (!scope) return this.navigate(kind, props, { ctx, dest: "origin" });
+    const active = this._scopeActiveTab(scope);
+    const aimsAtOwnList = !_isEntityTab({ props }) && _isEntityTab(active) && this.taxonomy.topNavFor(kind) === this.taxonomy.topNavFor(active.kind);
+    if (aimsAtOwnList && this._returnToOpenList(scope)) return;
+    this._navigateInScope(scope, kind, props);
   }
   /** True when `navigateBack` would do something user-visible — i.e.
    *  the active tab has per-tab history, OR the current kind has a
@@ -4230,67 +4227,178 @@ var WindowManager = class _WindowManager {
     this.renderer?.rebaselineLeaf?.(leafId, expected);
     this._persist();
   }
-  /** Navigate inside the current tab — preserves every other tab in
-   *  the leaf. Used by Backspace + breadcrumb segments + anything
-   *  else that should walk WITHIN the tile rather than reset it. */
+  // ── Back and up: one scope model, one rule ─────────────────────
+  //
+  // A SCOPE is where a navigation happens: `{ leafId }` for a tile or
+  // `{ windowId }` for a floating window. Backspace and `navigateUp` both
+  // resolve one, and everything below works on a scope, so tiles and windows
+  // cannot drift into two versions of the same behaviour.
+  /** The scope Backspace acts on. C34: a floating window the user last
+   *  clicked in, because the tree's focus never moves to a window; else the
+   *  focused content tile; else the primary tile. Panels are never a scope:
+   *  Backspace from the nav panel walks the content area. */
+  _backScope() {
+    if (this._backWindowId && this._windowToLeaf.has(this._backWindowId)) {
+      return { windowId: this._backWindowId };
+    }
+    this._backWindowId = null;
+    const tree = this._tree();
+    const focusedId = tree.focusedLeafId;
+    const focusedKind = focusedId ? tree.get(focusedId)?.content?.kind || "" : "";
+    const id = focusedId && focusedKind && !focusedKind.startsWith("panel:") && focusedKind !== "window-placeholder" ? focusedId : tree.primaryLeafId();
+    return id ? { leafId: id } : null;
+  }
+  /** The scope a content context names: its window, or its tile. Null for a
+   *  panel or a context the WM does not know. */
+  _scopeFromCtx(ctx) {
+    if (ctx?.windowId && this._windowToLeaf.has(ctx.windowId)) return { windowId: ctx.windowId };
+    const leaf = ctx?.leafId ? this._tree().get(ctx.leafId) : null;
+    const k = leaf?.content?.kind || "";
+    if (leaf && leaf.kind === "leaf" && k && !k.startsWith("panel:")) return { leafId: leaf.id };
+    return null;
+  }
+  /** A scope's tab list and active index. A window promoted with no strip, or
+   *  a tile with no tab array, reads as a single tab. */
+  _scopeTabs(scope) {
+    if (scope?.windowId) {
+      const rec = this._windowToLeaf.get(scope.windowId);
+      if (!rec) return null;
+      const tabs2 = Array.isArray(rec.tabs) && rec.tabs.length ? rec.tabs : [rec.original].filter(Boolean);
+      return { tabs: tabs2, activeIdx: Math.max(0, Math.min(tabs2.length - 1, rec.activeTabIdx || 0)) };
+    }
+    const leaf = scope?.leafId ? this._tree().get(scope.leafId) : null;
+    if (!leaf || leaf.kind !== "leaf") return null;
+    const tabs = Array.isArray(leaf.tabs) && leaf.tabs.length ? leaf.tabs : [leaf.content].filter(Boolean);
+    return { tabs, activeIdx: Math.max(0, Math.min(tabs.length - 1, leaf.activeTabIdx || 0)) };
+  }
+  _scopeActiveTab(scope) {
+    const src = this._scopeTabs(scope);
+    return src ? src.tabs[src.activeIdx] || null : null;
+  }
+  /** Replace what a scope shows, in place: the tile's active tab (recording
+   *  history) or the window's content. */
+  _navigateInScope(scope, kind, props = {}) {
+    if (scope.windowId) return this.openInWindow(scope.windowId, kind, props);
+    return this.navigateActiveTab(scope.leafId, kind, props);
+  }
+  /** Pop the active tab's history, if it has any. */
+  _popTabHistory(id) {
+    const tree = this._tree();
+    const prior = tree.popActiveTabHistory?.(id);
+    if (!prior || !prior.kind) return false;
+    const curKind = tree.get(id)?.content?.kind;
+    const curTopNav = curKind ? this.taxonomy.topNavFor(curKind) : null;
+    const title = prior.title || _tabTitle(prior.kind, prior.props);
+    if (prior.topNav && curTopNav && prior.topNav !== curTopNav) {
+      tree.swapToPage?.(
+        id,
+        { kind: prior.kind, props: prior.props || {}, title },
+        curTopNav,
+        prior.topNav,
+        { recordHistory: false }
+      );
+    } else {
+      tree.replaceActiveTabContent(
+        id,
+        { kind: prior.kind, props: prior.props || {} },
+        title,
+        { recordHistory: false }
+      );
+    }
+    tree.focus(id);
+    this.renderer.render();
+    this._persist();
+    this._notifyChange("navigate-back");
+    return true;
+  }
   /**
-   * C32. BACK FROM AN OPENED RECORD RETURNS TO THE LIST, IT DOES NOT MAKE ONE.
-   *
-   * The gesture this is for: a list tab, a record opened from it into a NEW
-   * tab, and Backspace in that record. With nothing left in the record tab's
-   * own history, step (3) of `navigateBack` walks the taxonomy up and REWRITES
-   * the record tab into its parent — so the tile ends up showing the list
-   * twice, once in the tab you started from and once in the tab you just left.
-   * The user's model is a browser's: you came from the list, the list is still
-   * open, so going back means closing this and being on the list again.
-   *
-   * So: when the active tab is an ENTITY — its props carry an `id`, the same
-   * test `swapToPage` uses for "the caller asked for a specific entity" — look
-   * for an open tab of the SAME section that is NOT one. That is the list or
-   * landing page the record belongs to. Close the record and activate it.
-   *
-   * NEAREST TO THE LEFT FIRST. New tabs are appended at the end, so the tab a
-   * record was opened from sits to its left; when several lists of the section
-   * are open, the nearest one on that side is the one it most plausibly came
-   * from. The right side is searched only after the left has nothing.
-   *
-   * DECLINES, and leaves step (3) to walk up in place, whenever there is no
-   * such tab: a record that is the tile's only tab, or one whose section has no
-   * list open. That keeps the one guarantee the whole rule exists for — Back
-   * never leaves two copies of a list — without ever closing a record into a
-   * tile that has nothing of its own to show.
-   *
-   * Matching is by SECTION (`topNavFor`) and not by kind, because the list a
-   * record was opened from is often not the record's taxonomy parent: a root
-   * landing page that renders the section, or a list that a flattened taxonomy
-   * files beside the record rather than above it.
-   *
-   * @returns {boolean} whether it closed a tab
+   * C32 / C34 / C35. BACK FROM A RECORD RETURNS TO THE LIST; IT DOES NOT MAKE ONE.
+   *
+   * The gesture this is for: a list, a record opened from it into a new tab,
+   * then Backspace or the list's crumb in that record. Rewriting the record
+   * into its parent would leave the list open twice. The user's model is a
+   * browser's: the list is still open, so going back closes the record and
+   * shows the list again. This function is the ONLY place that rule lives.
+   *
+   * Applies when `backToOpenList` is on and the scope's active tab is a RECORD
+   * (its props carry an `id`). The list is an open tab that is not a record
+   * and belongs to the same SECTION (`topNavFor`), matched by section and not
+   * by kind because a record's list is often not its taxonomy parent: a root
+   * landing that renders the section, or a list filed beside the record.
+   *
+   * Where it looks, in order:
+   *   - the scope's own tabs, nearest to the LEFT first (new tabs are appended,
+   *     so the tab a record came from sits to its left), then to the right;
+   *   - for a WINDOW only, then any tile of the window's desktop, primary tile
+   *     first, activating a list tab there. Closing a window's last tab closes
+   *     the window, which discards it; a plain close never docks back.
+   *
+   * Declines, leaving the caller to navigate in place, when there is no such
+   * list, so Back never closes a record into a tile with nothing to show.
+   *
+   * @returns {boolean} whether it closed the record
    */
-  _backToOpenList(leafId) {
-    const tree = this._tree();
-    const leaf = tree.get(leafId);
-    if (!leaf || leaf.kind !== "leaf") return false;
-    const tabs = Array.isArray(leaf.tabs) ? leaf.tabs : [];
-    if (tabs.length < 2) return false;
-    const activeIdx = Math.max(0, Math.min(tabs.length - 1, leaf.activeTabIdx || 0));
+  _returnToOpenList(scope) {
+    if (!this.backToOpenList) return false;
+    const src = this._scopeTabs(scope);
+    if (!src) return false;
+    const { tabs, activeIdx } = src;
     const active = tabs[activeIdx];
     if (!_isEntityTab(active)) return false;
     const section = this.taxonomy.topNavFor(active.kind);
     if (!section) return false;
-    const isList = (t) => t && !_isEntityTab(t) && this.taxonomy.topNavFor(t.kind) === section;
-    let target = -1;
-    for (let i = activeIdx - 1; i >= 0 && target < 0; i--) if (isList(tabs[i])) target = i;
-    for (let i = activeIdx + 1; i < tabs.length && target < 0; i++) if (isList(tabs[i])) target = i;
-    if (target < 0) return false;
-    tree.removeLeafTab(leafId, activeIdx);
-    tree.setActiveLeafTab(leafId, target > activeIdx ? target - 1 : target);
-    tree.focus(leafId);
-    this.renderer.render();
-    this._persist();
-    this._notifyChange("navigate-back-close");
-    return true;
+    const isList = (t) => !!t && !_isEntityTab(t) && this.taxonomy.topNavFor(t.kind) === section;
+    const own = _nearestIndex(tabs, activeIdx, isList);
+    if (own >= 0 && tabs.length > 1) {
+      const landing = own > activeIdx ? own - 1 : own;
+      if (scope.windowId) {
+        this._windowTabAction(scope.windowId, "close", { idx: activeIdx });
+        this.showWindowTab(scope.windowId, landing);
+        return true;
+      }
+      const tree2 = this._tree();
+      tree2.removeLeafTab(scope.leafId, activeIdx);
+      tree2.setActiveLeafTab(scope.leafId, landing);
+      tree2.focus(scope.leafId);
+      this.renderer.render();
+      this._persist();
+      this._notifyChange("navigate-back-close");
+      return true;
+    }
+    if (!scope.windowId) return false;
+    const rec = this._windowToLeaf.get(scope.windowId);
+    const tree = (this.desktops.desktops[rec.desktopIdx] || this.desktops.active()).tree;
+    const primaryId = tree.primaryLeafId();
+    const leaves = tree.leaves?.() || [];
+    const ordered = [...leaves.filter((l) => l.id === primaryId), ...leaves.filter((l) => l.id !== primaryId)];
+    for (const leaf of ordered) {
+      const ltabs = Array.isArray(leaf.tabs) ? leaf.tabs : [];
+      const cur = Math.max(0, Math.min(ltabs.length - 1, leaf.activeTabIdx || 0));
+      const hit = isList(ltabs[cur]) ? cur : ltabs.findIndex(isList);
+      if (hit < 0) continue;
+      if (this._backWindowId === scope.windowId) this._backWindowId = null;
+      if (Array.isArray(rec.tabs) && rec.tabs.length > 1) {
+        this._windowTabAction(scope.windowId, "close", { idx: activeIdx });
+      } else {
+        try {
+          rec.window.close({ force: true });
+        } catch {
+        }
+      }
+      if (this.desktops.active().tree === tree) {
+        tree.setActiveLeafTab(leaf.id, hit);
+        tree.focus(leaf.id);
+        this.renderer.render();
+      }
+      this._persist();
+      this._notifyChange("navigate-back-close");
+      return true;
+    }
+    return false;
   }
+  /** Navigate inside the current tab — preserves every other tab in
+   *  the leaf. Used by Backspace + breadcrumb segments + anything
+   *  else that should walk WITHIN the tile rather than reset it. */
   navigateActiveTab(leafId, kind, props = {}) {
     const tree = this._tree();
     const leaf = tree.get(leafId);
@@ -4417,6 +4525,11 @@ var WindowManager = class _WindowManager {
       currentTopNav,
       targetTopNav
     );
+    const _leaf = tree.get(leafId);
+    const _active = _leaf?.tabs?.[_leaf.activeTabIdx];
+    if (_active && _active.kind === kind && Object.keys(props || {}).length > 0 && JSON.stringify(_active.props || {}) !== JSON.stringify(props || {})) {
+      tree.replaceActiveTabContent(leafId, { kind, props }, title, { recordHistory: false });
+    }
     tree.focus(leafId);
     if (spawned) this._canonicalize(tree, this.desktops.active());
     this.renderer.render();
@@ -4632,6 +4745,11 @@ var WindowManager = class _WindowManager {
     const tree = this._tree();
     const focused = tree.focused();
     if (!focused) return null;
+    const tabs = Array.isArray(focused.tabs) ? focused.tabs : [];
+    if (this.floatActiveTab && tabs.length > 1) {
+      const idx = Math.max(0, Math.min(tabs.length - 1, focused.activeTabIdx || 0));
+      return this.floatTabAsWindow(focused.id, idx);
+    }
     return this.floatPane(focused.id);
   }
   /** R8. Float a pane — every tab, with the strip — into a managed window.
@@ -6904,6 +7022,11 @@ function _swapSiblings(tree, aId, bId) {
   parent.sizes[j] = size;
   return true;
 }
+function _nearestIndex(tabs, from, test) {
+  for (let i = from - 1; i >= 0; i--) if (test(tabs[i])) return i;
+  for (let i = from + 1; i < tabs.length; i++) if (test(tabs[i])) return i;
+  return -1;
+}
 function _isEntityTab(tab) {
   return !!tab && tab.props != null && tab.props.id != null && tab.props.id !== "";
 }
@@ -7421,6 +7544,7 @@ async function createShell({
   snapPromotion = false,
   promoteInPlace = false,
   backToOpenList = false,
+  floatActiveTab = false,
   tabLayout = null,
   chrome = {},
   // An embedder that moved its sections out of the top bar — into an icon
@@ -7461,6 +7585,7 @@ async function createShell({
     snapPromotion,
     promoteInPlace,
     backToOpenList,
+    floatActiveTab,
     tabLayout,
     // `ctx` is the delivery vehicle for leaf-mounted chrome: tile_renderer
     // spreads it into every content factory, which is how the breadcrumb
@@ -7788,7 +7913,7 @@ function _tileContextMenu(wm, leafId, x, y) {
     // direction is a dead control; in the mean direction it is a missing
     // feature, and this file has shipped one of each.
     {
-      label: "Float this pane as a window",
+      label: wm.floatActiveTab ? "Float this tab as a window" : "Float this pane as a window",
       icon: "web_asset",
       action: "promote",
       disabled: isPanel || !leaf.content || wm.renderer?.leafChrome?.(leafId)?.promote === false