@mkbabb/glass-ui 0.2.0 → 2.0.0

package/dist/composables/motion/useSpring.d.ts

@@ -0,0 +1,66 @@
+import { type MaybeRefOrGetter, type Ref } from "vue";
+export interface UseSpringOptions {
+    /**
+     * Angular period of oscillation in seconds. Roughly: how long the spring
+     * takes to swing through one cycle if undamped. Default 0.5 (iOS smooth).
+     */
+    response?: number;
+    /**
+     * Damping ratio ζ. `1` is critically damped (fastest settle, no
+     * overshoot); `< 1` rings (overshoots target); `> 1` is overdamped
+     * (sluggish, monotone). Default 0.86 (iOS smooth preset).
+     */
+    dampingFraction?: number;
+    /** Starting position. Default 0. */
+    initial?: number;
+    /** Starting velocity (units/s). Default 0. */
+    initialVelocity?: number;
+    /**
+     * Position settle threshold. When |value - target| AND |velocity| both
+     * drop below their respective thresholds, the spring snaps to target
+     * and stops integrating. Default 1e-3.
+     */
+    settleThreshold?: number;
+    /** Velocity settle threshold (units/s). Default 1e-3. */
+    velocitySettleThreshold?: number;
+    /**
+     * Honor `prefers-reduced-motion: reduce` by snapping to target
+     * immediately rather than springing. Default true.
+     */
+    respectReducedMotion?: boolean;
+    /** Per-frame side-effect hook. Receives the current spring value. */
+    onValue?: (value: number, velocity: number) => void;
+}
+export interface SpringRef {
+    /** Reactive spring position. Bind in templates. */
+    value: Readonly<Ref<number>>;
+    /** Reactive spring velocity (units/s). */
+    velocity: Readonly<Ref<number>>;
+    /** True when the spring has settled at target. */
+    isSettled: Readonly<Ref<boolean>>;
+    /** Force value to target immediately and stop the loop. */
+    snap: () => void;
+    /** Reset value + velocity (default 0/0), then stop the loop. */
+    reset: (value?: number, velocity?: number) => void;
+    /** Stop the spring and detach the target watcher. */
+    dispose: () => void;
+}
+/**
+ * Track a live numeric target with iOS-style spring physics.
+ *
+ * Wraps `SpringProgress.play(onFrame)` from `@mkbabb/keyframes.js`. The
+ * engine owns rAF + analytic ODE integration; this composable wires the
+ * reactive surface, target-source tracking, and PRM fast-path.
+ *
+ * @example
+ * ```ts
+ * const target = ref(0)
+ * const { value, isSettled } = useSpring(target, {
+ *   response: 0.4,
+ *   dampingFraction: 0.7,
+ * })
+ * // ...
+ * target.value = 100  // value damps toward 100 with overshoot per ζ
+ * ```
+ */
+export declare function useSpring(target: MaybeRefOrGetter<number | null | undefined>, options?: UseSpringOptions): SpringRef;

package/dist/composables/motion/useSpringMount.d.ts

@@ -0,0 +1,52 @@
+import { type Ref } from "vue";
+import { type SpringRef } from "./useSpring";
+/** Named iOS spring presets (mirrors X1 §2.3 / tokens.css §2). */
+export type SpringPreset = "smooth" | "snappy" | "bouncy" | "gentle";
+export interface UseSpringMountOptions {
+    /**
+     * Reactive open-state mirror from the host's DialogContext. Accepts
+     * both `Ref<boolean>` and `Readonly<Ref<boolean>>` — reka-ui's
+     * DialogContext exposes the readonly variant; our internal use of
+     * `.value` is read-only here, so the Readonly satisfies the contract.
+     */
+    open: Readonly<Ref<boolean>>;
+    /** Preset name (default `smooth`). */
+    preset?: SpringPreset;
+    /** Honor `prefers-reduced-motion`. Default true. */
+    respectReducedMotion?: boolean;
+    /**
+     * Dismiss-position threshold as a fraction of full travel. When pointer
+     * release crosses this, the target snaps to 1 and on-settle fires
+     * `onDismiss`. Default 0.3 (iOS sheet convention).
+     */
+    dismissThreshold?: number;
+    /** Called once the dismiss-spring has settled. Wire to `onOpenChange(false)`. */
+    onDismiss?: () => void;
+}
+export interface SpringMountRef {
+    /** Position 0 (mounted) → 1 (dismissed). Bind to `transform: translateY` or scale. */
+    position: SpringRef["value"];
+    /** True while pointer is actively dragging. */
+    isDragging: Readonly<Ref<boolean>>;
+    /**
+     * Pointer handlers for the Sheet drag-dismiss gesture. Spread onto the
+     * sheet content (`v-bind="dragHandlers"`). Pass a getter for the sheet
+     * height so the threshold is computed against real pixels.
+     */
+    dragHandlers: {
+        onPointerdown: (e: PointerEvent) => void;
+        onPointermove: (e: PointerEvent) => void;
+        onPointerup: (e: PointerEvent) => void;
+        onPointercancel: (e: PointerEvent) => void;
+    };
+}
+/**
+ * Spring-driven mount with optional pointer drag-dismiss.
+ *
+ * The spring target lives between 0 (fully mounted) and 1 (fully dismissed).
+ * The host watches `open` to seat the entrance (1 → 0). Pointer drags
+ * re-seat the target mid-flight; on release the threshold decides bounce
+ * vs. dismiss. The mid-flight re-target preserves spring continuity per
+ * SpringProgress (G-W2-3 verified).
+ */
+export declare function useSpringMount(options: UseSpringMountOptions): SpringMountRef;

package/dist/composables/motion/useSpringOrchestrator.d.ts

@@ -0,0 +1,15 @@
+import { useNumericTransition, type SpringSnapshot, type UseNumericTransitionOptions } from "./useNumericTransition";
+/**
+ * @deprecated Renamed to `useNumericTransition` at AL.W9-δ to reclaim the
+ * "spring" name for the physics-based `useSpring` composable. This shim
+ * resolves to the same implementation and will be removed at the next
+ * major version (v3.0). Migrate to `useNumericTransition`.
+ */
+export declare const useSpringOrchestrator: typeof useNumericTransition;
+/**
+ * @deprecated Renamed to `UseNumericTransitionOptions` at AL.W9-δ. This
+ * shim will be removed at the next major version (v3.0). Migrate to
+ * `UseNumericTransitionOptions`.
+ */
+export type UseSpringOrchestratorOptions<K extends string> = UseNumericTransitionOptions<K>;
+export type { SpringSnapshot };

package/dist/composables/motion/useSpringPress.d.ts

@@ -0,0 +1,46 @@
+import { type UseSpringOptions, type SpringRef } from "./useSpring";
+export interface UseSpringPressOptions extends UseSpringOptions {
+    /**
+     * Spring `response`. Default 0.25s (iOS tap-press canonical; faster
+     * than the default `useSpring` 0.5s to keep press feedback under the
+     * 100ms perception threshold).
+     */
+    response?: number;
+    /**
+     * Spring `dampingFraction`. Default 0.7 (overshoots ~5% — feels
+     * springy but doesn't ring).
+     */
+    dampingFraction?: number;
+}
+export interface SpringPressRef extends SpringRef {
+    /** Call on `pointerdown`. Drives target to 1. */
+    press: () => void;
+    /** Call on `pointerup` / `pointercancel` / `pointerleave`. Drives target to 0. */
+    release: () => void;
+    /** Convenience: handlers ready to spread onto an element. */
+    handlers: {
+        onPointerdown: () => void;
+        onPointerup: () => void;
+        onPointercancel: () => void;
+        onPointerleave: () => void;
+    };
+}
+/**
+ * Spring-physics press feedback. Returns a `value` ref animating between
+ * 0 (released) and 1 (pressed) with iOS-style overshoot, plus handlers
+ * to wire into an element's pointer events.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * const { value, handlers } = useSpringPress()
+ * </script>
+ * <template>
+ *   <button
+ *     v-bind="handlers"
+ *     :style="{ transform: `scale(${1 - value * 0.05})` }"
+ *   />
+ * </template>
+ * ```
+ */
+export declare function useSpringPress(options?: UseSpringPressOptions): SpringPressRef;

package/dist/composables/motion/useStagger.d.ts

@@ -0,0 +1,50 @@
+import { type Ref } from "vue";
+export interface UseStaggerOptions {
+    /** Count of staggered slots. Each slot maps to one boolean in `revealed`. */
+    items: number;
+    /**
+     * Delay between consecutive reveals.
+     *
+     * Default 80ms — mirrors the `--motion-stagger-default` token in
+     * `tokens.css` (AJ-W4-κ canon). Consumers driving per-row CSS
+     * `animation-delay` cascades on the same surface should also read
+     * `--motion-stagger-default` so the JS-driven cascade (this composable)
+     * and the CSS-driven cascade stay in lockstep.
+     *
+     * The two adjacent canon tiers are:
+     *   - `--motion-stagger-tight: 40ms` — dense row cascades
+     *   - `--motion-stagger-relaxed: 120ms` — wide series cascades
+     */
+    delayMs?: number;
+    /** Delay before the first reveal fires. Default 0. */
+    initialDelayMs?: number;
+    /** Auto-start on creation. Default true. */
+    immediate?: boolean;
+    /**
+     * When true, honour `prefers-reduced-motion: reduce` by flipping every
+     * slot true synchronously instead of cascading the timeline. Mirrors
+     * the canonical opt-in on `useAnimatedNumber` and the global
+     * `transitions.css` / `utilities.css` reduced-motion brackets. SSR
+     * environments (no `window.matchMedia`) treat the option as a no-op.
+     * Default true.
+     */
+    respectReducedMotion?: boolean;
+}
+export interface UseStaggerControls {
+    /** Per-slot reveal state. `revealed.value[i]` flips true at `initialDelayMs + i * delayMs`. */
+    revealed: Ref<boolean[]>;
+    /** Re-arm the cascade. Resets `revealed` to all-false then fires the timeline. */
+    start: () => void;
+    /** Reset to all-false. Cancels any pending reveals. */
+    reset: () => void;
+    /** True once every slot has flipped. */
+    isComplete: Ref<boolean>;
+}
+/**
+ * Drive a fixed-count staggered reveal off a single timer cascade.
+ *
+ * @example
+ * const { revealed, start } = useStagger({ items: visible.value.length, delayMs: 80, initialDelayMs: 80, immediate: false });
+ * watch(allComplete, (done, prev) => { if (done && !prev) start(); });
+ */
+export declare function useStagger(options: UseStaggerOptions): UseStaggerControls;

package/dist/composables/motion/useStaggerReveal.d.ts

@@ -0,0 +1,22 @@
+interface StaggerRevealConfig {
+    /** Delay between each target becoming `revealed`. Default 60ms. */
+    staggerMs?: number;
+    /** When true (default), a target stays revealed after first entering the viewport. */
+    once?: boolean;
+    /** IntersectionObserver rootMargin. Default `0px`. */
+    rootMargin?: string;
+    /** IntersectionObserver threshold. Default 0.15. */
+    threshold?: number;
+}
+/**
+ * Sequence entrance animations for a list/grid. Each registered target
+ * gets a staggered `revealed` flag once it crosses the viewport threshold.
+ * Consumers bind the flag to a Tailwind class (e.g. `opacity-100 translate-y-0`)
+ * and let CSS transitions handle the visual entry.
+ */
+export declare function useStaggerReveal(options?: StaggerRevealConfig): {
+    targets: import("vue").Ref<HTMLElement[], HTMLElement[]>;
+    register: (el: HTMLElement | null, index?: number) => void;
+    revealed: Record<number, boolean>;
+};
+export {};

package/dist/composables/reactive/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./useInterval";
+export * from "./useTimer";

package/dist/composables/reactive/useInterval.d.ts

@@ -0,0 +1,24 @@
+import { type Ref } from "vue";
+export interface UseIntervalOptions {
+    /** Start the interval immediately. Default: true. */
+    immediate?: boolean;
+}
+export interface UseIntervalControls {
+    /** True while an interval is running. */
+    readonly isActive: Readonly<Ref<boolean>>;
+    /** Start the interval, replacing any running interval. */
+    start: (delay?: number) => void;
+    /** Alias for start(). */
+    restart: (delay?: number) => void;
+    /** Stop the running interval. */
+    stop: () => void;
+    /** Alias for stop(), useful when replacing clearInterval(). */
+    clear: () => void;
+}
+/**
+ * Vue-scope-aware setInterval replacement.
+ *
+ * Safe to call outside setup/effect scopes. In a scope it auto-cleans on
+ * disposal; outside a scope callers use the returned controls explicitly.
+ */
+export declare function useInterval(callback: () => void, delay?: number, options?: UseIntervalOptions): UseIntervalControls;

package/dist/composables/reactive/useTimer.d.ts

@@ -0,0 +1,24 @@
+import { type Ref } from "vue";
+export interface UseTimerOptions {
+    /** Start the timeout immediately. Default: true. */
+    immediate?: boolean;
+}
+export interface UseTimerControls {
+    /** True while a timeout is pending. */
+    readonly isActive: Readonly<Ref<boolean>>;
+    /** Schedule the timeout, replacing any pending timeout. */
+    start: (delay?: number) => void;
+    /** Alias for start(). */
+    restart: (delay?: number) => void;
+    /** Cancel the pending timeout. */
+    stop: () => void;
+    /** Alias for stop(), useful when replacing clearTimeout(). */
+    clear: () => void;
+}
+/**
+ * Vue-scope-aware setTimeout replacement.
+ *
+ * Safe to call outside setup/effect scopes. In a scope it auto-cleans on
+ * disposal; outside a scope callers use the returned controls explicitly.
+ */
+export declare function useTimer(callback: () => void, delay?: number, options?: UseTimerOptions): UseTimerControls;

package/dist/composables/sidebar/index.d.ts

@@ -0,0 +1,7 @@
+export { useScrollTracker } from "./useScrollTracker";
+export { useSidebarFollow } from "./useSidebarFollow";
+export type { SidebarFollowOptions } from "./useSidebarFollow";
+export { useSidebarState } from "./useSidebarState";
+export type { UseSidebarStateOptions, GenericSidebarState } from "./useSidebarState";
+export { useTreeIndex, buildTreeIndex, isActive, isInActiveChain } from "./useTreeIndex";
+export type { TreeNode, TreeIndexEntry, SidebarSection, SidebarIndexEntry, SidebarState, ScrollTrackerOptions, } from "./types";

package/dist/composables/sidebar/types.d.ts

@@ -0,0 +1,44 @@
+import type { Ref, ComputedRef } from "vue";
+/** Minimal interface for tree-structured content with scroll targets. */
+export interface TreeNode {
+    id: string;
+    children?: TreeNode[];
+}
+/** Generic flat index entry for a tree node. */
+export interface TreeIndexEntry<T extends TreeNode = TreeNode> {
+    node: T;
+    depth: number;
+    /** ID of the root-level ancestor (self.id when depth === 0). */
+    rootId: string;
+    /** Direct parent ID (self.id for root nodes). */
+    parentId: string | null;
+    /** Index within root-level nodes. */
+    rootIndex: number;
+}
+/** A section in the sidebar tree. */
+export interface SidebarSection extends TreeNode {
+    title: string;
+    children?: SidebarSection[];
+    level?: number;
+}
+/** Flat index entry for a sidebar section. */
+export type SidebarIndexEntry = TreeIndexEntry<SidebarSection>;
+/** Options for scroll tracking. */
+export interface ScrollTrackerOptions {
+    /** IntersectionObserver rootMargin. Default: "-20% 0px -60% 0px" */
+    rootMargin?: string;
+    threshold?: number;
+}
+/** Reactive state returned by `useSidebarState`. */
+export interface SidebarState {
+    sections: SidebarSection[];
+    activeId: Ref<string | null>;
+    activeRootId: ComputedRef<string | null>;
+    treeIndex: Map<string, SidebarIndexEntry>;
+    isExpanded(id: string): boolean;
+    toggleSection(id: string): void;
+    navigateTo(id: string): void;
+    scrollToTop(): void;
+    isActive(id: string): boolean;
+    isInActiveChain(id: string): boolean;
+}

package/dist/composables/sidebar/useScrollTracker.d.ts

@@ -0,0 +1,12 @@
+import type { MaybeRefOrGetter, Ref } from "vue";
+import type { TreeNode, TreeIndexEntry, ScrollTrackerOptions } from "./types";
+export declare function useScrollTracker<T extends TreeNode>(roots: MaybeRefOrGetter<T[]>, index: MaybeRefOrGetter<Map<string, TreeIndexEntry<T>>>, options?: ScrollTrackerOptions & {
+    getChildren?: (node: T) => T[] | undefined;
+    scrollContainer?: Ref<HTMLElement | null>;
+}): {
+    activeId: Ref<string | null, string | null>;
+    activeRootId: import("vue").ComputedRef<string | null>;
+    forceRecalculate: () => void;
+    lockTracking: () => void;
+    unlockTracking: () => void;
+};

package/dist/composables/sidebar/useSidebarFollow.d.ts

@@ -0,0 +1,16 @@
+import type { Ref } from "vue";
+export interface SidebarFollowOptions {
+    /** The sidebar nav element to auto-scroll. */
+    sidebarEl: Ref<HTMLElement | null>;
+    /** Currently active section ID. */
+    activeId: Ref<string | null>;
+    /** Currently active root section ID. */
+    activeRootId?: Ref<string | null>;
+    /** External scroll source (page container) to listen to. */
+    scrollSource?: Ref<HTMLElement | null>;
+    /** Damping factor (0-1, default 0.22). Lower = slower approach. */
+    damping?: number;
+}
+export declare function useSidebarFollow(options: SidebarFollowOptions): {
+    queueSidebarFollow: (immediate?: boolean) => void;
+};

package/dist/composables/sidebar/useSidebarState.d.ts

@@ -0,0 +1,39 @@
+import type { Ref, MaybeRefOrGetter } from "vue";
+import type { TreeNode, TreeIndexEntry, SidebarSection, SidebarState } from "./types";
+export interface UseSidebarStateOptions<T extends TreeNode = SidebarSection> {
+    sections: T[];
+    /**
+     * Currently active leaf section id. Accepts a `Ref`, a getter, or a raw
+     * value — `toValue` is applied internally so cross-package Vue version
+     * skew doesn't impose a `Ref` symbol-identity check at the call site.
+     */
+    activeId: MaybeRefOrGetter<string | null>;
+    /** Currently active root-level section id. Same `MaybeRefOrGetter` shape. */
+    activeRootId: MaybeRefOrGetter<string | null>;
+    scrollTo: (id: string) => void;
+    scrollToTop: () => void;
+    /**
+     * Optional accessor for child nodes. Defaults to `node.children`.
+     * Pass when your tree stores children under a different property
+     * (e.g. `subsections`) — symmetric with `useTreeIndex` / `useScrollTracker`.
+     */
+    getChildren?: (node: T) => T[] | undefined;
+}
+/**
+ * Generic return shape — when called with a custom `T`, `treeIndex` is keyed
+ * to `TreeIndexEntry<T>` rather than the canonical `SidebarIndexEntry`.
+ */
+export interface GenericSidebarState<T extends TreeNode> {
+    sections: T[];
+    activeId: Ref<string | null>;
+    activeRootId: import("vue").ComputedRef<string | null>;
+    treeIndex: Map<string, TreeIndexEntry<T>>;
+    isExpanded(id: string): boolean;
+    toggleSection(id: string): void;
+    navigateTo(id: string): void;
+    scrollToTop(): void;
+    isActive(id: string): boolean;
+    isInActiveChain(id: string): boolean;
+}
+export declare function useSidebarState(options: UseSidebarStateOptions<SidebarSection>): SidebarState;
+export declare function useSidebarState<T extends TreeNode>(options: UseSidebarStateOptions<T>): GenericSidebarState<T>;

package/dist/composables/sidebar/useTreeIndex.d.ts

@@ -0,0 +1,37 @@
+import type { TreeNode, TreeIndexEntry, SidebarSection, SidebarIndexEntry } from "./types";
+/**
+ * Builds a flat index of all nodes in a tree for O(1) lookup with hierarchy
+ * metadata.  Returns the index plus `isActive`, `isInActiveChain`, and
+ * `isDescendant` helpers that close over the index.
+ *
+ * Accepts an optional `getChildren` callback so callers with custom tree
+ * shapes (e.g. nodes whose children live under a different property name)
+ * don't need to conform to `TreeNode.children`.
+ */
+export declare function useTreeIndex<T extends TreeNode>(roots: T[], options?: {
+    getChildren?: (node: T) => T[] | undefined;
+}): {
+    index: Map<string, TreeIndexEntry<T>>;
+    isActive: (id: string, activeId: string | null) => boolean;
+    isInActiveChain: (id: string, activeId: string | null) => boolean;
+    isDescendant: (childId: string, ancestorId: string) => boolean;
+};
+/**
+ * Builds a flat index of all nodes in a sidebar tree for O(1) lookup with
+ * hierarchy metadata. Pure function, no Vue reactivity.
+ */
+export declare function buildTreeIndex(roots: SidebarSection[]): Map<string, SidebarIndexEntry>;
+/**
+ * Check if `id` is the active section.
+ *
+ * Pure-function variant for non-reactive callers. The composable returned by
+ * `useTreeIndex` includes the same helper.
+ */
+export declare function isActive(id: string, activeId: string | null): boolean;
+/**
+ * Check if `id` is an ancestor of or equal to `activeId`.
+ *
+ * Pure-function variant for non-reactive callers. The composable returned by
+ * `useTreeIndex` includes the same helper.
+ */
+export declare function isInActiveChain(id: string, activeId: string | null, index: Map<string, SidebarIndexEntry>, _roots: SidebarSection[]): boolean;

package/dist/composables/sortable/index.d.ts

@@ -0,0 +1 @@
+export { useSortable, type UseSortableReturn, type SortableId, } from "./useSortable";

package/dist/composables/sortable/useSortable.d.ts

@@ -0,0 +1,149 @@
+/**
+ * useSortable — pointer-capture drag-reorder for Vue lists.
+ *
+ * Headless composable that owns all pointer handling, drop-target
+ * resolution, splice math, AND a DOM-clone drag ghost. Consumers
+ * spread the returned per-item binding on each row; the composable
+ * handles everything else. No `#preview` slot required — the
+ * ghost is a cloned snapshot of the row the user grabbed, so it
+ * always looks exactly like what's being dragged regardless of the
+ * row's markup.
+ *
+ * Why pointer events (not HTML5 DnD): HTML5 DnD is flaky inside
+ * reactive rendering loops, doesn't respect `user-select: none`
+ * ancestors, and can't render a non-ghost drag preview without
+ * fighting the browser. Pointer capture gives us direct control
+ * over the entire drag lifecycle and composes cleanly with other
+ * pointer-driven UI (canvas editors, pan/zoom, hover popovers).
+ *
+ * Cross-list drops via `group`: two or more SortableList
+ * instances that share a group id accept items from each other.
+ * On drag move, the composable hit-tests `elementFromPoint` for
+ * any `[data-sortable-container]` element matching the same
+ * group; when the cursor crosses into a sibling instance, the
+ * drop target transfers to that instance. On drop into a
+ * foreign group, the source's `onReorder` emits the removal
+ * and the target's `onInsert` receives the item + insertion
+ * index.
+ *
+ * Drop resolution walks registered row elements via a data
+ * attribute rather than subscribing to each row's bounding-box
+ * reactively — that keeps the cost at O(rows) per pointermove
+ * frame and avoids a layout thrash storm.
+ */
+import { type ComputedRef, type Ref } from "vue";
+/**
+ * Identifier type for sortable rows. Must be stable across
+ * reorders (e.g. a record id, not a positional index).
+ */
+export type SortableId = string | number;
+interface SortableOptions<T> {
+    /** The reactive array being reordered. */
+    items: Ref<readonly T[]> | ComputedRef<readonly T[]>;
+    /**
+     * Extract a stable id from an item. The id is used both as
+     * the drop-target key (via `data-sortable-id`) and as the
+     * row registration key. Two items with the same id in the
+     * same list is undefined behavior.
+     */
+    getId: (item: T) => SortableId;
+    /**
+     * Called once per successful same-list drop with the full
+     * reordered array. Also called with the post-removal array
+     * when an item is transferred OUT to another list in the
+     * same group.
+     */
+    onReorder: (next: T[]) => void;
+    /**
+     * Cross-list group id. Instances that share a group id
+     * accept drops from each other. Undefined (the default)
+     * isolates this instance — drags stay within the same list.
+     */
+    group?: string;
+    /**
+     * Called when a foreign item is dropped into this list. The
+     * consumer is responsible for the insert (typically by
+     * calling its own onReorder counterpart to mutate the
+     * source-of-truth). The item type is `unknown` because the
+     * source list may own a different T — the group id is the
+     * only contract that asserts compatibility.
+     */
+    onInsert?: (index: number, item: unknown) => void;
+    /**
+     * Optional grip constraint. When set, drag only starts if
+     * the pointerdown target is (or is a descendant of) an
+     * element matching this selector. Defaults to
+     * `[data-sortable-handle]` — the selector that
+     * <SortableHandle> emits. Pass `null` to allow drag from
+     * anywhere on the row.
+     */
+    handleSelector?: string | null;
+    /**
+     * Axis constraint for drop resolution. `"y"` uses row
+     * midpoint Y (vertical list), `"x"` uses row midpoint X
+     * (horizontal list). Default: `"y"`.
+     */
+    axis?: "x" | "y";
+}
+/**
+ * Handlers + attrs to spread on a row element. `SortableList`
+ * calls `registerItem(id)` once per row and forwards these via
+ * a `v-bind` on the row's root.
+ */
+interface SortableRowBinding {
+    /**
+     * Template ref callback. Spread on the row's root element
+     * via `:ref="binding.ref"`.
+     */
+    ref: (el: Element | null) => void;
+    /** Data attribute set — includes `data-sortable-id`. */
+    dataAttrs: Record<string, string>;
+    /**
+     * Reactive class object — carries the drop-target hint
+     * classes (`is-sortable-drop-above` / `-below`) when this
+     * row is the live drop target during a drag.
+     */
+    class: ComputedRef<Record<string, boolean>>;
+    /** Pointerdown handler — spread as `@pointerdown`. */
+    onPointerdown: (e: PointerEvent) => void;
+}
+/**
+ * Container binding — spread on the list's root element so the
+ * composable can hit-test it during cross-list drags.
+ */
+export interface SortableContainerBinding {
+    ref: (el: Element | null) => void;
+    dataAttrs: Record<string, string>;
+}
+export interface UseSortableReturn {
+    /**
+     * Register a row by its stable id. Returns the binding
+     * object the row should spread on its root element.
+     * Idempotent — calling with the same id returns the same
+     * binding so Vue's `v-bind` stays stable across rerenders.
+     */
+    registerItem: (id: SortableId) => SortableRowBinding;
+    /**
+     * Binding to spread on the list's container element. Marks
+     * it as a drop target for cross-list drags in the same
+     * group and exposes the container bounding rect for hit
+     * testing.
+     */
+    container: SortableContainerBinding;
+    /** True while a drag is in progress. */
+    isDragging: ComputedRef<boolean>;
+    /** Id of the row currently being dragged, or null. */
+    dragId: ComputedRef<SortableId | null>;
+    /**
+     * Live pointer position in page coordinates while a drag
+     * is in progress.
+     */
+    dragPosition: ComputedRef<{
+        x: number;
+        y: number;
+    } | null>;
+    /** Index the drop will land at, or null when no target. */
+    dropIndex: ComputedRef<number | null>;
+}
+export declare function useSortable<T>(options: SortableOptions<T>): UseSortableReturn;
+export {};

package/dist/configurator.d.ts

@@ -0,0 +1 @@
+export * from "./components/custom/configurator";

package/dist/configurator.js

@@ -0,0 +1,2 @@
+import { a as e, i as t, n, o as r, r as i, s as a, t as o } from "./useConfiguratorState-BlaevW0S.js";
+export { e as CONFIGURATOR_DENSITY_KEY, t as Configurator, i as ConfiguratorLayer, n as ConfiguratorRow, r as provideConfiguratorDensity, o as useConfiguratorState, a as useOptionalConfiguratorDensity };

package/dist/confirm-dialog.d.ts

@@ -0,0 +1 @@
+export * from "./components/custom/confirm-dialog";