flexdesk 0.4.6 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "flexdesk",
-    "version": "0.4.6",
+    "version": "0.5.0",
     "description": "A tiling window manager and widget set for desktop-class web applications. Zero runtime dependencies.",
     "license": "MIT",
     "repository": {

package/src/tiling/landing_table.js

@@ -3,7 +3,10 @@
  * pattern used by SFC / Markets / Scenarios / KPIs landings (and the
  * market-archetype instances table). Three responsibilities:
  *
- *   1. Single-click row → open the entity (handled by callers).
+ *   1. Single-click row → open the entity (handled by callers). Since 0.5.0
+ *      the click is judged by the same rule as `DataTable`'s `onRowActivate`
+ *      (`ui/components/row_activation.js`); a table that owns its rows can
+ *      use that option directly instead of this helper.
  *   2. Right-click row → custom context menu with Open / Edit / Delete
  *      (replaces DataTable's default copy-as-TSV menu for these tables;
  *      the default still applies to data tables outside this helper).
@@ -16,6 +19,7 @@
  */
 
 import { showContextMenu } from '../ui/components/context_menu.js';
+import { isRowActivation } from '../ui/components/row_activation.js';
 import { registerPanelKeys } from './panel_keys.js';
 
 /** Attach the navigation-table interactions to a host element that
@@ -85,10 +89,14 @@ export function attachLandingTableBehavior(host, getRow, entityActions, options
             dispatch(actionBtn.dataset.twmAction, tr ? getRow(tr.__rowIndex) : null);
             return;
         }
-        // Plain row click → open. Ignore clicks on interactive controls
-        // (buttons, filter inputs, links) and anything outside a body row
-        // (pagination strip, header, empty space).
-        if (ev.target.closest('button, a, input, select, textarea')) return;
+        // Plain row click → open — by THE row-activation rule DataTable's own
+        // `onRowActivate` uses (0.5.0, `ui/components/row_activation.js`), so
+        // the two cannot drift: not on a control (a button, a field, a link),
+        // not on the click that ends a drag selecting a cell's text, and not on
+        // the second click of a double-click, which used to open the row twice.
+        // Anything outside a body row (pagination strip, header, empty space)
+        // is not a row either.
+        if (!isRowActivation(ev, 'click', { scope: host })) return;
         const tr = bodyRowFor(ev);
         if (tr) dispatch('open', getRow(tr.__rowIndex));
     };

package/src/tiling/tile_breadcrumb.js

@@ -206,6 +206,27 @@ function _segments(kind, props, taxonomy, rootCrumb, rootLabel, navigate, trail)
     return segs;
 }
 
+/**
+ * C37. THE SAME STRIP FOR A CONTENT'S OWN LEVELS — the markup every tile
+ * breadcrumb draws, with segments the caller routes itself.
+ *
+ * `mountTileBreadcrumb` names where the TILE is, and every one of its segments
+ * climbs through the window manager. A page with levels that are not tabs (a
+ * section's list, one record opened in its place) has a trail the taxonomy
+ * cannot know and segments the WM cannot route; it draws them here, in the same
+ * markup and so the same look, and pairs it with a `navigateBack()` from its
+ * mount so Backspace climbs the same levels (`wm.navigateBack`, step 0).
+ *
+ * `segments` is `[{label, icon?, onClick?}]`; the last one — and any with no
+ * `onClick` — is drawn as the current one, as text. Redraws `container` in full.
+ *
+ * @param {HTMLElement} container
+ * @param {Array<{label: string, icon?: string, onClick?: Function}>} segments
+ */
+export function renderBreadcrumb(container, segments) {
+    _renderInto(container, segments);
+}
+
 function _renderInto(container, segments) {
     container.innerHTML = '';
     if (!segments?.length) return;

package/src/tiling/tile_renderer.js

@@ -839,6 +839,17 @@ export class TileRenderer {
         return (leaf && leaf.kind === 'leaf') ? this._leafKindKey(leaf) : null;
     }
 
+    /**
+     * C37. WHAT A LEAF'S CONTENT FACTORY RETURNED for the tab on screen, or
+     * `null` — so the window manager can ask the content a question about
+     * itself (`wm.navigateBack`: *"have you a level of your own to go up?"*)
+     * without reaching into the cache. Read-only; a leaf that has not been
+     * rendered yet has none.
+     */
+    contentOf(leafId) {
+        return this._leafCache.get(leafId)?.content ?? null;
+    }
+
     /**
      * C34. ACCEPT A PROPS WRITE THE CONTENT MADE ABOUT ITSELF, WITHOUT
      * REBUILDING THE TILE THAT MADE IT.

package/src/tiling/wm.js

@@ -259,10 +259,22 @@ export class WindowManager {
      *  Adding a new "Open from X" click that should be a back-able
      *  navigation just needs to use one of the in-tile routing
      *  methods (openFromContext / openInLeaf / navigateActiveTab) —
-     *  they all record history by default. */
+     *  they all record history by default.
+     *
+     *  (0) C37. BEFORE ALL OF THAT, THE CONTENT'S OWN LEVELS. A page can have
+     *  levels that are not tabs — a settings page whose section opened one
+     *  member in place of its list, an organization page showing one of its
+     *  projects — and Backspace must climb those before it walks the tile. The
+     *  content factory says so by returning `navigateBack()` from its mount: it
+     *  is asked first, in the scope Backspace acts on (`_backScope`, so a
+     *  floating window's content and the focused tile's alike), and `true`
+     *  means it climbed. `false`, or no such function, and the walk below runs
+     *  exactly as it always has. */
     navigateBack() {
         const scope = this._backScope();
         if (!scope) return;
+        // (0) C37. The content's own levels, when it has one above it.
+        if (this._contentNavigateBack(scope)) return;
         // (1) Per-tab history, browser-style. Tiles only: a window keeps none.
         if (scope.leafId && this._popTabHistory(scope.leafId)) return;
         // (2) C32. A record beside an open list of its section closes onto it.
@@ -308,24 +320,35 @@ export class WindowManager {
     }
 
     /** True when `navigateBack` would do something user-visible — i.e.
-     *  the active tab has per-tab history, OR the current kind has a
-     *  taxonomy parent. Used by the breadcrumb to grey out / hide the
-     *  Back button when there's nowhere to go. */
+     *  the content has a level of its own above the one it shows (C37), the
+     *  active tab has per-tab history, OR the current kind has a taxonomy
+     *  parent. Used by the breadcrumb to grey out / hide the Back button when
+     *  there's nowhere to go.
+     *
+     *  IT ANSWERS FOR THE SCOPE BACKSPACE ACTS ON — `_backScope`'s: a floating
+     *  window last pressed in, else the focused content tile, else the primary
+     *  one. It used to pick the tile alone, so after a press inside a window it
+     *  reported on the tile BEHIND it while Backspace climbed the window, and
+     *  C37's question went to the wrong content. For a tile the answer is
+     *  exactly what it always was; only a window scope answers differently. */
     canNavigateBack() {
-        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 false;
-        const history = tree.activeTabHistory?.(id) || [];
-        if (history.length > 0) return true;
-        const leaf = tree.get(id);
-        const kind = leaf?.content?.kind;
+        const scope = this._backScope();
+        if (!scope) return false;
+        const content = this._scopeContent(scope);
+        if (typeof content?.canNavigateBack === 'function') {
+            try { if (content.canNavigateBack() === true) return true; }
+            catch (err) { console.warn('[wm] content canNavigateBack threw', err); }
+        }
+        if (scope.leafId) {
+            const tree = this._tree();
+            const history = tree.activeTabHistory?.(scope.leafId) || [];
+            if (history.length > 0) return true;
+            const kind = tree.get(scope.leafId)?.content?.kind;
+            return !!(kind && this.taxonomy.parentKindFor(kind));
+        }
+        // A window keeps no per-tab history (`navigateBack`'s step 1 is tiles
+        // only), so what is left to it is its active tab's taxonomy parent.
+        const kind = this._scopeActiveTab(scope)?.kind;
         return !!(kind && this.taxonomy.parentKindFor(kind));
     }
 
@@ -409,6 +432,27 @@ export class WindowManager {
         return src ? src.tabs[src.activeIdx] || null : null;
     }
 
+    /** C37. What the scope's content factory returned for what is on screen:
+     *  a window's `mountInfo`, or the tile's mounted content. */
+    _scopeContent(scope) {
+        if (scope?.windowId) return this._windowToLeaf.get(scope.windowId)?.mountInfo || null;
+        return scope?.leafId ? this.renderer?.contentOf?.(scope.leafId) || null : null;
+    }
+
+    /** C37. Ask the content to climb one of its own levels; `true` if it did.
+     *  A content that throws is treated as having nowhere to go, so Backspace
+     *  still walks the tile rather than doing nothing. */
+    _contentNavigateBack(scope) {
+        const content = this._scopeContent(scope);
+        if (typeof content?.navigateBack !== 'function') return false;
+        try {
+            return content.navigateBack() === true;
+        } catch (err) {
+            console.warn('[wm] content navigateBack threw', err);
+            return false;
+        }
+    }
+
     /** Replace what a scope shows, in place: the tile's active tab (recording
      *  history) or the window's content. */
     _navigateInScope(scope, kind, props = {}) {