coily 0.11.0 → 0.12.0

package/dist/vue.js

@@ -1,13 +1,13 @@
-import { n as SpringConfig, t as createSpringSystem } from "./system-Dxxv4ee7.js";
-import { computed, customRef, defineComponent, inject, onBeforeUnmount, onMounted, provide, toRefs, toValue, watchSyncEffect } from "vue";
+import { n as SpringConfig, t as createSpringSystem } from "./system-DPaqec-Z.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");
 function provideSpringSystem(system, app) {
 	if (app) app.provide(SpringSystemKey, system);
 	else provide(SpringSystemKey, system);
 }
-function useSpringSystem() {
-	const system = createSpringSystem();
+function useSpringSystem(options) {
+	const system = createSpringSystem(options);
 	provideSpringSystem(system);
 	onMounted(() => {
 		system.start();
@@ -23,7 +23,17 @@ const defaultOptions = {
 	damping: 10,
 	precision: 2
 };
+/** @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);
+}
+function createSpringRef(target, options) {
 	const system = inject(SpringSystemKey);
 	if (!system) throw new Error("No SpringSystem found");
 	const config = computed(() => {
@@ -37,43 +47,207 @@ function useSpring(target, options) {
 	});
 	let triggerValue;
 	let triggerVelocity;
+	let triggerTimeRemaining;
 	spring.onUpdate(() => {
 		triggerValue?.();
 		triggerVelocity?.();
+		triggerTimeRemaining?.();
 	});
-	const value = customRef((track, trigger) => {
-		triggerValue = trigger;
+	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.value;
+				return spring.isResting;
 			},
-			set(value) {
-				spring.value = value;
-				trigger();
-			}
+			set() {}
 		};
 	});
-	const velocity = customRef((track, trigger) => {
-		triggerVelocity = trigger;
+	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, SpringInstanceKey, { 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);
+	watchSyncEffect(() => {
+		const c = config.value;
+		if (c) spring.configure(c);
+		else spring.clearConfigOverride();
+	});
+	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.velocity;
+				return spring.isResting;
 			},
-			set(value) {
-				spring.velocity = value;
-				trigger();
-			}
+			set() {}
 		};
 	});
-	const resting = customRef((track, trigger) => {
+	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;
+}
+/** @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 (hasSpring2DInstance(target)) return createLinkedSpringRef2D(target, options);
+	return createSpringRef2D(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 new SpringConfig(opts ?? defaultOptions);
+	});
+	const spring = system.createSpring2D(toValue(target), config.value);
+	watchSyncEffect(() => {
+		spring.configure(config.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.resting;
+				return spring.isResting;
 			},
 			set() {}
 		};
@@ -81,41 +255,113 @@ function useSpring(target, options) {
 	watchSyncEffect(() => {
 		spring.target = toValue(target);
 	});
-	return {
-		value,
+	if (getCurrentScope()) onScopeDispose(() => spring.dispose());
+	const ref = Object.assign(value, {
 		velocity,
-		resting,
-		jumpTo: (value) => {
-			spring.jumpTo(value);
+		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.configure(c);
+		else spring.clearConfigOverride();
+	});
+	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, Spring2DInstanceKey, { value: spring });
+	return ref;
 }
 //#endregion
 //#region src/vue/component.ts
-const SpringValue = defineComponent((props, { slots }) => {
-	const { target, mass, tension, damping, precision } = toRefs(props);
-	const spring = useSpring(target, () => ({
-		mass: mass?.value ?? 1,
-		tension: tension?.value ?? 100,
-		damping: damping?.value ?? 10,
-		precision: precision?.value ?? 2
-	}));
-	return () => {
-		return slots.default?.({
-			value: spring.value.value,
-			velocity: spring.velocity.value,
-			resting: spring.resting.value
-		}) ?? null;
-	};
+const SpringValue = defineComponent((props, { slots, expose }) => {
+	const { target, config } = toRefs(props);
+	const spring = useSpring(target, config);
+	expose({
+		value: spring,
+		velocity: spring.velocity,
+		isResting: spring.isResting,
+		timeRemaining: spring.timeRemaining,
+		jumpTo: spring.jumpTo
+	});
+	return () => slots.default?.({
+		value: spring.value,
+		velocity: spring.velocity.value,
+		isResting: spring.isResting.value,
+		timeRemaining: spring.timeRemaining.value,
+		jumpTo: spring.jumpTo
+	}) ?? null;
 }, {
 	name: "SpringValue",
-	props: [
-		"target",
-		"mass",
-		"tension",
-		"damping",
-		"precision"
-	]
+	props: ["target", "config"]
 });
 //#endregion
-export { SpringValue, provideSpringSystem, useSpring, useSpringSystem };
+export { SpringValue, provideSpringSystem, useSpring, useSpring2D, useSpringSystem };

package/package.json

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