@proyecto-viviana/solidaria 0.1.0 → 0.1.2

package/dist/interactions/FocusableProvider.d.ts

@@ -0,0 +1,26 @@
+/**
+ * FocusableProvider - Provides DOM props to the nearest focusable child.
+ *
+ * This is a 1-1 port of React-Aria's FocusableProvider adapted for SolidJS.
+ */
+import { JSX, ParentComponent } from 'solid-js';
+import { FocusableProviderProps } from './createFocusable';
+/**
+ * Provides DOM props to the nearest focusable child.
+ * Used to pass focus-related props through component boundaries.
+ *
+ * @example
+ * ```tsx
+ * import { FocusableProvider } from 'solidaria';
+ *
+ * function MyComponent() {
+ *   return (
+ *     <FocusableProvider onFocus={() => console.log('focused!')}>
+ *       <NestedFocusableComponent />
+ *     </FocusableProvider>
+ *   );
+ * }
+ * ```
+ */
+export declare const FocusableProvider: ParentComponent<FocusableProviderProps & JSX.HTMLAttributes<HTMLElement>>;
+//# sourceMappingURL=FocusableProvider.d.ts.map

package/dist/interactions/FocusableProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FocusableProvider.d.ts","sourceRoot":"","sources":["../../src/interactions/FocusableProvider.tsx"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,GAAG,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EAA2C,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAEpG;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iBAAiB,EAAE,eAAe,CAC7C,sBAAsB,GAAG,GAAG,CAAC,cAAc,CAAC,WAAW,CAAC,CAgBzD,CAAC"}

package/dist/interactions/PressEvent.d.ts

@@ -0,0 +1,73 @@
+/**
+ * PressEvent class that matches React-Aria's PressEvent interface.
+ * Wraps native events with press-specific data.
+ */
+export type PointerType = 'mouse' | 'pen' | 'touch' | 'keyboard' | 'virtual';
+export type PressEventType = 'pressstart' | 'pressend' | 'pressup' | 'press';
+/** Base event properties needed for press event creation */
+export interface BaseEventForPress {
+    currentTarget: EventTarget | null;
+    shiftKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+    clientX?: number;
+    clientY?: number;
+}
+export interface IPressEvent {
+    /** The type of press event being fired. */
+    type: PressEventType;
+    /** The pointer type that triggered the press event. */
+    pointerType: PointerType;
+    /** The target element of the press event. */
+    target: Element;
+    /** Whether the shift keyboard modifier was held during the press event. */
+    shiftKey: boolean;
+    /** Whether the ctrl keyboard modifier was held during the press event. */
+    ctrlKey: boolean;
+    /** Whether the meta keyboard modifier was held during the press event. */
+    metaKey: boolean;
+    /** Whether the alt keyboard modifier was held during the press event. */
+    altKey: boolean;
+    /** X position of the press relative to the target element. */
+    x: number;
+    /** Y position of the press relative to the target element. */
+    y: number;
+    /**
+     * By default, press events stop propagation to parent elements.
+     * Call continuePropagation() to allow the event to bubble up.
+     */
+    continuePropagation(): void;
+}
+/**
+ * PressEvent class that provides all press event data.
+ * Based on React-Aria's PressEvent implementation.
+ */
+export declare class PressEvent implements IPressEvent {
+    #private;
+    type: PressEventType;
+    pointerType: PointerType;
+    target: Element;
+    shiftKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+    x: number;
+    y: number;
+    constructor(type: PressEventType, pointerType: PointerType, originalEvent: Event | null, target: Element | null);
+    /**
+     * Call this to allow the press event to propagate to parent elements.
+     * By default, press events stop propagation.
+     */
+    continuePropagation(): void;
+    /**
+     * Whether the event should stop propagation.
+     * Used internally by the press handler.
+     */
+    get shouldStopPropagation(): boolean;
+}
+/**
+ * Creates a PressEvent from a native event.
+ */
+export declare function createPressEvent(type: PressEventType, pointerType: PointerType, originalEvent: BaseEventForPress | Event | null, target: Element | null): PressEvent;
+//# sourceMappingURL=PressEvent.d.ts.map

package/dist/interactions/PressEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PressEvent.d.ts","sourceRoot":"","sources":["../../src/interactions/PressEvent.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,KAAK,GAAG,OAAO,GAAG,UAAU,GAAG,SAAS,CAAC;AAC7E,MAAM,MAAM,cAAc,GAAG,YAAY,GAAG,UAAU,GAAG,SAAS,GAAG,OAAO,CAAC;AAE7E,4DAA4D;AAC5D,MAAM,WAAW,iBAAiB;IAChC,aAAa,EAAE,WAAW,GAAG,IAAI,CAAC;IAClC,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,2CAA2C;IAC3C,IAAI,EAAE,cAAc,CAAC;IACrB,uDAAuD;IACvD,WAAW,EAAE,WAAW,CAAC;IACzB,6CAA6C;IAC7C,MAAM,EAAE,OAAO,CAAC;IAChB,2EAA2E;IAC3E,QAAQ,EAAE,OAAO,CAAC;IAClB,0EAA0E;IAC1E,OAAO,EAAE,OAAO,CAAC;IACjB,0EAA0E;IAC1E,OAAO,EAAE,OAAO,CAAC;IACjB,yEAAyE;IACzE,MAAM,EAAE,OAAO,CAAC;IAChB,8DAA8D;IAC9D,CAAC,EAAE,MAAM,CAAC;IACV,8DAA8D;IAC9D,CAAC,EAAE,MAAM,CAAC;IACV;;;OAGG;IACH,mBAAmB,IAAI,IAAI,CAAC;CAC7B;AAED;;;GAGG;AACH,qBAAa,UAAW,YAAW,WAAW;;IAC5C,IAAI,EAAE,cAAc,CAAC;IACrB,WAAW,EAAE,WAAW,CAAC;IACzB,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;gBAKR,IAAI,EAAE,cAAc,EACpB,WAAW,EAAE,WAAW,EACxB,aAAa,EAAE,KAAK,GAAG,IAAI,EAC3B,MAAM,EAAE,OAAO,GAAG,IAAI;IA8BxB;;;OAGG;IACH,mBAAmB,IAAI,IAAI;IAI3B;;;OAGG;IACH,IAAI,qBAAqB,IAAI,OAAO,CAEnC;CACF;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,cAAc,EACpB,WAAW,EAAE,WAAW,EACxB,aAAa,EAAE,iBAAiB,GAAG,KAAK,GAAG,IAAI,EAC/C,MAAM,EAAE,OAAO,GAAG,IAAI,GACrB,UAAU,CAEZ"}

package/dist/interactions/createFocus.d.ts

@@ -0,0 +1,31 @@
+/**
+ * createFocus - Handles focus events for the immediate target.
+ *
+ * This is a 1-1 port of React-Aria's useFocus hook adapted for SolidJS.
+ * Focus events on child elements will be ignored.
+ */
+import { JSX } from 'solid-js';
+export interface FocusEvents {
+    /** Handler that is called when the element receives focus. */
+    onFocus?: (e: FocusEvent) => void;
+    /** Handler that is called when the element loses focus. */
+    onBlur?: (e: FocusEvent) => void;
+    /** Handler that is called when the element's focus status changes. */
+    onFocusChange?: (isFocused: boolean) => void;
+}
+export interface CreateFocusProps extends FocusEvents {
+    /** Whether the focus events should be disabled. */
+    isDisabled?: boolean;
+}
+export interface FocusResult {
+    /** Props to spread onto the target element. */
+    focusProps: JSX.HTMLAttributes<HTMLElement>;
+}
+/**
+ * Handles focus events for the immediate target.
+ * Focus events on child elements will be ignored.
+ *
+ * Based on react-aria's useFocus but adapted for SolidJS.
+ */
+export declare function createFocus(props?: CreateFocusProps): FocusResult;
+//# sourceMappingURL=createFocus.d.ts.map

package/dist/interactions/createFocus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFocus.d.ts","sourceRoot":"","sources":["../../src/interactions/createFocus.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,GAAG,EAAa,MAAM,UAAU,CAAC;AAU1C,MAAM,WAAW,WAAW;IAC1B,8DAA8D;IAC9D,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,IAAI,CAAC;IAClC,2DAA2D;IAC3D,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,IAAI,CAAC;IACjC,sEAAsE;IACtE,aAAa,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;CAC9C;AAED,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACnD,mDAAmD;IACnD,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,WAAW;IAC1B,+CAA+C;IAC/C,UAAU,EAAE,GAAG,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;CAC7C;AA0DD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,GAAE,gBAAqB,GAAG,WAAW,CAgErE"}

package/dist/interactions/createFocusRing.d.ts

@@ -0,0 +1,37 @@
+/**
+ * createFocusRing hook for Solidaria
+ *
+ * Determines whether a focus ring should be visible for a given element.
+ * Focus rings are visible when the user navigates with keyboard, but hidden
+ * when using mouse/touch.
+ *
+ * Port of @react-aria/focus useFocusRing.
+ */
+import { type JSX, type Accessor } from 'solid-js';
+export interface FocusRingProps {
+    /** Whether the element is a text input. */
+    isTextInput?: boolean;
+    /** Whether the element will be auto focused. */
+    autoFocus?: boolean;
+    /** Whether focus should be tracked within the element. */
+    within?: boolean;
+}
+export interface FocusRingResult {
+    /** Whether the element is currently focused. */
+    isFocused: Accessor<boolean>;
+    /** Whether the focus ring should be visible. */
+    isFocusVisible: Accessor<boolean>;
+    /** Props to spread on the element to track focus. */
+    focusProps: JSX.HTMLAttributes<HTMLElement>;
+}
+/**
+ * Determines whether a focus ring should be visible for a given element.
+ *
+ * Focus rings are visible when:
+ * - The element is focused AND
+ * - The user is navigating with keyboard (not mouse/touch)
+ *
+ * For text inputs, focus rings are always visible when focused.
+ */
+export declare function createFocusRing(props?: FocusRingProps): FocusRingResult;
+//# sourceMappingURL=createFocusRing.d.ts.map

package/dist/interactions/createFocusRing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFocusRing.d.ts","sourceRoot":"","sources":["../../src/interactions/createFocusRing.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,KAAK,GAAG,EAAE,KAAK,QAAQ,EAAqD,MAAM,UAAU,CAAC;AAYtG,MAAM,WAAW,cAAc;IAC7B,2CAA2C;IAC3C,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,gDAAgD;IAChD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,0DAA0D;IAC1D,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,gDAAgD;IAChD,SAAS,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC7B,gDAAgD;IAChD,cAAc,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;IAClC,qDAAqD;IACrD,UAAU,EAAE,GAAG,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;CAC7C;AAMD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,KAAK,GAAE,cAAmB,GAAG,eAAe,CAmC3E"}

package/dist/interactions/createFocusWithin.d.ts

@@ -0,0 +1,27 @@
+/**
+ * createFocusWithin - Handles focus events for the target and its descendants.
+ *
+ * This is a 1-1 port of React-Aria's useFocusWithin hook adapted for SolidJS.
+ */
+import { JSX } from 'solid-js';
+export interface FocusWithinProps {
+    /** Whether the focus within events should be disabled. */
+    isDisabled?: boolean;
+    /** Handler that is called when the target element or a descendant receives focus. */
+    onFocusWithin?: (e: FocusEvent) => void;
+    /** Handler that is called when the target element and all descendants lose focus. */
+    onBlurWithin?: (e: FocusEvent) => void;
+    /** Handler that is called when the focus within state changes. */
+    onFocusWithinChange?: (isFocusWithin: boolean) => void;
+}
+export interface FocusWithinResult {
+    /** Props to spread onto the target element. */
+    focusWithinProps: JSX.HTMLAttributes<HTMLElement>;
+}
+/**
+ * Handles focus events for the target and its descendants.
+ *
+ * Based on react-aria's useFocusWithin but adapted for SolidJS.
+ */
+export declare function createFocusWithin(props?: FocusWithinProps): FocusWithinResult;
+//# sourceMappingURL=createFocusWithin.d.ts.map

package/dist/interactions/createFocusWithin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFocusWithin.d.ts","sourceRoot":"","sources":["../../src/interactions/createFocusWithin.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,GAAG,EAAa,MAAM,UAAU,CAAC;AAI1C,MAAM,WAAW,gBAAgB;IAC/B,0DAA0D;IAC1D,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,qFAAqF;IACrF,aAAa,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,IAAI,CAAC;IACxC,qFAAqF;IACrF,YAAY,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,IAAI,CAAC;IACvC,kEAAkE;IAClE,mBAAmB,CAAC,EAAE,CAAC,aAAa,EAAE,OAAO,KAAK,IAAI,CAAC;CACxD;AAED,MAAM,WAAW,iBAAiB;IAChC,+CAA+C;IAC/C,gBAAgB,EAAE,GAAG,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;CACnD;AA2DD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,GAAE,gBAAqB,GAAG,iBAAiB,CAqHjF"}

package/dist/interactions/createFocusable.d.ts

@@ -0,0 +1,65 @@
+/**
+ * createFocusable - Makes an element focusable and capable of auto focus.
+ *
+ * This is a 1-1 port of React-Aria's useFocusable hook adapted for SolidJS.
+ */
+import { JSX, Accessor } from 'solid-js';
+import { type FocusEvents } from './createFocus';
+import { type KeyboardEvents } from './createKeyboard';
+export interface FocusableDOMProps {
+    /** Whether to exclude the element from the sequential tab order. */
+    excludeFromTabOrder?: boolean;
+}
+export interface FocusableProps extends FocusEvents, KeyboardEvents {
+    /** Whether the element should receive focus on mount. */
+    autoFocus?: boolean;
+}
+export interface CreateFocusableProps extends FocusableProps, FocusableDOMProps {
+    /** Whether focus should be disabled. */
+    isDisabled?: Accessor<boolean> | boolean;
+}
+export interface FocusableResult {
+    /** Props to spread on the focusable element. */
+    focusableProps: JSX.HTMLAttributes<HTMLElement>;
+}
+export interface FocusableContextValue {
+    ref?: (el: HTMLElement) => void;
+    [key: string]: unknown;
+}
+/**
+ * Context for passing focusable props to nested focusable children.
+ * Used by FocusableProvider to pass DOM props to the nearest focusable child.
+ */
+export declare const FocusableContext: import("solid-js").Context<FocusableContextValue | null>;
+export interface FocusableProviderProps {
+    /** The child element to provide DOM props to. */
+    children?: JSX.Element;
+}
+/**
+ * Makes an element focusable, handling disabled state and tab order.
+ * Provides focus state tracking and autoFocus support.
+ *
+ * Based on react-aria's useFocusable but adapted for SolidJS.
+ *
+ * @example
+ * ```tsx
+ * import { createFocusable } from 'solidaria';
+ *
+ * function FocusableInput(props) {
+ *   let ref;
+ *   const { focusableProps } = createFocusable({
+ *     autoFocus: props.autoFocus,
+ *     onFocusChange: (focused) => console.log('Focus:', focused),
+ *   });
+ *
+ *   return (
+ *     <input
+ *       {...focusableProps}
+ *       ref={(el) => { ref = el; focusableProps.ref?.(el); }}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+export declare function createFocusable(props?: CreateFocusableProps, ref?: (el: HTMLElement) => void): FocusableResult;
+//# sourceMappingURL=createFocusable.d.ts.map

package/dist/interactions/createFocusable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFocusable.d.ts","sourceRoot":"","sources":["../../src/interactions/createFocusable.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAsC,MAAM,UAAU,CAAC;AAC7E,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGvE,MAAM,WAAW,iBAAiB;IAChC,oEAAoE;IACpE,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,MAAM,WAAW,cAAe,SAAQ,WAAW,EAAE,cAAc;IACjE,yDAAyD;IACzD,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,oBAAqB,SAAQ,cAAc,EAAE,iBAAiB;IAC7E,wCAAwC;IACxC,UAAU,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;CAC1C;AAED,MAAM,WAAW,eAAe;IAC9B,gDAAgD;IAChD,cAAc,EAAE,GAAG,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;CACjD;AAID,MAAM,WAAW,qBAAqB;IACpC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,IAAI,CAAC;IAChC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,0DAAoD,CAAC;AA0BlF,MAAM,WAAW,sBAAsB;IACrC,iDAAiD;IACjD,QAAQ,CAAC,EAAE,GAAG,CAAC,OAAO,CAAC;CACxB;AASD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,eAAe,CAC7B,KAAK,GAAE,oBAAyB,EAChC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,IAAI,GAC9B,eAAe,CA0DjB"}

package/dist/interactions/createHover.d.ts

@@ -0,0 +1,43 @@
+/**
+ * createHover hook for Solidaria
+ *
+ * Handles pointer hover interactions for an element. Normalizes behavior
+ * across browsers and platforms, and ignores emulated mouse events on touch devices.
+ *
+ * Port of @react-aria/interactions useHover.
+ */
+import { type JSX, type Accessor } from 'solid-js';
+import { type MaybeAccessor } from '../utils/reactivity';
+export interface HoverEvent {
+    /** The type of hover event being fired. */
+    type: 'hoverstart' | 'hoverend';
+    /** The pointer type that triggered the hover event. */
+    pointerType: 'mouse' | 'pen';
+    /** The target element of the hover event. */
+    target: Element;
+}
+export interface HoverEvents {
+    /** Handler called when the hover starts. */
+    onHoverStart?: (e: HoverEvent) => void;
+    /** Handler called when the hover ends. */
+    onHoverEnd?: (e: HoverEvent) => void;
+    /** Handler called when the hover state changes. */
+    onHoverChange?: (isHovering: boolean) => void;
+}
+export interface CreateHoverProps extends HoverEvents {
+    /** Whether the hover events should be disabled. */
+    isDisabled?: boolean;
+}
+/** Event handler props returned by createHover - safe to spread on any element */
+export type HoverProps = Pick<JSX.HTMLAttributes<HTMLElement>, 'onPointerEnter' | 'onPointerLeave' | 'onPointerOver' | 'onPointerOut' | 'onMouseEnter' | 'onMouseLeave'>;
+export interface HoverResult {
+    /** Props to spread on the target element. */
+    hoverProps: HoverProps;
+    /** Whether the element is currently hovered. */
+    isHovered: Accessor<boolean>;
+}
+/**
+ * Handles pointer hover interactions for an element.
+ */
+export declare function createHover(props?: MaybeAccessor<CreateHoverProps>): HoverResult;
+//# sourceMappingURL=createHover.d.ts.map

package/dist/interactions/createHover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createHover.d.ts","sourceRoot":"","sources":["../../src/interactions/createHover.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,KAAK,GAAG,EAAE,KAAK,QAAQ,EAAqD,MAAM,UAAU,CAAC;AACtG,OAAO,EAAE,KAAK,aAAa,EAAU,MAAM,qBAAqB,CAAC;AAQjE,MAAM,WAAW,UAAU;IACzB,2CAA2C;IAC3C,IAAI,EAAE,YAAY,GAAG,UAAU,CAAC;IAChC,uDAAuD;IACvD,WAAW,EAAE,OAAO,GAAG,KAAK,CAAC;IAC7B,6CAA6C;IAC7C,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,4CAA4C;IAC5C,YAAY,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,IAAI,CAAC;IACvC,0CAA0C;IAC1C,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,IAAI,CAAC;IACrC,mDAAmD;IACnD,aAAa,CAAC,EAAE,CAAC,UAAU,EAAE,OAAO,KAAK,IAAI,CAAC;CAC/C;AAED,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACnD,mDAAmD;IACnD,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,kFAAkF;AAClF,MAAM,MAAM,UAAU,GAAG,IAAI,CAC3B,GAAG,CAAC,cAAc,CAAC,WAAW,CAAC,EAC7B,gBAAgB,GAChB,gBAAgB,GAChB,eAAe,GACf,cAAc,GACd,cAAc,GACd,cAAc,CACjB,CAAC;AAEF,MAAM,WAAW,WAAW;IAC1B,6CAA6C;IAC7C,UAAU,EAAE,UAAU,CAAC;IACvB,gDAAgD;IAChD,SAAS,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;CAC9B;AAwDD;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,GAAE,aAAa,CAAC,gBAAgB,CAAM,GAAG,WAAW,CAyIpF"}

package/dist/interactions/createInteractionModality.d.ts

@@ -0,0 +1,73 @@
+/**
+ * createInteractionModality + focus-visible tracking for solidaria
+ *
+ * Port of @react-aria/interactions useFocusVisible/useInteractionModality.
+ * Tracks the current interaction modality (keyboard, pointer, or virtual) and
+ * provides focus-visible state and listeners.
+ */
+import { type Accessor } from 'solid-js';
+export type Modality = 'keyboard' | 'pointer' | 'virtual';
+export type PointerType = 'mouse' | 'pen' | 'touch' | 'keyboard' | 'virtual';
+export type FocusVisibleHandler = (isFocusVisible: boolean) => void;
+export interface FocusVisibleProps {
+    /** Whether the element is a text input. */
+    isTextInput?: boolean;
+    /** Whether the element will be auto focused. */
+    autoFocus?: boolean;
+}
+export interface FocusVisibleResult {
+    /** Whether keyboard focus is visible globally. */
+    isFocusVisible: Accessor<boolean>;
+}
+export interface InteractionModalityResult {
+    /** The current interaction modality. */
+    modality: Accessor<Modality | null>;
+}
+export declare let hasSetupGlobalListeners: Map<Window, {
+    focus: typeof window.HTMLElement.prototype.focus;
+    canOverride: boolean;
+}>;
+/**
+ * Adds a window (i.e. iframe) to the list of windows that are being tracked for focus visible.
+ */
+export declare function addWindowFocusTracking(element?: HTMLElement | null): () => void;
+export declare function setupGlobalFocusListeners(): void;
+/**
+ * If true, keyboard focus is visible.
+ */
+export declare function isFocusVisible(): boolean;
+/**
+ * Gets the current interaction modality.
+ */
+export declare function getInteractionModality(): Modality | null;
+/**
+ * Sets the current interaction modality.
+ */
+export declare function setInteractionModality(modality: Modality): void;
+/**
+ * Gets the current pointer type.
+ */
+export declare function getPointerType(): PointerType;
+/**
+ * Listens for trigger change and reports if focus is visible.
+ */
+export declare function createFocusVisibleListener(handler: FocusVisibleHandler, opts?: {
+    isTextInput?: boolean;
+}): () => void;
+/**
+ * Manages focus visible state for the page.
+ */
+export declare function createFocusVisible(props?: FocusVisibleProps): FocusVisibleResult;
+/**
+ * Tracks the current interaction modality.
+ */
+export declare function createInteractionModality(): InteractionModalityResult;
+/**
+ * Adds a listener for modality changes.
+ */
+export declare function addModalityListener(handler: (modality: Modality) => void): () => void;
+/**
+ * Hook to track whether the user is currently interacting with the keyboard.
+ */
+export declare function useIsKeyboardFocused(): Accessor<boolean>;
+//# sourceMappingURL=createInteractionModality.d.ts.map

package/dist/interactions/createInteractionModality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createInteractionModality.d.ts","sourceRoot":"","sources":["../../src/interactions/createInteractionModality.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,KAAK,QAAQ,EAAyC,MAAM,UAAU,CAAC;AAQhF,MAAM,MAAM,QAAQ,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,CAAC;AAC1D,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,KAAK,GAAG,OAAO,GAAG,UAAU,GAAG,SAAS,CAAC;AAI7E,MAAM,MAAM,mBAAmB,GAAG,CAAC,cAAc,EAAE,OAAO,KAAK,IAAI,CAAC;AAEpE,MAAM,WAAW,iBAAiB;IAChC,2CAA2C;IAC3C,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,gDAAgD;IAChD,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,kBAAkB;IACjC,kDAAkD;IAClD,cAAc,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,yBAAyB;IACxC,wCAAwC;IACxC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAC;CACrC;AAUD,eAAO,IAAI,uBAAuB,EAAE,GAAG,CACrC,MAAM,EACN;IAAE,KAAK,EAAE,OAAO,MAAM,CAAC,WAAW,CAAC,SAAS,CAAC,KAAK,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CAC/D,CAAC;AAoLd;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,GAAG,MAAM,IAAI,CAc/E;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CAEhD;AAMD;;GAEG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAExC;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,QAAQ,GAAG,IAAI,CAExD;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAI/D;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,WAAW,CAE5C;AA+CD;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,mBAAmB,EAC5B,IAAI,CAAC,EAAE;IAAE,WAAW,CAAC,EAAE,OAAO,CAAA;CAAE,GAC/B,MAAM,IAAI,CAYZ;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,GAAE,iBAAsB,GAAG,kBAAkB,CAcpF;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,yBAAyB,CAuBrE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,GAAG,MAAM,IAAI,CAQrF;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,QAAQ,CAAC,OAAO,CAAC,CAOxD"}

package/dist/interactions/createKeyboard.d.ts

@@ -0,0 +1,35 @@
+/**
+ * createKeyboard - Handles keyboard interactions for a focusable element.
+ *
+ * This is a 1-1 port of React-Aria's useKeyboard hook adapted for SolidJS.
+ */
+import { JSX } from 'solid-js';
+/**
+ * Keyboard event with continuePropagation support.
+ * By default, keyboard events stop propagation.
+ */
+export interface KeyboardEvent extends globalThis.KeyboardEvent {
+    /** Call this to allow the event to propagate to parent elements. */
+    continuePropagation(): void;
+}
+export interface KeyboardEvents {
+    /** Handler that is called when a key is pressed. */
+    onKeyDown?: (e: KeyboardEvent) => void;
+    /** Handler that is called when a key is released. */
+    onKeyUp?: (e: KeyboardEvent) => void;
+}
+export interface CreateKeyboardProps extends KeyboardEvents {
+    /** Whether the keyboard events should be disabled. */
+    isDisabled?: boolean;
+}
+export interface KeyboardResult {
+    /** Props to spread onto the target element. */
+    keyboardProps: JSX.HTMLAttributes<HTMLElement>;
+}
+/**
+ * Handles keyboard interactions for a focusable element.
+ *
+ * Based on react-aria's useKeyboard but adapted for SolidJS.
+ */
+export declare function createKeyboard(props?: CreateKeyboardProps): KeyboardResult;
+//# sourceMappingURL=createKeyboard.d.ts.map

package/dist/interactions/createKeyboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createKeyboard.d.ts","sourceRoot":"","sources":["../../src/interactions/createKeyboard.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAE/B;;;GAGG;AACH,MAAM,WAAW,aAAc,SAAQ,UAAU,CAAC,aAAa;IAC7D,oEAAoE;IACpE,mBAAmB,IAAI,IAAI,CAAC;CAC7B;AAED,MAAM,WAAW,cAAc;IAC7B,oDAAoD;IACpD,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,aAAa,KAAK,IAAI,CAAC;IACvC,qDAAqD;IACrD,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,aAAa,KAAK,IAAI,CAAC;CACtC;AAED,MAAM,WAAW,mBAAoB,SAAQ,cAAc;IACzD,sDAAsD;IACtD,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,cAAc;IAC7B,+CAA+C;IAC/C,aAAa,EAAE,GAAG,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;CAChD;AA+BD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,GAAE,mBAAwB,GAAG,cAAc,CAa9E"}

package/dist/interactions/createLongPress.d.ts

@@ -0,0 +1,63 @@
+/**
+ * createLongPress - Handles long press interactions across mouse and touch.
+ *
+ * Port of @react-aria/interactions useLongPress, adapted for SolidJS.
+ */
+import { JSX } from 'solid-js';
+import { type PressEvent } from './createPress';
+import { type MaybeAccessor } from '../utils/reactivity';
+export interface LongPressEvent {
+    /** The type of long press event being fired. */
+    type: 'longpressstart' | 'longpressend' | 'longpress';
+    /** The pointer type that triggered the long press. */
+    pointerType: PressEvent['pointerType'];
+    /** The target element of the long press event. */
+    target: Element;
+    /** Whether the shift keyboard modifier was held during the long press event. */
+    shiftKey: boolean;
+    /** Whether the ctrl keyboard modifier was held during the long press event. */
+    ctrlKey: boolean;
+    /** Whether the meta keyboard modifier was held during the long press event. */
+    metaKey: boolean;
+    /** Whether the alt keyboard modifier was held during the long press event. */
+    altKey: boolean;
+    /** X position relative to the target. */
+    x: number;
+    /** Y position relative to the target. */
+    y: number;
+}
+export interface LongPressProps {
+    /** Whether long press events should be disabled. */
+    isDisabled?: MaybeAccessor<boolean>;
+    /** Handler that is called when a long press interaction starts. */
+    onLongPressStart?: (e: LongPressEvent) => void;
+    /**
+     * Handler that is called when a long press interaction ends, either
+     * over the target or when the pointer leaves the target.
+     */
+    onLongPressEnd?: (e: LongPressEvent) => void;
+    /**
+     * Handler that is called when the threshold time is met while
+     * the press is over the target.
+     */
+    onLongPress?: (e: LongPressEvent) => void;
+    /**
+     * The amount of time in milliseconds to wait before triggering a long press.
+     * @default 500ms
+     */
+    threshold?: number;
+    /**
+     * A description for assistive technology users indicating that a long press
+     * action is available, e.g. "Long press to open menu".
+     */
+    accessibilityDescription?: string;
+}
+export interface LongPressResult {
+    /** Props to spread on the target element. */
+    longPressProps: JSX.HTMLAttributes<HTMLElement>;
+}
+/**
+ * Handles long press interactions across mouse and touch devices.
+ */
+export declare function createLongPress(props?: LongPressProps): LongPressResult;
+//# sourceMappingURL=createLongPress.d.ts.map

package/dist/interactions/createLongPress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createLongPress.d.ts","sourceRoot":"","sources":["../../src/interactions/createLongPress.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,GAAG,EAAa,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAG7D,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,MAAM,WAAW,cAAc;IAC7B,gDAAgD;IAChD,IAAI,EAAE,gBAAgB,GAAG,cAAc,GAAG,WAAW,CAAC;IACtD,sDAAsD;IACtD,WAAW,EAAE,UAAU,CAAC,aAAa,CAAC,CAAC;IACvC,kDAAkD;IAClD,MAAM,EAAE,OAAO,CAAC;IAChB,gFAAgF;IAChF,QAAQ,EAAE,OAAO,CAAC;IAClB,+EAA+E;IAC/E,OAAO,EAAE,OAAO,CAAC;IACjB,+EAA+E;IAC/E,OAAO,EAAE,OAAO,CAAC;IACjB,8EAA8E;IAC9E,MAAM,EAAE,OAAO,CAAC;IAChB,yCAAyC;IACzC,CAAC,EAAE,MAAM,CAAC;IACV,yCAAyC;IACzC,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,cAAc;IAC7B,oDAAoD;IACpD,UAAU,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IACpC,mEAAmE;IACnE,gBAAgB,CAAC,EAAE,CAAC,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IAC/C;;;OAGG;IACH,cAAc,CAAC,EAAE,CAAC,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IAC7C;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IAC1C;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,wBAAwB,CAAC,EAAE,MAAM,CAAC;CACnC;AAED,MAAM,WAAW,eAAe;IAC9B,6CAA6C;IAC7C,cAAc,EAAE,GAAG,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;CACjD;AAsBD;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,GAAE,cAAmB,GAAG,eAAe,CAqF3E"}

package/dist/interactions/createMove.d.ts

@@ -0,0 +1,40 @@
+/**
+ * createMove - Handles move interactions across mouse, touch, pointer, and keyboard.
+ *
+ * Port of @react-aria/interactions useMove, adapted for SolidJS.
+ */
+import { JSX } from 'solid-js';
+export type PointerType = 'mouse' | 'pen' | 'touch' | 'keyboard';
+interface BaseMoveEvent {
+    pointerType: PointerType;
+    shiftKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+}
+export interface MoveStartEvent extends BaseMoveEvent {
+    type: 'movestart';
+}
+export interface MoveMoveEvent extends BaseMoveEvent {
+    type: 'move';
+    deltaX: number;
+    deltaY: number;
+}
+export interface MoveEndEvent extends BaseMoveEvent {
+    type: 'moveend';
+}
+export interface MoveEvents {
+    onMoveStart?: (e: MoveStartEvent) => void;
+    onMove?: (e: MoveMoveEvent) => void;
+    onMoveEnd?: (e: MoveEndEvent) => void;
+}
+export interface MoveResult {
+    /** Props to spread on the target element. */
+    moveProps: JSX.HTMLAttributes<HTMLElement>;
+}
+/**
+ * Handles move interactions across mouse, touch, pointer, and keyboard.
+ */
+export declare function createMove(props?: MoveEvents): MoveResult;
+export {};
+//# sourceMappingURL=createMove.d.ts.map

package/dist/interactions/createMove.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMove.d.ts","sourceRoot":"","sources":["../../src/interactions/createMove.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,GAAG,EAAyC,MAAM,UAAU,CAAC;AAGtE,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,KAAK,GAAG,OAAO,GAAG,UAAU,CAAC;AAEjE,UAAU,aAAa;IACrB,WAAW,EAAE,WAAW,CAAC;IACzB,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,cAAe,SAAQ,aAAa;IACnD,IAAI,EAAE,WAAW,CAAC;CACnB;AAED,MAAM,WAAW,aAAc,SAAQ,aAAa;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,YAAa,SAAQ,aAAa;IACjD,IAAI,EAAE,SAAS,CAAC;CACjB;AAED,MAAM,WAAW,UAAU;IACzB,WAAW,CAAC,EAAE,CAAC,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IAC1C,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,aAAa,KAAK,IAAI,CAAC;IACpC,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,IAAI,CAAC;CACvC;AAED,MAAM,WAAW,UAAU;IACzB,6CAA6C;IAC7C,SAAS,EAAE,GAAG,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;CAC5C;AAqBD;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,GAAE,UAAe,GAAG,UAAU,CA8N7D"}

package/dist/interactions/createPress.d.ts

@@ -0,0 +1,55 @@
+/**
+ * createPress - Handles press interactions across mouse, touch, keyboard, and virtual clicks.
+ *
+ * This is a 1-1 port of React-Aria's usePress hook adapted for SolidJS.
+ * All behaviors, edge cases, and platform-specific handling are preserved.
+ */
+import { JSX, Accessor } from 'solid-js';
+import { PressEvent } from './PressEvent';
+export { PressEvent, type PointerType } from './PressEvent';
+export type { IPressEvent, PressEventType } from './PressEvent';
+export interface CreatePressProps {
+    /** Whether the target is currently disabled. */
+    isDisabled?: Accessor<boolean> | boolean;
+    /** Handler called when the press is released over the target. */
+    onPress?: (e: PressEvent) => void;
+    /** Handler called when a press interaction starts. */
+    onPressStart?: (e: PressEvent) => void;
+    /**
+     * Handler called when a press interaction ends, either
+     * over the target or when the pointer leaves the target.
+     */
+    onPressEnd?: (e: PressEvent) => void;
+    /** Handler called when a press is released over the target, regardless of whether it started on the target. */
+    onPressUp?: (e: PressEvent) => void;
+    /** Handler called when the press state changes. */
+    onPressChange?: (isPressed: boolean) => void;
+    /**
+     * Handler called on native click event.
+     * Some third-party libraries pass onClick instead of onPress.
+     * This matches the browser's native activation behavior for certain elements.
+     */
+    onClick?: (e: MouseEvent) => void;
+    /** Whether the press should be visual only, not triggering onPress. */
+    isPressed?: Accessor<boolean> | boolean;
+    /** Whether to prevent focus when pressing. */
+    preventFocusOnPress?: boolean;
+    /** Whether long press should cancel when pointer moves out of target. */
+    shouldCancelOnPointerExit?: boolean;
+    /** Whether text selection should be allowed during press. */
+    allowTextSelectionOnPress?: boolean;
+}
+export interface PressResult {
+    /** Whether the target is currently pressed. */
+    isPressed: Accessor<boolean>;
+    /** Props to spread on the target element. */
+    pressProps: JSX.HTMLAttributes<HTMLElement>;
+}
+/**
+ * Handles press interactions across mouse, touch, keyboard, and screen readers.
+ * Provides consistent press behavior regardless of input method.
+ *
+ * Based on react-aria's usePress but adapted for SolidJS.
+ */
+export declare function createPress(props?: CreatePressProps): PressResult;
+//# sourceMappingURL=createPress.d.ts.map

package/dist/interactions/createPress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPress.d.ts","sourceRoot":"","sources":["../../src/interactions/createPress.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAgB,GAAG,EAAE,QAAQ,EAAa,MAAM,UAAU,CAAC;AAClE,OAAO,EAAE,UAAU,EAAoD,MAAM,cAAc,CAAC;AAsB5F,OAAO,EAAE,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAC5D,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEhE,MAAM,WAAW,gBAAgB;IAC/B,gDAAgD;IAChD,UAAU,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IACzC,iEAAiE;IACjE,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,IAAI,CAAC;IAClC,sDAAsD;IACtD,YAAY,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,IAAI,CAAC;IACvC;;;OAGG;IACH,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,IAAI,CAAC;IACrC,+GAA+G;IAC/G,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,IAAI,CAAC;IACpC,mDAAmD;IACnD,aAAa,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;IAC7C;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,IAAI,CAAC;IAClC,uEAAuE;IACvE,SAAS,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IACxC,8CAA8C;IAC9C,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,yEAAyE;IACzE,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,6DAA6D;IAC7D,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACrC;AAED,MAAM,WAAW,WAAW;IAC1B,+CAA+C;IAC/C,SAAS,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC7B,6CAA6C;IAC7C,UAAU,EAAE,GAAG,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;CAC7C;AAmCD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,GAAE,gBAAqB,GAAG,WAAW,CAktBrE"}

package/dist/interactions/index.d.ts

@@ -0,0 +1,13 @@
+export { createPress, type CreatePressProps, type PressResult } from './createPress';
+export { PressEvent, type IPressEvent, type PointerType as PressPointerType, type PressEventType, type BaseEventForPress } from './PressEvent';
+export { createLongPress, type LongPressProps, type LongPressResult, type LongPressEvent, } from './createLongPress';
+export { createMove, type MoveEvents, type MoveResult, type MoveStartEvent, type MoveMoveEvent, type MoveEndEvent } from './createMove';
+export { createFocus, type CreateFocusProps, type FocusResult, type FocusEvents } from './createFocus';
+export { createFocusWithin, type FocusWithinProps, type FocusWithinResult, } from './createFocusWithin';
+export { createFocusable, FocusableContext, type CreateFocusableProps, type FocusableResult, type FocusableContextValue, type FocusableProviderProps, type FocusableProps, type FocusableDOMProps, } from './createFocusable';
+export { FocusableProvider } from './FocusableProvider';
+export { createFocusRing, type FocusRingProps, type FocusRingResult, } from './createFocusRing';
+export { createInteractionModality, createFocusVisible, createFocusVisibleListener, addWindowFocusTracking, isFocusVisible, getInteractionModality, setInteractionModality, getPointerType, setupGlobalFocusListeners, addModalityListener, useIsKeyboardFocused, type Modality, type PointerType, type FocusVisibleProps, type FocusVisibleResult, type FocusVisibleHandler, type InteractionModalityResult, } from './createInteractionModality';
+export { createHover, type CreateHoverProps, type HoverProps, type HoverResult, type HoverEvent, type HoverEvents, } from './createHover';
+export { createKeyboard, type CreateKeyboardProps, type KeyboardResult, type KeyboardEvents, type KeyboardEvent, } from './createKeyboard';
+//# sourceMappingURL=index.d.ts.map