@haruhimemoe/ui 0.6.0 → 0.8.0

package/dist/components/palette/PaletteFooter.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const KBD = "rounded border border-b3 bg-b5 px-1 font-sans text-c3";
+/**
+ * @function PaletteFooter
+ * @param props {PaletteFooterProps} count, nested, status and its run
+ * @returns {JSX.Element} the footer with its `<output>` live region
+ */
+export function PaletteFooter({ count, nested, status, statusRun }) {
+    return (_jsxs("div", { className: "flex items-center justify-between gap-4 border-b4 border-t px-4 py-2 text-c4 text-xs", children: [_jsx("output", { "aria-live": "polite", className: "truncate", children: statusRun === null ? (`${count} ${count === 1 ? "result" : "results"}`) : (_jsx("span", { children: status }, statusRun)) }), _jsxs("span", { className: "hidden shrink-0 gap-3 sm:flex", children: [_jsxs("span", { children: [_jsx("kbd", { className: KBD, children: "\u2191" }), " ", _jsx("kbd", { className: KBD, children: "\u2193" }), " navigate"] }), _jsxs("span", { children: [_jsx("kbd", { className: KBD, children: "\u21B5" }), " select"] }), nested ? (_jsxs("span", { children: [_jsx("kbd", { className: KBD, children: "\u232B" }), " back"] })) : null, _jsxs("span", { children: [_jsx("kbd", { className: KBD, children: "esc" }), " ", nested ? "back" : "close"] })] })] }));
+}

package/dist/components/palette/PaletteInput.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @file src/components/palette/PaletteInput.tsx
+ * @desc The palette's top line (internal): breadcrumb chips for nested pages or the argument
+ *       being collected, the combobox input, and the validation message under it. The input is
+ *       the dialog's one focusable thing, so its row shows focus: the bottom border turns h1 on
+ *       focus-visible, the cue 0.7.0's fields use. The error line is a status region that is
+ *       always mounted, so a message that appears is announced.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+import { type Ref } from "react";
+/** The input's state and ids. */
+export type PaletteInputProps = {
+    ref: Ref<HTMLInputElement>;
+    value: string;
+    placeholder: string;
+    label: string;
+    crumbs: readonly string[];
+    listId: string;
+    activeId: string | undefined;
+    error: string | undefined;
+    onChange: (value: string) => void;
+};
+/**
+ * @function PaletteInput
+ * @param props {PaletteInputProps} value, placeholder, name, crumbs, list and active ids, error
+ * @returns {JSX.Element} the crumbs, the combobox and its error line
+ */
+export declare function PaletteInput({ ref, value, placeholder, label, crumbs, listId, activeId, error, onChange, }: PaletteInputProps): import("react").JSX.Element;

package/dist/components/palette/PaletteInput.js

@@ -0,0 +1,23 @@
+/**
+ * @file src/components/palette/PaletteInput.tsx
+ * @desc The palette's top line (internal): breadcrumb chips for nested pages or the argument
+ *       being collected, the combobox input, and the validation message under it. The input is
+ *       the dialog's one focusable thing, so its row shows focus: the bottom border turns h1 on
+ *       focus-visible, the cue 0.7.0's fields use. The error line is a status region that is
+ *       always mounted, so a message that appears is announced.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useId } from "react";
+/**
+ * @function PaletteInput
+ * @param props {PaletteInputProps} value, placeholder, name, crumbs, list and active ids, error
+ * @returns {JSX.Element} the crumbs, the combobox and its error line
+ */
+export function PaletteInput({ ref, value, placeholder, label, crumbs, listId, activeId, error, onChange, }) {
+    const errorId = `${useId()}-error`;
+    return (_jsxs("div", { className: "border-b4 border-b has-[input:focus-visible]:border-h1", children: [_jsxs("div", { className: "flex items-center gap-2 px-4 py-3", children: [crumbs.map((crumb, index) => (_jsx("span", { className: "shrink-0 rounded bg-b4 px-2 py-0.5 text-c3 text-xs", children: crumb }, index))), _jsx("input", { ref: ref, type: "text", role: "combobox", "aria-expanded": "true", "aria-controls": listId, "aria-activedescendant": activeId, "aria-autocomplete": "list", "aria-label": label, "aria-invalid": error ? true : undefined, "aria-describedby": errorId, autoComplete: "off", spellCheck: false, value: value, placeholder: placeholder, onChange: (event) => onChange(event.target.value), className: "min-w-0 flex-1 bg-transparent text-base text-c1 outline-hidden placeholder:text-c4 sm:text-lg" })] }), _jsx("p", { id: errorId, role: "status", className: error ? "px-4 pb-2 text-rose-300 text-xs" : "sr-only", children: error })] }));
+}

package/dist/components/palette/PaletteList.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @file src/components/palette/PaletteList.tsx
+ * @desc The palette's listbox (internal): option rows under group headings, hint rows as plain
+ *       text, the active row scrolled into view. Hover makes a row active; click selects it.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+import type { Row } from "./rows.js";
+import type { Command } from "./types.js";
+/** The rows, which option is active, how to id an option, and the handlers. */
+export type PaletteListProps = {
+    id: string;
+    rows: readonly Row[];
+    active: number;
+    mac: boolean;
+    optionId: (index: number) => string;
+    /** A provider is searching: the listbox is aria-busy. */
+    busy?: boolean | undefined;
+    /** The pointer is over a row, at this position. */
+    onActivate: (index: number, x: number, y: number) => void;
+    onSelect: (command: Command) => void;
+};
+/**
+ * @function PaletteList
+ * @param props {PaletteListProps} rows, the active index, option ids and handlers
+ * @returns {JSX.Element} the `role="listbox"`
+ */
+export declare function PaletteList({ id, rows, active, mac, optionId, busy, onActivate, onSelect, }: PaletteListProps): import("react").JSX.Element;

package/dist/components/palette/PaletteList.js

@@ -0,0 +1,44 @@
+/**
+ * @file src/components/palette/PaletteList.tsx
+ * @desc The palette's listbox (internal): option rows under group headings, hint rows as plain
+ *       text, the active row scrolled into view. Hover makes a row active; click selects it.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect } from "react";
+import { PaletteRow } from "./PaletteRow.js";
+const segments = (rows) => {
+    const out = [];
+    let index = 0;
+    for (const row of rows) {
+        if (row.kind === "hint") {
+            out.push({ kind: "hint", row });
+            continue;
+        }
+        const last = out[out.length - 1];
+        const item = { row, index: index++ };
+        if (last?.kind === "group" && last.group === row.group)
+            last.items.push(item);
+        else
+            out.push({ kind: "group", group: row.group, items: [item] });
+    }
+    return out;
+};
+/**
+ * @function PaletteList
+ * @param props {PaletteListProps} rows, the active index, option ids and handlers
+ * @returns {JSX.Element} the `role="listbox"`
+ */
+export function PaletteList({ id, rows, active, mac, optionId, busy, onActivate, onSelect, }) {
+    // Runs for a new list too (its first row changes), so it scrolls back up when active stays 0.
+    const first = rows[0]?.id;
+    useEffect(() => {
+        if (first === undefined)
+            return;
+        document.getElementById(optionId(active))?.scrollIntoView?.({ block: "nearest" });
+    }, [active, optionId, first]);
+    return (_jsx("div", { id: id, role: "listbox", "aria-label": "Results", "aria-busy": busy ? true : undefined, className: "min-h-0 flex-1 overflow-y-auto p-2", children: segments(rows).map((segment) => segment.kind === "hint" ? (_jsx("div", { role: "option", "aria-disabled": "true", "aria-selected": "false", className: "px-3 py-2 text-c4 text-sm", children: segment.row.text }, segment.row.id)) : (_jsxs("div", { role: "group", "aria-labelledby": `${id}-${segment.items[0]?.index}-h`, children: [_jsx("div", { id: `${id}-${segment.items[0]?.index}-h`, className: "px-3 pt-3 pb-1 font-bold text-c3 text-xs", children: segment.group }), segment.items.map(({ row, index }) => (_jsx(PaletteRow, { id: optionId(index), command: row.command, ranges: row.ranges, active: index === active, mac: mac, onHover: (x, y) => onActivate(index, x, y), onSelect: () => onSelect(row.command) }, row.id)))] }, `${segment.group}:${segment.items[0]?.row.id}`))) }));
+}

package/dist/components/palette/PaletteRow.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @file src/components/palette/PaletteRow.tsx
+ * @desc One option in the palette's list (internal): icon slot, the title with its matched
+ *       characters marked, the subtitle, and the shortcut as kbd parts. Finished class strings,
+ *       no hooks: the list sets aria-selected and the pointer handlers. Keyboard handling lives
+ *       on the dialog, so this isn't focusable (aria-activedescendant names it).
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+import type { FuzzyMatch } from "./fuzzy.js";
+import type { Command } from "./types.js";
+/** The row's id (for aria-activedescendant), its command and spans, whether it's active. */
+export type PaletteRowProps = {
+    id: string;
+    command: Command;
+    ranges: FuzzyMatch["ranges"];
+    active: boolean;
+    mac: boolean;
+    /** The pointer moved over the row; gets the pointer's position, so a stale move can be told. */
+    onHover: (x: number, y: number) => void;
+    onSelect: () => void;
+};
+/**
+ * @function PaletteRow
+ * @param props {PaletteRowProps} the option's id, command, matched spans, active state, platform
+ *        and pointer handlers
+ * @returns {JSX.Element} a `role="option"` row
+ */
+export declare function PaletteRow({ id, command, ranges, active, mac, onHover, onSelect, }: PaletteRowProps): import("react").JSX.Element;

package/dist/components/palette/PaletteRow.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { displayShortcut, parseShortcut } from "./hotkeys.js";
+// The active row shows its state with an h1 edge, not background alone: bg-b4 on b6 is only
+// 1.5:1. min-h-9 keeps every row a 36px target.
+const ROW = "flex min-h-9 cursor-default items-center gap-3 rounded-lg border-l-2 border-transparent px-3 py-2";
+const ACTIVE = `${ROW} border-h1 bg-b4 forced-colors:border-[Highlight] forced-colors:bg-[Highlight] forced-colors:text-[HighlightText]`;
+const KBD = "rounded border border-b3 bg-b5 px-1.5 font-sans text-c3 text-xs";
+const highlighted = (title, ranges) => {
+    const parts = [];
+    let at = 0;
+    for (const [start, end] of ranges) {
+        if (start > at)
+            parts.push(title.slice(at, start));
+        parts.push(_jsx("mark", { className: "bg-transparent text-h1", children: title.slice(start, end) }, start));
+        at = end;
+    }
+    if (at < title.length)
+        parts.push(title.slice(at));
+    return parts;
+};
+/**
+ * @function PaletteRow
+ * @param props {PaletteRowProps} the option's id, command, matched spans, active state, platform
+ *        and pointer handlers
+ * @returns {JSX.Element} a `role="option"` row
+ */
+export function PaletteRow({ id, command, ranges, active, mac, onHover, onSelect, }) {
+    const shortcut = command.shortcut ? parseShortcut(command.shortcut) : null;
+    return (_jsxs("div", { id: id, role: "option", "aria-selected": active, className: active ? ACTIVE : ROW, onPointerMove: (event) => onHover(event.clientX, event.clientY), 
+        // Keep focus in the input: a click on a row must not blur it, so the next prompt
+        // (an argument, a nested page) can be typed straight away.
+        onPointerDown: (event) => event.preventDefault(), onClick: onSelect, children: [command.icon ? (_jsx("span", { className: "flex size-5 shrink-0 items-center justify-center text-c3", children: command.icon })) : null, _jsxs("span", { className: "flex min-w-0 flex-1 flex-col", children: [_jsx("span", { className: "truncate font-bold text-c1 text-sm", children: highlighted(command.title, ranges) }), command.subtitle ? (_jsx("span", { className: "truncate text-c4 text-xs", children: command.subtitle })) : null] }), shortcut ? (_jsx("span", { className: "flex shrink-0 gap-1", children: displayShortcut(shortcut, mac).map((part, index) => (_jsx("kbd", { className: KBD, children: part }, index))) })) : null] }));
+}

package/dist/components/palette/calc.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @file src/components/palette/calc.ts
+ * @desc The palette's calculator, pure and without eval: a tokenizer and the shunting-yard
+ *       algorithm over + - * / % ^, unary minus, parentheses, k and m number suffixes, pi and e,
+ *       and sqrt, abs, round, floor, ceil, min and max. Anything it can't parse, and any result
+ *       that isn't finite (division by zero), is null.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+/**
+ * @function evaluate
+ * @param expression {string} what was typed, e.g. "1.5k * (2 + sqrt(9))"
+ * @returns {number | null} the value, or null when it doesn't parse or isn't finite
+ */
+export declare function evaluate(expression: string): number | null;
+/**
+ * @function formatResult
+ * @param value {number} a result
+ * @returns {string} up to 10 significant digits, trailing zeros dropped, "-0" as "0"
+ */
+export declare function formatResult(value: number): string;
+/**
+ * @function isBareNumber
+ * @param expression {string} what was typed
+ * @returns {boolean} true for just a number ("2", " -2.5 "), when the palette shows no "= 2" row
+ */
+export declare const isBareNumber: (expression: string) => boolean;

package/dist/components/palette/calc.js

@@ -0,0 +1,226 @@
+/**
+ * @file src/components/palette/calc.ts
+ * @desc The palette's calculator, pure and without eval: a tokenizer and the shunting-yard
+ *       algorithm over + - * / % ^, unary minus, parentheses, k and m number suffixes, pi and e,
+ *       and sqrt, abs, round, floor, ceil, min and max. Anything it can't parse, and any result
+ *       that isn't finite (division by zero), is null.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+const CONSTANTS = { pi: Math.PI, e: Math.E };
+const FUNCTIONS = {
+    sqrt: ([x]) => (x === undefined ? undefined : Math.sqrt(x)),
+    abs: ([x]) => (x === undefined ? undefined : Math.abs(x)),
+    round: ([x]) => (x === undefined ? undefined : Math.round(x)),
+    floor: ([x]) => (x === undefined ? undefined : Math.floor(x)),
+    ceil: ([x]) => (x === undefined ? undefined : Math.ceil(x)),
+    min: (args) => (args.length === 0 ? undefined : Math.min(...args)),
+    max: (args) => (args.length === 0 ? undefined : Math.max(...args)),
+};
+const SUFFIX = { k: 1e3, m: 1e6 };
+const NUMBER = /^(\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?([km])?/i;
+const IDENT = /^[a-z]+/i;
+const tokenize = (expression) => {
+    const tokens = [];
+    let rest = expression.trim();
+    while (rest.length > 0) {
+        const space = /^\s+/.exec(rest);
+        if (space) {
+            rest = rest.slice(space[0].length);
+            continue;
+        }
+        const num = NUMBER.exec(rest);
+        const ident = num ? null : IDENT.exec(rest);
+        if (num) {
+            const value = Number(num[0].replace(/[km]$/i, "")) * (SUFFIX[(num[2] ?? "").toLowerCase()] ?? 1);
+            tokens.push({ kind: "num", value });
+            rest = rest.slice(num[0].length);
+        }
+        else if (ident) {
+            const name = ident[0].toLowerCase();
+            rest = rest.slice(ident[0].length);
+            if (name in CONSTANTS)
+                tokens.push({ kind: "num", value: CONSTANTS[name] });
+            else if (name in FUNCTIONS)
+                tokens.push({ kind: "fn", value: name });
+            else
+                return null;
+        }
+        else {
+            const ch = rest[0];
+            rest = rest.slice(1);
+            if (ch === "(" || ch === ")" || ch === ",")
+                tokens.push({ kind: ch });
+            else if ("+-*/%^".includes(ch)) {
+                const previous = tokens[tokens.length - 1];
+                const unary = ch === "-" &&
+                    (!previous || previous.kind === "op" || previous.kind === "(" || previous.kind === ",");
+                tokens.push({
+                    kind: "op",
+                    value: unary ? "neg" : ch,
+                });
+            }
+            else
+                return null;
+        }
+    }
+    return tokens;
+};
+const PRECEDENCE = {
+    "+": 1,
+    "-": 1,
+    "*": 2,
+    "/": 2,
+    "%": 2,
+    "^": 4,
+    neg: 3,
+};
+const RIGHT = new Set(["^", "neg"]);
+const apply = (op, values) => {
+    if (op === "neg") {
+        const x = values.pop();
+        if (x === undefined)
+            return false;
+        values.push(-x);
+        return true;
+    }
+    const b = values.pop();
+    const a = values.pop();
+    if (a === undefined || b === undefined)
+        return false;
+    const result = op === "+"
+        ? a + b
+        : op === "-"
+            ? a - b
+            : op === "*"
+                ? a * b
+                : op === "/"
+                    ? a / b
+                    : op === "%"
+                        ? a % b
+                        : a ** b;
+    values.push(result);
+    return true;
+};
+/**
+ * @function evaluate
+ * @param expression {string} what was typed, e.g. "1.5k * (2 + sqrt(9))"
+ * @returns {number | null} the value, or null when it doesn't parse or isn't finite
+ */
+export function evaluate(expression) {
+    const tokens = tokenize(expression);
+    if (!tokens || tokens.length === 0)
+        return null;
+    const values = [];
+    const ops = [];
+    const argc = [];
+    let expectValue = true;
+    const popOps = (until) => {
+        while (ops.length > 0) {
+            const top = ops[ops.length - 1];
+            if (until(top))
+                return true;
+            ops.pop();
+            if (top.kind !== "op" || !apply(top.value, values))
+                return false;
+        }
+        return false;
+    };
+    for (const [i, token] of tokens.entries()) {
+        const next = tokens[i + 1];
+        if (token.kind === "num") {
+            if (!expectValue)
+                return null;
+            values.push(token.value);
+            expectValue = false;
+        }
+        else if (token.kind === "fn") {
+            if (!expectValue || next?.kind !== "(")
+                return null;
+            ops.push({ kind: "(", fn: token.value });
+            argc.push(next === undefined ? 0 : tokens[i + 2]?.kind === ")" ? 0 : 1);
+            tokens.splice(i + 1, 1);
+        }
+        else if (token.kind === "(") {
+            if (!expectValue)
+                return null;
+            ops.push(token);
+            argc.push(0);
+            expectValue = true;
+        }
+        else if (token.kind === ",") {
+            if (expectValue)
+                return null;
+            if (!popOps((top) => top.kind === "("))
+                return null;
+            const top = ops[ops.length - 1];
+            if (top?.kind !== "(" || !top.fn)
+                return null;
+            argc[argc.length - 1] = (argc[argc.length - 1] ?? 0) + 1;
+            expectValue = true;
+        }
+        else if (token.kind === ")") {
+            if (expectValue && ops[ops.length - 1]?.kind !== "(")
+                return null;
+            if (!popOps((top) => top.kind === "("))
+                return null;
+            const open = ops.pop();
+            const count = argc.pop() ?? 0;
+            if (open?.kind === "(" && open.fn) {
+                const n = expectValue ? count : count;
+                const args = values.splice(values.length - n, n);
+                if (args.length !== n)
+                    return null;
+                const result = FUNCTIONS[open.fn]?.(args);
+                if (result === undefined)
+                    return null;
+                values.push(result);
+            }
+            else if (expectValue)
+                return null;
+            expectValue = false;
+        }
+        else {
+            const op = token.value;
+            if (op === "neg") {
+                if (!expectValue)
+                    return null;
+                ops.push(token);
+                continue;
+            }
+            if (expectValue)
+                return null;
+            const p = PRECEDENCE[op];
+            popOps((top) => {
+                if (top.kind !== "op")
+                    return true;
+                const topP = PRECEDENCE[top.value];
+                return topP < p || (topP === p && RIGHT.has(op));
+            });
+            ops.push(token);
+            expectValue = true;
+        }
+    }
+    if (expectValue)
+        return null;
+    if (popOps((top) => top.kind === "("))
+        return null;
+    const result = values.length === 1 ? values[0] : undefined;
+    return result !== undefined && Number.isFinite(result) ? result : null;
+}
+/**
+ * @function formatResult
+ * @param value {number} a result
+ * @returns {string} up to 10 significant digits, trailing zeros dropped, "-0" as "0"
+ */
+export function formatResult(value) {
+    const text = String(Number(value.toPrecision(10)));
+    return text === "-0" ? "0" : text;
+}
+/**
+ * @function isBareNumber
+ * @param expression {string} what was typed
+ * @returns {boolean} true for just a number ("2", " -2.5 "), when the palette shows no "= 2" row
+ */
+export const isBareNumber = (expression) => /^\s*-?(\d+\.?\d*|\.\d+)\s*$/.test(expression);

package/dist/components/palette/fuzzy.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @file src/components/palette/fuzzy.ts
+ * @desc The palette's scorer, pure. A query matches a text when its characters appear in order
+ *       (case-insensitive). Each matched character scores 10 at a word start, 8 when it follows
+ *       the previous match, 4 otherwise, minus one per skipped character; a query that prefixes
+ *       the text adds 20. A command's score is the best of its title, keywords (0.7), subtitle
+ *       (0.5) and group (0.3). A cased letter or digit may only match at a word start or right
+ *       after the previous match, so "cpu" lands on "Copy page URL"'s initials and "go" never
+ *       finds "Sign out"; punctuation and uncased scripts (kanji, kana) match anywhere, since
+ *       they have no word starts. Backtracking, left to right, memoized.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+import type { Command } from "./types.js";
+/** A match: its score and the matched [start, end) spans in the text, for highlighting. */
+export type FuzzyMatch = {
+    score: number;
+    ranges: readonly (readonly [number, number])[];
+};
+/** A command with its score and the title's matched spans (empty when another field matched). */
+export type Scored = {
+    command: Command;
+    score: number;
+    ranges: FuzzyMatch["ranges"];
+};
+/**
+ * @function fuzzyScore
+ * @param query {string} what was typed; surrounding spaces are ignored
+ * @param text {string} a title, keyword or heading
+ * @returns {FuzzyMatch | null} the score and matched spans, or null when the query isn't a
+ *          subsequence of the text. An empty query scores 0 with no spans.
+ */
+export declare function fuzzyScore(query: string, text: string): FuzzyMatch | null;
+/**
+ * @function scoreCommand
+ * @param query {string} what was typed
+ * @param command {Command} a row
+ * @returns {Scored | null} the best weighted field match, with title spans only when the title
+ *          itself matched; null when no field matches
+ */
+export declare function scoreCommand(query: string, command: Command): Scored | null;
+/**
+ * @function rankResults
+ * @param query {string} what was typed
+ * @param commands {readonly Command[]} the rows to search
+ * @param boost {(id: string) => number} a tie-breaker per id (recents count)
+ * @returns {Scored[]} the matching rows, best first; ties go to the higher boost, then to
+ *          declaration order
+ */
+export declare function rankResults(query: string, commands: readonly Command[], boost: (id: string) => number): Scored[];

package/dist/components/palette/fuzzy.js

@@ -0,0 +1,138 @@
+/**
+ * @file src/components/palette/fuzzy.ts
+ * @desc The palette's scorer, pure. A query matches a text when its characters appear in order
+ *       (case-insensitive). Each matched character scores 10 at a word start, 8 when it follows
+ *       the previous match, 4 otherwise, minus one per skipped character; a query that prefixes
+ *       the text adds 20. A command's score is the best of its title, keywords (0.7), subtitle
+ *       (0.5) and group (0.3). A cased letter or digit may only match at a word start or right
+ *       after the previous match, so "cpu" lands on "Copy page URL"'s initials and "go" never
+ *       finds "Sign out"; punctuation and uncased scripts (kanji, kana) match anywhere, since
+ *       they have no word starts. Backtracking, left to right, memoized.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+const WORD_BREAK = /[\s\-_/.]/;
+const isWordStart = (text, at) => {
+    if (at === 0)
+        return true;
+    const before = text[at - 1] ?? "";
+    const here = text[at] ?? "";
+    if (WORD_BREAK.test(before))
+        return true;
+    return before === before.toLowerCase() && here !== here.toLowerCase();
+};
+/**
+ * A character the word-start rule applies to: a digit or a letter with case. Scripts without
+ * case (kanji, kana, hangul) have no spaces to start words at, so they may match anywhere.
+ */
+const isStrict = (ch) => /\p{N}/u.test(ch) || (/\p{L}/u.test(ch) && ch.toLowerCase() !== ch.toUpperCase());
+/**
+ * The positions where the query's characters match, found left to right with backtracking,
+ * memoized on (index, from, consecutive) so a repetitive query stays polynomial. A cased letter
+ * or a digit may only match at a word start or right after the previous match (so "go" never
+ * lands on the g inside "Sign out"); punctuation and uncased letters may match anywhere. Null
+ * when the query can't be placed.
+ */
+const place = (chars, i, from, prev, text, t, memo) => {
+    const ch = chars[i];
+    if (ch === undefined)
+        return [];
+    const key = `${i}:${from}:${prev === from - 1 ? 1 : 0}`;
+    const seen = memo.get(key);
+    if (seen !== undefined)
+        return seen;
+    let found = null;
+    for (let at = t.indexOf(ch, from); at >= 0; at = t.indexOf(ch, at + 1)) {
+        const allowed = !isStrict(ch) || (prev >= 0 && at === prev + 1) || isWordStart(text, at);
+        if (!allowed)
+            continue;
+        const rest = place(chars, i + 1, at + 1, at, text, t, memo);
+        if (rest) {
+            found = [at, ...rest];
+            break;
+        }
+    }
+    memo.set(key, found);
+    return found;
+};
+/**
+ * @function fuzzyScore
+ * @param query {string} what was typed; surrounding spaces are ignored
+ * @param text {string} a title, keyword or heading
+ * @returns {FuzzyMatch | null} the score and matched spans, or null when the query isn't a
+ *          subsequence of the text. An empty query scores 0 with no spans.
+ */
+export function fuzzyScore(query, text) {
+    const q = query.trim().toLowerCase();
+    if (q.length === 0)
+        return { score: 0, ranges: [] };
+    const t = text.toLowerCase();
+    const positions = place([...q], 0, 0, -1, text, t, new Map());
+    if (!positions)
+        return null;
+    let score = 0;
+    let prev = -1;
+    const ranges = [];
+    for (const at of positions) {
+        if (prev >= 0 && at === prev + 1)
+            score += 8;
+        else if (isWordStart(text, at))
+            score += 10;
+        else
+            score += 4;
+        if (prev >= 0)
+            score -= Math.max(0, at - prev - 1);
+        const last = ranges[ranges.length - 1];
+        if (last && last[1] === at)
+            last[1] = at + 1;
+        else
+            ranges.push([at, at + 1]);
+        prev = at;
+    }
+    if (t.startsWith(q))
+        score += 20;
+    return { score, ranges };
+}
+const WEIGHTS = { keyword: 0.7, subtitle: 0.5, group: 0.3 };
+/**
+ * @function scoreCommand
+ * @param query {string} what was typed
+ * @param command {Command} a row
+ * @returns {Scored | null} the best weighted field match, with title spans only when the title
+ *          itself matched; null when no field matches
+ */
+export function scoreCommand(query, command) {
+    const title = fuzzyScore(query, command.title);
+    let best = title ? { score: title.score, ranges: title.ranges } : null;
+    const consider = (text, weight) => {
+        if (!text)
+            return;
+        const match = fuzzyScore(query, text);
+        if (match && (!best || match.score * weight > best.score)) {
+            best = { score: match.score * weight, ranges: [] };
+        }
+    };
+    for (const keyword of command.keywords ?? [])
+        consider(keyword, WEIGHTS.keyword);
+    consider(command.subtitle, WEIGHTS.subtitle);
+    consider(command.group, WEIGHTS.group);
+    return best ? { command, ...best } : null;
+}
+/**
+ * @function rankResults
+ * @param query {string} what was typed
+ * @param commands {readonly Command[]} the rows to search
+ * @param boost {(id: string) => number} a tie-breaker per id (recents count)
+ * @returns {Scored[]} the matching rows, best first; ties go to the higher boost, then to
+ *          declaration order
+ */
+export function rankResults(query, commands, boost) {
+    return commands
+        .map((command, index) => ({ scored: scoreCommand(query, command), index }))
+        .filter((entry) => entry.scored !== null)
+        .sort((a, b) => b.scored.score - a.scored.score ||
+        boost(b.scored.command.id) - boost(a.scored.command.id) ||
+        a.index - b.index)
+        .map((entry) => entry.scored);
+}