coily 0.10.0 → 0.11.0

package/dist/system-Dxxv4ee7.js

@@ -0,0 +1,614 @@
+//#region src/motion-set.ts
+var MotionSet = class {
+	#motions = /* @__PURE__ */ new Set();
+	add(motion) {
+		this.#motions.add(motion);
+	}
+	remove(motion) {
+		this.#motions.delete(motion);
+	}
+	tick(dt) {
+		for (const motion of this.#motions) {
+			motion.tick(dt);
+			if (motion.resting) this.#motions.delete(motion);
+		}
+	}
+};
+//#endregion
+//#region src/util.ts
+function invariant(condition, message) {
+	if (condition) return;
+	throw new Error(message ?? "Invariant Failed");
+}
+//#endregion
+//#region src/config.ts
+/**
+* Immutable spring configuration.
+*/
+var SpringConfig = class {
+	mass;
+	tension;
+	damping;
+	precision;
+	naturalFrequency;
+	criticalDamping;
+	dampingRatio;
+	precisionMultiplier;
+	restingMagnitude;
+	constructor(input) {
+		const raw = input;
+		const mass = raw.mass;
+		const tension = raw.tension;
+		const damping = raw.damping;
+		const bounce = raw.bounce;
+		const duration = raw.duration !== void 0 ? raw.duration / 1e3 : void 0;
+		const displacement = raw.displacement ?? 1;
+		const precision = raw.precision ?? 2;
+		if (mass !== void 0) invariant(mass > 0, "Mass must be greater than 0");
+		if (tension !== void 0) invariant(tension > 0, "Tension must be greater than 0");
+		if (damping !== void 0) invariant(damping >= 0, "Damping must be greater than or equal to 0");
+		if (bounce !== void 0) invariant(bounce >= -1 && bounce <= 1, "Bounce must be between -1 and 1");
+		const dampingRatio = raw.dampingRatio ?? (bounce !== void 0 ? Math.max(1e-4, 1 - bounce) : void 0);
+		if (dampingRatio !== void 0) invariant(dampingRatio >= 0, "Damping ratio must be greater than or equal to 0");
+		if (duration !== void 0) invariant(duration > 0, "Duration must be greater than 0");
+		invariant(displacement !== 0, "Displacement must not be 0");
+		invariant(precision > 0, "Precision must be greater than 0");
+		this.precision = precision;
+		this.precisionMultiplier = 10 ** precision;
+		this.restingMagnitude = 1 / this.precisionMultiplier;
+		const hasM = mass !== void 0;
+		const hasK = tension !== void 0;
+		const hasC = damping !== void 0;
+		const hasZ = dampingRatio !== void 0;
+		const hasT = duration !== void 0;
+		if (hasK && hasC && !hasZ && !hasT) {
+			this.mass = mass ?? 1;
+			this.tension = tension;
+			this.damping = damping;
+		} else if (hasK && hasZ && !hasC && !hasT) {
+			this.mass = mass ?? 1;
+			this.tension = tension;
+			this.damping = 2 * dampingRatio * Math.sqrt(this.mass * tension);
+		} else if (hasC && hasZ && !hasK && !hasT) {
+			invariant(dampingRatio > 0, "dampingRatio must be > 0 to derive tension");
+			this.mass = mass ?? 1;
+			this.tension = damping ** 2 / (4 * dampingRatio ** 2 * this.mass);
+			this.damping = damping;
+		} else if (hasK && hasC && hasZ && !hasT) {
+			invariant(dampingRatio > 0, "dampingRatio must be > 0 to derive mass");
+			this.mass = damping ** 2 / (4 * dampingRatio ** 2 * tension);
+			this.tension = tension;
+			this.damping = damping;
+		} else if (hasZ && hasT) {
+			const threshold = this.restingMagnitude;
+			const x0 = Math.abs(displacement);
+			invariant(x0 > threshold, "displacement must be greater than the precision threshold");
+			let sigmaCoeff;
+			if (dampingRatio < 1) sigmaCoeff = dampingRatio;
+			else if (dampingRatio === 1) sigmaCoeff = 1;
+			else sigmaCoeff = dampingRatio - Math.sqrt(dampingRatio ** 2 - 1);
+			invariant(sigmaCoeff > 0, "dampingRatio must be > 0 for duration-based config");
+			const wn = 2 * Math.log(x0 / threshold) / (sigmaCoeff * duration);
+			if (!hasK && !hasC) {
+				this.mass = mass ?? 1;
+				this.tension = wn ** 2 * this.mass;
+				this.damping = 2 * dampingRatio * this.mass * wn;
+			} else if (hasK && !hasM && !hasC) {
+				this.mass = tension / wn ** 2;
+				this.tension = tension;
+				this.damping = 2 * dampingRatio * this.mass * wn;
+			} else if (hasC && !hasM && !hasK) {
+				this.mass = damping / (2 * dampingRatio * wn);
+				this.tension = wn ** 2 * this.mass;
+				this.damping = damping;
+			} else throw new Error("Invalid spring config: provide one of the supported input shapes.");
+		} else throw new Error("Invalid spring config: provide one of the supported input shapes.");
+		this.naturalFrequency = Math.sqrt(this.tension / this.mass);
+		this.criticalDamping = 2 * this.mass * this.naturalFrequency;
+		this.dampingRatio = this.damping / this.criticalDamping;
+	}
+};
+function defineSpring(input) {
+	return new SpringConfig(input);
+}
+//#endregion
+//#region src/emitter.ts
+var Emitter = class {
+	#update = [];
+	#start = [];
+	#stop = [];
+	on(type, handler) {
+		this.#list(type).push(handler);
+		return () => {
+			this.off(type, handler);
+		};
+	}
+	off(type, handler) {
+		const list = this.#list(type);
+		if (handler) list.splice(list.indexOf(handler) >>> 0, 1);
+		else list.length = 0;
+	}
+	clear() {
+		this.#update.length = 0;
+		this.#start.length = 0;
+		this.#stop.length = 0;
+	}
+	emit(type) {
+		const list = this.#list(type);
+		if (list.length === 1) list[0]();
+		else if (list.length > 1) for (const handler of list.slice()) handler();
+	}
+	#list(type) {
+		switch (type) {
+			case "update": return this.#update;
+			case "start": return this.#start;
+			case "stop": return this.#stop;
+		}
+	}
+};
+//#endregion
+//#region src/state.ts
+var State = class {
+	#config;
+	#position;
+	#velocity;
+	constructor(config, position, velocity) {
+		this.#config = config;
+		this.#position = position;
+		this.#velocity = velocity;
+	}
+	configure(config) {
+		this.#config = config;
+	}
+	/** Returns the position rounded to the configured precision. */
+	get position() {
+		return Math.round(this.#position * this.#config.precisionMultiplier) / this.#config.precisionMultiplier;
+	}
+	set position(value) {
+		this.#position = value;
+	}
+	/** Returns the velocity rounded to the configured precision. */
+	get velocity() {
+		return Math.round(this.#velocity * this.#config.precisionMultiplier) / this.#config.precisionMultiplier;
+	}
+	set velocity(value) {
+		this.#velocity = value;
+	}
+	/** Uses raw (unrounded) values so resting detection isn't affected by output quantization. */
+	get resting() {
+		return Math.abs(this.#velocity) < this.#config.restingMagnitude && Math.abs(this.#position) < this.#config.restingMagnitude;
+	}
+};
+//#endregion
+//#region src/solver.ts
+var UnderdampedSolver = class {
+	#state;
+	#dampedFrequency = 0;
+	#decayRate = 0;
+	#t = 0;
+	#c1 = 0;
+	#c2 = 0;
+	constructor(state) {
+		this.#state = state;
+	}
+	configure(config) {
+		if (config) {
+			this.#decayRate = config.dampingRatio * config.naturalFrequency;
+			this.#dampedFrequency = config.naturalFrequency * Math.sqrt(1 - config.dampingRatio ** 2);
+		}
+		this.#t = 0;
+		this.#c1 = this.#state.position;
+		this.#c2 = (this.#state.velocity + this.#decayRate * this.#state.position) / this.#dampedFrequency;
+	}
+	tick(dt) {
+		this.#t += dt;
+		const sin = Math.sin(this.#dampedFrequency * this.#t);
+		const cos = Math.cos(this.#dampedFrequency * this.#t);
+		const decay = Math.exp(-this.#decayRate * this.#t);
+		const decayVelocity = -this.#decayRate * decay;
+		const oscillation = this.#c1 * cos + this.#c2 * sin;
+		const oscillationVelocity = -this.#c1 * this.#dampedFrequency * sin + this.#c2 * this.#dampedFrequency * cos;
+		this.#state.position = decay * oscillation;
+		this.#state.velocity = decay * oscillationVelocity + decayVelocity * oscillation;
+	}
+};
+var CriticallyDampedSolver = class {
+	#state;
+	#naturalFrequency = 0;
+	#t = 0;
+	#c1 = 0;
+	#c2 = 0;
+	constructor(state) {
+		this.#state = state;
+	}
+	configure(config) {
+		if (config) this.#naturalFrequency = config.naturalFrequency;
+		this.#t = 0;
+		this.#c1 = this.#state.position;
+		this.#c2 = this.#state.velocity + this.#naturalFrequency * this.#state.position;
+	}
+	tick(dt) {
+		this.#t += dt;
+		const decay = Math.exp(-this.#naturalFrequency * this.#t);
+		const decayVelocity = -this.#naturalFrequency * decay;
+		const scale = this.#c1 + this.#c2 * this.#t;
+		const scaleVelocity = this.#c2;
+		this.#state.position = scale * decay;
+		this.#state.velocity = scaleVelocity * decay + decayVelocity * scale;
+	}
+};
+var OverdampedSolver = class {
+	#state;
+	#dampedFrequency = 0;
+	#decayRate = 0;
+	#t = 0;
+	#c1 = 0;
+	#c2 = 0;
+	constructor(state) {
+		this.#state = state;
+	}
+	configure(config) {
+		if (config) {
+			this.#decayRate = config.dampingRatio * config.naturalFrequency;
+			this.#dampedFrequency = config.naturalFrequency * Math.sqrt(config.dampingRatio ** 2 - 1);
+		}
+		this.#t = 0;
+		this.#c1 = this.#state.velocity + this.#decayRate * this.#state.position;
+		this.#c2 = this.#state.position * this.#dampedFrequency;
+	}
+	tick(dt) {
+		this.#t += dt;
+		const decay = Math.exp(-this.#decayRate * this.#t);
+		const decayVelocity = -this.#decayRate * decay;
+		const clamped = Math.min(this.#dampedFrequency * this.#t, 300);
+		const sinh = Math.sinh(clamped);
+		const cosh = Math.cosh(clamped);
+		const scale = this.#c1 * sinh + this.#c2 * cosh;
+		const scaleVelocity = this.#c1 * this.#dampedFrequency * cosh + this.#c2 * this.#dampedFrequency * sinh;
+		this.#state.position = scale * decay / this.#dampedFrequency;
+		this.#state.velocity = (scale * decayVelocity + scaleVelocity * decay) / this.#dampedFrequency;
+	}
+};
+//#endregion
+//#region src/motion.ts
+var Motion = class {
+	#config;
+	#state;
+	#underdampedSolver = null;
+	#criticallyDampedSolver = null;
+	#overdampedSolver = null;
+	#currentSolver = null;
+	#needsUpdate = false;
+	#needsReset = false;
+	#emitter;
+	constructor(config, position, velocity) {
+		this.#config = config;
+		this.#state = new State(config, position, velocity);
+		this.#emitter = new Emitter();
+		this.#updateSolver();
+	}
+	get position() {
+		return this.#state.position;
+	}
+	set position(value) {
+		this.#state.position = value;
+		this.#needsReset = true;
+		if (!this.#state.resting) this.#emitter.emit("start");
+	}
+	get velocity() {
+		return this.#state.velocity;
+	}
+	set velocity(value) {
+		this.#state.velocity = value;
+		this.#needsReset = true;
+	}
+	get resting() {
+		return this.#state.resting;
+	}
+	configure(config) {
+		this.#config = config;
+		this.#state.configure(config);
+		this.#needsUpdate = true;
+	}
+	tick(dt, emit = true) {
+		invariant(this.#currentSolver, "Cannot tick a disposed motion");
+		if (this.#needsUpdate) {
+			this.#updateSolver();
+			this.#needsUpdate = false;
+			this.#needsReset = false;
+		} else if (this.#needsReset) {
+			this.#currentSolver.configure();
+			this.#needsReset = false;
+		}
+		this.#currentSolver.tick(dt);
+		if (emit) {
+			this.#emitter.emit("update");
+			if (this.#state.resting) this.#emitter.emit("stop");
+		}
+	}
+	onUpdate(callback) {
+		return this.#emitter.on("update", callback);
+	}
+	onStart(callback) {
+		return this.#emitter.on("start", callback);
+	}
+	onStop(callback) {
+		return this.#emitter.on("stop", callback);
+	}
+	dispose() {
+		this.#emitter.clear();
+		this.#underdampedSolver = null;
+		this.#criticallyDampedSolver = null;
+		this.#overdampedSolver = null;
+		this.#currentSolver = null;
+	}
+	#updateSolver() {
+		if (this.#config.dampingRatio < 1) {
+			this.#underdampedSolver ||= new UnderdampedSolver(this.#state);
+			this.#currentSolver = this.#underdampedSolver;
+		} else if (this.#config.dampingRatio === 1) {
+			this.#criticallyDampedSolver ||= new CriticallyDampedSolver(this.#state);
+			this.#currentSolver = this.#criticallyDampedSolver;
+		} else {
+			this.#overdampedSolver ||= new OverdampedSolver(this.#state);
+			this.#currentSolver = this.#overdampedSolver;
+		}
+		this.#currentSolver.configure(this.#config);
+	}
+};
+//#endregion
+//#region src/spring.ts
+var Spring = class {
+	#target;
+	#config;
+	#motion;
+	#motions;
+	constructor(motions, position, config) {
+		let target;
+		let value;
+		if (typeof position === "number") {
+			target = position;
+			value = position;
+		} else {
+			target = position.target ?? position.value ?? 0;
+			value = position.value ?? target;
+		}
+		this.#target = target;
+		this.#config = config;
+		this.#motion = new Motion(config, value - target, 0);
+		this.#motions = motions;
+		if (!this.#motion.resting) this.#motions.add(this.#motion);
+	}
+	get target() {
+		return this.#target;
+	}
+	set target(value) {
+		if (value !== this.#target) {
+			this.#motions.add(this.#motion);
+			const currentValue = this.value;
+			this.#target = value;
+			this.#motion.position = currentValue - this.#target;
+			this.#motion.tick(0);
+		}
+	}
+	get value() {
+		return this.#target + this.#motion.position;
+	}
+	set value(value) {
+		const position = value - this.#target;
+		if (position !== this.#motion.position) {
+			this.#motions.add(this.#motion);
+			this.#motion.position = position;
+			this.#motion.tick(0);
+		}
+	}
+	get velocity() {
+		return this.#motion.velocity;
+	}
+	set velocity(value) {
+		this.#motions.add(this.#motion);
+		this.#motion.velocity = value;
+	}
+	get mass() {
+		return this.#config.mass;
+	}
+	get tension() {
+		return this.#config.tension;
+	}
+	get damping() {
+		return this.#config.damping;
+	}
+	get dampingRatio() {
+		return this.#config.dampingRatio;
+	}
+	get precision() {
+		return this.#config.precision;
+	}
+	get resting() {
+		return this.#motion.resting;
+	}
+	configure(config) {
+		this.#config = config;
+		this.#motion.configure(config);
+		this.#motions.add(this.#motion);
+	}
+	onUpdate(callback) {
+		return this.#motion.onUpdate(callback);
+	}
+	onStart(callback) {
+		return this.#motion.onStart(callback);
+	}
+	onStop(callback) {
+		return this.#motion.onStop(callback);
+	}
+	jumpTo(value) {
+		this.#target = value;
+		this.#motion.position = 0;
+		this.#motion.velocity = 0;
+		this.#motion.tick(0);
+	}
+	dispose() {
+		this.#motions.remove(this.#motion);
+		this.#motion.dispose();
+	}
+};
+//#endregion
+//#region src/ticker.ts
+const hasWindow = typeof window !== "undefined";
+const request = hasWindow ? (cb) => window.requestAnimationFrame(cb) : (cb) => setTimeout(cb, 1);
+const cancel = hasWindow ? (id) => window.cancelAnimationFrame(id) : (id) => clearTimeout(id);
+var Ticker = class {
+	#fps;
+	#gap;
+	#lagThreshold;
+	#adjustedLag;
+	#motion;
+	#frame = 0;
+	#time = 0;
+	#previousTime = 0;
+	#delta = 0;
+	#nextTime;
+	#lastWallTime = 0;
+	#id = 0;
+	#stopped = true;
+	constructor(motions, options) {
+		this.#motion = motions;
+		const fps = options?.fps ?? 60;
+		const lagThreshold = options?.lagThreshold ?? 500;
+		const adjustedLag = options?.adjustedLag ?? 33;
+		invariant(fps > 0, "FPS must be greater than 0");
+		invariant(lagThreshold >= 0, "Lag threshold must be greater than or equal to 0");
+		invariant(adjustedLag >= 0, "Adjusted lag must be greater than or equal to 0");
+		this.#fps = fps;
+		this.#gap = 1e3 / fps;
+		this.#lagThreshold = lagThreshold === 0 ? 1e8 : lagThreshold;
+		this.#adjustedLag = Math.min(adjustedLag, this.#lagThreshold);
+		this.#nextTime = this.#gap;
+	}
+	get fps() {
+		return this.#fps;
+	}
+	set fps(value) {
+		invariant(value > 0, "FPS must be greater than 0");
+		this.#fps = value;
+		this.#gap = 1e3 / value;
+		this.#nextTime = this.#previousTime + this.#gap;
+	}
+	get lagThreshold() {
+		return this.#lagThreshold;
+	}
+	set lagThreshold(value) {
+		invariant(value >= 0, "Lag threshold must be greater than or equal to 0");
+		this.#lagThreshold = value === 0 ? 1e8 : value;
+		this.#adjustedLag = Math.min(this.#adjustedLag, this.#lagThreshold);
+	}
+	get adjustedLag() {
+		return this.#adjustedLag;
+	}
+	set adjustedLag(value) {
+		invariant(value >= 0, "Adjusted lag must be greater than or equal to 0");
+		this.#adjustedLag = Math.min(value, this.#lagThreshold);
+	}
+	get time() {
+		return this.#time;
+	}
+	get frame() {
+		return this.#frame;
+	}
+	get delta() {
+		return this.#delta;
+	}
+	get deltaRatio() {
+		return this.#delta / this.#gap;
+	}
+	get stopped() {
+		return this.#stopped;
+	}
+	start() {
+		if (this.#stopped) {
+			this.#stopped = false;
+			this.#lastWallTime = performance.now();
+			this.#id = request((t) => this.#onFrame(t));
+		}
+	}
+	stop() {
+		if (!this.#stopped) {
+			cancel(this.#id);
+			this.#stopped = true;
+		}
+	}
+	/** Manually advance one frame. */
+	tick() {
+		this.#step(this.#gap);
+	}
+	#onFrame(timestamp) {
+		if (this.#stopped) return;
+		const wallElapsed = timestamp - this.#lastWallTime;
+		this.#lastWallTime = timestamp;
+		const elapsed = wallElapsed > this.#lagThreshold ? this.#adjustedLag : wallElapsed;
+		this.#time += elapsed;
+		if (this.#time - this.#nextTime >= 0) {
+			this.#frame++;
+			this.#delta = this.#time - this.#previousTime;
+			this.#previousTime = this.#time;
+			this.#nextTime += this.#gap;
+			this.#motion.tick(this.#delta / 1e3);
+		}
+		this.#id = request((t) => this.#onFrame(t));
+	}
+	#step(dt) {
+		this.#time += dt;
+		this.#frame++;
+		this.#delta = dt;
+		this.#previousTime = this.#time;
+		this.#motion.tick(dt / 1e3);
+	}
+};
+//#endregion
+//#region src/system.ts
+var SpringSystemImpl = class {
+	#motion;
+	#ticker;
+	constructor(options) {
+		this.#motion = new MotionSet();
+		this.#ticker = new Ticker(this.#motion, options);
+	}
+	createSpring(position, config) {
+		return new Spring(this.#motion, position, config);
+	}
+	advance(dt) {
+		this.#motion.tick(dt / 1e3);
+	}
+	start() {
+		this.#ticker.start();
+	}
+	stop() {
+		this.#ticker.stop();
+	}
+	get running() {
+		return !this.#ticker.stopped;
+	}
+	get fps() {
+		return this.#ticker.fps;
+	}
+	set fps(value) {
+		this.#ticker.fps = value;
+	}
+	get lagThreshold() {
+		return this.#ticker.lagThreshold;
+	}
+	set lagThreshold(value) {
+		this.#ticker.lagThreshold = value;
+	}
+	get adjustedLag() {
+		return this.#ticker.adjustedLag;
+	}
+	set adjustedLag(value) {
+		this.#ticker.adjustedLag = value;
+	}
+};
+function createSpringSystem(options) {
+	return new SpringSystemImpl(options);
+}
+//#endregion
+export { SpringConfig as n, defineSpring as r, createSpringSystem as t };

package/dist/vue.d.ts

@@ -0,0 +1,38 @@
+import { o as SpringConfig, s as SpringOptions, t as SpringSystem } from "./system-B_kZMcpg.js";
+import * as vue from "vue";
+import { App, MaybeRefOrGetter, Ref, SlotsType } from "vue";
+
+//#region src/vue/spring.d.ts
+interface UseSpringReturn {
+  readonly value: Ref<number>;
+  readonly velocity: Ref<number>;
+  readonly resting: Readonly<Ref<boolean>>;
+  readonly jumpTo: (value: number) => void;
+}
+declare function useSpring(target: MaybeRefOrGetter<number>, options?: MaybeRefOrGetter<SpringOptions | SpringConfig>): UseSpringReturn;
+//#endregion
+//#region src/vue/component.d.ts
+interface SpringValueProps {
+  target: number;
+  mass?: number;
+  tension?: number;
+  damping?: number;
+  precision?: number;
+}
+type SpringValueEmits = Record<string, never>;
+type SpringValueSlots = SlotsType<{
+  default: {
+    value: number;
+    velocity: number;
+    resting: boolean;
+  };
+}>;
+declare const SpringValue: vue.DefineSetupFnComponent<SpringValueProps, SpringValueEmits, SpringValueSlots, SpringValueProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue.PublicProps>;
+//#endregion
+//#region src/vue/system.d.ts
+declare function provideSpringSystem(system: SpringSystem, app?: App): void;
+declare function useSpringSystem(): void;
+//#endregion
+export { SpringValue, type SpringValueProps, type SpringValueSlots, provideSpringSystem, useSpring, useSpringSystem };