solid-drift 0.18.0 → 0.20.0

package/README.md

@@ -412,6 +412,32 @@ const { x, y, status } = createDrag(() => card, {
 
 Returns `{ x, y, status }`: the drag offset in pixels and `status` (`"idle"`, `"dragging"`, `"settling"`). SSR-safe: everything rests at 0. Under reduced motion the drag still tracks the pointer (direct manipulation is not animation) but release snaps instantly to the constrained target with no glide.
 
+### `createSwipe(ref, options?)`
+
+Touch swipe gesture recognition: swipe-to-dismiss, carousels. While `createDrag` tracks the pointer continuously, `createSwipe` makes the discrete decision: was that gesture a swipe, and which way? On pointerup it compares travel, duration, and velocity against the thresholds and fires the matching callbacks plus the `lastSwipe` signal. Pointer Events give touch parity for free: mouse, touch, and pen run through the same path. For touch, set `touch-action: pan-y` on a horizontal swipe surface (or `pan-x` for vertical) so the browser does not hijack the gesture; use `none` when recognizing both axes.
+
+```tsx
+import { createSwipe } from "solid-drift"
+
+let deck!: HTMLDivElement
+const { lastSwipe } = createSwipe(() => deck, {
+  onSwipeLeft: () => dismiss(),
+  onSwipeRight: () => keep(),
+})
+<div ref={deck} style={{ "touch-action": "pan-y" }}>card</div>
+```
+
+| Option         | Default | Description                                                              |
+| -------------- | ------- | ------------------------------------------------------------------------ |
+| `threshold`    | `48`    | Minimum travel in px to count as a swipe                                 |
+| `maxDuration`  | `800`   | Maximum gesture duration in ms                                           |
+| `minVelocity`  | `0.4`   | Minimum velocity in px/ms; a fast flick below `threshold` still counts    |
+| `axis`         | `"both"`| `"x"`, `"y"`, or `"both"`                                                |
+| `onSwipe`      | none    | Called for every recognized swipe with `{ direction, distance, velocity, duration, from, to }` |
+| `onSwipeLeft` / `onSwipeRight` / `onSwipeUp` / `onSwipeDown` | none | Per-direction callbacks |
+
+Returns `{ lastSwipe, reset }`. A swipe counts when travel passes `threshold` inside `maxDuration`, or velocity passes `minVelocity`; slow long drags are not swipes. Recognition is not animation, so it works identically under reduced motion; the host decides how to animate the response. SSR-safe: `lastSwipe()` stays null and callbacks never fire.
+
 ### `createTrail(source, options?)`
 
 A signal that replays another signal's past: it returns the value the source had `delay` milliseconds ago, interpolated between samples. Chain trails off one source for follower effects (a cursor with a comet tail, cascading highlights), or trail a scroll progress for a delayed echo of the page. The trail catches up and parks exactly on the latest value when the source rests. The follow loop runs only while the trail is behind.
@@ -1104,6 +1130,28 @@ const reveal = createMintReveal(() => card, {
 
 Returns `{ play, reset, status }`. `status()` walks `"idle"`, `"anticipating"`, `"flipping"`, `"revealed"`. Under reduced motion (and on the server) `play()` applies the revealed state immediately and still calls `onFlip`.
 
+### `createDepixelate(image, canvas, options?)`
+
+Pixel-to-sharp image reveal, the classic NFT mint ceremony. An image renders into a canvas fully pixelated, then resolves to sharp in discrete chunky steps on the shared animation clock. Owns the canvas drawing: give it an image and a canvas, call `play()` when the art should reveal. The pixelated teaser frame paints itself as soon as the image loads, so the pre-reveal state needs no manual setup. Pair with `createMintReveal` for the full ceremony: flip the card, depixelate the art.
+
+```tsx
+let img!: HTMLImageElement
+let cvs!: HTMLCanvasElement
+const reveal = createDepixelate(() => img, () => cvs, { duration: 1800 })
+<img ref={img} src={artUrl} style={{ display: "none" }} />
+<canvas ref={cvs} />
+<button onClick={() => reveal.play()}>Reveal</button>
+```
+
+| Option       | Default           | Description                                    |
+| ------------ | ----------------- | ---------------------------------------------- |
+| `levels`     | `10`              | Discrete pixelation steps from blocky to sharp |
+| `duration`   | `1600`            | Full reveal duration in ms                     |
+| `easing`     | `"easeInOutCubic"`| Easing for the reveal progress                 |
+| `onComplete` | none              | Called when the reveal reaches sharp           |
+
+Returns `{ pixelSize, progress, status, play, complete, reset, stop }`. `status()` walks `"idle"`, `"revealing"`, `"revealed"`; `pixelSize()` is the current block size in px (1 means sharp). `stop()` halts mid-reveal and resolves the pending `play()` promise; `reset()` repaints the teaser; `complete()` jumps to sharp. Under reduced motion (and on the server) the art is sharp immediately.
+
 ### `createConnectButton(ref, options?)`
 
 Wallet connect button micro-interactions: magnetic pull toward the pointer, a press scale, an animated check overlay for copy-address feedback, and a chain pulse ring. Pointer handling is global (presses that start inside still count if released outside), and everything cleans up on unmount.

package/dist/depixelate.d.ts

@@ -0,0 +1,57 @@
+import { type Accessor } from "solid-js";
+import { type Easing, type EasingName } from "./easing.js";
+/**
+ * Pixel-to-sharp image reveal, the classic NFT mint ceremony.
+ *
+ * An image renders into a canvas fully pixelated, then resolves to
+ * sharp in discrete chunky steps. Owns the canvas drawing: give it
+ * an image and a canvas, call `play()` when the art should reveal.
+ *
+ * ```tsx
+ * let img!: HTMLImageElement
+ * let cvs!: HTMLCanvasElement
+ * const reveal = createDepixelate(() => img, () => cvs, { duration: 1800 })
+ * <img ref={img} src={artUrl} style={{ display: "none" }} />
+ * <canvas ref={cvs} />
+ * <button onClick={() => reveal.play()}>Reveal</button>
+ * ```
+ *
+ * The pixelated teaser frame paints itself as soon as the image
+ * loads, so the pre-reveal state needs no manual setup. Call `play()`
+ * after the image has loaded; if the image or canvas is missing,
+ * `play()` resolves immediately as revealed.
+ *
+ * SSR-safe: `status()` starts `"revealed"` and `play()` resolves
+ * immediately. Reduced-motion safe: `play()` and `complete()` jump
+ * straight to sharp.
+ */
+export type DepixelateStatus = "idle" | "revealing" | "revealed";
+export interface DepixelateOptions {
+    /**
+     * Discrete pixelation steps from blocky to sharp. Default 10.
+     * More steps make a smoother, longer-feeling resolve.
+     */
+    levels?: number;
+    /** Full reveal duration in ms. Default 1600. */
+    duration?: number;
+    /** Easing for the reveal progress. Default "easeInOutCubic". */
+    easing?: Easing | EasingName;
+    /** Called when the reveal reaches sharp. */
+    onComplete?: () => void;
+}
+export interface DepixelateControls {
+    /** Current pixel block size in px. 1 (or 0) means fully sharp. */
+    pixelSize: Accessor<number>;
+    /** Reveal progress 0..1. */
+    progress: Accessor<number>;
+    status: Accessor<DepixelateStatus>;
+    /** Start (or restart) the reveal. Resolves when sharp or stopped. */
+    play: () => Promise<void>;
+    /** Jump straight to sharp. */
+    complete: () => void;
+    /** Back to the fully pixelated teaser frame. */
+    reset: () => void;
+    /** Stop the reveal where it is. */
+    stop: () => void;
+}
+export declare function createDepixelate(image: () => HTMLImageElement | null | undefined, canvas: () => HTMLCanvasElement | null | undefined, options?: DepixelateOptions): DepixelateControls;

package/dist/depixelate.js

@@ -0,0 +1,190 @@
+import { createEffect, createSignal, onCleanup, } from "solid-js";
+import { now, schedule } from "./engine.js";
+import { resolveEasing } from "./easing.js";
+import { prefersReducedMotion } from "./reduced-motion.js";
+export function createDepixelate(image, canvas, options = {}) {
+    const server = typeof window === "undefined";
+    const { levels = 10, duration = 1600, easing: easingOpt = "easeInOutCubic", onComplete, } = options;
+    const easing = resolveEasing(easingOpt);
+    const steps = Math.max(1, Math.round(levels));
+    const [pixelSize, setPixelSize] = createSignal(1);
+    const [progress, setProgress] = createSignal(0);
+    const [status, setStatus] = createSignal(server ? "revealed" : "idle");
+    let off = null;
+    const scratch = () => {
+        if (off || typeof document === "undefined")
+            return off;
+        off = document.createElement("canvas");
+        return off;
+    };
+    /** Largest block size: chunky enough to hide the art, small enough to hint at it. */
+    const startBlock = (img) => Math.max(8, Math.floor(Math.min(img.naturalWidth, img.naturalHeight) / 12));
+    const blockFor = (step, start) => {
+        if (step >= steps - 1)
+            return 1;
+        const t = 1 - step / Math.max(1, steps - 1);
+        return Math.max(2, Math.round(start * t * t));
+    };
+    const draw = (block) => {
+        const img = image();
+        const cvs = canvas();
+        if (!img || !cvs)
+            return;
+        if (!img.complete || img.naturalWidth === 0)
+            return;
+        const w = img.naturalWidth;
+        const h = img.naturalHeight;
+        if (cvs.width !== w || cvs.height !== h) {
+            cvs.width = w;
+            cvs.height = h;
+        }
+        const ctx = cvs.getContext("2d");
+        if (!ctx)
+            return;
+        if (block <= 1) {
+            ctx.imageSmoothingEnabled = true;
+            ctx.clearRect(0, 0, w, h);
+            ctx.drawImage(img, 0, 0, w, h);
+            return;
+        }
+        const buf = scratch();
+        if (!buf)
+            return;
+        const sw = Math.max(1, Math.round(w / block));
+        const sh = Math.max(1, Math.round(h / block));
+        buf.width = sw;
+        buf.height = sh;
+        const bctx = buf.getContext("2d");
+        if (!bctx)
+            return;
+        bctx.imageSmoothingEnabled = true;
+        bctx.drawImage(img, 0, 0, sw, sh);
+        ctx.imageSmoothingEnabled = false;
+        ctx.clearRect(0, 0, w, h);
+        ctx.drawImage(buf, 0, 0, sw, sh, 0, 0, w, h);
+    };
+    const paintTeaser = () => {
+        const img = image();
+        if (!img)
+            return;
+        const block = startBlock(img);
+        draw(block);
+        setPixelSize(block);
+        setProgress(0);
+    };
+    const paintSharp = () => {
+        draw(1);
+        setPixelSize(1);
+        setProgress(1);
+    };
+    // Paint the teaser frame as soon as the image is ready, so the
+    // pre-reveal state works with no manual setup. Under reduced motion
+    // the teaser is the sharp art, since the reveal itself is skipped.
+    if (!server) {
+        createEffect(() => {
+            const img = image();
+            if (!img || !img.complete || img.naturalWidth === 0)
+                return;
+            if (!canvas())
+                return;
+            if (status() !== "idle")
+                return;
+            if (prefersReducedMotion()) {
+                paintSharp();
+            }
+            else {
+                paintTeaser();
+            }
+        });
+    }
+    let cancelTask = null;
+    let finish = null;
+    // Creation-time owner: cancel any in-flight reveal on unmount so a
+    // disposed component never keeps drawing into a dead canvas.
+    if (!server) {
+        onCleanup(() => {
+            cancelTask?.();
+            cancelTask = null;
+            finish?.();
+            finish = null;
+        });
+    }
+    const settle = (final) => {
+        cancelTask?.();
+        cancelTask = null;
+        setStatus(final);
+        finish?.();
+        finish = null;
+    };
+    const play = () => {
+        cancelTask?.();
+        cancelTask = null;
+        finish?.();
+        finish = null;
+        if (server) {
+            setStatus("revealed");
+            return Promise.resolve();
+        }
+        const img = image();
+        const cvs = canvas();
+        if (!img || !cvs || !img.complete || img.naturalWidth === 0) {
+            setStatus("revealed");
+            return Promise.resolve();
+        }
+        if (prefersReducedMotion() || duration <= 0) {
+            paintSharp();
+            setStatus("revealed");
+            onComplete?.();
+            return Promise.resolve();
+        }
+        const start = startBlock(img);
+        paintTeaser();
+        setStatus("revealing");
+        const t0 = now();
+        let resolvePromise;
+        const done = new Promise((resolve) => {
+            resolvePromise = resolve;
+        });
+        finish = resolvePromise;
+        cancelTask = schedule((t) => {
+            const p = Math.min(1, (t - t0) / duration);
+            const eased = easing(p);
+            const step = Math.min(steps - 1, Math.floor(eased * steps));
+            const block = blockFor(step, start);
+            draw(block);
+            setPixelSize(block);
+            setProgress(eased);
+            if (p >= 1) {
+                paintSharp();
+                settle("revealed");
+                onComplete?.();
+                return false;
+            }
+            return true;
+        });
+        return done;
+    };
+    const stop = () => {
+        if (status() === "revealing") {
+            settle("idle");
+        }
+    };
+    const complete = () => {
+        cancelTask?.();
+        cancelTask = null;
+        finish?.();
+        finish = null;
+        paintSharp();
+        setStatus("revealed");
+        onComplete?.();
+    };
+    const reset = () => {
+        cancelTask?.();
+        cancelTask = null;
+        finish?.();
+        finish = null;
+        paintTeaser();
+        setStatus("idle");
+    };
+    return { pixelSize, progress, status, play, complete, reset, stop };
+}

package/dist/gesture.d.ts

@@ -105,4 +105,86 @@ export interface DragControls {
  * ```
  */
 export declare function createDrag(ref: MaybeElement, options?: DragOptions): DragControls;
+/** Cardinal direction of a recognized swipe. */
+export type SwipeDirection = "left" | "right" | "up" | "down";
+/** Snapshot delivered for a recognized swipe. */
+export interface SwipeDetails {
+    direction: SwipeDirection;
+    /** Primary-axis travel in px. Always positive. */
+    distance: number;
+    /** Primary-axis velocity in px/ms. Always positive. */
+    velocity: number;
+    /** Gesture duration in ms. */
+    duration: number;
+    /** Pointer path endpoints in client pixels. */
+    from: {
+        x: number;
+        y: number;
+    };
+    to: {
+        x: number;
+        y: number;
+    };
+}
+export interface SwipeOptions {
+    /** Minimum travel in px to count as a swipe. Default 48. */
+    threshold?: number;
+    /** Maximum gesture duration in ms. Default 800. */
+    maxDuration?: number;
+    /**
+     * Minimum primary-axis velocity in px/ms. A fast flick shorter than
+     * `threshold` still counts as a swipe. Default 0.4.
+     */
+    minVelocity?: number;
+    /** Lock recognition to an axis. Default "both". */
+    axis?: DragAxis;
+    /** Called for every recognized swipe. */
+    onSwipe?: (details: SwipeDetails) => void;
+    /** Called for a leftward swipe. */
+    onSwipeLeft?: (details: SwipeDetails) => void;
+    /** Called for a rightward swipe. */
+    onSwipeRight?: (details: SwipeDetails) => void;
+    /** Called for an upward swipe. */
+    onSwipeUp?: (details: SwipeDetails) => void;
+    /** Called for a downward swipe. */
+    onSwipeDown?: (details: SwipeDetails) => void;
+}
+export interface SwipeControls {
+    /** The most recent recognized swipe, or null if none yet. */
+    lastSwipe: Accessor<SwipeDetails | null>;
+    /** Clear the last swipe. */
+    reset: () => void;
+}
+/**
+ * Touch swipe gesture recognition: swipe-to-dismiss, carousels.
+ *
+ * While `createDrag` tracks the pointer continuously, `createSwipe`
+ * makes the discrete decision: was that gesture a swipe, and which
+ * way? On pointerup it compares travel, duration, and velocity
+ * against the thresholds and fires the matching callbacks plus the
+ * `lastSwipe` signal.
+ *
+ * Pointer Events give touch parity for free: mouse, touch, and pen
+ * run through the same path. For touch, set `touch-action: pan-y` on
+ * a horizontal swipe surface (or `pan-x` for vertical) so the browser
+ * does not hijack the gesture; use `none` when recognizing both axes.
+ *
+ * A swipe counts when travel passes `threshold` inside `maxDuration`,
+ * or when velocity passes `minVelocity` (a fast flick). Slow long
+ * drags are not swipes; they belong to `createDrag`.
+ *
+ * Recognition is not animation, so it works identically under
+ * reduced motion; the host decides how to animate the response.
+ * SSR-safe: `lastSwipe()` stays null and callbacks never fire.
+ *
+ * ```tsx
+ * let deck!: HTMLDivElement
+ * const { lastSwipe } = createSwipe(() => deck, {
+ *   onSwipeLeft: () => dismiss(),
+ *   onSwipeRight: () => keep(),
+ * })
+ * <div ref={deck} style={{ "touch-action": "pan-y" }}>card</div>
+ * ```
+ */
+export declare function createSwipe(ref: MaybeElement, options?: SwipeOptions): SwipeControls;
 export {};

package/dist/gesture.js

@@ -205,3 +205,110 @@ export function createDrag(ref, options = {}) {
     onCleanup(() => stopSettle());
     return { x, y, status };
 }
+/**
+ * Touch swipe gesture recognition: swipe-to-dismiss, carousels.
+ *
+ * While `createDrag` tracks the pointer continuously, `createSwipe`
+ * makes the discrete decision: was that gesture a swipe, and which
+ * way? On pointerup it compares travel, duration, and velocity
+ * against the thresholds and fires the matching callbacks plus the
+ * `lastSwipe` signal.
+ *
+ * Pointer Events give touch parity for free: mouse, touch, and pen
+ * run through the same path. For touch, set `touch-action: pan-y` on
+ * a horizontal swipe surface (or `pan-x` for vertical) so the browser
+ * does not hijack the gesture; use `none` when recognizing both axes.
+ *
+ * A swipe counts when travel passes `threshold` inside `maxDuration`,
+ * or when velocity passes `minVelocity` (a fast flick). Slow long
+ * drags are not swipes; they belong to `createDrag`.
+ *
+ * Recognition is not animation, so it works identically under
+ * reduced motion; the host decides how to animate the response.
+ * SSR-safe: `lastSwipe()` stays null and callbacks never fire.
+ *
+ * ```tsx
+ * let deck!: HTMLDivElement
+ * const { lastSwipe } = createSwipe(() => deck, {
+ *   onSwipeLeft: () => dismiss(),
+ *   onSwipeRight: () => keep(),
+ * })
+ * <div ref={deck} style={{ "touch-action": "pan-y" }}>card</div>
+ * ```
+ */
+export function createSwipe(ref, options = {}) {
+    const none = () => null;
+    if (typeof window === "undefined") {
+        return { lastSwipe: none, reset: () => { } };
+    }
+    const { threshold = 48, maxDuration = 800, minVelocity = 0.4, axis = "both", onSwipe, onSwipeLeft, onSwipeRight, onSwipeUp, onSwipeDown, } = options;
+    const [lastSwipe, setLastSwipe] = createSignal(null);
+    const fire = (details) => {
+        setLastSwipe(details);
+        onSwipe?.(details);
+        if (details.direction === "left")
+            onSwipeLeft?.(details);
+        else if (details.direction === "right")
+            onSwipeRight?.(details);
+        else if (details.direction === "up")
+            onSwipeUp?.(details);
+        else
+            onSwipeDown?.(details);
+    };
+    const onDown = (event) => {
+        if (event.isPrimary === false)
+            return;
+        const el = ref();
+        if (!el)
+            return;
+        const startX = event.clientX;
+        const startY = event.clientY;
+        const startT = now();
+        const up = (ev) => {
+            window.removeEventListener("pointerup", up);
+            window.removeEventListener("pointercancel", cancel);
+            const dx = ev.clientX - startX;
+            const dy = ev.clientY - startY;
+            const dt = Math.max(now() - startT, 1);
+            // Primary axis, honoring the axis lock.
+            const horizontal = axis === "x" || (axis === "both" && Math.abs(dx) >= Math.abs(dy));
+            const travel = horizontal ? dx : dy;
+            const distance = Math.abs(travel);
+            const velocity = distance / dt;
+            const isSwipe = (distance >= threshold && dt <= maxDuration) ||
+                velocity >= minVelocity;
+            if (!isSwipe || distance === 0)
+                return;
+            const direction = horizontal
+                ? travel > 0
+                    ? "right"
+                    : "left"
+                : travel > 0
+                    ? "down"
+                    : "up";
+            fire({
+                direction,
+                distance,
+                velocity,
+                duration: dt,
+                from: { x: startX, y: startY },
+                to: { x: ev.clientX, y: ev.clientY },
+            });
+        };
+        const cancel = () => {
+            window.removeEventListener("pointerup", up);
+            window.removeEventListener("pointercancel", cancel);
+        };
+        window.addEventListener("pointerup", up);
+        window.addEventListener("pointercancel", cancel);
+    };
+    // Late-bound refs (Solid assigns `ref` after mount) still get the grab.
+    createEffect(() => {
+        const el = ref();
+        if (!el)
+            return;
+        el.addEventListener("pointerdown", onDown);
+        onCleanup(() => el.removeEventListener("pointerdown", onDown));
+    });
+    return { lastSwipe, reset: () => setLastSwipe(null) };
+}

package/dist/index.d.ts

@@ -20,6 +20,7 @@ export { createScrollColor, type ScrollColorStop, type ScrollColorOptions, type
 export { createVelocity, type VelocityOptions } from "./velocity.js";
 export { createMagnetic, type MagneticOptions, type MagneticResult, createTilt, type TiltOptions, type TiltResult, createTiltCard, type TiltCardOptions, type TiltCardResult, } from "./pointer.js";
 export { createTrail, type TrailOptions } from "./trail.js";
+export { createDepixelate, type DepixelateOptions, type DepixelateStatus, type DepixelateControls, } from "./depixelate.js";
 export { createTimeline, type TimelineStep, type TimelineStatus, type TimelineControls, } from "./timeline.js";
 export { animateFlip, type FlipOptions, createSharedLayout, type SharedLayoutOptions, type SharedLayoutResult, } from "./flip.js";
 export { createToast, type Toast, type ToastControls, type ToastKind, type ToastOptions, type ToastQueueOptions, type ToastState, } from "./toast.js";
@@ -29,7 +30,7 @@ export { createFontSwap, type FontSwapOptions, type FontSwapResult, createTyping
 export { easings, cubicBezier, linear, easeInQuad, easeOutQuad, easeInOutQuad, easeInCubic, easeOutCubic, easeInOutCubic, easeInQuart, easeOutQuart, easeInOutQuart, easeOutExpo, easeOutBack, easeInBack, easeInOutBack, easeOutElastic, easeOutBounce, resolveEasing, type Easing, type EasingName, } from "./easing.js";
 export { createKineticType, createScenePlayer, createShowreel, createCamera, createColorShift, createTransition, createBeat, createBeatCuts, } from "./motion.js";
 export type { KineticTypeFrom, KineticTypeOptions, KineticTypeStatus, KineticTypeControls, MotionScene, ScenePlayerStatus, ScenePlayerControls, ShowreelScene, ShowreelSceneKind, CameraKeyframe, CameraOptions, ColorShiftOptions, ColorShiftStatus, ColorShiftControls, TransitionType, TransitionDirection, TransitionOptions, TransitionLayerStyle, TransitionStatus, TransitionControls, BeatOptions, BeatStatus, BeatControls, BeatCutOptions, } from "./motion.js";
-export { createDrag, type DragStatus, type DragAxis, type DragConstraints, type DragEndInfo, type DragOptions, type DragControls, } from "./gesture.js";
+export { createDrag, type DragStatus, type DragAxis, type DragConstraints, type DragEndInfo, type DragOptions, type DragControls, createSwipe, type SwipeDirection, type SwipeDetails, type SwipeOptions, type SwipeControls, } from "./gesture.js";
 export { createStreamReveal, createAgentState, parseDriftSpec, createSpecPlayer, DriftSpecError, } from "./ai.js";
 export type { StreamRevealStatus, StreamRevealOptions, StreamRevealControls, AgentState, AgentStateTransition, AgentStateOptions, AgentStateControls, DriftSpecPrimitive, DriftSpecStep, DriftSpec, SpecPlayerStatus, SpecPlayerHooks, SpecPlayerControls, } from "./ai.js";
 export { createTxLifecycle, createTicker, createMintReveal, createConnectButton, createAgentTx, } from "./web3.js";

package/dist/index.js

@@ -20,6 +20,7 @@ export { createScrollColor, createScrollTracking, createScrollLine, } from "./sc
 export { createVelocity } from "./velocity.js";
 export { createMagnetic, createTilt, createTiltCard, } from "./pointer.js";
 export { createTrail } from "./trail.js";
+export { createDepixelate, } from "./depixelate.js";
 export { createTimeline, } from "./timeline.js";
 export { animateFlip, createSharedLayout, } from "./flip.js";
 export { createToast, } from "./toast.js";
@@ -28,7 +29,7 @@ export { createGravity, createPendulum, createFling, } from "./physics.js";
 export { createFontSwap, createTyping, createTextPhysics, createTextTunnel, createTextCutout, createTextGradient, createTextScramble, createTextWave, createCountUp, } from "./typography.js";
 export { easings, cubicBezier, linear, easeInQuad, easeOutQuad, easeInOutQuad, easeInCubic, easeOutCubic, easeInOutCubic, easeInQuart, easeOutQuart, easeInOutQuart, easeOutExpo, easeOutBack, easeInBack, easeInOutBack, easeOutElastic, easeOutBounce, resolveEasing, } from "./easing.js";
 export { createKineticType, createScenePlayer, createShowreel, createCamera, createColorShift, createTransition, createBeat, createBeatCuts, } from "./motion.js";
-export { createDrag, } from "./gesture.js";
+export { createDrag, createSwipe, } from "./gesture.js";
 export { createStreamReveal, createAgentState, parseDriftSpec, createSpecPlayer, DriftSpecError, } from "./ai.js";
 export { createTxLifecycle, createTicker, createMintReveal, createConnectButton, createAgentTx, } from "./web3.js";
 export { createPoll, shortenAddress, isAddress, formatUnits, parseUnits, CHAINS, createChain, createTokenPrice, createPriceChange, createPriceCompare, createGasPrice, createBalance, createTxReceipt, createBlockNumber, createChainlinkPrice, createNFTMetadata, createENS, createIdenticon, } from "./web3data.js";

package/package.json

@@ -43,5 +43,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "0.18.0"
+  "version": "0.20.0"
 }