@askrjs/askr 0.0.7 → 0.0.9

package/dist/{component-BBGWJdqJ.d.ts → component-DHAn9JxU.d.ts}

@@ -1,4 +1,4 @@
-import { P as Props, J as JSXElement } from './jsx-AzPM8gMS.js';
+import { P as Props, J as JSXElement } from './jsx-CSWf4VFg.js';
 
 /**
  * State primitive for Askr components

package/dist/foundations/index.d.ts

@@ -1,7 +1,7 @@
 export { L as LayoutComponent, l as layout } from '../layout-BINPv-nz.js';
-import '../types-uOPfcrdz.js';
-import { J as JSXElement } from '../jsx-AzPM8gMS.js';
-import { S as State } from '../component-BBGWJdqJ.js';
+import '../types-DxdosFWx.js';
+import { J as JSXElement } from '../jsx-CSWf4VFg.js';
+import { S as State } from '../component-DHAn9JxU.js';
 
 type SlotProps = {
     asChild: true;
@@ -21,6 +21,7 @@ type SlotProps = {
  * 1. asChild Pattern
  *    When asChild=true, merges props into the single child element.
  *    Child must be a valid JSXElement; non-element children return null.
+ *    **Slot props override child props** (injection pattern).
  *
  * 2. Fallback Behavior
  *    When asChild=false, returns a Fragment (structural no-op).
@@ -93,6 +94,133 @@ interface Portal<T = unknown> {
 declare function definePortal<T = unknown>(): Portal<T>;
 declare const DefaultPortal: Portal<unknown>;
 
+/**
+ * createCollection
+ *
+ * Ordered descendant registry for coordinating items without DOM queries.
+ *
+ * INVARIANTS:
+ * 1. Registration order determines item order (no DOM queries)
+ * 2. Stable ordering across renders (insertion order preserved)
+ * 3. Each item may have metadata (type-safe, user-defined)
+ * 4. No implicit global state (explicit collection instances)
+ * 5. No automatic cleanup (caller controls lifecycle)
+ *
+ * DESIGN:
+ * - Returns a registry API ({ register, items, clear })
+ * - Items are stored in insertion order
+ * - Registration returns an unregister function
+ * - No side effects on registration (pure data structure)
+ *
+ * USAGE:
+ *   const collection = createCollection<HTMLElement, { disabled: boolean }>();
+ *   const unregister = collection.register(element, { disabled: false });
+ *   const allItems = collection.items();
+ *   unregister();
+ */
+type CollectionItem<TNode, TMetadata = unknown> = {
+    node: TNode;
+    metadata: TMetadata;
+};
+interface Collection<TNode, TMetadata = unknown> {
+    /**
+     * Register a node with optional metadata.
+     * Returns an unregister function.
+     */
+    register(node: TNode, metadata: TMetadata): () => void;
+    /**
+     * Get all registered items in insertion order.
+     */
+    items(): ReadonlyArray<CollectionItem<TNode, TMetadata>>;
+    /**
+     * Clear all registered items.
+     */
+    clear(): void;
+    /**
+     * Get the count of registered items.
+     */
+    size(): number;
+}
+declare function createCollection<TNode, TMetadata = unknown>(): Collection<TNode, TMetadata>;
+
+/**
+ * createLayer
+ *
+ * Manages stacking order and coordination for overlays (modals, popovers, etc).
+ *
+ * INVARIANTS:
+ * 1. Layers are ordered by registration time (FIFO)
+ * 2. Only the top layer handles Escape key
+ * 3. Only the top layer handles outside pointer events
+ * 4. Nested layers are supported
+ * 5. Does not implement portals (orthogonal concern)
+ * 6. No automatic DOM insertion (caller controls mounting)
+ *
+ * DESIGN:
+ * - Returns a layer manager with register/unregister API
+ * - Each layer has a unique ID and can query if it's the top layer
+ * - Escape and outside pointer coordination via callbacks
+ * - No z-index management (CSS concern)
+ *
+ * USAGE:
+ *   const manager = createLayer();
+ *
+ *   const layer = manager.register({
+ *     onEscape: () => { ... },
+ *     onOutsidePointer: () => { ... }
+ *   });
+ *
+ *   layer.isTop(); // true if this is the topmost layer
+ *   layer.unregister();
+ */
+interface LayerOptions {
+    /**
+     * Called when Escape is pressed and this is the top layer
+     */
+    onEscape?: () => void;
+    /**
+     * Called when pointer event occurs outside and this is the top layer
+     */
+    onOutsidePointer?: (e: PointerEvent) => void;
+    /**
+     * Optional node reference for outside pointer detection
+     */
+    node?: Node | null;
+}
+interface Layer {
+    /**
+     * Unique layer ID
+     */
+    id: number;
+    /**
+     * Check if this layer is the topmost
+     */
+    isTop(): boolean;
+    /**
+     * Remove this layer from the stack
+     */
+    unregister(): void;
+}
+interface LayerManager {
+    /**
+     * Register a new layer
+     */
+    register(options: LayerOptions): Layer;
+    /**
+     * Get all active layers in order
+     */
+    layers(): ReadonlyArray<Layer>;
+    /**
+     * Manually trigger escape handling on the top layer
+     */
+    handleEscape(): void;
+    /**
+     * Manually trigger outside pointer handling on the top layer
+     */
+    handleOutsidePointer(e: PointerEvent): void;
+}
+declare function createLayer(): LayerManager;
+
 /**
  * composeHandlers
  *
@@ -318,22 +446,59 @@ declare function pressable({ disabled, onPress, isNativeButton, }: PressableOpti
 /**
  * dismissable
  *
- * Provides props and helpers to support dismissal behaviour. This helper is
- * runtime-agnostic:
- * - It returns `onKeyDown` prop which will call onDismiss when Escape is
- *   pressed.
- * - It also provides `outsideListener` factory which given an `isInside`
- *   predicate returns a handler suitable to attach at the document level that
- *   will call onDismiss when the pointerdown target is outside the component.
+ * THE dismissal primitive. Handles Escape key and outside interactions.
+ *
+ * INVARIANTS:
+ * 1. Returns props that compose via mergeProps (no factories)
+ * 2. Disabled state respected exactly once, here
+ * 3. No side effects - pure props generation
+ * 4. Outside detection requires explicit node reference
+ * 5. This is the ONLY dismissal primitive - do not create alternatives
+ *
+ * DESIGN:
+ * - Returns standard event handler props (onKeyDown, onPointerDownCapture)
+ * - Composable via mergeProps with other foundations
+ * - Caller provides node reference for outside detection
+ * - Single onDismiss callback for all dismiss triggers
+ *
+ * PIT OF SUCCESS:
+ * ✓ Can't accidentally bypass (only way to get dismiss behavior)
+ * ✓ Can't duplicate (disabled checked once)
+ * ✓ Composes via mergeProps (standard props)
+ * ✓ Wrong usage is hard (no factories to misuse)
+ *
+ * USAGE:
+ *   const props = dismissable({
+ *     node: elementRef,
+ *     disabled: false,
+ *     onDismiss: () => close()
+ *   });
+ *
+ *   <div ref={elementRef} {...props}>Content</div>
+ *
+ * MISUSE EXAMPLE (PREVENTED):
+ *   ❌ Can't forget to check disabled - checked inside dismissable
+ *   ❌ Can't create custom escape handler - this is the only one
+ *   ❌ Can't bypass via direct event listeners - mergeProps composes correctly
  */
 interface DismissableOptions {
-    onDismiss?: () => void;
+    /**
+     * Reference to the element for outside click detection
+     */
+    node?: Node | null;
+    /**
+     * Whether dismiss is disabled
+     */
     disabled?: boolean;
+    /**
+     * Called when dismiss is triggered (Escape or outside click)
+     */
+    onDismiss?: (trigger: 'escape' | 'outside') => void;
 }
 
-declare function dismissable({ onDismiss, disabled }: DismissableOptions): {
-    onKeyDown: ((e: KeyboardLikeEvent) => void) | undefined;
-    outsideListener: ((isInside: (target: unknown) => boolean) => (e: PointerLikeEvent) => void) | undefined;
+declare function dismissable({ node, disabled, onDismiss, }: DismissableOptions): {
+    onKeyDown: (e: KeyboardLikeEvent) => void;
+    onPointerDownCapture: (e: PointerLikeEvent) => void;
 };
 
 /**
@@ -370,4 +535,190 @@ interface HoverableResult {
 }
 declare function hoverable({ disabled, onEnter, onLeave, }: HoverableOptions): HoverableResult;
 
-export { type ComposeHandlersOptions, type ControllableState, DefaultPortal, type DismissableOptions, type FocusableOptions, type FocusableResult, type HoverableOptions, type HoverableResult, JSXElement, type Portal, Presence, type PresenceProps, type PressableOptions, type PressableResult, type Ref, Slot, type SlotProps, ariaDisabled, ariaExpanded, ariaSelected, composeHandlers, composeRefs, controllableState, definePortal, dismissable, focusable, hoverable, isControlled, makeControllable, mergeProps, pressable, resolveControllable, setRef, useId };
+/**
+ * rovingFocus
+ *
+ * Single tab stop navigation with arrow-key control.
+ *
+ * INVARIANTS:
+ * 1. Only one item in the group is reachable via Tab (single tab stop)
+ * 2. Arrow keys move focus within the group
+ * 3. Orientation determines which arrow keys are active
+ * 4. Looping is opt-in
+ * 5. Disabled items are skipped
+ * 6. Returns props objects, never factories (composes via mergeProps)
+ *
+ * DESIGN:
+ * - Container gets onKeyDown for arrow navigation
+ * - Each item gets tabIndex based on current selection
+ * - Navigation logic is pure - caller controls focus application
+ * - Disabled check happens per-item via predicate
+ *
+ * PIT OF SUCCESS:
+ * ✓ Can't accidentally break tab order (tabIndex assigned correctly)
+ * ✓ Can't duplicate navigation logic (single source)
+ * ✓ Composes via mergeProps (all standard props)
+ * ✓ Type-safe - invalid indices caught at call site
+ *
+ * USAGE:
+ *   const nav = rovingFocus({
+ *     currentIndex: 0,
+ *     itemCount: 3,
+ *     orientation: 'horizontal',
+ *     onNavigate: setIndex
+ *   });
+ *
+ *   <div {...nav.container}>
+ *     <button {...nav.item(0)}>First</button>
+ *     <button {...nav.item(1)}>Second</button>
+ *   </div>
+ *
+ * MISUSE EXAMPLE (PREVENTED):
+ *   ❌ Can't forget to set tabIndex - returned in item props
+ *   ❌ Can't create conflicting arrow handlers - mergeProps composes
+ *   ❌ Can't skip disabled items incorrectly - logic is internal
+ */
+
+type Orientation = 'horizontal' | 'vertical' | 'both';
+interface RovingFocusOptions {
+    /**
+     * Current focused index
+     */
+    currentIndex: number;
+    /**
+     * Total number of items
+     */
+    itemCount: number;
+    /**
+     * Navigation orientation
+     * - horizontal: ArrowLeft/ArrowRight
+     * - vertical: ArrowUp/ArrowDown
+     * - both: all arrow keys
+     */
+    orientation?: Orientation;
+    /**
+     * Whether to loop when reaching the end
+     */
+    loop?: boolean;
+    /**
+     * Callback when navigation occurs
+     */
+    onNavigate?: (index: number) => void;
+    /**
+     * Optional disabled state check per index
+     */
+    isDisabled?: (index: number) => boolean;
+}
+interface RovingFocusResult {
+    /**
+     * Props for the container element (composes via mergeProps)
+     */
+    container: {
+        onKeyDown: (e: KeyboardLikeEvent) => void;
+    };
+    /**
+     * Generate props for an item at the given index (composes via mergeProps)
+     */
+    item: (index: number) => {
+        tabIndex: number;
+        'data-roving-index': number;
+    };
+}
+declare function rovingFocus(options: RovingFocusOptions): RovingFocusResult;
+
+/**
+ * INTERACTION POLICY (FRAMEWORK LAW)
+ *
+ * This is THE ONLY way to create interactive elements. Components MUST NOT
+ * implement interaction logic directly.
+ *
+ * INVARIANTS (ENFORCED):
+ * 1. "Press" is the semantic. Click/touch/Enter/Space are implementation details.
+ * 2. Disabled is enforced exactly once, here. Components may not check disabled.
+ * 3. Keyboard handling is automatic. Components may not add onKeyDown for activation.
+ * 4. Native elements opt out of polyfills, not semantics.
+ * 5. asChild may replace the host element, not interaction behavior.
+ * 6. This policy is the SINGLE SOURCE OF TRUTH for interactive behavior.
+ *
+ * DESIGN:
+ * - Single public function: applyInteractionPolicy
+ * - Returns props that compose via mergeProps
+ * - Delegates to pressable for mechanics
+ * - Enforces disabled once and only once
+ * - No configuration beyond disabled and native element type
+ *
+ * PIT OF SUCCESS:
+ * ✓ Can't bypass policy (only way to get interaction behavior)
+ * ✓ Can't duplicate disabled checks (enforced once, here)
+ * ✓ Can't write custom keyboard handlers for buttons (policy owns it)
+ * ✓ Composes via mergeProps (standard props)
+ * ✓ Wrong usage is impossible (no escape hatch)
+ *
+ * USAGE:
+ *   function Button({ onPress, disabled }) {
+ *     const interaction = applyInteractionPolicy({
+ *       isNative: true,
+ *       disabled,
+ *       onPress
+ *     });
+ *
+ *     return <button {...interaction}>Click me</button>;
+ *   }
+ *
+ * MISUSE EXAMPLE (PREVENTED):
+ *   ❌ Button checking disabled again:
+ *      function Button({ disabled, onPress }) {
+ *        if (disabled) return; // NO! Policy handles this
+ *        const interaction = applyInteractionPolicy(...);
+ *      }
+ *
+ *   ❌ Custom keyboard handler:
+ *      function Button({ onPress }) {
+ *        const interaction = applyInteractionPolicy(...);
+ *        return <button {...interaction} onKeyDown={...}>; // NO! Policy owns this
+ *      }
+ *
+ *   ❌ Direct event handler:
+ *      <button onClick={onPress}>; // NO! Use applyInteractionPolicy
+ */
+interface InteractionPolicyInput {
+    /** Whether the host element is a native interactive element (button, a, etc) */
+    isNative: boolean;
+    /** Disabled state - checked ONLY here, never in components */
+    disabled: boolean;
+    /** User-provided press handler - semantic action, not DOM event */
+    onPress?: (e: Event) => void;
+    /** Optional ref to compose */
+    ref?: any;
+}
+/**
+ * THE interaction policy. Components MUST use this, NEVER implement
+ * interaction logic directly.
+ */
+declare function applyInteractionPolicy({ isNative, disabled, onPress, ref, }: InteractionPolicyInput): {
+    disabled: true | undefined;
+    onClick: (e: Event) => void;
+    ref: any;
+} | {
+    'aria-disabled': true | undefined;
+    tabIndex: number;
+    ref: any;
+    onClick: (e: DefaultPreventable & PropagationStoppable) => void;
+    disabled?: true;
+    role?: "button";
+    onKeyDown?: (e: KeyboardLikeEvent) => void;
+    onKeyUp?: (e: KeyboardLikeEvent) => void;
+};
+/**
+ * Merge rule for Slot / asChild
+ *
+ * Precedence:
+ *   policy → user → child
+ *
+ * Event handlers are composed (policy first).
+ * Refs are always composed.
+ * Policy props MUST take precedence to enforce invariants.
+ */
+declare function mergeInteractionProps(childProps: Record<string, any>, policyProps: Record<string, any>, userProps?: Record<string, any>): Record<string, any>;
+
+export { type Collection, type CollectionItem, type ComposeHandlersOptions, type ControllableState, DefaultPortal, type DismissableOptions, type FocusableOptions, type FocusableResult, type HoverableOptions, type HoverableResult, type InteractionPolicyInput, JSXElement, type Layer, type LayerManager, type LayerOptions, type Orientation, type Portal, Presence, type PresenceProps, type PressableOptions, type PressableResult, type Ref, type RovingFocusOptions, type RovingFocusResult, Slot, type SlotProps, applyInteractionPolicy, ariaDisabled, ariaExpanded, ariaSelected, composeHandlers, composeRefs, controllableState, createCollection, createLayer, definePortal, dismissable, focusable, hoverable, isControlled, makeControllable, mergeInteractionProps, mergeProps, pressable, resolveControllable, rovingFocus, setRef, useId };