@happyvertical/smrt-svelte 0.55.7 → 0.55.9

package/dist/components/command-palette/controller.svelte.js

@@ -0,0 +1,379 @@
+/**
+ * Command palette state: provider registry, open/query state, local and
+ * remote results, and keyboard selection. Components render this; assistants
+ * and tests can drive it directly.
+ */
+import { logger } from '../../internal/logger.js';
+import { buildPaletteSections, flattenSections, orderProviders, } from './rank.js';
+function isThenable(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.then === 'function');
+}
+export class CommandPaletteController {
+    #options;
+    #providers = $state.raw([]);
+    #local = $state.raw({});
+    #remote = $state.raw({});
+    #failed = $state.raw(new Set());
+    #itemsPending = $state(0);
+    #searchPending = $state(0);
+    #searchRun = 0;
+    #activeKey = $state(null);
+    #open = $state(false);
+    #query = $state('');
+    #itemsAbort = null;
+    #searchAbort = null;
+    #searchTimer = null;
+    #generation = 0;
+    constructor(options = {}) {
+        this.#options = options;
+        this.#providers = [...(options.providers ?? [])];
+    }
+    /** Whether the palette is showing. */
+    get isOpen() {
+        return this.#open;
+    }
+    /** The text in the search box. */
+    get query() {
+        return this.#query;
+    }
+    /** Registered providers, in registration order. */
+    get providers() {
+        return this.#providers;
+    }
+    /** Whether any provider is still loading or searching. */
+    get busy() {
+        return this.#itemsPending + this.#searchPending > 0;
+    }
+    /** Ids of providers whose last load or search failed. */
+    get failedProviders() {
+        return this.#failed;
+    }
+    /** Grouped, ranked rows for the current query. */
+    sections = $derived.by(() => buildPaletteSections({
+        providers: this.#providers,
+        local: this.#local,
+        remote: this.#remote,
+        query: this.#query,
+        maxPerGroup: this.#options.maxPerGroup,
+    }));
+    /** The rows in display order. */
+    results = $derived(flattenSections(this.sections));
+    /** The highlighted row: the chosen one, else the first selectable row. */
+    active = $derived.by(() => {
+        const chosen = this.results.find((result) => result.key === this.#activeKey && result.selectable);
+        return chosen ?? this.results.find((result) => result.selectable) ?? null;
+    });
+    /**
+     * Register a provider; returns its disposer. Registering an id again
+     * replaces the earlier provider in place (so a re-rendering component does
+     * not stack duplicates); the disposer of a replaced registration is a no-op.
+     */
+    registerProvider(provider) {
+        const existing = this.#providers.findIndex((p) => p.id === provider.id);
+        if (existing === -1) {
+            this.#providers = [...this.#providers, provider];
+        }
+        else {
+            const replaced = this.#providers[existing];
+            this.#providers = this.#providers.map((p, index) => index === existing ? provider : p);
+            // The replaced provider's rows (and any in-flight results, dropped by
+            // the registration check) must not outlive it.
+            this.#local = omit(this.#local, replaced.id);
+            this.#remote = omit(this.#remote, replaced.id);
+            this.#markFailed(replaced.id, false);
+        }
+        if (this.#open) {
+            void this.#loadProvider(provider, this.#itemsSignal());
+            if (this.#query.trim())
+                this.#scheduleSearch(0);
+        }
+        return () => {
+            if (!this.#providers.includes(provider))
+                return;
+            this.#providers = this.#providers.filter((p) => p !== provider);
+            this.#local = omit(this.#local, provider.id);
+            this.#remote = omit(this.#remote, provider.id);
+        };
+    }
+    /** Show the palette with an empty query. */
+    open() {
+        if (this.#open)
+            return;
+        this.#open = true;
+        this.#query = '';
+        this.#activeKey = null;
+        this.#remote = {};
+        this.#failed = new Set();
+        this.#generation += 1;
+        this.#itemsAbort?.abort();
+        this.#itemsAbort = new AbortController();
+        for (const provider of orderProviders(this.#providers)) {
+            void this.#loadProvider(provider, this.#itemsAbort.signal);
+        }
+    }
+    /** Hide the palette and cancel work in flight. */
+    close() {
+        if (!this.#open)
+            return;
+        this.#open = false;
+        this.#query = '';
+        this.#activeKey = null;
+        this.#generation += 1;
+        this.#cancelSearch();
+        this.#itemsAbort?.abort();
+        this.#itemsAbort = null;
+        this.#itemsPending = 0;
+        this.#searchPending = 0;
+        this.#remote = {};
+    }
+    toggle() {
+        if (this.#open)
+            this.close();
+        else
+            this.open();
+    }
+    /** Set the search text; local rows update at once, `search` providers after a pause. */
+    setQuery(query) {
+        if (query === this.#query)
+            return;
+        this.#query = query;
+        this.#activeKey = null;
+        this.#scheduleSearch(this.#options.searchDebounceMs ?? 150);
+    }
+    /** Move the highlight by `delta` rows among selectable ones, wrapping. */
+    moveActive(delta) {
+        const selectable = this.results.filter((result) => result.selectable);
+        if (selectable.length === 0)
+            return;
+        const current = this.active
+            ? selectable.findIndex((result) => result.key === this.active?.key)
+            : -1;
+        const next = current === -1
+            ? delta > 0
+                ? 0
+                : selectable.length - 1
+            : (((current + delta) % selectable.length) + selectable.length) %
+                selectable.length;
+        this.#activeKey = selectable[next].key;
+    }
+    /** Move the highlight to the first or last selectable row. */
+    moveActiveTo(edge) {
+        const selectable = this.results.filter((result) => result.selectable);
+        if (selectable.length === 0)
+            return;
+        this.#activeKey = (edge === 'first' ? selectable[0] : selectable[selectable.length - 1]).key;
+    }
+    /** Highlight a specific row (pointer hover). */
+    setActive(key) {
+        const result = this.results.find((candidate) => candidate.key === key);
+        if (result?.selectable)
+            this.#activeKey = key;
+    }
+    /**
+     * Choose a row (default: the highlighted one): closes the palette, then runs
+     * the item or navigates to its `href`. Resolves once that has finished.
+     */
+    async activate(result = this.active) {
+        if (!result?.selectable)
+            return;
+        const { item, providerId } = result;
+        const query = this.#query;
+        this.close();
+        try {
+            if (item.run) {
+                await item.run({
+                    query,
+                    providerId,
+                    navigate: (href) => this.navigate(href, item),
+                });
+            }
+            else if (item.href) {
+                await this.navigate(item.href, item);
+            }
+        }
+        catch (error) {
+            this.#report(error, { providerId, phase: 'run', item });
+        }
+    }
+    /** Go to `href` with the host's `navigate` seam. */
+    navigate(href, item) {
+        if (this.#options.navigate)
+            return this.#options.navigate(href, item);
+        if (typeof window !== 'undefined')
+            window.location.assign(href);
+    }
+    /** Cancel timers and requests; call when the owner is destroyed. */
+    destroy() {
+        this.#open = false;
+        this.#generation += 1;
+        this.#cancelSearch();
+        this.#itemsAbort?.abort();
+        this.#itemsAbort = null;
+    }
+    #itemsSignal() {
+        if (!this.#itemsAbort)
+            this.#itemsAbort = new AbortController();
+        return this.#itemsAbort.signal;
+    }
+    #report(error, context) {
+        if (this.#options.onError) {
+            this.#options.onError(error, context);
+            return;
+        }
+        logger.warn('[smrt-svelte] command palette provider failed', {
+            ...context,
+            item: context.item?.id,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+    #markFailed(providerId, failed) {
+        if (this.#failed.has(providerId) === failed)
+            return;
+        const next = new Set(this.#failed);
+        if (failed)
+            next.add(providerId);
+        else
+            next.delete(providerId);
+        this.#failed = next;
+    }
+    /** Read a provider's `items`; sync results land immediately. */
+    #loadProvider(provider, signal) {
+        if (!provider.items)
+            return Promise.resolve();
+        const generation = this.#generation;
+        // A replaced or removed registration must not land late results.
+        const current = () => generation === this.#generation &&
+            !signal.aborted &&
+            this.#providers.includes(provider);
+        const accept = (items) => {
+            if (!current())
+                return;
+            this.#local = { ...this.#local, [provider.id]: items };
+            this.#markFailed(provider.id, false);
+        };
+        let outcome;
+        try {
+            outcome = provider.items({ signal });
+        }
+        catch (error) {
+            this.#markFailed(provider.id, true);
+            this.#report(error, { providerId: provider.id, phase: 'items' });
+            return Promise.resolve();
+        }
+        if (!isThenable(outcome)) {
+            accept(outcome);
+            return Promise.resolve();
+        }
+        this.#itemsPending += 1;
+        const settle = () => {
+            // A close or reopen already reset the count for this generation.
+            if (generation === this.#generation) {
+                this.#itemsPending = Math.max(0, this.#itemsPending - 1);
+            }
+        };
+        return Promise.resolve(outcome).then((items) => {
+            settle();
+            accept(items);
+        }, (error) => {
+            settle();
+            if (!current())
+                return;
+            this.#markFailed(provider.id, true);
+            this.#report(error, { providerId: provider.id, phase: 'items' });
+        });
+    }
+    #cancelSearch() {
+        if (this.#searchTimer)
+            clearTimeout(this.#searchTimer);
+        this.#searchTimer = null;
+        this.#searchAbort?.abort();
+        this.#searchAbort = null;
+        this.#searchRun += 1;
+        this.#searchPending = 0;
+    }
+    #scheduleSearch(delayMs) {
+        if (this.#searchTimer)
+            clearTimeout(this.#searchTimer);
+        this.#searchTimer = null;
+        this.#searchAbort?.abort();
+        this.#searchAbort = null;
+        this.#searchRun += 1;
+        this.#searchPending = 0;
+        const query = this.#query.trim();
+        if (query.length === 0) {
+            this.#remote = {};
+            return;
+        }
+        if (!this.#open)
+            return;
+        this.#searchTimer = setTimeout(() => {
+            this.#searchTimer = null;
+            this.#runSearch(query);
+        }, delayMs);
+    }
+    #runSearch(query) {
+        const generation = this.#generation;
+        const controller = new AbortController();
+        this.#searchAbort = controller;
+        const run = ++this.#searchRun;
+        this.#searchPending = 0;
+        const stale = (provider) => generation !== this.#generation ||
+            controller.signal.aborted ||
+            !this.#providers.includes(provider);
+        const settle = () => {
+            if (run === this.#searchRun) {
+                this.#searchPending = Math.max(0, this.#searchPending - 1);
+            }
+        };
+        for (const provider of this.#providers) {
+            if (!provider.search)
+                continue;
+            if (query.length < (provider.minQueryLength ?? 2)) {
+                // Too short for this provider: drop what an earlier, longer query left.
+                if (this.#remote[provider.id]) {
+                    this.#remote = omit(this.#remote, provider.id);
+                }
+                continue;
+            }
+            const limit = provider.limit ?? this.#options.maxPerGroup ?? 8;
+            let outcome;
+            try {
+                outcome = provider.search(query, { signal: controller.signal, limit });
+            }
+            catch (error) {
+                this.#markFailed(provider.id, true);
+                this.#report(error, { providerId: provider.id, phase: 'search' });
+                continue;
+            }
+            // Earlier rows stay until these arrive, so a keystroke does not blank
+            // the list; they are replaced (or cleared on failure) below.
+            this.#searchPending += 1;
+            Promise.resolve(outcome).then((items) => {
+                settle();
+                if (stale(provider))
+                    return;
+                this.#remote = { ...this.#remote, [provider.id]: items };
+                this.#markFailed(provider.id, false);
+            }, (error) => {
+                settle();
+                if (stale(provider))
+                    return;
+                this.#remote = omit(this.#remote, provider.id);
+                this.#markFailed(provider.id, true);
+                this.#report(error, { providerId: provider.id, phase: 'search' });
+            });
+        }
+    }
+}
+function omit(record, key) {
+    if (!(key in record))
+        return record;
+    const { [key]: _removed, ...rest } = record;
+    return rest;
+}
+/** Create a palette controller. */
+export function createCommandPalette(options = {}) {
+    return new CommandPaletteController(options);
+}

package/dist/components/command-palette/hotkeys.d.ts

@@ -0,0 +1,30 @@
+/** Parsed hotkey. */
+export interface PaletteHotkey {
+    /** Lower-cased `KeyboardEvent.key`, e.g. `k` or `/`. */
+    key: string;
+    /** Control or Meta. */
+    mod: boolean;
+    ctrl: boolean;
+    meta: boolean;
+    alt: boolean;
+    shift: boolean;
+}
+/** The palette's default shortcut. */
+export declare const DEFAULT_PALETTE_HOTKEYS: readonly string[];
+/** Parse `"Mod+K"`; null when the spec has no key. */
+export declare function parsePaletteHotkey(spec: string): PaletteHotkey | null;
+/** Whether `event` is the hotkey (modifiers must match exactly). */
+export declare function matchesPaletteHotkey(hotkey: PaletteHotkey, event: KeyboardEvent): boolean;
+/**
+ * Whether `event` should open the palette: it matches one of `hotkeys`, is
+ * not part of an IME composition, was not already handled, and (for a bare
+ * key) is not going to a text field.
+ */
+export declare function isPaletteHotkeyEvent(event: KeyboardEvent, hotkeys: readonly PaletteHotkey[]): boolean;
+/** Whether the platform shows the command key as a symbol (Apple devices). */
+export declare function isApplePlatform(): boolean;
+/** Display text for a hotkey: `⌘K` on Apple devices, `Ctrl+K` elsewhere. */
+export declare function formatPaletteHotkey(spec: string | PaletteHotkey, apple?: boolean): string;
+/** The `aria-keyshortcuts` value for specs: `Mod+K` -> `Control+K Meta+K`. */
+export declare function ariaKeyShortcuts(specs: readonly string[]): string | undefined;
+//# sourceMappingURL=hotkeys.d.ts.map

package/dist/components/command-palette/hotkeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotkeys.d.ts","sourceRoot":"","sources":["../../../src/components/command-palette/hotkeys.ts"],"names":[],"mappings":"AAWA,qBAAqB;AACrB,MAAM,WAAW,aAAa;IAC5B,wDAAwD;IACxD,GAAG,EAAE,MAAM,CAAC;IACZ,uBAAuB;IACvB,GAAG,EAAE,OAAO,CAAC;IACb,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;IACd,GAAG,EAAE,OAAO,CAAC;IACb,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,sCAAsC;AACtC,eAAO,MAAM,uBAAuB,EAAE,SAAS,MAAM,EAAc,CAAC;AAEpE,sDAAsD;AACtD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CA0CrE;AAWD,oEAAoE;AACpE,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,aAAa,GACnB,OAAO,CAaT;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,SAAS,aAAa,EAAE,GAChC,OAAO,CAST;AAED,8EAA8E;AAC9E,wBAAgB,eAAe,IAAI,OAAO,CAOzC;AAED,4EAA4E;AAC5E,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,GAAG,aAAa,EAC5B,KAAK,GAAE,OAA2B,GACjC,MAAM,CAqBR;AAED,8EAA8E;AAC9E,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CA2B7E"}

package/dist/components/command-palette/hotkeys.js

@@ -0,0 +1,161 @@
+/**
+ * Hotkey specs for the command palette: `"Mod+K"`, `"Ctrl+Shift+P"`, `"/"`.
+ *
+ * `Mod` is the platform command key: either Control or Meta matches, so
+ * Cmd+K on macOS and Ctrl+K elsewhere (and an external keyboard on either)
+ * all work. A spec with no modifier (`"/"`) never fires while the user is
+ * typing in a field; a spec with a modifier fires anywhere, because Ctrl/Cmd+K
+ * is not a character a field could be waiting for.
+ */
+import { isEditableTarget } from '../workspace/admin-shell/hotkeys.js';
+/** The palette's default shortcut. */
+export const DEFAULT_PALETTE_HOTKEYS = ['Mod+K'];
+/** Parse `"Mod+K"`; null when the spec has no key. */
+export function parsePaletteHotkey(spec) {
+    const parts = spec
+        .split('+')
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0);
+    // "Mod++" would mean Mod and "+", which no palette needs: drop empties.
+    const key = parts.pop();
+    if (!key)
+        return null;
+    const hotkey = {
+        key: key.toLowerCase(),
+        mod: false,
+        ctrl: false,
+        meta: false,
+        alt: false,
+        shift: false,
+    };
+    for (const part of parts) {
+        switch (part.toLowerCase()) {
+            case 'mod':
+                hotkey.mod = true;
+                break;
+            case 'ctrl':
+            case 'control':
+                hotkey.ctrl = true;
+                break;
+            case 'meta':
+            case 'cmd':
+            case 'command':
+                hotkey.meta = true;
+                break;
+            case 'alt':
+            case 'option':
+                hotkey.alt = true;
+                break;
+            case 'shift':
+                hotkey.shift = true;
+                break;
+            default:
+                return null;
+        }
+    }
+    return hotkey;
+}
+function keyMatches(hotkey, event) {
+    if (event.key.toLowerCase() === hotkey.key)
+        return true;
+    // A letter on a non-Latin layout or with Alt held still has its physical key.
+    return (/^[a-z]$/.test(hotkey.key) &&
+        event.code === `Key${hotkey.key.toUpperCase()}`);
+}
+/** Whether `event` is the hotkey (modifiers must match exactly). */
+export function matchesPaletteHotkey(hotkey, event) {
+    if (!keyMatches(hotkey, event))
+        return false;
+    if (hotkey.mod) {
+        if (!(event.ctrlKey || event.metaKey))
+            return false;
+    }
+    else if (event.ctrlKey !== hotkey.ctrl || event.metaKey !== hotkey.meta) {
+        return false;
+    }
+    if (event.altKey !== hotkey.alt)
+        return false;
+    // A bare symbol such as "/" or "?" may need Shift on some layouts.
+    const symbol = !/^[a-z0-9]$/.test(hotkey.key);
+    const modified = hotkey.mod || hotkey.ctrl || hotkey.meta || hotkey.alt;
+    if (symbol && !modified && !hotkey.shift)
+        return true;
+    return event.shiftKey === hotkey.shift;
+}
+/**
+ * Whether `event` should open the palette: it matches one of `hotkeys`, is
+ * not part of an IME composition, was not already handled, and (for a bare
+ * key) is not going to a text field.
+ */
+export function isPaletteHotkeyEvent(event, hotkeys) {
+    if (event.isComposing || event.defaultPrevented || event.repeat)
+        return false;
+    for (const hotkey of hotkeys) {
+        if (!matchesPaletteHotkey(hotkey, event))
+            continue;
+        const modified = hotkey.mod || hotkey.ctrl || hotkey.meta || hotkey.alt;
+        if (!modified && isEditableTarget(event.target))
+            continue;
+        return true;
+    }
+    return false;
+}
+/** Whether the platform shows the command key as a symbol (Apple devices). */
+export function isApplePlatform() {
+    if (typeof navigator === 'undefined')
+        return false;
+    const nav = navigator;
+    const platform = nav.userAgentData?.platform ?? nav.platform ?? '';
+    return /mac|iphone|ipad|ipod/i.test(platform);
+}
+/** Display text for a hotkey: `⌘K` on Apple devices, `Ctrl+K` elsewhere. */
+export function formatPaletteHotkey(spec, apple = isApplePlatform()) {
+    const hotkey = typeof spec === 'string' ? parsePaletteHotkey(spec) : spec;
+    if (!hotkey)
+        return typeof spec === 'string' ? spec : '';
+    const key = hotkey.key.length === 1 ? hotkey.key.toUpperCase() : hotkey.key;
+    if (apple) {
+        return ((hotkey.ctrl ? '⌃' : '') +
+            (hotkey.alt ? '⌥' : '') +
+            (hotkey.shift ? '⇧' : '') +
+            (hotkey.mod || hotkey.meta ? '⌘' : '') +
+            key);
+    }
+    const parts = [
+        hotkey.mod || hotkey.ctrl ? 'Ctrl' : '',
+        hotkey.meta ? 'Meta' : '',
+        hotkey.alt ? 'Alt' : '',
+        hotkey.shift ? 'Shift' : '',
+        key,
+    ].filter(Boolean);
+    return parts.join('+');
+}
+/** The `aria-keyshortcuts` value for specs: `Mod+K` -> `Control+K Meta+K`. */
+export function ariaKeyShortcuts(specs) {
+    const out = [];
+    for (const spec of specs) {
+        const hotkey = parsePaletteHotkey(spec);
+        if (!hotkey)
+            continue;
+        const key = hotkey.key.length === 1 ? hotkey.key.toUpperCase() : hotkey.key;
+        const shared = [
+            hotkey.alt ? 'Alt' : '',
+            hotkey.shift ? 'Shift' : '',
+        ].filter(Boolean);
+        if (hotkey.mod) {
+            out.push([...shared, 'Control', key].join('+'));
+            out.push([...shared, 'Meta', key].join('+'));
+        }
+        else {
+            out.push([
+                hotkey.ctrl ? 'Control' : '',
+                hotkey.meta ? 'Meta' : '',
+                ...shared,
+                key,
+            ]
+                .filter(Boolean)
+                .join('+'));
+        }
+    }
+    return out.length > 0 ? out.join(' ') : undefined;
+}

package/dist/components/command-palette/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @happyvertical/smrt-svelte/command-palette
+ *
+ * Global search and command palette (#3713): a shell-slot trigger, a modal
+ * palette, a provider contract, and providers derived from the shell nav and
+ * the SMRT manifest.
+ */
+export { default as CommandPalette } from './CommandPalette.svelte';
+export { default as CommandPaletteDialog } from './CommandPaletteDialog.svelte';
+export { default as CommandPaletteTrigger } from './CommandPaletteTrigger.svelte';
+export { COMMAND_PALETTE_CONTEXT, setCommandPalette, tryUseCommandPalette, useCommandPalette, } from './context.js';
+export { CommandPaletteController, type CommandPaletteOptions, createCommandPalette, } from './controller.svelte.js';
+export { ariaKeyShortcuts, DEFAULT_PALETTE_HOTKEYS, formatPaletteHotkey, isApplePlatform, isPaletteHotkeyEvent, matchesPaletteHotkey, type PaletteHotkey, parsePaletteHotkey, } from './hotkeys.js';
+export { highlightSegments, type ItemMatch, matchItem, matchText, type TextMatch, } from './match.js';
+export { createModelProviders, createNavigationProvider, type ModelProvidersOptions, type NavigationProviderOptions, type PaletteManifestEntryLike, type PaletteManifestFieldLike, type PaletteManifestLike, type PaletteModel, type PaletteRecordRow, type PaletteRecordSearch, paletteModelsFromManifest, } from './providers.js';
+export { buildPaletteSections, DEFAULT_MAX_PER_GROUP, flattenSections, orderProviders, type RankInput, } from './rank.js';
+export type { MatchRange, PaletteErrorContext, PaletteItem, PaletteItemKind, PaletteItemsContext, PaletteProvider, PaletteResult, PaletteRunContext, PaletteSearchContext, PaletteSection, } from './types.js';
+export { useCommandPaletteProvider } from './use-provider.svelte.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/command-palette/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/command-palette/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAChF,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAClF,OAAO,EACL,uBAAuB,EACvB,iBAAiB,EACjB,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,wBAAwB,EACxB,KAAK,qBAAqB,EAC1B,oBAAoB,GACrB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,gBAAgB,EAChB,uBAAuB,EACvB,mBAAmB,EACnB,eAAe,EACf,oBAAoB,EACpB,oBAAoB,EACpB,KAAK,aAAa,EAClB,kBAAkB,GACnB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,iBAAiB,EACjB,KAAK,SAAS,EACd,SAAS,EACT,SAAS,EACT,KAAK,SAAS,GACf,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,oBAAoB,EACpB,wBAAwB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACxB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,yBAAyB,GAC1B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,eAAe,EACf,cAAc,EACd,KAAK,SAAS,GACf,MAAM,WAAW,CAAC;AACnB,YAAY,EACV,UAAU,EACV,mBAAmB,EACnB,WAAW,EACX,eAAe,EACf,mBAAmB,EACnB,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,oBAAoB,EACpB,cAAc,GACf,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/components/command-palette/index.js

@@ -0,0 +1,17 @@
+/**
+ * @happyvertical/smrt-svelte/command-palette
+ *
+ * Global search and command palette (#3713): a shell-slot trigger, a modal
+ * palette, a provider contract, and providers derived from the shell nav and
+ * the SMRT manifest.
+ */
+export { default as CommandPalette } from './CommandPalette.svelte';
+export { default as CommandPaletteDialog } from './CommandPaletteDialog.svelte';
+export { default as CommandPaletteTrigger } from './CommandPaletteTrigger.svelte';
+export { COMMAND_PALETTE_CONTEXT, setCommandPalette, tryUseCommandPalette, useCommandPalette, } from './context.js';
+export { CommandPaletteController, createCommandPalette, } from './controller.svelte.js';
+export { ariaKeyShortcuts, DEFAULT_PALETTE_HOTKEYS, formatPaletteHotkey, isApplePlatform, isPaletteHotkeyEvent, matchesPaletteHotkey, parsePaletteHotkey, } from './hotkeys.js';
+export { highlightSegments, matchItem, matchText, } from './match.js';
+export { createModelProviders, createNavigationProvider, paletteModelsFromManifest, } from './providers.js';
+export { buildPaletteSections, DEFAULT_MAX_PER_GROUP, flattenSections, orderProviders, } from './rank.js';
+export { useCommandPaletteProvider } from './use-provider.svelte.js';

package/dist/components/command-palette/match.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Text matching for the command palette: accent- and case-insensitive,
+ * multi-term, with word-start and in-order (fuzzy) matches, and the matched
+ * ranges of the original text for highlighting. Pure; no DOM, no Svelte.
+ */
+import type { MatchRange, PaletteItem } from './types.js';
+/** Lower-case and strip accents; the form both sides of a match are compared in. */
+export declare function foldForMatch(source: string): string;
+/** Split a query into its terms (whitespace separated, folded, de-duplicated). */
+export declare function queryTerms(query: string): string[];
+/** Result of matching a query against one text. */
+export interface TextMatch {
+    score: number;
+    /** Ranges of the original text that matched. */
+    ranges: MatchRange[];
+}
+/**
+ * Match every term of `query` against `text`. All terms must match somewhere
+ * (a missing term is no match). An empty query matches everything with score 0.
+ */
+export declare function matchText(query: string, text: string): TextMatch | null;
+/** Result of matching a query against a palette item. */
+export interface ItemMatch {
+    score: number;
+    /** Ranges of `item.title` that matched. */
+    titleRanges: MatchRange[];
+}
+/**
+ * Match `query` against an item's title (full weight), and its subtitle and
+ * keywords (half weight). Each term may match any of them; all must match.
+ */
+export declare function matchItem(query: string, item: PaletteItem): ItemMatch | null;
+/** Split `text` into alternating plain and matched segments for rendering. */
+export declare function highlightSegments(text: string, ranges: readonly MatchRange[]): Array<{
+    text: string;
+    match: boolean;
+}>;
+//# sourceMappingURL=match.d.ts.map

package/dist/components/command-palette/match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"match.d.ts","sourceRoot":"","sources":["../../../src/components/command-palette/match.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAmC1D,oFAAoF;AACpF,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,kFAAkF;AAClF,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAKlD;AA0ED,mDAAmD;AACnD,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,MAAM,EAAE,UAAU,EAAE,CAAC;CACtB;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAkBvE;AAED,yDAAyD;AACzD,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,2CAA2C;IAC3C,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI,CA2B5E;AAED,8EAA8E;AAC9E,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,SAAS,UAAU,EAAE,GAC5B,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC,CAgBzC"}