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

package/collections/list-state.js

@@ -0,0 +1,156 @@
+// Ported from @react-stately/list (useListState.ts, useSingleSelectListState.ts), Apache-2.0, © Adobe.
+//
+// List state (collection-class form) for list-like components: ListBox, Select, ComboBox, Menu, GridList, TagGroup:
+// `items` / `children` (or DOM / pre-built collection) plus multiple-selection + focus state.
+//
+// Rivet: the state object is serializable (signals + plain data + resumable functions). The
+// collection and the `SelectionManager` are class instances, so they are derived on demand:
+// `listCollection(state)` / `listSelectionManager(state)` (cached per state and items array; a
+// resumed handler rebuilds them from the state). React's `state.selectionManager.x` is
+// `listSelectionManager(state).x`.
+import { signal, untrack } from "@rivetjs/reactivity";
+import { createId } from "@rivetjs/cdk/id";
+import { CollectionBuilder, Item as CollectionItem, createCollection } from "@rivetjs/cdk/collections/builder";
+import { ListCollection } from "@rivetjs/cdk/collections/list";
+import { SelectionManager } from "@rivetjs/cdk/selection/manager";
+import { createMultipleSelectionState } from "@rivetjs/cdk/selection/state";
+import { BaseCollection } from "@rivetjs/cdk/collections/base";
+import { domCollection } from "@rivetjs/cdk/collections/dom";
+import { isSlot } from "@rivetjs/runtime/slot";
+/** Default renderer for `items` without `children`: `{ key | id, label | name | textValue, … }` objects. */
+export function defaultItemRenderer(item) {
+    const label = item.label ?? item.name ?? item.textValue ?? "";
+    return CollectionItem({
+        key: item.key ?? item.id,
+        textValue: item.textValue ?? (typeof label === "string" ? label : ""),
+        children: label,
+        isDisabled: item.isDisabled ?? item.disabled,
+        href: item.href,
+        description: item.description,
+    });
+}
+/** `children` as collection children: elements (a compiler slot is resolved) or a renderer. */
+function collectionChildren(children) {
+    if (children == null)
+        return undefined;
+    return (isSlot(children) ? children() : children);
+}
+/**
+ * Provides state management for list-like components (react-stately `useListState`): builds the
+ * collection inputs, and manages multiple selection + focus state.
+ */
+export function createListState(options) {
+    const disabledKeys = new Set(options.disabledKeys ?? []);
+    const selectionState = createMultipleSelectionState({ ...options, disabledKeys });
+    return {
+        id: options.id ?? createId(),
+        selectionState,
+        disabledKeys,
+        items: options.items,
+        children: collectionChildren(options.children),
+        collection: options.collection,
+        filter: options.filter,
+        suppressTextValueWarning: !!options.suppressTextValueWarning,
+        layoutDelegate: options.layoutDelegate,
+    };
+}
+const collections = new WeakMap();
+/**
+ * The collection of a list state (react-stately `state.collection`). Rebuilt when the items array
+ * changes; reads `items` when it is an accessor (tracked in bindings).
+ */
+export function listCollection(state, root) {
+    const provided = state.collection;
+    if (provided)
+        return typeof provided === "function" ? provided() : provided;
+    if (state.items == null && state.children == null) {
+        // Live RAC parts: the rendered items are the collection.
+        const el = root ?? (typeof document !== "undefined" ? document.getElementById(state.id) : null);
+        const dom = el ? domCollection(el) : new BaseCollection();
+        return state.filter ? new ListCollection(state.filter(dom)) : dom;
+    }
+    const items = typeof state.items === "function" ? state.items() : state.items;
+    const cached = collections.get(state);
+    if (cached && cached.items === items)
+        return cached.collection;
+    const builder = cached?.builder ?? new CollectionBuilder();
+    const children = state.children ?? (items ? defaultItemRenderer : null);
+    const collection = createCollection({ children, items: items }, (nodes) => (state.filter ? new ListCollection(state.filter(nodes)) : new ListCollection(nodes)), { suppressTextValueWarning: state.suppressTextValueWarning || !state.children }, builder);
+    collections.set(state, { items, collection, builder });
+    return collection;
+}
+/** The selection manager of a list state (react-stately `state.selectionManager`). */
+export function listSelectionManager(state, collection = listCollection(state)) {
+    return new SelectionManager(collection, state.selectionState, { layoutDelegate: state.layoutDelegate });
+}
+/**
+ * Reset the focused key when its item left the collection (react-stately `useFocusedKeyReset`):
+ * walk forward in the previous collection to the next key still present and enabled, else
+ * backward. Call from an effect when the items change.
+ */
+export function resetFocusedKey(state, previous, collection = listCollection(state)) {
+    const manager = listSelectionManager(state, collection);
+    const focusedKey = untrack(() => manager.focusedKey);
+    if (focusedKey == null || collection.getItem(focusedKey))
+        return;
+    let next = null;
+    for (let key = previous.getKeyAfter(focusedKey); key != null; key = previous.getKeyAfter(key)) {
+        const node = collection.getItem(key);
+        if (node && node.type === "item" && !manager.isDisabled(key)) {
+            next = key;
+            break;
+        }
+    }
+    if (next == null) {
+        for (let key = previous.getKeyBefore(focusedKey); key != null; key = previous.getKeyBefore(key)) {
+            const node = collection.getItem(key);
+            if (node && node.type === "item" && !manager.isDisabled(key)) {
+                next = key;
+                break;
+            }
+        }
+    }
+    manager.setFocusedKey(next);
+}
+/** Filters a list state's collection (react-stately `UNSTABLE_useFilteredListState`). */
+export function filteredListCollection(state, filterFn) {
+    const collection = listCollection(state);
+    return filterFn && collection.filter ? collection.filter(filterFn) : collection;
+}
+const isKeySignal = (value) => typeof value === "function" && typeof value.set === "function";
+/**
+ * Provides state management for list-like components with single selection (react-stately
+ * `useSingleSelectListState`): the selection is backed by `selectedKey`; disallowEmptySelection,
+ * and onSelectionChange fires even when the same key is chosen again.
+ */
+export function createSingleSelectListState(options) {
+    const prop = options.selectedKey;
+    const controlled = prop !== undefined && !isKeySignal(prop);
+    const selectedKey = isKeySignal(prop) ? prop : signal(controlled ? prop : (options.defaultSelectedKey ?? null));
+    const { onSelectionChange, ...rest } = options;
+    const state = createListState({
+        ...rest,
+        selectionMode: "single",
+        disallowEmptySelection: true,
+        allowDuplicateSelectionEvents: true,
+        selectedKey,
+        selectedKeyControlled: controlled,
+        onSelectedKeyChange: onSelectionChange,
+    });
+    return { ...state, selectedKey };
+}
+/** The selected item node (react-stately `state.selectedItem`). Reads the selection. */
+export function selectedItem(state, collection) {
+    const key = state.selectedKey();
+    return key != null ? (collection ?? listCollection(state)).getItem(key) : null;
+}
+/** Sets the selected key (react-stately `state.setSelectedKey`). */
+export function setSelectedKey(state, key) {
+    // react-stately: the controlled-state setter (onSelectionChange when the key changes).
+    const { selectionState } = state;
+    if (untrack(state.selectedKey) === key)
+        return;
+    if (!selectionState.selectedKeyControlled)
+        state.selectedKey.set(key);
+    selectionState.onSelectedKeyChange?.(key);
+}

package/collections/list.d.ts

@@ -0,0 +1,20 @@
+import type { Collection, Key, Node } from "./types.js";
+/** A flat (optionally sectioned) collection: sections and their items, in order. */
+export declare class ListCollection<T> implements Collection<Node<T>> {
+    private keyMap;
+    private iterable;
+    private firstKey;
+    private lastKey;
+    private _size;
+    constructor(nodes: Iterable<Node<T>>);
+    [Symbol.iterator](): IterableIterator<Node<T>>;
+    get size(): number;
+    getKeys(): IterableIterator<Key>;
+    getKeyBefore(key: Key): Key | null;
+    getKeyAfter(key: Key): Key | null;
+    getFirstKey(): Key | null;
+    getLastKey(): Key | null;
+    getItem(key: Key): Node<T> | null;
+    at(idx: number): Node<T> | null;
+    getChildren(key: Key): Iterable<Node<T>>;
+}

package/collections/list.js

@@ -0,0 +1,77 @@
+/** A flat (optionally sectioned) collection: sections and their items, in order. */
+export class ListCollection {
+    keyMap = new Map();
+    iterable;
+    firstKey = null;
+    lastKey = null;
+    _size;
+    constructor(nodes) {
+        this.iterable = nodes;
+        const visit = (node) => {
+            this.keyMap.set(node.key, node);
+            if (node.childNodes && node.type === "section")
+                for (const child of node.childNodes)
+                    visit(child);
+        };
+        for (const node of nodes)
+            visit(node);
+        let last = null;
+        let index = 0;
+        let size = 0;
+        for (const [key, node] of this.keyMap) {
+            if (last) {
+                last.nextKey = key;
+                node.prevKey = last.key;
+            }
+            else {
+                this.firstKey = key;
+                node.prevKey = undefined;
+            }
+            if (node.type === "item")
+                node.index = index++;
+            // Only count sections and items when determining size so that loaders and separators don't
+            // influence the empty state determination.
+            if (node.type === "section" || node.type === "item")
+                size++;
+            last = node;
+            // Set nextKey as undefined since this might be the last node.
+            last.nextKey = undefined;
+        }
+        this._size = size;
+        this.lastKey = last?.key ?? null;
+    }
+    *[Symbol.iterator]() {
+        yield* this.iterable;
+    }
+    get size() {
+        return this._size;
+    }
+    getKeys() {
+        return this.keyMap.keys();
+    }
+    getKeyBefore(key) {
+        const node = this.keyMap.get(key);
+        return node ? (node.prevKey ?? null) : null;
+    }
+    getKeyAfter(key) {
+        const node = this.keyMap.get(key);
+        return node ? (node.nextKey ?? null) : null;
+    }
+    getFirstKey() {
+        return this.firstKey;
+    }
+    getLastKey() {
+        return this.lastKey;
+    }
+    getItem(key) {
+        return this.keyMap.get(key) ?? null;
+    }
+    at(idx) {
+        const keys = [...this.getKeys()];
+        return this.getItem(keys[idx]);
+    }
+    getChildren(key) {
+        const node = this.keyMap.get(key);
+        return node?.childNodes || [];
+    }
+}

package/collections/nodes.d.ts

@@ -0,0 +1,9 @@
+import type { Collection, Node } from "./types.js";
+export declare function getChildNodes<T>(node: Node<T>, collection: Collection<Node<T>>): Iterable<Node<T>>;
+export declare function getFirstItem<T>(iterable: Iterable<T>): T | undefined;
+export declare function getNthItem<T>(iterable: Iterable<T>, index: number): T | undefined;
+export declare function getLastItem<T>(iterable: Iterable<T>): T | undefined;
+/** Document order of two nodes (negative: `a` first). */
+export declare function compareNodeOrder<T>(collection: Collection<Node<T>>, a: Node<T>, b: Node<T>): number;
+/** Number of `item` nodes, descending into sections (cached per collection). */
+export declare function getItemCount<T>(collection: Collection<Node<T>>): number;

package/collections/nodes.js

@@ -0,0 +1,81 @@
+export function getChildNodes(node, collection) {
+    // New API: call collection.getChildren with the node key.
+    if (typeof collection.getChildren === "function")
+        return collection.getChildren(node.key);
+    // Old API: access childNodes directly.
+    return node.childNodes;
+}
+export function getFirstItem(iterable) {
+    return getNthItem(iterable, 0);
+}
+export function getNthItem(iterable, index) {
+    if (index < 0)
+        return undefined;
+    let i = 0;
+    for (const item of iterable) {
+        if (i === index)
+            return item;
+        i++;
+    }
+    return undefined;
+}
+export function getLastItem(iterable) {
+    let lastItem = undefined;
+    for (const value of iterable)
+        lastItem = value;
+    return lastItem;
+}
+/** Document order of two nodes (negative: `a` first). */
+export function compareNodeOrder(collection, a, b) {
+    // If the two nodes have the same parent, compare their indices.
+    if (a.parentKey === b.parentKey)
+        return a.index - b.index;
+    // Otherwise, collect all of the ancestors from each node, and find the first one that doesn't match
+    // starting from the root. Include the base nodes in case we are comparing nodes of different levels.
+    // Rivet: same algorithm without the spread / slice copies and the `findIndex` closures (sort comparator).
+    const aAncestors = getAncestors(collection, a);
+    aAncestors.push(a);
+    const bAncestors = getAncestors(collection, b);
+    bAncestors.push(b);
+    const shared = Math.min(aAncestors.length, bAncestors.length);
+    for (let i = 0; i < shared; i++)
+        if (aAncestors[i] !== bAncestors[i]) {
+            // Compare the indices of two children within the common ancestor.
+            return aAncestors[i].index - bAncestors[i].index;
+        }
+    // One of the nodes is the ancestor of the other.
+    if (aAncestors.includes(b))
+        return 1;
+    else if (bAncestors.includes(a))
+        return -1;
+    return -1;
+}
+function getAncestors(collection, node) {
+    const parents = [];
+    let currNode = node;
+    while (currNode?.parentKey != null) {
+        currNode = collection.getItem(currNode.parentKey);
+        if (currNode)
+            parents.push(currNode);
+    }
+    return parents.reverse(); // Rivet: push + reverse (upstream `unshift` per level)
+}
+const countCache = new WeakMap();
+/** Number of `item` nodes, descending into sections (cached per collection). */
+export function getItemCount(collection) {
+    const cached = countCache.get(collection);
+    if (cached != null)
+        return cached;
+    let counter = 0;
+    const countItems = (items) => {
+        for (const item of items) {
+            if (item.type === "section")
+                countItems(getChildNodes(item, collection));
+            else if (item.type === "item")
+                counter++;
+        }
+    };
+    countItems(collection);
+    countCache.set(collection, counter);
+    return counter;
+}

package/collections/selection-model.d.ts

@@ -0,0 +1,93 @@
+/** Event emitted when the value of a SelectionModel has changed. */
+export interface SelectionChange<T> {
+    /** Model that dispatched the event. */
+    source: SelectionModel<T>;
+    /** Options that were added to the model. */
+    added: T[];
+    /** Options that were removed from the model. */
+    removed: T[];
+}
+/** Minimal Subject: `next` notifies subscribers in order. */
+export declare class Emitter<T> {
+    private listeners;
+    subscribe(fn: (value: T) => void): {
+        unsubscribe(): void;
+    };
+    next(value: T): void;
+    get observed(): boolean;
+}
+/** Class to be used to power selecting one or more options from a list. */
+export declare class SelectionModel<T> {
+    /** Currently-selected values. */
+    private _selection;
+    /** Keeps track of the deselected options that haven't been emitted by the change event. */
+    private _deselectedToEmit;
+    /** Keeps track of the selected options that haven't been emitted by the change event. */
+    private _selectedToEmit;
+    /** Cache for the array value of the selected items. */
+    private _selected;
+    /** Selected values. */
+    get selected(): T[];
+    /** Event emitted when the value has changed. */
+    readonly changed: Emitter<SelectionChange<T>>;
+    /** Selection methods taking arrays (no spread: large collections). */
+    readonly bulk: Readonly<{
+        select: (values: T[]) => boolean;
+        deselect: (values: T[]) => boolean;
+        setSelection: (values: T[]) => boolean;
+    }>;
+    private _multiple;
+    private _emitChanges;
+    compareWith?: ((o1: T, o2: T) => boolean) | undefined;
+    constructor(_multiple?: boolean, initiallySelectedValues?: T[], _emitChanges?: boolean, compareWith?: (o1: T, o2: T) => boolean);
+    /** Selects a value or an array of values. Returns whether the selection changed. */
+    select(...values: T[]): boolean;
+    /** Deselects a value or an array of values. Returns whether the selection changed. */
+    deselect(...values: T[]): boolean;
+    /** Sets the selected values. Returns whether the selection changed. */
+    setSelection(...values: T[]): boolean;
+    /** Toggles a value between selected and deselected. */
+    toggle(value: T): boolean;
+    /**
+     * Clears all of the selected values. `flushEvent` false defers the change event to the next one.
+     * Returns whether the selection changed.
+     */
+    clear(flushEvent?: boolean): boolean;
+    /** Determines whether a value is selected. */
+    isSelected(value: T): boolean;
+    /** Determines whether the model does not have a value. */
+    isEmpty(): boolean;
+    /** Determines whether the model has a value. */
+    hasValue(): boolean;
+    /** Sorts the selected values based on a predicate function. */
+    sort(predicate?: (a: T, b: T) => number): void;
+    /** Gets whether multiple values can be selected. */
+    isMultipleSelection(): boolean;
+    private _select;
+    private _deselect;
+    private _setSelection;
+    /** Emits a change event and clears the records of selected and deselected values. */
+    private _emitChangeEvent;
+    private _markSelected;
+    private _unmarkSelected;
+    private _unmarkAll;
+    /** Throws when several values are assigned to a single-selection model. */
+    private _verifyValueAssignment;
+    private _hasQueuedChanges;
+    /** A value comparable to inputValue by compareWith, or inputValue itself. */
+    private _getConcreteValue;
+}
+/** Error: multiple values passed into a single-value SelectionModel. */
+export declare function getMultipleValuesInSingleSelectionError(): Error;
+/**
+ * Interface for a class that can flatten hierarchical structured data and re-expand the flattened
+ * data back into its original structure. Should be used in conjunction with a tree.
+ */
+export interface TreeDataNodeFlattener<T> {
+    /** Transforms a set of hierarchical structured data into a flattened data array. */
+    flattenNodes(structuredData: any[]): T[];
+    /** Expands a flattened array of data into its hierarchical form using the provided expansion model. */
+    expandFlattenedNodes(nodes: T[], expansionModel: SelectionModel<T>): T[];
+    /** Put node descendants of node in array. If `onlyExpandable` is true, then only process expandable descendants. */
+    nodeDescendents(node: T, nodes: T[], onlyExpandable: boolean): void;
+}

package/collections/selection-model.js

@@ -0,0 +1,192 @@
+// Ported from @angular/cdk/collections (selection-model.ts), MIT, © Google LLC.
+//
+// Imperative selection of values (not keys): for client-side code and stores. rxjs `Subject` →
+// a minimal `changed` emitter (`subscribe(fn)` returns an unsubscribe). Not serializable: for
+// resumable component state use `@rivetjs/cdk/selection/state` (signals) instead.
+/** Minimal Subject: `next` notifies subscribers in order. */
+export class Emitter {
+    listeners = [];
+    subscribe(fn) {
+        this.listeners.push(fn);
+        return {
+            unsubscribe: () => {
+                this.listeners = this.listeners.filter((l) => l !== fn);
+            },
+        };
+    }
+    next(value) {
+        for (const fn of [...this.listeners])
+            fn(value);
+    }
+    get observed() {
+        return this.listeners.length > 0;
+    }
+}
+/** Class to be used to power selecting one or more options from a list. */
+export class SelectionModel {
+    /** Currently-selected values. */
+    _selection = new Set();
+    /** Keeps track of the deselected options that haven't been emitted by the change event. */
+    _deselectedToEmit = [];
+    /** Keeps track of the selected options that haven't been emitted by the change event. */
+    _selectedToEmit = [];
+    /** Cache for the array value of the selected items. */
+    _selected = null;
+    /** Selected values. */
+    get selected() {
+        if (!this._selected)
+            this._selected = Array.from(this._selection.values());
+        return this._selected;
+    }
+    /** Event emitted when the value has changed. */
+    changed = new Emitter();
+    /** Selection methods taking arrays (no spread: large collections). */
+    bulk = {
+        select: (values) => this._select(values),
+        deselect: (values) => this._deselect(values),
+        setSelection: (values) => this._setSelection(values),
+    };
+    _multiple;
+    _emitChanges;
+    compareWith;
+    constructor(_multiple = false, initiallySelectedValues, _emitChanges = true, compareWith) {
+        this._multiple = _multiple;
+        this._emitChanges = _emitChanges;
+        this.compareWith = compareWith;
+        if (initiallySelectedValues && initiallySelectedValues.length) {
+            if (_multiple)
+                initiallySelectedValues.forEach((value) => this._markSelected(value));
+            else
+                this._markSelected(initiallySelectedValues[0]);
+            // Clear the array in order to avoid firing the change event for preselected values.
+            this._selectedToEmit.length = 0;
+        }
+    }
+    /** Selects a value or an array of values. Returns whether the selection changed. */
+    select(...values) {
+        return this._select(values);
+    }
+    /** Deselects a value or an array of values. Returns whether the selection changed. */
+    deselect(...values) {
+        return this._deselect(values);
+    }
+    /** Sets the selected values. Returns whether the selection changed. */
+    setSelection(...values) {
+        return this._setSelection(values);
+    }
+    /** Toggles a value between selected and deselected. */
+    toggle(value) {
+        return this.isSelected(value) ? this.deselect(value) : this.select(value);
+    }
+    /**
+     * Clears all of the selected values. `flushEvent` false defers the change event to the next one.
+     * Returns whether the selection changed.
+     */
+    clear(flushEvent = true) {
+        this._unmarkAll();
+        const changed = this._hasQueuedChanges();
+        if (flushEvent)
+            this._emitChangeEvent();
+        return changed;
+    }
+    /** Determines whether a value is selected. */
+    isSelected(value) {
+        return this._selection.has(this._getConcreteValue(value));
+    }
+    /** Determines whether the model does not have a value. */
+    isEmpty() {
+        return this._selection.size === 0;
+    }
+    /** Determines whether the model has a value. */
+    hasValue() {
+        return !this.isEmpty();
+    }
+    /** Sorts the selected values based on a predicate function. */
+    sort(predicate) {
+        if (this._multiple && this.selected)
+            this._selected.sort(predicate);
+    }
+    /** Gets whether multiple values can be selected. */
+    isMultipleSelection() {
+        return this._multiple;
+    }
+    _select(values) {
+        this._verifyValueAssignment(values);
+        values.forEach((value) => this._markSelected(value));
+        const changed = this._hasQueuedChanges();
+        this._emitChangeEvent();
+        return changed;
+    }
+    _deselect(values) {
+        this._verifyValueAssignment(values);
+        values.forEach((value) => this._unmarkSelected(value));
+        const changed = this._hasQueuedChanges();
+        this._emitChangeEvent();
+        return changed;
+    }
+    _setSelection(values) {
+        this._verifyValueAssignment(values);
+        const oldValues = this.selected;
+        const newSelectedSet = new Set(values.map((value) => this._getConcreteValue(value)));
+        values.forEach((value) => this._markSelected(value));
+        oldValues.filter((value) => !newSelectedSet.has(this._getConcreteValue(value, newSelectedSet))).forEach((value) => this._unmarkSelected(value));
+        const changed = this._hasQueuedChanges();
+        this._emitChangeEvent();
+        return changed;
+    }
+    /** Emits a change event and clears the records of selected and deselected values. */
+    _emitChangeEvent() {
+        // Clear the selected values so they can be re-cached.
+        this._selected = null;
+        if (this._selectedToEmit.length || this._deselectedToEmit.length) {
+            this.changed.next({ source: this, added: this._selectedToEmit, removed: this._deselectedToEmit });
+            this._deselectedToEmit = [];
+            this._selectedToEmit = [];
+        }
+    }
+    _markSelected(value) {
+        value = this._getConcreteValue(value);
+        if (!this.isSelected(value)) {
+            if (!this._multiple)
+                this._unmarkAll();
+            if (!this.isSelected(value))
+                this._selection.add(value);
+            if (this._emitChanges)
+                this._selectedToEmit.push(value);
+        }
+    }
+    _unmarkSelected(value) {
+        value = this._getConcreteValue(value);
+        if (this.isSelected(value)) {
+            this._selection.delete(value);
+            if (this._emitChanges)
+                this._deselectedToEmit.push(value);
+        }
+    }
+    _unmarkAll() {
+        if (!this.isEmpty())
+            this._selection.forEach((value) => this._unmarkSelected(value));
+    }
+    /** Throws when several values are assigned to a single-selection model. */
+    _verifyValueAssignment(values) {
+        if (values.length > 1 && !this._multiple)
+            throw getMultipleValuesInSingleSelectionError();
+    }
+    _hasQueuedChanges() {
+        return !!(this._deselectedToEmit.length || this._selectedToEmit.length);
+    }
+    /** A value comparable to inputValue by compareWith, or inputValue itself. */
+    _getConcreteValue(inputValue, selection) {
+        if (!this.compareWith)
+            return inputValue;
+        selection = selection ?? this._selection;
+        for (const selectedValue of selection)
+            if (this.compareWith(inputValue, selectedValue))
+                return selectedValue;
+        return inputValue;
+    }
+}
+/** Error: multiple values passed into a single-value SelectionModel. */
+export function getMultipleValuesInSingleSelectionError() {
+    return Error("Cannot pass multiple values into SelectionModel with single-value mode.");
+}

package/collections/server-dev.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from "@rivetjs/reactivity";
+export declare const slotProbing = false;
+export declare function probeSlots(_values: readonly (readonly [Context<any>, unknown])[], _content: unknown): void;
+export declare const idScoping = false;
+export declare function scopedIdUpdaters(): Map<string, unknown> | undefined;

package/collections/server-dev.js

@@ -0,0 +1,16 @@
+export const slotProbing = false;
+let warned = false;
+export function probeSlots(_values, _content) {
+    if (warned || typeof document !== "undefined")
+        return;
+    warned = true;
+    // eslint-disable-next-line no-console
+    console.warn("[rivet cdk] cdk slot probe is disabled: your server bundle resolves the `browser` export condition for @rivetjs/cdk " +
+        "(`#server` / `@rivetjs/cdk/slot-probe` → the browser no-op), so server-rendered aria-describedby / aria-labelledby " +
+        "ids keep slots by expectation and can point at elements that never render. Build the server bundle without the `browser` condition.");
+}
+// Reactive ids: one browser registry (`utils/id.ts`); `idScoping` folds the server lookup away.
+export const idScoping = false;
+export function scopedIdUpdaters() {
+    return undefined;
+}

package/collections/server-off.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from "@rivetjs/reactivity";
+export declare const slotProbing = false;
+export declare function probeSlots(_values: readonly (readonly [Context<any>, unknown])[], _content: unknown): void;
+export declare const idScoping = false;
+export declare function scopedIdUpdaters(): Map<string, unknown> | undefined;

package/collections/server-off.js

@@ -0,0 +1,7 @@
+export const slotProbing = false;
+export function probeSlots(_values, _content) { }
+// Reactive ids: one browser registry (`utils/id.ts`); `idScoping` folds the server lookup away.
+export const idScoping = false;
+export function scopedIdUpdaters() {
+    return undefined;
+}