coily 0.12.0 → 0.12.2

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { _ as defineSpring, a as Spring2D, c as Spring2DWithOffset, d as SpringPosition, f as SpringTarget, g as SpringState, h as SpringOptions, i as TickerOptions, l as Vector2, m as SpringConfig, n as SpringSystemOptions, o as Spring2DPosition, p as SpringWithOffset, r as createSpringSystem, s as Spring2DTarget, t as SpringSystem, u as Spring } from "./system-Do5rE0j7.js";
+import { _ as defineSpring, a as Spring2D, c as Spring2DWithOffset, d as SpringPosition, f as SpringTarget, g as SpringState, h as SpringOptions, i as TickerOptions, l as Vector2, m as SpringConfig, n as SpringSystemOptions, o as Spring2DPosition, p as SpringWithOffset, r as createSpringSystem, s as Spring2DTarget, t as SpringSystem, u as Spring } from "./system-coAFNYnb.js";
 export { type Spring, type Spring2D, type Spring2DPosition, type Spring2DTarget, type Spring2DWithOffset, type SpringConfig, type SpringOptions, type SpringPosition, type SpringState, type SpringSystem, type SpringSystemOptions, type SpringTarget, type SpringWithOffset, type TickerOptions, type Vector2, createSpringSystem, defineSpring };

package/dist/index.js

@@ -1,2 +1,2 @@
-import { r as defineSpring, t as createSpringSystem } from "./system-DPaqec-Z.js";
+import { r as defineSpring, t as createSpringSystem } from "./system-Bzrx4uso.js";
 export { createSpringSystem, defineSpring };

package/dist/{system-DPaqec-Z.js → system-Bzrx4uso.js}

@@ -34,10 +34,13 @@ function invariant(condition, message) {
 /**
 * Immutable spring configuration.
 */
-let globalConfigVersion = 0;
-var SpringConfig = class {
-	/** @internal Incremented by `SpringConfig.assign` to signal mutations. */
-	#version = 0;
+var SpringConfig = class SpringConfig {
+	static default = new SpringConfig({
+		dampingRatio: 1,
+		duration: 500
+	});
+	/** @internal Incremented by `assign` to signal mutations. Do not read or write directly. */
+	_version = 0;
 	mass;
 	tension;
 	damping;
@@ -119,16 +122,10 @@ var SpringConfig = class {
 		this.criticalDamping = 2 * this.mass * this.naturalFrequency;
 		this.dampingRatio = this.damping / this.criticalDamping;
 	}
-	static get globalVersion() {
-		return globalConfigVersion;
-	}
-	static version(config) {
-		return config.#version;
-	}
-	static assign(target, source) {
-		globalConfigVersion++;
-		target.#version++;
-		const t = target;
+	/** @internal Copies physical parameters from `source` onto this config and bumps `_version`. */
+	assign(source) {
+		this._version++;
+		const t = this;
 		t.mass = source.mass;
 		t.tension = source.tension;
 		t.damping = source.damping;
@@ -343,7 +340,6 @@ var Motion = class {
 	#needsUpdate = false;
 	#needsReset = false;
 	#configVersion = 0;
-	#globalConfigVersion = 0;
 	#timeRemaining = 0;
 	#emitter;
 	constructor(config, position, velocity) {
@@ -377,20 +373,15 @@ var Motion = class {
 	configure(config) {
 		this.#config = config;
 		this.#state.configure(config);
-		this.#configVersion = SpringConfig.version(config);
-		this.#globalConfigVersion = SpringConfig.globalVersion;
+		this.#configVersion = config._version;
 		this.#needsUpdate = true;
 	}
 	tick(dt, emit = true) {
 		invariant(this.#currentSolver, "Cannot tick a disposed motion");
-		const gv = SpringConfig.globalVersion;
-		if (gv !== this.#globalConfigVersion) {
-			this.#globalConfigVersion = gv;
-			if (SpringConfig.version(this.#config) !== this.#configVersion) {
-				this.#state.configure(this.#config);
-				this.#configVersion = SpringConfig.version(this.#config);
-				this.#needsUpdate = true;
-			}
+		if (this.#config._version !== this.#configVersion) {
+			this.#state.configure(this.#config);
+			this.#configVersion = this.#config._version;
+			this.#needsUpdate = true;
 		}
 		const needsTimeRemaining = this.#needsUpdate || this.#needsReset;
 		if (this.#needsUpdate) {
@@ -455,14 +446,14 @@ function normalizeTarget(target) {
 	};
 	return null;
 }
-var Spring = class Spring {
+var Spring = class {
 	#target;
 	#config;
 	#motion;
 	#motions;
 	#leader = null;
 	#offset = 0;
-	#hasConfigOverride;
+	#ownsConfig;
 	#unsubLeader = null;
 	constructor(motions, position, config) {
 		this.#motions = motions;
@@ -475,7 +466,7 @@ var Spring = class Spring {
 		} else {
 			normalized = normalizeTarget(position.target);
 			if (normalized) {
-				numericTarget = Spring.#rawValue(normalized.spring) + normalized.offset;
+				numericTarget = normalized.spring.#target + normalized.spring.#motion.position + normalized.offset;
 				value = position.value ?? numericTarget;
 			} else {
 				numericTarget = position.target ?? position.value ?? 0;
@@ -483,9 +474,9 @@ var Spring = class Spring {
 			}
 		}
 		const hasOverride = config !== void 0;
-		this.#hasConfigOverride = hasOverride || !normalized;
+		this.#ownsConfig = hasOverride || !normalized;
 		if (normalized && !hasOverride) this.#config = normalized.spring.#config;
-		else this.#config = config;
+		else this.#config = config ?? SpringConfig.default;
 		this.#target = numericTarget;
 		this.#motion = new Motion(this.#config, value - numericTarget, 0);
 		if (!this.#motion.isResting) this.#motions.add(this.#motion);
@@ -493,7 +484,7 @@ var Spring = class Spring {
 			this.#leader = normalized.spring;
 			this.#offset = normalized.offset;
 			this.#unsubLeader = normalized.spring.onUpdate(() => {
-				this.#setTarget(Spring.#rawValue(this.#leader) + this.#offset);
+				this.#setTarget(this.#leader.#target + this.#leader.#motion.position + this.#offset);
 			});
 		}
 	}
@@ -545,23 +536,22 @@ var Spring = class Spring {
 	get precision() {
 		return this.#config.precision;
 	}
-	configure(config) {
-		if (this.#leader && !this.#hasConfigOverride) {
-			this.#hasConfigOverride = true;
-			this.#config = new SpringConfig({
-				tension: config.tension,
-				damping: config.damping,
-				mass: config.mass,
-				precision: config.precision
-			});
-			this.#motion.configure(this.#config);
-		} else SpringConfig.assign(this.#config, config);
-		this.#motions.add(this.#motion);
-	}
-	clearConfigOverride() {
-		if (this.#leader && this.#hasConfigOverride) {
-			this.#hasConfigOverride = false;
-			this.#config = this.#leader.#config;
+	set config(value) {
+		if (value) {
+			if (this.#leader && !this.#ownsConfig) {
+				this.#ownsConfig = true;
+				this.#config = new SpringConfig({
+					tension: value.tension,
+					damping: value.damping,
+					mass: value.mass,
+					precision: value.precision
+				});
+				this.#motion.configure(this.#config);
+			} else this.#config.assign(value);
+			this.#motions.add(this.#motion);
+		} else if (this.#ownsConfig) {
+			this.#ownsConfig = false;
+			this.#config = this.#leader ? this.#leader.#config : SpringConfig.default;
 			this.#motion.configure(this.#config);
 			this.#motions.add(this.#motion);
 		}
@@ -595,9 +585,6 @@ var Spring = class Spring {
 	onStop(callback) {
 		return this.#motion.onStop(callback);
 	}
-	static #rawValue(spring) {
-		return spring.#target + spring.#motion.position;
-	}
 	#setTarget(value) {
 		if (value !== this.#target) {
 			this.#motions.add(this.#motion);
@@ -611,14 +598,14 @@ var Spring = class Spring {
 		if (this.#unsubLeader) this.#unsubLeader();
 		this.#leader = leader;
 		this.#offset = offset;
-		if (!this.#hasConfigOverride) {
+		if (!this.#ownsConfig) {
 			this.#config = leader.#config;
 			this.#motion.configure(this.#config);
 		}
 		this.#unsubLeader = leader.onUpdate(() => {
-			this.#setTarget(Spring.#rawValue(this.#leader) + this.#offset);
+			this.#setTarget(this.#leader.#target + this.#leader.#motion.position + this.#offset);
 		});
-		this.#setTarget(Spring.#rawValue(leader) + offset);
+		this.#setTarget(leader.#target + leader.#motion.position + offset);
 	}
 	#unfollow() {
 		if (!this.#leader) return;
@@ -626,8 +613,8 @@ var Spring = class Spring {
 		this.#unsubLeader = null;
 		this.#leader = null;
 		this.#offset = 0;
-		if (!this.#hasConfigOverride) {
-			this.#hasConfigOverride = true;
+		if (!this.#ownsConfig) {
+			this.#ownsConfig = true;
 			this.#config = new SpringConfig({
 				tension: this.#config.tension,
 				damping: this.#config.damping,
@@ -778,13 +765,9 @@ var Spring2D = class Spring2D {
 	get precision() {
 		return this.#x.precision;
 	}
-	configure(config) {
-		this.#x.configure(config);
-		this.#y.configure(config);
-	}
-	clearConfigOverride() {
-		this.#x.clearConfigOverride();
-		this.#y.clearConfigOverride();
+	set config(value) {
+		this.#x.config = value;
+		this.#y.config = value;
 	}
 	get timeRemaining() {
 		return Math.max(this.#x.timeRemaining, this.#y.timeRemaining);

package/dist/{system-Do5rE0j7.d.ts → system-coAFNYnb.d.ts}

@@ -71,8 +71,11 @@ interface TensionBounceDurationOptions extends BaseOptions, WithTension, WithBou
 interface DampingDurationOptions extends BaseOptions, WithDamping, WithDampingRatio, WithDuration, WithDisplacement {}
 interface DampingBounceDurationOptions extends BaseOptions, WithDamping, WithBounce, WithDuration, WithDisplacement {}
 type SpringOptions = DirectOptions | TensionRatioOptions | TensionBounceOptions | DampingRatioOptions | DampingBounceOptions | TensionDampingRatioOptions | TensionDampingBounceOptions | DurationOptions | BounceDurationOptions | TensionDurationOptions | TensionBounceDurationOptions | DampingDurationOptions | DampingBounceDurationOptions;
+/**
+ * Immutable spring configuration.
+ */
 declare class SpringConfig {
-  #private;
+  static readonly default: SpringConfig;
   readonly mass: number;
   readonly tension: number;
   readonly damping: number;
@@ -83,9 +86,6 @@ declare class SpringConfig {
   readonly precisionMultiplier: number;
   readonly restingMagnitude: number;
   constructor(input: SpringOptions);
-  static get globalVersion(): number;
-  static version(config: SpringConfig): number;
-  static assign(target: SpringConfig, source: SpringConfig): void;
   /**
    * Analytically estimates the time remaining for a spring to come to rest,
    * given the current displacement and velocity.
@@ -229,15 +229,11 @@ interface SpringWithOffset {
   offset?: number | undefined;
 }
 type SpringTarget = number | Spring | SpringWithOffset;
-interface StandaloneSpringPosition {
-  target?: number | undefined;
+interface DisplacedSpringPosition {
+  target?: SpringTarget | undefined;
   value?: number | undefined;
 }
-interface FollowingSpringPosition {
-  target: Spring | SpringWithOffset;
-  value?: number | undefined;
-}
-type SpringPosition = number | StandaloneSpringPosition | FollowingSpringPosition;
+type SpringPosition = number | DisplacedSpringPosition;
 declare class Spring {
   #private;
   constructor(motions: MotionSet, position: SpringPosition, config?: SpringConfig);
@@ -247,14 +243,13 @@ declare class Spring {
   set value(value: number);
   get velocity(): number;
   set velocity(value: number);
-  get config(): SpringConfig;
+  get config(): SpringConfig | null;
   get mass(): number;
   get tension(): number;
   get damping(): number;
   get dampingRatio(): number;
   get precision(): number;
-  configure(config: SpringConfig): void;
-  clearConfigOverride(): void;
+  set config(value: SpringConfig | null);
   get timeRemaining(): number;
   get isResting(): boolean;
   jumpTo(value: number): void;
@@ -290,14 +285,13 @@ declare class Spring2D {
   set value(value: Vector2);
   get velocity(): Readonly<Vector2>;
   set velocity(value: Vector2);
-  get config(): SpringConfig;
+  get config(): SpringConfig | null;
   get mass(): number;
   get tension(): number;
   get damping(): number;
   get dampingRatio(): number;
   get precision(): number;
-  configure(config: SpringConfig): void;
-  clearConfigOverride(): void;
+  set config(value: SpringConfig | null);
   get timeRemaining(): number;
   get isResting(): boolean;
   jumpTo(value: Vector2): void;

package/dist/vue.d.ts

@@ -1,4 +1,4 @@
-import { h as SpringOptions, l as Vector2, m as SpringConfig, n as SpringSystemOptions, t as SpringSystem } from "./system-Do5rE0j7.js";
+import { h as SpringOptions, l as Vector2, m as SpringConfig, n as SpringSystemOptions, t as SpringSystem } from "./system-coAFNYnb.js";
 import * as vue from "vue";
 import { App, MaybeRefOrGetter, Ref, SlotsType } from "vue";
 
@@ -13,6 +13,8 @@ interface SpringRef extends Ref<number> {
 declare function useSpring(target: MaybeRefOrGetter<number>, options?: UseSpringOptions): SpringRef;
 declare function useSpring(target: SpringRef, options?: UseSpringOptions): SpringRef;
 declare function useSpring<const T extends readonly MaybeRefOrGetter<number>[]>(targets: T, options?: UseSpringOptions): { [K in keyof T]: SpringRef };
+//#endregion
+//#region src/vue/spring2d.d.ts
 interface SpringRef2D extends Ref<Readonly<Vector2>> {
   readonly velocity: Ref<Readonly<Vector2>>;
   readonly timeRemaining: Ref<number>;
@@ -21,6 +23,7 @@ interface SpringRef2D extends Ref<Readonly<Vector2>> {
 }
 declare function useSpring2D(target: MaybeRefOrGetter<Vector2>, options?: UseSpringOptions): SpringRef2D;
 declare function useSpring2D(target: SpringRef2D, options?: UseSpringOptions): SpringRef2D;
+declare function useSpring2D<const T extends readonly MaybeRefOrGetter<Vector2>[]>(targets: T, options?: UseSpringOptions): { [K in keyof T]: SpringRef2D };
 //#endregion
 //#region src/vue/component.d.ts
 interface SpringValueProps {

package/dist/vue.js

@@ -1,4 +1,4 @@
-import { n as SpringConfig, t as createSpringSystem } from "./system-DPaqec-Z.js";
+import { n as SpringConfig, t as createSpringSystem } from "./system-Bzrx4uso.js";
 import { computed, customRef, defineComponent, getCurrentScope, inject, onBeforeUnmount, onMounted, onScopeDispose, provide, toRefs, toValue, watchSyncEffect } from "vue";
 //#region src/vue/system.ts
 const SpringSystemKey = Symbol.for("coily/spring-system");
@@ -18,11 +18,6 @@ function useSpringSystem(options) {
 }
 //#endregion
 //#region src/vue/spring.ts
-const defaultOptions = {
-	tension: 100,
-	damping: 10,
-	precision: 2
-};
 /** @internal Symbol to access the underlying Spring from a SpringRef */
 const SpringInstanceKey = Symbol("spring");
 function hasSpringInstance(value) {
@@ -39,11 +34,13 @@ function createSpringRef(target, options) {
 	const config = computed(() => {
 		const opts = toValue(options);
 		if (opts instanceof SpringConfig) return opts;
-		return new SpringConfig(opts ?? defaultOptions);
+		return opts ? new SpringConfig(opts) : void 0;
 	});
-	const spring = system.createSpring(toValue(target), config.value);
+	const spring = system.createSpring(toValue(target), config.value ?? void 0);
 	watchSyncEffect(() => {
-		spring.configure(config.value);
+		const c = config.value;
+		if (c) spring.config = c;
+		else spring.config = null;
 	});
 	let triggerValue;
 	let triggerVelocity;
@@ -120,8 +117,8 @@ function createLinkedSpringRef(leaderRef, options) {
 	const spring = system.createSpring({ target: leaderSpring }, config.value);
 	watchSyncEffect(() => {
 		const c = config.value;
-		if (c) spring.configure(c);
-		else spring.clearConfigOverride();
+		if (c) spring.config = c;
+		else spring.config = null;
 	});
 	let triggerValue;
 	let triggerVelocity;
@@ -182,12 +179,15 @@ function createLinkedSpringRef(leaderRef, options) {
 	Object.defineProperty(ref, SpringInstanceKey, { value: spring });
 	return ref;
 }
+//#endregion
+//#region src/vue/spring2d.ts
 /** @internal Symbol to access the underlying Spring2D from a SpringRef2D */
 const Spring2DInstanceKey = Symbol("spring2d");
 function hasSpring2DInstance(value) {
 	return typeof value === "object" && value !== null && Spring2DInstanceKey in value;
 }
 function useSpring2D(target, options) {
+	if (Array.isArray(target)) return Array.from(target, (t) => createSpringRef2D(t, options));
 	if (hasSpring2DInstance(target)) return createLinkedSpringRef2D(target, options);
 	return createSpringRef2D(target, options);
 }
@@ -197,11 +197,13 @@ function createSpringRef2D(target, options) {
 	const config = computed(() => {
 		const opts = toValue(options);
 		if (opts instanceof SpringConfig) return opts;
-		return new SpringConfig(opts ?? defaultOptions);
+		return opts ? new SpringConfig(opts) : void 0;
 	});
-	const spring = system.createSpring2D(toValue(target), config.value);
+	const spring = system.createSpring2D(toValue(target), config.value ?? void 0);
 	watchSyncEffect(() => {
-		spring.configure(config.value);
+		const c = config.value;
+		if (c) spring.config = c;
+		else spring.config = null;
 	});
 	let triggerValue;
 	let triggerVelocity;
@@ -278,8 +280,8 @@ function createLinkedSpringRef2D(leaderRef, options) {
 	const spring = system.createSpring2D({ target: leaderSpring }, config.value);
 	watchSyncEffect(() => {
 		const c = config.value;
-		if (c) spring.configure(c);
-		else spring.clearConfigOverride();
+		if (c) spring.config = c;
+		else spring.config = null;
 	});
 	let triggerValue;
 	let triggerVelocity;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coily",
-  "version": "0.12.0",
+  "version": "0.12.2",
   "description": "Simulate values using spring physics",
   "homepage": "https://github.com/tkofh/coily#readme",
   "bugs": {