coily 0.14.0 → 0.16.0

package/dist/solver-CAXuxdKj.js

@@ -0,0 +1,243 @@
+//#region src/util.ts
+function invariant(condition, message) {
+	if (condition) return;
+	const resolved = typeof message === "function" ? message() : message;
+	throw new Error(resolved ?? "Invariant Failed");
+}
+/**
+* True for plain objects only. Excluding class instances makes shape walks
+* reject a `Spring` instead of descending into it as a nested shape.
+*/
+function isRecord(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function isRecordOrArray(value) {
+	return isRecord(value) || Array.isArray(value);
+}
+function isArray(value) {
+	return Array.isArray(value);
+}
+function isNumber(value) {
+	return typeof value === "number";
+}
+const RESOLVED = Promise.resolve();
+//#endregion
+//#region src/state.ts
+/**
+* The mutable position and velocity that a motion and its solvers share,
+* in displacement space. Position 0 means at the target.
+*/
+var State = class {
+	#config;
+	#position;
+	#velocity;
+	constructor(config, position, velocity) {
+		this.#config = config;
+		this.#position = position;
+		this.#velocity = velocity;
+	}
+	configure(config) {
+		this.#config = config;
+	}
+	get position() {
+		return this.#position;
+	}
+	set position(value) {
+		this.#position = value;
+	}
+	get velocity() {
+		return this.#velocity;
+	}
+	set velocity(value) {
+		this.#velocity = value;
+	}
+	/**
+	* True when |x| + |v| / wn, the displacement plus what the velocity could
+	* still add, is within the config's resting threshold.
+	*/
+	get isResting() {
+		return Math.abs(this.#position) + Math.abs(this.#velocity) / this.#config.naturalFrequency <= this.#config.restingMagnitude;
+	}
+};
+//#endregion
+//#region src/solver.ts
+/** dampingRatio < 1: decaying oscillation, x(t) = exp(-sigma*t) * (c1*cos(wd*t) + c2*sin(wd*t)). */
+var UnderdampedSolver = class {
+	#state;
+	#dampedFrequency = 0;
+	#decayRate = 0;
+	#arrival = 1;
+	#t = 0;
+	#c1 = 0;
+	#c2 = 0;
+	#crossing = Infinity;
+	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.#arrival = config.arrival;
+		}
+		this.#t = 0;
+		this.#c1 = this.#state.position;
+		this.#c2 = (this.#state.velocity + this.#decayRate * this.#state.position) / this.#dampedFrequency;
+		if (this.#arrival === 1) this.#crossing = Infinity;
+		else {
+			let theta = Math.atan2(-this.#c1, this.#c2) % Math.PI;
+			if (theta <= 0) theta += Math.PI;
+			this.#crossing = theta / this.#dampedFrequency;
+		}
+	}
+	tick(dt) {
+		let t = this.#t + dt;
+		while (t >= this.#crossing) {
+			t -= this.#crossing;
+			this.#arrive();
+			if (this.#state.isResting) return;
+		}
+		this.#t = t;
+		this.#evaluate();
+	}
+	#arrive() {
+		this.#t = this.#crossing;
+		this.#evaluate();
+		this.#state.position = 0;
+		this.#state.velocity *= this.#arrival;
+		this.configure();
+	}
+	#evaluate() {
+		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;
+	}
+};
+/** dampingRatio = 1: fastest non-oscillating decay, x(t) = (c1 + c2*t) * exp(-wn*t). */
+var CriticallyDampedSolver = class {
+	#state;
+	#naturalFrequency = 0;
+	#arrival = 1;
+	#t = 0;
+	#c1 = 0;
+	#c2 = 0;
+	#crossing = Infinity;
+	constructor(state) {
+		this.#state = state;
+	}
+	configure(config) {
+		if (config) {
+			this.#naturalFrequency = config.naturalFrequency;
+			this.#arrival = config.arrival;
+		}
+		this.#t = 0;
+		this.#c1 = this.#state.position;
+		this.#c2 = this.#state.velocity + this.#naturalFrequency * this.#state.position;
+		if (this.#arrival === 1) this.#crossing = Infinity;
+		else {
+			const t = -this.#c1 / this.#c2;
+			this.#crossing = t > 0 ? t : Infinity;
+		}
+	}
+	tick(dt) {
+		let t = this.#t + dt;
+		while (t >= this.#crossing) {
+			t -= this.#crossing;
+			this.#arrive();
+			if (this.#state.isResting) return;
+		}
+		this.#t = t;
+		this.#evaluate();
+	}
+	#arrive() {
+		this.#t = this.#crossing;
+		this.#evaluate();
+		this.#state.position = 0;
+		this.#state.velocity *= this.#arrival;
+		this.configure();
+	}
+	#evaluate() {
+		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;
+	}
+};
+/** The `wd * t` past which `OverdampedSolver` evaluates only its slow mode. */
+const TAIL = 20;
+/** dampingRatio > 1: slow non-oscillating decay, x(t) = exp(-sigma*t) * (c1*sinh(wd*t) + c2*cosh(wd*t)) / wd. */
+var OverdampedSolver = class {
+	#state;
+	#dampedFrequency = 0;
+	#decayRate = 0;
+	#arrival = 1;
+	#t = 0;
+	#c1 = 0;
+	#c2 = 0;
+	#crossing = Infinity;
+	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.#arrival = config.arrival;
+		}
+		this.#t = 0;
+		this.#c1 = this.#state.velocity + this.#decayRate * this.#state.position;
+		this.#c2 = this.#state.position * this.#dampedFrequency;
+		if (this.#arrival === 1) this.#crossing = Infinity;
+		else {
+			const theta = Math.atanh(-this.#c2 / this.#c1);
+			this.#crossing = theta > 0 ? theta / this.#dampedFrequency : Infinity;
+		}
+	}
+	tick(dt) {
+		let t = this.#t + dt;
+		while (t >= this.#crossing) {
+			t -= this.#crossing;
+			this.#arrive();
+			if (this.#state.isResting) return;
+		}
+		this.#t = t;
+		this.#evaluate();
+	}
+	#arrive() {
+		this.#t = this.#crossing;
+		this.#evaluate();
+		this.#state.position = 0;
+		this.#state.velocity *= this.#arrival;
+		this.configure();
+	}
+	#evaluate() {
+		const wd = this.#dampedFrequency;
+		const wdt = wd * this.#t;
+		if (wdt > TAIL) {
+			const slowRate = wd - this.#decayRate;
+			const position = (this.#c1 + this.#c2) / (2 * wd) * Math.exp(slowRate * this.#t);
+			this.#state.position = position;
+			this.#state.velocity = slowRate * position;
+			return;
+		}
+		const decay = Math.exp(-this.#decayRate * this.#t);
+		const decayVelocity = -this.#decayRate * decay;
+		const sinh = Math.sinh(wdt);
+		const cosh = Math.cosh(wdt);
+		const scale = this.#c1 * sinh + this.#c2 * cosh;
+		const scaleVelocity = this.#c1 * wd * cosh + this.#c2 * wd * sinh;
+		this.#state.position = scale * decay / wd;
+		this.#state.velocity = (scale * decayVelocity + scaleVelocity * decay) / wd;
+	}
+};
+//#endregion
+export { RESOLVED as a, isNumber as c, State as i, isRecord as l, OverdampedSolver as n, invariant as o, UnderdampedSolver as r, isArray as s, CriticallyDampedSolver as t, isRecordOrArray as u };