@proyecto-viviana/solidaria 0.2.0 → 0.2.1

package/dist/dnd/types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Drag and Drop ARIA types for solidaria.
+ */
+import type { JSX } from 'solid-js';
+import type { DragItem, DragStartEvent, DragMoveEvent, DragEndEvent, DropEnterEvent, DropMoveEvent, DropActivateEvent, DropExitEvent, DropEvent, DropOperation, DragTypes, DragPreviewRenderer } from '@proyecto-viviana/solid-stately';
+export interface AriaDragOptions {
+    /** 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 there is a separate drag button affordance. */
+    hasDragButton?: boolean;
+    /** Whether the drag operation is disabled. */
+    isDisabled?: boolean;
+    /** Preview renderer function ref. */
+    preview?: {
+        current: DragPreviewRenderer | null;
+    };
+}
+export interface DragAria {
+    /** Props for the draggable element. */
+    dragProps: JSX.HTMLAttributes<HTMLElement>;
+    /** Props for the explicit drag button affordance, if any. */
+    dragButtonProps: JSX.ButtonHTMLAttributes<HTMLButtonElement>;
+    /** Whether the element is currently being dragged. */
+    isDragging: boolean;
+}
+export interface AriaDropOptions {
+    /**
+     * 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 DropAria {
+    /** Props for the droppable element. */
+    dropProps: JSX.HTMLAttributes<HTMLElement>;
+    /** Whether the drop target is currently being hovered or focused. */
+    isDropTarget: boolean;
+    /** Props for the explicit drop button affordance, if any. */
+    dropButtonProps: JSX.ButtonHTMLAttributes<HTMLButtonElement>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/dnd/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/dnd/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,KAAK,EACV,QAAQ,EACR,cAAc,EACd,aAAa,EACb,YAAY,EACZ,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,SAAS,EACT,aAAa,EACb,SAAS,EACT,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AAEzC,MAAM,WAAW,eAAe;IAC9B,uDAAuD;IACvD,QAAQ,EAAE,MAAM,QAAQ,EAAE,CAAC;IAC3B,yDAAyD;IACzD,wBAAwB,CAAC,EAAE,MAAM,aAAa,EAAE,CAAC;IACjD,+DAA+D;IAC/D,WAAW,CAAC,EAAE,CAAC,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IAC1C,qDAAqD;IACrD,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,aAAa,KAAK,IAAI,CAAC;IACxC,2DAA2D;IAC3D,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,IAAI,CAAC;IACtC,0DAA0D;IAC1D,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,8CAA8C;IAC9C,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,qCAAqC;IACrC,OAAO,CAAC,EAAE;QAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAAA;KAAE,CAAC;CACnD;AAED,MAAM,WAAW,QAAQ;IACvB,uCAAuC;IACvC,SAAS,EAAE,GAAG,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;IAC3C,6DAA6D;IAC7D,eAAe,EAAE,GAAG,CAAC,oBAAoB,CAAC,iBAAiB,CAAC,CAAC;IAC7D,sDAAsD;IACtD,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,gBAAgB,CAAC,EAAE,CACjB,KAAK,EAAE,SAAS,EAChB,iBAAiB,EAAE,aAAa,EAAE,KAC/B,aAAa,CAAC;IACnB;;OAEG;IACH,wBAAwB,CAAC,EAAE,CACzB,KAAK,EAAE,SAAS,EAChB,iBAAiB,EAAE,aAAa,EAAE,EAClC,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,KACN,aAAa,CAAC;IACnB,uEAAuE;IACvE,WAAW,CAAC,EAAE,CAAC,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IAC1C,gFAAgF;IAChF,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,aAAa,KAAK,IAAI,CAAC;IACxC,8EAA8E;IAC9E,cAAc,CAAC,EAAE,CAAC,CAAC,EAAE,iBAAiB,KAAK,IAAI,CAAC;IAChD,sEAAsE;IACtE,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,aAAa,KAAK,IAAI,CAAC;IACxC,8EAA8E;IAC9E,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,KAAK,IAAI,CAAC;IAChC,0DAA0D;IAC1D,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,2CAA2C;IAC3C,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,QAAQ;IACvB,uCAAuC;IACvC,SAAS,EAAE,GAAG,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;IAC3C,qEAAqE;IACrE,YAAY,EAAE,OAAO,CAAC;IACtB,6DAA6D;IAC7D,eAAe,EAAE,GAAG,CAAC,oBAAoB,CAAC,iBAAiB,CAAC,CAAC;CAC9D"}

package/dist/dnd/utils.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Drag and Drop utilities for solidaria.
+ */
+import type { DragItem, DropItem, TextDropItem, FileDropItem, DirectoryDropItem, DropOperation } from '@proyecto-viviana/solid-stately';
+export declare const NATIVE_DRAG_TYPES: Set<string>;
+export declare const CUSTOM_DRAG_TYPE = "application/vnd.solidaria.items+json";
+export declare const GENERIC_TYPE = "application/octet-stream";
+export declare enum DROP_OPERATION {
+    none = 0,
+    cancel = 0,
+    move = 1,
+    copy = 2,
+    link = 4,
+    all = 7
+}
+export declare const DROP_OPERATION_ALLOWED: Record<string, number>;
+export declare const EFFECT_ALLOWED: Record<number, string>;
+export declare const DROP_EFFECT_TO_DROP_OPERATION: Record<string, DropOperation>;
+export declare const DROP_OPERATION_TO_DROP_EFFECT: Record<DropOperation, string>;
+/**
+ * Get the types present in drag items.
+ */
+export declare function getTypes(items: DragItem[]): Set<string>;
+/**
+ * Write drag items to a DataTransfer object.
+ */
+export declare function writeToDataTransfer(dataTransfer: DataTransfer, items: DragItem[]): void;
+/**
+ * Read drop items from a DataTransfer object.
+ */
+export declare function readFromDataTransfer(dataTransfer: DataTransfer): DropItem[];
+/**
+ * DragTypes implementation for checking drag types.
+ */
+export declare class DragTypesImpl {
+    private types;
+    private includesUnknownTypes;
+    constructor(dataTransfer: DataTransfer);
+    has(type: string | symbol): boolean;
+}
+/**
+ * Check if a drop item is a text item.
+ */
+export declare function isTextDropItem(dropItem: DropItem): dropItem is TextDropItem;
+/**
+ * Check if a drop item is a file item.
+ */
+export declare function isFileDropItem(dropItem: DropItem): dropItem is FileDropItem;
+/**
+ * Check if a drop item is a directory item.
+ */
+export declare function isDirectoryDropItem(dropItem: DropItem): dropItem is DirectoryDropItem;
+export declare function setGlobalDropEffect(effect: string | undefined): void;
+export declare function getGlobalDropEffect(): string | undefined;
+export declare function setGlobalAllowedDropOperations(ops: number): void;
+export declare function getGlobalAllowedDropOperations(): number;
+//# sourceMappingURL=utils.d.ts.map

package/dist/dnd/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/dnd/utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EACV,QAAQ,EACR,QAAQ,EACR,YAAY,EACZ,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACd,MAAM,iCAAiC,CAAC;AAGzC,eAAO,MAAM,iBAAiB,EAAE,GAAG,CAAC,MAAM,CAIxC,CAAC;AAGH,eAAO,MAAM,gBAAgB,yCAAyC,CAAC;AAGvE,eAAO,MAAM,YAAY,6BAA6B,CAAC;AAGvD,oBAAY,cAAc;IACxB,IAAI,IAAI;IACR,MAAM,IAAI;IACV,IAAI,IAAS;IACb,IAAI,IAAS;IACb,IAAI,IAAS;IACb,GAAG,IAAiC;CACrC;AAGD,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAUzD,CAAC;AAGF,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CASjD,CAAC;AAGF,eAAO,MAAM,6BAA6B,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAKvE,CAAC;AAGF,eAAO,MAAM,6BAA6B,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,CAKvE,CAAC;AAEF;;GAEG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAQvD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,YAAY,EAC1B,KAAK,EAAE,QAAQ,EAAE,GAChB,IAAI,CA4CN;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,YAAY,GAAG,QAAQ,EAAE,CAoD3E;AAeD;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,oBAAoB,CAAU;gBAE1B,YAAY,EAAE,YAAY;IAsBtC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO;CASpC;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,IAAI,YAAY,CAE3E;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,IAAI,YAAY,CAE3E;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,GACjB,QAAQ,IAAI,iBAAiB,CAE/B;AAMD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAEpE;AAED,wBAAgB,mBAAmB,IAAI,MAAM,GAAG,SAAS,CAExD;AAED,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAEhE;AAED,wBAAgB,8BAA8B,IAAI,MAAM,CAEvD"}

package/dist/focus/FocusScope.d.ts

@@ -0,0 +1,57 @@
+/**
+ * FocusScope component for managing focus containment, restoration, and auto-focus.
+ * Based on @react-aria/focus FocusScope.
+ */
+import { type JSX, type ParentComponent } from 'solid-js';
+export interface FocusScopeProps {
+    /** The contents of the focus scope. */
+    children: JSX.Element;
+    /**
+     * Whether to contain focus inside the scope, so users cannot
+     * move focus outside, for example in a modal dialog.
+     */
+    contain?: boolean;
+    /**
+     * Whether to restore focus back to the element that was focused
+     * when the focus scope mounted, after the focus scope unmounts.
+     */
+    restoreFocus?: boolean;
+    /** Whether to auto focus the first focusable element in the focus scope on mount. */
+    autoFocus?: boolean;
+}
+export interface FocusManagerOptions {
+    /** The element to start searching from. The currently focused element by default. */
+    from?: Element;
+    /** Whether to only include tabbable elements, or all focusable elements. */
+    tabbable?: boolean;
+    /** Whether focus should wrap around when it reaches the end of the scope. */
+    wrap?: boolean;
+    /** A callback that determines whether the given element is focused. */
+    accept?: (node: Element) => boolean;
+}
+export interface FocusManager {
+    /** Moves focus to the next focusable or tabbable element in the focus scope. */
+    focusNext(opts?: FocusManagerOptions): HTMLElement | null;
+    /** Moves focus to the previous focusable or tabbable element in the focus scope. */
+    focusPrevious(opts?: FocusManagerOptions): HTMLElement | null;
+    /** Moves focus to the first focusable or tabbable element in the focus scope. */
+    focusFirst(opts?: FocusManagerOptions): HTMLElement | null;
+    /** Moves focus to the last focusable or tabbable element in the focus scope. */
+    focusLast(opts?: FocusManagerOptions): HTMLElement | null;
+}
+/**
+ * Returns a FocusManager interface for the parent FocusScope.
+ * A FocusManager can be used to programmatically move focus within
+ * a FocusScope, e.g. in response to user events like keyboard navigation.
+ */
+export declare function useFocusManager(): FocusManager | undefined;
+/**
+ * A FocusScope manages focus for its descendants. It supports containing focus inside
+ * the scope, restoring focus to the previously focused element on unmount, and auto
+ * focusing children on mount. It also acts as a container for a programmatic focus
+ * management interface that can be used to move focus forward and back in response
+ * to user events.
+ */
+export declare const FocusScope: ParentComponent<FocusScopeProps>;
+export default FocusScope;
+//# sourceMappingURL=FocusScope.d.ts.map

package/dist/focus/FocusScope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FocusScope.d.ts","sourceRoot":"","sources":["../../src/focus/FocusScope.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAKL,KAAK,GAAG,EAER,KAAK,eAAe,EAGrB,MAAM,UAAU,CAAA;AASjB,MAAM,WAAW,eAAe;IAC9B,uCAAuC;IACvC,QAAQ,EAAE,GAAG,CAAC,OAAO,CAAA;IACrB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,qFAAqF;IACrF,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,qFAAqF;IACrF,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,6EAA6E;IAC7E,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,uEAAuE;IACvE,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAA;CACpC;AAED,MAAM,WAAW,YAAY;IAC3B,gFAAgF;IAChF,SAAS,CAAC,IAAI,CAAC,EAAE,mBAAmB,GAAG,WAAW,GAAG,IAAI,CAAA;IACzD,oFAAoF;IACpF,aAAa,CAAC,IAAI,CAAC,EAAE,mBAAmB,GAAG,WAAW,GAAG,IAAI,CAAA;IAC7D,iFAAiF;IACjF,UAAU,CAAC,IAAI,CAAC,EAAE,mBAAmB,GAAG,WAAW,GAAG,IAAI,CAAA;IAC1D,gFAAgF;IAChF,SAAS,CAAC,IAAI,CAAC,EAAE,mBAAmB,GAAG,WAAW,GAAG,IAAI,CAAA;CAC1D;AAaD;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,YAAY,GAAG,SAAS,CAE1D;AAwED;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,EAAE,eAAe,CAAC,eAAe,CAqPvD,CAAA;AAED,eAAe,UAAU,CAAA"}

package/dist/focus/createAutoFocus.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Auto-focus management for solidaria
+ *
+ * Provides priority-based auto-focus with deferred execution
+ * and conflict resolution for multiple auto-focus elements.
+ */
+export interface AutoFocusOptions {
+    /**
+     * Whether auto-focus is enabled.
+     * @default true
+     */
+    isEnabled?: boolean;
+    /**
+     * Priority level (higher = more important).
+     * When multiple elements request auto-focus, the highest priority wins.
+     * @default 0
+     */
+    priority?: number;
+    /**
+     * Delay in milliseconds before focusing.
+     * Useful for animations or transitions.
+     * @default 0
+     */
+    delay?: number;
+    /**
+     * Whether to focus even if another element is already focused.
+     * @default false
+     */
+    force?: boolean;
+    /**
+     * Whether to prevent scrolling when focusing.
+     * @default true
+     */
+    preventScroll?: boolean;
+    /**
+     * Callback when focus is applied.
+     */
+    onFocus?: (element: HTMLElement) => void;
+    /**
+     * Callback when focus is skipped (due to lower priority or other reasons).
+     */
+    onSkip?: () => void;
+}
+export interface AutoFocusResult {
+    /**
+     * Manually trigger the auto-focus.
+     */
+    focus: () => void;
+    /**
+     * Cancel any pending auto-focus.
+     */
+    cancel: () => void;
+}
+/**
+ * Creates auto-focus behavior for an element.
+ *
+ * This hook registers the element for auto-focus when mounted. If multiple
+ * elements request auto-focus, the one with the highest priority wins.
+ *
+ * @param ref - Accessor for the element to focus
+ * @param options - Auto-focus options
+ *
+ * @example
+ * ```tsx
+ * function Dialog(props) {
+ *   let contentRef: HTMLDivElement | undefined;
+ *
+ *   createAutoFocus(() => contentRef, {
+ *     priority: 10, // High priority for dialogs
+ *     onFocus: () => console.log('Dialog focused'),
+ *   });
+ *
+ *   return (
+ *     <div ref={contentRef} tabIndex={-1}>
+ *       {props.children}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With delay for animations
+ * function AnimatedPanel() {
+ *   let panelRef: HTMLDivElement | undefined;
+ *
+ *   createAutoFocus(() => panelRef, {
+ *     delay: 300, // Wait for animation
+ *   });
+ *
+ *   return <div ref={panelRef} class="animated-panel">...</div>;
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Conditional auto-focus
+ * function Input(props) {
+ *   let inputRef: HTMLInputElement | undefined;
+ *
+ *   createAutoFocus(() => inputRef, {
+ *     isEnabled: props.autoFocus,
+ *   });
+ *
+ *   return <input ref={inputRef} />;
+ * }
+ * ```
+ */
+export declare function createAutoFocus(ref: () => HTMLElement | null | undefined, options?: AutoFocusOptions): AutoFocusResult;
+/**
+ * Clears all pending auto-focus requests.
+ * Useful for testing or when navigating away.
+ */
+export declare function clearAutoFocusQueue(): void;
+/**
+ * Gets the current auto-focus queue length.
+ * Useful for debugging.
+ */
+export declare function getAutoFocusQueueLength(): number;
+//# sourceMappingURL=createAutoFocus.d.ts.map

package/dist/focus/createAutoFocus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAutoFocus.d.ts","sourceRoot":"","sources":["../../src/focus/createAutoFocus.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,CAAC;IACzC;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB;;OAEG;IACH,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB;AAgHD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,WAAW,GAAG,IAAI,GAAG,SAAS,EACzC,OAAO,GAAE,gBAAqB,GAC7B,eAAe,CAgEjB;AAMD;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAM1C;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD"}

package/dist/focus/createFocusRestore.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Focus restoration utilities for solidaria
+ *
+ * Provides enhanced focus restoration with retry logic, cross-scope tracking,
+ * and safe restoration patterns.
+ */
+export interface FocusRestoreOptions {
+    /**
+     * Whether to restore focus when the component unmounts.
+     * @default true
+     */
+    restoreOnUnmount?: boolean;
+    /**
+     * Maximum number of retries if the element is not in the DOM.
+     * @default 3
+     */
+    maxRetries?: number;
+    /**
+     * Delay between retries in milliseconds.
+     * @default 50
+     */
+    retryDelay?: number;
+    /**
+     * Callback when focus is successfully restored.
+     */
+    onRestore?: (element: HTMLElement) => void;
+    /**
+     * Callback when focus restoration fails.
+     */
+    onRestoreFailed?: () => void;
+    /**
+     * Whether to prevent scrolling when restoring focus.
+     * @default true
+     */
+    preventScroll?: boolean;
+}
+export interface FocusRestoreResult {
+    /**
+     * Manually restore focus to the saved element.
+     */
+    restore: () => boolean;
+    /**
+     * Get the saved element (if any).
+     */
+    getSavedElement: () => HTMLElement | null;
+    /**
+     * Save the currently focused element.
+     */
+    saveCurrentFocus: () => void;
+    /**
+     * Clear the saved element without restoring.
+     */
+    clear: () => void;
+}
+/**
+ * Push an element onto the focus stack.
+ */
+export declare function pushFocusStack(element: HTMLElement): void;
+/**
+ * Pop the last element from the focus stack.
+ */
+export declare function popFocusStack(): HTMLElement | undefined;
+/**
+ * Get the current focus stack length.
+ */
+export declare function getFocusStackLength(): number;
+/**
+ * Clear the entire focus stack.
+ */
+export declare function clearFocusStack(): void;
+/**
+ * Creates a focus restoration manager.
+ *
+ * This hook saves the currently focused element when mounted and provides
+ * methods to restore focus later, with retry logic for reliability.
+ *
+ * @example
+ * ```tsx
+ * function Modal(props) {
+ *   const focusRestore = createFocusRestore({
+ *     restoreOnUnmount: true,
+ *     onRestore: () => console.log('Focus restored'),
+ *   });
+ *
+ *   return (
+ *     <div role="dialog">
+ *       {props.children}
+ *       <button onClick={() => focusRestore.restore()}>
+ *         Close
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Manual focus management
+ * function Dropdown() {
+ *   const focusRestore = createFocusRestore({ restoreOnUnmount: false });
+ *
+ *   const onOpen = () => {
+ *     focusRestore.saveCurrentFocus();
+ *     // Focus dropdown content
+ *   };
+ *
+ *   const onClose = () => {
+ *     focusRestore.restore();
+ *   };
+ *
+ *   return <div>...</div>;
+ * }
+ * ```
+ */
+export declare function createFocusRestore(options?: FocusRestoreOptions): FocusRestoreResult;
+//# sourceMappingURL=createFocusRestore.d.ts.map

package/dist/focus/createFocusRestore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFocusRestore.d.ts","sourceRoot":"","sources":["../../src/focus/createFocusRestore.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAWH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,CAAC;IAC3C;;OAEG;IACH,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;IAC7B;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,OAAO,EAAE,MAAM,OAAO,CAAC;IACvB;;OAEG;IACH,eAAe,EAAE,MAAM,WAAW,GAAG,IAAI,CAAC;IAC1C;;OAEG;IACH,gBAAgB,EAAE,MAAM,IAAI,CAAC;IAC7B;;OAEG;IACH,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AASD;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CAEzD;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,WAAW,GAAG,SAAS,CAEvD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAEtC;AAuED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,GAAE,mBAAwB,GAChC,kBAAkB,CAgGpB"}

package/dist/focus/createVirtualFocus.d.ts

@@ -0,0 +1,170 @@
+/**
+ * Virtual focus management for solidaria
+ *
+ * Provides virtual focus for large collections where tracking DOM focus
+ * on every item is impractical. Instead, a single element receives real
+ * focus while aria-activedescendant indicates the virtually focused item.
+ *
+ * This is commonly used in:
+ * - Virtualized lists (where not all items are in the DOM)
+ * - Large trees
+ * - Autocomplete/combobox suggestions
+ * - Grid/table navigation
+ */
+import { type Accessor } from 'solid-js';
+export interface VirtualFocusOptions<T> {
+    /**
+     * The items in the collection.
+     */
+    items: Accessor<T[]>;
+    /**
+     * Function to get a unique key for each item.
+     */
+    getKey: (item: T) => string;
+    /**
+     * Function to check if an item is disabled.
+     */
+    isDisabled?: (item: T) => boolean;
+    /**
+     * Initial focused key.
+     */
+    defaultFocusedKey?: string;
+    /**
+     * Controlled focused key.
+     */
+    focusedKey?: Accessor<string | null>;
+    /**
+     * Callback when focused key changes.
+     */
+    onFocusChange?: (key: string | null) => void;
+    /**
+     * Whether to wrap focus at the edges.
+     * @default true
+     */
+    wrap?: boolean;
+    /**
+     * Whether to loop through disabled items.
+     * @default false
+     */
+    skipDisabled?: boolean;
+    /**
+     * Orientation for keyboard navigation.
+     * @default 'vertical'
+     */
+    orientation?: 'horizontal' | 'vertical' | 'both';
+}
+export interface VirtualFocusResult<T> {
+    /**
+     * The currently focused key.
+     */
+    focusedKey: Accessor<string | null>;
+    /**
+     * The currently focused item (if any).
+     */
+    focusedItem: Accessor<T | null>;
+    /**
+     * Set the focused key.
+     */
+    setFocusedKey: (key: string | null) => void;
+    /**
+     * Move focus to the next item.
+     */
+    focusNext: () => void;
+    /**
+     * Move focus to the previous item.
+     */
+    focusPrevious: () => void;
+    /**
+     * Move focus to the first item.
+     */
+    focusFirst: () => void;
+    /**
+     * Move focus to the last item.
+     */
+    focusLast: () => void;
+    /**
+     * Move focus by a page (for large lists).
+     */
+    focusPageDown: (pageSize?: number) => void;
+    /**
+     * Move focus up by a page (for large lists).
+     */
+    focusPageUp: (pageSize?: number) => void;
+    /**
+     * Check if a key is the currently focused key.
+     */
+    isFocused: (key: string) => boolean;
+    /**
+     * Props to spread on the container element.
+     */
+    containerProps: {
+        'aria-activedescendant': Accessor<string | undefined>;
+        onKeyDown: (e: KeyboardEvent) => void;
+    };
+    /**
+     * Get props for an item element.
+     */
+    getItemProps: (key: string) => {
+        id: string;
+        'aria-selected'?: boolean;
+    };
+}
+/**
+ * Creates virtual focus management for a collection.
+ *
+ * Virtual focus uses aria-activedescendant to indicate which item is
+ * "focused" while keeping real DOM focus on a container element. This
+ * is more performant for large collections and required for virtualized
+ * lists where items may not be in the DOM.
+ *
+ * @example
+ * ```tsx
+ * function Listbox(props) {
+ *   const virtualFocus = createVirtualFocus({
+ *     items: () => props.items,
+ *     getKey: (item) => item.id,
+ *     isDisabled: (item) => item.disabled,
+ *   });
+ *
+ *   return (
+ *     <ul
+ *       role="listbox"
+ *       tabIndex={0}
+ *       aria-activedescendant={virtualFocus.containerProps['aria-activedescendant']()}
+ *       onKeyDown={virtualFocus.containerProps.onKeyDown}
+ *     >
+ *       <For each={props.items}>
+ *         {(item) => (
+ *           <li
+ *             {...virtualFocus.getItemProps(item.id)}
+ *             role="option"
+ *             aria-selected={virtualFocus.isFocused(item.id)}
+ *           >
+ *             {item.name}
+ *           </li>
+ *         )}
+ *       </For>
+ *     </ul>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With controlled focus
+ * function ControlledListbox() {
+ *   const [focusedKey, setFocusedKey] = createSignal<string | null>(null);
+ *
+ *   const virtualFocus = createVirtualFocus({
+ *     items: () => items,
+ *     getKey: (item) => item.id,
+ *     focusedKey: focusedKey,
+ *     onFocusChange: setFocusedKey,
+ *   });
+ *
+ *   return <ul>...</ul>;
+ * }
+ * ```
+ */
+export declare function createVirtualFocus<T>(options: VirtualFocusOptions<T>): VirtualFocusResult<T>;
+//# sourceMappingURL=createVirtualFocus.d.ts.map

package/dist/focus/createVirtualFocus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createVirtualFocus.d.ts","sourceRoot":"","sources":["../../src/focus/createVirtualFocus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,KAAK,QAAQ,EAAyC,MAAM,UAAU,CAAC;AAOhF,MAAM,WAAW,mBAAmB,CAAC,CAAC;IACpC;;OAEG;IACH,KAAK,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC;IACrB;;OAEG;IACH,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC;IAC5B;;OAEG;IACH,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC;IAClC;;OAEG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;OAEG;IACH,UAAU,CAAC,EAAE,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACrC;;OAEG;IACH,aAAa,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IAC7C;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;OAGG;IACH,WAAW,CAAC,EAAE,YAAY,GAAG,UAAU,GAAG,MAAM,CAAC;CAClD;AAED,MAAM,WAAW,kBAAkB,CAAC,CAAC;IACnC;;OAEG;IACH,UAAU,EAAE,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACpC;;OAEG;IACH,WAAW,EAAE,QAAQ,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAChC;;OAEG;IACH,aAAa,EAAE,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IAC5C;;OAEG;IACH,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB;;OAEG;IACH,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B;;OAEG;IACH,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB;;OAEG;IACH,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB;;OAEG;IACH,aAAa,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3C;;OAEG;IACH,WAAW,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC;;OAEG;IACH,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IACpC;;OAEG;IACH,cAAc,EAAE;QACd,uBAAuB,EAAE,QAAQ,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;QACtD,SAAS,EAAE,CAAC,CAAC,EAAE,aAAa,KAAK,IAAI,CAAC;KACvC,CAAC;IACF;;OAEG;IACH,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK;QAC7B,EAAE,EAAE,MAAM,CAAC;QACX,eAAe,CAAC,EAAE,OAAO,CAAC;KAC3B,CAAC;CACH;AAYD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAC9B,kBAAkB,CAAC,CAAC,CAAC,CA8MvB"}

package/dist/focus/index.d.ts

@@ -0,0 +1,5 @@
+export { FocusScope, useFocusManager, type FocusScopeProps, type FocusManager, type FocusManagerOptions, } from './FocusScope';
+export { createFocusRestore, pushFocusStack, popFocusStack, getFocusStackLength, clearFocusStack, type FocusRestoreOptions, type FocusRestoreResult, } from './createFocusRestore';
+export { createVirtualFocus, type VirtualFocusOptions, type VirtualFocusResult, } from './createVirtualFocus';
+export { createAutoFocus, clearAutoFocusQueue, getAutoFocusQueueLength, type AutoFocusOptions, type AutoFocusResult, } from './createAutoFocus';
+//# sourceMappingURL=index.d.ts.map

package/dist/focus/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/focus/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,UAAU,EACV,eAAe,EACf,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,mBAAmB,GACzB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,aAAa,EACb,mBAAmB,EACnB,eAAe,EACf,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,GACxB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EACL,kBAAkB,EAClB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,GACxB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,uBAAuB,EACvB,KAAK,gBAAgB,EACrB,KAAK,eAAe,GACrB,MAAM,mBAAmB,CAAC"}

package/dist/form/createFormReset.d.ts

@@ -0,0 +1,27 @@
+/**
+ * createFormReset - Handles form reset events for form fields.
+ *
+ * Resets the field value to its default when the containing form is reset.
+ * Port of @react-aria/utils useFormReset.
+ */
+import { type Accessor } from 'solid-js';
+export interface FormResetOptions<T> {
+    /** The default value to reset to. */
+    defaultValue: T;
+    /** Function to set the current value. */
+    onReset: (value: T) => void;
+}
+/**
+ * Listens for form reset events and resets the field value to its default.
+ *
+ * @example
+ * ```tsx
+ * createFormReset(
+ *   () => inputRef,
+ *   { label: 'Default' },
+ *   (value) => state.setSelectedKey(value.key)
+ * );
+ * ```
+ */
+export declare function createFormReset<T>(ref: Accessor<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement | undefined>, defaultValue: T, onReset: (value: T) => void): void;
+//# sourceMappingURL=createFormReset.d.ts.map

package/dist/form/createFormReset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFormReset.d.ts","sourceRoot":"","sources":["../../src/form/createFormReset.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,KAAK,QAAQ,EAA2B,MAAM,UAAU,CAAC;AAElE,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,qCAAqC;IACrC,YAAY,EAAE,CAAC,CAAC;IAChB,yCAAyC;IACzC,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;CAC7B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,GAAG,EAAE,QAAQ,CAAC,gBAAgB,GAAG,iBAAiB,GAAG,mBAAmB,GAAG,SAAS,CAAC,EACrF,YAAY,EAAE,CAAC,EACf,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAC1B,IAAI,CAkBN"}