@mkbabb/glass-ui 4.2.0 → 5.0.0

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

@@ -1,108 +0,0 @@
-import { type MaybeRefOrGetter, type Ref } from "vue";
-import { type SpringPresetName } from "./springPresets";
-import { type LiquidRevealPreset } from "./useLiquidReveal";
-/** The morph MODES the one scalar drives. */
-export type LiquidMorphMode = "split" | "union" | "expand";
-/**
- * How a piece's travel ANGLE is resolved:
- *   • `radial`   — the unit vector host-center -> piece-center (the n-ary fan).
- *   • `lateral`  — the host's cross-axis (a single side bud).
- *   • `inward`   — the negated radial (a union pull toward the host).
- *   • `directed` — the caller's explicit `piece.angle` (radians) — the
- *                  configurable-angle case the playground's slider drives.
- */
-export type LiquidMorphVector = "radial" | "lateral" | "inward" | "directed";
-/** The named morphology signature — the goo neck/squish character per mode. */
-export interface LiquidMorphSignature {
-    /** How each piece's travel angle is resolved (default `radial`). */
-    vector: LiquidMorphVector;
-    /** Where the goo neck snaps in the 0..1 travel (0.4 tense -> 0.7 long-tail). */
-    neckHold: number;
-    /** The LOW squish cap the bud-off swell can reach (>1; default 1.08). */
-    maxStretch: number;
-}
-/** The default radial-fan signature (the macOS goo-split read). */
-export declare const RADIAL_SPLIT: LiquidMorphSignature;
-/** The directed-beam signature (the configurable-angle / single-direction case). */
-export declare const DIRECTED_SPLIT: LiquidMorphSignature;
-export interface UseLiquidMorphOptions {
-    /** The host element carrying the `--liquid-morph-t` scalar (a card OR a dock). */
-    rootEl: Ref<HTMLElement | null>;
-    /**
-     * The ORIGIN element the split BUDS FROM (the dock pill). The pieces fan out of
-     * this element's center (a connecting goo neck back to the dock), NOT the host
-     * stage center — the WAVE-1 "bud from the dock" fix. Its center is measured
-     * relative to `rootEl` each episode and written as `--liquid-morph-origin-x/y`
-     * (px-from-the-host-top-left) which the goo group (liquid-morph.css) anchors at.
-     * When unset the goo group falls back to the host center (the standalone case).
-     */
-    originEl?: Ref<HTMLElement | null>;
-    /** The morphology signature (default `RADIAL_SPLIT`). */
-    signature?: LiquidMorphSignature;
-    /**
-     * The spring register the scalar rides — a `SPRING_PRESETS` row name, or a
-     * ref/getter resolved PER-DRIVE so a host can vary the clock by gesture (a smooth
-     * card bloom vs a livelier split). Default `"dock"`. NO new family is minted.
-     */
-    spring?: MaybeRefOrGetter<SpringPresetName>;
-    /** The bloom preset for `expand()` (default `"bouncy"`). */
-    revealPreset?: LiquidRevealPreset;
-    /** Honor `prefers-reduced-motion: reduce` (seat synchronously). Default true. */
-    respectReducedMotion?: boolean;
-}
-/** A registered split piece — its element + its vector descriptor. */
-export interface LiquidMorphPiece {
-    /** The piece element (a free-floating glass shard). */
-    el: Ref<HTMLElement | null>;
-    /**
-     * The explicit travel angle in RADIANS for the `directed` vector. Ignored for
-     * `radial`/`lateral`/`inward` (those derive the angle from geometry).
-     */
-    angle?: number;
-    /** The piece's fan rank (the stagger index; 0-based). */
-    rank?: number;
-    /** The travel distance in px (how far the piece flies). Default 96. */
-    distance?: number;
-}
-export interface RegisteredPiece extends LiquidMorphPiece {
-    /** Detach this piece from the morph (clears its inline customs). */
-    release(): void;
-}
-export interface UseLiquidMorphReturn {
-    /** Register a split piece; returns the live handle. */
-    registerPiece(p: LiquidMorphPiece): RegisteredPiece;
-    /** SPLIT — drive the scalar 0 -> 1 (the pieces bud off through the goo neck). */
-    split(): void;
-    /** UNION — drive the scalar 1 -> 0 (the SAME loop, reversed; bidirectional). */
-    union(): void;
-    /** SEEK — scrub the scalar to an arbitrary 0..1 value (the timeline scrubber). */
-    seek(value: number): void;
-    /** EXPAND — bloom a card FROM a trigger pill (the dock->card materialize). */
-    expand(opts: {
-        card: Ref<HTMLElement | null>;
-        trigger: Ref<HTMLElement | null>;
-    }): void;
-    /** COLLAPSE — conceal the expanded card back to the pill (the bloom's close). */
-    collapse(): void;
-    /** The live normalized scalar (0..1) — what `--liquid-morph-t` reads. */
-    readonly t: Readonly<Ref<number>>;
-    /** Whether a morph is in flight (the host carries `[data-liquid-morphing]`). */
-    readonly morphing: Readonly<Ref<boolean>>;
-}
-/**
- * The generalized liquid-morph driver. See the module header for the REUSE (the
- * cloned dock loop shape + the composed reveal/flex leaves), the arbitrary-angle goo
- * mechanism, and the compositor-only + PRM fences.
- *
- * @example
- * ```ts
- * const root = ref<HTMLElement | null>(null)
- * const morph = useLiquidMorph({ rootEl: root, signature: DIRECTED_SPLIT })
- * for (const el of shardRefs) morph.registerPiece({ el, angle: theta.value })
- * // n-ary split at an arbitrary angle:
- * morph.split()
- * // the dock -> card bloom:
- * morph.expand({ card: cardRef, trigger: pillRef })
- * ```
- */
-export declare function useLiquidMorph(options: UseLiquidMorphOptions): UseLiquidMorphReturn;

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

@@ -1,157 +0,0 @@
-import { type MaybeRef, type Ref } from "vue";
-/** The five motion VECTORS a signature selects (geometry/motion, never an app name). */
-export type MorphVector = "lateral" | "radial" | "inward" | "axial" | "directed";
-/** The render TIER a morph resolves to (the caps ladder). */
-export type MorphTier = "css" | "svg-goo" | "gpu";
-/** The silhouette a body presents. `capture` = sample its clip-path → SDF (Tier-G, the
- *  arbitrary-outline element→element morph — HARD-gated on useElementBloom). */
-export type MorphSilhouette = "circle" | "squircle" | "capture";
-/** A measured rectangle (the body endpoints; left/top/width/height in host-local px). */
-export interface MorphFieldRect {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-/**
- * The motion SIGNATURE — DATA, the only thing that distinguishes the morphs. `vector`
- * picks the geometry; `kRest`/`kPeak` are gap-FRACTIONS (not px) the threshold band
- * scales by; `neckHold` is how long the neck holds before it pinches; `maxStretch` the
- * LOW squish cap (the anti-taffy fence).
- */
-export interface MorphSignature {
-    vector: MorphVector;
-    /** The neck-gap fraction at REST (bodies apart) — the threshold band floor. */
-    kRest: number;
-    /** The neck-gap fraction at the PEAK (bodies near, the gooey waist) — the band ceiling. */
-    kPeak: number;
-    /** How long (0..1 of t) the neck HOLDS its girth before it pinches (the tense pop). */
-    neckHold: number;
-    /** The LOW on-axis squish cap (≤~1.14 — the loud register lives in NECK girth, not body taffy). */
-    maxStretch: number;
-}
-/**
- * The canonical, motion-named SIGNATURE map (DATA — F3, the FLOOR). Every consumer
- * passes a `MorphSignatureName`; one weld reads the row; one recipe paints it. NO app
- * names, NO three code paths.
- */
-export declare const MORPH_SIGNATURES: {
-    /** carousel / deck / pager goo: two equal beads bud apart, a concave neck wells, the
-     *  filter merges them into one barbell with a thin pinched waist, then they coalesce. */
-    readonly lateralNeck: {
-        readonly vector: "lateral";
-        readonly kRest: 0.92;
-        readonly kPeak: 0.34;
-        readonly neckHold: 0.5;
-        readonly maxStretch: 1.12;
-    };
-    /** dock fission media: the now-playing anchor stays; flanking transport PEELS along
-     *  the cross axis with a long tapering neck tail. */
-    readonly lateralPeel: {
-        readonly vector: "lateral";
-        readonly kRest: 0.88;
-        readonly kPeak: 0.4;
-        readonly neckHold: 0.4;
-        readonly maxStretch: 1.08;
-    };
-    /** dock fission search: controls fly outward like a bloom; the neck NECKS LATE (the
-     *  tense radial pop), innermost-first — an outward ripple, not a simultaneous scatter. */
-    readonly radialBurst: {
-        readonly vector: "radial";
-        readonly kRest: 0.85;
-        readonly kPeak: 0.3;
-        readonly neckHold: 0.55;
-        readonly maxStretch: 1.08;
-    };
-    /** dock fission nav: the negative radial — N masses collapse INWARD to ONE; the bridge
-     *  runs backward; --stretch peaks at coalescence. */
-    readonly inwardMerge: {
-        readonly vector: "inward";
-        readonly kRest: 0.8;
-        readonly kPeak: 0.28;
-        readonly neckHold: 0.35;
-        readonly maxStretch: 1.1;
-    };
-    /** dock V↔H: column-mass + row-mass are two distributions in ONE topology-free field;
-     *  a gooey teardrop LOBS column→row through the midpoint (no crossfade dodge). */
-    readonly axialNeck: {
-        readonly vector: "axial";
-        readonly kRest: 0.9;
-        readonly kPeak: 0.36;
-        readonly neckHold: 0.5;
-        readonly maxStretch: 1.14;
-    };
-    /** dock collapse: the DEGENERATE 1-body field — a single mass squishes between two
-     *  footprints (no waist, Tier-C). The ratio-free convex blend. */
-    readonly collapse: {
-        readonly vector: "axial";
-        readonly kRest: 1;
-        readonly kPeak: 1;
-        readonly neckHold: 0;
-        readonly maxStretch: 1.14;
-    };
-    /** drag morph: a grabbed rect → drop rect, an optional directed neck. */
-    readonly directed: {
-        readonly vector: "directed";
-        readonly kRest: 0.9;
-        readonly kPeak: 0.42;
-        readonly neckHold: 0.45;
-        readonly maxStretch: 1.1;
-    };
-};
-export type MorphSignatureName = keyof typeof MORPH_SIGNATURES;
-/** A warm "body" the field welds — a measured endpoint pair + an optional silhouette. */
-export interface BodySpec {
-    /** The DOM node this body IS (the weld writes its transform). */
-    el: Ref<HTMLElement | null>;
-    /** The body's REST rect (t=0), measured ONCE (dock-core: no per-frame measure). */
-    at0: () => MorphFieldRect;
-    /** The body's TARGET rect (t=1), measured ONCE. */
-    at1: () => MorphFieldRect;
-    /** The body diameter (px). Default `min(width,height)/φ` — a golden-minor BLOB. */
-    radius?: () => number;
-    /** circle (default) / squircle / capture (arbitrary outline → Tier-G, HARD-gated). */
-    silhouette?: MorphSilhouette;
-}
-export interface MorphFieldOptions {
-    /** 1..N warm masses. 1 body = collapse (no weld); 2 = a neck; (1+N) = fission. */
-    bodies: MaybeRef<BodySpec[]>;
-    /** The motion signature NAME (DATA). The weld reads its row from MORPH_SIGNATURES. */
-    signature: MorphSignatureName;
-    /**
-     * The EXISTING drive scalar this weld READS off the host (NO rename). Default
-     * `--goo-t`; dock passes `--dock-morph-t`, fission `--neck-t`. The consumer's
-     * spring/rAF writes it; the weld only samples + projects.
-     */
-    driveVar?: string;
-    /** The host the drive scalar + the dedicated squish channel are read/written on. */
-    hostRef: Ref<HTMLElement | null>;
-    /** The cartoon-weight scalar source. Read live off the host `--motion-weight` if absent. */
-    weight?: MaybeRef<number>;
-    /** The render tier. `auto` (default) resolves from caps + body count + signature. */
-    tier?: MorphTier | "auto";
-    /** Travel axis for the neck span. `false` (default) horizontal, `true` vertical. */
-    vertical?: MaybeRef<boolean>;
-}
-export interface MorphFieldHandle {
-    /** Mirror of the consumer's drive scalar (last sampled). Read-only. */
-    readonly t: Readonly<Ref<number>>;
-    /** The neck waist FRACTION (waist/body) at the current frame — for π readback. */
-    readonly waist: Readonly<Ref<number>>;
-    /** The resolved render tier. */
-    readonly tier: Readonly<Ref<MorphTier>>;
-    /**
-     * PROJECT the field for an explicit drive value `t` (0..1). Reads the masses'
-     * measured endpoints + the signature, writes each body's transform + the welling
-     * neck + the dedicated squish channel + the live waist. The consumer calls this from
-     * its OWN rAF/spring callback (the weld owns no clock).
-     */
-    project(t: number): void;
-    /**
-     * SEAT the endpoint silhouette at `t` with ZERO neck frames (the PRM cut / first
-     * paint). One resting mass at the endpoint, neck hidden, --stretch 1. The consumer's
-     * PRM branch calls this.
-     */
-    seat(t: number): void;
-}
-export declare function useMorphField(opts: MorphFieldOptions): MorphFieldHandle;

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

@@ -1,44 +0,0 @@
-/**
- * Sortable drag-state controller — the drag lifecycle + cross-list routing.
- *
- * Owns the live drag state (`dragId` / `pos` / `dropIndex` / `pointerCaptureActive`)
- * and the `beginDrag` → `onPointerMove` → `onPointerUp` → `endDrag` lifecycle. It
- * composes the leaf services: the ghost renderer (visual clone), the drop resolver
- * (collision/measure + cross-list lookup), and the touch gate (handle constraint +
- * pointer-capture optimization). Same-list reorders and foreign-list transfers are
- * both routed here through the unified resolver.
- */
-import { type ShallowRef } from "vue";
-import type { InstanceHandle, SortableId } from "./types";
-import type { GhostRenderer } from "./ghostRenderer";
-export interface DragControllerDeps {
-    /** Live items array accessor (the reactive source-of-truth). */
-    getItems: () => readonly unknown[];
-    getId: (item: unknown) => SortableId;
-    /** Per-id element cache, shared with the row registry. */
-    elements: Map<SortableId, Element | null>;
-    /** This instance's registry handle (for cross-list lookups). */
-    handle: InstanceHandle;
-    onReorder: (next: unknown[]) => void;
-    /** Horizontal-axis drop resolution (`axis === "x"`). */
-    horizontal: boolean;
-    ghost: GhostRenderer;
-}
-export interface DragController {
-    /** Live id of the dragged row, or null. */
-    dragId: ShallowRef<SortableId | null>;
-    /** Live pointer position in page coordinates, or null. */
-    pos: ShallowRef<{
-        x: number;
-        y: number;
-    } | null>;
-    /** Resolved local drop index, or null. */
-    dropIndex: ShallowRef<number | null>;
-    /** Whether the active drag holds a pointer capture. */
-    pointerCaptureActive: ShallowRef<boolean>;
-    /** Start a drag for the row `id` from the pointerdown event `e`. */
-    beginDrag: (id: SortableId, e: PointerEvent) => void;
-    /** Tear down an in-flight drag (also the defensive scope-dispose path). */
-    endDrag: () => void;
-}
-export declare function createDragController(deps: DragControllerDeps): DragController;

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

@@ -1,133 +0,0 @@
-/**
- * Sortable shared types — the contract surface the controller + services share.
- *
- * Kept in one leaf module so the five cohesive services + the `useSortable`
- * orchestrator import the same definitions without a circular edge. The public
- * `useSortable` / `UseSortableReturn` / `SortableId` surface is re-exported
- * unchanged from `useSortable.ts` (the consumer contract is byte-identical).
- */
-import type { ComputedRef, 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;
-export 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.
- */
-export interface SortableRowBinding {
-    /** Template ref callback. Spread on the row's root element via `: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>;
-    /**
-     * `true` while the active drag holds a pointer capture; `false` when the
-     * `setPointerCapture` optimization was unavailable and the drag is running on
-     * the document `pointermove`/`pointerup` listeners alone (still fully
-     * functional). Surfaced so a consumer can observe the degraded-but-correct
-     * path instead of it being an invisible swallow.
-     */
-    pointerCaptureActive: ComputedRef<boolean>;
-}
-/**
- * Module-level registry entry for a live `useSortable` instance. Used for
- * cross-list drop resolution — on drag move, the source instance looks up any
- * other instance in the same group whose container contains the cursor, and
- * transfers the drop target to it.
- */
-export interface InstanceHandle {
-    group?: string;
-    getContainer: () => Element | null;
-    getItems: () => readonly unknown[];
-    getId: (item: unknown) => SortableId;
-    getElements: () => Map<SortableId, Element | null>;
-    setExternalDropIndex: (index: number | null) => void;
-    acceptExternal: (index: number, item: unknown) => void;
-    /** The target insertion index at drop time (set by pointermove). */
-    getExternalDropIndex?: () => number | null;
-}

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

@@ -1,34 +0,0 @@
-/**
- * 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
- * the sibling instance registry; 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.
- *
- * This module is the thin orchestrator. It composes five cohesive services:
- *   - dragController   — the drag-state lifecycle + cross-list routing
- *   - dropResolver     — pure collision/measure math + the instance registry
- *   - ghostRenderer    — the snap-physics + visual clone
- *   - touchGate        — the handle constraint + pointer-capture optimization
- *   - transitionTiming — the drop-target class grammar
- */
-import type { SortableOptions, UseSortableReturn } from "./types";
-import { isNonZeroRadius } from "./ghostRenderer";
-export declare function useSortable<T>(options: SortableOptions<T>): UseSortableReturn;
-export { isNonZeroRadius };
-export type { SortableId, SortableContainerBinding, UseSortableReturn } from "./types";

package/dist/concentric.d.ts

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