@askrjs/askr 0.0.52 → 0.0.54

package/dist/foundations/icon/index.d.ts

@@ -1,3 +1,69 @@
-import { IconOwnProps, IconProps, IconSizeToken, IconStyleObject } from "./icon.types.js";
-import { IconBase, getIconContractProps, isIconSizeToken, joinIconStyle, normalizeIconSizeValue, resolveIconSizeVariable, resolveIconStrokeWidthVariable, serializeIconStyle } from "./icon.js";
+import { r as JSXElement, s as Props } from "../../jsx-CP0gmYwJ.js";
+import { t as Ref } from "../../compose-ref-Cizq72-x.js";
+
+//#region src/foundations/icon/icon.types.d.ts
+type IconSizeToken = 'sm' | 'md' | 'lg' | 'xl';
+type IconStyleObject = Record<string, unknown>;
+type IconOwnProps = {
+  size?: number | string;
+  strokeWidth?: number;
+  color?: string;
+  title?: string;
+  class?: string;
+  style?: string | IconStyleObject;
+  iconName?: string;
+};
+type IconProps = Omit<Props, 'children' | 'class' | 'color' | 'height' | 'ref' | 'role' | 'stroke' | 'stroke-width' | 'style' | 'title' | 'width'> & IconOwnProps & {
+  children?: unknown;
+  ref?: Ref<SVGSVGElement>;
+};
+//#endregion
+//#region src/foundations/icon/icon.d.ts
+declare function isIconSizeToken(value: unknown): value is IconSizeToken;
+declare function normalizeIconSizeValue(size: number | string): string;
+declare function resolveIconSizeVariable(size: number | string): string;
+declare function resolveIconStrokeWidthVariable(strokeWidth: number, sizeToken: IconSizeToken | undefined): string;
+declare function serializeIconStyle(style: string | IconStyleObject | undefined): string;
+declare function joinIconStyle(...styles: Array<string | undefined>): string | undefined;
+declare function getIconContractProps({
+  size,
+  strokeWidth,
+  color,
+  title,
+  style,
+  iconName
+}: Pick<IconProps, 'color' | 'iconName' | 'size' | 'strokeWidth' | 'style' | 'title'>): {
+  sizeToken: IconSizeToken | undefined;
+  decorative: string | undefined;
+  iconStyle: string | undefined;
+  attrs: {
+    xmlns: string;
+    width: string;
+    height: string;
+    fill: string;
+    stroke: string;
+    'stroke-width': string;
+    role: string;
+    'aria-hidden': string | undefined;
+    style: string | undefined;
+    'data-slot': string;
+    'data-icon': string | undefined;
+    'data-size': IconSizeToken | undefined;
+    'data-decorative': string | undefined;
+    'data-color': string | undefined;
+  };
+};
+declare function IconBase({
+  size,
+  strokeWidth,
+  color,
+  title,
+  class: className,
+  style,
+  iconName,
+  children,
+  ref,
+  ...rest
+}: IconProps): JSXElement;
+//#endregion
 export { IconBase, type IconOwnProps, type IconProps, type IconSizeToken, type IconStyleObject, getIconContractProps, isIconSizeToken, joinIconStyle, normalizeIconSizeValue, resolveIconSizeVariable, resolveIconStrokeWidthVariable, serializeIconStyle };

package/dist/foundations/icon/index.js

@@ -1,2 +1,86 @@
-import { IconBase, getIconContractProps, isIconSizeToken, joinIconStyle, normalizeIconSizeValue, resolveIconSizeVariable, resolveIconStrokeWidthVariable, serializeIconStyle } from "./icon.js";
+import { jsx, jsxs } from "../../jsx-runtime.js";
+//#region src/foundations/icon/icon.tsx
+const ICON_SIZE_TOKENS = [
+	"sm",
+	"md",
+	"lg",
+	"xl"
+];
+function isIconSizeToken(value) {
+	return typeof value === "string" && ICON_SIZE_TOKENS.includes(value);
+}
+function normalizeIconSizeValue(size) {
+	if (typeof size === "number") return `${size}px`;
+	return size;
+}
+function resolveIconSizeVariable(size) {
+	if (isIconSizeToken(size)) return `var(--ak-icon-size-${size}, var(--ak-icon-size-md, 1.25rem))`;
+	return normalizeIconSizeValue(size);
+}
+function resolveIconStrokeWidthVariable(strokeWidth, sizeToken) {
+	if (sizeToken) return `var(--ak-icon-stroke-width-${sizeToken}, var(--ak-icon-stroke-width-md, ${strokeWidth}))`;
+	return `var(--ak-icon-stroke-width-md, ${strokeWidth})`;
+}
+function camelToKebab(key) {
+	return key.replace(/([A-Z])/g, (match) => `-${match.toLowerCase()}`);
+}
+function serializeIconStyle(style) {
+	if (!style) return "";
+	if (typeof style === "string") return style.trim();
+	return Object.entries(style).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => `${camelToKebab(key)}:${String(value)}`).join(";");
+}
+function joinIconStyle(...styles) {
+	const merged = styles.map((style) => style?.trim()).filter(Boolean);
+	return merged.length > 0 ? merged.join(";") : void 0;
+}
+function getIconContractProps({ size = 20, strokeWidth = 2, color = "currentColor", title, style, iconName }) {
+	const sizeToken = isIconSizeToken(size) ? size : void 0;
+	const decorative = title ? void 0 : "true";
+	const resolvedSize = resolveIconSizeVariable(size);
+	const resolvedStrokeWidth = resolveIconStrokeWidthVariable(strokeWidth, sizeToken);
+	const iconStyle = joinIconStyle(`--ak-icon-size:${resolvedSize}`, `--ak-icon-stroke-width:${resolvedStrokeWidth}`, "display:inline-block", "flex-shrink:0", "width:var(--ak-icon-size)", "height:var(--ak-icon-size)", "stroke-width:var(--ak-icon-stroke-width)", serializeIconStyle(style));
+	return {
+		sizeToken,
+		decorative,
+		iconStyle,
+		attrs: {
+			xmlns: "http://www.w3.org/2000/svg",
+			width: "24",
+			height: "24",
+			fill: "none",
+			stroke: color,
+			"stroke-width": "var(--ak-icon-stroke-width)",
+			role: "img",
+			"aria-hidden": title ? void 0 : "true",
+			style: iconStyle,
+			"data-slot": "icon",
+			"data-icon": iconName,
+			"data-size": sizeToken,
+			"data-decorative": decorative,
+			"data-color": color === "currentColor" ? "current" : void 0
+		}
+	};
+}
+function IconBase({ size = 20, strokeWidth = 2, color = "currentColor", title, class: className, style, iconName, children, ref, ...rest }) {
+	const { attrs } = getIconContractProps({
+		size,
+		strokeWidth,
+		color,
+		title,
+		style,
+		iconName
+	});
+	const finalChildren = title ? [jsx("title", { children: title }), children] : children;
+	return jsxs("svg", {
+		...rest,
+		...attrs,
+		viewBox: rest.viewBox ?? "0 0 24 24",
+		"stroke-linecap": rest["stroke-linecap"] ?? "round",
+		"stroke-linejoin": rest["stroke-linejoin"] ?? "round",
+		class: className,
+		ref,
+		children: finalChildren
+	});
+}
+//#endregion
 export { IconBase, getIconContractProps, isIconSizeToken, joinIconStyle, normalizeIconSizeValue, resolveIconSizeVariable, resolveIconStrokeWidthVariable, serializeIconStyle };

package/dist/foundations/index.d.ts

@@ -1,6 +1,3 @@
-import { JSXElement } from "../common/jsx.js";
-import { DefaultPortal, Portal, PortalProps, definePortal } from "../runtime/portal.js";
-import { LayoutComponent, layout } from "./structures/layout.js";
-import { Slot, SlotProps } from "./structures/slot.js";
-import { Presence, PresenceProps } from "./structures/presence.js";
+import { r as JSXElement } from "../jsx-CP0gmYwJ.js";
+import { _ as definePortal, c as Presence, d as SlotProps, f as LayoutComponent, g as PortalProps, h as Portal, l as PresenceProps, m as DefaultPortal, p as layout, u as Slot } from "../index-B1LNotpU.js";
 export { DefaultPortal, type JSXElement, type LayoutComponent, Portal, type PortalProps, Presence, type PresenceProps, Slot, type SlotProps, definePortal, layout };

package/dist/foundations/index.js

@@ -1,6 +1,3 @@
-import { DefaultPortal, Portal, definePortal } from "../runtime/portal.js";
-import { layout } from "./structures/layout.js";
-import { Slot } from "./structures/slot.js";
-import { Presence } from "./structures/presence.js";
-import "./structures/index.js";
+import { i as definePortal, n as Portal, t as DefaultPortal } from "../portal-C47xkwXj.js";
+import { a as layout, i as Slot, r as Presence } from "../structures-DUB3HchX.js";
 export { DefaultPortal, Portal, Presence, Slot, definePortal, layout };

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

@@ -1,7 +1,265 @@
-import { PressableOptions, PressableResult, pressable } from "./pressable.js";
-import { DismissableOptions, dismissable } from "./dismissable.js";
-import { FocusableOptions, FocusableResult, focusable } from "./focusable.js";
-import { HoverableOptions, HoverableResult, hoverable } from "./hoverable.js";
-import { Orientation, RovingFocusOptions, RovingFocusResult, rovingFocus } from "./roving-focus.js";
-import { InteractionPolicyInput, applyInteractionPolicy, mergeInteractionProps } from "./interaction-policy.js";
+import { t as Ref } from "../../compose-ref-Cizq72-x.js";
+import { d as KeyboardLikeEvent, f as PointerLikeEvent, l as DefaultPreventable, p as PropagationStoppable } from "../../index-BnU0NPwM.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
+//#region src/foundations/interactions/dismissable.d.ts
+/**
+ * dismissable
+ *
+ * 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 the protected node reference for outside detection
+ * - Returned capture props must be attached to a surface that can observe both
+ *   the protected subtree and the outside interaction path (for example, an
+ *   overlay or wrapper around the protected node)
+ * - 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 {...props}>
+ *     <div ref={elementRef}>Content</div>
+ *   </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 {
+  /**
+   * Reference to the protected element for outside click detection. Attach the
+   * returned capture props to a surface that encloses this node.
+   */
+  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({
+  node,
+  disabled,
+  onDismiss
+}: DismissableOptions): {
+  onKeyDown: (e: KeyboardLikeEvent) => void;
+  onPointerDownCapture: (e: PointerLikeEvent) => void;
+};
+//#endregion
+//#region src/foundations/interactions/focusable.d.ts
+/**
+ * focusable
+ *
+ * Normalize focus-related props for hosts.
+ * - No DOM manipulation here; returns props that the runtime may attach.
+ */
+interface FocusableOptions {
+  disabled?: boolean;
+  tabIndex?: number | undefined;
+}
+interface FocusableResult {
+  tabIndex?: number;
+  'aria-disabled'?: 'true';
+}
+declare function focusable({
+  disabled,
+  tabIndex
+}: FocusableOptions): FocusableResult;
+//#endregion
+//#region src/foundations/interactions/hoverable.d.ts
+/**
+ * hoverable
+ *
+ * Produces props for pointer enter/leave handling. Pure and deterministic.
+ */
+interface HoverableOptions {
+  disabled?: boolean;
+  onEnter?: (e: HoverEvent) => void;
+  onLeave?: (e: HoverEvent) => void;
+}
+type HoverEvent = DefaultPreventable & PropagationStoppable;
+interface HoverableResult {
+  onPointerEnter?: (e: HoverEvent) => void;
+  onPointerLeave?: (e: HoverEvent) => void;
+}
+declare function hoverable({
+  disabled,
+  onEnter,
+  onLeave
+}: HoverableOptions): HoverableResult;
+//#endregion
+//#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
+//#region src/foundations/interactions/interaction-policy.d.ts
+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?: Ref<unknown>;
+}
+/**
+ * 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: Ref<unknown>;
+} | {
+  tabIndex: number;
+  ref: Ref<unknown>;
+  'aria-disabled'?: "true";
+  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, unknown>, policyProps: Record<string, unknown>, userProps?: Record<string, unknown>): Record<string, unknown>;
+//#endregion
 export { type DismissableOptions, type FocusableOptions, type FocusableResult, type HoverableOptions, type HoverableResult, type InteractionPolicyInput, type Orientation, type PressableOptions, type PressableResult, type RovingFocusOptions, type RovingFocusResult, applyInteractionPolicy, dismissable, focusable, hoverable, mergeInteractionProps, pressable, rovingFocus };

package/dist/foundations/interactions/index.js

@@ -1,7 +1,2 @@
-import { pressable } from "./pressable.js";
-import { dismissable } from "./dismissable.js";
-import { focusable } from "./focusable.js";
-import { hoverable } from "./hoverable.js";
-import { rovingFocus } from "./roving-focus.js";
-import { applyInteractionPolicy, mergeInteractionProps } from "./interaction-policy.js";
+import { a as focusable, i as hoverable, n as mergeInteractionProps, o as dismissable, r as rovingFocus, s as pressable, t as applyInteractionPolicy } from "../../interactions-w7gQN4ha.js";
 export { applyInteractionPolicy, dismissable, focusable, hoverable, mergeInteractionProps, pressable, rovingFocus };

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

@@ -1,2 +1,33 @@
-import { ControllableState, controllableState, isControlled, makeControllable, resolveControllable } from "./controllable.js";
+import { m as State } from "../../control-BI4RMD2z.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 { type ControllableState, controllableState, isControlled, makeControllable, resolveControllable };

package/dist/foundations/state/index.js

@@ -1,2 +1,79 @@
-import { controllableState, isControlled, makeControllable, resolveControllable } from "./controllable.js";
+import { t as state } from "../../state-DPl8lffD.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 };

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

@@ -1,8 +1,3 @@
-import { JSXElement } from "../../common/jsx.js";
-import { DefaultPortal, Portal, PortalProps, definePortal } from "../../runtime/portal.js";
-import { LayoutComponent, layout } from "./layout.js";
-import { Slot, SlotProps } from "./slot.js";
-import { Presence, PresenceProps } from "./presence.js";
-import { Collection, CollectionItem, createCollection } from "./collection.js";
-import { Layer, LayerManager, LayerOptions, createLayer } from "./layer.js";
+import { r as JSXElement } from "../../jsx-CP0gmYwJ.js";
+import { _ as definePortal, a as Collection, c as Presence, d as SlotProps, f as LayoutComponent, g as PortalProps, h as Portal, i as createLayer, l as PresenceProps, m as DefaultPortal, n as LayerManager, o as CollectionItem, p as layout, r as LayerOptions, s as createCollection, t as Layer, u as Slot } from "../../index-B1LNotpU.js";
 export { type Collection, type CollectionItem, DefaultPortal, type JSXElement, type Layer, type LayerManager, type LayerOptions, type LayoutComponent, Portal, type PortalProps, Presence, type PresenceProps, Slot, type SlotProps, createCollection, createLayer, definePortal, layout };

package/dist/foundations/structures/index.js

@@ -1,8 +1,3 @@
-import { DefaultPortal, Portal, definePortal } from "../../runtime/portal.js";
-import { layout } from "./layout.js";
-import { Slot } from "./slot.js";
-import { Presence } from "./presence.js";
-import "./portal.js";
-import { createCollection } from "./collection.js";
-import { createLayer } from "./layer.js";
+import { i as definePortal, n as Portal, t as DefaultPortal } from "../../portal-C47xkwXj.js";
+import { a as layout, i as Slot, n as createCollection, r as Presence, t as createLayer } from "../../structures-DUB3HchX.js";
 export { DefaultPortal, Portal, Presence, Slot, createCollection, createLayer, definePortal, layout };

package/dist/foundations/utilities/index.d.ts

@@ -1,7 +1,3 @@
-import { Ref, composeRefs, setRef } from "./compose-ref.js";
-import { DefaultPreventable, FocusLikeEvent, KeyboardLikeEvent, PointerLikeEvent, PropagationStoppable } from "./event-types.js";
-import { ComposeHandlersOptions, composeHandlers } from "./compose-handlers.js";
-import { mergeProps } from "./merge-props.js";
-import { ariaDisabled, ariaExpanded, ariaSelected } from "./aria.js";
-import { FormatIdOptions, formatId } from "./use-id.js";
+import { n as composeRefs, r as setRef, t as Ref } from "../../compose-ref-Cizq72-x.js";
+import { a as ariaSelected, c as composeHandlers, d as KeyboardLikeEvent, f as PointerLikeEvent, i as ariaExpanded, l as DefaultPreventable, n as formatId, o as mergeProps, p as PropagationStoppable, r as ariaDisabled, s as ComposeHandlersOptions, t as FormatIdOptions, u as FocusLikeEvent } from "../../index-BnU0NPwM.js";
 export { type ComposeHandlersOptions, type DefaultPreventable, type FocusLikeEvent, type FormatIdOptions, type KeyboardLikeEvent, type PointerLikeEvent, type PropagationStoppable, type Ref, ariaDisabled, ariaExpanded, ariaSelected, composeHandlers, composeRefs, formatId, mergeProps, setRef };

package/dist/foundations/utilities/index.js

@@ -1,6 +1,3 @@
-import { composeHandlers } from "./compose-handlers.js";
-import { mergeProps } from "./merge-props.js";
-import { ariaDisabled, ariaExpanded, ariaSelected } from "./aria.js";
-import { composeRefs, setRef } from "./compose-ref.js";
-import { formatId } from "./use-id.js";
+import { a as ariaSelected, i as ariaExpanded, n as setRef, o as mergeProps, r as ariaDisabled, s as composeHandlers, t as composeRefs } from "../../compose-ref-Cc_YkUpM.js";
+import { t as formatId } from "../../utilities-C_CGX4Dz.js";
 export { ariaDisabled, ariaExpanded, ariaSelected, composeHandlers, composeRefs, formatId, mergeProps, setRef };