@mkbabb/glass-ui 4.0.0 → 4.0.1

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

@@ -0,0 +1,51 @@
+import { type Ref } from "vue";
+import { type SpringPresetName } from "./springPresets";
+/** The reveal spring register — `snappy` (the quick app-open default) or `bouncy`
+ *  (the emphatic large-dialog bloom). A subset of the named `SPRING_PRESETS` rows. */
+export type LiquidRevealPreset = Extract<SpringPresetName, "snappy" | "bouncy">;
+export interface UseLiquidRevealOptions {
+    /**
+     * The trigger element the surface blooms FROM — the source rect (the button, the
+     * collapsed dock pill). When null at reveal time, the bloom degrades to a
+     * center-anchored scale-from-self (the no-trigger fallback — still spring-clocked,
+     * never the flat bezier zoom).
+     */
+    trigger?: Ref<HTMLElement | null>;
+    /** The spring register (default `snappy`). */
+    preset?: LiquidRevealPreset;
+    /** The starting backdrop-blur radius in px (the decongest start). Default 4. */
+    blur?: number;
+    /** Honor `prefers-reduced-motion: reduce` (snap to settled, fade only). Default true. */
+    respectReducedMotion?: boolean;
+}
+export interface UseLiquidRevealReturn {
+    /**
+     * Bloom the surface open from the trigger's rect. Idempotent per call — measures
+     * the trigger + settled rects fresh, drives the inversion spring 1→0. A no-op if
+     * the surface element is not yet mounted.
+     */
+    reveal: () => void;
+    /**
+     * Snap the surface to its settled identity (clear the bloom transform/blur). The
+     * EXIT is the CSS recipe's `--ease-out` no-overshoot leg (a closing surface must
+     * not overshoot past gone) — this leaf clears the enter transform so the recipe's
+     * exit owns the close.
+     */
+    conceal: () => void;
+}
+/**
+ * The iOS-27 source-rect bloom. Composes the dormant kf `ElementMorph` +
+ * `springTimingFunction` into the three-channel liquid open (scale+fade+blur-settle
+ * from the trigger's origin), compositor-only + PRM-snap. See the module header for
+ * the REUSE + bloom-mechanism (FLIP inversion) + the channel split.
+ *
+ * @example
+ * ```ts
+ * const { reveal, conceal } = useLiquidReveal(surfaceRef, {
+ *   trigger: triggerRef,
+ *   preset: "bouncy",
+ * })
+ * watch(open, (o) => (o ? reveal() : conceal()))
+ * ```
+ */
+export declare function useLiquidReveal(surface: Ref<HTMLElement | null>, options?: UseLiquidRevealOptions): UseLiquidRevealReturn;

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

@@ -30,9 +30,9 @@ export interface UseNumericTransitionOptions<K extends string> {
      * (a name now resolves only through the ASYNC `resolveEasing`, which crosses
      * the value.js dynamic boundary the dock/motion light surface must never
      * pull in). Narrowing glass-ui's public option to a callable decouples it
-     * from keyframes' name-resolution churn AND is assignable to every supported
-     * keyframes major (2.2 / 3 / 4). A consumer wanting a named curve passes the
-     * function directly (e.g. `(t) => 1 - Math.pow(1 - t, 3)` for easeOutCubic).
+     * from keyframes' name-resolution churn. A consumer wanting a named curve
+     * passes the function directly (e.g. `(t) => 1 - Math.pow(1 - t, 3)` for
+     * easeOutCubic).
      */
     timingFunction?: TimingFunction;
     /** Per-frame consumer. Receives the same zero-allocation record each tick. */

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

@@ -0,0 +1,98 @@
+import { type Ref } from "vue";
+/** A 2-vector in normalized-host space (0..1 across the host box). */
+export interface PointerVec2 {
+    x: number;
+    y: number;
+}
+export interface UsePointerVelocityFieldOptions {
+    /**
+     * The smoothing rate for the eased POSITION (0..1 per second-equivalent; higher
+     * = snappier approach). Default 0.22 (the cursorModel `CURSOR_POS_LERP` snappy
+     * register). The viz reads `position`/`smoothedPosition`; the velocity is its
+     * derivative.
+     */
+    positionLerp?: number;
+    /**
+     * The smoothing rate for the derived VELOCITY (0..1; higher = velocity tracks the
+     * live delta faster, lower = a longer momentum tail). Default 0.3 (the cursorModel
+     * `CURSOR_VELOCITY_LERP`).
+     */
+    velocityLerp?: number;
+    /**
+     * The smoothing rate for the derived ACCELERATION (0..1). Default 0.3 — the accel
+     * term tracks the velocity-delta on the same register as the velocity itself.
+     */
+    accelerationLerp?: number;
+    /**
+     * The per-tick burst decay multiplier (the transient swirl-impulse a fast flick
+     * injects, decaying over ~1s). Default 0.96 (the cursorModel
+     * `CURSOR_BURST_DECAY_PER_FRAME`, ≈0.96^60≈0.09 after 1s at 60fps).
+     */
+    burstDecay?: number;
+    /**
+     * Honor `prefers-reduced-motion: reduce` → `tick(0)` freeze (no live velocity).
+     * Default true. (A deterministic viz capture that ACCEPTS live dynamics opts out.)
+     */
+    respectReducedMotion?: boolean;
+}
+export interface UsePointerVelocityField {
+    /** True while the pointer is over the host (down between enter and leave). */
+    readonly active: Readonly<Ref<boolean>>;
+    /** The RAW live pointer target in normalized-host space (0..1), pre-smoothing. */
+    readonly position: Readonly<Ref<PointerVec2>>;
+    /** The eased/smoothed pointer position the velocity derives from (0..1). */
+    readonly smoothedPosition: Readonly<Ref<PointerVec2>>;
+    /** The smoothed pointer VELOCITY (normalized-host units per second). */
+    readonly velocity: Readonly<Ref<PointerVec2>>;
+    /** The scalar velocity magnitude (`hypot(velocity)`), the common viz read. */
+    readonly speed: Readonly<Ref<number>>;
+    /** The smoothed pointer ACCELERATION (the second derivative — the accel term). */
+    readonly acceleration: Readonly<Ref<PointerVec2>>;
+    /** The transient flick-burst impulse (0..1, decays over ~1s). */
+    readonly burst: Readonly<Ref<number>>;
+    /**
+     * The `@pointermove` handler — schedules NO frame; it only stashes the raw target
+     * (PRM-gated). The renderer's `tick` does the smoothing/derivation on its OWN
+     * frame. Bind on the host (or call `setPointer` directly from a custom listener).
+     */
+    onPointerMove: (event: PointerEvent) => void;
+    /** Bind on the host `@pointerenter` (sets `active`). */
+    onPointerEnter: () => void;
+    /** Bind on the host `@pointerleave` (clears `active`; the field decays to rest). */
+    onPointerLeave: () => void;
+    /**
+     * Set the raw pointer target directly in normalized-host space (0..1) — for a
+     * viz that already owns its pointer→uv mapping (a WebGPU surface reading
+     * clip-space coords). PRM-gated like `onPointerMove`.
+     */
+    setPointer: (xNorm: number, yNorm: number) => void;
+    /**
+     * Advance the physics ONE renderer frame. The viz calls this from INSIDE its
+     * existing frame callback with the frame `delta` (ms). NO own rAF — the renderer
+     * owns the loop. Under PRM (or an explicit `tick(0)`) the field freezes to rest
+     * (no live velocity). Returns the live field (so a renderer can read inline).
+     */
+    tick: (deltaMs: number) => void;
+    /** Snap the whole field to rest (position held, velocity/accel/burst zeroed). */
+    reset: () => void;
+    /** Tear down the cached PRM listener (auto-run on scope dispose). */
+    dispose: () => void;
+}
+/**
+ * The shared viz-pointer-physics field — pointer POSITION + derived VELOCITY +
+ * derived ACCELERATION (the accel term), advanced by the renderer's frame `tick`
+ * (NO own rAF), frozen under PRM (`tick(0)`). The procedural-viz family reads the
+ * field for pointer dynamics; the position is event-driven, the derivatives are
+ * computed in `tick`.
+ *
+ * @example
+ * ```ts
+ * const field = usePointerVelocityField()
+ * // in the renderer's frame callback (the ONE loop the canvas lifecycle owns):
+ * function onFrame({ delta }) {
+ *   field.tick(delta)                       // advance the physics, no second rAF
+ *   uploadUniforms({ vel: field.velocity.value, accel: field.acceleration.value })
+ * }
+ * ```
+ */
+export declare function usePointerVelocityField(options?: UsePointerVelocityFieldOptions): UsePointerVelocityField;

package/dist/concentric.d.ts

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