@askrjs/askr 0.0.51 → 0.0.53

package/dist/foundations/interactions/interaction-policy.js

@@ -1,122 +0,0 @@
-import { composeHandlers } from "../utilities/compose-handlers.js";
-import { mergeProps } from "../utilities/merge-props.js";
-import { ariaDisabled } from "../utilities/aria.js";
-import { composeRefs } from "../utilities/compose-ref.js";
-import { pressable } from "./pressable.js";
-//#region src/foundations/interactions/interaction-policy.ts
-/**
-* 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
-*/
-/**
-* THE interaction policy. Components MUST use this, NEVER implement
-* interaction logic directly.
-*/
-function applyInteractionPolicy({ isNative, disabled, onPress, ref }) {
-	function invokePress(e) {
-		if (disabled) {
-			e.preventDefault?.();
-			return;
-		}
-		onPress?.(e);
-	}
-	if (isNative) return {
-		disabled: disabled || void 0,
-		onClick: (e) => invokePress(e),
-		ref
-	};
-	const interaction = pressable({
-		disabled,
-		isNativeButton: false,
-		onPress: (e) => invokePress(e)
-	});
-	return {
-		...interaction,
-		...ariaDisabled(disabled),
-		tabIndex: disabled ? -1 : interaction.tabIndex ?? 0,
-		ref
-	};
-}
-/**
-* 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.
-*/
-function mergeInteractionProps(childProps, policyProps, userProps) {
-	const out = mergeProps(policyProps, userProps ? mergeProps(userProps, childProps) : childProps);
-	for (const k in out) {
-		if (!k.startsWith("on")) continue;
-		const policyHandler = policyProps?.[k];
-		const userHandler = userProps?.[k];
-		const childHandler = childProps?.[k];
-		if (policyHandler || userHandler || childHandler) {
-			const toHandler = (h) => typeof h === "function" ? h : void 0;
-			out[k] = composeHandlers(toHandler(policyHandler), composeHandlers(toHandler(userHandler), toHandler(childHandler)));
-		}
-	}
-	const childRef = childProps?.ref;
-	const userRef = userProps?.ref;
-	const policyRef = policyProps?.ref;
-	out.ref = composeRefs(childRef, userRef, policyRef);
-	return out;
-}
-//#endregion
-export { applyInteractionPolicy, mergeInteractionProps };
-
-//# sourceMappingURL=interaction-policy.js.map

package/dist/foundations/interactions/interaction-policy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"interaction-policy.js","names":["mergePropsBase"],"sources":["../../../src/foundations/interactions/interaction-policy.ts"],"sourcesContent":["/**\n * INTERACTION POLICY (FRAMEWORK LAW)\n *\n * This is THE ONLY way to create interactive elements. Components MUST NOT\n * implement interaction logic directly.\n *\n * INVARIANTS (ENFORCED):\n * 1. \"Press\" is the semantic. Click/touch/Enter/Space are implementation details.\n * 2. Disabled is enforced exactly once, here. Components may not check disabled.\n * 3. Keyboard handling is automatic. Components may not add onKeyDown for activation.\n * 4. Native elements opt out of polyfills, not semantics.\n * 5. asChild may replace the host element, not interaction behavior.\n * 6. This policy is the SINGLE SOURCE OF TRUTH for interactive behavior.\n *\n * DESIGN:\n * - Single public function: applyInteractionPolicy\n * - Returns props that compose via mergeProps\n * - Delegates to pressable for mechanics\n * - Enforces disabled once and only once\n * - No configuration beyond disabled and native element type\n *\n * PIT OF SUCCESS:\n * ✓ Can't bypass policy (only way to get interaction behavior)\n * ✓ Can't duplicate disabled checks (enforced once, here)\n * ✓ Can't write custom keyboard handlers for buttons (policy owns it)\n * ✓ Composes via mergeProps (standard props)\n * ✓ Wrong usage is impossible (no escape hatch)\n *\n * USAGE:\n *   function Button({ onPress, disabled }) {\n *     const interaction = applyInteractionPolicy({\n *       isNative: true,\n *       disabled,\n *       onPress\n *     });\n *\n *     return <button {...interaction}>Click me</button>;\n *   }\n *\n * MISUSE EXAMPLE (PREVENTED):\n *   ❌ Button checking disabled again:\n *      function Button({ disabled, onPress }) {\n *        if (disabled) return; // NO! Policy handles this\n *        const interaction = applyInteractionPolicy(...);\n *      }\n *\n *   ❌ Custom keyboard handler:\n *      function Button({ onPress }) {\n *        const interaction = applyInteractionPolicy(...);\n *        return <button {...interaction} onKeyDown={...}>; // NO! Policy owns this\n *      }\n *\n *   ❌ Direct event handler:\n *      <button onClick={onPress}>; // NO! Use applyInteractionPolicy\n */\n\nimport { pressable } from './pressable';\nimport { ariaDisabled } from '../utilities/aria';\nimport { composeHandlers } from '../utilities/compose-handlers';\nimport { composeRefs, Ref } from '../utilities/compose-ref';\nimport { mergeProps as mergePropsBase } from '../utilities/merge-props';\n\nexport interface InteractionPolicyInput {\n  /** Whether the host element is a native interactive element (button, a, etc) */\n  isNative: boolean;\n  /** Disabled state - checked ONLY here, never in components */\n  disabled: boolean;\n  /** User-provided press handler - semantic action, not DOM event */\n  onPress?: (e: Event) => void;\n  /** Optional ref to compose */\n  ref?: Ref<unknown>;\n}\n\n/**\n * THE interaction policy. Components MUST use this, NEVER implement\n * interaction logic directly.\n */\nexport function applyInteractionPolicy({\n  isNative,\n  disabled,\n  onPress,\n  ref,\n}: InteractionPolicyInput) {\n  // Disabled is enforced exactly once, here.\n  // Components downstream may NOT check disabled.\n  function invokePress(e: Event) {\n    if (disabled) {\n      e.preventDefault?.();\n      return;\n    }\n    onPress?.(e);\n  }\n\n  if (isNative) {\n    return {\n      disabled: disabled || undefined,\n      onClick: (e: Event) => invokePress(e),\n      ref,\n    };\n  }\n\n  // Non-native elements get full button semantics\n  const interaction = pressable({\n    disabled,\n    isNativeButton: false,\n    onPress: (e) => invokePress(e as Event),\n  });\n\n  return {\n    ...interaction,\n    ...ariaDisabled(disabled),\n    tabIndex: disabled ? -1 : (interaction.tabIndex ?? 0),\n    ref,\n  };\n}\n\n/**\n * Merge rule for Slot / asChild\n *\n * Precedence:\n *   policy → user → child\n *\n * Event handlers are composed (policy first).\n * Refs are always composed.\n * Policy props MUST take precedence to enforce invariants.\n */\nexport function mergeInteractionProps(\n  childProps: Record<string, unknown>,\n  policyProps: Record<string, unknown>,\n  userProps?: Record<string, unknown>\n) {\n  const mergedUserChild = userProps\n    ? mergePropsBase(userProps, childProps)\n    : childProps;\n  const out = mergePropsBase(policyProps, mergedUserChild);\n\n  // Ensure policy handlers always run first\n  for (const k in out) {\n    if (!k.startsWith('on')) continue;\n\n    const policyHandler = policyProps?.[k];\n    const userHandler = userProps?.[k];\n    const childHandler = childProps?.[k];\n\n    if (policyHandler || userHandler || childHandler) {\n      const toHandler = (h: unknown) =>\n        typeof h === 'function'\n          ? (h as (...args: readonly unknown[]) => void)\n          : undefined;\n\n      out[k] = composeHandlers(\n        toHandler(policyHandler),\n        composeHandlers(toHandler(userHandler), toHandler(childHandler))\n      );\n    }\n  }\n\n  const childRef = childProps?.ref as Ref<unknown> | undefined;\n  const userRef = userProps?.ref as Ref<unknown> | undefined;\n  const policyRef = policyProps?.ref as Ref<unknown> | undefined;\n\n  out.ref = composeRefs(childRef, userRef, policyRef);\n\n  return out;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6EA,SAAgB,uBAAuB,EACrC,UACA,UACA,SACA,OACyB;CAGzB,SAAS,YAAY,GAAU;EAC7B,IAAI,UAAU;GACZ,EAAE,iBAAiB;GACnB;EACF;EACA,UAAU,CAAC;CACb;CAEA,IAAI,UACF,OAAO;EACL,UAAU,YAAY;EACtB,UAAU,MAAa,YAAY,CAAC;EACpC;CACF;CAIF,MAAM,cAAc,UAAU;EAC5B;EACA,gBAAgB;EAChB,UAAU,MAAM,YAAY,CAAU;CACxC,CAAC;CAED,OAAO;EACL,GAAG;EACH,GAAG,aAAa,QAAQ;EACxB,UAAU,WAAW,KAAM,YAAY,YAAY;EACnD;CACF;AACF;;;;;;;;;;;AAYA,SAAgB,sBACd,YACA,aACA,WACA;CAIA,MAAM,MAAMA,WAAe,aAHH,YACpBA,WAAe,WAAW,UAAU,IACpC,UACmD;CAGvD,KAAK,MAAM,KAAK,KAAK;EACnB,IAAI,CAAC,EAAE,WAAW,IAAI,GAAG;EAEzB,MAAM,gBAAgB,cAAc;EACpC,MAAM,cAAc,YAAY;EAChC,MAAM,eAAe,aAAa;EAElC,IAAI,iBAAiB,eAAe,cAAc;GAChD,MAAM,aAAa,MACjB,OAAO,MAAM,aACR,IACD;GAEN,IAAI,KAAK,gBACP,UAAU,aAAa,GACvB,gBAAgB,UAAU,WAAW,GAAG,UAAU,YAAY,CAAC,CACjE;EACF;CACF;CAEA,MAAM,WAAW,YAAY;CAC7B,MAAM,UAAU,WAAW;CAC3B,MAAM,YAAY,aAAa;CAE/B,IAAI,MAAM,YAAY,UAAU,SAAS,SAAS;CAElD,OAAO;AACT"}

package/dist/foundations/interactions/pressable.d.ts

@@ -1,61 +0,0 @@
-import { DefaultPreventable, KeyboardLikeEvent, PropagationStoppable } from "../utilities/event-types.js";
-
-//#region src/foundations/interactions/pressable.d.ts
-/**
- * pressable
- *
- * Interaction helper that produces VNode props for 'press' semantics.
- * - Pure and deterministic: no DOM construction or mutation here
- * - The runtime owns event attachment and scheduling
- * - This helper returns plain props (handlers) intended to be attached by the runtime
- *
- * Behaviour:
- * - For native buttons: only an `onClick` prop is provided (no ARIA or keyboard shims)
- * - For non-button elements: add `role="button"` and `tabIndex` and keyboard handlers
- * - Activation: `Enter` activates on keydown, `Space` activates on keyup (matches native button)
- * - Disabled: handlers short-circuit and `aria-disabled` is set for all hosts
- *
- * POLICY DECISIONS (LOCKED):
- *
- * 1. Activation Timing (Platform Parity)
- *    - Enter fires on keydown (immediate response)
- *    - Space fires on keyup (allows cancel by moving focus, matches native)
- *    - Space keydown prevents scroll (matches native button behavior)
- *
- * 2. Disabled Enforcement Strategy
- *    - Native buttons: Use HTML `disabled` attribute (platform-enforced non-interactivity)
- *                     AND `aria-disabled` (consistent a11y signaling)
- *    - Non-native: Use `tabIndex=-1` (removes from tab order)
- *                  AND `aria-disabled` (signals disabled state to AT)
- *    - Click handler short-circuits as defense-in-depth (prevents leaked focus issues)
- *
- * 3. Key Repeat Behavior
- *    - Held Enter/Space will fire onPress repeatedly (matches native button)
- *    - No debouncing or repeat prevention (platform parity)
- */
-interface PressableOptions {
-  disabled?: boolean;
-  onPress?: (e: PressEvent) => void;
-  /**
-   * Whether the host is a native button. Defaults to false.
-   */
-  isNativeButton?: boolean;
-}
-type PressEvent = DefaultPreventable & PropagationStoppable;
-interface PressableResult {
-  onClick: (e: PressEvent) => void;
-  disabled?: true;
-  role?: 'button';
-  tabIndex?: number;
-  onKeyDown?: (e: KeyboardLikeEvent) => void;
-  onKeyUp?: (e: KeyboardLikeEvent) => void;
-  'aria-disabled'?: 'true';
-}
-declare function pressable({
-  disabled,
-  onPress,
-  isNativeButton
-}: PressableOptions): PressableResult;
-//#endregion
-export { PressableOptions, PressableResult, pressable };
-//# sourceMappingURL=pressable.d.ts.map

package/dist/foundations/interactions/pressable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pressable.d.ts","names":[],"sources":["../../../src/foundations/interactions/pressable.ts"],"mappings":";;;;;;AAiCA;;;;;;;;;;AAMgB;AAOkB;;;;AAGyB;AAE3D;;;;;;;;;;;;;UAlBiB,gBAAA;EACf,QAAA;EACA,OAAA,IAAW,CAAA,EAAG,UAAU;EAqBX;;;EAjBb,cAAA;AAAA;AAAA,KAUG,UAAA,GAAa,kBAAA,GAAqB,oBAAoB;AAAA,UAE1C,eAAA;EACf,OAAA,GAAU,CAAA,EAAG,UAAA;EACb,QAAA;EACA,IAAA;EACA,QAAA;EACA,SAAA,IAAa,CAAA,EAAG,iBAAA;EAChB,OAAA,IAAW,CAAA,EAAG,iBAAA;EACd,eAAA;AAAA;AAAA,iBAGc,SAAA;EACd,QAAA;EACA,OAAA;EACA;AAAA,GACC,gBAAA,GAAmB,eAAA"}

package/dist/foundations/interactions/pressable.js

@@ -1,51 +0,0 @@
-import { ariaDisabled } from "../utilities/aria.js";
-//#region src/foundations/interactions/pressable.ts
-function pressable({ disabled, onPress, isNativeButton = false }) {
-	const props = { onClick: (e) => {
-		if (disabled) {
-			e.preventDefault?.();
-			e.stopPropagation?.();
-			return;
-		}
-		onPress?.(e);
-	} };
-	if (isNativeButton) {
-		if (disabled) {
-			props.disabled = true;
-			Object.assign(props, ariaDisabled(disabled));
-		}
-		return props;
-	}
-	props.role = "button";
-	props.tabIndex = disabled ? -1 : 0;
-	props.onKeyDown = (e) => {
-		if (disabled) {
-			e.preventDefault?.();
-			e.stopPropagation?.();
-			return;
-		}
-		if (e.key === "Enter") {
-			e.preventDefault?.();
-			onPress?.(e);
-			return;
-		}
-		if (e.key === " ") e.preventDefault?.();
-	};
-	props.onKeyUp = (e) => {
-		if (disabled) {
-			e.preventDefault?.();
-			e.stopPropagation?.();
-			return;
-		}
-		if (e.key === " ") {
-			e.preventDefault?.();
-			onPress?.(e);
-		}
-	};
-	if (disabled) Object.assign(props, ariaDisabled(disabled));
-	return props;
-}
-//#endregion
-export { pressable };
-
-//# sourceMappingURL=pressable.js.map

package/dist/foundations/interactions/pressable.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pressable.js","names":[],"sources":["../../../src/foundations/interactions/pressable.ts"],"sourcesContent":["/**\n * pressable\n *\n * Interaction helper that produces VNode props for 'press' semantics.\n * - Pure and deterministic: no DOM construction or mutation here\n * - The runtime owns event attachment and scheduling\n * - This helper returns plain props (handlers) intended to be attached by the runtime\n *\n * Behaviour:\n * - For native buttons: only an `onClick` prop is provided (no ARIA or keyboard shims)\n * - For non-button elements: add `role=\"button\"` and `tabIndex` and keyboard handlers\n * - Activation: `Enter` activates on keydown, `Space` activates on keyup (matches native button)\n * - Disabled: handlers short-circuit and `aria-disabled` is set for all hosts\n *\n * POLICY DECISIONS (LOCKED):\n *\n * 1. Activation Timing (Platform Parity)\n *    - Enter fires on keydown (immediate response)\n *    - Space fires on keyup (allows cancel by moving focus, matches native)\n *    - Space keydown prevents scroll (matches native button behavior)\n *\n * 2. Disabled Enforcement Strategy\n *    - Native buttons: Use HTML `disabled` attribute (platform-enforced non-interactivity)\n *                     AND `aria-disabled` (consistent a11y signaling)\n *    - Non-native: Use `tabIndex=-1` (removes from tab order)\n *                  AND `aria-disabled` (signals disabled state to AT)\n *    - Click handler short-circuits as defense-in-depth (prevents leaked focus issues)\n *\n * 3. Key Repeat Behavior\n *    - Held Enter/Space will fire onPress repeatedly (matches native button)\n *    - No debouncing or repeat prevention (platform parity)\n */\n\nexport interface PressableOptions {\n  disabled?: boolean;\n  onPress?: (e: PressEvent) => void;\n  /**\n   * Whether the host is a native button. Defaults to false.\n   */\n  isNativeButton?: boolean;\n}\n\nimport type {\n  DefaultPreventable,\n  KeyboardLikeEvent,\n  PropagationStoppable,\n} from '../utilities/event-types';\nimport { ariaDisabled } from '../utilities/aria';\n\ntype PressEvent = DefaultPreventable & PropagationStoppable;\n\nexport interface PressableResult {\n  onClick: (e: PressEvent) => void;\n  disabled?: true;\n  role?: 'button';\n  tabIndex?: number;\n  onKeyDown?: (e: KeyboardLikeEvent) => void;\n  onKeyUp?: (e: KeyboardLikeEvent) => void;\n  'aria-disabled'?: 'true';\n}\n\nexport function pressable({\n  disabled,\n  onPress,\n  isNativeButton = false,\n}: PressableOptions): PressableResult {\n  const props: PressableResult = {\n    onClick: (e) => {\n      if (disabled) {\n        e.preventDefault?.();\n        e.stopPropagation?.();\n        return;\n      }\n      onPress?.(e);\n    },\n  };\n\n  if (isNativeButton) {\n    if (disabled) {\n      props.disabled = true;\n      Object.assign(props, ariaDisabled(disabled));\n    }\n    return props;\n  }\n\n  props.role = 'button';\n  props.tabIndex = disabled ? -1 : 0;\n\n  props.onKeyDown = (e) => {\n    if (disabled) {\n      e.preventDefault?.();\n      e.stopPropagation?.();\n      return;\n    }\n\n    if (e.key === 'Enter') {\n      e.preventDefault?.();\n      onPress?.(e);\n      return;\n    }\n\n    if (e.key === ' ') {\n      // Prevent scrolling while Space is held.\n      e.preventDefault?.();\n    }\n  };\n\n  props.onKeyUp = (e) => {\n    if (disabled) {\n      e.preventDefault?.();\n      e.stopPropagation?.();\n      return;\n    }\n    if (e.key === ' ') {\n      e.preventDefault?.();\n      onPress?.(e);\n    }\n  };\n\n  if (disabled) Object.assign(props, ariaDisabled(disabled));\n  return props;\n}\n"],"mappings":";;AA6DA,SAAgB,UAAU,EACxB,UACA,SACA,iBAAiB,SACmB;CACpC,MAAM,QAAyB,EAC7B,UAAU,MAAM;EACd,IAAI,UAAU;GACZ,EAAE,iBAAiB;GACnB,EAAE,kBAAkB;GACpB;EACF;EACA,UAAU,CAAC;CACb,EACF;CAEA,IAAI,gBAAgB;EAClB,IAAI,UAAU;GACZ,MAAM,WAAW;GACjB,OAAO,OAAO,OAAO,aAAa,QAAQ,CAAC;EAC7C;EACA,OAAO;CACT;CAEA,MAAM,OAAO;CACb,MAAM,WAAW,WAAW,KAAK;CAEjC,MAAM,aAAa,MAAM;EACvB,IAAI,UAAU;GACZ,EAAE,iBAAiB;GACnB,EAAE,kBAAkB;GACpB;EACF;EAEA,IAAI,EAAE,QAAQ,SAAS;GACrB,EAAE,iBAAiB;GACnB,UAAU,CAAC;GACX;EACF;EAEA,IAAI,EAAE,QAAQ,KAEZ,EAAE,iBAAiB;CAEvB;CAEA,MAAM,WAAW,MAAM;EACrB,IAAI,UAAU;GACZ,EAAE,iBAAiB;GACnB,EAAE,kBAAkB;GACpB;EACF;EACA,IAAI,EAAE,QAAQ,KAAK;GACjB,EAAE,iBAAiB;GACnB,UAAU,CAAC;EACb;CACF;CAEA,IAAI,UAAU,OAAO,OAAO,OAAO,aAAa,QAAQ,CAAC;CACzD,OAAO;AACT"}

package/dist/foundations/interactions/roving-focus.d.ts

@@ -1,52 +0,0 @@
-import { KeyboardLikeEvent } from "../utilities/event-types.js";
-
-//#region src/foundations/interactions/roving-focus.d.ts
-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;
-//#endregion
-export { Orientation, RovingFocusOptions, RovingFocusResult, rovingFocus };
-//# sourceMappingURL=roving-focus.d.ts.map

package/dist/foundations/interactions/roving-focus.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"roving-focus.d.ts","names":[],"sources":["../../../src/foundations/interactions/roving-focus.ts"],"mappings":";;;KA8CY,WAAA;AAAA,UAEK,kBAAA;;;;EAIf,YAAA;;;;EAKA,SAAA;;;;;;;EAQA,WAAA,GAAc,WAAW;;;;EAKzB,IAAA;;;;EAKA,UAAA,IAAc,KAAA;;;;EAKd,UAAA,IAAc,KAAA;AAAA;AAAA,UAGC,iBAAA;;;;EAIf,SAAA;IACE,SAAA,GAAY,CAAA,EAAG,iBAAiB;EAAA;;;;EAMlC,IAAA,GAAO,KAAA;IACL,QAAA;IACA,mBAAA;EAAA;AAAA;AAAA,iBAIY,WAAA,CAAY,OAAA,EAAS,kBAAA,GAAqB,iBAAiB"}

package/dist/foundations/interactions/roving-focus.js

@@ -1,71 +0,0 @@
-//#region src/foundations/interactions/roving-focus.ts
-function rovingFocus(options) {
-	const { currentIndex, itemCount, orientation = "horizontal", loop = false, onNavigate, isDisabled } = options;
-	function findNextIndex(from, direction) {
-		let next = from;
-		for (let steps = 0; steps < itemCount; steps += 1) {
-			next += direction;
-			if (loop) {
-				if (next < 0) next = itemCount - 1;
-				if (next >= itemCount) next = 0;
-			} else if (next < 0 || next >= itemCount) return;
-			if (next === from) return void 0;
-			if (!isDisabled?.(next)) return next;
-		}
-	}
-	function handleKeyDown(e) {
-		const { key } = e;
-		let direction;
-		if (orientation === "horizontal" || orientation === "both") {
-			if (key === "ArrowRight") direction = 1;
-			if (key === "ArrowLeft") direction = -1;
-		}
-		if (orientation === "vertical" || orientation === "both") {
-			if (key === "ArrowDown") direction = 1;
-			if (key === "ArrowUp") direction = -1;
-		}
-		if (direction === void 0) return;
-		const nextIndex = findNextIndex(currentIndex, direction);
-		if (nextIndex === void 0) return;
-		e.preventDefault?.();
-		e.stopPropagation?.();
-		onNavigate?.(nextIndex);
-	}
-	return {
-		container: { onKeyDown: handleKeyDown },
-		item: (index) => ({
-			tabIndex: index === currentIndex ? 0 : -1,
-			"data-roving-index": index
-		})
-	};
-}
-/**
-* USAGE EXAMPLE:
-*
-* function Menu() {
-*   const [focusIndex, setFocusIndex] = state(0);
-*   const items = ['File', 'Edit', 'View'];
-*
-*   const navigation = rovingFocus({
-*     currentIndex: focusIndex(),
-*     itemCount: items.length,
-*     orientation: 'horizontal',
-*     loop: true,
-*     onNavigate: setFocusIndex,
-*   });
-*
-*   return (
-*     <div {...navigation.container}>
-*       {items.map((label, index) => (
-*         <button {...navigation.item(index)}>
-*           {label}
-*         </button>
-*       ))}
-*     </div>
-*   );
-* }
-*/
-//#endregion
-export { rovingFocus };
-
-//# sourceMappingURL=roving-focus.js.map

package/dist/foundations/interactions/roving-focus.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"roving-focus.js","names":[],"sources":["../../../src/foundations/interactions/roving-focus.ts"],"sourcesContent":["/**\n * rovingFocus\n *\n * Single tab stop navigation with arrow-key control.\n *\n * INVARIANTS:\n * 1. Only one item in the group is reachable via Tab (single tab stop)\n * 2. Arrow keys move focus within the group\n * 3. Orientation determines which arrow keys are active\n * 4. Looping is opt-in\n * 5. Disabled items are skipped\n * 6. Returns props objects, never factories (composes via mergeProps)\n *\n * DESIGN:\n * - Container gets onKeyDown for arrow navigation\n * - Each item gets tabIndex based on current selection\n * - Navigation logic is pure - caller controls focus application\n * - Disabled check happens per-item via predicate\n *\n * PIT OF SUCCESS:\n * ✓ Can't accidentally break tab order (tabIndex assigned correctly)\n * ✓ Can't duplicate navigation logic (single source)\n * ✓ Composes via mergeProps (all standard props)\n * ✓ Type-safe - invalid indices caught at call site\n *\n * USAGE:\n *   const nav = rovingFocus({\n *     currentIndex: 0,\n *     itemCount: 3,\n *     orientation: 'horizontal',\n *     onNavigate: setIndex\n *   });\n *\n *   <div {...nav.container}>\n *     <button {...nav.item(0)}>First</button>\n *     <button {...nav.item(1)}>Second</button>\n *   </div>\n *\n * MISUSE EXAMPLE (PREVENTED):\n *   ❌ Can't forget to set tabIndex - returned in item props\n *   ❌ Can't create conflicting arrow handlers - mergeProps composes\n *   ❌ Can't skip disabled items incorrectly - logic is internal\n */\n\nimport type { KeyboardLikeEvent } from '../utilities/event-types';\n\nexport type Orientation = 'horizontal' | 'vertical' | 'both';\n\nexport interface RovingFocusOptions {\n  /**\n   * Current focused index\n   */\n  currentIndex: number;\n\n  /**\n   * Total number of items\n   */\n  itemCount: number;\n\n  /**\n   * Navigation orientation\n   * - horizontal: ArrowLeft/ArrowRight\n   * - vertical: ArrowUp/ArrowDown\n   * - both: all arrow keys\n   */\n  orientation?: Orientation;\n\n  /**\n   * Whether to loop when reaching the end\n   */\n  loop?: boolean;\n\n  /**\n   * Callback when navigation occurs\n   */\n  onNavigate?: (index: number) => void;\n\n  /**\n   * Optional disabled state check per index\n   */\n  isDisabled?: (index: number) => boolean;\n}\n\nexport interface RovingFocusResult {\n  /**\n   * Props for the container element (composes via mergeProps)\n   */\n  container: {\n    onKeyDown: (e: KeyboardLikeEvent) => void;\n  };\n\n  /**\n   * Generate props for an item at the given index (composes via mergeProps)\n   */\n  item: (index: number) => {\n    tabIndex: number;\n    'data-roving-index': number;\n  };\n}\n\nexport function rovingFocus(options: RovingFocusOptions): RovingFocusResult {\n  const {\n    currentIndex,\n    itemCount,\n    orientation = 'horizontal',\n    loop = false,\n    onNavigate,\n    isDisabled,\n  } = options;\n\n  function findNextIndex(from: number, direction: 1 | -1): number | undefined {\n    let next = from;\n\n    for (let steps = 0; steps < itemCount; steps += 1) {\n      next += direction;\n\n      if (loop) {\n        if (next < 0) next = itemCount - 1;\n        if (next >= itemCount) next = 0;\n      } else if (next < 0 || next >= itemCount) {\n        return undefined;\n      }\n\n      if (next === from) return undefined;\n      if (!isDisabled?.(next)) return next;\n    }\n\n    return undefined;\n  }\n\n  function handleKeyDown(e: KeyboardLikeEvent) {\n    const { key } = e;\n\n    let direction: 1 | -1 | undefined;\n\n    if (orientation === 'horizontal' || orientation === 'both') {\n      if (key === 'ArrowRight') direction = 1;\n      if (key === 'ArrowLeft') direction = -1;\n    }\n\n    if (orientation === 'vertical' || orientation === 'both') {\n      if (key === 'ArrowDown') direction = 1;\n      if (key === 'ArrowUp') direction = -1;\n    }\n\n    if (direction === undefined) return;\n\n    const nextIndex = findNextIndex(currentIndex, direction);\n    if (nextIndex === undefined) return;\n\n    e.preventDefault?.();\n    e.stopPropagation?.();\n\n    onNavigate?.(nextIndex);\n  }\n\n  return {\n    container: {\n      onKeyDown: handleKeyDown,\n    },\n    item: (index: number) => ({\n      tabIndex: index === currentIndex ? 0 : -1,\n      'data-roving-index': index,\n    }),\n  };\n}\n\n/**\n * USAGE EXAMPLE:\n *\n * function Menu() {\n *   const [focusIndex, setFocusIndex] = state(0);\n *   const items = ['File', 'Edit', 'View'];\n *\n *   const navigation = rovingFocus({\n *     currentIndex: focusIndex(),\n *     itemCount: items.length,\n *     orientation: 'horizontal',\n *     loop: true,\n *     onNavigate: setFocusIndex,\n *   });\n *\n *   return (\n *     <div {...navigation.container}>\n *       {items.map((label, index) => (\n *         <button {...navigation.item(index)}>\n *           {label}\n *         </button>\n *       ))}\n *     </div>\n *   );\n * }\n */\n"],"mappings":";AAoGA,SAAgB,YAAY,SAAgD;CAC1E,MAAM,EACJ,cACA,WACA,cAAc,cACd,OAAO,OACP,YACA,eACE;CAEJ,SAAS,cAAc,MAAc,WAAuC;EAC1E,IAAI,OAAO;EAEX,KAAK,IAAI,QAAQ,GAAG,QAAQ,WAAW,SAAS,GAAG;GACjD,QAAQ;GAER,IAAI,MAAM;IACR,IAAI,OAAO,GAAG,OAAO,YAAY;IACjC,IAAI,QAAQ,WAAW,OAAO;GAChC,OAAO,IAAI,OAAO,KAAK,QAAQ,WAC7B;GAGF,IAAI,SAAS,MAAM,OAAO;GAC1B,IAAI,CAAC,aAAa,IAAI,GAAG,OAAO;EAClC;CAGF;CAEA,SAAS,cAAc,GAAsB;EAC3C,MAAM,EAAE,QAAQ;EAEhB,IAAI;EAEJ,IAAI,gBAAgB,gBAAgB,gBAAgB,QAAQ;GAC1D,IAAI,QAAQ,cAAc,YAAY;GACtC,IAAI,QAAQ,aAAa,YAAY;EACvC;EAEA,IAAI,gBAAgB,cAAc,gBAAgB,QAAQ;GACxD,IAAI,QAAQ,aAAa,YAAY;GACrC,IAAI,QAAQ,WAAW,YAAY;EACrC;EAEA,IAAI,cAAc,QAAW;EAE7B,MAAM,YAAY,cAAc,cAAc,SAAS;EACvD,IAAI,cAAc,QAAW;EAE7B,EAAE,iBAAiB;EACnB,EAAE,kBAAkB;EAEpB,aAAa,SAAS;CACxB;CAEA,OAAO;EACL,WAAW,EACT,WAAW,cACb;EACA,OAAO,WAAmB;GACxB,UAAU,UAAU,eAAe,IAAI;GACvC,qBAAqB;EACvB;CACF;AACF"}

package/dist/foundations/state/controllable.d.ts

@@ -1,33 +0,0 @@
-import { State } from "../../runtime/state.js";
-//#region src/foundations/state/controllable.d.ts
-declare function isControlled<T>(value: T | undefined): value is T;
-declare function resolveControllable<T>(value: T | undefined, defaultValue: T): {
-  value: T;
-  isControlled: boolean;
-};
-declare function makeControllable<T>(options: {
-  value: T | undefined;
-  defaultValue: T;
-  onChange?: (next: T) => void;
-  setInternal?: (next: T) => void;
-}): {
-  set: (next: T) => void;
-  isControlled: boolean;
-};
-type ControllableState<T> = State<T> & {
-  isControlled: boolean;
-};
-/**
- * controllableState
- *
- * Hook-like primitive that mirrors `state()` semantics while supporting
- * controlled/uncontrolled behavior.
- */
-declare function controllableState<T>(options: {
-  value: T | undefined;
-  defaultValue: T;
-  onChange?: (next: T) => void;
-}): ControllableState<T>;
-//#endregion
-export { ControllableState, controllableState, isControlled, makeControllable, resolveControllable };
-//# sourceMappingURL=controllable.d.ts.map

package/dist/foundations/state/controllable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"controllable.d.ts","names":[],"sources":["../../../src/foundations/state/controllable.ts"],"mappings":";;iBA0BgB,YAAA,IAAgB,KAAA,EAAO,CAAA,eAAgB,KAAA,IAAS,CAAC;AAAA,iBAIjD,mBAAA,IACd,KAAA,EAAO,CAAA,cACP,YAAA,EAAc,CAAA;EACX,KAAA,EAAO,CAAA;EAAG,YAAA;AAAA;AAAA,iBAQC,gBAAA,IAAoB,OAAA;EAClC,KAAA,EAAO,CAAA;EACP,YAAA,EAAc,CAAA;EACd,QAAA,IAAY,IAAA,EAAM,CAAA;EAClB,WAAA,IAAe,IAAA,EAAM,CAAA;AAAA;cAKF,CAAA;;;KAYT,iBAAA,MAAuB,KAAK,CAAC,CAAA;EAAO,YAAA;AAAA;;;;;;;iBAQhC,iBAAA,IAAqB,OAAA;EACnC,KAAA,EAAO,CAAA;EACP,YAAA,EAAc,CAAA;EACd,QAAA,IAAY,IAAA,EAAM,CAAA;AAAA,IAChB,iBAAA,CAAkB,CAAA"}

package/dist/foundations/state/controllable.js

@@ -1,82 +0,0 @@
-import { state } from "../../runtime/state.js";
-import "../../runtime/index.js";
-//#region src/foundations/state/controllable.ts
-/**
-* controllable
-*
-* Small utilities for controlled vs uncontrolled components. These helpers are
-* intentionally minimal and do not manage state themselves; they help component
-* implementations make correct decisions about when to call `onChange` vs
-* update internal state.
-*
-* POLICY DECISIONS (LOCKED):
-*
-* 1. Controlled Detection
-*    A value is "controlled" if it is not `undefined`.
-*    This matches React conventions and is SSR-safe.
-*
-* 2. onChange Timing
-*    - Controlled mode: onChange called immediately, no internal update
-*    - Uncontrolled mode: internal state updated first, then onChange called
-*    This ensures onChange sees the new value in both modes.
-*
-* 3. Value Equality
-*    controllableState uses Object.is() to prevent unnecessary onChange calls.
-*    This is intentional — strict equality, no deep comparison.
-*/
-function isControlled(value) {
-	return value !== void 0;
-}
-function resolveControllable(value, defaultValue) {
-	const controlled = isControlled(value);
-	return {
-		value: controlled ? value : defaultValue,
-		isControlled: controlled
-	};
-}
-function makeControllable(options) {
-	const { value, defaultValue, onChange, setInternal } = options;
-	const { isControlled } = resolveControllable(value, defaultValue);
-	function set(next) {
-		if (isControlled) onChange?.(next);
-		else {
-			setInternal?.(next);
-			onChange?.(next);
-		}
-	}
-	return {
-		set,
-		isControlled
-	};
-}
-/**
-* controllableState
-*
-* Hook-like primitive that mirrors `state()` semantics while supporting
-* controlled/uncontrolled behavior.
-*/
-function controllableState(options) {
-	const isControlled = options.value !== void 0;
-	const internal = isControlled ? null : state(options.defaultValue);
-	function read() {
-		if (isControlled) return options.value;
-		return internal();
-	}
-	read.set = (nextOrUpdater) => {
-		const prev = read();
-		const next = typeof nextOrUpdater === "function" ? nextOrUpdater(prev) : nextOrUpdater;
-		if (Object.is(prev, next)) return;
-		if (isControlled) {
-			options.onChange?.(next);
-			return;
-		}
-		internal.set(nextOrUpdater);
-		options.onChange?.(next);
-	};
-	read.isControlled = isControlled;
-	return read;
-}
-//#endregion
-export { controllableState, isControlled, makeControllable, resolveControllable };
-
-//# sourceMappingURL=controllable.js.map

package/dist/foundations/state/controllable.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"controllable.js","names":[],"sources":["../../../src/foundations/state/controllable.ts"],"sourcesContent":["/**\n * controllable\n *\n * Small utilities for controlled vs uncontrolled components. These helpers are\n * intentionally minimal and do not manage state themselves; they help component\n * implementations make correct decisions about when to call `onChange` vs\n * update internal state.\n *\n * POLICY DECISIONS (LOCKED):\n *\n * 1. Controlled Detection\n *    A value is \"controlled\" if it is not `undefined`.\n *    This matches React conventions and is SSR-safe.\n *\n * 2. onChange Timing\n *    - Controlled mode: onChange called immediately, no internal update\n *    - Uncontrolled mode: internal state updated first, then onChange called\n *    This ensures onChange sees the new value in both modes.\n *\n * 3. Value Equality\n *    controllableState uses Object.is() to prevent unnecessary onChange calls.\n *    This is intentional — strict equality, no deep comparison.\n */\n\nimport { state, type State } from '../../runtime';\n\nexport function isControlled<T>(value: T | undefined): value is T {\n  return value !== undefined;\n}\n\nexport function resolveControllable<T>(\n  value: T | undefined,\n  defaultValue: T\n): { value: T; isControlled: boolean } {\n  const controlled = isControlled(value);\n  return {\n    value: controlled ? (value as T) : defaultValue,\n    isControlled: controlled,\n  };\n}\n\nexport function makeControllable<T>(options: {\n  value: T | undefined;\n  defaultValue: T;\n  onChange?: (next: T) => void;\n  setInternal?: (next: T) => void;\n}) {\n  const { value, defaultValue, onChange, setInternal } = options;\n  const { isControlled } = resolveControllable(value, defaultValue);\n\n  function set(next: T) {\n    if (isControlled) {\n      onChange?.(next);\n    } else {\n      setInternal?.(next);\n      onChange?.(next);\n    }\n  }\n\n  return { set, isControlled };\n}\n\nexport type ControllableState<T> = State<T> & { isControlled: boolean };\n\n/**\n * controllableState\n *\n * Hook-like primitive that mirrors `state()` semantics while supporting\n * controlled/uncontrolled behavior.\n */\nexport function controllableState<T>(options: {\n  value: T | undefined;\n  defaultValue: T;\n  onChange?: (next: T) => void;\n}): ControllableState<T> {\n  const isControlled = options.value !== undefined;\n  const internal = isControlled ? null : state<T>(options.defaultValue);\n\n  function read(): T {\n    if (isControlled) {\n      return options.value as T;\n    }\n\n    return internal!();\n  }\n\n  read.set = (nextOrUpdater: T | ((prev: T) => T)) => {\n    const prev = read();\n    const next =\n      typeof nextOrUpdater === 'function'\n        ? (nextOrUpdater as (p: T) => T)(prev)\n        : (nextOrUpdater as T);\n\n    if (Object.is(prev, next)) return;\n\n    if (isControlled) {\n      options.onChange?.(next);\n      return;\n    }\n\n    internal!.set(nextOrUpdater as never);\n    options.onChange?.(next);\n  };\n\n  (read as ControllableState<T>).isControlled = isControlled;\n  return read as ControllableState<T>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,aAAgB,OAAkC;CAChE,OAAO,UAAU;AACnB;AAEA,SAAgB,oBACd,OACA,cACqC;CACrC,MAAM,aAAa,aAAa,KAAK;CACrC,OAAO;EACL,OAAO,aAAc,QAAc;EACnC,cAAc;CAChB;AACF;AAEA,SAAgB,iBAAoB,SAKjC;CACD,MAAM,EAAE,OAAO,cAAc,UAAU,gBAAgB;CACvD,MAAM,EAAE,iBAAiB,oBAAoB,OAAO,YAAY;CAEhE,SAAS,IAAI,MAAS;EACpB,IAAI,cACF,WAAW,IAAI;OACV;GACL,cAAc,IAAI;GAClB,WAAW,IAAI;EACjB;CACF;CAEA,OAAO;EAAE;EAAK;CAAa;AAC7B;;;;;;;AAUA,SAAgB,kBAAqB,SAIZ;CACvB,MAAM,eAAe,QAAQ,UAAU;CACvC,MAAM,WAAW,eAAe,OAAO,MAAS,QAAQ,YAAY;CAEpE,SAAS,OAAU;EACjB,IAAI,cACF,OAAO,QAAQ;EAGjB,OAAO,SAAU;CACnB;CAEA,KAAK,OAAO,kBAAwC;EAClD,MAAM,OAAO,KAAK;EAClB,MAAM,OACJ,OAAO,kBAAkB,aACpB,cAA8B,IAAI,IAClC;EAEP,IAAI,OAAO,GAAG,MAAM,IAAI,GAAG;EAE3B,IAAI,cAAc;GAChB,QAAQ,WAAW,IAAI;GACvB;EACF;EAEA,SAAU,IAAI,aAAsB;EACpC,QAAQ,WAAW,IAAI;CACzB;CAEA,KAA+B,eAAe;CAC9C,OAAO;AACT"}

package/dist/foundations/structures/collection.d.ts

@@ -1,52 +0,0 @@
-//#region src/foundations/structures/collection.d.ts
-/**
- * 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>;
-//#endregion
-export { Collection, CollectionItem, createCollection };
-//# sourceMappingURL=collection.d.ts.map

package/dist/foundations/structures/collection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"collection.d.ts","names":[],"sources":["../../../src/foundations/structures/collection.ts"],"mappings":";;AAyBA;;;;;;;;;;;AAEqB;AAGrB;;;;;;;;;;;KALY,cAAA;EACV,IAAA,EAAM,KAAA;EACN,QAAA,EAAU,SAAS;AAAA;AAAA,UAGJ,UAAA;EAKiB;;;;EAAhC,QAAA,CAAS,IAAA,EAAM,KAAA,EAAO,QAAA,EAAU,SAAA;EAKM;;;EAAtC,KAAA,IAAS,aAAA,CAAc,cAAA,CAAe,KAAA,EAAO,SAAA;EAUzC;AAAA;AAGN;EARE,KAAA;EAQ8B;;;EAH9B,IAAA;AAAA;AAAA,iBAGc,gBAAA,gCAAgD,UAAA,CAC9D,KAAA,EACA,SAAA"}

package/dist/foundations/structures/collection.js

@@ -1,51 +0,0 @@
-//#region src/foundations/structures/collection.ts
-function createCollection() {
-	const registry = /* @__PURE__ */ new Map();
-	function register(node, metadata) {
-		const item = {
-			node,
-			metadata
-		};
-		registry.set(node, item);
-		return () => {
-			registry.delete(node);
-		};
-	}
-	function items() {
-		return Array.from(registry.values());
-	}
-	function clear() {
-		registry.clear();
-	}
-	function size() {
-		return registry.size;
-	}
-	return {
-		register,
-		items,
-		clear,
-		size
-	};
-}
-/**
-* USAGE EXAMPLE:
-*
-* // Create a collection for menu items
-* const menuItems = createCollection<HTMLElement, { disabled: boolean }>();
-*
-* // Register items
-* const unregister1 = menuItems.register(element1, { disabled: false });
-* const unregister2 = menuItems.register(element2, { disabled: true });
-*
-* // Query items
-* const allItems = menuItems.items();
-* const enabledItems = allItems.filter(item => !item.metadata.disabled);
-*
-* // Cleanup
-* unregister1();
-* unregister2();
-*/
-//#endregion
-export { createCollection };
-
-//# sourceMappingURL=collection.js.map

package/dist/foundations/structures/collection.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"collection.js","names":[],"sources":["../../../src/foundations/structures/collection.ts"],"sourcesContent":["/**\n * createCollection\n *\n * Ordered descendant registry for coordinating items without DOM queries.\n *\n * INVARIANTS:\n * 1. Registration order determines item order (no DOM queries)\n * 2. Stable ordering across renders (insertion order preserved)\n * 3. Each item may have metadata (type-safe, user-defined)\n * 4. No implicit global state (explicit collection instances)\n * 5. No automatic cleanup (caller controls lifecycle)\n *\n * DESIGN:\n * - Returns a registry API ({ register, items, clear })\n * - Items are stored in insertion order\n * - Registration returns an unregister function\n * - No side effects on registration (pure data structure)\n *\n * USAGE:\n *   const collection = createCollection<HTMLElement, { disabled: boolean }>();\n *   const unregister = collection.register(element, { disabled: false });\n *   const allItems = collection.items();\n *   unregister();\n */\n\nexport type CollectionItem<TNode, TMetadata = unknown> = {\n  node: TNode;\n  metadata: TMetadata;\n};\n\nexport interface Collection<TNode, TMetadata = unknown> {\n  /**\n   * Register a node with optional metadata.\n   * Returns an unregister function.\n   */\n  register(node: TNode, metadata: TMetadata): () => void;\n\n  /**\n   * Get all registered items in insertion order.\n   */\n  items(): ReadonlyArray<CollectionItem<TNode, TMetadata>>;\n\n  /**\n   * Clear all registered items.\n   */\n  clear(): void;\n\n  /**\n   * Get the count of registered items.\n   */\n  size(): number;\n}\n\nexport function createCollection<TNode, TMetadata = unknown>(): Collection<\n  TNode,\n  TMetadata\n> {\n  const registry = new Map<TNode, CollectionItem<TNode, TMetadata>>();\n\n  function register(node: TNode, metadata: TMetadata): () => void {\n    const item: CollectionItem<TNode, TMetadata> = { node, metadata };\n    registry.set(node, item);\n\n    return () => {\n      registry.delete(node);\n    };\n  }\n\n  function items(): ReadonlyArray<CollectionItem<TNode, TMetadata>> {\n    return Array.from(registry.values());\n  }\n\n  function clear(): void {\n    registry.clear();\n  }\n\n  function size(): number {\n    return registry.size;\n  }\n\n  return {\n    register,\n    items,\n    clear,\n    size,\n  };\n}\n\n/**\n * USAGE EXAMPLE:\n *\n * // Create a collection for menu items\n * const menuItems = createCollection<HTMLElement, { disabled: boolean }>();\n *\n * // Register items\n * const unregister1 = menuItems.register(element1, { disabled: false });\n * const unregister2 = menuItems.register(element2, { disabled: true });\n *\n * // Query items\n * const allItems = menuItems.items();\n * const enabledItems = allItems.filter(item => !item.metadata.disabled);\n *\n * // Cleanup\n * unregister1();\n * unregister2();\n */\n"],"mappings":";AAqDA,SAAgB,mBAGd;CACA,MAAM,2BAAW,IAAI,IAA6C;CAElE,SAAS,SAAS,MAAa,UAAiC;EAC9D,MAAM,OAAyC;GAAE;GAAM;EAAS;EAChE,SAAS,IAAI,MAAM,IAAI;EAEvB,aAAa;GACX,SAAS,OAAO,IAAI;EACtB;CACF;CAEA,SAAS,QAAyD;EAChE,OAAO,MAAM,KAAK,SAAS,OAAO,CAAC;CACrC;CAEA,SAAS,QAAc;EACrB,SAAS,MAAM;CACjB;CAEA,SAAS,OAAe;EACtB,OAAO,SAAS;CAClB;CAEA,OAAO;EACL;EACA;EACA;EACA;CACF;AACF"}