@rivetjs/cdk 0.0.0-stage → 0.1.0-alpha.0

package/_adapters/grid-selection.js

@@ -0,0 +1,436 @@
+// Multiple selection: serializable state (react-stately useMultipleSelectionState) and the transient
+// SelectionManager that reads/updates it against a collection. Ported from react-spectrum
+// (Apache-2.0, © Adobe): packages/react-stately/src/selection/{Selection,useMultipleSelectionState,
+// SelectionManager}.ts.
+//
+// LOCAL ADAPTER (aria-grid-tree): stands in for the cdk-collections branch until its API is published.
+//
+// Rivet idioms / deviations:
+// - State is a plain object of signals + JSON (resumable). React's `Selection extends Set` carried
+//   `anchorKey` / `currentKey` on the set; here they are separate signals (class instances do not
+//   serialize). `Selection` remains as the transient value the manager builds.
+// - `selectedKeys` controlled = a caller `Signal<SelectionValue>` (two-way); `onSelectionChange`
+//   (R2 symbol) fires on every committed change like React's controlled callback.
+// - The manager is created per event (`new SelectionManager(collection, state)`); in bindings use
+//   `isKeySelected(state, key)` (no collection needed).
+import { signal, untrack } from "@rivetjs/reactivity";
+import { compareNodeOrder, getChildNodes, getFirstItem, } from "./collection.js";
+/** Transient selection value: a key set with the range anchor and the current (range end) key. */
+export class Selection extends Set {
+    anchorKey;
+    currentKey;
+    constructor(keys, anchorKey, currentKey) {
+        super(keys);
+        if (keys instanceof Selection) {
+            this.anchorKey = anchorKey ?? keys.anchorKey;
+            this.currentKey = currentKey ?? keys.currentKey;
+        }
+        else {
+            this.anchorKey = anchorKey ?? null;
+            this.currentKey = currentKey ?? null;
+        }
+    }
+}
+const toSelection = (value) => value == null ? undefined : value === "all" ? "all" : new Set(value);
+export function createMultipleSelectionState(props = {}) {
+    const behaviour = props.selectionBehavior ?? "toggle";
+    return {
+        selectionMode: props.selectionMode ?? "none",
+        disallowEmptySelection: props.disallowEmptySelection ?? false,
+        selectionBehaviorProp: behaviour,
+        selectionBehavior: signal(behaviour),
+        selectedKeys: props.selectedKeys ?? signal(toSelection(props.defaultSelectedKeys) ?? new Set()),
+        anchorKey: signal(null),
+        currentKey: signal(null),
+        disabledKeys: new Set(props.disabledKeys ?? []),
+        disabledBehavior: props.disabledBehavior ?? "all",
+        allowDuplicateSelectionEvents: props.allowDuplicateSelectionEvents ?? false,
+        isFocused: signal(false),
+        focusedKey: signal(null),
+        childFocusStrategy: signal(null),
+        onSelectionChange: props.onSelectionChange,
+    };
+}
+function equalSets(a, b) {
+    if (a === "all" || b === "all")
+        return a === b;
+    if (a.size !== b.size)
+        return false;
+    for (const item of a)
+        if (!b.has(item))
+            return false;
+    return true;
+}
+/** Commit `keys` (react-stately `setSelectedKeys` incl. the duplicate-event guard). */
+export function setSelectedKeys(state, keys) {
+    const current = untrack(state.selectedKeys);
+    if (keys !== "all") {
+        state.anchorKey.set(keys.anchorKey);
+        state.currentKey.set(keys.currentKey);
+    }
+    if (!state.allowDuplicateSelectionEvents && equalSets(keys, current))
+        return;
+    const value = keys === "all" ? "all" : new Set(keys);
+    state.selectedKeys.set(value);
+    // `selectionBehavior="replace"` that switched to toggle (touch long press) resets once empty.
+    if (state.selectionBehaviorProp === "replace" && value !== "all" && value.size === 0)
+        state.selectionBehavior.set("replace");
+    state.onSelectionChange?.(value);
+}
+/** Focus setters (react-stately FocusState). */
+export function setFocusedKey(state, key, childFocusStrategy = "first") {
+    state.focusedKey.set(key);
+    state.childFocusStrategy.set(childFocusStrategy);
+}
+/**
+ * Whether `key` is selected, for render bindings (reads `selectedKeys`). `itemDisabled`: the item is
+ * disabled (an `"all"` selection does not include it).
+ */
+export function isKeySelected(state, key, itemDisabled = false) {
+    if (state.selectionMode === "none")
+        return false;
+    const keys = state.selectedKeys();
+    if (keys === "all")
+        return !itemDisabled && !hasKey(state.disabledKeys, key);
+    return hasKey(keys, key);
+}
+/** Whether the item is disabled for interaction (react-stately `isDisabled`), from state + item flags. */
+export function isKeyDisabled(state, key, itemDisabled = false, itemDisabledBehavior) {
+    return state.disabledBehavior === "all" && (hasKey(state.disabledKeys, key) || itemDisabled) && itemDisabledBehavior !== "selection";
+}
+/** Keys compare as strings: DOM keys are attribute strings, data keys may be numbers. */
+export function hasKey(set, key) {
+    if (set.has(key))
+        return true;
+    const text = String(key);
+    for (const k of set)
+        if (String(k) === text)
+            return true;
+    return false;
+}
+/** react-stately SelectionManager over a collection + the serializable state. Create per event. */
+export class SelectionManager {
+    collection;
+    state;
+    allowsCellSelection;
+    _isSelectAll = null;
+    layoutDelegate;
+    fullCollection;
+    constructor(collection, state, options) {
+        this.collection = collection;
+        this.state = state;
+        this.allowsCellSelection = options?.allowsCellSelection ?? false;
+        this.layoutDelegate = options?.layoutDelegate || null;
+        this.fullCollection = options?.fullCollection || null;
+    }
+    get keys() {
+        return untrack(this.state.selectedKeys);
+    }
+    get selectionMode() {
+        return this.state.selectionMode;
+    }
+    get disallowEmptySelection() {
+        return this.state.disallowEmptySelection;
+    }
+    get selectionBehavior() {
+        return untrack(this.state.selectionBehavior);
+    }
+    setSelectionBehavior(selectionBehavior) {
+        this.state.selectionBehavior.set(selectionBehavior);
+    }
+    get isFocused() {
+        return untrack(this.state.isFocused);
+    }
+    setFocused(isFocused) {
+        this.state.isFocused.set(isFocused);
+    }
+    get focusedKey() {
+        return untrack(this.state.focusedKey);
+    }
+    get childFocusStrategy() {
+        return untrack(this.state.childFocusStrategy);
+    }
+    setFocusedKey(key, childFocusStrategy) {
+        if (key == null || this.collection.getItem(key))
+            setFocusedKey(this.state, key, childFocusStrategy);
+    }
+    get selectedKeys() {
+        const keys = this.keys;
+        return keys === "all" ? new Set(this.getSelectAllKeys()) : this.normalized(keys);
+    }
+    /** Raw selection: `"all"` or the key set. */
+    get rawSelection() {
+        return this.keys;
+    }
+    /** The state's keys mapped onto the collection's key identity (string DOM keys vs number data keys). */
+    normalized(keys) {
+        const out = new Set();
+        for (const key of keys)
+            out.add(this.collectionKey(key));
+        return out;
+    }
+    collectionKey(key) {
+        if (this.collection.getItem(key))
+            return key;
+        const alt = typeof key === "number" ? String(key) : Number(key);
+        return typeof alt === "number" && Number.isNaN(alt) ? key : this.collection.getItem(alt) ? alt : key;
+    }
+    has(keys, key) {
+        return hasKey(keys, key);
+    }
+    isSelected(key) {
+        if (this.state.selectionMode === "none")
+            return false;
+        const mapped = this.getKey(key);
+        if (mapped == null)
+            return false;
+        const keys = this.keys;
+        return keys === "all" ? this.canSelectItem(mapped) : this.has(keys, mapped);
+    }
+    get isEmpty() {
+        const keys = this.keys;
+        return keys !== "all" && keys.size === 0;
+    }
+    get isSelectAll() {
+        if (this.isEmpty)
+            return false;
+        const keys = this.keys;
+        if (keys === "all")
+            return true;
+        if (this._isSelectAll != null)
+            return this._isSelectAll;
+        const all = this.getSelectAllKeys();
+        this._isSelectAll = all.every((k) => this.has(keys, k));
+        return this._isSelectAll;
+    }
+    get firstSelectedKey() {
+        let first = null;
+        const keys = this.keys;
+        if (keys === "all")
+            return this.getSelectAllKeys()[0] ?? null;
+        for (const key of keys) {
+            const item = this.collection.getItem(this.collectionKey(key));
+            if (!first || (item && compareNodeOrder(this.collection, item, first) < 0))
+                first = item;
+        }
+        return first?.key ?? null;
+    }
+    get lastSelectedKey() {
+        let last = null;
+        const keys = this.keys;
+        if (keys === "all") {
+            const all = this.getSelectAllKeys();
+            return all[all.length - 1] ?? null;
+        }
+        for (const key of keys) {
+            const item = this.collection.getItem(this.collectionKey(key));
+            if (!last || (item && compareNodeOrder(this.collection, item, last) > 0))
+                last = item;
+        }
+        return last?.key ?? null;
+    }
+    get disabledKeys() {
+        return this.state.disabledKeys;
+    }
+    get disabledBehavior() {
+        return this.state.disabledBehavior;
+    }
+    extendSelection(toKey) {
+        if (this.selectionMode === "none")
+            return;
+        if (this.selectionMode === "single") {
+            this.replaceSelection(toKey);
+            return;
+        }
+        const mappedToKey = this.getKey(toKey);
+        if (mappedToKey == null)
+            return;
+        let selection;
+        const keys = this.keys;
+        if (keys === "all")
+            selection = new Selection([mappedToKey], mappedToKey, mappedToKey);
+        else {
+            const current = new Selection(this.normalized(keys), untrack(this.state.anchorKey), untrack(this.state.currentKey));
+            const anchorKey = current.anchorKey != null ? this.collectionKey(current.anchorKey) : mappedToKey;
+            selection = new Selection(current, anchorKey, mappedToKey);
+            for (const key of this.getKeyRange(anchorKey, current.currentKey != null ? this.collectionKey(current.currentKey) : mappedToKey))
+                selection.delete(key);
+            for (const key of this.getKeyRange(mappedToKey, anchorKey))
+                if (this.canSelectItem(key))
+                    selection.add(key);
+        }
+        setSelectedKeys(this.state, selection);
+    }
+    getKeyRange(from, to) {
+        const fromItem = this.collection.getItem(from), toItem = this.collection.getItem(to);
+        if (fromItem && toItem) {
+            if (compareNodeOrder(this.collection, fromItem, toItem) <= 0)
+                return this.getKeyRangeInternal(from, to);
+            return this.getKeyRangeInternal(to, from);
+        }
+        return [];
+    }
+    getKeyRangeInternal(from, to) {
+        if (this.layoutDelegate?.getKeyRange)
+            return this.layoutDelegate.getKeyRange(from, to);
+        const keys = [];
+        let key = from;
+        while (key != null) {
+            const item = this.collection.getItem(key);
+            if (item && (item.type === "item" || (item.type === "cell" && this.allowsCellSelection)))
+                keys.push(key);
+            if (key === to)
+                return keys;
+            key = this.collection.getKeyAfter(key);
+        }
+        return [];
+    }
+    getKey(key) {
+        key = this.collectionKey(key);
+        let item = this.collection.getItem(key);
+        if (!item)
+            return key;
+        if (item.type === "cell" && this.allowsCellSelection)
+            return key;
+        while (item && item.type !== "item" && item.parentKey != null)
+            item = this.collection.getItem(item.parentKey);
+        if (!item || item.type !== "item")
+            return null;
+        return item.key;
+    }
+    toggleSelection(key) {
+        if (this.selectionMode === "none")
+            return;
+        if (this.selectionMode === "single" && !this.isSelected(key)) {
+            this.replaceSelection(key);
+            return;
+        }
+        const mappedKey = this.getKey(key);
+        if (mappedKey == null)
+            return;
+        const raw = this.keys;
+        const keys = new Selection(raw === "all" ? this.getSelectAllKeys() : this.normalized(raw), untrack(this.state.anchorKey), untrack(this.state.currentKey));
+        if (keys.has(mappedKey))
+            keys.delete(mappedKey);
+        else if (this.canSelectItem(mappedKey)) {
+            keys.add(mappedKey);
+            keys.anchorKey = mappedKey;
+            keys.currentKey = mappedKey;
+        }
+        if (this.disallowEmptySelection && keys.size === 0)
+            return;
+        setSelectedKeys(this.state, keys);
+    }
+    replaceSelection(key) {
+        if (this.selectionMode === "none")
+            return;
+        const mappedKey = this.getKey(key);
+        if (mappedKey == null)
+            return;
+        const selection = this.canSelectItem(mappedKey) ? new Selection([mappedKey], mappedKey, mappedKey) : new Selection();
+        setSelectedKeys(this.state, selection);
+    }
+    setSelectedKeys(keys) {
+        if (this.selectionMode === "none")
+            return;
+        const selection = new Selection();
+        for (const key of keys) {
+            const mappedKey = this.getKey(key);
+            if (mappedKey != null) {
+                selection.add(mappedKey);
+                if (this.selectionMode === "single")
+                    break;
+            }
+        }
+        setSelectedKeys(this.state, selection);
+    }
+    getSelectAllKeys() {
+        const collection = this.fullCollection ?? this.collection;
+        const keys = [];
+        const addKeys = (key) => {
+            while (key != null) {
+                if (this.canSelectItemIn(key, collection)) {
+                    const item = collection.getItem(key);
+                    if (item?.type === "item")
+                        keys.push(key);
+                    if (item?.hasChildNodes && (this.allowsCellSelection || item.type !== "item"))
+                        addKeys(getFirstItem(getChildNodes(item, collection))?.key ?? null);
+                }
+                key = collection.getKeyAfter(key);
+            }
+        };
+        addKeys(collection.getFirstKey());
+        return keys;
+    }
+    selectAll() {
+        if (!this.isSelectAll && this.selectionMode === "multiple")
+            setSelectedKeys(this.state, "all");
+    }
+    clearSelection() {
+        const keys = this.keys;
+        if (!this.disallowEmptySelection && (keys === "all" || keys.size > 0))
+            setSelectedKeys(this.state, new Selection());
+    }
+    toggleSelectAll() {
+        if (this.isSelectAll)
+            this.clearSelection();
+        else
+            this.selectAll();
+    }
+    select(key, e) {
+        if (this.selectionMode === "none")
+            return;
+        if (this.selectionMode === "single") {
+            if (this.isSelected(key) && !this.disallowEmptySelection)
+                this.toggleSelection(key);
+            else
+                this.replaceSelection(key);
+        }
+        else if (this.selectionBehavior === "toggle" || (e && (e.pointerType === "touch" || e.pointerType === "virtual")))
+            this.toggleSelection(key);
+        else
+            this.replaceSelection(key);
+    }
+    isSelectionEqual(selection) {
+        if (selection === this.keys)
+            return true;
+        const selected = this.selectedKeys;
+        if (selection.size !== selected.size)
+            return false;
+        for (const key of selection)
+            if (!this.has(selected, key))
+                return false;
+        for (const key of selected)
+            if (!this.has(selection, key))
+                return false;
+        return true;
+    }
+    canSelectItem(key) {
+        return this.canSelectItemIn(key, this.collection);
+    }
+    canSelectItemIn(key, collection) {
+        if (this.state.selectionMode === "none" || hasKey(this.state.disabledKeys, key))
+            return false;
+        const item = collection.getItem(key);
+        if (!item || item.props?.isDisabled || (item.type === "cell" && !this.allowsCellSelection))
+            return false;
+        return true;
+    }
+    isDisabled(key) {
+        const item = this.collection.getItem(key);
+        return this.state.disabledBehavior === "all" && (hasKey(this.state.disabledKeys, key) || !!item?.props?.isDisabled) && item?.props?.disabledBehavior !== "selection";
+    }
+    isLink(key) {
+        return !!this.collection.getItem(key)?.props?.href;
+    }
+    getItemProps(key) {
+        return this.collection.getItem(key)?.props;
+    }
+    withCollection(collection) {
+        return new SelectionManager(collection, this.state, {
+            allowsCellSelection: this.allowsCellSelection,
+            layoutDelegate: this.layoutDelegate || undefined,
+            fullCollection: this.fullCollection ?? this.collection,
+        });
+    }
+}

package/_adapters/interactions.d.ts

@@ -0,0 +1,19 @@
+import type { PressEvent as AriaPressEvent } from "../interactions/press.jsx";
+import type { PointerType } from "../interactions/utils.js";
+export type { PointerType } from "../interactions/utils.js";
+export type { Modality } from "../interactions/focus-visible.jsx";
+export { getInteractionModality, isFocusVisible, noteModality, setInteractionModality } from "../interactions/focus-visible.jsx";
+export { isVirtualClick, isVirtualPointerEvent } from "../platform/index.js";
+export { focusSafely } from "../focus/index.js";
+export { focusWithoutScrolling } from "../utils/index.js";
+export { isOpeningLink, openLink, shouldClientNavigate, type Modifiers } from "../utils/links.jsx";
+export { scrollIntoView, scrollIntoViewport } from "../utils/dom.js";
+export { dispatchVirtualBlur, dispatchVirtualFocus, getVirtuallyFocusedElement, moveVirtualFocus, pointerTypeOf } from "../selection/dom-utils.js";
+export { CLEAR_FOCUS_EVENT, FOCUS_EVENT } from "../selection/selectable-collection.js";
+/** react-aria `PressEvent` (the fields the collection behaviours read). */
+export type PressEvent = AriaPressEvent;
+/** A `PressEvent` for a delegated handler (`continuePropagation` is a no-op: the handler owns propagation). */
+export declare function pressEvent(type: PressEvent["type"], pointerType: PointerType, target: HTMLElement, e: Event): PressEvent;
+/** Start a long-press timer for `owner` (react-aria `useLongPress`, 500 ms default threshold). */
+export declare function startLongPress(owner: object, onLongPress: () => void, threshold?: number): void;
+export declare function cancelLongPress(owner: object): boolean;

package/_adapters/interactions.js

@@ -0,0 +1,45 @@
+export { getInteractionModality, isFocusVisible, noteModality, setInteractionModality } from "../interactions/focus-visible.jsx";
+export { isVirtualClick, isVirtualPointerEvent } from "../platform/index.js";
+export { focusSafely } from "../focus/index.js";
+export { focusWithoutScrolling } from "../utils/index.js";
+export { isOpeningLink, openLink, shouldClientNavigate } from "../utils/links.jsx";
+export { scrollIntoView, scrollIntoViewport } from "../utils/dom.js";
+export { dispatchVirtualBlur, dispatchVirtualFocus, getVirtuallyFocusedElement, moveVirtualFocus, pointerTypeOf } from "../selection/dom-utils.js";
+export { CLEAR_FOCUS_EVENT, FOCUS_EVENT } from "../selection/selectable-collection.js";
+/** A `PressEvent` for a delegated handler (`continuePropagation` is a no-op: the handler owns propagation). */
+export function pressEvent(type, pointerType, target, e) {
+    const m = e;
+    const rect = target.getBoundingClientRect();
+    return {
+        type,
+        pointerType,
+        target,
+        shiftKey: !!m.shiftKey,
+        ctrlKey: !!m.ctrlKey,
+        metaKey: !!m.metaKey,
+        altKey: !!m.altKey,
+        ...(m.key !== undefined ? { key: m.key } : {}),
+        x: (m.clientX ?? rect.left) - rect.left,
+        y: (m.clientY ?? rect.top) - rect.top,
+        continuePropagation() { },
+    };
+}
+// --- Long press (useLongPress) -----------------------------------------------------------------
+const DEFAULT_THRESHOLD = 500;
+const timers = new WeakMap();
+/** Start a long-press timer for `owner` (react-aria `useLongPress`, 500 ms default threshold). */
+export function startLongPress(owner, onLongPress, threshold = DEFAULT_THRESHOLD) {
+    cancelLongPress(owner);
+    timers.set(owner, setTimeout(() => {
+        timers.delete(owner);
+        onLongPress();
+    }, threshold));
+}
+export function cancelLongPress(owner) {
+    const timer = timers.get(owner);
+    if (timer === undefined)
+        return false;
+    clearTimeout(timer);
+    timers.delete(owner);
+    return true;
+}

package/_adapters/intl.d.ts

@@ -0,0 +1,8 @@
+/** Locale → message key → ICU message. */
+export type LocalizedStrings = Readonly<Record<string, Readonly<Record<string, string>>>>;
+/** Locale of `element` (nearest `lang`), else the document's, else the browser's, else `en-US`. */
+export declare function localeOf(element?: Element | null): string;
+/** Messages of the best matching locale: exact, then same language, then `en-US`. */
+export declare function stringsFor(strings: LocalizedStrings, locale?: string): Readonly<Record<string, string>>;
+/** Format `key` of `strings` for `locale` with ICU arguments (react-aria `stringFormatter.format`). */
+export declare function formatMessage(strings: LocalizedStrings, locale: string | undefined, key: string, args?: Record<string, unknown>): string;

package/_adapters/intl.js

@@ -0,0 +1,106 @@
+// Ported from react-spectrum (@internationalized/string LocalizedStringDictionary /
+// LocalizedStringFormatter, react-aria i18n/useLocalizedStringFormatter), Apache-2.0, © Adobe.
+//
+// LOCAL ADAPTER: localized strings of a module (`<module>/intl.ts`: every locale of the original's
+// `intl/<module>/*.json`, plain data) and a small ICU subset formatter (`{arg}`, `plural` with `#`
+// and `=n`, `select`). No import-time globals: number formats / plural rules are created on first use
+// and cached (`i18n/intl-cache.ts`).
+import { cachedIntl } from "../i18n/intl-cache.js";
+/** Locale of `element` (nearest `lang`), else the document's, else the browser's, else `en-US`. */
+export function localeOf(element) {
+    const lang = element?.closest("[lang]")?.getAttribute("lang") || (typeof document !== "undefined" ? document.documentElement.lang : "");
+    return lang || (typeof navigator !== "undefined" ? navigator.language : "") || "en-US";
+}
+/** Messages of the best matching locale: exact, then same language, then `en-US`. */
+export function stringsFor(strings, locale = "en-US") {
+    if (strings[locale])
+        return strings[locale];
+    const language = locale.split("-")[0].toLowerCase();
+    for (const key of Object.keys(strings))
+        if (key.split("-")[0].toLowerCase() === language)
+            return strings[key];
+    return strings["en-US"] ?? {};
+}
+/** Format `key` of `strings` for `locale` with ICU arguments (react-aria `stringFormatter.format`). */
+export function formatMessage(strings, locale, key, args = {}) {
+    const message = stringsFor(strings, locale)[key] ?? stringsFor(strings, "en-US")[key] ?? key;
+    return format(message, args, locale ?? "en-US");
+}
+// --- ICU subset ------------------------------------------------------------------------------
+function format(message, args, locale, hash) {
+    let out = "";
+    let i = 0;
+    while (i < message.length) {
+        const c = message[i];
+        if (c === "{") {
+            const end = matching(message, i);
+            out += argument(message.slice(i + 1, end), args, locale);
+            i = end + 1;
+        }
+        else if (c === "#" && hash !== undefined) {
+            out += hash;
+            i++;
+        }
+        else if (c === "'" && message[i + 1] === "'") {
+            out += "'";
+            i += 2;
+        }
+        else {
+            out += c;
+            i++;
+        }
+    }
+    return out;
+}
+function matching(message, open) {
+    let depth = 0;
+    for (let i = open; i < message.length; i++) {
+        if (message[i] === "{")
+            depth++;
+        else if (message[i] === "}" && --depth === 0)
+            return i;
+    }
+    return message.length - 1;
+}
+function argument(body, args, locale) {
+    const first = body.indexOf(",");
+    if (first < 0)
+        return String(args[body.trim()] ?? "");
+    const name = body.slice(0, first).trim();
+    const rest = body.slice(first + 1);
+    const second = rest.indexOf(",");
+    const type = (second < 0 ? rest : rest.slice(0, second)).trim();
+    const value = args[name];
+    if (type === "number")
+        return cachedIntl(Intl.NumberFormat, locale).format(Number(value));
+    if (second < 0)
+        return String(value ?? "");
+    const options = cases(rest.slice(second + 1));
+    if (type === "plural" || type === "selectordinal") {
+        const n = Number(value);
+        const exact = options.get("=" + n);
+        const hash = cachedIntl(Intl.NumberFormat, locale).format(n);
+        if (exact !== undefined)
+            return format(exact, args, locale, hash);
+        const rule = cachedIntl(Intl.PluralRules, locale, { type: type === "plural" ? "cardinal" : "ordinal" }).select(n);
+        return format(options.get(rule) ?? options.get("other") ?? "", args, locale, hash);
+    }
+    // select
+    return format(options.get(String(value)) ?? options.get("other") ?? "", args, locale);
+}
+function cases(source) {
+    const map = new Map();
+    let i = 0;
+    while (i < source.length) {
+        while (i < source.length && /\s/.test(source[i]))
+            i++;
+        const open = source.indexOf("{", i);
+        if (open < 0)
+            break;
+        const selector = source.slice(i, open).trim();
+        const close = matching(source, open);
+        map.set(selector, source.slice(open + 1, close));
+        i = close + 1;
+    }
+    return map;
+}

package/_adapters/press.d.ts

@@ -0,0 +1,22 @@
+import type { PointerType } from "../interactions/utils.js";
+export type { PointerType } from "../interactions/utils.js";
+export type { Modality } from "../interactions/focus-visible.jsx";
+export { getInteractionModality, setInteractionModality } from "../interactions/focus-visible.jsx";
+export { isVirtualClick, isVirtualPointerEvent } from "../platform/index.js";
+export { pressEvent, type PressEvent } from "./interactions.js";
+export { pointerTypeOf } from "../selection/dom-utils.js";
+interface PressTrack {
+    pointerType: PointerType;
+    target: Element;
+    longPressTimer?: ReturnType<typeof setTimeout>;
+    longPressed?: boolean;
+    key?: string;
+}
+/** Start tracking a press on `target` for `owner` (pointer down / key down). */
+export declare function beginPress(owner: object, target: Element, pointerType: PointerType, key?: string): PressTrack;
+/** The press in progress for `owner`, if any. */
+export declare const currentPress: (owner: object) => PressTrack | undefined;
+/** End the press: returns it (and forgets it). */
+export declare function endPress(owner: object): PressTrack | undefined;
+/** Arm a long press (react-aria useLongPress, default threshold 500 ms). */
+export declare function armLongPress(owner: object, onLongPress: () => void, threshold?: number): void;

package/_adapters/press.js

@@ -0,0 +1,34 @@
+export { getInteractionModality, setInteractionModality } from "../interactions/focus-visible.jsx";
+export { isVirtualClick, isVirtualPointerEvent } from "../platform/index.js";
+export { pressEvent } from "./interactions.js";
+export { pointerTypeOf } from "../selection/dom-utils.js";
+const tracks = new WeakMap();
+/** Start tracking a press on `target` for `owner` (pointer down / key down). */
+export function beginPress(owner, target, pointerType, key) {
+    const previous = tracks.get(owner);
+    if (previous?.longPressTimer)
+        clearTimeout(previous.longPressTimer);
+    const track = { pointerType, target, key };
+    tracks.set(owner, track);
+    return track;
+}
+/** The press in progress for `owner`, if any. */
+export const currentPress = (owner) => tracks.get(owner);
+/** End the press: returns it (and forgets it). */
+export function endPress(owner) {
+    const track = tracks.get(owner);
+    if (track?.longPressTimer)
+        clearTimeout(track.longPressTimer);
+    tracks.delete(owner);
+    return track;
+}
+/** Arm a long press (react-aria useLongPress, default threshold 500 ms). */
+export function armLongPress(owner, onLongPress, threshold = 500) {
+    const track = tracks.get(owner);
+    if (!track)
+        return;
+    track.longPressTimer = setTimeout(() => {
+        track.longPressed = true;
+        onLongPress();
+    }, threshold);
+}