@proyecto-viviana/solid-stately 0.3.0 → 0.4.1

package/dist/calendar/IncompleteDate.d.ts

@@ -0,0 +1,61 @@
+/**
+ * IncompleteDate for Solid-Stately
+ *
+ * Represents a date that is incomplete or otherwise invalid as a result of user
+ * editing (for example February 31st, if the day is edited before the month).
+ * This lets a date field hold an invalid intermediate value while typing and
+ * only constrain it on blur, matching upstream behavior.
+ *
+ * Based on @react-stately/datepicker IncompleteDate
+ */
+import { type AnyDateTime, type Calendar, type DateValue } from "@internationalized/date";
+import type { DateSegmentType } from "./createDateFieldState";
+type HourCycle = "h12" | "h11" | "h23" | "h24";
+/**
+ * This class represents a date that is incomplete or otherwise invalid as a result of user editing.
+ * For example, it can represent temporary dates such as February 31st if the user edits the day
+ * before the month. Times are represented according to an hour cycle rather than always in 24 hour
+ * time. This enables the user to adjust the day period (e.g. am/pm) independently from the hour.
+ */
+export declare class IncompleteDate {
+    calendar: Calendar;
+    era: string | null;
+    year: number | null;
+    month: number | null;
+    day: number | null;
+    hour: number | null;
+    hourCycle: HourCycle;
+    dayPeriod: number | null;
+    minute: number | null;
+    second: number | null;
+    millisecond: number | null;
+    offset: number | null;
+    constructor(calendar: Calendar, hourCycle: HourCycle, dateValue?: Partial<Omit<AnyDateTime, "copy">> | null);
+    copy(): IncompleteDate;
+    /** Checks whether all the specified segments have a value. */
+    isComplete(segments: DateSegmentType[]): boolean;
+    /** Checks whether the given date value matches this value for the specified segments. */
+    validate(dt: DateValue, segments: DateSegmentType[]): boolean;
+    /** Checks if the date is empty (i.e. all specified segments are null). */
+    isCleared(segments: DateSegmentType[]): boolean;
+    /** Sets the given field. */
+    set(field: DateSegmentType, value: number | string, placeholder: DateValue): IncompleteDate;
+    /** Sets the given field to null. */
+    clear(field: DateSegmentType): IncompleteDate;
+    /**
+     * Increments or decrements the given field. If it is null, then it is set to the placeholder
+     * value.
+     */
+    cycle(field: DateSegmentType, amount: number, placeholder: DateValue, displaySegments: DateSegmentType[]): IncompleteDate;
+    /**
+     * Converts the incomplete date to a full date value, using the provided value for any unset
+     * fields.
+     */
+    toValue(value: DateValue): DateValue;
+    getSegmentLimits(type: string): {
+        value: number | null;
+        minValue: number;
+        maxValue: number;
+    } | undefined;
+}
+export {};

package/dist/calendar/createCalendarState.d.ts

@@ -11,13 +11,17 @@ export type ValidationState = "valid" | "invalid";
 export type CalendarPageBehavior = "single" | "visible";
 export type CalendarSelectionAlignment = "start" | "center" | "end";
 export type CalendarDayOfWeek = "sun" | "mon" | "tue" | "wed" | "thu" | "fri" | "sat";
-export interface CalendarStateProps<T extends DateValue = DateValue> {
+export type CalendarSelectionMode = "single" | "multiple";
+export type CalendarValueType<T, M extends CalendarSelectionMode> = M extends "single" ? T : readonly T[];
+export interface CalendarStateProps<T extends DateValue = DateValue, M extends CalendarSelectionMode = "single"> {
     /** The current value (controlled). */
-    value?: MaybeAccessor<T | null>;
+    value?: MaybeAccessor<CalendarValueType<T | null, M> | undefined>;
     /** The default value (uncontrolled). */
-    defaultValue?: T | null;
+    defaultValue?: CalendarValueType<T | null, M> | null;
     /** Handler called when the value changes. */
-    onChange?: (value: T | null) => void;
+    onChange?: (value: CalendarValueType<T | null, M>) => void;
+    /** Whether single or multiple date selection is enabled. */
+    selectionMode?: MaybeAccessor<M>;
     /** The minimum allowed date. */
     minValue?: MaybeAccessor<DateValue | undefined>;
     /** The maximum allowed date. */
@@ -57,15 +61,21 @@ export interface CalendarStateProps<T extends DateValue = DateValue> {
     /** The first day of the week (0 = Sunday, 1 = Monday, etc.). */
     firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
 }
-export interface CalendarState<T extends DateValue = DateValue> {
-    /** The currently selected date. */
-    value: Accessor<T | null>;
-    /** Sets the selected date. */
-    setValue: (value: T | null) => void;
+export interface CalendarState<T extends DateValue = DateValue, M extends CalendarSelectionMode = "single"> {
+    /** Whether single or multiple selection is enabled. */
+    selectionMode: Accessor<CalendarSelectionMode>;
+    /** The currently selected date(s). */
+    value: Accessor<CalendarValueType<T | null, M>>;
+    /** Sets the selected date(s). */
+    setValue: (value: CalendarValueType<T | null, M>) => void;
     /** The currently focused date. */
     focusedDate: Accessor<CalendarDate>;
     /** Sets the focused date. */
     setFocusedDate: (date: CalendarDate) => void;
+    /** The minimum allowed date that a user may select. */
+    minValue: Accessor<DateValue | null>;
+    /** The maximum allowed date that a user may select. */
+    maxValue: Accessor<DateValue | null>;
     /** Whether the calendar is disabled. */
     isDisabled: Accessor<boolean>;
     /** Whether the calendar is read-only. */
@@ -141,4 +151,4 @@ export interface CalendarState<T extends DateValue = DateValue> {
 /**
  * Provides state management for a calendar component.
  */
-export declare function createCalendarState<T extends DateValue = CalendarDate>(props?: CalendarStateProps<T>): CalendarState<T>;
+export declare function createCalendarState<T extends DateValue = CalendarDate, M extends CalendarSelectionMode = "single">(props?: CalendarStateProps<T, M>): CalendarState<T, M>;

package/dist/calendar/createDateFieldState.d.ts

@@ -2,21 +2,34 @@
  * DateFieldState for Solid-Stately
  *
  * Provides state management for date field components with segment-based editing.
- * Based on @react-stately/datepicker useDateFieldState
+ * Faithful port of @react-stately/datepicker useDateFieldState.
+ *
+ * Editing is modeled with an {@link IncompleteDate} display value so that invalid
+ * intermediate dates (e.g. February 31st, produced by editing the day before the
+ * month) are held as-typed while the field is focused and only constrained on blur
+ * via `confirmPlaceholder`, matching upstream behavior. Out-of-range values are
+ * never snapped to `minValue`/`maxValue`; they are kept and reported as invalid.
+ *
+ * The upstream "derived state during render" resync (which re-mints the display
+ * value when the committed value / calendar / hour cycle changes) is ported to a
+ * Solid `createComputed` so it runs synchronously before render effects — mirroring
+ * React's render-phase setState rather than a post-render `createEffect`.
  */
 import { type Accessor } from "solid-js";
-import { CalendarDate, type DateValue } from "@internationalized/date";
+import { type Calendar, type CalendarDateTime, type CalendarIdentifier, type DateValue, DateFormatter, Time } from "@internationalized/date";
 import { type MaybeAccessor } from "../utils";
 import type { ValidationState } from "./createCalendarState";
 import { type ValidationBehavior, type ValidationFunction, type ValidationResult } from "../form";
 export type DateSegmentType = "year" | "month" | "day" | "hour" | "minute" | "second" | "dayPeriod" | "era" | "timeZoneName" | "literal";
+type Granularity = "year" | "month" | "day" | "hour" | "minute" | "second";
+type FieldGranularity = "day" | "hour" | "minute" | "second";
 export interface DateSegment {
     /** The type of segment. */
     type: DateSegmentType;
     /** The text content of the segment. */
     text: string;
     /** The numeric value of the segment (if applicable). */
-    value?: number;
+    value?: number | null;
     /** The minimum value for the segment. */
     minValue?: number;
     /** The maximum value for the segment. */
@@ -50,7 +63,9 @@ export interface DateFieldStateProps<T extends DateValue = DateValue> {
     /** The locale to use for formatting. */
     locale?: string;
     /** The granularity of the date/time (day, hour, minute, second). */
-    granularity?: "day" | "hour" | "minute" | "second";
+    granularity?: FieldGranularity;
+    /** The maximum granularity (largest editable unit). Defaults to `year`. */
+    maxGranularity?: "year" | "month" | "day" | "hour" | "minute";
     /** Whether to show the hour in 12 or 24 hour format. */
     hourCycle?: 12 | 24;
     /** Whether to hide the time zone. */
@@ -71,28 +86,42 @@ export interface DateFieldStateProps<T extends DateValue = DateValue> {
     errorMessage?: string;
     /** Whether dates outside the min/max range are allowed. */
     allowsNonContiguousRanges?: boolean;
-    /** Whether to create a date or datetime. */
-    createCalendar?: (name: string) => unknown;
+    /** Resolves a calendar system by its Unicode identifier. */
+    createCalendar?: (name: CalendarIdentifier) => Calendar;
     /** Whether a date is unavailable. */
     isDateUnavailable?: (date: DateValue) => boolean;
 }
 export interface DateFieldState<T extends DateValue = DateValue> {
-    /** The current value. */
-    value: Accessor<T | null>;
-    /** The date value (may be partial during editing). */
-    dateValue: Accessor<DateValue | null>;
+    /** The current value, converted to the display calendar. */
+    value: Accessor<DateValue | null>;
+    /** The current value as a native JavaScript Date (may be partial during editing). */
+    dateValue: Accessor<Date>;
+    /** The display calendar system. */
+    readonly calendar: Calendar;
     /** Sets the date value. */
     setValue: (value: T | null) => void;
     /** The segments that make up the date. */
     segments: Accessor<DateSegment[]>;
-    /** The format string. */
+    /** The formatter used to render the field. */
+    readonly dateFormatter: DateFormatter;
+    /** Formats the current value with the given field options. */
     formatValue: (fieldOptions?: Intl.DateTimeFormatOptions) => string;
+    /** Returns a formatter with the field's resolved options merged with the given ones. */
+    getDateFormatter: (locale: string, formatOptions: FormatterOptions) => DateFormatter;
     /** Sets a segment value. */
     setSegment: (type: DateSegmentType, value: number) => void;
-    /** Increments a segment. */
-    incrementSegment: (type: DateSegmentType) => void;
-    /** Decrements a segment. */
-    decrementSegment: (type: DateSegmentType) => void;
+    /** Increments a segment by one. */
+    increment: (type: DateSegmentType) => void;
+    /** Decrements a segment by one. */
+    decrement: (type: DateSegmentType) => void;
+    /** Increments a segment by a larger page step. */
+    incrementPage: (type: DateSegmentType) => void;
+    /** Decrements a segment by a larger page step. */
+    decrementPage: (type: DateSegmentType) => void;
+    /** Sets a segment to its maximum value. */
+    incrementToMax: (type: DateSegmentType) => void;
+    /** Sets a segment to its minimum value. */
+    decrementToMin: (type: DateSegmentType) => void;
     /** Clears a segment. */
     clearSegment: (type: DateSegmentType) => void;
     /** Confirms the value (after typing). */
@@ -106,7 +135,9 @@ export interface DateFieldState<T extends DateValue = DateValue> {
     /** The validation state. */
     validationState: Accessor<ValidationState | undefined>;
     /** The granularity. */
-    granularity: "day" | "hour" | "minute" | "second";
+    readonly granularity: FieldGranularity;
+    /** The maximum granularity. */
+    readonly maxGranularity: "year" | "month" | "day" | "hour" | "minute";
     /** Whether the value is invalid. */
     isInvalid: Accessor<boolean>;
     /** Realtime validation results, including native and custom constraints. */
@@ -120,13 +151,27 @@ export interface DateFieldState<T extends DateValue = DateValue> {
     /** Commits realtime validation to displayed validation. */
     commitValidation: () => void;
     /** The locale. */
-    locale: string;
+    readonly locale: string;
     /** The time zone. */
-    timeZone: string;
+    readonly timeZone: string;
     /** The default value. */
-    defaultValue: T | null;
+    defaultValue: DateValue | null;
 }
 /**
  * Provides state management for a date field component.
  */
-export declare function createDateFieldState<T extends DateValue = CalendarDate>(props?: DateFieldStateProps<T>): DateFieldState<T>;
+export declare function createDateFieldState<T extends DateValue = DateValue>(props?: DateFieldStateProps<T>): DateFieldState<T>;
+interface FormatterOptions {
+    timeZone?: string;
+    hideTimeZone?: boolean;
+    granularity?: Granularity;
+    maxGranularity?: "year" | "month" | "day" | "hour" | "minute";
+    hourCycle?: 12 | 24;
+    showEra?: boolean;
+    shouldForceLeadingZeros?: boolean;
+}
+export declare function getFormatOptions(fieldOptions: Intl.DateTimeFormatOptions | undefined, options: FormatterOptions): Intl.DateTimeFormatOptions;
+/** The placeholder time, used by time-only fields. */
+export declare function getPlaceholderTime(placeholderValue?: DateValue): Time | DateValue;
+export declare function getValidationResult(value: DateValue | null, minValue: DateValue | undefined, maxValue: DateValue | undefined, isDateUnavailable: ((date: DateValue) => boolean) | undefined, options: FormatterOptions): ValidationResult;
+export type { CalendarDateTime };

package/dist/calendar/createRangeCalendarState.d.ts

@@ -43,8 +43,12 @@ export interface RangeCalendarStateProps<T extends DateValue = DateValue> {
     locale?: MaybeAccessor<string | undefined>;
     /** Creates a calendar object for a locale calendar identifier. */
     createCalendar?: (identifier: CalendarIdentifier) => InternationalizedCalendar;
-    /** Callback to determine if a date is unavailable. */
-    isDateUnavailable?: (date: DateValue) => boolean;
+    /**
+     * Callback that determines if a date is unavailable. The second argument is the
+     * current selection anchor (the first selected date), so availability can be
+     * derived from it. Mirrors @react-stately/calendar 1.18.
+     */
+    isDateUnavailable?: (date: DateValue, anchorDate: CalendarDate | null) => boolean;
     /** The number of months to display at once. */
     visibleMonths?: MaybeAccessor<number | undefined>;
     /** Controls how the initial visible months are aligned around the current value. */
@@ -69,6 +73,10 @@ export interface RangeCalendarState<T extends DateValue = DateValue> {
     focusedDate: Accessor<CalendarDate>;
     /** Sets the focused date. */
     setFocusedDate: (date: CalendarDate) => void;
+    /** The minimum allowed date that a user may select. */
+    minValue: Accessor<DateValue | null>;
+    /** The maximum allowed date that a user may select. */
+    maxValue: Accessor<DateValue | null>;
     /** The anchor date when selecting a range (first click). */
     anchorDate: Accessor<CalendarDate | null>;
     /** Sets the anchor date. */
@@ -156,6 +164,16 @@ export interface RangeCalendarState<T extends DateValue = DateValue> {
     isDragging: Accessor<boolean>;
     /** Sets whether the user is dragging to select. */
     setDragging: (dragging: boolean) => void;
+    /**
+     * Formats the selected range as a `{ start, end }` pair of localized strings,
+     * or `null` when the range is incomplete. Mirrors upstream
+     * `DateRangePickerState.formatValue` — the port collapses that state into the
+     * range calendar state, so the range picker reads its SR description from here.
+     */
+    formatValue: (locale: string, fieldOptions: Intl.DateTimeFormatOptions) => {
+        start: string;
+        end: string;
+    } | null;
 }
 /**
  * Provides state management for a range calendar component.

package/dist/calendar/createTimeFieldState.d.ts

@@ -1,34 +1,37 @@
 /**
  * TimeFieldState for Solid-Stately
  *
- * Provides state management for time field components with segment-based editing.
- * Based on @react-stately/datepicker useTimeFieldState
+ * Faithful port of `@react-stately/datepicker` `useTimeFieldState`, which is a
+ * thin wrapper over `useDateFieldState`: a time-only `Time` value is converted
+ * to a `CalendarDateTime` (anchored on today's date, or a zoned date when the
+ * value/default carries a time zone) and fed to the date-field state machine
+ * with `maxGranularity: 'hour'` so the date segments drop away and only
+ * hour/minute[/second]/dayPeriod remain. The returned state IS the
+ * `DateFieldState`, plus a `timeValue` accessor holding the value back in the
+ * `Time` domain. This means TimeField reuses the certified DateField segment
+ * stack (`createDateSegment`, `DateInput`, `DateSegment`) exactly as RAC's
+ * TimeField reuses `DateInput`/`DateSegment` — there is no parallel time
+ * primitive.
+ *
+ * The `timeValue` is layered on with a Proxy rather than an object spread
+ * because `DateFieldState`'s `calendar`/`dateFormatter`/`granularity`/
+ * `maxGranularity`/`locale`/`timeZone` members are getters — spreading would
+ * invoke and freeze them, breaking reactivity.
  */
 import { type Accessor } from "solid-js";
-import { type Time, type CalendarDateTime, type ZonedDateTime, type DateValue } from "@internationalized/date";
+import { Time, type CalendarDateTime, type ZonedDateTime, type DateValue } from "@internationalized/date";
 import { type MaybeAccessor } from "../utils";
 import type { ValidationState } from "./createCalendarState";
-import { type ValidationBehavior, type ValidationFunction, type ValidationResult } from "../form";
+import type { ValidationBehavior, ValidationFunction } from "../form";
+import { type DateFieldState, type DateSegment as DateSegmentInternal, type DateSegmentType as DateSegmentTypeInternal } from "./createDateFieldState";
 export type TimeValue = Time | CalendarDateTime | ZonedDateTime;
-export type TimeSegmentType = "hour" | "minute" | "second" | "dayPeriod" | "literal";
-export interface TimeSegment {
-    /** The type of segment. */
-    type: TimeSegmentType;
-    /** The text content of the segment. */
-    text: string;
-    /** The numeric value of the segment (if applicable). */
-    value?: number;
-    /** The minimum value for the segment. */
-    minValue?: number;
-    /** The maximum value for the segment. */
-    maxValue?: number;
-    /** Whether this segment is editable. */
-    isEditable: boolean;
-    /** Whether this segment is a placeholder. */
-    isPlaceholder: boolean;
-    /** A placeholder string for the segment. */
-    placeholder: string;
-}
+/**
+ * TimeField reuses the DateField segment vocabulary (RAC TimeField reuses
+ * `DateInput`/`DateSegment`); the legacy `TimeSegment`/`TimeSegmentType` names
+ * are kept as aliases of the shared date-segment types.
+ */
+export type TimeSegmentType = DateSegmentTypeInternal;
+export type TimeSegment = DateSegmentInternal;
 export interface TimeFieldStateProps<T extends TimeValue = Time> {
     /** The current value (controlled). */
     value?: MaybeAccessor<T | null>;
@@ -54,6 +57,8 @@ export interface TimeFieldStateProps<T extends TimeValue = Time> {
     granularity?: "hour" | "minute" | "second";
     /** Whether to show 12 or 24 hour format. */
     hourCycle?: 12 | 24;
+    /** Whether to hide the time zone. */
+    hideTimeZone?: boolean;
     /** Whether to force leading zeroes in the hour segment. */
     shouldForceLeadingZeros?: boolean;
     /** Validation state. */
@@ -61,7 +66,7 @@ export interface TimeFieldStateProps<T extends TimeValue = Time> {
     /** Validation behavior mode. */
     validationBehavior?: ValidationBehavior;
     /** Custom validation function. */
-    validate?: ValidationFunction<T>;
+    validate?: ValidationFunction<T | null>;
     /** Description text. */
     description?: string;
     /** Error message. */
@@ -71,49 +76,15 @@ export interface TimeFieldStateProps<T extends TimeValue = Time> {
     /** Whether dates outside the min/max range are unavailable. Added for API consistency. */
     isDateUnavailable?: (date: DateValue) => boolean;
 }
-export interface TimeFieldState<T extends TimeValue = Time> {
-    /** The current value. */
-    value: Accessor<T | null>;
-    /** The default value. */
-    defaultValue: T | null;
-    /** Sets the value. */
-    setValue: (value: T | null) => void;
-    /** The segments that make up the time. */
-    segments: Accessor<TimeSegment[]>;
-    /** Sets a segment value. */
-    setSegment: (type: TimeSegmentType, value: number) => void;
-    /** Increments a segment. */
-    incrementSegment: (type: TimeSegmentType) => void;
-    /** Decrements a segment. */
-    decrementSegment: (type: TimeSegmentType) => void;
-    /** Clears a segment. */
-    clearSegment: (type: TimeSegmentType) => void;
-    /** Whether the field is disabled. */
-    isDisabled: Accessor<boolean>;
-    /** Whether the field is read-only. */
-    isReadOnly: Accessor<boolean>;
-    /** Whether the field is required. */
-    isRequired: Accessor<boolean>;
-    /** The validation state. */
-    validationState: Accessor<ValidationState | undefined>;
-    /** The granularity. */
-    granularity: "hour" | "minute" | "second";
-    /** Whether the value is invalid. */
-    isInvalid: Accessor<boolean>;
-    /** Realtime validation results, including native and custom constraints. */
-    realtimeValidation: Accessor<ValidationResult>;
-    /** Currently displayed validation results. */
-    displayValidation: Accessor<ValidationResult>;
-    /** Updates the current validation result. */
-    updateValidation: (result: ValidationResult) => void;
-    /** Resets displayed validation to valid. */
-    resetValidation: () => void;
-    /** Commits realtime validation to displayed validation. */
-    commitValidation: () => void;
-    /** The locale. */
-    locale: string;
-    /** The hour cycle. */
-    hourCycle: 12 | 24;
+/**
+ * The TimeField state IS the certified DateField state (segments, validation,
+ * increment/decrement, formatter, etc.) with a `timeValue` accessor added. The
+ * `T` generic is retained for API back-compat with existing `TimeFieldState<T>`
+ * consumers.
+ */
+export interface TimeFieldState<T extends TimeValue = Time> extends DateFieldState {
+    /** The current value in the `Time`/`CalendarDateTime`/`ZonedDateTime` domain. */
+    timeValue: Accessor<TimeValue | null>;
 }
 /**
  * Provides state management for a time field component.

package/dist/calendar/index.d.ts

@@ -1,4 +1,4 @@
-export { createCalendarState, type CalendarStateProps, type CalendarState, type ValidationState, type CalendarPageBehavior, type CalendarSelectionAlignment, type CalendarDayOfWeek, } from "./createCalendarState";
+export { createCalendarState, type CalendarStateProps, type CalendarState, type CalendarSelectionMode, type CalendarValueType, type ValidationState, type CalendarPageBehavior, type CalendarSelectionAlignment, type CalendarDayOfWeek, } from "./createCalendarState";
 export { createRangeCalendarState, type RangeCalendarStateProps, type RangeCalendarState, type DateRange, type RangeValue, } from "./createRangeCalendarState";
 export { createDateFieldState, type DateFieldStateProps, type DateFieldState, type DateSegment, type DateSegmentType, } from "./createDateFieldState";
 export { createTimeFieldState, type TimeFieldStateProps, type TimeFieldState, type TimeSegment, type TimeSegmentType, type TimeValue, } from "./createTimeFieldState";

package/dist/calendar/intl/index.d.ts

@@ -0,0 +1,10 @@
+export type DateFieldErrorKey = "rangeUnderflow" | "rangeOverflow" | "rangeReversed" | "unavailableDate";
+type DateFieldErrorArgs = {
+    minValue?: string;
+    maxValue?: string;
+};
+/** Mirrors LocalizedStringFormatter.format for the datepicker validation messages. */
+export declare function formatDateFieldError(locale: string, key: DateFieldErrorKey, args?: DateFieldErrorArgs): string;
+/** Mirrors @react-stately/datepicker getPlaceholder. */
+export declare function getPlaceholder(field: string, value: string, locale: string): string;
+export {};

package/dist/collections/ListCollection.d.ts

@@ -21,6 +21,14 @@ export declare class ListCollection<T = unknown> implements Collection<T> {
     getLastKey(): Key | null;
     getChildren(key: Key): Iterable<CollectionNode<T>>;
     getTextValue(key: Key): string;
+    /**
+     * Filter the collection, returning a new `ListCollection` containing only the
+     * item nodes for which `filterFn(node.textValue, node)` returns true. Sections
+     * whose children are all filtered out are dropped; surviving sections are
+     * rebuilt with their filtered children. Node order is preserved. Mirrors the
+     * behaviour of @react-aria/collections `BaseCollection.filter`.
+     */
+    filter(filterFn: (nodeValue: string, node: CollectionNode<T>) => boolean): ListCollection<T>;
     /**
      * Get all items (excluding sections, including items within sections).
      */

package/dist/collections/createListState.d.ts

@@ -5,7 +5,8 @@
  */
 import { type Accessor } from "solid-js";
 import { type MaybeAccessor } from "../utils";
-import { type SelectionState } from "./createSelectionState";
+import type { SelectionState } from "./createSelectionState";
+import { SelectionManager } from "../selection/SelectionManager";
 import type { Collection, CollectionNode, DisabledBehavior, FocusStrategy, Key, SelectionBehavior, SelectionMode } from "./types";
 export interface ListStateProps<T = unknown> {
     /** The items in the list (for dynamic rendering). */
@@ -38,6 +39,8 @@ export interface ListStateProps<T = unknown> {
 export interface ListState<T = unknown> extends SelectionState {
     /** The collection of items. */
     readonly collection: Accessor<Collection<T>>;
+    /** The collection-aware selection manager (single source of truth for selection). */
+    readonly selectionManager: SelectionManager<T>;
     /** Whether the collection is focused. */
     readonly isFocused: Accessor<boolean>;
     /** Set the focused state. */
@@ -53,6 +56,18 @@ export interface ListState<T = unknown> extends SelectionState {
  * Creates state for a list component with selection.
  */
 export declare function createListState<T = unknown>(props: MaybeAccessor<ListStateProps<T>>): ListState<T>;
+/** A collection filter predicate: `(nodeTextValue, node) => keep`. */
+export type ListFilterFn<T = unknown> = (nodeValue: string, node: CollectionNode<T>) => boolean;
+/**
+ * Wraps a {@link ListState} so its collection is filtered by `filterFn`, returning
+ * a new (reactive) ListState. Mirrors @react-stately's `UNSTABLE_useFilteredListState`
+ * (used by Autocomplete): the filter re-runs as the predicate — which typically
+ * closes over the current input value — or the base collection changes; a single
+ * stable, collection-aware manager reads the narrowed collection live and shares
+ * the base selection/focus state; and the focused key is reset to the nearest
+ * surviving item when the current one is filtered out.
+ */
+export declare function createFilteredListState<T = unknown>(state: ListState<T>, filterFn: Accessor<ListFilterFn<T> | null | undefined>): ListState<T>;
 /**
  * Props for single selection list state.
  */

package/dist/collections/createSelectionState.d.ts

@@ -63,11 +63,23 @@ export interface SelectionState {
     /** Extend selection to a key (for shift-click). */
     extendSelection(toKey: Key, collection: Collection): void;
     /** Select a key based on interaction. */
-    select(key: Key, e?: {
-        shiftKey?: boolean;
-        ctrlKey?: boolean;
-        metaKey?: boolean;
-    }, collection?: Collection): void;
+    select(key: Key, e?: SelectionPressEvent): void;
+}
+/**
+ * The press/pointer interaction consulted by {@link SelectionState.select}.
+ * Mirrors react-stately's `SelectionManager.select(e)`: only `pointerType` is
+ * read here (touch / virtual force toggle, since those devices have no modifier
+ * keys). Modifier keys (ctrl / meta / shift) are resolved one layer up in the
+ * aria-layer `onSelect` (solidaria `selectItem`), matching upstream's split
+ * between react-stately and react-aria. The modifier fields are accepted so a
+ * full press/pointer event is assignable, but they are not read here.
+ */
+export interface SelectionPressEvent {
+    pointerType?: "mouse" | "pen" | "touch" | "keyboard" | "virtual";
+    shiftKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    altKey?: boolean;
 }
 /**
  * Creates selection state for a collection.

package/dist/collections/getChildNodes.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Helpers for traversing collection nodes and comparing their document order.
+ *
+ * Based on @react-stately/collections.
+ */
+import type { Collection, CollectionNode } from "./types";
+export declare function getChildNodes<T>(node: CollectionNode<T>, collection: Collection<T>): Iterable<CollectionNode<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;
+/**
+ * Counts the item nodes (recursing into sections, ignoring section headers and
+ * other non-item nodes) in a collection. Faithful port of
+ * @react-stately/collections `getItemCount`; used by createOption to populate
+ * `aria-setsize` when the listbox is virtualized. Cached per (immutable)
+ * collection identity, exactly like upstream.
+ */
+export declare function getItemCount<T>(collection: Collection<T>): number;
+export declare function compareNodeOrder<T>(collection: Collection<T>, a: CollectionNode<T>, b: CollectionNode<T>): number;

package/dist/collections/index.d.ts

@@ -1,5 +1,6 @@
 export type { Key, SelectionMode, SelectionBehavior, Selection, FocusStrategy, DisabledBehavior, CollectionNode, Collection, ItemProps, SectionProps, CollectionBase, SingleSelection, MultipleSelection, } from "./types";
 export { ListCollection, createListCollection } from "./ListCollection";
-export { createSelectionState, type SelectionStateProps, type SelectionState, } from "./createSelectionState";
-export { createListState, createSingleSelectListState, type ListStateProps, type ListState, type SingleSelectListStateProps, type SingleSelectListState, } from "./createListState";
+export { getChildNodes, getFirstItem, getNthItem, getLastItem, getItemCount, compareNodeOrder, } from "./getChildNodes";
+export { createSelectionState, type SelectionStateProps, type SelectionState, type SelectionPressEvent, } from "./createSelectionState";
+export { createListState, createFilteredListState, createSingleSelectListState, type ListStateProps, type ListState, type ListFilterFn, type SingleSelectListStateProps, type SingleSelectListState, } from "./createListState";
 export { createMenuState, createMenuTriggerState, type MenuStateProps, type MenuState, type MenuTriggerStateProps, type MenuTriggerState, } from "./createMenuState";

package/dist/collections/types.d.ts

@@ -70,6 +70,15 @@ export interface Collection<T = unknown> extends Iterable<CollectionNode<T>> {
     getChildren(key: Key): Iterable<CollectionNode<T>>;
     /** Get the text value for a key. */
     getTextValue(key: Key): string;
+    /**
+     * Filter the collection, returning a new collection containing only the item
+     * nodes for which `filterFn` returns true. Sections whose children are all
+     * filtered out are dropped. Mirrors @react-aria/collections
+     * `BaseCollection.filter` (and the optional `Collection.filter` in
+     * @react-types/shared). Used by Autocomplete to narrow the collection as the
+     * user types.
+     */
+    filter?(filterFn: (nodeValue: string, node: CollectionNode<T>) => boolean): Collection<T>;
 }
 /**
  * Structural shape expected when inferring collection item properties

package/dist/color/intl/index.d.ts

@@ -0,0 +1,14 @@
+export type ColorStringKey = "hue" | "saturation" | "lightness" | "brightness" | "red" | "green" | "blue" | "alpha" | "colorName" | "transparentColorName" | "very dark" | "dark" | "light" | "very light" | "pale" | "grayish" | "vibrant" | "black" | "white" | "gray" | "pink" | "pink red" | "red orange" | "brown" | "orange" | "orange yellow" | "brown yellow" | "yellow" | "yellow green" | "green cyan" | "cyan" | "cyan blue" | "blue purple" | "purple" | "purple magenta" | "magenta" | "magenta pink";
+export declare const colorStrings: Record<string, Record<ColorStringKey, string>>;
+/**
+ * Mirrors LocalizedStringDictionary.getStringForLocale: exact-locale match,
+ * then language-only match (e.g. "ar" for "ar-AE"), then the en-US fallback.
+ * Ported so solid-stately's Color needs no @internationalized/string dependency.
+ */
+export declare function getColorStringForLocale(key: ColorStringKey, locale: string): string;
+/**
+ * Mirrors LocalizedStringFormatter.format for the plain `{variable}` messages
+ * used by color names (colorName / transparentColorName). Substitutes each
+ * `{name}` token with the matching variable's string value.
+ */
+export declare function formatColorMessage(key: ColorStringKey, locale: string, variables: Record<string, string>): string;

package/dist/combobox/createComboBoxState.d.ts

@@ -8,6 +8,7 @@
 import { type Accessor } from "solid-js";
 import { type MaybeAccessor } from "../utils";
 import type { Key, CollectionNode, Collection, FocusStrategy } from "../collections/types";
+import type { SelectionManager } from "../selection/SelectionManager";
 export type MenuTriggerAction = "focus" | "input" | "manual";
 export type { FocusStrategy } from "../collections/types";
 export type FilterFn = (textValue: string, inputValue: string) => boolean;
@@ -70,6 +71,12 @@ export interface ComboBoxStateProps<T = unknown> {
 export interface ComboBoxState<T = unknown> {
     /** The collection of items (may be filtered). */
     readonly collection: Accessor<Collection<T>>;
+    /**
+     * The collection-aware selection manager. Mirrors upstream `useComboBoxState`,
+     * which returns the `useListState` selection manager bound to the unfiltered
+     * collection (selection spans all items; filtering is display-only).
+     */
+    readonly selectionManager: SelectionManager<T>;
     /** Whether the combobox dropdown is open. */
     readonly isOpen: Accessor<boolean>;
     /** Open the combobox dropdown. */