anim-engine 0.3.1 → 0.4.0

package/README.md

@@ -81,7 +81,7 @@ By restricting itself to numeric values, the engine eliminates string parsing, c
 | 🧩 **Composable models**     | Animations, keyframes, and timelines compose cleanly — put tweens inside timelines, nest keyframes anywhere.                        |
 | 🔄 **Continuous primitives** | Spring, smooth damp, and lerp chase live targets with zero setup — pass `() => value` for dynamic targets.                          |
 | 🚫 **No GC pressure**        | Zero object allocations in hot update paths. State is mutated in place.                                                             |
-| 🎨 **Perceptual color**      | Oklab interpolation via `lerpOklab` — no muddy browns. Compose it into any `onUpdate`.                                              |
+| 🎨 **Perceptual color**      | Oklab interpolation via `lerpRgba` — no muddy browns. Compose it into any `onUpdate`.                                               |
 | 📐 **TypeScript-first**      | Full type exports, exhaustive discriminated unions, no `any`.                                                                       |
 | 🔧 **Ticker control**        | Bring your own game loop or use the built-in rAF ticker. Explicit — never auto-starts.                                              |
 
@@ -112,7 +112,7 @@ Interpolations have `start()`/`stop()`/`kill()` controls, auto-start on creation
 | Primitive                                 | Returns              | Description                                   |
 | ----------------------------------------- | -------------------- | --------------------------------------------- |
 | [`createSmoothClamp`](#createsmoothclamp) | `(n: number) => n`   | Asymptotic clamp — saturates toward threshold |
-| [`lerpOklab` / `hexToRgba`](#color)       | `RgbaTuple` / parser | Perceptually uniform color interpolation      |
+| [`lerpRgba` / `hexToRgba`](#color)        | `RgbaTuple` / parser | Perceptually uniform color interpolation      |
 
 ## Usage
 
@@ -381,7 +381,7 @@ Uses `threshold * (normalized / (1 + |normalized|))` for asymptotic saturation.
 Perceptually uniform Oklab interpolation. Straight RGB lerp produces muddy transitions — red→green goes through brown, blue→yellow goes through grey. Oklab matches human perception: equal steps look like equal changes.
 
 ```ts
-import { lerpOklab, hexToRgba } from "anim-engine";
+import { lerpRgba, hexToRgba } from "anim-engine";
 
 hexToRgba("#ff6b6b"); // → [1, 0.42, 0.42, 1]
 hexToRgba("#f80"); // → [1, 0.533, 0, 1] (shorthand)
@@ -396,7 +396,7 @@ createAnimation({
   durationMs: 2000,
   ease: "outCubic",
   onUpdate: (t) => {
-    const [r, g, b, a] = lerpOklab(fromColor, toColor, t);
+    const [r, g, b, a] = lerpRgba(fromColor, toColor, t);
     sprite.setColor(r, g, b, a);
   },
 });
@@ -405,7 +405,7 @@ createAnimation({
 **With continuous primitives** — drive the blend factor via spring, damp, or lerp:
 
 ```ts
-import { createSpring, lerpOklab, hexToRgba } from "anim-engine";
+import { createSpring, lerpRgba, hexToRgba } from "anim-engine";
 
 const fromColor = hexToRgba("#ff6b6b");
 const toColor = hexToRgba("#4ecdc4");
@@ -416,7 +416,7 @@ const spring = createSpring({
   stiffness: 180,
   damping: 12,
   onUpdate: (t) => {
-    const [r, g, b] = lerpOklab(fromColor, toColor, t);
+    const [r, g, b] = lerpRgba(fromColor, toColor, t);
     sprite.setColor(r, g, b, 1);
   },
 });
@@ -658,7 +658,7 @@ requestAnimationFrame(gameLoop);
 | `createSmoothClamp(threshold)`     | Asymptotic clamp factory            |
 | `getTicker()`                      | Singleton ticker                    |
 | `cubicBezier(p1x, p1y, p2x, p2y)`  | Custom cubic bezier easing          |
-| `lerpOklab(from, to, t)`           | Oklab color interpolation           |
+| `lerpRgba(from, to, t)`            | Oklab color interpolation           |
 | `hexToRgba(hex)`                   | Parse hex color to normalized RGBA  |
 
 ### Type exports
@@ -681,7 +681,7 @@ requestAnimationFrame(gameLoop);
 | `SmoothDampOptions`        | `to`, `smoothTimeMs`, `maxSpeed?`, `precision?`, `onUpdate`, `onEnded`                                                  |
 | `LerpOptions`              | `to`, `smoothTimeMs`, `precision?`, `onUpdate`, `onEnded`                                                               |
 | `RgbaTuple`                | `readonly [number, number, number, number]`                                                                             |
-| `TickerControls`           | `start`, `stop`, `update`, `add`, `remove`                                                                              |
+| `Ticker`                   | `start`, `stop`, `update`, `add`, `remove`                                                                              |
 
 ## License
 

package/dist/animation/create-animation.d.ts

@@ -1,24 +1,2 @@
-import { Animation, DynamicValue, EaseFunction, EaseName } from '../shared/types';
-export type SingleTweenOptions = {
-    from: DynamicValue;
-    to: DynamicValue;
-    durationMs: DynamicValue;
-    ease?: EaseName | EaseFunction;
-    onStarted?: () => void;
-    onUpdate?: (value: number, velocity: number) => void;
-    onEnded?: () => void;
-};
-export type Keyframe = {
-    value: DynamicValue;
-    ease?: EaseName | EaseFunction;
-    gap?: DynamicValue;
-};
-export type KeyframeAnimationOptions = {
-    keyframes: Keyframe[];
-    onStarted?: () => void;
-    onUpdate?: (value: number, velocity: number) => void;
-    onProgress?: (progress: number) => void;
-    onEnded?: () => void;
-};
-export type AnimationOptions = SingleTweenOptions | KeyframeAnimationOptions;
+import { AnimationOptions, Animation } from '../domain';
 export declare const createAnimation: (options: AnimationOptions) => Animation;

package/dist/animation/create-animation.js

@@ -1,9 +1,8 @@
-import { easingFunctions } from "../easing/easing.js";
+import { resolveEasing } from "../domain/easing.js";
+import { resolveValue } from "../domain/resolve-value.js";
 import { getTicker } from "../ticker/get-ticker.js";
 import { createKeyframeRunner, createTweenRunner } from "./runner.js";
 //#region src/animation/create-animation.ts
-var resolveEasing = (ease) => typeof ease === "function" ? ease : easingFunctions[ease];
-var resolveValue = (v) => typeof v === "function" ? v() : v;
 var isKeyframeMode = (options) => {
 	return "keyframes" in options && Array.isArray(options.keyframes);
 };
@@ -11,23 +10,20 @@ var createAnimation = (options) => {
 	if (isKeyframeMode(options)) return createKeyframeAnimation(options);
 	return createSingleTween(options);
 };
-var createSingleTween = (options) => {
-	const easeName = options.ease ?? "inOutSine";
-	const { onStarted, onUpdate, onEnded } = options;
-	const rawFrom = options.from;
-	const rawTo = options.to;
-	const rawDurationMs = options.durationMs;
+var createSingleTween = ({ onStarted, onUpdate, onProgress, onEnded, from: rawFrom, to: rawTo, durationMs: rawDurationMs, ease: easeName = "inOutSine" }) => {
 	let cachedDurationMs = resolveValue(rawDurationMs);
 	let status = "stopped";
+	const hasDynamicProperty = typeof rawFrom === "function" || typeof rawTo === "function" || typeof rawDurationMs === "function";
 	let resolvePromise;
 	const ticker = getTicker();
-	let runner;
-	const finish = () => {
+	const handleEnded = () => {
 		status = "stopped";
 		ticker.remove(runner);
-		resolvePromise?.(controls);
+		resolvePromise?.();
+		onEnded?.();
 		resolvePromise = void 0;
 	};
+	let runner;
 	const buildRunner = () => {
 		const from = resolveValue(rawFrom);
 		const to = resolveValue(rawTo);
@@ -39,15 +35,14 @@ var createSingleTween = (options) => {
 			easeFn: resolveEasing(easeName),
 			onStarted,
 			onUpdate,
-			onEnded,
-			onComplete: finish
+			onProgress,
+			onEnded: handleEnded
 		});
 	};
-	const hasDynamic = typeof rawFrom === "function" || typeof rawTo === "function" || typeof rawDurationMs === "function";
 	runner = buildRunner();
 	const play = () => {
 		if (status === "dead") throw new Error("Cannot play a dead animation");
-		if (hasDynamic) runner = buildRunner();
+		if (hasDynamicProperty) runner = buildRunner();
 		else runner.reset();
 		const promise = new Promise((resolve) => {
 			resolvePromise = resolve;
@@ -70,7 +65,7 @@ var createSingleTween = (options) => {
 	const stop = () => {
 		status = "stopped";
 		ticker.remove(runner);
-		resolvePromise?.(controls);
+		resolvePromise?.();
 		resolvePromise = void 0;
 	};
 	const skipToEnd = () => {
@@ -78,7 +73,7 @@ var createSingleTween = (options) => {
 		if (status === "playing" || status === "paused") onEnded?.();
 		status = "stopped";
 		ticker.remove(runner);
-		resolvePromise?.(controls);
+		resolvePromise?.();
 		resolvePromise = void 0;
 	};
 	const kill = () => {
@@ -86,7 +81,11 @@ var createSingleTween = (options) => {
 		ticker.remove(runner);
 		resolvePromise = void 0;
 	};
-	const controls = {
+	const setProgress = (value) => {
+		if (status === "playing") pause();
+		runner.evaluate(Math.max(0, Math.min(1, value)));
+	};
+	return {
 		play,
 		pause,
 		resume,
@@ -102,10 +101,7 @@ var createSingleTween = (options) => {
 		get progress() {
 			return runner.progress;
 		},
-		setProgress(value) {
-			if (status === "playing") pause();
-			runner.evaluate(Math.max(0, Math.min(1, value)));
-		},
+		setProgress,
 		get status() {
 			return status;
 		},
@@ -113,10 +109,8 @@ var createSingleTween = (options) => {
 			return cachedDurationMs;
 		}
 	};
-	return controls;
 };
-var createKeyframeAnimation = (options) => {
-	const { keyframes: rawKeyframes, onStarted, onUpdate, onProgress, onEnded } = options;
+var createKeyframeAnimation = ({ keyframes: rawKeyframes, onStarted, onUpdate, onProgress, onEnded }) => {
 	const resolveKeyframeGaps = () => {
 		let total = 0;
 		for (let i = 1; i < rawKeyframes.length; i++) total += resolveValue(rawKeyframes[i].gap ?? 0);
@@ -125,14 +119,16 @@ var createKeyframeAnimation = (options) => {
 	let cachedDurationMs = resolveKeyframeGaps();
 	let status = "stopped";
 	let resolvePromise;
+	const hasDynamicProperty = rawKeyframes.some((kf) => typeof kf.value === "function" || typeof kf.gap === "function");
 	const ticker = getTicker();
-	let runner;
-	const finish = () => {
+	const handleEnded = () => {
 		status = "stopped";
 		ticker.remove(runner);
-		resolvePromise?.(controls);
+		resolvePromise?.();
+		onEnded?.();
 		resolvePromise = void 0;
 	};
+	let runner;
 	const buildRunner = () => {
 		return createKeyframeRunner({
 			keyframes: rawKeyframes.map((kf, i) => ({
@@ -143,15 +139,13 @@ var createKeyframeAnimation = (options) => {
 			onStarted,
 			onUpdate,
 			onProgress,
-			onEnded,
-			onComplete: finish
+			onEnded: handleEnded
 		});
 	};
-	const hasDynamic = rawKeyframes.some((kf) => typeof kf.value === "function" || typeof kf.gap === "function");
 	runner = buildRunner();
 	const play = () => {
 		if (status === "dead") throw new Error("Cannot play a dead animation");
-		if (hasDynamic) {
+		if (hasDynamicProperty) {
 			runner = buildRunner();
 			cachedDurationMs = resolveKeyframeGaps();
 		} else runner.reset();
@@ -176,7 +170,7 @@ var createKeyframeAnimation = (options) => {
 	const stop = () => {
 		status = "stopped";
 		ticker.remove(runner);
-		resolvePromise?.(controls);
+		resolvePromise?.();
 		resolvePromise = void 0;
 	};
 	const skipToEnd = () => {
@@ -184,7 +178,7 @@ var createKeyframeAnimation = (options) => {
 		if (status === "playing" || status === "paused") onEnded?.();
 		status = "stopped";
 		ticker.remove(runner);
-		resolvePromise?.(controls);
+		resolvePromise?.();
 		resolvePromise = void 0;
 	};
 	const kill = () => {
@@ -192,7 +186,11 @@ var createKeyframeAnimation = (options) => {
 		ticker.remove(runner);
 		resolvePromise = void 0;
 	};
-	const controls = {
+	const setProgress = (value) => {
+		if (status === "playing") pause();
+		runner.evaluate(Math.max(0, Math.min(1, value)));
+	};
+	return {
 		play,
 		pause,
 		resume,
@@ -208,10 +206,7 @@ var createKeyframeAnimation = (options) => {
 		get progress() {
 			return runner.progress;
 		},
-		setProgress(value) {
-			if (status === "playing") pause();
-			runner.evaluate(Math.max(0, Math.min(1, value)));
-		},
+		setProgress,
 		get status() {
 			return status;
 		},
@@ -219,7 +214,6 @@ var createKeyframeAnimation = (options) => {
 			return cachedDurationMs;
 		}
 	};
-	return controls;
 };
 //#endregion
 export { createAnimation };

package/dist/animation/create-single-tween.d.ts

@@ -0,0 +1,39 @@
+import { EaseName, AnimationStatus, DynamicValue, EaseFunction } from '../domain';
+export type SingleTweenOptions = {
+    from: DynamicValue;
+    to: DynamicValue;
+    durationMs: DynamicValue;
+    ease?: EaseName | EaseFunction;
+    onStarted?: () => void;
+    onUpdate?: (value: number, velocity: number) => void;
+    onProgress?: (progress: number) => void;
+    onEnded?: () => void;
+};
+export type Keyframe = {
+    value: DynamicValue;
+    ease?: EaseName | EaseFunction;
+    gap?: DynamicValue;
+};
+export type KeyframeAnimationOptions = {
+    keyframes: Keyframe[];
+    onStarted?: () => void;
+    onUpdate?: (value: number, velocity: number) => void;
+    onProgress?: (progress: number) => void;
+    onEnded?: () => void;
+};
+export type AnimationOptions = SingleTweenOptions | KeyframeAnimationOptions;
+export type Animation = {
+    play: () => Promise<void>;
+    pause: () => void;
+    resume: () => void;
+    stop: () => void;
+    skipToEnd: () => void;
+    kill: () => void;
+    currentValue: number;
+    velocity: number;
+    progress: number;
+    setProgress: (value: number) => void;
+    status: AnimationStatus;
+    durationMs: number;
+};
+export declare const createSingleTween: ({ onStarted, onUpdate, onProgress, onEnded, from: rawFrom, to: rawTo, durationMs: rawDurationMs, ease: easeName, }: SingleTweenOptions) => Animation;

package/dist/animation/index.d.ts

@@ -0,0 +1 @@
+export { createAnimation } from './create-animation';

package/dist/animation/runner.d.ts

@@ -1,4 +1,4 @@
-import { EaseFunction } from '../shared/types';
+import { EaseFunction } from '../domain';
 export type Runner = {
     (deltaMs: number): boolean;
     evaluate: (progress: number) => number;
@@ -7,8 +7,6 @@ export type Runner = {
     velocity: number;
     progress: number;
     onStarted: (() => void) | undefined;
-    onUpdate: ((value: number, velocity: number) => void) | undefined;
-    onProgress: ((progress: number) => void) | undefined;
     onEnded: (() => void) | undefined;
 };
 export type TweenRunnerConfig = {
@@ -18,10 +16,10 @@ export type TweenRunnerConfig = {
     easeFn: EaseFunction;
     onStarted?: () => void;
     onUpdate?: (value: number, velocity: number) => void;
-    onEnded?: () => void;
-    onComplete?: () => void;
+    onProgress?: (progress: number) => void;
+    onEnded: () => void;
 };
-export declare const createTweenRunner: (config: TweenRunnerConfig) => Runner;
+export declare const createTweenRunner: ({ from, to, durationMs, easeFn, onStarted, onUpdate, onProgress, onEnded, }: TweenRunnerConfig) => Runner;
 export type KeyframeRunnerConfig = {
     keyframes: {
         value: number;
@@ -32,6 +30,5 @@ export type KeyframeRunnerConfig = {
     onUpdate?: (value: number, velocity: number) => void;
     onProgress?: (progress: number) => void;
     onEnded?: () => void;
-    onComplete?: () => void;
 };
-export declare const createKeyframeRunner: (config: KeyframeRunnerConfig) => Runner;
+export declare const createKeyframeRunner: ({ keyframes, onStarted, onUpdate, onProgress, onEnded, }: KeyframeRunnerConfig) => Runner;

package/dist/animation/runner.js

@@ -1,12 +1,7 @@
 import { updateTween } from "./update.js";
 //#region src/animation/runner.ts
-var noop = () => {};
-var createTweenRunner = (config) => {
-	const { from, to, durationMs, easeFn } = config;
-	const onStarted = config.onStarted;
-	const onUpdate = config.onUpdate ?? noop;
-	const onEnded = config.onEnded;
-	const onComplete = config.onComplete;
+var noOp = () => {};
+var createTweenRunner = ({ from, to, durationMs, easeFn, onStarted, onUpdate = noOp, onProgress = noOp, onEnded }) => {
 	const state = {
 		progress: 0,
 		currentValue: from,
@@ -16,10 +11,8 @@ var createTweenRunner = (config) => {
 	const step = (deltaMs) => {
 		const completed = updateTween(state, deltaMs, durationMs, easeFn, from, to);
 		onUpdate(state.currentValue, state.velocity);
-		if (completed) {
-			onEnded?.();
-			onComplete?.();
-		}
+		onProgress(state.progress);
+		if (completed) onEnded();
 		return completed;
 	};
 	const evaluate = (progress) => {
@@ -57,18 +50,11 @@ var createTweenRunner = (config) => {
 		configurable: true
 	});
 	runner.onStarted = onStarted;
-	runner.onUpdate = config.onUpdate;
-	runner.onProgress = void 0;
 	runner.onEnded = onEnded;
 	return runner;
 };
-var createKeyframeRunner = (config) => {
-	const { keyframes } = config;
-	const onStarted = config.onStarted;
-	const onUpdate = config.onUpdate ?? noop;
-	const onProgress = config.onProgress ?? noop;
-	const onEnded = config.onEnded;
-	const onComplete = config.onComplete;
+var createKeyframeRunner = ({ keyframes, onStarted, onUpdate = noOp, onProgress = noOp, onEnded }) => {
+	if (keyframes.length < 2) throw new Error("Keyframe animation must have at least 2 keyframes");
 	const segments = [];
 	for (let i = 0; i < keyframes.length - 1; i++) {
 		const cur = keyframes[i];
@@ -92,44 +78,7 @@ var createKeyframeRunner = (config) => {
 	let segmentElapsed = 0;
 	let segmentProgress = 0;
 	let runner;
-	if (segments.length === 0) {
-		const complete = () => {
-			onEnded?.();
-			onComplete?.();
-		};
-		const step = (_deltaMs) => {
-			onUpdate(currentValue, 0);
-			onProgress(1);
-			complete();
-			return true;
-		};
-		const evaluate = (prog) => {
-			onUpdate(currentValue, 0);
-			onProgress(Math.max(0, Math.min(1, prog)));
-			return currentValue;
-		};
-		runner = step;
-		runner.evaluate = evaluate;
-		runner.reset = () => {};
-		Object.defineProperty(runner, "currentValue", {
-			get: () => currentValue,
-			configurable: true
-		});
-		Object.defineProperty(runner, "velocity", {
-			get: () => 0,
-			configurable: true
-		});
-		Object.defineProperty(runner, "progress", {
-			get: () => 1,
-			configurable: true
-		});
-		runner.onStarted = onStarted;
-		runner.onUpdate = config.onUpdate;
-		runner.onProgress = config.onProgress;
-		runner.onEnded = onEnded;
-		return runner;
-	}
-	const step = (deltaMs) => {
+	const update = (deltaMs) => {
 		const segment = segments[currentSegmentIndex];
 		segmentElapsed += deltaMs;
 		segmentProgress += deltaMs / segment.durationMs;
@@ -155,7 +104,6 @@ var createKeyframeRunner = (config) => {
 			onProgress(globalProgress);
 		} else {
 			onEnded?.();
-			onComplete?.();
 			return true;
 		}
 		return false;
@@ -195,7 +143,7 @@ var createKeyframeRunner = (config) => {
 		segmentElapsed = 0;
 		segmentProgress = 0;
 	};
-	runner = step;
+	runner = update;
 	runner.evaluate = evaluate;
 	runner.reset = reset;
 	Object.defineProperty(runner, "currentValue", {
@@ -211,8 +159,6 @@ var createKeyframeRunner = (config) => {
 		configurable: true
 	});
 	runner.onStarted = onStarted;
-	runner.onUpdate = config.onUpdate;
-	runner.onProgress = config.onProgress;
 	runner.onEnded = onEnded;
 	return runner;
 };

package/dist/animation/update.d.ts

@@ -1,4 +1,4 @@
-import { EaseFunction } from '../shared/types';
+import { EaseFunction } from '../domain';
 export type TweenState = {
     progress: number;
     currentValue: number;

package/dist/domain/animation.d.ts

@@ -0,0 +1,40 @@
+import { EaseFunction, EaseName } from './easing';
+import { DynamicValue } from './resolve-value';
+export type AnimationStatus = "playing" | "paused" | "stopped" | "dead";
+export type SingleTweenOptions = {
+    from: DynamicValue;
+    to: DynamicValue;
+    durationMs: DynamicValue;
+    ease?: EaseName | EaseFunction;
+    onStarted?: () => void;
+    onUpdate?: (value: number, velocity: number) => void;
+    onProgress?: (progress: number) => void;
+    onEnded?: () => void;
+};
+export type Keyframe = {
+    value: DynamicValue;
+    ease?: EaseName | EaseFunction;
+    gap?: DynamicValue;
+};
+export type KeyframeAnimationOptions = {
+    keyframes: Keyframe[];
+    onStarted?: () => void;
+    onUpdate?: (value: number, velocity: number) => void;
+    onProgress?: (progress: number) => void;
+    onEnded?: () => void;
+};
+export type AnimationOptions = SingleTweenOptions | KeyframeAnimationOptions;
+export type Animation = {
+    play: () => Promise<void>;
+    pause: () => void;
+    resume: () => void;
+    stop: () => void;
+    skipToEnd: () => void;
+    kill: () => void;
+    currentValue: number;
+    velocity: number;
+    progress: number;
+    setProgress: (value: number) => void;
+    status: AnimationStatus;
+    durationMs: number;
+};

package/dist/domain/color.d.ts

@@ -0,0 +1,2 @@
+export type RgbaTuple = readonly [number, number, number, number];
+export type LerpRgba = (from: RgbaTuple, to: RgbaTuple, progress: number) => RgbaTuple;

package/dist/domain/easing.d.ts

@@ -0,0 +1,18 @@
+export type EaseFunction = (t: number) => number;
+export declare const resolveEasing: (ease: EaseName | EaseFunction) => EaseFunction;
+/** All 31 named easing identifiers, ordered by type. */
+export declare const EASE_NAMES: readonly ["linear", "inQuad", "outQuad", "inOutQuad", "inCubic", "outCubic", "inOutCubic", "inQuart", "outQuart", "inOutQuart", "inQuint", "outQuint", "inOutQuint", "inSine", "outSine", "inOutSine", "inExpo", "outExpo", "inOutExpo", "inCirc", "outCirc", "inOutCirc", "inBack", "outBack", "inOutBack", "inElastic", "outElastic", "inOutElastic", "inBounce", "outBounce", "inOutBounce"];
+export type EaseName = (typeof EASE_NAMES)[number];
+export declare const EASING_FUNCTIONS: Record<EaseName, EaseFunction>;
+/**
+ * Cubic bezier easing. Builds a pre-computed lookup table at construction time
+ * for O(log n) binary search at runtime — no Newton iteration, no allocation
+ * per frame.
+ *
+ * @param p1x - First control point x coordinate.
+ * @param p1y - First control point y coordinate.
+ * @param p2x - Second control point x coordinate.
+ * @param p2y - Second control point y coordinate.
+ * @returns An EaseFunction suitable for use with animate() or createTimeline().
+ */
+export declare const cubicBezier: (p1x: number, p1y: number, p2x: number, p2y: number) => EaseFunction;

package/dist/{easing → domain}/easing.js

@@ -1,4 +1,5 @@
-//#region src/easing/easing.ts
+//#region src/domain/easing.ts
+var resolveEasing = (ease) => typeof ease === "function" ? ease : EASING_FUNCTIONS[ease];
 var pow = Math.pow;
 var sqrt = Math.sqrt;
 var sin = Math.sin;
@@ -17,41 +18,7 @@ var bounceOut = (x) => {
 	else if (x < 2.5 / d1) return n1 * (x -= 2.25 / d1) * x + .9375;
 	else return n1 * (x -= 2.625 / d1) * x + .984375;
 };
-/** All 31 named easing identifiers, ordered by type. */
-var EASE_NAMES = [
-	"linear",
-	"inQuad",
-	"outQuad",
-	"inOutQuad",
-	"inCubic",
-	"outCubic",
-	"inOutCubic",
-	"inQuart",
-	"outQuart",
-	"inOutQuart",
-	"inQuint",
-	"outQuint",
-	"inOutQuint",
-	"inSine",
-	"outSine",
-	"inOutSine",
-	"inExpo",
-	"outExpo",
-	"inOutExpo",
-	"inCirc",
-	"outCirc",
-	"inOutCirc",
-	"inBack",
-	"outBack",
-	"inOutBack",
-	"inElastic",
-	"outElastic",
-	"inOutElastic",
-	"inBounce",
-	"outBounce",
-	"inOutBounce"
-];
-var easingFunctions = {
+var EASING_FUNCTIONS = {
 	linear: (x) => x,
 	inQuad: (x) => x * x,
 	outQuad: (x) => 1 - (1 - x) * (1 - x),
@@ -151,4 +118,4 @@ var cubicBezier = (p1x, p1y, p2x, p2y) => {
 	};
 };
 //#endregion
-export { EASE_NAMES, cubicBezier, easingFunctions };
+export { EASING_FUNCTIONS, cubicBezier, resolveEasing };

package/dist/domain/index.d.ts

@@ -0,0 +1,10 @@
+export type { AnimationStatus } from './animation';
+export type { InterpolationStatus, Interpolation, LerpOptions, SmoothDampOptions, SpringOptions, } from './interpolation';
+export type { EaseName, EaseFunction } from './easing';
+export { EASE_NAMES, cubicBezier, EASING_FUNCTIONS, resolveEasing } from './easing';
+export type { Ticker, TickHandler } from './ticker';
+export { resolveValue } from './resolve-value';
+export type { DynamicValue } from './resolve-value';
+export type { Animation, AnimationOptions, SingleTweenOptions, KeyframeAnimationOptions, Keyframe, } from './animation';
+export type { TimelineLayer, Timeline } from './timeline';
+export type { RgbaTuple, LerpRgba } from './color';

package/dist/domain/interpolation.d.ts

@@ -0,0 +1,35 @@
+import { DynamicValue } from './resolve-value';
+export type InterpolationStatus = "active" | "inactive" | "dead";
+export type Interpolation = {
+    start: () => void;
+    stop: () => void;
+    kill: () => void;
+    setCurrentValue: (value: number) => void;
+    currentValue: number;
+    velocity: number;
+    status: InterpolationStatus;
+};
+export type LerpOptions = {
+    to: () => number;
+    smoothTimeMs: DynamicValue;
+    precision?: number;
+    onUpdate?: (value: number, velocity: number) => void;
+    onEnded?: () => void;
+};
+export type SmoothDampOptions = {
+    to: () => number;
+    smoothTimeMs: DynamicValue;
+    maxSpeed?: DynamicValue;
+    precision?: number;
+    onUpdate?: (value: number, velocity: number) => void;
+    onEnded?: () => void;
+};
+export type SpringOptions = {
+    to: () => number;
+    stiffness?: DynamicValue;
+    damping?: DynamicValue;
+    mass?: DynamicValue;
+    precision?: number;
+    onUpdate?: (value: number, velocity: number) => void;
+    onEnded?: () => void;
+};

package/dist/domain/resolve-value.d.ts

@@ -0,0 +1,2 @@
+export type DynamicValue = number | (() => number);
+export declare const resolveValue: (value: DynamicValue) => number;