coily 0.10.1 → 0.12.0

package/dist/vue.js

@@ -0,0 +1,367 @@
+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(options) {
+	const system = createSpringSystem(options);
+	provideSpringSystem(system);
+	onMounted(() => {
+		system.start();
+	});
+	onBeforeUnmount(() => {
+		system.stop();
+	});
+}
+//#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) {
+	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(() => {
+		const opts = toValue(options);
+		if (opts instanceof SpringConfig) return opts;
+		return new SpringConfig(opts ?? defaultOptions);
+	});
+	const spring = system.createSpring(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.isResting;
+			},
+			set() {}
+		};
+	});
+	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.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;
+}
+/** @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.isResting;
+			},
+			set() {}
+		};
+	});
+	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.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, 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", "config"]
+});
+//#endregion
+export { SpringValue, provideSpringSystem, useSpring, useSpring2D, useSpringSystem };

package/package.json

@@ -1,47 +1,66 @@
 {
   "name": "coily",
-  "version": "0.10.1",
+  "version": "0.12.0",
   "description": "Simulate values using spring physics",
-  "author": "Tim Morris <timthewebguy@gmail.com>",
   "homepage": "https://github.com/tkofh/coily#readme",
+  "bugs": {
+    "url": "https://github.com/tkofh/coily/issues"
+  },
   "license": "MIT",
-  "sideEffects": false,
-  "type": "module",
-  "module": "./dist/api.mjs",
-  "types": "./dist/api.d.mts",
-  "exports": {
-    ".": {
-      "import": "./dist/api.mjs",
-      "types": "./dist/api.d.mts"
-    },
-    "./loop": {
-      "import": "./dist/loop.mjs",
-      "types": "./dist/loop.d.mts"
-    }
+  "author": "Tim Morris <timthewebguy@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tkofh/coily.git"
   },
   "files": [
     "dist"
   ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.js",
+    "./nuxt": "./dist/nuxt.js",
+    "./vue": "./dist/vue.js",
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
     "access": "public"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/tkofh/coily.git"
+  "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",
+    "vitest-browser-vue": "^2.1.0",
+    "vue": "^3.5.30"
   },
-  "bugs": {
-    "url": "https://github.com/tkofh/coily/issues"
+  "peerDependencies": {
+    "@nuxt/kit": "^4.0.0",
+    "vue": "^3.4.0"
   },
-  "devDependencies": {
-    "unbuild": "^2.0.0",
-    "vitest": "^2.1.4",
-    "@repo/tsconfig": "0.0.0"
+  "peerDependenciesMeta": {
+    "vue": {
+      "optional": true
+    },
+    "@nuxt/kit": {
+      "optional": true
+    }
   },
-  "dependencies": {
-    "tickloop": "^0.5.0"
+  "engines": {
+    "node": ">=24.10.0"
   },
   "scripts": {
-    "build": "unbuild",
-    "test": "vitest run"
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "bench": "vitest bench --run",
+    "bench:baseline": "vitest bench --run --outputJson bench-baseline.json",
+    "bench:compare": "vitest bench --run --compare bench-baseline.json"
   }
 }

package/dist/api.d.mts

@@ -1,110 +0,0 @@
-interface SolverOptions {
-    mass: number;
-    tension: number;
-    damping: number;
-    position: number;
-    velocity: number;
-    precision: number;
-}
-declare class Solver {
-    #private;
-    constructor(options: SolverOptions);
-    get mass(): number;
-    set mass(value: number);
-    get tension(): number;
-    set tension(value: number);
-    get damping(): number;
-    set damping(value: number);
-    get position(): number;
-    set position(value: number);
-    get velocity(): number;
-    set velocity(value: number);
-    get precision(): number;
-    set precision(value: number);
-    get resting(): boolean;
-    get naturalFrequency(): number;
-    get criticalDamping(): number;
-    get dampingRatio(): number;
-    tick(dt: number, emit?: boolean): void;
-    onUpdate(callback: () => void): () => void;
-    onStart(callback: () => void): () => void;
-    onStop(callback: () => void): () => void;
-}
-
-declare class Scheduler {
-    #private;
-    tick(delta: number): void;
-    add(solver: Solver): void;
-    remove(solver: Solver): void;
-    has(solver: Solver): boolean;
-}
-
-interface SpringOptions {
-    /**
-     * The mass of the spring
-     *
-     * must be greater than 0
-     */
-    mass: number;
-    /**
-     * The tension of the spring
-     *
-     * must be greater than 0
-     */
-    tension: number;
-    /**
-     * The damping of the spring
-     *
-     * must be greater than or equal to 0
-     */
-    damping: number;
-    /**
-     * The target of the spring
-     *
-     * defaults to 0
-     */
-    target?: number;
-    /**
-     * The current value of the spring
-     *
-     * defaults to the target
-     */
-    value?: number;
-    /**
-     * The precision of the solver
-     *
-     * defaults to 2
-     */
-    precision?: number;
-}
-declare class Spring {
-    #private;
-    constructor(scheduler: Scheduler, options: SpringOptions);
-    get target(): number;
-    set target(value: number);
-    get value(): number;
-    set value(value: number);
-    get velocity(): number;
-    set velocity(value: number);
-    get mass(): number;
-    set mass(value: number);
-    get tension(): number;
-    set tension(value: number);
-    get damping(): number;
-    set damping(value: number);
-    get precision(): number;
-    set precision(value: number);
-    get resting(): boolean;
-    onUpdate(callback: () => void): () => void;
-    onStart(callback: () => void): () => void;
-    onStop(callback: () => void): () => void;
-    jumpTo(value: number): void;
-}
-
-interface SpringSystem {
-    createSpring(options: SpringOptions): Spring;
-    tick(dt: number): void;
-}
-declare function createSpringSystem(): SpringSystem;
-
-export { Spring, type SpringSystem, createSpringSystem };

package/dist/api.d.ts

@@ -1,110 +0,0 @@
-interface SolverOptions {
-    mass: number;
-    tension: number;
-    damping: number;
-    position: number;
-    velocity: number;
-    precision: number;
-}
-declare class Solver {
-    #private;
-    constructor(options: SolverOptions);
-    get mass(): number;
-    set mass(value: number);
-    get tension(): number;
-    set tension(value: number);
-    get damping(): number;
-    set damping(value: number);
-    get position(): number;
-    set position(value: number);
-    get velocity(): number;
-    set velocity(value: number);
-    get precision(): number;
-    set precision(value: number);
-    get resting(): boolean;
-    get naturalFrequency(): number;
-    get criticalDamping(): number;
-    get dampingRatio(): number;
-    tick(dt: number, emit?: boolean): void;
-    onUpdate(callback: () => void): () => void;
-    onStart(callback: () => void): () => void;
-    onStop(callback: () => void): () => void;
-}
-
-declare class Scheduler {
-    #private;
-    tick(delta: number): void;
-    add(solver: Solver): void;
-    remove(solver: Solver): void;
-    has(solver: Solver): boolean;
-}
-
-interface SpringOptions {
-    /**
-     * The mass of the spring
-     *
-     * must be greater than 0
-     */
-    mass: number;
-    /**
-     * The tension of the spring
-     *
-     * must be greater than 0
-     */
-    tension: number;
-    /**
-     * The damping of the spring
-     *
-     * must be greater than or equal to 0
-     */
-    damping: number;
-    /**
-     * The target of the spring
-     *
-     * defaults to 0
-     */
-    target?: number;
-    /**
-     * The current value of the spring
-     *
-     * defaults to the target
-     */
-    value?: number;
-    /**
-     * The precision of the solver
-     *
-     * defaults to 2
-     */
-    precision?: number;
-}
-declare class Spring {
-    #private;
-    constructor(scheduler: Scheduler, options: SpringOptions);
-    get target(): number;
-    set target(value: number);
-    get value(): number;
-    set value(value: number);
-    get velocity(): number;
-    set velocity(value: number);
-    get mass(): number;
-    set mass(value: number);
-    get tension(): number;
-    set tension(value: number);
-    get damping(): number;
-    set damping(value: number);
-    get precision(): number;
-    set precision(value: number);
-    get resting(): boolean;
-    onUpdate(callback: () => void): () => void;
-    onStart(callback: () => void): () => void;
-    onStop(callback: () => void): () => void;
-    jumpTo(value: number): void;
-}
-
-interface SpringSystem {
-    createSpring(options: SpringOptions): Spring;
-    tick(dt: number): void;
-}
-declare function createSpringSystem(): SpringSystem;
-
-export { Spring, type SpringSystem, createSpringSystem };