flexdesk 0.17.1 → 0.17.3

package/package.json

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

package/src/tiling/command_palette.js

@@ -72,6 +72,17 @@
  *   drillLabel the Tab hint ("search rows"); Tab is offered only with it
  *   shortcut   a key binding drawn on the right
  *   verb       the Enter hint ('open' by default, 'run' for a command)
+ *   enabled    `() => boolean` (0.17.2). False: the row is still listed and
+ *              the arrows still reach it, but it is drawn greyed
+ *              (`twm-cmdpal__item--disabled`, aria-disabled="true") and
+ *              picking it — click, Enter, Ctrl/Shift+Enter — does nothing and
+ *              leaves the palette open. Asked on every draw and every pick.
+ *   disabledReason  the disabled row's tooltip (its `title`)
+ *
+ * A catalog source with `scopedOnly: true` (0.17.2) contributes no rows to a
+ * plain typed query, in either layout: its rows are listed only once its
+ * prefix has made the type chip (`help: solver`).
+ *
  * `hint` keeps its old meaning — drawn AND searched — for a row that sets
  * neither `context` nor `keywords`. A group's header is the taxonomy's
  * `plural` for the kind, else its `label`.
@@ -281,8 +292,7 @@ export function createCommandPalette({ wm, api, taxonomy, catalog, placeholder =
         const render = () => {
             if (grouped) { renderGrouped(); return; }
             list.innerHTML = filtered.slice(0, MAX_ROWS).map((e, i) => `
-                <div class="twm-cmdpal__item${i === active ? ' twm-cmdpal__item--active' : ''}"
-                     data-idx="${i}">
+                ${_itemOpen(e, i === active ? ' twm-cmdpal__item--active' : '', `data-idx="${i}"`)}
                     <span class="material-symbols-outlined twm-cmdpal__icon">${e.icon || 'arrow_right'}</span>
                     <span class="twm-cmdpal__label">${_esc(e.label || e.id)}</span>
                     <span class="twm-cmdpal__kind">${e.kind}</span>
@@ -343,7 +353,7 @@ export function createCommandPalette({ wm, api, taxonomy, catalog, placeholder =
             const side = r.shortcut
                 ? `<kbd class="twm-cmdpal__shortcut">${_esc(r.shortcut)}</kbd>`
                 : `<span class="twm-cmdpal__kind">${_esc(kindLabel(r))}</span>`;
-            return `<div class="twm-cmdpal__item${on}" data-idx="${i}" role="option">
+            return `${_itemOpen(r, on, `data-idx="${i}" role="option"`)}
                 <span class="material-symbols-outlined twm-cmdpal__icon">${_esc(r.icon || 'arrow_right')}</span>
                 <span class="twm-cmdpal__main"><span class="twm-cmdpal__label">${_mark(r.label || r.id, r._hits)}</span>${ctx}</span>
                 <span class="twm-cmdpal__side">${side}<span class="twm-cmdpal__acts">${acts.join('')}</span></span>
@@ -453,6 +463,9 @@ export function createCommandPalette({ wm, api, taxonomy, catalog, placeholder =
             const picked = filtered[i];
             if (!picked) return;
             if (picked.more) { showAll(picked.more); return; }
+            // A disabled row is listed so it can say why; picking it runs
+            // nothing and the palette stays open on it.
+            if (_isDisabled(picked)) return;
             // Split and window open a COPY; a single kind refuses both, and the
             // palette stays open on the row whose hints say why.
             if (mode !== 'open' && isSingle(picked)) return;
@@ -585,6 +598,7 @@ export function createCommandPalette({ wm, api, taxonomy, catalog, placeholder =
                 return;
             }
             let pool = entities;
+            if (!filterSet) pool = pool.filter((e) => !e._scopedOnly);
             if (commandsOnly) pool = pool.filter((e) => e.kind === 'command');
             else if (filterSet) pool = pool.filter((e) => filterSet.has(_groupOf(e)) || filterSet.has(e.kind));
             else if (q.length < commandMinChars) pool = pool.filter((e) => e.kind !== 'command');
@@ -649,7 +663,7 @@ export function createCommandPalette({ wm, api, taxonomy, catalog, placeholder =
             const filterSet = typeFilter ? new Set(typeFilter) : null;
             const pool = filterSet
                 ? entities.filter((e) => filterSet.has(e.kind))
-                : entities;
+                : entities.filter((e) => !e._scopedOnly);
             if (!q) {
                 // Scoped + empty query → list every entity of that
                 // kind so the user sees what's available. Unscoped +
@@ -715,10 +729,18 @@ export function createCommandPalette({ wm, api, taxonomy, catalog, placeholder =
             }
             return [...staticCommands, ...extra];
         };
+        // A `scopedOnly` source's rows are marked here, from the catalog's
+        // own source list, so only the rows the catalog produced are held
+        // back — a command or a Recent row of the same kind is not.
+        const scopedKinds = new Set((catalog?.sources || [])
+            .filter((s) => s?.scopedOnly === true).map((s) => s.navKind));
+        const tagScoped = (rows) => (scopedKinds.size
+            ? rows.map((r) => (scopedKinds.has(r.kind) ? { ...r, _scopedOnly: true } : r))
+            : rows);
         // Objects before commands in the grouped layout, so that a tie that
         // survives every rule goes to the object (first seen wins).
         const withCommands = (rows) => (grouped ? [...rows, ...commandRows()] : [...commandRows(), ...rows]);
-        entities = _decorateIcons(withCommands(cache && cached ? cached : []), taxonomy);
+        entities = _decorateIcons(withCommands(tagScoped(cache && cached ? cached : [])), taxonomy);
         if (grouped) {
             refilter();
             if (typeof empty === 'function') {
@@ -735,7 +757,7 @@ export function createCommandPalette({ wm, api, taxonomy, catalog, placeholder =
                 const loaded = await catalog.loadAll(api);
                 if (cache) cached = loaded;
                 if (overlay !== mine) return;
-                entities = _decorateIcons(withCommands(loaded), taxonomy);
+                entities = _decorateIcons(withCommands(tagScoped(loaded)), taxonomy);
                 if (grouped ? (!scope && (input.value || typeFilter)) : input.value) refilter();
             } catch (err) {
                 console.warn('[cmdpal] entity load failed', err);
@@ -859,9 +881,26 @@ function _searched(r) {
 }
 function _groupOf(r) { return r.group || r.kind; }
 
+/** 0.17.2. `enabled` is asked each time; one that throws counts as no. */
+function _isDisabled(r) {
+    if (!r || typeof r.enabled !== 'function') return false;
+    try { return !r.enabled(); }
+    catch (err) { console.warn('[cmdpal] enabled() threw', err); return true; }
+}
+/** A row's opening `<div>` with its classes (`twm-cmdpal__item` plus `extra`)
+ *  and attributes. A disabled row adds its class, `aria-disabled` and, given a
+ *  `disabledReason`, the reason as its `title`. */
+function _itemOpen(r, extra, attrs) {
+    const off = _isDisabled(r);
+    const cls = 'twm-cmdpal__item' + extra + (off ? ' twm-cmdpal__item--disabled' : '');
+    const refused = !off ? ''
+        : ' aria-disabled="true"' + (r.disabledReason ? ` title="${_esc(r.disabledReason)}"` : '');
+    return `<div class="${cls}"${refused} ${attrs}>`;
+}
+
 /** Strip the palette's private fields before a row leaves it. */
 function _public(r) {
-    const { _hits, _score, ...rest } = r;
+    const { _hits, _score, _scopedOnly, ...rest } = r;
     return rest;
 }
 

package/src/tiling/content_registry.js

@@ -8,6 +8,9 @@
  *
  * The tile renderer calls the factory once when the leaf is first
  * mounted with a given (kind, props) pair, and `destroy()` on unmount.
+ * A content of a `single` kind may return `navigate(props)`: an open path
+ * that reveals the instance instead of mounting it hands it the new props
+ * (`wm.revealInstance`, 0.17.2).
  *
  * `ctx` is the shell's ctx plus, per leaf, `leafId` and `setTitle(text)` —
  * rename the pane's chrome title from inside the content, at mount or any

package/src/tiling/entity_sources.js

@@ -27,6 +27,12 @@
  *             row to the record shape every search surface consumes.
  *             Return `null` to skip the row.
  *
+ *   scopedOnly? `true` keeps the source's rows out of a plain typed query:
+ *             the command palette lists them only behind the source's
+ *             prefix (`<navKind>:` or an alias that resolves to it). For a
+ *             source too broad to compete with everything else — help
+ *             topics, say. Absent or `false`: searched as always (0.17.2).
+ *
  * ## Aggregation
  *
  * An embedder whose backend can answer for every source in ONE call
@@ -48,6 +54,10 @@ export function createEntityCatalog({ sources, aliases = {}, aggregate = null }
             throw new TypeError(
                 `createEntityCatalog: source '${s?.navKind ?? '?'}' needs navKind + list() + shape()`);
         }
+        if (s.scopedOnly != null && typeof s.scopedOnly !== 'boolean') {
+            throw new TypeError(
+                `createEntityCatalog: source '${s.navKind}' \`scopedOnly\` must be a boolean when present`);
+        }
     }
     if (aggregate != null && typeof aggregate !== 'function') {
         throw new TypeError('createEntityCatalog: `aggregate` must be a function when present');

package/src/tiling/wm.js

@@ -348,10 +348,57 @@ export class WindowManager {
     }
 
     /** Reveal the instance of a single kind that is open: answers whether
-     *  there was one. Every open path asks this first. */
+     *  there was one. Every open path asks this first.
+     *
+     *  An open path names props too, and revealing alone would drop them: the
+     *  instance keeps showing what it was opened with. So a revealed content
+     *  that returned a `navigate(props)` hook from its mount is handed the new
+     *  props — once per open, the same props twice are two calls — and they
+     *  are recorded on its tab, so a page restore or a reload mounts it with
+     *  the latest. A content without the hook is revealed as it is: its tab
+     *  keeps its props and nothing is called. So is every content when the
+     *  open names no props at all — a top-nav button, `openInPrimary(kind)` —
+     *  which asks to SEE the instance, not to empty it. */
     revealInstance(kind, props = {}) {
         const loc = this.findInstance(kind, props);
-        return loc ? this._revealAt(loc) : false;
+        if (!loc || !this._revealAt(loc)) return false;
+        if (props && Object.keys(props).length) this._deliverProps(kind, props);
+        return true;
+    }
+
+    /** Hand a revealed instance the props it was opened with, and record them
+     *  on its tab (and the tile's `content` mirror of it, re-baselining the
+     *  tile so the write does not rebuild it). Looks
+     *  the instance up again: a reveal from a page archive moved it into the
+     *  tile's tabs. A throwing hook is a warning, never a crash. */
+    _deliverProps(kind, props) {
+        const loc = this.findInstance(kind, props);
+        if (!loc || loc.where === 'archive') return;
+        const scope = loc.where === 'window' ? { windowId: loc.windowId } : { leafId: loc.leafId };
+        const content = this._scopeContent(scope);
+        if (typeof content?.navigate !== 'function') return;
+        const next = { ...(props || {}) };
+        if (loc.where === 'window') {
+            const rec = this._windowToLeaf.get(loc.windowId);
+            const tab = Array.isArray(rec.tabs) ? rec.tabs[loc.idx] : null;
+            if (tab) tab.props = { ...next };
+            if (rec.original) rec.original = { ...rec.original, props: { ...next } };
+        } else {
+            const leaf = this._tree().get(loc.leafId);
+            const expected = this.renderer?.leafKey?.(loc.leafId) ?? undefined;
+            leaf.tabs[loc.idx].props = { ...next };
+            // The tab is the active one now, and `content` mirrors it: the
+            // next tab activation re-mirrors it anyway, and a mirror left
+            // behind would change the tile's key then and rebuild it.
+            if (leaf.content?.kind === kind) leaf.content = { ...leaf.content, props: { ...next } };
+            this.renderer?.rebaselineLeaf?.(loc.leafId, expected);
+        }
+        this._persist();
+        try {
+            content.navigate({ ...next });
+        } catch (err) {
+            console.warn('[wm] content navigate threw', err);
+        }
     }
 
     /** A leaf's archived pages that can come back — every `pageTabs` entry
@@ -4106,8 +4153,23 @@ export class WindowManager {
      *
      *  The lower-level primitives (`openFromContext`,
      *  `openInTabFromContext`, `openInTabInPrimary`, `openInPrimary`,
-     *  `openInWindow`) stay internal; callers prefer `wm.navigate(...)`. */
+     *  `openInWindow`) stay internal; callers prefer `wm.navigate(...)`.
+     *
+     *  Returns `true` once the navigation is routed. A kind the shell's
+     *  content registry has no factory for is refused instead: one
+     *  `console.warn` naming it, no tile, tab, window or history touched, and
+     *  `false` — never a placeholder tile, never a throw. */
     navigate(kind, props = {}, opts = {}) {
+        if (!this.content.has(kind)) {
+            console.warn(`[wm] navigate: no content registered for kind "${String(kind)}"`);
+            return false;
+        }
+        this._route(kind, props, opts);
+        return true;
+    }
+
+    /** The routing behind `navigate`, for a kind known to be registered. */
+    _route(kind, props, opts) {
         const { ctx = null, transient = false } = opts;
         // Append the tab but stay where you are. Only meaningful with `newTab`.
         const background = !!opts.background;

package/src/ui/components/notification_history.js

@@ -2,8 +2,10 @@
  * NotificationHistory - Bottom bar notification history panel
  *
  * Bell icon in the global-bottom-bar that opens a popover listing past notifications.
- * Reads from NotificationCenter.history (no modifications to NotificationCenter needed).
- * Tracks unread count via lastSeenCount delta and updates a badge on the bell icon.
+ * Reads from NotificationCenter.history and follows it through
+ * `notificationCenter.subscribe()` (0.17.3): every entry the centre records — a
+ * toast from `show()`/`warn()`/... or from the bus — is one unread, until the
+ * popover is opened. The bus is not watched for toasts.
  *
  * THREE OPTIONS, all additive (FlexDesk STORY-0020); without them it is the bell
  * it always was:
@@ -34,7 +36,8 @@ export class NotificationHistory {
 
         this.triggerEl = null;
         this.badgeEl = null;
-        this.lastSeenCount = 0;
+        /** Entries recorded since the popover was last opened. */
+        this.unreadCount = 0;
         this._popoverCleanup = null;
         this._subscriptions = [];
     }
@@ -80,10 +83,14 @@ export class NotificationHistory {
             return;
         }
 
-        // Sync initial count so existing history doesn't show as unread
-        this.lastSeenCount = this.notificationCenter?.history?.length ?? 0;
-
-        this.#subscribeEvents();
+        // What is in the history at mount is not unread.
+        this.unreadCount = 0;
+        const unsubscribe = this.notificationCenter?.subscribe?.(() => {
+            this.unreadCount += 1;
+            this.#updateBadge();
+        });
+        if (typeof unsubscribe === 'function') this._subscriptions.push(unsubscribe);
+        this.#updateBadge();
     }
 
     unmount() {
@@ -99,20 +106,6 @@ export class NotificationHistory {
         this.badgeEl = null;
     }
 
-    #subscribeEvents() {
-        if (!this.eventBus) return;
-
-        // Update badge whenever a new notification comes in
-        const badgeUpdate = () => queueMicrotask(() => this.#updateBadge());
-        const events = ['toast:show', 'notification:show', 'log:entry',
-            'workspace:save:failed', 'workspace:import:failed'];
-
-        events.forEach(name => {
-            const handle = this.eventBus.on(name, badgeUpdate);
-            this._subscriptions.push(() => handle?.dispose?.());
-        });
-    }
-
     /** The Alerts tab, asked for on the bus — or the embedder's own verb. */
     #openAlerts() {
         if (this.onOpen) {
@@ -126,7 +119,7 @@ export class NotificationHistory {
         const historyLen = this.notificationCenter?.history?.length ?? 0;
         const unread = this.alertLog
             ? this.alertLog.unreadCount()
-            : Math.max(0, historyLen - this.lastSeenCount);
+            : Math.min(this.unreadCount, historyLen);
 
         if (!this.badgeEl) return;
 
@@ -164,7 +157,7 @@ export class NotificationHistory {
         this.#closePanel();
 
         // Mark all as seen
-        this.lastSeenCount = this.notificationCenter?.history?.length ?? 0;
+        this.unreadCount = 0;
         this.#updateBadge();
 
         const panel = document.createElement('div');
@@ -197,7 +190,7 @@ export class NotificationHistory {
         header.querySelector('.twm-notification-history__clear-btn')
             .addEventListener('click', () => {
                 this.notificationCenter.history.splice(0);
-                this.lastSeenCount = 0;
+                this.unreadCount = 0;
                 this.#updateBadge();
                 this.#renderList(list);
             });