sh3-core 0.11.4 → 0.11.6

package/dist/actions/MenuBar.test.js

@@ -0,0 +1,109 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mount, unmount, tick } from 'svelte';
+import MenuBar from './MenuBar.svelte';
+import { registerLayerRoot, unregisterLayerRoot } from '../overlays/roots';
+import { __resetPopupManagerForTest } from '../overlays/popup';
+import { setActiveApp, __resetDispatcherStateForTest, } from './state.svelte';
+import { registerAction, __resetActionsRegistryForTest, } from './registry';
+import { __resetContributionsForTest } from '../contributions/registry';
+import { registerApp, __resetAppRegistryForTest, } from '../apps/registry.svelte';
+let layerRoot;
+let host;
+let cmp = null;
+function makeApp(id, menus) {
+    return {
+        manifest: {
+            id, label: id, version: '0.0.0',
+            requiredShards: ['shard.x'], layoutVersion: 1,
+            menus,
+        },
+        initialLayout: { type: 'leaf', viewId: 'shard.x:v' },
+    };
+}
+beforeEach(() => {
+    vi.stubGlobal('innerWidth', 2000);
+    vi.stubGlobal('innerHeight', 2000);
+    layerRoot = document.createElement('div');
+    layerRoot.style.position = 'relative';
+    document.body.appendChild(layerRoot);
+    registerLayerRoot('popup', layerRoot);
+    host = document.createElement('div');
+    document.body.appendChild(host);
+});
+afterEach(() => {
+    if (cmp) {
+        unmount(cmp);
+        cmp = null;
+    }
+    host.remove();
+    __resetPopupManagerForTest();
+    unregisterLayerRoot('popup');
+    layerRoot.remove();
+    __resetActionsRegistryForTest();
+    __resetContributionsForTest();
+    __resetAppRegistryForTest();
+    __resetDispatcherStateForTest();
+    vi.unstubAllGlobals();
+});
+describe('MenuBar', () => {
+    it('renders an empty menubar when no app is active', async () => {
+        cmp = mount(MenuBar, { target: host, props: {} });
+        await tick();
+        // The wrapper always renders (it occupies a grid cell in the shell
+        // tabbar so user chrome stays anchored right). When no app is active
+        // it's just empty.
+        const bar = host.querySelector('.sh3-menubar');
+        expect(bar).not.toBeNull();
+        expect(bar.querySelectorAll('.sh3-menubar-button')).toHaveLength(0);
+    });
+    it('renders one button per declared container when an app is active', async () => {
+        registerApp(makeApp('app.a', [
+            { id: 'file', label: 'File' },
+            { id: 'help', label: 'Help' },
+        ]));
+        registerAction({
+            id: 'open', label: 'Open', scope: 'app',
+            menuItem: 'file', run: () => { },
+        }, 'shard.x');
+        registerAction({
+            id: 'docs', label: 'Docs', scope: 'app',
+            menuItem: 'help', run: () => { },
+        }, 'shard.x');
+        setActiveApp('app.a', new Set(['shard.x']));
+        cmp = mount(MenuBar, { target: host, props: {} });
+        await tick();
+        const buttons = host.querySelectorAll('.sh3-menubar-button');
+        expect(buttons).toHaveLength(2);
+        expect(buttons[0].textContent).toContain('File');
+        expect(buttons[1].textContent).toContain('Help');
+    });
+    it('falls back to DEFAULT_MENU_CONTAINERS when manifest.menus is absent', async () => {
+        registerApp(makeApp('app.b'));
+        registerAction({
+            id: 'q', label: 'Quit', scope: 'app',
+            menuItem: 'file', run: () => { },
+        }, 'shard.x');
+        setActiveApp('app.b', new Set(['shard.x']));
+        cmp = mount(MenuBar, { target: host, props: {} });
+        await tick();
+        const buttons = host.querySelectorAll('.sh3-menubar-button');
+        expect(buttons).toHaveLength(1);
+        expect(buttons[0].textContent).toContain('File');
+    });
+    it('hides containers whose item list is empty', async () => {
+        registerApp(makeApp('app.c', [
+            { id: 'file', label: 'File' },
+            { id: 'edit', label: 'Edit' },
+        ]));
+        registerAction({
+            id: 'open', label: 'Open', scope: 'app',
+            menuItem: 'file', run: () => { },
+        }, 'shard.x');
+        setActiveApp('app.c', new Set(['shard.x']));
+        cmp = mount(MenuBar, { target: host, props: {} });
+        await tick();
+        const buttons = host.querySelectorAll('.sh3-menubar-button');
+        expect(buttons).toHaveLength(1);
+        expect(buttons[0].textContent).toContain('File');
+    });
+});

package/dist/actions/MenuButton.svelte

@@ -0,0 +1,104 @@
+<script lang="ts">
+  /*
+   * MenuButton — one menu bar container. A button that opens a popup
+   * containing an ActionPanel rendered with this container's items.
+   * Items are passed in (the parent MenuBar resolves them via
+   * menuBarModel.resolveMenuItems).
+   */
+  import { popupManager } from '../overlays/popup';
+  import ActionPanel, { type ActionPanelSection } from './ActionPanel.svelte';
+  import { listActions } from './registry';
+  import { getLiveDispatcherState } from './state.svelte';
+  import type { MenuBarItem } from './menuBarModel';
+  import type { MenuContainer } from '../apps/types';
+
+  let { container, items }: {
+    container: MenuContainer;
+    items: MenuBarItem[];
+  } = $props();
+
+  let buttonEl: HTMLButtonElement | undefined = $state();
+
+  function makeSections(list: MenuBarItem[]): ActionPanelSection[] {
+    const buckets = new Map<string, MenuBarItem[]>();
+    const order: string[] = [];
+    for (const item of list) {
+      const key = item.group || '';
+      if (!buckets.has(key)) {
+        buckets.set(key, []);
+        order.push(key);
+      }
+      buckets.get(key)!.push(item);
+    }
+    return order.map((k) => ({ id: `group:${k || '_default'}`, items: buckets.get(k)! }));
+  }
+
+  function openPopup() {
+    if (!buttonEl) return;
+    const state = getLiveDispatcherState();
+    popupManager.show(
+      ActionPanel,
+      { anchor: buttonEl, placement: 'bottom-start' },
+      {
+        sections: makeSections(items),
+        onInvoke: (id: string) => {
+          const entry = listActions().find((e) => e.action.id === id);
+          if (!entry) return;
+          try {
+            void entry.action.run({
+              action: { id, label: entry.action.label },
+              appId: state.activeAppId,
+              viewId: state.focusedViewId ?? undefined,
+              selection: state.selection ?? undefined,
+              invokedVia: 'palette',
+              dispatch: () => {},
+            });
+          } catch (err) {
+            console.error(`[sh3] menu-bar action "${id}" threw:`, err);
+          }
+        },
+        onDismiss: () => popupManager.close(),
+      },
+    );
+  }
+
+  const iconPosition = $derived(container.iconPosition ?? 'before');
+</script>
+
+<button
+  type="button"
+  class="sh3-menubar-button"
+  bind:this={buttonEl}
+  onclick={openPopup}
+>
+  {#if container.icon && iconPosition === 'before'}
+    <span class="sh3-menubar-icon" data-icon={container.icon}></span>
+  {/if}
+  <span class="sh3-menubar-label">{container.label}</span>
+  {#if container.icon && iconPosition === 'after'}
+    <span class="sh3-menubar-icon" data-icon={container.icon}></span>
+  {/if}
+</button>
+
+<style>
+  .sh3-menubar-button {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    padding: 0 var(--shell-pad-md);
+    height: 100%;
+    background: transparent;
+    color: var(--shell-fg);
+    border: 0;
+    font: inherit;
+    cursor: default;
+  }
+  .sh3-menubar-button:hover {
+    background: var(--shell-bg-elevated);
+  }
+  .sh3-menubar-icon {
+    width: 14px;
+    height: 14px;
+    display: inline-block;
+  }
+</style>

package/dist/actions/MenuButton.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { MenuBarItem } from './menuBarModel';
+import type { MenuContainer } from '../apps/types';
+type $$ComponentProps = {
+    container: MenuContainer;
+    items: MenuBarItem[];
+};
+declare const MenuButton: import("svelte").Component<$$ComponentProps, {}, "">;
+type MenuButton = ReturnType<typeof MenuButton>;
+export default MenuButton;

package/dist/actions/MenuButton.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/actions/MenuButton.test.js

@@ -0,0 +1,88 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mount, unmount, tick } from 'svelte';
+import MenuButton from './MenuButton.svelte';
+import { registerLayerRoot, unregisterLayerRoot } from '../overlays/roots';
+import { __resetPopupManagerForTest } from '../overlays/popup';
+let layerRoot;
+let host;
+let cmp = null;
+beforeEach(() => {
+    vi.stubGlobal('innerWidth', 2000);
+    vi.stubGlobal('innerHeight', 2000);
+    layerRoot = document.createElement('div');
+    layerRoot.style.position = 'relative';
+    document.body.appendChild(layerRoot);
+    registerLayerRoot('popup', layerRoot);
+    host = document.createElement('div');
+    document.body.appendChild(host);
+});
+afterEach(() => {
+    if (cmp) {
+        unmount(cmp);
+        cmp = null;
+    }
+    host.remove();
+    __resetPopupManagerForTest();
+    unregisterLayerRoot('popup');
+    layerRoot.remove();
+    vi.unstubAllGlobals();
+});
+describe('MenuButton', () => {
+    it('renders the container label', () => {
+        cmp = mount(MenuButton, {
+            target: host,
+            props: {
+                container: { id: 'file', label: 'File' },
+                items: [],
+            },
+        });
+        expect(host.textContent).toContain('File');
+    });
+    it('renders icon before label when iconPosition is "before" (default)', () => {
+        cmp = mount(MenuButton, {
+            target: host,
+            props: {
+                container: { id: 'file', label: 'File', icon: 'folder' },
+                items: [],
+            },
+        });
+        const btn = host.querySelector('button');
+        const children = Array.from(btn.children);
+        const iconIdx = children.findIndex((c) => c.classList.contains('sh3-menubar-icon'));
+        const labelIdx = children.findIndex((c) => c.classList.contains('sh3-menubar-label'));
+        expect(iconIdx).toBeGreaterThanOrEqual(0);
+        expect(iconIdx).toBeLessThan(labelIdx);
+    });
+    it('renders icon after label when iconPosition is "after"', () => {
+        cmp = mount(MenuButton, {
+            target: host,
+            props: {
+                container: { id: 'file', label: 'File', icon: 'folder', iconPosition: 'after' },
+                items: [],
+            },
+        });
+        const btn = host.querySelector('button');
+        const children = Array.from(btn.children);
+        const iconIdx = children.findIndex((c) => c.classList.contains('sh3-menubar-icon'));
+        const labelIdx = children.findIndex((c) => c.classList.contains('sh3-menubar-label'));
+        expect(labelIdx).toBeLessThan(iconIdx);
+    });
+    it('clicking the button opens a popup with ActionPanel mounted', async () => {
+        cmp = mount(MenuButton, {
+            target: host,
+            props: {
+                container: { id: 'file', label: 'File' },
+                items: [
+                    { id: 'open', label: 'Open', shortcut: 'Ctrl+O', group: '', icon: undefined },
+                ],
+            },
+        });
+        await tick();
+        const btn = host.querySelector('button');
+        btn.click();
+        await tick();
+        const items = layerRoot.querySelectorAll('[role="menuitem"]');
+        expect(items.length).toBe(1);
+        expect(items[0].textContent).toContain('Open');
+    });
+});

package/dist/actions/defaultMenuContainers.d.ts

@@ -0,0 +1,2 @@
+import type { MenuContainer } from '../apps/types';
+export declare const DEFAULT_MENU_CONTAINERS: readonly MenuContainer[];

package/dist/actions/defaultMenuContainers.js

@@ -0,0 +1,7 @@
+export const DEFAULT_MENU_CONTAINERS = Object.freeze([
+    { id: 'file', label: 'File' },
+    { id: 'edit', label: 'Edit' },
+    { id: 'view', label: 'View' },
+    { id: 'window', label: 'Window' },
+    { id: 'help', label: 'Help' },
+]);

package/dist/actions/defaultMenuContainers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/actions/defaultMenuContainers.test.js

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import { DEFAULT_MENU_CONTAINERS } from './defaultMenuContainers';
+describe('DEFAULT_MENU_CONTAINERS', () => {
+    it('declares the canonical five containers in fixed order', () => {
+        expect(DEFAULT_MENU_CONTAINERS.map((c) => c.id))
+            .toEqual(['file', 'edit', 'view', 'window', 'help']);
+    });
+    it('declares matching labels', () => {
+        expect(DEFAULT_MENU_CONTAINERS.map((c) => c.label))
+            .toEqual(['File', 'Edit', 'View', 'Window', 'Help']);
+    });
+    it('declares no icons by default (text-only fallback)', () => {
+        for (const c of DEFAULT_MENU_CONTAINERS) {
+            expect(c.icon).toBeUndefined();
+        }
+    });
+    it('is frozen — mutating throws or is silently dropped', () => {
+        expect(() => {
+            // @ts-expect-error — testing runtime immutability of a readonly constant
+            DEFAULT_MENU_CONTAINERS.push({ id: 'x', label: 'X' });
+        }).toThrow();
+    });
+});

package/dist/actions/menuBarModel.d.ts

@@ -0,0 +1,28 @@
+import type { ActionEntry } from './registry';
+import type { DispatcherState } from './dispatcher.svelte';
+import type { MenuContainer } from '../apps/types';
+export interface MenuBarItem {
+    id: string;
+    label: string;
+    shortcut: string | null;
+    group: string;
+    icon: string | undefined;
+}
+/**
+ * Resolved container list for the currently-active app:
+ *   - activeAppId == null              → returns []
+ *   - declared has entries             → returns declared, sorted by `order`
+ *                                        ascending then declaration order
+ *                                        for ties / undefined
+ *   - declared is undefined            → returns a copy of DEFAULT_MENU_CONTAINERS
+ *
+ * Callers can render unconditionally; the empty-array case naturally
+ * suppresses the menu bar at home.
+ */
+export declare function resolveMenuContainers(activeAppId: string | null, declared: readonly MenuContainer[] | undefined): MenuContainer[];
+/**
+ * Items targeting `containerId`, filtered by current scope activation
+ * and de-duplicated to the innermost active scope per action id (mirrors
+ * contextMenuModel).
+ */
+export declare function resolveMenuItems(entries: readonly ActionEntry[], state: DispatcherState, containerId: string): MenuBarItem[];

package/dist/actions/menuBarModel.js

@@ -0,0 +1,67 @@
+/*
+ * Pure model layer for the menu bar: resolves container list for the
+ * active app, and resolves per-container item lists by filtering the
+ * action registry by `menuItem` + scope-activation. Mirrors the
+ * de-duplication semantics of contextMenuModel.
+ */
+import { effectiveShortcut } from './bindings';
+import { innermostActiveScope } from './scope-helpers';
+import { DEFAULT_MENU_CONTAINERS } from './defaultMenuContainers';
+/**
+ * Resolved container list for the currently-active app:
+ *   - activeAppId == null              → returns []
+ *   - declared has entries             → returns declared, sorted by `order`
+ *                                        ascending then declaration order
+ *                                        for ties / undefined
+ *   - declared is undefined            → returns a copy of DEFAULT_MENU_CONTAINERS
+ *
+ * Callers can render unconditionally; the empty-array case naturally
+ * suppresses the menu bar at home.
+ */
+export function resolveMenuContainers(activeAppId, declared) {
+    if (activeAppId == null)
+        return [];
+    if (declared == null)
+        return DEFAULT_MENU_CONTAINERS.slice();
+    const indexed = declared.map((c, i) => ({ c, i }));
+    indexed.sort((a, b) => {
+        const ao = a.c.order;
+        const bo = b.c.order;
+        if (ao != null && bo != null)
+            return ao - bo || a.i - b.i;
+        if (ao != null)
+            return -1;
+        if (bo != null)
+            return 1;
+        return a.i - b.i;
+    });
+    return indexed.map((x) => x.c);
+}
+/**
+ * Items targeting `containerId`, filtered by current scope activation
+ * and de-duplicated to the innermost active scope per action id (mirrors
+ * contextMenuModel).
+ */
+export function resolveMenuItems(entries, state, containerId) {
+    var _a;
+    const out = [];
+    const seen = new Set();
+    for (const entry of entries) {
+        if (entry.action.menuItem !== containerId)
+            continue;
+        if (seen.has(entry.action.id))
+            continue;
+        const winning = innermostActiveScope(entry.action.scope, state, entry.ownerShardId);
+        if (!winning)
+            continue;
+        seen.add(entry.action.id);
+        out.push({
+            id: entry.action.id,
+            label: entry.action.label,
+            shortcut: effectiveShortcut(entry.action, state.bindings, state.platform),
+            group: (_a = entry.action.group) !== null && _a !== void 0 ? _a : '',
+            icon: entry.action.icon,
+        });
+    }
+    return out;
+}

package/dist/actions/menuBarModel.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/actions/menuBarModel.test.js

@@ -0,0 +1,84 @@
+import { describe, it, expect } from 'vitest';
+import { resolveMenuContainers, resolveMenuItems, } from './menuBarModel';
+const mkEntry = (a, owner = 'shard.x') => ({
+    ownerShardId: owner,
+    action: Object.assign({ id: 'a', label: 'A', scope: 'home', run: () => { } }, a),
+});
+const mkState = (o = {}) => (Object.assign({ activeAppId: null, activeAppRequiredShards: new Set(), autostartShards: new Set(), mountedViewIds: new Set(), focusedViewId: null, selection: null, bindings: {}, platform: 'other' }, o));
+describe('resolveMenuContainers', () => {
+    it('returns [] when no app is active', () => {
+        expect(resolveMenuContainers(null, undefined)).toEqual([]);
+    });
+    it('returns DEFAULT_MENU_CONTAINERS when app has no manifest.menus', () => {
+        const out = resolveMenuContainers('app.a', undefined);
+        expect(out.map((c) => c.id)).toEqual(['file', 'edit', 'view', 'window', 'help']);
+    });
+    it('returns manifest.menus when declared', () => {
+        const declared = [
+            { id: 'project', label: 'Project' },
+            { id: 'help', label: 'Help' },
+        ];
+        expect(resolveMenuContainers('app.a', declared).map((c) => c.id))
+            .toEqual(['project', 'help']);
+    });
+    it('sorts by `order` ascending, then by declaration order for ties/undefined', () => {
+        const declared = [
+            { id: 'a', label: 'A', order: 10 },
+            { id: 'b', label: 'B' },
+            { id: 'c', label: 'C', order: 5 },
+            { id: 'd', label: 'D' },
+        ];
+        expect(resolveMenuContainers('app.a', declared).map((c) => c.id))
+            .toEqual(['c', 'a', 'b', 'd']);
+    });
+});
+describe('resolveMenuItems', () => {
+    const stateWithApp = mkState({
+        activeAppId: 'app.a',
+        activeAppRequiredShards: new Set(['shard.x']),
+    });
+    it('returns only actions whose menuItem matches the container id', () => {
+        const entries = [
+            mkEntry({ id: 'open', scope: 'app', menuItem: 'file', label: 'Open' }),
+            mkEntry({ id: 'copy', scope: 'app', menuItem: 'edit', label: 'Copy' }),
+            mkEntry({ id: 'close', scope: 'app', menuItem: 'file', label: 'Close' }),
+        ];
+        const out = resolveMenuItems(entries, stateWithApp, 'file');
+        expect(out.map((i) => i.id)).toEqual(['open', 'close']);
+    });
+    it('skips actions whose scope is not currently active', () => {
+        const entries = [
+            mkEntry({ id: 'open', scope: 'app', menuItem: 'file', label: 'Open' }),
+            mkEntry({ id: 'help', scope: 'home', menuItem: 'file', label: 'Help' }),
+        ];
+        const out = resolveMenuItems(entries, stateWithApp, 'file');
+        expect(out.map((i) => i.id)).toEqual(['open']);
+    });
+    it('skips actions without a menuItem field', () => {
+        const entries = [
+            mkEntry({ id: 'a', scope: 'app', menuItem: 'file', label: 'A' }),
+            mkEntry({ id: 'b', scope: 'app', label: 'B' }),
+        ];
+        const out = resolveMenuItems(entries, stateWithApp, 'file');
+        expect(out.map((i) => i.id)).toEqual(['a']);
+    });
+    it('returns [] for an unknown container id', () => {
+        const entries = [
+            mkEntry({ id: 'open', scope: 'app', menuItem: 'file', label: 'Open' }),
+        ];
+        expect(resolveMenuItems(entries, stateWithApp, 'sausage')).toEqual([]);
+    });
+    it('de-duplicates multi-scope actions by innermost active scope', () => {
+        const state = mkState({
+            activeAppId: 'app.a',
+            activeAppRequiredShards: new Set(['shard.x']),
+            autostartShards: new Set(['shard.x']),
+        });
+        const entries = [
+            mkEntry({ id: 'p', scope: ['home', 'app'], menuItem: 'file', label: 'P' }),
+        ];
+        const out = resolveMenuItems(entries, state, 'file');
+        expect(out).toHaveLength(1);
+        expect(out[0].id).toBe('p');
+    });
+});

package/dist/actions/types.d.ts

@@ -8,6 +8,14 @@ export interface Action {
     scope: ActionScope;
     contextItem?: boolean;
     paletteItem?: boolean;
+    /**
+     * Optional menu container id. When set and the active app's declared
+     * (or canonical fallback) menu list contains this id, the action
+     * appears in that container's dropdown. Orphaned values render
+     * nowhere in the menu bar; the action remains reachable via
+     * palette/hotkey/context menu.
+     */
+    menuItem?: string;
     defaultShortcut?: string;
     icon?: string;
     group?: string;

package/dist/apps/lifecycle.js

@@ -14,7 +14,7 @@
 import { createStateZones } from '../state/zones.svelte';
 import { activateShard, deactivateShard, getShardContext, registeredShards, } from '../shards/activate.svelte';
 import { attachApp, acquireAppSlotHolds, detachApp, switchToApp, switchToHome, } from '../layout/store.svelte';
-import { activeApp, getRegisteredApp, registeredApps } from './registry.svelte';
+import { activeApp, breadcrumbApp, getRegisteredApp, registeredApps } from './registry.svelte';
 import { createZoneManager } from '../state/manage';
 import { PERMISSION_STATE_MANAGE } from '../state/types';
 import { setActiveApp, setUserBindings } from '../actions/state.svelte';
@@ -96,6 +96,7 @@ export async function launchApp(id) {
         switchToApp();
         void ((_c = app.onAppReady) === null || _c === void 0 ? void 0 : _c.call(app, getOrCreateAppContext(id)));
         writeLastApp(id);
+        breadcrumbApp.id = id;
         setActiveApp(id, new Set((_d = app.manifest.requiredShards) !== null && _d !== void 0 ? _d : []));
         void loadUserBindings(id).then(setUserBindings);
         return;
@@ -135,6 +136,7 @@ export async function launchApp(id) {
     switchToApp();
     void ((_g = app.onAppReady) === null || _g === void 0 ? void 0 : _g.call(app, getOrCreateAppContext(id)));
     writeLastApp(id);
+    breadcrumbApp.id = id;
 }
 // ---------- unload --------------------------------------------------------
 /**
@@ -226,6 +228,11 @@ export async function returnToHome() {
             return false;
     }
     switchToHome();
+    // Mirror unregisterApp: clear the dispatcher's active-app pointer so
+    // 'app'-scope actions become inactive on home. Without this, any action
+    // registered with scope: ['app'] keeps appearing in the palette while
+    // the user is on home.
+    setActiveApp(null, new Set());
     writeLastApp(null);
     return true;
 }