@happyvertical/smrt-svelte 0.55.7 → 0.55.9

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

@@ -0,0 +1,172 @@
+const MARKS = /\p{M}/gu;
+/** Fold one code point; may yield 0..n characters (marks vanish, `İ` splits). */
+function foldChar(char) {
+    return char.normalize('NFD').replace(MARKS, '').toLowerCase();
+}
+function fold(source) {
+    let text = '';
+    const origin = [];
+    const originEnd = [];
+    let index = 0;
+    for (const char of source) {
+        const folded = foldChar(char);
+        for (let i = 0; i < folded.length; i += 1) {
+            origin.push(index);
+            originEnd.push(index + char.length);
+        }
+        text += folded;
+        index += char.length;
+    }
+    return { text, origin, originEnd };
+}
+/** Lower-case and strip accents; the form both sides of a match are compared in. */
+export function foldForMatch(source) {
+    return fold(source).text;
+}
+/** Split a query into its terms (whitespace separated, folded, de-duplicated). */
+export function queryTerms(query) {
+    const terms = foldForMatch(query)
+        .split(/\s+/)
+        .filter((term) => term.length > 0);
+    return [...new Set(terms)];
+}
+const WORD_CHAR = /[\p{L}\p{N}]/u;
+function isWordChar(char) {
+    return char !== undefined && WORD_CHAR.test(char);
+}
+/** Best match of one term in folded text, or null. */
+function matchTerm(term, text) {
+    let best = null;
+    let at = text.indexOf(term);
+    while (at !== -1) {
+        const wordStart = at === 0 || !isWordChar(text[at - 1]);
+        const score = wordStart ? (at === 0 ? 150 : 100) : 60;
+        if (!best || score > best.score) {
+            best = { score, ranges: [[at, at + term.length]] };
+        }
+        at = text.indexOf(term, at + 1);
+    }
+    if (best)
+        return best;
+    // In-order subsequence ("nwinv" -> "New Invoice"), compact spans only so
+    // short terms do not match everything.
+    if (term.length < 2)
+        return null;
+    const hits = [];
+    let cursor = 0;
+    for (const char of term) {
+        const found = text.indexOf(char, cursor);
+        if (found === -1)
+            return null;
+        hits.push(found);
+        cursor = found + 1;
+    }
+    const span = hits[hits.length - 1] - hits[0] + 1;
+    if (span > term.length * 4)
+        return null;
+    const ranges = [];
+    for (const hit of hits) {
+        const last = ranges[ranges.length - 1];
+        if (last && last[1] === hit)
+            last[1] = hit + 1;
+        else
+            ranges.push([hit, hit + 1]);
+    }
+    const startsWord = hits[0] === 0 || !isWordChar(text[hits[0] - 1]);
+    return {
+        score: Math.max(5, 30 - (span - term.length) + (startsWord ? 10 : 0)),
+        ranges,
+    };
+}
+function mergeRanges(ranges) {
+    const sorted = [...ranges].sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+    const merged = [];
+    for (const range of sorted) {
+        const last = merged[merged.length - 1];
+        if (last && range[0] <= last[1])
+            last[1] = Math.max(last[1], range[1]);
+        else
+            merged.push([range[0], range[1]]);
+    }
+    return merged;
+}
+function toOriginal(folded, ranges) {
+    return mergeRanges(ranges.map(([start, end]) => [folded.origin[start], folded.originEnd[end - 1]]));
+}
+/**
+ * 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 function matchText(query, text) {
+    const terms = queryTerms(query);
+    if (terms.length === 0)
+        return { score: 0, ranges: [] };
+    const folded = fold(text);
+    let score = 0;
+    const ranges = [];
+    for (const term of terms) {
+        const match = matchTerm(term, folded.text);
+        if (!match)
+            return null;
+        score += match.score;
+        ranges.push(...match.ranges);
+    }
+    const whole = foldForMatch(query).trim();
+    if (folded.text === whole)
+        score += 200;
+    else if (folded.text.startsWith(whole))
+        score += 50;
+    // Of equal matches, the shorter text is the closer one.
+    score -= Math.min(folded.text.length, 100) * 0.1;
+    return { score, ranges: toOriginal(folded, ranges) };
+}
+/**
+ * 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 function matchItem(query, item) {
+    const terms = queryTerms(query);
+    if (terms.length === 0)
+        return { score: 0, titleRanges: [] };
+    const title = fold(item.title);
+    const secondary = foldForMatch([item.subtitle ?? '', ...(item.keywords ?? [])].join(' '));
+    let score = 0;
+    const titleRanges = [];
+    for (const term of terms) {
+        const inTitle = matchTerm(term, title.text);
+        if (inTitle) {
+            score += inTitle.score;
+            titleRanges.push(...inTitle.ranges);
+            continue;
+        }
+        const inSecondary = matchTerm(term, secondary);
+        if (!inSecondary)
+            return null;
+        score += inSecondary.score * 0.5;
+    }
+    const whole = foldForMatch(query).trim();
+    if (title.text === whole)
+        score += 200;
+    else if (title.text.startsWith(whole))
+        score += 50;
+    score -= Math.min(title.text.length, 100) * 0.1;
+    return { score, titleRanges: toOriginal(title, titleRanges) };
+}
+/** Split `text` into alternating plain and matched segments for rendering. */
+export function highlightSegments(text, ranges) {
+    const segments = [];
+    let cursor = 0;
+    for (const [start, end] of ranges) {
+        if (start > cursor) {
+            segments.push({ text: text.slice(cursor, start), match: false });
+        }
+        if (end > start) {
+            segments.push({ text: text.slice(start, end), match: true });
+        }
+        cursor = Math.max(cursor, end);
+    }
+    if (cursor < text.length) {
+        segments.push({ text: text.slice(cursor), match: false });
+    }
+    return segments;
+}

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

@@ -0,0 +1,159 @@
+import type { ShellNavGroup, ShellNavItem } from '../workspace/admin-shell/types.js';
+import { type SmrtManifestEntryLike } from '../workspace/manifest-nav.js';
+import type { PaletteProvider } from './types.js';
+type MaybeGetter<T> = T | (() => T);
+export interface NavigationProviderOptions {
+    /** Flat nav items (the `AppShell` `nav` prop). A getter follows reactive state. */
+    nav?: MaybeGetter<readonly ShellNavItem[]>;
+    /** Grouped nav (the `AppShell` `groups` prop). */
+    groups?: MaybeGetter<readonly ShellNavGroup[]>;
+    /** Provider id (default `navigation`). */
+    id?: string;
+    /** Group heading (default `Go to`). */
+    label?: string;
+    /** Sort position among providers (default 10). */
+    order?: number;
+}
+/**
+ * Rows that open each page of the shell navigation. Pass the *applied* nav
+ * (`useShellLayout().applied`) to honour sections a user hid or renamed.
+ *
+ * @example
+ * ```ts
+ * createNavigationProvider({
+ *   nav: () => layout.applied.nav,
+ *   groups: () => layout.applied.groups,
+ * });
+ * ```
+ */
+export declare function createNavigationProvider(options?: NavigationProviderOptions): PaletteProvider;
+/** The slice of a manifest field the palette reads. */
+export interface PaletteManifestFieldLike {
+    type?: string;
+    sensitive?: boolean;
+    transient?: boolean;
+    enum?: readonly unknown[];
+}
+/** A manifest entry with its fields (a subset of `SmartObjectDefinition`). */
+export interface PaletteManifestEntryLike extends SmrtManifestEntryLike {
+    fields?: Record<string, PaletteManifestFieldLike>;
+}
+/** A manifest (a subset of `SmartObjectManifest`). */
+export interface PaletteManifestLike {
+    objects: Record<string, PaletteManifestEntryLike>;
+}
+/** A model with the metadata the model providers work from. */
+export interface PaletteModel {
+    entry: PaletteManifestEntryLike;
+    /** Qualified name (`@pkg/name:Class`). */
+    qualifier: string;
+    /** Plural, display-cased label ("Invoices"). */
+    label: string;
+    /** Singular, display-cased label ("Invoice"). */
+    singular: string;
+    /** REST collection path segment. */
+    collection: string;
+    /** Whether the REST `create` route exists. */
+    creatable: boolean;
+    /** Text fields searched with a `like` filter. */
+    searchFields: readonly string[];
+    /** Field read as a record's title. */
+    titleField: string | null;
+}
+/** A row from the REST list route. */
+export type PaletteRecordRow = Record<string, unknown>;
+/** Request handed to {@link ModelProvidersOptions.searchRows}. */
+export interface PaletteRecordSearch {
+    model: PaletteModel;
+    field: string;
+    query: string;
+    limit: number;
+    signal: AbortSignal;
+}
+export interface ModelProvidersOptions {
+    /** The app manifest. */
+    manifest: PaletteManifestLike;
+    /**
+     * Qualified class names the user may reach (the nav helper's allow-list).
+     * Omit to include every navigable model; the server still decides what rows
+     * come back.
+     */
+    permittedResources?: readonly string[];
+    /** Only these models (class or qualified names) get search. */
+    searchModels?: readonly string[];
+    /**
+     * Text fields to search per model, keyed by class or qualified name.
+     * Default: the model's `title`, `name`, `displayName`, `label`, `subject`,
+     * `headline`, `number`, `code`, `sku`, `email` or `slug` field, first found.
+     */
+    searchFields?: Readonly<Record<string, readonly string[]>>;
+    /** How many of those fields to search per model (default 1). */
+    fieldsPerModel?: number;
+    /** Most models searched per query (default 20). */
+    maxModels?: number;
+    /** Rows taken from each model (default 3). */
+    perModelLimit?: number;
+    /** Concurrent requests per query (default 4). */
+    concurrency?: number;
+    /** Base of the generated REST routes (default `/api/v1`). */
+    apiBasePath?: string;
+    /** Base of the app's pages, used by the default hrefs (default ``). */
+    pagesBasePath?: string;
+    /**
+     * Page for a model's list, new-record form and a record. Return null to
+     * leave a row without a destination (it is then omitted). Defaults:
+     * `<pages>/<collection>`, `<pages>/<collection>/new`,
+     * `<pages>/<collection>/<id>`.
+     */
+    hrefs?: {
+        list?: (model: PaletteModel) => string | null;
+        create?: (model: PaletteModel) => string | null;
+        record?: (model: PaletteModel, row: PaletteRecordRow) => string | null;
+    };
+    /** Fetch used by the default `searchRows` (default: global `fetch`). */
+    fetch?: typeof fetch;
+    /**
+     * Replace the default `GET <api>/<collection>?<field>[like]=%q%` request,
+     * for example with a server search endpoint. The default's `LIKE` is
+     * case-insensitive on SQLite and case-sensitive on PostgreSQL.
+     */
+    searchRows?: (request: PaletteRecordSearch) => Promise<PaletteRecordRow[]>;
+    /** Also offer an "open <list>" row per model (default false; nav covers it). */
+    lists?: boolean;
+    /** Text of a create row (default `New <singular>`). */
+    createTitle?: (model: PaletteModel) => string;
+    /** Text of a list row (default the plural label). */
+    listTitle?: (model: PaletteModel) => string;
+    /** Group heading of the commands provider (default `Create`). */
+    commandsLabel?: string;
+    /** Group heading of the search provider (default `Records`). */
+    recordsLabel?: string;
+    /** Sort positions (defaults 20 and 30). */
+    commandsOrder?: number;
+    recordsOrder?: number;
+}
+/**
+ * Resolve each navigable model's palette metadata from the manifest. Exported
+ * for apps that build their own rows from the same model list.
+ */
+export declare function paletteModelsFromManifest(options: Pick<ModelProvidersOptions, 'manifest' | 'permittedResources' | 'searchFields' | 'fieldsPerModel'>): PaletteModel[];
+/**
+ * The model-driven providers: a `Create` commands provider ("New invoice")
+ * and a `Records` provider that searches the models' text fields through the
+ * generated REST routes. Models and their eligibility come from the same
+ * filters as the manifest-derived navigation.
+ *
+ * @example
+ * ```ts
+ * const palette = createCommandPalette({
+ *   providers: [
+ *     createNavigationProvider({ nav }),
+ *     ...createModelProviders({ manifest, pagesBasePath: '/app' }),
+ *   ],
+ *   navigate: goto,
+ * });
+ * ```
+ */
+export declare function createModelProviders(options: ModelProvidersOptions): PaletteProvider[];
+export {};
+//# sourceMappingURL=providers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../../src/components/command-palette/providers.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,345 @@
+/**
+ * Providers the shell ships with (#3713):
+ *
+ * - {@link createNavigationProvider}: "go to" rows from the shell nav model.
+ * - {@link createModelProviders}: "New <Noun>" commands and cross-model record
+ *   search derived from the SMRT manifest, over the generated REST routes.
+ *
+ * Both are plain `PaletteProvider`s; an app is free to ignore them and
+ * register its own.
+ */
+import { unwrapListResult } from '@happyvertical/smrt-web';
+import { navigableManifestEntries, pluralizeClassName, } from '../workspace/manifest-nav.js';
+function read(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    return typeof value === 'function' ? value() : value;
+}
+function flattenNav(items, trail, out, seen) {
+    for (const item of items) {
+        const id = `nav:${item.id ?? item.href}`;
+        if (!seen.has(id)) {
+            seen.add(id);
+            out.push({
+                id,
+                title: item.label,
+                subtitle: trail,
+                keywords: item.description ? [item.description] : undefined,
+                icon: item.icon,
+                kind: 'navigation',
+                href: item.href,
+            });
+        }
+        if (item.children?.length) {
+            flattenNav(item.children, trail ?? item.label, out, seen);
+        }
+    }
+}
+/**
+ * Rows that open each page of the shell navigation. Pass the *applied* nav
+ * (`useShellLayout().applied`) to honour sections a user hid or renamed.
+ *
+ * @example
+ * ```ts
+ * createNavigationProvider({
+ *   nav: () => layout.applied.nav,
+ *   groups: () => layout.applied.groups,
+ * });
+ * ```
+ */
+export function createNavigationProvider(options = {}) {
+    return {
+        id: options.id ?? 'navigation',
+        label: options.label ?? 'Go to',
+        order: options.order ?? 10,
+        items() {
+            const out = [];
+            const seen = new Set();
+            flattenNav(read(options.nav, []), undefined, out, seen);
+            for (const group of read(options.groups, [])) {
+                flattenNav(group.items, group.heading, out, seen);
+            }
+            return out;
+        },
+    };
+}
+const TITLE_FIELDS = [
+    'title',
+    'name',
+    'displayName',
+    'label',
+    'subject',
+    'headline',
+    'number',
+    'code',
+    'sku',
+    'email',
+    'slug',
+];
+function kebab(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
+        .toLowerCase();
+}
+/** "SalesInvoice" -> "Sales invoice". */
+function humanize(className) {
+    const words = className
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        .trim();
+    if (!words)
+        return className;
+    return words[0].toUpperCase() + words.slice(1).toLowerCase();
+}
+function isSearchableField(field) {
+    return (field?.type === 'text' &&
+        !field.sensitive &&
+        !field.transient &&
+        !(field.enum && field.enum.length > 0));
+}
+/**
+ * Resolve each navigable model's palette metadata from the manifest. Exported
+ * for apps that build their own rows from the same model list.
+ */
+export function paletteModelsFromManifest(options) {
+    const perModel = Math.max(1, options.fieldsPerModel ?? 1);
+    const models = navigableManifestEntries(options.manifest, { permittedResources: options.permittedResources }).map(({ entry, qualifier, creatable, }) => {
+        const fields = entry.fields ?? {};
+        const override = options.searchFields?.[qualifier] ??
+            options.searchFields?.[entry.className];
+        const candidates = (override ?? TITLE_FIELDS).filter((name) => override ? true : isSearchableField(fields[name]));
+        const titleField = TITLE_FIELDS.find((name) => isSearchableField(fields[name])) ??
+            override?.[0] ??
+            null;
+        return {
+            entry,
+            qualifier,
+            label: entry.decoratorConfig?.ui?.label ??
+                pluralizeClassName(humanize(entry.className)),
+            singular: humanize(entry.className),
+            collection: entry.collection ?? kebab(entry.className),
+            creatable,
+            searchFields: candidates.slice(0, perModel),
+            titleField,
+        };
+    });
+    return models.sort((a, b) => a.label.localeCompare(b.label) || a.qualifier.localeCompare(b.qualifier));
+}
+async function defaultSearchRows(request, options) {
+    const doFetch = options.fetch ?? globalThis.fetch;
+    if (!doFetch)
+        throw new Error('No fetch available for palette search.');
+    // `%` is a wildcard in LIKE; a typed one would only widen the match.
+    const term = request.query.replaceAll('%', '');
+    const params = new URLSearchParams();
+    params.set(`${request.field}[like]`, `%${term}%`);
+    params.set('limit', String(request.limit));
+    const response = await doFetch(`${options.apiBasePath}/${request.model.collection}?${params}`, {
+        signal: request.signal,
+        credentials: 'same-origin',
+        headers: { accept: 'application/json' },
+    });
+    // A model the user may not read (403) or a route the app does not mount
+    // (404) is a model without results, not a failed search.
+    if (response.status === 401 ||
+        response.status === 403 ||
+        response.status === 404) {
+        return [];
+    }
+    if (!response.ok) {
+        throw new Error(`Search of ${request.model.collection} failed (${response.status}).`);
+    }
+    const body = await response.json();
+    // The generated list routes answer `{ items, count, limit, offset }`; a
+    // bare array is accepted too. Any other shape is a model without results.
+    try {
+        return unwrapListResult(body, request.model.collection).filter((row) => row !== null && typeof row === 'object' && !Array.isArray(row));
+    }
+    catch {
+        return [];
+    }
+}
+/** Run `task` over `inputs` with at most `limit` in flight; keeps input order. */
+async function mapPool(inputs, limit, task) {
+    const results = new Array(inputs.length);
+    let next = 0;
+    const worker = async () => {
+        while (next < inputs.length) {
+            const index = next;
+            next += 1;
+            try {
+                results[index] = {
+                    status: 'fulfilled',
+                    value: await task(inputs[index]),
+                };
+            }
+            catch (reason) {
+                results[index] = { status: 'rejected', reason };
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(limit, inputs.length) }, worker));
+    return results;
+}
+function rowTitle(model, row) {
+    const fields = [model.titleField, ...TITLE_FIELDS];
+    for (const name of fields) {
+        if (!name)
+            continue;
+        const value = row[name];
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+        if (typeof value === 'number')
+            return String(value);
+    }
+    return typeof row.id === 'string' ? row.id : model.singular;
+}
+/**
+ * The model-driven providers: a `Create` commands provider ("New invoice")
+ * and a `Records` provider that searches the models' text fields through the
+ * generated REST routes. Models and their eligibility come from the same
+ * filters as the manifest-derived navigation.
+ *
+ * @example
+ * ```ts
+ * const palette = createCommandPalette({
+ *   providers: [
+ *     createNavigationProvider({ nav }),
+ *     ...createModelProviders({ manifest, pagesBasePath: '/app' }),
+ *   ],
+ *   navigate: goto,
+ * });
+ * ```
+ */
+export function createModelProviders(options) {
+    const models = paletteModelsFromManifest(options);
+    const pagesBase = options.pagesBasePath ?? '';
+    const apiBase = options.apiBasePath ?? '/api/v1';
+    const listHref = (model) => options.hrefs?.list
+        ? options.hrefs.list(model)
+        : `${pagesBase}/${model.collection}`;
+    const createHref = (model) => options.hrefs?.create
+        ? options.hrefs.create(model)
+        : `${pagesBase}/${model.collection}/new`;
+    const recordHref = (model, row) => options.hrefs?.record
+        ? options.hrefs.record(model, row)
+        : typeof row.id === 'string' || typeof row.id === 'number'
+            ? `${pagesBase}/${model.collection}/${encodeURIComponent(String(row.id))}`
+            : null;
+    const commands = {
+        id: 'models.commands',
+        label: options.commandsLabel ?? 'Create',
+        order: options.commandsOrder ?? 20,
+        items() {
+            const items = [];
+            for (const model of models) {
+                if (model.creatable) {
+                    const href = createHref(model);
+                    if (href) {
+                        items.push({
+                            id: `create:${model.qualifier}`,
+                            title: options.createTitle?.(model) ??
+                                `New ${model.singular.toLowerCase()}`,
+                            subtitle: model.label,
+                            keywords: ['create', 'add', model.singular],
+                            icon: 'add',
+                            kind: 'create',
+                            href,
+                        });
+                    }
+                }
+                if (options.lists) {
+                    const href = listHref(model);
+                    if (href) {
+                        items.push({
+                            id: `list:${model.qualifier}`,
+                            title: options.listTitle?.(model) ?? model.label,
+                            keywords: [model.singular],
+                            kind: 'navigation',
+                            href,
+                        });
+                    }
+                }
+            }
+            return items;
+        },
+    };
+    const allow = options.searchModels ? new Set(options.searchModels) : null;
+    const targets = models
+        .filter((model) => model.searchFields.length > 0)
+        .filter((model) => !allow ||
+        allow.has(model.qualifier) ||
+        allow.has(model.entry.className))
+        .slice(0, options.maxModels ?? 20);
+    const records = {
+        id: 'models.records',
+        label: options.recordsLabel ?? 'Records',
+        order: options.recordsOrder ?? 30,
+        minQueryLength: 2,
+        async search(query, { signal, limit }) {
+            if (targets.length === 0)
+                return [];
+            const perModel = Math.max(1, options.perModelLimit ?? 3);
+            const jobs = targets.flatMap((model) => model.searchFields.map((field) => ({ model, field })));
+            const run = options.searchRows
+                ? options.searchRows
+                : (request) => defaultSearchRows(request, {
+                    fetch: options.fetch,
+                    apiBasePath: apiBase,
+                });
+            const settled = await mapPool(jobs, Math.max(1, options.concurrency ?? 4), ({ model, field }) => run({ model, field, query, limit: perModel, signal }));
+            if (signal.aborted)
+                throw new DOMException('Aborted', 'AbortError');
+            if (settled.every((outcome) => outcome.status === 'rejected')) {
+                const first = settled[0];
+                throw first.reason instanceof Error
+                    ? first.reason
+                    : new Error('Record search failed.');
+            }
+            // One list per model (a model with several search fields merges, by id),
+            // then interleaved so a chatty model cannot crowd out the rest.
+            const perModelItems = new Map();
+            jobs.forEach(({ model }, index) => {
+                const outcome = settled[index];
+                if (outcome.status !== 'fulfilled')
+                    return;
+                const list = perModelItems.get(model) ?? [];
+                for (const row of outcome.value) {
+                    const id = row.id;
+                    if (typeof id !== 'string' && typeof id !== 'number')
+                        continue;
+                    const key = `${model.qualifier}:${id}`;
+                    if (list.some((item) => item.id === key))
+                        continue;
+                    const href = recordHref(model, row);
+                    if (!href)
+                        continue;
+                    list.push({
+                        id: key,
+                        title: rowTitle(model, row),
+                        subtitle: model.singular,
+                        kind: 'record',
+                        href,
+                    });
+                }
+                perModelItems.set(model, list);
+            });
+            const lists = [...perModelItems.values()].map((list) => list.slice(0, perModel));
+            const merged = [];
+            for (let round = 0; merged.length < limit; round += 1) {
+                let added = false;
+                for (const list of lists) {
+                    if (round < list.length && merged.length < limit) {
+                        merged.push(list[round]);
+                        added = true;
+                    }
+                }
+                if (!added)
+                    break;
+            }
+            return merged;
+        },
+    };
+    return [commands, records];
+}