@proyecto-viviana/solid-stately 0.1.0 → 0.1.2

package/dist/color/types.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Color types for color picker components.
+ * Based on @react-stately/color.
+ */
+/**
+ * Supported color formats.
+ */
+export type ColorFormat = 'hex' | 'hexa' | 'rgb' | 'rgba' | 'hsl' | 'hsla' | 'hsb' | 'hsba';
+/**
+ * Color spaces.
+ */
+export type ColorSpace = 'rgb' | 'hsl' | 'hsb';
+/**
+ * Color channels.
+ */
+export type ColorChannel = 'hue' | 'saturation' | 'brightness' | 'lightness' | 'red' | 'green' | 'blue' | 'alpha';
+/**
+ * Range for a color channel.
+ */
+export interface ColorChannelRange {
+    /** Minimum value. */
+    minValue: number;
+    /** Maximum value. */
+    maxValue: number;
+    /** Step for keyboard increment. */
+    step: number;
+    /** Page step for larger increments. */
+    pageSize: number;
+}
+/**
+ * Color axes for a color space.
+ */
+export interface ColorAxes {
+    /** X-axis channel. */
+    xChannel: ColorChannel;
+    /** Y-axis channel. */
+    yChannel: ColorChannel;
+    /** Z-axis channel (the one not on x or y). */
+    zChannel: ColorChannel;
+}
+/**
+ * Color interface representing a color value.
+ */
+export interface Color {
+    /** Convert to a different format. */
+    toFormat(format: ColorFormat): Color;
+    /** Convert to a CSS string. */
+    toString(format?: ColorFormat | 'css'): string;
+    /** Clone this color. */
+    clone(): Color;
+    /** Get the hex value as an integer. */
+    toHexInt(): number;
+    /** Get the value of a specific channel. */
+    getChannelValue(channel: ColorChannel): number;
+    /** Create a new color with a channel value changed. */
+    withChannelValue(channel: ColorChannel, value: number): Color;
+    /** Get the range for a channel. */
+    getChannelRange(channel: ColorChannel): ColorChannelRange;
+    /** Get the localized name of a channel. */
+    getChannelName(channel: ColorChannel, locale: string): string;
+    /** Get the format options for a channel. */
+    getChannelFormatOptions(channel: ColorChannel): Intl.NumberFormatOptions;
+    /** Format the value of a channel. */
+    formatChannelValue(channel: ColorChannel, locale: string): string;
+    /** Get the color space. */
+    getColorSpace(): ColorSpace;
+    /** Get the axes for a color space. */
+    getColorSpaceAxes(xyChannels?: {
+        xChannel?: ColorChannel;
+        yChannel?: ColorChannel;
+    }): ColorAxes;
+    /** Get all channels for this color space. */
+    getColorChannels(): [ColorChannel, ColorChannel, ColorChannel];
+    /** Get a human-readable color name. */
+    getColorName(locale: string): string;
+    /** Get the hue name (e.g., "red", "blue"). */
+    getHueName(locale: string): string;
+}
+/**
+ * RGB color value.
+ */
+export interface RGBColor {
+    red: number;
+    green: number;
+    blue: number;
+    alpha: number;
+}
+/**
+ * HSL color value.
+ */
+export interface HSLColor {
+    hue: number;
+    saturation: number;
+    lightness: number;
+    alpha: number;
+}
+/**
+ * HSB color value.
+ */
+export interface HSBColor {
+    hue: number;
+    saturation: number;
+    brightness: number;
+    alpha: number;
+}

package/dist/combobox/createComboBoxState.d.ts

@@ -0,0 +1,124 @@
+/**
+ * State management for ComboBox components.
+ * Based on @react-stately/combobox useComboBoxState.
+ *
+ * ComboBox combines a text input with a dropdown list, allowing users to
+ * either type to filter options or select from a list.
+ */
+import { type Accessor } from 'solid-js';
+import { type MaybeAccessor } from '../utils';
+import type { Key, CollectionNode, Collection, FocusStrategy } from '../collections/types';
+export type MenuTriggerAction = 'focus' | 'input' | 'manual';
+export type { FocusStrategy } from '../collections/types';
+export type FilterFn = (textValue: string, inputValue: string) => boolean;
+export interface ComboBoxStateProps<T = unknown> {
+    /** The items to display in the combobox dropdown. */
+    items: T[];
+    /** Default items when uncontrolled. */
+    defaultItems?: T[];
+    /** Function to get the key for an item. */
+    getKey?: (item: T) => Key;
+    /** Function to get the text value for 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>;
+    /** The currently selected key (controlled). */
+    selectedKey?: Key | null;
+    /** The default selected key (uncontrolled). */
+    defaultSelectedKey?: Key | null;
+    /** Handler called when the selection changes. */
+    onSelectionChange?: (key: Key | null) => void;
+    /** The current input value (controlled). */
+    inputValue?: string;
+    /** The default input value (uncontrolled). */
+    defaultInputValue?: string;
+    /** Handler called when the input value changes. */
+    onInputChange?: (value: string) => void;
+    /** Whether the combobox is open (controlled). */
+    isOpen?: boolean;
+    /** Whether the combobox is open by default (uncontrolled). */
+    defaultOpen?: boolean;
+    /** Handler called when the open state changes. */
+    onOpenChange?: (isOpen: boolean, trigger?: MenuTriggerAction) => void;
+    /** Whether the combobox is disabled. */
+    isDisabled?: boolean;
+    /** Whether the combobox is read-only. */
+    isReadOnly?: boolean;
+    /** Whether the combobox is required. */
+    isRequired?: boolean;
+    /** The filter function to use when filtering items. */
+    defaultFilter?: FilterFn;
+    /** Whether to allow the menu to open when there are no items. */
+    allowsEmptyCollection?: boolean;
+    /** Whether to allow custom values that don't match any option. */
+    allowsCustomValue?: boolean;
+    /** What triggers the menu to open. */
+    menuTrigger?: MenuTriggerAction;
+    /** Whether to close the menu on blur. */
+    shouldCloseOnBlur?: boolean;
+}
+export interface ComboBoxState<T = unknown> {
+    /** The collection of items (may be filtered). */
+    readonly collection: Accessor<Collection<T>>;
+    /** Whether the combobox dropdown is open. */
+    readonly isOpen: Accessor<boolean>;
+    /** Open the combobox dropdown. */
+    open(focusStrategy?: FocusStrategy | null, trigger?: MenuTriggerAction): void;
+    /** Close the combobox dropdown. */
+    close(): void;
+    /** Toggle the combobox dropdown. */
+    toggle(focusStrategy?: FocusStrategy | null, trigger?: MenuTriggerAction): void;
+    /** The currently selected key. */
+    readonly selectedKey: Accessor<Key | null>;
+    /** The default selected key. */
+    readonly defaultSelectedKey: Key | null;
+    /** The currently selected item. */
+    readonly selectedItem: Accessor<CollectionNode<T> | null>;
+    /** Set the selected key. */
+    setSelectedKey(key: Key | null): void;
+    /** The current input value. */
+    readonly inputValue: Accessor<string>;
+    /** The default input value. */
+    readonly defaultInputValue: string;
+    /** Set the input value. */
+    setInputValue(value: string): void;
+    /** The currently focused key in the list. */
+    readonly focusedKey: Accessor<Key | null>;
+    /** Set the focused key. */
+    setFocusedKey(key: Key | null): void;
+    /** Whether the combobox input has focus. */
+    readonly isFocused: Accessor<boolean>;
+    /** Set whether the combobox has focus. */
+    setFocused(isFocused: boolean): void;
+    /** The focus strategy to use when opening. */
+    readonly focusStrategy: Accessor<FocusStrategy | null>;
+    /** Commit the current selection (select focused item or custom value). */
+    commit(): void;
+    /** Revert input to the selected item's text and close menu. */
+    revert(): void;
+    /** Whether a specific key is disabled. */
+    isKeyDisabled(key: Key): boolean;
+    /** Select a key and close the menu (for ListState compatibility). */
+    select(key: Key): void;
+    /** The selection mode (always 'single' for combobox). */
+    readonly selectionMode: Accessor<'single'>;
+    /** Check if a key is selected. */
+    isSelected(key: Key): boolean;
+    /** Whether the combobox is disabled. */
+    readonly isDisabled: boolean;
+    /** Whether the combobox is read-only. */
+    readonly isReadOnly: boolean;
+    /** Whether the combobox is required. */
+    readonly isRequired: boolean;
+}
+/**
+ * Default filter function that does case-insensitive "contains" matching.
+ */
+export declare const defaultContainsFilter: FilterFn;
+/**
+ * Creates state for a combobox component.
+ * Combines list state with input value management and filtering.
+ */
+export declare function createComboBoxState<T = unknown>(props: MaybeAccessor<ComboBoxStateProps<T>>): ComboBoxState<T>;

package/dist/combobox/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * ComboBox state management for Solid Stately.
+ */
+export { createComboBoxState, defaultContainsFilter, type ComboBoxState, type ComboBoxStateProps, type FilterFn, type MenuTriggerAction, type FocusStrategy, } from './createComboBoxState';

package/dist/disclosure/createDisclosureState.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Disclosure state management for SolidJS
+ * Based on @react-stately/disclosure useDisclosureState and useDisclosureGroupState
+ */
+import { type Accessor } from 'solid-js';
+import { type MaybeAccessor } from '../utils';
+export interface DisclosureStateProps {
+    /** Whether the disclosure is expanded (controlled). */
+    isExpanded?: boolean;
+    /** Whether the disclosure is expanded by default (uncontrolled). */
+    defaultExpanded?: boolean;
+    /** Handler that is called when the disclosure expanded state changes. */
+    onExpandedChange?: (isExpanded: boolean) => void;
+}
+export interface DisclosureState {
+    /** Whether the disclosure is currently expanded. */
+    readonly isExpanded: Accessor<boolean>;
+    /** Sets whether the disclosure is expanded. */
+    setExpanded(isExpanded: boolean): void;
+    /** Expand the disclosure. */
+    expand(): void;
+    /** Collapse the disclosure. */
+    collapse(): void;
+    /** Toggles the disclosure's visibility. */
+    toggle(): void;
+}
+/**
+ * Manages state for a disclosure widget. Tracks whether the disclosure is expanded,
+ * and provides methods to toggle this state.
+ */
+export declare function createDisclosureState(props?: MaybeAccessor<DisclosureStateProps>): DisclosureState;
+export type Key = string | number;
+export interface DisclosureGroupStateProps {
+    /** Whether multiple items can be expanded at the same time. */
+    allowsMultipleExpanded?: boolean;
+    /** Whether all items are disabled. */
+    isDisabled?: boolean;
+    /** The currently expanded keys in the group (controlled). */
+    expandedKeys?: Iterable<Key>;
+    /** The initial expanded keys in the group (uncontrolled). */
+    defaultExpandedKeys?: Iterable<Key>;
+    /** Handler that is called when items are expanded or collapsed. */
+    onExpandedChange?: (keys: Set<Key>) => void;
+}
+export interface DisclosureGroupState {
+    /** Whether multiple items can be expanded at the same time. */
+    readonly allowsMultipleExpanded: boolean;
+    /** Whether all items are disabled. */
+    readonly isDisabled: boolean;
+    /** A set of keys for items that are expanded. */
+    readonly expandedKeys: Accessor<Set<Key>>;
+    /** Toggles the expanded state for an item by its key. */
+    toggleKey(key: Key): void;
+    /** Replaces the set of expanded keys. */
+    setExpandedKeys(keys: Set<Key>): void;
+    /** Check if a specific key is expanded. */
+    isExpanded(key: Key): boolean;
+}
+/**
+ * Manages state for a group of disclosures, e.g. an accordion.
+ * It supports both single and multiple expanded items.
+ */
+export declare function createDisclosureGroupState(props?: MaybeAccessor<DisclosureGroupStateProps>): DisclosureGroupState;

package/dist/disclosure/index.d.ts

@@ -0,0 +1 @@
+export { createDisclosureState, createDisclosureGroupState, type DisclosureStateProps, type DisclosureState, type DisclosureGroupStateProps, type DisclosureGroupState, type Key, } from './createDisclosureState';

package/dist/dnd/createDragState.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Drag state management for solid-stately.
+ *
+ * Provides reactive state for drag operations.
+ */
+import { type Accessor } from 'solid-js';
+import type { DragItem, DragStartEvent, DragMoveEvent, DragEndEvent, DropOperation, DragPreviewRenderer } from './types';
+export interface DragStateOptions {
+    /** A function that returns the items being dragged. */
+    getItems: () => DragItem[];
+    /** Function that returns the allowed drop operations. */
+    getAllowedDropOperations?: () => DropOperation[];
+    /** Handler that is called when a drag operation is started. */
+    onDragStart?: (e: DragStartEvent) => void;
+    /** Handler that is called when the drag is moved. */
+    onDragMove?: (e: DragMoveEvent) => void;
+    /** Handler that is called when the drag operation ends. */
+    onDragEnd?: (e: DragEndEvent) => void;
+    /** Whether the drag operation is disabled. */
+    isDisabled?: boolean;
+    /** Whether there is a separate drag button affordance. */
+    hasDragButton?: boolean;
+    /** Preview renderer function ref. */
+    preview?: {
+        current: DragPreviewRenderer | null;
+    };
+}
+export interface DragState {
+    /** Whether an element is currently being dragged. */
+    readonly isDragging: boolean;
+    /** Whether drag is disabled. */
+    readonly isDisabled: boolean;
+    /** Start a drag operation. */
+    startDrag(x: number, y: number): void;
+    /** Update drag position. */
+    moveDrag(x: number, y: number): void;
+    /** End a drag operation. */
+    endDrag(x: number, y: number, dropOperation: DropOperation): void;
+    /** Cancel a drag operation. */
+    cancelDrag(): void;
+    /** Get the items being dragged. */
+    getItems(): DragItem[];
+    /** Get allowed drop operations. */
+    getAllowedDropOperations(): DropOperation[];
+    /** Whether there is a drag button. */
+    readonly hasDragButton: boolean;
+    /** Preview renderer. */
+    readonly preview: {
+        current: DragPreviewRenderer | null;
+    } | undefined;
+}
+/**
+ * Creates drag state for managing drag operations.
+ *
+ * @param props - Accessor returning drag state options
+ * @returns Drag state object
+ */
+export declare function createDragState(props: Accessor<DragStateOptions>): DragState;

package/dist/dnd/createDraggableCollectionState.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Draggable collection state management for solid-stately.
+ *
+ * Provides reactive state for dragging items from a collection.
+ */
+import { type Accessor } from 'solid-js';
+import type { DragItem, DraggableCollectionStartEvent, DraggableCollectionMoveEvent, DraggableCollectionEndEvent, DropOperation, DragPreviewRenderer } from './types';
+export interface DraggableCollectionStateOptions<T = object> {
+    /** A function that returns the items being dragged. */
+    getItems: (keys: Set<string | number>) => DragItem[];
+    /** Function that returns the allowed drop operations. */
+    getAllowedDropOperations?: () => DropOperation[];
+    /** Handler that is called when a drag operation is started. */
+    onDragStart?: (e: DraggableCollectionStartEvent) => void;
+    /** Handler that is called when the drag is moved. */
+    onDragMove?: (e: DraggableCollectionMoveEvent) => void;
+    /** Handler that is called when the drag operation ends. */
+    onDragEnd?: (e: DraggableCollectionEndEvent) => void;
+    /** Whether the drag operation is disabled. */
+    isDisabled?: boolean;
+    /** Preview renderer function ref. */
+    preview?: {
+        current: DragPreviewRenderer | null;
+    };
+}
+export interface DraggableCollectionState {
+    /** Whether items are currently being dragged. */
+    readonly isDragging: boolean;
+    /** The keys of the items being dragged. */
+    readonly draggingKeys: Set<string | number>;
+    /** Whether dragging is disabled. */
+    readonly isDisabled: boolean;
+    /** Start a drag operation with the given keys. */
+    startDrag(keys: Set<string | number>, x: number, y: number): void;
+    /** Update drag position. */
+    moveDrag(x: number, y: number): void;
+    /** End a drag operation. */
+    endDrag(x: number, y: number, dropOperation: DropOperation, isInternal: boolean): void;
+    /** Cancel a drag operation. */
+    cancelDrag(): void;
+    /** Get the items being dragged for the given keys. */
+    getItems(keys: Set<string | number>): DragItem[];
+    /** Get allowed drop operations. */
+    getAllowedDropOperations(): DropOperation[];
+    /** Preview renderer. */
+    readonly preview: {
+        current: DragPreviewRenderer | null;
+    } | undefined;
+}
+/**
+ * Creates state for dragging items from a collection.
+ *
+ * @param props - Accessor returning draggable collection options
+ * @returns Draggable collection state object
+ */
+export declare function createDraggableCollectionState<T = object>(props: Accessor<DraggableCollectionStateOptions<T>>): DraggableCollectionState;

package/dist/dnd/createDropState.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Drop state management for solid-stately.
+ *
+ * Provides reactive state for drop target operations.
+ */
+import { type Accessor } from 'solid-js';
+import type { DropItem, DropEnterEvent, DropMoveEvent, DropExitEvent, DropActivateEvent, DropEvent, DropOperation, DragTypes } from './types';
+export interface DropStateOptions {
+    /**
+     * A function returning the drop operation to be performed.
+     */
+    getDropOperation?: (types: DragTypes, allowedOperations: DropOperation[]) => DropOperation;
+    /**
+     * A function returning the drop operation for a specific point.
+     */
+    getDropOperationForPoint?: (types: DragTypes, allowedOperations: DropOperation[], x: number, y: number) => DropOperation;
+    /** Handler that is called when a valid drag enters the drop target. */
+    onDropEnter?: (e: DropEnterEvent) => void;
+    /** Handler that is called when a valid drag is moved within the drop target. */
+    onDropMove?: (e: DropMoveEvent) => void;
+    /** Handler that is called after a valid drag is held over the drop target. */
+    onDropActivate?: (e: DropActivateEvent) => void;
+    /** Handler that is called when a valid drag exits the drop target. */
+    onDropExit?: (e: DropExitEvent) => void;
+    /** Handler that is called when a valid drag is dropped on the drop target. */
+    onDrop?: (e: DropEvent) => void;
+    /** Whether there is a separate drop button affordance. */
+    hasDropButton?: boolean;
+    /** Whether the drop target is disabled. */
+    isDisabled?: boolean;
+}
+export interface DropState {
+    /** Whether the drop target is currently being hovered or focused. */
+    readonly isDropTarget: boolean;
+    /** Whether the drop target is disabled. */
+    readonly isDisabled: boolean;
+    /** Whether there is a drop button. */
+    readonly hasDropButton: boolean;
+    /** Enter the drop target. */
+    enterTarget(x: number, y: number): void;
+    /** Move within the drop target. */
+    moveInTarget(x: number, y: number): void;
+    /** Exit the drop target. */
+    exitTarget(x: number, y: number): void;
+    /** Activate the drop target (after holding). */
+    activateTarget(x: number, y: number): void;
+    /** Perform a drop on the target. */
+    drop(x: number, y: number, items: DropItem[], dropOperation: DropOperation): void;
+    /** Get the drop operation for given types. */
+    getDropOperation(types: DragTypes, allowedOperations: DropOperation[]): DropOperation;
+    /** Get the drop operation for a specific point. */
+    getDropOperationForPoint(types: DragTypes, allowedOperations: DropOperation[], x: number, y: number): DropOperation;
+}
+/**
+ * Creates drop state for managing drop target operations.
+ *
+ * @param props - Accessor returning drop state options
+ * @returns Drop state object
+ */
+export declare function createDropState(props: Accessor<DropStateOptions>): DropState;

package/dist/dnd/createDroppableCollectionState.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Droppable collection state management for solid-stately.
+ *
+ * Provides reactive state for accepting drops onto a collection.
+ */
+import { type Accessor } from 'solid-js';
+import type { DropItem, DropTarget, DropOperation, DragTypes, DroppableCollectionEnterEvent, DroppableCollectionActivateEvent, DroppableCollectionExitEvent, DroppableCollectionDropEvent, DroppableCollectionInsertDropEvent, DroppableCollectionRootDropEvent, DroppableCollectionOnItemDropEvent, DroppableCollectionReorderEvent, ItemDropTarget } from './types';
+export interface DroppableCollectionStateOptions {
+    /**
+     * The drag types that the droppable collection accepts.
+     * @default 'all'
+     */
+    acceptedDragTypes?: 'all' | Array<string | symbol>;
+    /**
+     * A function returning the drop operation to be performed.
+     */
+    getDropOperation?: (target: DropTarget, types: DragTypes, allowedOperations: DropOperation[]) => DropOperation;
+    /** Handler that is called when a valid drag enters a drop target. */
+    onDropEnter?: (e: DroppableCollectionEnterEvent) => void;
+    /** Handler that is called after a valid drag is held over a drop target. */
+    onDropActivate?: (e: DroppableCollectionActivateEvent) => void;
+    /** Handler that is called when a valid drag exits a drop target. */
+    onDropExit?: (e: DroppableCollectionExitEvent) => void;
+    /** Handler that is called when a valid drag is dropped. */
+    onDrop?: (e: DroppableCollectionDropEvent) => void;
+    /** Handler that is called when external items are dropped "between" items. */
+    onInsert?: (e: DroppableCollectionInsertDropEvent) => void;
+    /** Handler that is called when external items are dropped on the collection's root. */
+    onRootDrop?: (e: DroppableCollectionRootDropEvent) => void;
+    /** Handler that is called when items are dropped "on" an item. */
+    onItemDrop?: (e: DroppableCollectionOnItemDropEvent) => void;
+    /** Handler that is called when items are reordered within the collection. */
+    onReorder?: (e: DroppableCollectionReorderEvent) => void;
+    /** Handler that is called when items are moved within the source collection. */
+    onMove?: (e: DroppableCollectionReorderEvent) => void;
+    /** A function returning whether a given target is a valid "on" drop target. */
+    shouldAcceptItemDrop?: (target: ItemDropTarget, types: DragTypes) => boolean;
+    /** Whether the droppable collection is disabled. */
+    isDisabled?: boolean;
+}
+export interface DroppableCollectionState {
+    /** Whether a drag is currently over the collection. */
+    readonly isDropTarget: boolean;
+    /** The current drop target within the collection. */
+    readonly target: DropTarget | null;
+    /** Whether the collection is disabled for drops. */
+    readonly isDisabled: boolean;
+    /** Set the current drop target. */
+    setTarget(target: DropTarget | null): void;
+    /** Check if a drag type is accepted. */
+    isAccepted(types: DragTypes): boolean;
+    /** Enter the collection with a drop target. */
+    enterTarget(target: DropTarget, x: number, y: number): void;
+    /** Move to a new target within the collection. */
+    moveToTarget(target: DropTarget, x: number, y: number): void;
+    /** Exit the collection. */
+    exitTarget(x: number, y: number): void;
+    /** Activate the current target. */
+    activateTarget(x: number, y: number): void;
+    /** Perform a drop on the collection. */
+    drop(items: DropItem[], dropOperation: DropOperation, isInternal: boolean, draggingKeys?: Set<string | number>): void;
+    /** Get the drop operation for a target. */
+    getDropOperation(target: DropTarget, types: DragTypes, allowedOperations: DropOperation[]): DropOperation;
+    /** Check if an item drop should be accepted. */
+    shouldAcceptItemDrop(target: ItemDropTarget, types: DragTypes): boolean;
+}
+/**
+ * Symbol for directory drag type.
+ */
+export declare const DIRECTORY_DRAG_TYPE: symbol;
+/**
+ * Creates state for accepting drops onto a collection.
+ *
+ * @param props - Accessor returning droppable collection options
+ * @returns Droppable collection state object
+ */
+export declare function createDroppableCollectionState(props: Accessor<DroppableCollectionStateOptions>): DroppableCollectionState;

package/dist/dnd/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Drag and Drop state management for solid-stately.
+ *
+ * Exports for DnD functionality.
+ */
+export type { DropOperation, DragItem, DragDropEvent, DragStartEvent, DragMoveEvent, DragEndEvent, DropEnterEvent, DropMoveEvent, DropActivateEvent, DropExitEvent, TextDropItem, FileDropItem, DirectoryDropItem, DropItem, DropEvent, DropPosition, RootDropTarget, ItemDropTarget, DropTarget, DroppableCollectionEnterEvent, DroppableCollectionMoveEvent, DroppableCollectionActivateEvent, DroppableCollectionExitEvent, DroppableCollectionDropEvent, DroppableCollectionInsertDropEvent, DroppableCollectionRootDropEvent, DroppableCollectionOnItemDropEvent, DroppableCollectionReorderEvent, DragTypes, DropTargetDelegate, DraggableCollectionStartEvent, DraggableCollectionMoveEvent, DraggableCollectionEndEvent, DragPreviewRenderer, DroppableCollectionUtilityOptions, DroppableCollectionBaseProps, DroppableCollectionProps, DraggableCollectionProps, } from './types';
+export { createDragState, type DragStateOptions, type DragState, } from './createDragState';
+export { createDropState, type DropStateOptions, type DropState, } from './createDropState';
+export { createDraggableCollectionState, type DraggableCollectionStateOptions, type DraggableCollectionState, } from './createDraggableCollectionState';
+export { createDroppableCollectionState, DIRECTORY_DRAG_TYPE, type DroppableCollectionStateOptions, type DroppableCollectionState, } from './createDroppableCollectionState';