@viniaraujo68/plinth 0.0.0-stage → 0.2.0

package/dist/components/date-range.d.ts

@@ -0,0 +1,101 @@
+/**
+ * The pair a range picker emits, and the whole of what it emits.
+ *
+ * Both ends are ISO-8601 instants in UTC (`2026-08-29T18:04:05.123Z`), the form `toISOString()`
+ * produces. A string rather than a `Date` because this value's job is to travel: into a fetch
+ * body, a query string, a store, a load function's return — all of which serialise a `Date` to
+ * exactly this string anyway, while an ISO string additionally survives the round trip back and
+ * sorts correctly with a plain `<`. UTC rather than a local offset because two clients in
+ * different zones must be able to name the same window with the same characters.
+ */
+export interface DateRange {
+    from: string;
+    to: string;
+}
+/**
+ * One relative window offered as a button — a fixed duration measured back from "now".
+ *
+ * `durationMs` is a duration and not a calendar step on purpose: "30d" means 30×24h, so the
+ * window keeps its length across a DST boundary instead of silently growing or shrinking an hour
+ * twice a year. A caller who really wants "this month" wants a custom range, not a preset.
+ */
+export interface DateRangePreset {
+    /** Stable across renders — it is what the picker's selection prop holds. */
+    id: string;
+    label: string;
+    durationMs: number;
+}
+/**
+ * The selection value that means "the user typed the two ends themselves".
+ *
+ * It lives in the same space as the preset ids, so a preset may not claim it.
+ */
+export declare const CUSTOM_PRESET_ID = "custom";
+/** The four windows a dashboard actually gets asked for. Replace the list, not the component. */
+export declare const DEFAULT_PRESETS: readonly DateRangePreset[];
+/** Builds the window a preset names, ending at `now`. */
+export declare const buildRange: (preset: DateRangePreset, now?: Date | number) => DateRange;
+/**
+ * Resolves a selection into the window it stands for right now, or `null` when there is nothing
+ * to build — an unknown id, or {@link CUSTOM_PRESET_ID}.
+ *
+ * The initial anchor and every re-anchor tick both go through here, which is what makes "a custom
+ * range is never re-anchored" a property of the data rather than of the timer's wiring: even a
+ * tick that somehow fired while the user was in custom mode would have nothing to emit.
+ */
+export declare const anchorSelection: (selection: string, presets: readonly DateRangePreset[], now?: Date | number) => DateRange | null;
+/** Whether the pair is in order. An empty end is not a range, so it is not valid either. */
+export declare const isValidRange: (from: string | null, to: string | null) => boolean;
+/**
+ * Formats a UTC instant for the `value` of an `<input type="datetime-local">`, whose contents are
+ * always wall-clock time in the browser's own zone and carry no offset of their own.
+ *
+ * Two browser traps are handled here. The string may not end in `Z` — appending one, or handing
+ * over a sliced `toISOString()`, silently shifts the field by the local offset. And the input's
+ * default `step` is 60, so a value carrying seconds is a step mismatch: the field would either
+ * refuse it or grow a seconds segment. The instant is therefore truncated down to the minute,
+ * which is a real loss of up to 59 seconds — the picker re-emits after the conversion rather than
+ * keeping a value it is no longer showing.
+ *
+ * Returns `null` for anything `Date` cannot parse, so a bad value from an API blanks the field
+ * instead of writing `NaN-NaN-NaN` into it.
+ */
+export declare const isoToLocalInput: (iso: string | null | undefined) => string | null;
+/**
+ * Reads an `<input type="datetime-local">` value back into a UTC ISO instant, interpreting it in
+ * the browser's zone.
+ *
+ * The parse is explicit rather than `new Date(value)`: the platform parser reads a date-only
+ * string as UTC and a date-time string as local, a split that turns a half-typed field into an
+ * instant a whole offset away. Anything that is not a complete local date and time — which is
+ * what a partly filled field reports — is rejected as `null`.
+ *
+ * A local time that does not exist, the hour a spring-forward skips, is normalised by the
+ * platform to the instant just after the jump. That is the same answer the input's own picker
+ * gives, so the field and the emitted value stay in agreement.
+ */
+export declare const localInputToIso: (local: string | null | undefined) => string | null;
+/** The clock behind a relative range, driven by the picker and stopped by it. */
+export interface ReAnchor {
+    /** Starts ticking. Idempotent, and a no-op for a non-positive interval. */
+    start: () => void;
+    /** Stops ticking and forgets that it was running. */
+    stop: () => void;
+    /**
+     * Reports the document's visibility. Going hidden suspends the interval; coming back fires one
+     * anchor immediately, because the range on screen is by then as stale as the tab is old.
+     */
+    setHidden: (hidden: boolean) => void;
+}
+/**
+ * A suspendable repeating anchor.
+ *
+ * It exists apart from the component for two reasons: the suspend-on-hidden rule is the part
+ * most likely to regress and the easiest to test with fake timers, and a background tab whose
+ * timers the browser has throttled to once a minute would otherwise fire a burst of catch-up
+ * anchors the moment it returns.
+ */
+export declare const createReAnchor: (options: {
+    intervalMs: number;
+    onAnchor: () => void;
+}) => ReAnchor;

package/dist/components/date-range.js

@@ -0,0 +1,144 @@
+/**
+ * The selection value that means "the user typed the two ends themselves".
+ *
+ * It lives in the same space as the preset ids, so a preset may not claim it.
+ */
+export const CUSTOM_PRESET_ID = "custom";
+const MINUTE_MS = 60_000;
+const HOUR_MS = 60 * MINUTE_MS;
+const DAY_MS = 24 * HOUR_MS;
+/** The four windows a dashboard actually gets asked for. Replace the list, not the component. */
+export const DEFAULT_PRESETS = [
+    { id: "1h", label: "1h", durationMs: HOUR_MS },
+    { id: "24h", label: "24h", durationMs: DAY_MS },
+    { id: "7d", label: "7d", durationMs: 7 * DAY_MS },
+    { id: "30d", label: "30d", durationMs: 30 * DAY_MS },
+];
+/** Builds the window a preset names, ending at `now`. */
+export const buildRange = (preset, now = Date.now()) => {
+    const end = now instanceof Date ? now.getTime() : now;
+    return { from: new Date(end - preset.durationMs).toISOString(), to: new Date(end).toISOString() };
+};
+/**
+ * Resolves a selection into the window it stands for right now, or `null` when there is nothing
+ * to build — an unknown id, or {@link CUSTOM_PRESET_ID}.
+ *
+ * The initial anchor and every re-anchor tick both go through here, which is what makes "a custom
+ * range is never re-anchored" a property of the data rather than of the timer's wiring: even a
+ * tick that somehow fired while the user was in custom mode would have nothing to emit.
+ */
+export const anchorSelection = (selection, presets, now = Date.now()) => {
+    if (selection === CUSTOM_PRESET_ID)
+        return null;
+    const preset = presets.find(({ id }) => id === selection);
+    return preset ? buildRange(preset, now) : null;
+};
+/** Whether the pair is in order. An empty end is not a range, so it is not valid either. */
+export const isValidRange = (from, to) => {
+    if (from === null || to === null)
+        return false;
+    const start = Date.parse(from);
+    const end = Date.parse(to);
+    return !Number.isNaN(start) && !Number.isNaN(end) && start <= end;
+};
+const pad = (value, length = 2) => String(value).padStart(length, "0");
+const LOCAL_INPUT_PATTERN = /^(\d{4,6})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2}))?$/;
+/**
+ * Formats a UTC instant for the `value` of an `<input type="datetime-local">`, whose contents are
+ * always wall-clock time in the browser's own zone and carry no offset of their own.
+ *
+ * Two browser traps are handled here. The string may not end in `Z` — appending one, or handing
+ * over a sliced `toISOString()`, silently shifts the field by the local offset. And the input's
+ * default `step` is 60, so a value carrying seconds is a step mismatch: the field would either
+ * refuse it or grow a seconds segment. The instant is therefore truncated down to the minute,
+ * which is a real loss of up to 59 seconds — the picker re-emits after the conversion rather than
+ * keeping a value it is no longer showing.
+ *
+ * Returns `null` for anything `Date` cannot parse, so a bad value from an API blanks the field
+ * instead of writing `NaN-NaN-NaN` into it.
+ */
+export const isoToLocalInput = (iso) => {
+    if (!iso)
+        return null;
+    const instant = new Date(iso);
+    if (Number.isNaN(instant.getTime()))
+        return null;
+    const date = `${pad(instant.getFullYear(), 4)}-${pad(instant.getMonth() + 1)}-${pad(instant.getDate())}`;
+    return `${date}T${pad(instant.getHours())}:${pad(instant.getMinutes())}`;
+};
+/**
+ * Reads an `<input type="datetime-local">` value back into a UTC ISO instant, interpreting it in
+ * the browser's zone.
+ *
+ * The parse is explicit rather than `new Date(value)`: the platform parser reads a date-only
+ * string as UTC and a date-time string as local, a split that turns a half-typed field into an
+ * instant a whole offset away. Anything that is not a complete local date and time — which is
+ * what a partly filled field reports — is rejected as `null`.
+ *
+ * A local time that does not exist, the hour a spring-forward skips, is normalised by the
+ * platform to the instant just after the jump. That is the same answer the input's own picker
+ * gives, so the field and the emitted value stay in agreement.
+ */
+export const localInputToIso = (local) => {
+    if (!local)
+        return null;
+    const match = LOCAL_INPUT_PATTERN.exec(local);
+    if (!match)
+        return null;
+    const [, year, month, day, hours, minutes, seconds = "0"] = match;
+    const instant = new Date(Number(year), Number(month) - 1, Number(day), Number(hours), Number(minutes), Number(seconds));
+    // `Date` rolls a nonsensical component over into the next unit -- month 13 becomes January --
+    // so the only way to reject "2026-02-31" is to ask what came back out.
+    if (Number.isNaN(instant.getTime()) ||
+        instant.getMonth() !== Number(month) - 1 ||
+        instant.getDate() !== Number(day))
+        return null;
+    return instant.toISOString();
+};
+/**
+ * A suspendable repeating anchor.
+ *
+ * It exists apart from the component for two reasons: the suspend-on-hidden rule is the part
+ * most likely to regress and the easiest to test with fake timers, and a background tab whose
+ * timers the browser has throttled to once a minute would otherwise fire a burst of catch-up
+ * anchors the moment it returns.
+ */
+export const createReAnchor = (options) => {
+    let timer;
+    let running = false;
+    let hidden = false;
+    const schedule = () => {
+        if (timer !== undefined || !running || hidden || options.intervalMs <= 0)
+            return;
+        timer = setInterval(options.onAnchor, options.intervalMs);
+    };
+    const clear = () => {
+        if (timer === undefined)
+            return;
+        clearInterval(timer);
+        timer = undefined;
+    };
+    return {
+        start: () => {
+            running = true;
+            schedule();
+        },
+        stop: () => {
+            running = false;
+            clear();
+        },
+        setHidden: (next) => {
+            if (next === hidden)
+                return;
+            hidden = next;
+            if (hidden) {
+                clear();
+                return;
+            }
+            if (!running)
+                return;
+            options.onAnchor();
+            schedule();
+        },
+    };
+};

package/dist/components/index.d.ts

@@ -0,0 +1,25 @@
+export { default as AsyncButton } from "./AsyncButton.svelte";
+export { default as Combobox } from "./Combobox.svelte";
+export { default as Copyable } from "./Copyable.svelte";
+export { default as DateRangePicker } from "./DateRangePicker.svelte";
+export { default as Dialog } from "./Dialog.svelte";
+export { default as Dropdown } from "./Dropdown.svelte";
+export { default as ErrorDisplay } from "./ErrorDisplay.svelte";
+export { default as ErrorPage } from "./ErrorPage.svelte";
+export { default as JsonInput } from "./JsonInput.svelte";
+export { default as Listbox } from "./Listbox.svelte";
+export { default as LoadingButton } from "./LoadingButton.svelte";
+export { default as Logo } from "./Logo.svelte";
+export { default as Modal } from "./Modal.svelte";
+export { default as MultiSelect } from "./MultiSelect.svelte";
+export { default as Paginator } from "./Paginator.svelte";
+export { default as RefreshButton } from "./RefreshButton.svelte";
+export { default as SegmentedControl } from "./SegmentedControl.svelte";
+export { default as Select } from "./Select.svelte";
+export { default as Skeleton } from "./Skeleton.svelte";
+export { default as Tooltip } from "./Tooltip.svelte";
+export { PICK_CLIP_PATH, PICK_PATH } from "./pick.js";
+export { buildRange, CUSTOM_PRESET_ID, DEFAULT_PRESETS, isoToLocalInput, localInputToIso, type DateRange, type DateRangePreset, } from "./date-range.js";
+export { matchesSelectQuery, normalizeForSearch, type SelectOption } from "./select.js";
+export { formatJsonText, parseJsonText, type JsonTextOptions, type JsonTextResult, } from "./json-text.js";
+export type { SegmentedOption } from "./segmented.js";

package/dist/components/index.js

@@ -0,0 +1,37 @@
+export { default as AsyncButton } from "./AsyncButton.svelte";
+export { default as Combobox } from "./Combobox.svelte";
+export { default as Copyable } from "./Copyable.svelte";
+export { default as DateRangePicker } from "./DateRangePicker.svelte";
+export { default as Dialog } from "./Dialog.svelte";
+export { default as Dropdown } from "./Dropdown.svelte";
+export { default as ErrorDisplay } from "./ErrorDisplay.svelte";
+export { default as ErrorPage } from "./ErrorPage.svelte";
+export { default as JsonInput } from "./JsonInput.svelte";
+export { default as Listbox } from "./Listbox.svelte";
+export { default as LoadingButton } from "./LoadingButton.svelte";
+export { default as Logo } from "./Logo.svelte";
+export { default as Modal } from "./Modal.svelte";
+export { default as MultiSelect } from "./MultiSelect.svelte";
+export { default as Paginator } from "./Paginator.svelte";
+export { default as RefreshButton } from "./RefreshButton.svelte";
+export { default as SegmentedControl } from "./SegmentedControl.svelte";
+export { default as Select } from "./Select.svelte";
+export { default as Skeleton } from "./Skeleton.svelte";
+export { default as Tooltip } from "./Tooltip.svelte";
+// The mark's outline as data. `Logo` and the shell's avatar already read it from here, and an app
+// that wants the same silhouette -- a placeholder cut to the pick, an avatar of its own -- has no
+// other way to get it than copying the curve out of the library, which is how two versions of one
+// shape start existing.
+export { PICK_CLIP_PATH, PICK_PATH } from "./pick.js";
+// The half of `date-range.js` a consumer of the picker has a use for: the two prop types, the
+// preset list and the reserved id they are written against, and the three conversions anyone
+// pairing their own field with a `DateRange` has to repeat otherwise. The rest -- the selection
+// anchor, the pair validator and the re-anchor clock -- is how the picker drives itself, and the
+// picker never emits a pair that would fail the validator.
+export { buildRange, CUSTOM_PRESET_ID, DEFAULT_PRESETS, isoToLocalInput, localInputToIso, } from "./date-range.js";
+// The half of `select.ts` a consumer has a use for: the option type every caller of either
+// control has to name, and the default matcher, so widening the search -- matching the value too,
+// a synonym list -- can compose with the accent folding instead of reimplementing it. The
+// highlight walk stays private: it is how the two components drive themselves.
+export { matchesSelectQuery, normalizeForSearch } from "./select.js";
+export { formatJsonText, parseJsonText, } from "./json-text.js";

package/dist/components/json-text.d.ts

@@ -0,0 +1,22 @@
+/** What reading the text of a JSON field yielded: the parsed value, or why it could not be read. */
+export type JsonTextResult = {
+    valid: true;
+    data: unknown;
+} | {
+    valid: false;
+    error: string;
+};
+export interface JsonTextOptions {
+    /** Rejects blank text. Off by default, so an optional field left blank reads as `undefined`. */
+    required?: boolean;
+    /** The error for blank text when `required`. */
+    requiredMessage?: string;
+}
+/**
+ * Parses the text of a JSON field. Blank text is valid and `undefined`, or invalid when
+ * `required`; anything else goes through `JSON.parse`, whose message is carried through as the
+ * error, since it names where the document broke.
+ */
+export declare const parseJsonText: (text: string, { required, requiredMessage }?: JsonTextOptions) => JsonTextResult;
+/** Pretty-prints the text of a JSON field, or hands it back untouched when it does not parse. */
+export declare const formatJsonText: (text: string, indent?: number) => string;

package/dist/components/json-text.js

@@ -0,0 +1,22 @@
+/**
+ * Parses the text of a JSON field. Blank text is valid and `undefined`, or invalid when
+ * `required`; anything else goes through `JSON.parse`, whose message is carried through as the
+ * error, since it names where the document broke.
+ */
+export const parseJsonText = (text, { required = false, requiredMessage = "Required" } = {}) => {
+    if (!text.trim())
+        return required ? { valid: false, error: requiredMessage } : { valid: true, data: undefined };
+    try {
+        return { valid: true, data: JSON.parse(text) };
+    }
+    catch (error) {
+        return { valid: false, error: error instanceof Error ? error.message : String(error) };
+    }
+};
+/** Pretty-prints the text of a JSON field, or hands it back untouched when it does not parse. */
+export const formatJsonText = (text, indent = 2) => {
+    const result = parseJsonText(text);
+    if (!result.valid || result.data === undefined)
+        return text;
+    return JSON.stringify(result.data, null, indent);
+};

package/dist/components/pick.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The brand mark's outline, stated once. `Logo` strokes it; anything that wants the pick as a
+ * silhouette — the shell's avatar, a placeholder cut to the same shape — clips to it. Three
+ * copies of the same curve would drift the moment one of them is nudged.
+ *
+ * Drawn in a 32-unit square, and the curve is the mark's centre line: stroked at 3.5 it reaches
+ * 1.75 units past this on every side, so a fill of the same path is the smaller of the two shapes.
+ */
+export declare const PICK_PATH = "M16 3.6 C17.8 3.6 19 5 20 7 L25.1 17.2 C26.6 20 27 22 26.3 23.7 C24.7 27 20.9 28.6 16 28.6 C11.1 28.6 7.3 27 5.7 23.7 C5 22 5.4 20 6.9 17.2 L12 7 C13 5 14.2 3.6 16 3.6 Z";
+/**
+ * The same outline in the 0..1 space a `<clipPath clipPathUnits="objectBoundingBox">` wants, which
+ * is what makes one declaration fit an avatar of any size. CSS `clip-path: path()` cannot: its
+ * coordinates are user units and never scale with the box.
+ *
+ * Scaling every number in the string is only sound because the outline is `M`/`L`/`C` with
+ * absolute coordinates — an arc would carry sweep flags in the same stream and come out mangled.
+ */
+export declare const PICK_CLIP_PATH: string;

package/dist/components/pick.js

@@ -0,0 +1,18 @@
+/**
+ * The brand mark's outline, stated once. `Logo` strokes it; anything that wants the pick as a
+ * silhouette — the shell's avatar, a placeholder cut to the same shape — clips to it. Three
+ * copies of the same curve would drift the moment one of them is nudged.
+ *
+ * Drawn in a 32-unit square, and the curve is the mark's centre line: stroked at 3.5 it reaches
+ * 1.75 units past this on every side, so a fill of the same path is the smaller of the two shapes.
+ */
+export const PICK_PATH = "M16 3.6 C17.8 3.6 19 5 20 7 L25.1 17.2 C26.6 20 27 22 26.3 23.7 C24.7 27 20.9 28.6 16 28.6 C11.1 28.6 7.3 27 5.7 23.7 C5 22 5.4 20 6.9 17.2 L12 7 C13 5 14.2 3.6 16 3.6 Z";
+/**
+ * The same outline in the 0..1 space a `<clipPath clipPathUnits="objectBoundingBox">` wants, which
+ * is what makes one declaration fit an avatar of any size. CSS `clip-path: path()` cannot: its
+ * coordinates are user units and never scale with the box.
+ *
+ * Scaling every number in the string is only sound because the outline is `M`/`L`/`C` with
+ * absolute coordinates — an arc would carry sweep flags in the same stream and come out mangled.
+ */
+export const PICK_CLIP_PATH = PICK_PATH.replace(/[\d.]+/g, (value) => String(Number(value) / 32));

package/dist/components/segmented.d.ts

@@ -0,0 +1,7 @@
+/** One choice of a `SegmentedControl`. `id` is the value the control reports. */
+export interface SegmentedOption<Id extends string = string> {
+    id: Id;
+    label: string;
+    /** Shown but not pickable — a view that exists but has nothing to show right now. */
+    disabled?: boolean;
+}

package/dist/components/segmented.js

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

package/dist/components/select.d.ts

@@ -0,0 +1,66 @@
+/**
+ * One row of a `Select` or a `Combobox`.
+ *
+ * `value` is the identity: it is what the control binds, what `onchange` reports, and what the
+ * option list is keyed by, so two options may not share one. `label` is what a human reads, what
+ * the default matcher searches and what a `Combobox` puts in its text field — a code that only
+ * means something to the backend belongs in `value`, never in `label`.
+ */
+export interface SelectOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+/**
+ * Strips accents and case so that a search compares the letters a person meant rather than the
+ * ones they managed to type.
+ *
+ * `NFD` splits a precomposed letter into its base plus a combining mark — `á` becomes `a` + U+0301
+ * — and removing every mark leaves the base behind. Without it a Portuguese list is close to
+ * unsearchable: `Otávio`, `Itaipava` and `São Gonçalo` are all words a user types unaccented, and
+ * a plain `includes` finds none of them.
+ *
+ * `toLowerCase` and not `toLocaleLowerCase`: the locale-aware form maps `I` to `ı` under a Turkish
+ * locale, which would make the result depend on the machine the code runs on.
+ */
+export declare const normalizeForSearch: (text: string) => string;
+/**
+ * The matcher `Combobox` uses when no `filter` is passed: the label contains every word of the
+ * query, in any order, accent- and case-insensitive. Punctuation stays significant.
+ *
+ * Exported so a consumer who only wants to widen it — matching the value too, or a synonym list —
+ * can compose rather than reimplement the normalisation.
+ */
+export declare const matchesSelectQuery: (option: SelectOption, query: string) => boolean;
+/**
+ * The options whose `text` contains every word of the query, under the same folding as
+ * {@link matchesSelectQuery}; all of them for a blank query.
+ */
+export declare const filterOptions: <T>(options: readonly T[], query: string, text: (option: T) => string) => readonly T[];
+/**
+ * The first selectable index from `from`, walking in `delta`'s direction; `-1` when there is none.
+ *
+ * Both controls move a highlight over the same list under the same rule — a disabled row is
+ * stepped over rather than landed on — and the walk stops at the ends instead of wrapping, so
+ * holding an arrow key rests against the edge rather than cycling forever.
+ */
+export declare const nextSelectableIndex: (options: readonly SelectOption[], from: number, delta: number) => number;
+/** The selectable index at `index`, clamped to the list, else the nearest one after it, else before. */
+export declare const nearestSelectableIndex: (options: readonly SelectOption[], index: number) => number;
+/**
+ * The selectable option whose label starts with `typed`, folded, searching from `active` and
+ * wrapping around; `-1` when none does. One letter, or the same letter repeated, moves past
+ * `active` and so cycles through the labels starting with it; a longer prefix may stay on it.
+ */
+export declare const typeaheadMatch: (options: readonly SelectOption[], active: number, typed: string) => number;
+/** Whether a key press types a character: one character long, without Ctrl, Meta or Alt. */
+export declare const isTypedKey: (event: Pick<KeyboardEvent, "key" | "ctrlKey" | "metaKey" | "altKey">) => boolean;
+/** Characters typed within half a second of each other, gathered into one prefix. */
+export declare class Typeahead {
+    private typed;
+    private at;
+    /** Whether a character came in the last half second, so a Space extends the prefix. */
+    get typing(): boolean;
+    /** Adds a character and returns the prefix so far. */
+    add(char: string): string;
+}

package/dist/components/select.js

@@ -0,0 +1,90 @@
+/**
+ * Strips accents and case so that a search compares the letters a person meant rather than the
+ * ones they managed to type.
+ *
+ * `NFD` splits a precomposed letter into its base plus a combining mark — `á` becomes `a` + U+0301
+ * — and removing every mark leaves the base behind. Without it a Portuguese list is close to
+ * unsearchable: `Otávio`, `Itaipava` and `São Gonçalo` are all words a user types unaccented, and
+ * a plain `includes` finds none of them.
+ *
+ * `toLowerCase` and not `toLocaleLowerCase`: the locale-aware form maps `I` to `ı` under a Turkish
+ * locale, which would make the result depend on the machine the code runs on.
+ */
+export const normalizeForSearch = (text) => text.normalize("NFD").replace(/\p{M}/gu, "").toLowerCase();
+const searchWords = (query) => normalizeForSearch(query).split(/\s+/).filter(Boolean);
+const containsEveryWord = (text, words) => {
+    const haystack = normalizeForSearch(text);
+    return words.every((word) => haystack.includes(word));
+};
+/**
+ * The matcher `Combobox` uses when no `filter` is passed: the label contains every word of the
+ * query, in any order, accent- and case-insensitive. Punctuation stays significant.
+ *
+ * Exported so a consumer who only wants to widen it — matching the value too, or a synonym list —
+ * can compose rather than reimplement the normalisation.
+ */
+export const matchesSelectQuery = (option, query) => containsEveryWord(option.label, searchWords(query));
+/**
+ * The options whose `text` contains every word of the query, under the same folding as
+ * {@link matchesSelectQuery}; all of them for a blank query.
+ */
+export const filterOptions = (options, query, text) => {
+    const words = searchWords(query);
+    if (words.length === 0)
+        return options;
+    return options.filter((option) => containsEveryWord(text(option), words));
+};
+/**
+ * The first selectable index from `from`, walking in `delta`'s direction; `-1` when there is none.
+ *
+ * Both controls move a highlight over the same list under the same rule — a disabled row is
+ * stepped over rather than landed on — and the walk stops at the ends instead of wrapping, so
+ * holding an arrow key rests against the edge rather than cycling forever.
+ */
+export const nextSelectableIndex = (options, from, delta) => {
+    for (let index = from; index >= 0 && index < options.length; index += delta)
+        if (!options[index].disabled)
+            return index;
+    return -1;
+};
+/** The selectable index at `index`, clamped to the list, else the nearest one after it, else before. */
+export const nearestSelectableIndex = (options, index) => {
+    const from = Math.min(Math.max(index, 0), options.length - 1);
+    const after = nextSelectableIndex(options, from, 1);
+    return after >= 0 ? after : nextSelectableIndex(options, from, -1);
+};
+/**
+ * The selectable option whose label starts with `typed`, folded, searching from `active` and
+ * wrapping around; `-1` when none does. One letter, or the same letter repeated, moves past
+ * `active` and so cycles through the labels starting with it; a longer prefix may stay on it.
+ */
+export const typeaheadMatch = (options, active, typed) => {
+    if (options.length === 0 || typed === "")
+        return -1;
+    const cycling = typed === typed[0].repeat(typed.length);
+    const prefix = normalizeForSearch(cycling ? typed[0] : typed);
+    for (let offset = cycling ? 1 : 0; offset <= options.length; offset++) {
+        const index = (((active + offset) % options.length) + options.length) % options.length;
+        const candidate = options[index];
+        if (!candidate.disabled && normalizeForSearch(candidate.label).startsWith(prefix))
+            return index;
+    }
+    return -1;
+};
+/** Whether a key press types a character: one character long, without Ctrl, Meta or Alt. */
+export const isTypedKey = (event) => event.key.length === 1 && !event.ctrlKey && !event.metaKey && !event.altKey;
+/** Characters typed within half a second of each other, gathered into one prefix. */
+export class Typeahead {
+    typed = "";
+    at = -Infinity;
+    /** Whether a character came in the last half second, so a Space extends the prefix. */
+    get typing() {
+        return Date.now() - this.at < 500;
+    }
+    /** Adds a character and returns the prefix so far. */
+    add(char) {
+        this.typed = this.typing ? this.typed + char : char;
+        this.at = Date.now();
+        return this.typed;
+    }
+}