@octanejs/spring 0.0.1

package/src/core/AnimationConfig.ts

@@ -0,0 +1,60 @@
+// Behavioral port of react-spring v10.1.2 packages/core/src/AnimationConfig.ts.
+export class AnimationConfig {
+	tension = 170;
+	friction = 26;
+	frequency?: number;
+	damping = 1;
+	mass = 1;
+	velocity: number | number[] = 0;
+	restVelocity?: number;
+	precision?: number;
+	progress?: number;
+	duration?: number;
+	easing = (value: number): number => value;
+	clamp = false;
+	bounce?: number;
+	decay?: boolean | number;
+	round?: number;
+}
+
+export function mergeConfig(
+	config: AnimationConfig,
+	newConfig: Partial<AnimationConfig>,
+	defaultConfig?: Partial<AnimationConfig>,
+): AnimationConfig {
+	let props = newConfig;
+	if (defaultConfig) {
+		const defaults = { ...defaultConfig };
+		sanitizeConfig(defaults, newConfig);
+		props = { ...defaults, ...newConfig };
+	}
+	sanitizeConfig(config, props);
+	Object.assign(config, props);
+	if (config.frequency !== undefined) {
+		config.frequency = Math.max(0.01, config.frequency);
+		config.damping = Math.max(0, config.damping);
+		config.tension = Math.pow((2 * Math.PI) / config.frequency, 2) * config.mass;
+		config.friction = (4 * Math.PI * config.damping * config.mass) / config.frequency;
+	}
+	return config;
+}
+
+function sanitizeConfig(config: Partial<AnimationConfig>, props: Partial<AnimationConfig>): void {
+	if (props.decay !== undefined) {
+		config.duration = undefined;
+	} else {
+		const isTensionConfig = props.tension !== undefined || props.friction !== undefined;
+		if (
+			isTensionConfig ||
+			props.frequency !== undefined ||
+			props.damping !== undefined ||
+			props.mass !== undefined
+		) {
+			config.duration = undefined;
+			config.decay = undefined;
+		}
+		if (isTensionConfig) {
+			config.frequency = undefined;
+		}
+	}
+}

package/src/core/AnimationResult.ts

@@ -0,0 +1,19 @@
+// Ported from react-spring v10.1.2 packages/core/src/AnimationResult.ts.
+export interface AnimationResult<T> {
+	value: T;
+	finished: boolean;
+	cancelled: boolean;
+	noop?: boolean;
+}
+
+export function getFinishedResult<T>(value: T, finished: boolean): AnimationResult<T> {
+	return { value, finished, cancelled: false };
+}
+
+export function getCancelledResult<T>(value: T): AnimationResult<T> {
+	return { value, finished: false, cancelled: true };
+}
+
+export function getNoopResult<T>(value: T): AnimationResult<T> {
+	return { value, finished: true, cancelled: false, noop: true };
+}

package/src/core/Controller.ts

@@ -0,0 +1,200 @@
+// React-free behavioral port of react-spring v10.1.2 packages/core/src/Controller.ts.
+import { hasReservedProps, inferTo } from '../upstream-compat';
+import {
+	type AnimationResult,
+	getCancelledResult,
+	getFinishedResult,
+	getNoopResult,
+} from './AnimationResult';
+import { type SpringConfig, type SpringUpdate, SpringValue } from './SpringValue';
+
+type StateRecord = Record<string, any>;
+export type ControllerTo<State extends StateRecord> =
+	| Partial<State>
+	| ((
+			next: (update: ControllerUpdate<State> | Partial<State>) => Promise<AnimationResult<State>>,
+	  ) => Promise<void> | void);
+
+export interface ControllerUpdate<State extends StateRecord> {
+	default?: boolean | Partial<ControllerUpdate<State>>;
+	from?: Partial<State>;
+	to?: ControllerTo<State>;
+	config?: SpringConfig | ((key: keyof State) => SpringConfig);
+	immediate?: boolean | ((key: keyof State) => boolean);
+	delay?: number;
+	cancel?: boolean;
+	pause?: boolean;
+	reset?: boolean;
+	loop?: boolean | (() => boolean | Partial<ControllerUpdate<State>>);
+	onStart?: (result: AnimationResult<State>, controller: Controller<State>) => void;
+	onChange?: (result: AnimationResult<State>, controller: Controller<State>) => void;
+	onRest?: (result: AnimationResult<State>, controller: Controller<State>) => void;
+	onResolve?: (result: AnimationResult<State>, controller: Controller<State>) => void;
+}
+
+export class Controller<State extends StateRecord = StateRecord> {
+	springs: { [Key in keyof State]: SpringValue<State[Key]> } = {} as any;
+	private runId = 0;
+	private paused = false;
+	private defaults: Partial<ControllerUpdate<State>> = {};
+	constructor(props: ControllerUpdate<State> = {}) {
+		props = normalizeUpdate(props);
+		if (props.default === true) this.defaults = withoutTargets(props);
+		else if (typeof props.default === 'object') this.defaults = props.default;
+		const initial = {
+			...props.from,
+			...(props.from ? undefined : typeof props.to === 'object' ? props.to : undefined),
+		} as State;
+		for (const key in initial) this.springs[key] = new SpringValue(initial[key]);
+	}
+	get(): State {
+		const value: StateRecord = {};
+		for (const key in this.springs) value[key] = this.springs[key].get();
+		return value as State;
+	}
+	set(values: Partial<State>): this {
+		for (const key in values)
+			this.ensure(key as keyof State, values[key] as State[keyof State]).set(values[key]!);
+		return this;
+	}
+	start(update: ControllerUpdate<State> = {}): Promise<AnimationResult<State>> {
+		update = normalizeUpdate(update);
+		if (update.default === true) this.defaults = { ...this.defaults, ...withoutTargets(update) };
+		else if (typeof update.default === 'object')
+			this.defaults = { ...this.defaults, ...update.default };
+		update = normalizeUpdate({ ...this.defaults, ...update });
+		const runId = ++this.runId;
+		return this.run(update, runId);
+	}
+	pause(): this {
+		if (!this.paused) {
+			this.paused = true;
+			for (const key in this.springs) this.springs[key].pause();
+		}
+		return this;
+	}
+	resume(): this {
+		if (this.paused) {
+			this.paused = false;
+			for (const key in this.springs) this.springs[key].resume();
+		}
+		return this;
+	}
+	stop(cancel = false): this {
+		this.runId++;
+		for (const key in this.springs) this.springs[key].stop(cancel);
+		return this;
+	}
+
+	private async run(
+		update: ControllerUpdate<State>,
+		runId: number,
+	): Promise<AnimationResult<State>> {
+		if (update.cancel) {
+			this.stop(true);
+			return getCancelledResult(this.get());
+		}
+		if (update.pause === true) {
+			this.pause();
+			return getFinishedResult(this.get(), false);
+		}
+		if (update.pause === false) this.resume();
+		if ((update.delay ?? 0) > 0) {
+			await new Promise<void>((resolve) => setTimeout(resolve, update.delay));
+			if (runId !== this.runId) return getCancelledResult(this.get());
+			update = { ...update, delay: undefined };
+		}
+		const to = update.to;
+		if (typeof to === 'function') {
+			let last = getNoopResult(this.get());
+			await to(async (next) => {
+				if (runId !== this.runId) return getCancelledResult(this.get());
+				const step = isControllerUpdate(next)
+					? { ...update, ...next, loop: undefined }
+					: { ...update, to: next, loop: undefined };
+				last = await this.run(normalizeUpdate(step), runId);
+				return last;
+			});
+			if (runId !== this.runId) return getCancelledResult(this.get());
+			const result = { ...last, value: this.get() };
+			update.onRest?.(result, this);
+			update.onResolve?.(result, this);
+			return result;
+		}
+		const from: Partial<State> = update.from ?? {};
+		const target: Partial<State> = to ?? {};
+		for (const key in from) this.ensure(key as keyof State, from[key] as State[keyof State]);
+		let started = false;
+		const promises = Object.keys(target).map((key) => {
+			const typedKey = key as keyof State;
+			const spring = this.ensure(
+				typedKey,
+				(from[typedKey] ?? target[typedKey]) as State[typeof typedKey],
+			);
+			const props: SpringUpdate<State[typeof typedKey]> = {
+				to: target[typedKey]!,
+				reset: update.reset,
+				delay: update.delay,
+				config: typeof update.config === 'function' ? update.config(typedKey) : update.config,
+				immediate:
+					typeof update.immediate === 'function' ? update.immediate(typedKey) : update.immediate,
+				onStart: () => {
+					if (!started) {
+						started = true;
+						update.onStart?.(getFinishedResult(this.get(), false), this);
+					}
+				},
+				onChange: () => update.onChange?.(getFinishedResult(this.get(), false), this),
+			};
+			// Upstream ignores `from` except on reset; initial values come from construction.
+			if (update.reset && from[typedKey] !== undefined) props.from = from[typedKey];
+			return spring.start(props);
+		});
+		const results = await Promise.all(promises);
+		if (runId !== this.runId) return getCancelledResult(this.get());
+		let result: AnimationResult<State> = {
+			value: this.get(),
+			finished: results.every((item) => item.finished),
+			cancelled: results.some((item) => item.cancelled),
+			...(results.length === 0 ? { noop: true } : {}),
+		};
+		const loop = update.loop;
+		const nextLoop = typeof loop === 'function' ? loop() : loop;
+		if (nextLoop && result.finished) {
+			result = await this.run(
+				{ ...update, ...(typeof nextLoop === 'object' ? nextLoop : {}), reset: true, loop },
+				runId,
+			);
+			return result;
+		}
+		update.onRest?.(result, this);
+		update.onResolve?.(result, this);
+		return result;
+	}
+	private ensure<Key extends keyof State>(key: Key, initial: State[Key]): SpringValue<State[Key]> {
+		return (this.springs[key] ??= new SpringValue(initial));
+	}
+}
+
+function normalizeUpdate<State extends StateRecord>(
+	update: ControllerUpdate<State> | Partial<State>,
+): ControllerUpdate<State> {
+	return inferTo(update as object) as ControllerUpdate<State>;
+}
+
+function withoutTargets<State extends StateRecord>(
+	update: ControllerUpdate<State>,
+): Partial<ControllerUpdate<State>> {
+	const { from: _from, to: _to, default: _default, ...defaults } = update;
+	return defaults;
+}
+
+function isControllerUpdate<State extends StateRecord>(
+	value: ControllerUpdate<State> | Partial<State>,
+): value is ControllerUpdate<State> {
+	// Check reserved keys on the raw object. Do not run inferTo here: shorthand
+	// steps like `{ x: 1 }` must stay on the `to: next` path so the parent async
+	// `to` function is replaced rather than left in place. Lifecycle keys such as
+	// onRest/onStart must still count as updates so they are not animated.
+	return hasReservedProps(value as object);
+}

package/src/core/FrameValue.ts

@@ -0,0 +1,16 @@
+// React-free observable base adapted from react-spring v10.1.2 packages/core/src/FrameValue.ts.
+export type ChangeListener<T> = (value: T) => void;
+
+export abstract class FrameValue<T> {
+	protected readonly listeners = new Set<ChangeListener<T>>();
+	idle = true;
+	priority = 0;
+	abstract get(): T;
+	onChange(listener: ChangeListener<T>): () => void {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	protected emitChange(value: T): void {
+		for (const listener of this.listeners) listener(value);
+	}
+}

package/src/core/Interpolation.ts

@@ -0,0 +1,46 @@
+// React-free behavioral port of react-spring v10.1.2 packages/core/src/Interpolation.ts.
+import { createInterpolator } from '../shared/index';
+import type { Interpolator } from '../types/interpolate';
+import type { ExtrapolateType, InterpolatorConfig } from '../types/index';
+import { FrameValue } from './FrameValue';
+
+export class Interpolation<T = any> extends FrameValue<T> {
+	private readonly cleanups: Array<() => void>;
+	constructor(
+		private readonly sources: Array<FrameValue<any>>,
+		private readonly calc: (...values: any[]) => T,
+	) {
+		super();
+		this.idle = sources.every((source) => source.idle);
+		this.cleanups = sources.map((source) =>
+			source.onChange(() => {
+				this.idle = this.sources.every((parent) => parent.idle);
+				this.emitChange(this.get());
+			}),
+		);
+	}
+	get(): T {
+		return this.calc(...this.sources.map((source) => source.get()));
+	}
+	dispose(): void {
+		for (const cleanup of this.cleanups) cleanup();
+		this.cleanups.length = 0;
+		this.listeners.clear();
+		this.idle = true;
+	}
+}
+
+export const to: Interpolator = function to(source: any, ...args: any[]): Interpolation<any> {
+	if (args.length >= 2 && Array.isArray(args[0]) && Array.isArray(args[1])) {
+		const range = args[0] as readonly number[];
+		const output = args[1] as readonly unknown[];
+		const extrapolate = args[2] as ExtrapolateType | undefined;
+		return to(source, { range, output, extrapolate } as InterpolatorConfig);
+	}
+	const calc = args[0];
+	const interpolate =
+		typeof calc === 'function' ? calc : createInterpolator(calc as InterpolatorConfig);
+	return new Interpolation(Array.isArray(source) ? source : [source], interpolate);
+};
+
+export const interpolate: Interpolator = to;

package/src/core/SpringRef.ts

@@ -0,0 +1,26 @@
+// React-free port of react-spring v10.1.2 packages/core/src/SpringRef.ts.
+import type { AnimationResult } from './AnimationResult';
+import { Controller, type ControllerUpdate } from './Controller';
+
+export class SpringRef<State extends Record<string, any> = Record<string, any>> {
+	current: Controller<State>[] = [];
+	add(controller: Controller<State>): void {
+		if (!this.current.includes(controller)) this.current.push(controller);
+	}
+	delete(controller: Controller<State>): void {
+		const index = this.current.indexOf(controller);
+		if (index >= 0) this.current.splice(index, 1);
+	}
+	start(update?: ControllerUpdate<State>): Promise<Array<AnimationResult<State>>> {
+		return Promise.all(this.current.map((controller) => controller.start(update ?? {})));
+	}
+	pause(): void {
+		for (const controller of this.current) controller.pause();
+	}
+	resume(): void {
+		for (const controller of this.current) controller.resume();
+	}
+	stop(cancel = false): void {
+		for (const controller of this.current) controller.stop(cancel);
+	}
+}