coily 0.12.2 → 0.13.1

package/dist/vue.d.ts

@@ -1,29 +1,34 @@
-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 { _ as SpringOptions, a as ConfigShape, c as Shape, f as Spring, g as SpringConfig, l as SpringObject, n as SpringSystemOptions, o as PartialShape, p as SpringPosition, s as ReadonlyShape, t as SpringSystem } from "./system-86fsXJN_.js";
 import { App, MaybeRefOrGetter, Ref, SlotsType } from "vue";
-
-//#region src/vue/spring.d.ts
+//#region src/vue/reactive-spring.d.ts
 type UseSpringOptions = MaybeRefOrGetter<SpringOptions | SpringConfig | undefined>;
-interface SpringRef extends Ref<number> {
-  readonly velocity: Ref<number>;
+interface ReactiveSpringRef<V, W = V> extends Ref<V, W> {
+  readonly velocity: Ref<V, W>;
   readonly timeRemaining: Ref<number>;
   readonly isResting: Ref<boolean>;
-  readonly jumpTo: (value: number) => void;
+  readonly settled: Promise<void>;
+  readonly jumpTo: (value: W) => void;
 }
+//#endregion
+//#region src/vue/spring-object.d.ts
+type UseSpringObjectOptions<T extends object> = MaybeRefOrGetter<ConfigShape<T> | undefined>;
+interface SpringObjectRef<T extends object> extends ReactiveSpringRef<ReadonlyShape<T>, PartialShape<T>> {}
+//#endregion
+//#region src/vue/spring.d.ts
+interface SpringRef extends ReactiveSpringRef<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 };
+declare function useSpring<T extends object>(target: SpringObjectRef<T>, options?: UseSpringObjectOptions<T>): SpringObjectRef<T>;
+declare function useSpring<T extends object>(target: T & Shape<T>, options?: UseSpringObjectOptions<T>): SpringObjectRef<T>;
+declare function useSpring<T extends object>(target: Ref<T & Shape<T>>, options?: UseSpringObjectOptions<T>): SpringObjectRef<T>;
+declare function useSpring<T extends object>(target: () => T & Shape<T>, options?: UseSpringObjectOptions<T>): SpringObjectRef<T>;
 //#endregion
-//#region src/vue/spring2d.d.ts
-interface SpringRef2D extends Ref<Readonly<Vector2>> {
-  readonly velocity: Ref<Readonly<Vector2>>;
-  readonly timeRemaining: Ref<number>;
-  readonly isResting: Ref<boolean>;
-  readonly jumpTo: (value: Vector2) => void;
+//#region src/vue/pool.d.ts
+interface SpringPool {
+  createSpring(position: SpringPosition, config?: SpringConfig): Spring;
+  createSpringObject<T extends object>(value: T & Shape<T>, config?: ConfigShape<T>): SpringObject<T>;
 }
-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 };
+declare function useSpringPool(): SpringPool;
 //#endregion
 //#region src/vue/component.d.ts
 interface SpringValueProps {
@@ -41,12 +46,12 @@ interface SpringValueSlotScope {
 type SpringValueSlots = SlotsType<{
   default: SpringValueSlotScope;
 }>;
-declare const SpringValue: vue.DefineSetupFnComponent<SpringValueProps, SpringValueEmits, SpringValueSlots, SpringValueProps & {
+declare const SpringValue: import("vue").DefineSetupFnComponent<SpringValueProps, SpringValueEmits, SpringValueSlots, SpringValueProps & {
   [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
-}, vue.PublicProps>;
+}, import("vue").PublicProps>;
 //#endregion
 //#region src/vue/system.d.ts
 declare function provideSpringSystem(system: SpringSystem, app?: App): void;
-declare function useSpringSystem(options?: SpringSystemOptions): void;
+declare function useSpringSystem(options?: SpringSystemOptions): SpringSystem;
 //#endregion
-export { type SpringRef, type SpringRef2D, SpringValue, type SpringValueProps, type SpringValueSlots, provideSpringSystem, useSpring, useSpring2D, useSpringSystem };
+export { type SpringObjectRef, type SpringPool, type SpringRef, SpringValue, type SpringValueProps, type SpringValueSlots, type UseSpringObjectOptions, provideSpringSystem, useSpring, useSpringPool, useSpringSystem };

package/dist/vue.js

@@ -1,46 +1,62 @@
-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";
+import { n as SpringConfig, t as createSpringSystem } from "./system-Csho09XW.js";
+import { computed, customRef, defineComponent, getCurrentInstance, getCurrentScope, inject, onBeforeUnmount, onMounted, onScopeDispose, provide, toRefs, toValue, watchSyncEffect } from "vue";
+//#region src/vue/local.ts
+const localProvides = /* @__PURE__ */ new WeakMap();
+function provideLocal(key, value) {
+	const instance = getCurrentInstance();
+	if (instance) {
+		let values = localProvides.get(instance);
+		if (!values) {
+			values = /* @__PURE__ */ new Map();
+			localProvides.set(instance, values);
+		}
+		values.set(key, value);
+	}
+	provide(key, value);
+}
+function injectLocal(key) {
+	const instance = getCurrentInstance();
+	if (instance) {
+		const values = localProvides.get(instance);
+		if (values?.has(key)) return values.get(key);
+	}
+	return inject(key, void 0);
+}
+//#endregion
 //#region src/vue/system.ts
 const SpringSystemKey = Symbol.for("coily/spring-system");
 function provideSpringSystem(system, app) {
 	if (app) app.provide(SpringSystemKey, system);
-	else provide(SpringSystemKey, system);
+	else provideLocal(SpringSystemKey, system);
 }
 function useSpringSystem(options) {
+	if (!getCurrentInstance()) throw new Error("useSpringSystem must be called inside setup()");
+	const existing = injectLocal(SpringSystemKey);
+	if (existing) return existing;
 	const system = createSpringSystem(options);
-	provideSpringSystem(system);
-	onMounted(() => {
-		system.start();
-	});
-	onBeforeUnmount(() => {
-		system.stop();
-	});
+	provideLocal(SpringSystemKey, system);
+	onMounted(() => system.start());
+	onBeforeUnmount(() => system.stop());
+	return system;
 }
 //#endregion
-//#region src/vue/spring.ts
-/** @internal Symbol to access the underlying Spring from a SpringRef */
-const SpringInstanceKey = Symbol("spring");
-function hasSpringInstance(value) {
-	return typeof value === "object" && value !== null && SpringInstanceKey in value;
-}
-function useSpring(target, options) {
-	if (Array.isArray(target)) return Array.from(target, (t) => createSpringRef(t, options));
-	if (hasSpringInstance(target)) return createLinkedSpringRef(target, options);
-	return createSpringRef(target, options);
+//#region src/vue/reactive-spring.ts
+const divergentRef = customRef;
+function injectSpringSystem() {
+	const system = injectLocal(SpringSystemKey);
+	if (!system) throw new Error("No SpringSystem found — install the coily/nuxt module or call useSpringSystem() in an ancestor component");
+	return system;
 }
-function createSpringRef(target, options) {
-	const system = inject(SpringSystemKey);
-	if (!system) throw new Error("No SpringSystem found");
-	const config = computed(() => {
+function resolveSpringConfig(options) {
+	return computed(() => {
 		const opts = toValue(options);
 		if (opts instanceof SpringConfig) return opts;
 		return opts ? new SpringConfig(opts) : void 0;
 	});
-	const spring = system.createSpring(toValue(target), config.value ?? void 0);
+}
+function createReactiveSpringRef(spring, config, instanceKey) {
 	watchSyncEffect(() => {
-		const c = config.value;
-		if (c) spring.config = c;
-		else spring.config = null;
+		spring.config = config.value ?? null;
 	});
 	let triggerValue;
 	let triggerVelocity;
@@ -50,25 +66,25 @@ function createSpringRef(target, options) {
 		triggerVelocity?.();
 		triggerTimeRemaining?.();
 	});
-	const value = customRef((track, trigger) => ({
+	const value = divergentRef((track, trigger) => ({
 		get() {
 			triggerValue ??= trigger;
 			track();
 			return spring.value;
 		},
-		set(value) {
-			spring.value = value;
+		set(next) {
+			spring.value = next;
 			trigger();
 		}
 	}));
-	const velocity = customRef((track, trigger) => ({
+	const velocity = divergentRef((track, trigger) => ({
 		get() {
 			triggerVelocity ??= trigger;
 			track();
 			return spring.velocity;
 		},
-		set(value) {
-			spring.velocity = value;
+		set(next) {
+			spring.velocity = next;
 			trigger();
 		}
 	}));
@@ -91,256 +107,94 @@ function createSpringRef(target, options) {
 			set() {}
 		};
 	});
-	watchSyncEffect(() => {
-		spring.target = toValue(target);
-	});
 	if (getCurrentScope()) onScopeDispose(() => spring.dispose());
 	const ref = Object.assign(value, {
 		velocity,
 		timeRemaining,
 		isResting,
-		jumpTo: (value) => spring.jumpTo(value)
+		jumpTo: (next) => spring.jumpTo(next)
 	});
-	Object.defineProperty(ref, SpringInstanceKey, { value: spring });
+	Object.defineProperty(ref, "settled", { get: () => spring.settled });
+	Object.defineProperty(ref, instanceKey, { value: spring });
 	return ref;
 }
-function createLinkedSpringRef(leaderRef, options) {
-	const system = inject(SpringSystemKey);
-	if (!system) throw new Error("No SpringSystem found");
-	const leaderSpring = leaderRef[SpringInstanceKey];
-	const config = computed(() => {
-		const opts = toValue(options);
-		if (!opts) return void 0;
-		if (opts instanceof SpringConfig) return opts;
-		return new SpringConfig(opts);
-	});
-	const spring = system.createSpring({ target: leaderSpring }, config.value);
+//#endregion
+//#region src/vue/spring-object.ts
+/** @internal */
+const SpringObjectInstanceKey = Symbol("spring-object");
+function hasSpringObjectInstance(value) {
+	return typeof value === "object" && value !== null && SpringObjectInstanceKey in value;
+}
+function resolveConfigShape(options) {
+	return computed(() => toValue(options));
+}
+function createSpringObjectRef(value, options) {
+	const system = injectSpringSystem();
+	const config = resolveConfigShape(options);
+	const spring = system.createSpringObject(toValue(value), config.value);
+	const ref = createReactiveSpringRef(spring, config, SpringObjectInstanceKey);
 	watchSyncEffect(() => {
-		const c = config.value;
-		if (c) spring.config = c;
-		else spring.config = null;
+		spring.target = toValue(value);
 	});
-	let triggerValue;
-	let triggerVelocity;
-	let triggerTimeRemaining;
-	spring.onUpdate(() => {
-		triggerValue?.();
-		triggerVelocity?.();
-		triggerTimeRemaining?.();
-	});
-	const value = customRef((track, trigger) => ({
-		get() {
-			triggerValue ??= trigger;
-			track();
-			return spring.value;
-		},
-		set(value) {
-			spring.value = value;
-			trigger();
-		}
-	}));
-	const velocity = customRef((track, trigger) => ({
-		get() {
-			triggerVelocity ??= trigger;
-			track();
-			return spring.velocity;
-		},
-		set(value) {
-			spring.velocity = value;
-			trigger();
-		}
-	}));
-	const timeRemaining = customRef((track, trigger) => ({
-		get() {
-			triggerTimeRemaining ??= trigger;
-			track();
-			return spring.timeRemaining;
-		},
-		set() {}
-	}));
-	const isResting = customRef((track, trigger) => {
-		spring.onStart(trigger);
-		spring.onStop(trigger);
-		return {
-			get() {
-				track();
-				return spring.isResting;
-			},
-			set() {}
-		};
-	});
-	if (getCurrentScope()) onScopeDispose(() => spring.dispose());
-	const ref = Object.assign(value, {
-		velocity,
-		timeRemaining,
-		isResting,
-		jumpTo: (value) => spring.jumpTo(value)
-	});
-	Object.defineProperty(ref, SpringInstanceKey, { value: spring });
 	return ref;
 }
+function createLinkedSpringObjectRef(leaderRef, options) {
+	const system = injectSpringSystem();
+	const leader = leaderRef[SpringObjectInstanceKey];
+	const config = resolveConfigShape(options);
+	const spring = system.createSpringObject(leader.value, config.value);
+	spring.target = leader;
+	return createReactiveSpringRef(spring, config, SpringObjectInstanceKey);
+}
 //#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;
+//#region src/vue/spring.ts
+/** @internal */
+const SpringInstanceKey = Symbol("spring");
+function hasSpringInstance(value) {
+	return typeof value === "object" && value !== null && SpringInstanceKey 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);
+function useSpring(target, options) {
+	if (hasSpringInstance(target)) return createLinkedSpringRef(target, options);
+	if (hasSpringObjectInstance(target)) return createLinkedSpringObjectRef(target, options);
+	if (typeof toValue(target) === "number") return createSpringRef(target, options);
+	return createSpringObjectRef(target, options);
 }
-function createSpringRef2D(target, options) {
-	const system = inject(SpringSystemKey);
-	if (!system) throw new Error("No SpringSystem found");
-	const config = computed(() => {
-		const opts = toValue(options);
-		if (opts instanceof SpringConfig) return opts;
-		return opts ? new SpringConfig(opts) : void 0;
-	});
-	const spring = system.createSpring2D(toValue(target), config.value ?? void 0);
-	watchSyncEffect(() => {
-		const c = config.value;
-		if (c) spring.config = c;
-		else spring.config = null;
-	});
-	let triggerValue;
-	let triggerVelocity;
-	let triggerTimeRemaining;
-	spring.onUpdate(() => {
-		triggerValue?.();
-		triggerVelocity?.();
-		triggerTimeRemaining?.();
-	});
-	const value = customRef((track, trigger) => ({
-		get() {
-			triggerValue ??= trigger;
-			track();
-			return spring.value;
-		},
-		set(value) {
-			spring.value = value;
-			trigger();
-		}
-	}));
-	const velocity = customRef((track, trigger) => ({
-		get() {
-			triggerVelocity ??= trigger;
-			track();
-			return spring.velocity;
-		},
-		set(value) {
-			spring.velocity = value;
-			trigger();
-		}
-	}));
-	const timeRemaining = customRef((track, trigger) => ({
-		get() {
-			triggerTimeRemaining ??= trigger;
-			track();
-			return spring.timeRemaining;
-		},
-		set() {}
-	}));
-	const isResting = customRef((track, trigger) => {
-		spring.onStart(trigger);
-		spring.onStop(trigger);
-		return {
-			get() {
-				track();
-				return spring.isResting;
-			},
-			set() {}
-		};
-	});
+function createSpringRef(target, options) {
+	const system = injectSpringSystem();
+	const config = resolveSpringConfig(options);
+	const spring = system.createSpring(toValue(target), config.value);
+	const ref = createReactiveSpringRef(spring, config, SpringInstanceKey);
 	watchSyncEffect(() => {
 		spring.target = toValue(target);
 	});
-	if (getCurrentScope()) onScopeDispose(() => spring.dispose());
-	const ref = Object.assign(value, {
-		velocity,
-		timeRemaining,
-		isResting,
-		jumpTo: (value) => spring.jumpTo(value)
-	});
-	Object.defineProperty(ref, Spring2DInstanceKey, { value: spring });
 	return ref;
 }
-function createLinkedSpringRef2D(leaderRef, options) {
-	const system = inject(SpringSystemKey);
-	if (!system) throw new Error("No SpringSystem found");
-	const leaderSpring = leaderRef[Spring2DInstanceKey];
-	const config = computed(() => {
-		const opts = toValue(options);
-		if (!opts) return void 0;
-		if (opts instanceof SpringConfig) return opts;
-		return new SpringConfig(opts);
-	});
-	const spring = system.createSpring2D({ target: leaderSpring }, config.value);
-	watchSyncEffect(() => {
-		const c = config.value;
-		if (c) spring.config = c;
-		else spring.config = null;
-	});
-	let triggerValue;
-	let triggerVelocity;
-	let triggerTimeRemaining;
-	spring.onUpdate(() => {
-		triggerValue?.();
-		triggerVelocity?.();
-		triggerTimeRemaining?.();
-	});
-	const value = customRef((track, trigger) => ({
-		get() {
-			triggerValue ??= trigger;
-			track();
-			return spring.value;
-		},
-		set(value) {
-			spring.value = value;
-			trigger();
-		}
-	}));
-	const velocity = customRef((track, trigger) => ({
-		get() {
-			triggerVelocity ??= trigger;
-			track();
-			return spring.velocity;
-		},
-		set(value) {
-			spring.velocity = value;
-			trigger();
+function createLinkedSpringRef(leaderRef, options) {
+	const system = injectSpringSystem();
+	const config = resolveSpringConfig(options);
+	return createReactiveSpringRef(system.createSpring({ target: leaderRef[SpringInstanceKey] }, config.value), config, SpringInstanceKey);
+}
+//#endregion
+//#region src/vue/pool.ts
+function useSpringPool() {
+	const system = injectSpringSystem();
+	const live = /* @__PURE__ */ new Set();
+	const adopt = (spring) => {
+		live.add(spring);
+		spring.onDispose(() => {
+			live.delete(spring);
+		});
+		return spring;
+	};
+	onScopeDispose(() => {
+		for (const spring of live) spring.dispose();
+	}, true);
+	return {
+		createSpring: (position, config) => adopt(system.createSpring(position, config)),
+		createSpringObject(value, config) {
+			return adopt(system.createSpringObject(value, config));
 		}
-	}));
-	const timeRemaining = customRef((track, trigger) => ({
-		get() {
-			triggerTimeRemaining ??= trigger;
-			track();
-			return spring.timeRemaining;
-		},
-		set() {}
-	}));
-	const isResting = customRef((track, trigger) => {
-		spring.onStart(trigger);
-		spring.onStop(trigger);
-		return {
-			get() {
-				track();
-				return spring.isResting;
-			},
-			set() {}
-		};
-	});
-	if (getCurrentScope()) onScopeDispose(() => spring.dispose());
-	const ref = Object.assign(value, {
-		velocity,
-		timeRemaining,
-		isResting,
-		jumpTo: (value) => spring.jumpTo(value)
-	});
-	Object.defineProperty(ref, Spring2DInstanceKey, { value: spring });
-	return ref;
+	};
 }
 //#endregion
 //#region src/vue/component.ts
@@ -366,4 +220,4 @@ const SpringValue = defineComponent((props, { slots, expose }) => {
 	props: ["target", "config"]
 });
 //#endregion
-export { SpringValue, provideSpringSystem, useSpring, useSpring2D, useSpringSystem };
+export { SpringValue, provideSpringSystem, useSpring, useSpringPool, useSpringSystem };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coily",
-  "version": "0.12.2",
+  "version": "0.13.1",
   "description": "Simulate values using spring physics",
   "homepage": "https://github.com/tkofh/coily#readme",
   "bugs": {
@@ -27,22 +27,24 @@
     "access": "public"
   },
   "devDependencies": {
-    "@nuxt/kit": "^4.4.2",
-    "@nuxt/schema": "^4.4.2",
-    "@vitejs/plugin-vue": "^6.0.5",
-    "@vitest/browser-playwright": "^4.1.0",
-    "@vitest/coverage-v8": "^4.1.0",
-    "@vue/test-utils": "^2.4.6",
-    "fast-check": "^4.6.0",
-    "happy-dom": "^20.8.4",
-    "tsdown": "^0.21.3",
-    "vitest": "^4.1.0",
+    "@nuxt/kit": "^4.4.8",
+    "@nuxt/schema": "^4.4.8",
+    "@vitejs/plugin-vue": "^6.0.7",
+    "@vitest/browser-playwright": "^4.1.10",
+    "@vitest/coverage-v8": "^4.1.10",
+    "@vue/test-utils": "^2.4.11",
+    "fast-check": "^4.9.0",
+    "happy-dom": "^20.10.6",
+    "playwright": "1.61.1",
+    "tsdown": "^0.22.4",
+    "typescript": "^6.0.0",
+    "vitest": "^4.1.10",
     "vitest-browser-vue": "^2.1.0",
-    "vue": "^3.5.30"
+    "vue": "^3.5.39"
   },
   "peerDependencies": {
     "@nuxt/kit": "^4.0.0",
-    "vue": "^3.4.0"
+    "vue": "^3.5.0"
   },
   "peerDependenciesMeta": {
     "vue": {
@@ -52,11 +54,9 @@
       "optional": true
     }
   },
-  "engines": {
-    "node": ">=24.10.0"
-  },
   "scripts": {
     "build": "tsdown",
+    "check": "tsc -p .",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "bench": "vitest bench --run",