3d-spinner 0.9.0

package/dist/engines/little-tween-engine/core/tweens.js

@@ -0,0 +1,231 @@
+function input(value, overextend) {
+    if (Number.isNaN(value))
+        return 0;
+    if (overextend)
+        return value;
+    return Math.min(1, Math.max(0, value));
+}
+export function linear(value, overextend = false) {
+    return input(value, overextend);
+}
+export function quadratic(value, overextend = false) {
+    return easeInQuad(value, overextend);
+}
+export function cubic(value, overextend = false) {
+    return easeInCubic(value, overextend);
+}
+export function quartic(value, overextend = false) {
+    return easeInQuart(value, overextend);
+}
+export function quintic(value, overextend = false) {
+    return easeInQuint(value, overextend);
+}
+export function easeInSine(value, overextend = false) {
+    const x = input(value, overextend);
+    return 1 - Math.cos((x * Math.PI) / 2);
+}
+export function easeOutSine(value, overextend = false) {
+    const x = input(value, overextend);
+    return Math.sin((x * Math.PI) / 2);
+}
+export function easeInOutSine(value, overextend = false) {
+    const x = input(value, overextend);
+    return -(Math.cos(Math.PI * x) - 1) / 2;
+}
+export function easeInQuad(value, overextend = false) {
+    const x = input(value, overextend);
+    return x * x;
+}
+export function easeOutQuad(value, overextend = false) {
+    const x = input(value, overextend);
+    return 1 - (1 - x) * (1 - x);
+}
+export function easeInOutQuad(value, overextend = false) {
+    const x = input(value, overextend);
+    return x < 0.5 ? 2 * x * x : 1 - Math.pow(-2 * x + 2, 2) / 2;
+}
+export function easeInCubic(value, overextend = false) {
+    const x = input(value, overextend);
+    return x * x * x;
+}
+export function easeOutCubic(value, overextend = false) {
+    const x = input(value, overextend);
+    return 1 - Math.pow(1 - x, 3);
+}
+export function easeInOutCubic(value, overextend = false) {
+    const x = input(value, overextend);
+    return x < 0.5 ? 4 * x * x * x : 1 - Math.pow(-2 * x + 2, 3) / 2;
+}
+export function easeInQuart(value, overextend = false) {
+    const x = input(value, overextend);
+    return x * x * x * x;
+}
+export function easeOutQuart(value, overextend = false) {
+    const x = input(value, overextend);
+    return 1 - Math.pow(1 - x, 4);
+}
+export function easeInOutQuart(value, overextend = false) {
+    const x = input(value, overextend);
+    return x < 0.5 ? 8 * x * x * x * x : 1 - Math.pow(-2 * x + 2, 4) / 2;
+}
+export function easeInQuint(value, overextend = false) {
+    const x = input(value, overextend);
+    return x * x * x * x * x;
+}
+export function easeOutQuint(value, overextend = false) {
+    const x = input(value, overextend);
+    return 1 - Math.pow(1 - x, 5);
+}
+export function easeInOutQuint(value, overextend = false) {
+    const x = input(value, overextend);
+    return x < 0.5 ? 16 * x * x * x * x * x : 1 - Math.pow(-2 * x + 2, 5) / 2;
+}
+export function easeInExpo(value, overextend = false) {
+    const x = input(value, overextend);
+    return x === 0 ? 0 : Math.pow(2, 10 * x - 10);
+}
+export function easeOutExpo(value, overextend = false) {
+    const x = input(value, overextend);
+    return x === 1 ? 1 : 1 - Math.pow(2, -10 * x);
+}
+export function easeInOutExpo(value, overextend = false) {
+    const x = input(value, overextend);
+    return x === 0
+        ? 0
+        : x === 1
+            ? 1
+            : x < 0.5
+                ? Math.pow(2, 20 * x - 10) / 2
+                : (2 - Math.pow(2, -20 * x + 10)) / 2;
+}
+export function easeInCirc(value, overextend = false) {
+    const x = input(value, overextend);
+    return 1 - Math.sqrt(1 - Math.pow(x, 2));
+}
+export function easeOutCirc(value, overextend = false) {
+    const x = input(value, overextend);
+    return Math.sqrt(1 - Math.pow(x - 1, 2));
+}
+export function easeInOutCirc(value, overextend = false) {
+    const x = input(value, overextend);
+    return x < 0.5
+        ? (1 - Math.sqrt(1 - Math.pow(2 * x, 2))) / 2
+        : (Math.sqrt(1 - Math.pow(-2 * x + 2, 2)) + 1) / 2;
+}
+export function easeInBack(value, overextend = false) {
+    const x = input(value, overextend);
+    const c1 = 1.70158;
+    const c3 = c1 + 1;
+    return c3 * x * x * x - c1 * x * x;
+}
+export function easeOutBack(value, overextend = false) {
+    const x = input(value, overextend);
+    const c1 = 1.70158;
+    const c3 = c1 + 1;
+    return 1 + c3 * Math.pow(x - 1, 3) + c1 * Math.pow(x - 1, 2);
+}
+export function easeInOutBack(value, overextend = false) {
+    const x = input(value, overextend);
+    const c1 = 1.70158;
+    const c2 = c1 * 1.525;
+    return x < 0.5
+        ? (Math.pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2)) / 2
+        : (Math.pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2;
+}
+export function easeInElastic(value, overextend = false) {
+    const x = input(value, overextend);
+    const c4 = (2 * Math.PI) / 3;
+    return x === 0
+        ? 0
+        : x === 1
+            ? 1
+            : -Math.pow(2, 10 * x - 10) * Math.sin((x * 10 - 10.75) * c4);
+}
+export function easeOutElastic(value, overextend = false) {
+    const x = input(value, overextend);
+    const c4 = (2 * Math.PI) / 3;
+    return x === 0
+        ? 0
+        : x === 1
+            ? 1
+            : Math.pow(2, -10 * x) * Math.sin((x * 10 - 0.75) * c4) + 1;
+}
+export function easeInOutElastic(value, overextend = false) {
+    const x = input(value, overextend);
+    const c5 = (2 * Math.PI) / 4.5;
+    return x === 0
+        ? 0
+        : x === 1
+            ? 1
+            : x < 0.5
+                ? -(Math.pow(2, 20 * x - 10) * Math.sin((20 * x - 11.125) * c5)) / 2
+                : (Math.pow(2, -20 * x + 10) * Math.sin((20 * x - 11.125) * c5)) / 2 + 1;
+}
+export function easeInBounce(value, overextend = false) {
+    const x = input(value, overextend);
+    return 1 - easeOutBounce(1 - x, true);
+}
+export function easeOutBounce(value, overextend = false) {
+    let x = input(value, overextend);
+    const n1 = 7.5625;
+    const d1 = 2.75;
+    if (x < 1 / d1) {
+        return n1 * x * x;
+    }
+    if (x < 2 / d1) {
+        x -= 1.5 / d1;
+        return n1 * x * x + 0.75;
+    }
+    if (x < 2.5 / d1) {
+        x -= 2.25 / d1;
+        return n1 * x * x + 0.9375;
+    }
+    x -= 2.625 / d1;
+    return n1 * x * x + 0.984375;
+}
+export function easeInOutBounce(value, overextend = false) {
+    const x = input(value, overextend);
+    return x < 0.5
+        ? (1 - easeOutBounce(1 - 2 * x, true)) / 2
+        : (1 + easeOutBounce(2 * x - 1, true)) / 2;
+}
+export const easeTypes = {
+    linear,
+    quadratic,
+    cubic,
+    quartic,
+    quintic,
+    easeInSine,
+    easeOutSine,
+    easeInOutSine,
+    easeInQuad,
+    easeOutQuad,
+    easeInOutQuad,
+    easeInCubic,
+    easeOutCubic,
+    easeInOutCubic,
+    easeInQuart,
+    easeOutQuart,
+    easeInOutQuart,
+    easeInQuint,
+    easeOutQuint,
+    easeInOutQuint,
+    easeInExpo,
+    easeOutExpo,
+    easeInOutExpo,
+    easeInCirc,
+    easeOutCirc,
+    easeInOutCirc,
+    easeInBack,
+    easeOutBack,
+    easeInOutBack,
+    easeInElastic,
+    easeOutElastic,
+    easeInOutElastic,
+    easeInBounce,
+    easeOutBounce,
+    easeInOutBounce,
+};
+export function ease(type, value, overextend = false) {
+    return easeTypes[type](value, overextend);
+}

package/dist/engines/little-tween-engine/little-tween-engine.d.ts

@@ -0,0 +1,21 @@
+import { type EaseType } from "./core/tweens.js";
+/** Options for {@link LittleTweenEngine}. */
+export interface LittleTweenEngineOptions {
+    /** Ease curve used when one is not provided to {@link LittleTweenEngine.value}. */
+    type?: EaseType;
+    /** Allow input values outside 0..1. Default `false` clamps input to 0..1. */
+    overextend?: boolean;
+}
+/**
+ * A small zero-dependency tween engine for mapping progress values through
+ * named easing curves.
+ */
+export declare class LittleTweenEngine {
+    private readonly type;
+    private readonly overextend;
+    constructor(options?: LittleTweenEngineOptions);
+    /** Map `value` through the selected ease type. */
+    value(value: number, type?: EaseType, overextend?: boolean): number;
+}
+export { ease, easeTypes, linear, quadratic, cubic, quartic, quintic, easeInSine, easeOutSine, easeInOutSine, easeInQuad, easeOutQuad, easeInOutQuad, easeInCubic, easeOutCubic, easeInOutCubic, easeInQuart, easeOutQuart, easeInOutQuart, easeInQuint, easeOutQuint, easeInOutQuint, easeInExpo, easeOutExpo, easeInOutExpo, easeInCirc, easeOutCirc, easeInOutCirc, easeInBack, easeOutBack, easeInOutBack, easeInElastic, easeOutElastic, easeInOutElastic, easeInBounce, easeOutBounce, easeInOutBounce, } from "./core/tweens.js";
+export type { EaseFunction, EaseType } from "./core/tweens.js";

package/dist/engines/little-tween-engine/little-tween-engine.js

@@ -0,0 +1,16 @@
+import { ease } from "./core/tweens.js";
+/**
+ * A small zero-dependency tween engine for mapping progress values through
+ * named easing curves.
+ */
+export class LittleTweenEngine {
+    constructor(options = {}) {
+        this.type = options.type ?? "linear";
+        this.overextend = options.overextend ?? false;
+    }
+    /** Map `value` through the selected ease type. */
+    value(value, type = this.type, overextend = this.overextend) {
+        return ease(type, value, overextend);
+    }
+}
+export { ease, easeTypes, linear, quadratic, cubic, quartic, quintic, easeInSine, easeOutSine, easeInOutSine, easeInQuad, easeOutQuad, easeInOutQuad, easeInCubic, easeOutCubic, easeInOutCubic, easeInQuart, easeOutQuart, easeInOutQuart, easeInQuint, easeOutQuint, easeInOutQuint, easeInExpo, easeOutExpo, easeInOutExpo, easeInCirc, easeOutCirc, easeInOutCirc, easeInBack, easeOutBack, easeInOutBack, easeInElastic, easeOutElastic, easeInOutElastic, easeInBounce, easeOutBounce, easeInOutBounce, } from "./core/tweens.js";

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+import type { SpinnerAnimation } from "./animation.js";
+/** A spinner driven by real progress the caller reports via {@link Spinner.setProgress}. */
+export interface ProgressSpinnerOptions {
+    type?: "progress";
+    /** The visual to play. */
+    animation: SpinnerAnimation;
+    /**
+     * Initial progress 0..1. A value above 0 plays the intro immediately; omit it
+     * to start idle until {@link Spinner.setProgress} is called.
+     */
+    progress?: number;
+    /** Auto-complete (drive progress to 1, playing the outro) after this many ms. */
+    timeout?: number;
+    /** Auto-complete at this absolute time. If both are set, the earlier wins. */
+    until?: Date;
+}
+/** A self-driving spinner: it loops a synthetic progress on a timer until stopped. */
+export interface IndeterminateSpinnerOptions {
+    type: "indeterminate";
+    /** The visual to play. */
+    animation: SpinnerAnimation;
+    /** `"bounce"` ramps 0->1->0; `"restart"` ramps 0->1 then repeats. Default `"bounce"`. */
+    loop?: "bounce" | "restart";
+    /** Milliseconds for one 0->1 sweep. Must be finite and greater than zero. Default `2000`. */
+    periodMs?: number;
+}
+export type SpinnerOptions = ProgressSpinnerOptions | IndeterminateSpinnerOptions;
+export interface Spinner {
+    /** Set the progress target (0..1). No-op for an indeterminate spinner. */
+    setProgress(target: number): void;
+    /** Play the outro, then stop animating (keeps the injected DOM in place). */
+    stop(): void;
+    /** Stop immediately and remove the injected DOM (no outro). Safe to call more than once. */
+    destroy(): void;
+}
+export declare function createSpinner(target: HTMLElement, options: SpinnerOptions): Spinner;
+export type { SpinnerAnimation, AnimationFrame } from "./animation.js";

package/dist/index.js

@@ -0,0 +1,110 @@
+function clamp01(value) {
+    if (Number.isNaN(value))
+        return 0;
+    return Math.min(1, Math.max(0, value));
+}
+function lerp(from, to, t) {
+    return from + (to - from) * t;
+}
+export function createSpinner(target, options) {
+    if (!(target instanceof HTMLElement)) {
+        throw new Error("3d-spinner: createSpinner requires a target HTMLElement.");
+    }
+    const { animation } = options;
+    const indeterminate = options.type === "indeterminate";
+    if (indeterminate &&
+        options.periodMs !== undefined &&
+        (!Number.isFinite(options.periodMs) || options.periodMs <= 0)) {
+        throw new RangeError("3d-spinner: periodMs must be a finite number greater than zero.");
+    }
+    animation.mount(target);
+    const start = performance.now();
+    let rafId = 0;
+    let stopped = false;
+    let destroyed = false;
+    let entered = false;
+    let exiting = false;
+    // Progress source (determinate only).
+    let current = 0;
+    let targetProgress = 0;
+    let deadline = Infinity;
+    if (!indeterminate) {
+        const opts = options;
+        if (typeof opts.progress === "number") {
+            current = clamp01(opts.progress);
+            targetProgress = current;
+        }
+        if (typeof opts.timeout === "number")
+            deadline = Math.min(deadline, start + opts.timeout);
+        if (opts.until instanceof Date)
+            deadline = Math.min(deadline, opts.until.getTime());
+    }
+    function computeProgress(now) {
+        if (!indeterminate) {
+            if (now >= deadline)
+                targetProgress = 1;
+            current = lerp(current, targetProgress, 0.12);
+            if (Math.abs(targetProgress - current) < 0.0005)
+                current = targetProgress;
+            return current;
+        }
+        const opts = options;
+        const period = opts.periodMs ?? 2000;
+        const t = (now - start) / period;
+        if ((opts.loop ?? "bounce") === "restart")
+            return t - Math.floor(t);
+        const phase = t - 2 * Math.floor(t / 2); // 0..2
+        return phase <= 1 ? phase : 2 - phase; // triangle 0..1..0
+    }
+    function frame(now) {
+        if (stopped)
+            return;
+        const progress = computeProgress(now);
+        if (!entered && (indeterminate || progress > 0)) {
+            animation.enter(now);
+            entered = true;
+        }
+        if (!exiting && entered && !indeterminate && progress >= 1 && targetProgress >= 1) {
+            animation.exit(now);
+            exiting = true;
+        }
+        const target = indeterminate ? progress : targetProgress;
+        animation.render(now, { progress, targetProgress: target, indeterminate });
+        if (exiting && animation.isFinished()) {
+            halt();
+            return;
+        }
+        rafId = requestAnimationFrame(frame);
+    }
+    function halt() {
+        if (stopped)
+            return;
+        stopped = true;
+        if (rafId)
+            cancelAnimationFrame(rafId);
+        rafId = 0;
+    }
+    function setProgress(value) {
+        if (!indeterminate)
+            targetProgress = clamp01(value);
+    }
+    function stop() {
+        if (stopped || exiting)
+            return;
+        if (!entered) {
+            halt();
+            return;
+        }
+        animation.exit(performance.now());
+        exiting = true;
+    }
+    function destroy() {
+        if (destroyed)
+            return;
+        destroyed = true;
+        halt();
+        animation.destroy();
+    }
+    rafId = requestAnimationFrame(frame);
+    return { setProgress, stop, destroy };
+}

package/dist/motion/circle.d.ts

@@ -0,0 +1,17 @@
+import type { MotionController } from "./controller.js";
+/** Options for {@link circleMotion}. */
+export interface CircleMotionOptions {
+    /** Circle radius in scene units. Default `1.3`. */
+    radius?: number;
+    /** Milliseconds for one full revolution. Default `3000`. */
+    periodMs?: number;
+    /** Tilt of the circle's plane about the X axis, radians. `0` faces the camera. Default `0.5`. */
+    tilt?: number;
+    /** Travel direction: `1` counter-clockwise, `-1` clockwise. Default `1`. */
+    direction?: number;
+}
+/**
+ * Orbits a circular path, nose following the tangent. `tilt` leans the circle
+ * away from the camera so it reads as a 3D orbit rather than a flat ring.
+ */
+export declare function circleMotion(options?: CircleMotionOptions): MotionController;

package/dist/motion/circle.js

@@ -0,0 +1,20 @@
+/**
+ * Orbits a circular path, nose following the tangent. `tilt` leans the circle
+ * away from the camera so it reads as a 3D orbit rather than a flat ring.
+ */
+export function circleMotion(options = {}) {
+    const radius = options.radius ?? 1.3;
+    const periodMs = options.periodMs ?? 3000;
+    const tilt = options.tilt ?? 0.5;
+    const direction = options.direction ?? 1;
+    const cosTilt = Math.cos(tilt);
+    const sinTilt = Math.sin(tilt);
+    return {
+        positionAt(t) {
+            const angle = ((direction * t) / periodMs) * Math.PI * 2;
+            const x = radius * Math.cos(angle);
+            const flatY = radius * Math.sin(angle);
+            return { x, y: flatY * cosTilt, z: flatY * sinTilt };
+        },
+    };
+}

package/dist/motion/controller.d.ts

@@ -0,0 +1,13 @@
+import type { Vec3 } from "../engines/little-3d-engine/little-3d-engine.js";
+/**
+ * Describes *how* an object moves: a pure function from time to a position in
+ * scene units. The animation that consumes it derives orientation from the path
+ * tangent, so a controller only has to say where the object is at time `t`.
+ *
+ * `positionAt` must be a pure function of `t` (same input -> same output) so the
+ * path is reproducible and can be sampled at offset times.
+ */
+export interface MotionController {
+    /** Position in scene units at time `t` (milliseconds). */
+    positionAt(t: number): Vec3;
+}

package/dist/motion/controller.js

@@ -0,0 +1 @@
+export {};

package/dist/motion/figure-eight.d.ts

@@ -0,0 +1,13 @@
+import type { MotionController } from "./controller.js";
+/** Options for {@link figureEightMotion}. */
+export interface FigureEightMotionOptions {
+    /** Overall scale of the figure-8 in scene units. Default `1`. */
+    size?: number;
+    /** Milliseconds for one full lap. Default `3600`. */
+    periodMs?: number;
+}
+/**
+ * Flies a seamless 3D figure-8, the same lemniscate path the flight animation
+ * loops on. Nose follows the tangent.
+ */
+export declare function figureEightMotion(options?: FigureEightMotionOptions): MotionController;

package/dist/motion/figure-eight.js

@@ -0,0 +1,23 @@
+// Figure-8 (lemniscate) amplitudes. A closed, periodic curve so it repeats
+// seamlessly; the z term gives it depth so it reads as 3D rather than flat.
+const LOOP_X = 1.5;
+const LOOP_Y = 1.0;
+const LOOP_Z = 1.05;
+/**
+ * Flies a seamless 3D figure-8, the same lemniscate path the flight animation
+ * loops on. Nose follows the tangent.
+ */
+export function figureEightMotion(options = {}) {
+    const size = options.size ?? 1;
+    const periodMs = options.periodMs ?? 3600;
+    return {
+        positionAt(t) {
+            const a = (t / periodMs) * Math.PI * 2;
+            return {
+                x: size * LOOP_X * Math.sin(a),
+                y: size * LOOP_Y * Math.sin(a) * Math.cos(a),
+                z: size * LOOP_Z * Math.cos(a),
+            };
+        },
+    };
+}

package/dist/motion/motion.d.ts

@@ -0,0 +1,5 @@
+export type { MotionController } from "./controller.js";
+export { circleMotion, type CircleMotionOptions } from "./circle.js";
+export { squareMotion, type SquareMotionOptions } from "./square.js";
+export { figureEightMotion, type FigureEightMotionOptions } from "./figure-eight.js";
+export { wanderMotion, type WanderMotionOptions, type WanderBounds, } from "./wander.js";

package/dist/motion/motion.js

@@ -0,0 +1,4 @@
+export { circleMotion } from "./circle.js";
+export { squareMotion } from "./square.js";
+export { figureEightMotion } from "./figure-eight.js";
+export { wanderMotion, } from "./wander.js";

package/dist/motion/square.d.ts

@@ -0,0 +1,17 @@
+import type { MotionController } from "./controller.js";
+/** Options for {@link squareMotion}. */
+export interface SquareMotionOptions {
+    /** Side length of the square in scene units. Default `2.4`. */
+    size?: number;
+    /** Milliseconds for one full lap of the perimeter. Default `4000`. */
+    periodMs?: number;
+    /** Tilt of the square's plane about the X axis, radians. `0` faces the camera. Default `0.45`. */
+    tilt?: number;
+    /** Travel direction: `1` counter-clockwise, `-1` clockwise. Default `1`. */
+    direction?: number;
+}
+/**
+ * Travels the perimeter of a square at constant speed, turning sharply at each
+ * corner. `tilt` leans the square away from the camera for a 3D read.
+ */
+export declare function squareMotion(options?: SquareMotionOptions): MotionController;

package/dist/motion/square.js

@@ -0,0 +1,39 @@
+/**
+ * Travels the perimeter of a square at constant speed, turning sharply at each
+ * corner. `tilt` leans the square away from the camera for a 3D read.
+ */
+export function squareMotion(options = {}) {
+    const half = (options.size ?? 2.4) / 2;
+    const periodMs = options.periodMs ?? 4000;
+    const tilt = options.tilt ?? 0.45;
+    const direction = options.direction ?? 1;
+    const cosTilt = Math.cos(tilt);
+    const sinTilt = Math.sin(tilt);
+    return {
+        positionAt(t) {
+            const lap = (direction * t) / periodMs;
+            const s = (lap - Math.floor(lap)) * 4; // 0..4 around the four edges
+            const edge = Math.floor(s);
+            const f = s - edge;
+            let flatX;
+            let flatY;
+            if (edge === 0) {
+                flatX = -half + 2 * half * f;
+                flatY = -half;
+            }
+            else if (edge === 1) {
+                flatX = half;
+                flatY = -half + 2 * half * f;
+            }
+            else if (edge === 2) {
+                flatX = half - 2 * half * f;
+                flatY = half;
+            }
+            else {
+                flatX = -half;
+                flatY = half - 2 * half * f;
+            }
+            return { x: flatX, y: flatY * cosTilt, z: flatY * sinTilt };
+        },
+    };
+}

package/dist/motion/transitions.d.ts

@@ -0,0 +1,44 @@
+import type { Vec3 } from "../engines/little-3d-engine/little-3d-engine.js";
+export type ObjectMotionTransitionPhase = "intro" | "outro";
+export interface ObjectMotionTransitionInput {
+    /** How far through the transition we are, from `0` to `1`. */
+    delta: number;
+    /** Intro endpoint or outro startpoint where the real motion path hands off. */
+    position: Vec3;
+    /** Unit direction of travel at the handoff point, when available. */
+    direction?: Vec3;
+    /** Velocity at the handoff point in scene units per millisecond, when available. */
+    velocity?: Vec3;
+    /** Full-size scale for the object, when relevant. */
+    size?: number;
+    /** Transition duration in milliseconds. */
+    durationMs: number;
+    /** Elapsed transition time in milliseconds. */
+    elapsedMs: number;
+    /** Whether this is running before or after the real motion path. */
+    phase: ObjectMotionTransitionPhase;
+}
+export interface ObjectMotionTransitionOutput {
+    /** Override position for this frame. */
+    position?: Vec3;
+    /** Override scale for this frame. */
+    size?: number;
+    /** Override engine Euler orientation for this frame. */
+    orientation?: Vec3;
+}
+export type ObjectMotionTransition = (input: ObjectMotionTransitionInput) => ObjectMotionTransitionOutput;
+export interface ObjectMotionTransitionWithDuration {
+    transition: ObjectMotionTransition;
+    durationMs?: number;
+}
+export type ObjectMotionTransitionConfig = ObjectMotionTransition | ObjectMotionTransitionWithDuration;
+export interface DirectionTransitionOptions {
+    /** Direction to travel in. Defaults to the path direction at the handoff point. */
+    direction?: Vec3;
+    /** Distance to travel when no useful velocity is supplied. Default `3.5`. */
+    distance?: number;
+}
+export declare function enterFromObjectDirection(options?: DirectionTransitionOptions): ObjectMotionTransition;
+export declare function leaveInObjectDirection(options?: DirectionTransitionOptions): ObjectMotionTransition;
+export declare function grow(): ObjectMotionTransition;
+export declare function shrink(): ObjectMotionTransition;