@proyecto-viviana/solid-stately 0.1.1 → 0.1.2

package/dist/collections/createListState.d.ts

@@ -0,0 +1,78 @@
+/**
+ * State management for list-like components.
+ * Combines collection and selection state.
+ * Based on @react-stately/list.
+ */
+import { type Accessor } from 'solid-js';
+import { type MaybeAccessor } from '../utils';
+import { type SelectionState } from './createSelectionState';
+import type { Collection, CollectionNode, DisabledBehavior, FocusStrategy, Key, SelectionBehavior, SelectionMode } from './types';
+export interface ListStateProps<T = unknown> {
+    /** The items in the list (for dynamic rendering). */
+    items?: T[];
+    /** Function to get a key from an item. */
+    getKey?: (item: T) => Key;
+    /** Function to get text value from an item. */
+    getTextValue?: (item: T) => string;
+    /** Function to check if an item is disabled. */
+    getDisabled?: (item: T) => boolean;
+    /** Keys of disabled items. */
+    disabledKeys?: Iterable<Key>;
+    /** How disabled keys behave. */
+    disabledBehavior?: DisabledBehavior;
+    /** The selection mode. */
+    selectionMode?: SelectionMode;
+    /** How selection behaves on interaction. */
+    selectionBehavior?: SelectionBehavior;
+    /** Whether empty selection is disallowed. */
+    disallowEmptySelection?: boolean;
+    /** Currently selected keys (controlled). */
+    selectedKeys?: 'all' | Iterable<Key>;
+    /** Default selected keys (uncontrolled). */
+    defaultSelectedKeys?: 'all' | Iterable<Key>;
+    /** Handler for selection changes. */
+    onSelectionChange?: (keys: 'all' | Set<Key>) => void;
+    /** Whether to allow duplicate selection events. */
+    allowDuplicateSelectionEvents?: boolean;
+}
+export interface ListState<T = unknown> extends SelectionState {
+    /** The collection of items. */
+    readonly collection: Accessor<Collection<T>>;
+    /** Whether the collection is focused. */
+    readonly isFocused: Accessor<boolean>;
+    /** Set the focused state. */
+    setFocused(isFocused: boolean): void;
+    /** The currently focused key. */
+    readonly focusedKey: Accessor<Key | null>;
+    /** Set the focused key. */
+    setFocusedKey(key: Key | null, childStrategy?: FocusStrategy): void;
+    /** The child focus strategy. */
+    readonly childFocusStrategy: Accessor<FocusStrategy | null>;
+}
+/**
+ * Creates state for a list component with selection.
+ */
+export declare function createListState<T = unknown>(props: MaybeAccessor<ListStateProps<T>>): ListState<T>;
+/**
+ * Props for single selection list state.
+ */
+export interface SingleSelectListStateProps<T = unknown> extends Omit<ListStateProps<T>, 'selectionMode' | 'selectedKeys' | 'defaultSelectedKeys' | 'onSelectionChange'> {
+    /** The currently selected key (controlled). */
+    selectedKey?: Key | null;
+    /** The default selected key (uncontrolled). */
+    defaultSelectedKey?: Key;
+    /** Handler for selection changes. */
+    onSelectionChange?: (key: Key | null) => void;
+}
+export interface SingleSelectListState<T = unknown> extends ListState<T> {
+    /** The currently selected key. */
+    readonly selectedKey: Accessor<Key | null>;
+    /** Set the selected key. */
+    setSelectedKey(key: Key | null): void;
+    /** The currently selected item. */
+    readonly selectedItem: Accessor<CollectionNode<T> | null>;
+}
+/**
+ * Creates state for a single-select list component.
+ */
+export declare function createSingleSelectListState<T = unknown>(props: MaybeAccessor<SingleSelectListStateProps<T>>): SingleSelectListState<T>;

package/dist/collections/createMenuState.d.ts

@@ -0,0 +1,49 @@
+/**
+ * State management for menu components.
+ * Based on @react-stately/menu.
+ */
+import { type MaybeAccessor } from '../utils';
+import { type ListState, type ListStateProps } from './createListState';
+import type { Key } from './types';
+export interface MenuStateProps<T = unknown> extends Omit<ListStateProps<T>, 'selectionMode' | 'disallowEmptySelection'> {
+    /** Handler called when an item is activated (pressed). */
+    onAction?: (key: Key) => void;
+    /** Handler called when the menu should close. */
+    onClose?: () => void;
+}
+export interface MenuState<T = unknown> extends ListState<T> {
+    /** Close the menu. */
+    close(): void;
+}
+/**
+ * Creates state for a menu component.
+ * Menus are single-select lists that support actions.
+ */
+export declare function createMenuState<T = unknown>(props: MaybeAccessor<MenuStateProps<T>>): MenuState<T>;
+export interface MenuTriggerStateProps {
+    /** Whether the menu is open (controlled). */
+    isOpen?: boolean;
+    /** Default open state (uncontrolled). */
+    defaultOpen?: boolean;
+    /** Handler called when the open state changes. */
+    onOpenChange?: (isOpen: boolean) => void;
+}
+export interface MenuTriggerState {
+    /** Whether the menu is open. */
+    readonly isOpen: () => boolean;
+    /** Open the menu. */
+    open(): void;
+    /** Close the menu. */
+    close(): void;
+    /** Toggle the menu. */
+    toggle(): void;
+    /** Focus strategy for when the menu opens. */
+    readonly focusStrategy: () => 'first' | 'last' | null;
+    /** Set the focus strategy. */
+    setFocusStrategy(strategy: 'first' | 'last' | null): void;
+}
+/**
+ * Creates state for a menu trigger (button that opens a menu).
+ * This is essentially the same as overlay trigger state but with focus strategy.
+ */
+export { createOverlayTriggerState as createMenuTriggerState } from '../overlays';

package/dist/collections/createSelectionState.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Selection state management for collections.
+ * Based on @react-stately/selection.
+ */
+import { type Accessor } from 'solid-js';
+import { type MaybeAccessor } from '../utils';
+import type { Collection, DisabledBehavior, Key, Selection, SelectionBehavior, SelectionMode } from './types';
+export interface SelectionStateProps {
+    /** The selection mode. */
+    selectionMode?: SelectionMode;
+    /** How selection behaves on interaction. */
+    selectionBehavior?: SelectionBehavior;
+    /** Whether empty selection is disallowed. */
+    disallowEmptySelection?: boolean;
+    /** Currently selected keys (controlled). */
+    selectedKeys?: 'all' | Iterable<Key>;
+    /** Default selected keys (uncontrolled). */
+    defaultSelectedKeys?: 'all' | Iterable<Key>;
+    /** Handler for selection changes. */
+    onSelectionChange?: (keys: Selection) => void;
+    /** Keys of disabled items. */
+    disabledKeys?: Iterable<Key>;
+    /** How disabled keys behave. */
+    disabledBehavior?: DisabledBehavior;
+    /** Whether to allow duplicate selection events. */
+    allowDuplicateSelectionEvents?: boolean;
+}
+export interface SelectionState {
+    /** The selection mode. */
+    readonly selectionMode: Accessor<SelectionMode>;
+    /** The selection behavior. */
+    readonly selectionBehavior: Accessor<SelectionBehavior>;
+    /** Whether empty selection is disallowed. */
+    readonly disallowEmptySelection: Accessor<boolean>;
+    /** The currently selected keys. */
+    readonly selectedKeys: Accessor<Selection>;
+    /** Set of disabled keys. */
+    readonly disabledKeys: Accessor<Set<Key>>;
+    /** How disabled keys behave. */
+    readonly disabledBehavior: Accessor<DisabledBehavior>;
+    /** Whether the selection is empty. */
+    readonly isEmpty: Accessor<boolean>;
+    /** Whether all items are selected. */
+    readonly isSelectAll: Accessor<boolean>;
+    /** Check if a key is selected. */
+    isSelected(key: Key): boolean;
+    /** Check if a key is disabled. */
+    isDisabled(key: Key): boolean;
+    /** Set the selection behavior. */
+    setSelectionBehavior(behavior: SelectionBehavior): void;
+    /** Toggle selection for a key. */
+    toggleSelection(key: Key): void;
+    /** Replace selection with a single key. */
+    replaceSelection(key: Key): void;
+    /** Set multiple selected keys. */
+    setSelectedKeys(keys: Iterable<Key>): void;
+    /** Select all items. */
+    selectAll(): void;
+    /** Clear all selection. */
+    clearSelection(): void;
+    /** Toggle between select all and clear. */
+    toggleSelectAll(): void;
+    /** 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;
+}
+/**
+ * Creates selection state for a collection.
+ */
+export declare function createSelectionState(props?: MaybeAccessor<SelectionStateProps>): SelectionState;

package/dist/collections/index.d.ts

@@ -0,0 +1,5 @@
+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 { createMenuState, createMenuTriggerState, type MenuStateProps, type MenuState, type MenuTriggerStateProps, type MenuTriggerState, } from './createMenuState';

package/dist/collections/types.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Core types for collection state management.
+ * Simplified from @react-stately/collections for SolidJS.
+ */
+import type { JSX } from 'solid-js';
+/** A unique identifier for an item in a collection. */
+export type Key = string | number;
+/** The type of selection allowed in a collection. */
+export type SelectionMode = 'none' | 'single' | 'multiple';
+/** How selection behaves when clicking on items. */
+export type SelectionBehavior = 'toggle' | 'replace';
+/** Represents the current selection state. */
+export type Selection = 'all' | Set<Key>;
+/** Strategy for focusing first or last item. */
+export type FocusStrategy = 'first' | 'last';
+/** Whether disabled keys affect selection, actions, or both. */
+export type DisabledBehavior = 'selection' | 'all';
+/**
+ * Represents a node in a collection (item or section).
+ */
+export interface CollectionNode<T = unknown> {
+    /** The type of node: 'item' or 'section'. */
+    type: 'item' | 'section';
+    /** A unique key for the node. */
+    key: Key;
+    /** The original value/data for this node. */
+    value: T | null;
+    /** The text content for accessibility and typeahead. */
+    textValue: string;
+    /** The rendered content (JSX). */
+    rendered: JSX.Element;
+    /** The level of nesting (0 for top-level). */
+    level: number;
+    /** The index within the parent. */
+    index: number;
+    /** The key of the parent node, if any. */
+    parentKey: Key | null;
+    /** Whether this node has child nodes. */
+    hasChildNodes: boolean;
+    /** Child nodes, if any. */
+    childNodes: CollectionNode<T>[];
+    /** Whether this item is disabled. */
+    isDisabled?: boolean;
+    /** ARIA label for this node. */
+    'aria-label'?: string;
+    /** Additional props for the node. */
+    props?: Record<string, unknown>;
+}
+/**
+ * A collection of nodes with methods to traverse and query.
+ */
+export interface Collection<T = unknown> extends Iterable<CollectionNode<T>> {
+    /** The number of items in the collection. */
+    readonly size: number;
+    /** Get all keys in the collection. */
+    getKeys(): Iterable<Key>;
+    /** Get a node by its key. */
+    getItem(key: Key): CollectionNode<T> | null;
+    /** Get a node by index. */
+    at(index: number): CollectionNode<T> | null;
+    /** Get the key before the given key. */
+    getKeyBefore(key: Key): Key | null;
+    /** Get the key after the given key. */
+    getKeyAfter(key: Key): Key | null;
+    /** Get the first key in the collection. */
+    getFirstKey(): Key | null;
+    /** Get the last key in the collection. */
+    getLastKey(): Key | null;
+    /** Get the children of a node. */
+    getChildren(key: Key): Iterable<CollectionNode<T>>;
+    /** Get the text value for a key. */
+    getTextValue(key: Key): string;
+}
+/**
+ * Props for items in a collection.
+ */
+export interface ItemProps<T = unknown> {
+    /** Unique key for the item. Required if items is used for dynamic collections. */
+    key?: Key;
+    /** The text value for accessibility and typeahead. If not provided, derived from children. */
+    textValue?: string;
+    /** Whether the item is disabled. */
+    isDisabled?: boolean;
+    /** The rendered content of the item. */
+    children?: JSX.Element;
+    /** ARIA label for the item. */
+    'aria-label'?: string;
+    /** The original value for dynamic collections. */
+    value?: T;
+}
+/**
+ * Props for sections in a collection.
+ */
+export interface SectionProps<T = unknown> {
+    /** Unique key for the section. */
+    key?: Key;
+    /** The section header/title. */
+    title?: JSX.Element;
+    /** ARIA label for the section. */
+    'aria-label'?: string;
+    /** The items in this section. */
+    children?: JSX.Element;
+    /** Items for dynamic rendering. */
+    items?: Iterable<T>;
+}
+/**
+ * Base props for components that use collections.
+ */
+export interface CollectionBase<T = unknown> {
+    /** The items in the collection (for dynamic rendering). */
+    items?: Iterable<T>;
+    /** The children (static items or render function). */
+    children?: JSX.Element | ((item: T) => JSX.Element);
+    /** Keys of disabled items. */
+    disabledKeys?: Iterable<Key>;
+}
+/**
+ * Props for single selection.
+ */
+export interface SingleSelection {
+    /** Whether empty selection is allowed. */
+    disallowEmptySelection?: boolean;
+    /** The currently selected key (controlled). */
+    selectedKey?: Key | null;
+    /** The default selected key (uncontrolled). */
+    defaultSelectedKey?: Key;
+    /** Handler called when selection changes. */
+    onSelectionChange?: (key: Key | null) => void;
+}
+/**
+ * Props for multiple selection.
+ */
+export interface MultipleSelection {
+    /** The selection mode. */
+    selectionMode?: SelectionMode;
+    /** Whether empty selection is allowed. */
+    disallowEmptySelection?: boolean;
+    /** The currently selected keys (controlled). */
+    selectedKeys?: 'all' | Iterable<Key>;
+    /** The default selected keys (uncontrolled). */
+    defaultSelectedKeys?: 'all' | Iterable<Key>;
+    /** Handler called when selection changes. */
+    onSelectionChange?: (keys: Selection) => void;
+    /** Keys of disabled items. */
+    disabledKeys?: Iterable<Key>;
+}

package/dist/color/Color.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Color class implementation.
+ * Based on @react-stately/color.
+ *
+ * Provides color manipulation, conversion, and formatting.
+ */
+import type { Color } from './types';
+/**
+ * Parse a color string into a Color object.
+ */
+export declare function parseColor(value: string): Color;
+/**
+ * Create an RGB color.
+ */
+export declare function createRGBColor(red: number, green: number, blue: number, alpha?: number): Color;
+/**
+ * Create an HSL color.
+ */
+export declare function createHSLColor(hue: number, saturation: number, lightness: number, alpha?: number): Color;
+/**
+ * Create an HSB color.
+ */
+export declare function createHSBColor(hue: number, saturation: number, brightness: number, alpha?: number): Color;
+/**
+ * Normalize a color value (string or Color) to a Color object.
+ */
+export declare function normalizeColor(value: string | Color): Color;

package/dist/color/createColorAreaState.d.ts

@@ -0,0 +1,75 @@
+/**
+ * ColorArea state management.
+ * Based on @react-stately/color useColorAreaState.
+ */
+import { type Accessor } from 'solid-js';
+import type { Color, ColorChannel } from './types';
+export interface ColorAreaStateOptions {
+    /** The current color value (controlled). */
+    value?: Color | string;
+    /** The default color value (uncontrolled). */
+    defaultValue?: Color | string;
+    /** Handler called when the color changes. */
+    onChange?: (color: Color) => void;
+    /** Handler called when dragging ends. */
+    onChangeEnd?: (color: Color) => void;
+    /** The color channel for the X axis. */
+    xChannel?: ColorChannel;
+    /** The color channel for the Y axis. */
+    yChannel?: ColorChannel;
+    /** Whether the area is disabled. */
+    isDisabled?: boolean;
+}
+export interface ColorAreaState {
+    /** The current color value. */
+    readonly value: Color;
+    /** The X axis channel. */
+    readonly xChannel: ColorChannel;
+    /** The Y axis channel. */
+    readonly yChannel: ColorChannel;
+    /** The Z axis channel (the third channel). */
+    readonly zChannel: ColorChannel;
+    /** Whether the area is being dragged. */
+    readonly isDragging: boolean;
+    /** Whether the area is disabled. */
+    readonly isDisabled: boolean;
+    /** Step for X channel. */
+    readonly xChannelStep: number;
+    /** Step for Y channel. */
+    readonly yChannelStep: number;
+    /** Page step for X channel. */
+    readonly xChannelPageStep: number;
+    /** Page step for Y channel. */
+    readonly yChannelPageStep: number;
+    /** Get the X channel value. */
+    getXValue(): number;
+    /** Get the Y channel value. */
+    getYValue(): number;
+    /** Set the X channel value. */
+    setXValue(value: number): void;
+    /** Set the Y channel value. */
+    setYValue(value: number): void;
+    /** Set color from a point (0-1, 0-1). */
+    setColorFromPoint(x: number, y: number): void;
+    /** Get the thumb position as percentages. */
+    getThumbPosition(): {
+        x: number;
+        y: number;
+    };
+    /** Increment X value. */
+    incrementX(stepSize?: number): void;
+    /** Decrement X value. */
+    decrementX(stepSize?: number): void;
+    /** Increment Y value. */
+    incrementY(stepSize?: number): void;
+    /** Decrement Y value. */
+    decrementY(stepSize?: number): void;
+    /** Set the dragging state. */
+    setDragging(isDragging: boolean): void;
+    /** Get the display color (with alpha = 1). */
+    getDisplayColor(): Color;
+}
+/**
+ * Creates state for a color area (2D color picker).
+ */
+export declare function createColorAreaState(options: Accessor<ColorAreaStateOptions>): ColorAreaState;

package/dist/color/createColorFieldState.d.ts

@@ -0,0 +1,54 @@
+/**
+ * ColorField state management.
+ * Based on @react-stately/color useColorFieldState.
+ */
+import { type Accessor } from 'solid-js';
+import type { Color, ColorChannel, ColorFormat } from './types';
+export interface ColorFieldStateOptions {
+    /** The current color value (controlled). */
+    value?: Color | string | null;
+    /** The default color value (uncontrolled). */
+    defaultValue?: Color | string;
+    /** Handler called when the color changes. */
+    onChange?: (color: Color | null) => void;
+    /** The color channel to edit (for single channel mode). */
+    channel?: ColorChannel;
+    /** The color format for parsing/displaying. */
+    colorFormat?: ColorFormat;
+    /** Whether the field is disabled. */
+    isDisabled?: boolean;
+    /** Whether the field is read-only. */
+    isReadOnly?: boolean;
+}
+export interface ColorFieldState {
+    /** The current color value (null if invalid). */
+    readonly value: Color | null;
+    /** The current input text. */
+    readonly inputValue: string;
+    /** Whether the input is invalid. */
+    readonly isInvalid: boolean;
+    /** Whether the field is disabled. */
+    readonly isDisabled: boolean;
+    /** Whether the field is read-only. */
+    readonly isReadOnly: boolean;
+    /** The color channel being edited (if single channel mode). */
+    readonly channel: ColorChannel | undefined;
+    /** Set the input text value. */
+    setInputValue(value: string): void;
+    /** Commit the current input value. */
+    commit(): void;
+    /** Increment the color channel value. */
+    increment(): void;
+    /** Decrement the color channel value. */
+    decrement(): void;
+    /** Increment by page size. */
+    incrementToMax(): void;
+    /** Decrement to minimum. */
+    decrementToMin(): void;
+    /** Validate the current input. */
+    validate(): boolean;
+}
+/**
+ * Creates state for a color field (text input for color values).
+ */
+export declare function createColorFieldState(options: Accessor<ColorFieldStateOptions>): ColorFieldState;

package/dist/color/createColorSliderState.d.ts

@@ -0,0 +1,66 @@
+/**
+ * ColorSlider state management.
+ * Based on @react-stately/color useColorSliderState.
+ */
+import { type Accessor } from 'solid-js';
+import type { Color, ColorChannel } from './types';
+export interface ColorSliderStateOptions {
+    /** The current color value (controlled). */
+    value?: Color | string;
+    /** The default color value (uncontrolled). */
+    defaultValue?: Color | string;
+    /** Handler called when the color changes. */
+    onChange?: (color: Color) => void;
+    /** Handler called when dragging ends. */
+    onChangeEnd?: (color: Color) => void;
+    /** The color channel this slider controls. */
+    channel: ColorChannel;
+    /** Whether the slider is disabled. */
+    isDisabled?: boolean;
+    /** The locale for formatting. */
+    locale?: string;
+}
+export interface ColorSliderState {
+    /** The current color value. */
+    readonly value: Color;
+    /** Whether the slider is being dragged. */
+    readonly isDragging: boolean;
+    /** The color channel being controlled. */
+    readonly channel: ColorChannel;
+    /** The step value for the channel. */
+    readonly step: number;
+    /** The page step value for the channel. */
+    readonly pageSize: number;
+    /** The minimum value for the channel. */
+    readonly minValue: number;
+    /** The maximum value for the channel. */
+    readonly maxValue: number;
+    /** Whether the slider is disabled. */
+    readonly isDisabled: boolean;
+    /** Get the current channel value. */
+    getThumbValue(): number;
+    /** Get the minimum percent. */
+    getThumbMinValue(): number;
+    /** Get the maximum percent. */
+    getThumbMaxValue(): number;
+    /** Get the thumb value as a percentage. */
+    getThumbPercent(): number;
+    /** Set the channel value. */
+    setThumbValue(value: number): void;
+    /** Set the thumb value from a percentage (0-1). */
+    setThumbPercent(percent: number): void;
+    /** Increment the channel value. */
+    incrementThumb(stepSize?: number): void;
+    /** Decrement the channel value. */
+    decrementThumb(stepSize?: number): void;
+    /** Set the dragging state. */
+    setDragging(isDragging: boolean): void;
+    /** Get the display color (with alpha = 1). */
+    getDisplayColor(): Color;
+    /** Get the formatted value label. */
+    getThumbValueLabel(): string;
+}
+/**
+ * Creates state for a color slider.
+ */
+export declare function createColorSliderState(options: Accessor<ColorSliderStateOptions>): ColorSliderState;

package/dist/color/createColorWheelState.d.ts

@@ -0,0 +1,50 @@
+/**
+ * ColorWheel state management.
+ * Based on @react-stately/color useColorWheelState.
+ */
+import { type Accessor } from 'solid-js';
+import type { Color } from './types';
+export interface ColorWheelStateOptions {
+    /** The current color value (controlled). */
+    value?: Color | string;
+    /** The default color value (uncontrolled). */
+    defaultValue?: Color | string;
+    /** Handler called when the color changes. */
+    onChange?: (color: Color) => void;
+    /** Handler called when dragging ends. */
+    onChangeEnd?: (color: Color) => void;
+    /** Whether the wheel is disabled. */
+    isDisabled?: boolean;
+}
+export interface ColorWheelState {
+    /** The current color value. */
+    readonly value: Color;
+    /** Whether the wheel is being dragged. */
+    readonly isDragging: boolean;
+    /** Whether the wheel is disabled. */
+    readonly isDisabled: boolean;
+    /** Step value for hue changes. */
+    readonly step: number;
+    /** Page step value for hue changes. */
+    readonly pageStep: number;
+    /** Get the current hue value (0-360). */
+    getHue(): number;
+    /** Set the hue value. */
+    setHue(value: number): void;
+    /** Set hue from an angle in radians. */
+    setHueFromAngle(angle: number): void;
+    /** Get the thumb angle in radians (0 = right, increases counterclockwise). */
+    getThumbAngle(): number;
+    /** Increment hue value. */
+    increment(stepSize?: number): void;
+    /** Decrement hue value. */
+    decrement(stepSize?: number): void;
+    /** Set the dragging state. */
+    setDragging(isDragging: boolean): void;
+    /** Get the display color (with full saturation/brightness for wheel). */
+    getDisplayColor(): Color;
+}
+/**
+ * Creates state for a color wheel (circular hue picker).
+ */
+export declare function createColorWheelState(options: Accessor<ColorWheelStateOptions>): ColorWheelState;

package/dist/color/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Color state management exports.
+ */
+export type { Color, ColorFormat, ColorSpace, ColorChannel, ColorChannelRange, ColorAxes, } from './types';
+export { parseColor, normalizeColor, createRGBColor, createHSLColor, createHSBColor, } from './Color';
+export { createColorSliderState, type ColorSliderStateOptions, type ColorSliderState, } from './createColorSliderState';
+export { createColorAreaState, type ColorAreaStateOptions, type ColorAreaState, } from './createColorAreaState';
+export { createColorWheelState, type ColorWheelStateOptions, type ColorWheelState, } from './createColorWheelState';
+export { createColorFieldState, type ColorFieldStateOptions, type ColorFieldState, } from './createColorFieldState';