coily 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Tim Morris
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,256 @@
+# `coily`
+
+Spring Physics Utilities
+
+## Installation & Setup
+
+`coily` is available on npm and can be installed with your favorite package manager:
+
+```shell
+$ yarn add coily
+# or
+$ npm i coily
+```
+
+Then import the creator from the package in your code:
+
+```typescript
+import { createSpring } from 'coily'
+
+const spring = createSpring(0, { mass: 1, tension: 100, friction: 25 })
+```
+
+## Usage
+
+### Creating a Spring
+
+The `createSpring` function takes the following arguments:
+
+- `initial: number`
+  The initial value of the spring, and its target. All springs start in a resting state, but you can set `spring.target`
+  at any time
+
+- `config: SpringConfig`
+  The configuration for the spring. `SpringConfig` takes the following parameters:
+
+  - `config.mass: number`
+    How massive the spring is. A lower number will allow the spring to speed up and slow down more quickly than a
+    larger number. Larger numbers are more likely to overshoot the `target`
+
+  - `config.tension: number`
+    How much force the spring experiences toward its `target`. A higher value will move the spring more quickly, and
+    allow the spring to potentially overshoot.
+
+  - `config.friction: number`
+    How much dampening the spring experiences against its tension. A higher friction will make sure the spring doesn't
+    move too quickly, and slows down dramatically as it approaches the `target`
+
+- `options: SpringOptions`
+  Additional options for the spring. `SpringOptions` takes the following parameters:
+
+  - `options.restingDistance: number`
+    The minimum difference between the `target` and `value` at which the spring will consider itself "at" the `target`
+
+  - `options.restingVelocity: number`
+    The minimum velocity at which the spring will consider itself "not moving"
+
+  - `options.arrivalBehavior: 'bounce' | 'clamp' | 'none' | number | ((velocity: number) => number)`
+    How the spring's `velocity` behaves when it arrives at its `target` value.
+    `velocity` is expressed in unit/second. Defaults to `none`.
+    - `'bounce'`: multiplies the velocity by -1, bouncing the value back in the direction from which it came
+    - `'clamp'`: multiplies the velocity by 0, instantly stopping the spring at its value
+    - `'none'`: multiplies the velocity by 1, allowing the spring to overshoot as necessary
+    - `number`: multiplies the velocity by the given number
+    - `(velocity: number) => number`: sets the velocity to the result of a function whose only argument is the
+      previous velocity
+
+#### Spring Config Tips
+
+The configuration object above provides a good starting point when picking your config:
+
+```typescript
+createSpring(0, { mass: 1, tension: 100, friction: 25 })
+```
+
+Don't be afraid to make `mass` a decimal, and don't be afraid of large tensions and frictions either. Picking the
+configuration is more of an art than a science.
+
+#### Spring Options
+
+The spring options object is helpful in reducing the amount of computation your springs perform. If the spring was
+allowed to wait until its `velocity` and difference (`value` - `target`) were _at_ zero, it would imperceptibly update
+every frame for a very long time.
+
+The `restingDistance` and `restingVelocity` options help combat this, by telling the spring at what point it should
+consider itself on target and resting. Once the velocity is less than `restingVelocity` and the difference
+between `value` and `target` is less than `restingDistance`, the spring sets its `value` to its `target` and enters
+the `resting` state.
+
+### Working With Springs
+
+#### Reading Information
+
+The spring exposes some readonly information such as its `value`, `state` and `velocity`:
+
+```typescript
+/**
+ * The current value of the spring
+ */
+spring.value
+
+/**
+ * In which state the spring is currently. Will be one of:
+ * - "resting"
+ * - "moving"
+ * - "frozen"
+ */
+spring.state
+
+/**
+ * How fast the spring is currently moving, and in which direction
+ */
+spring.velocity
+```
+
+Additionally, `target` and `config` can be updated whenever:
+
+```typescript
+/**
+ * Get & Set the target of the spring
+ */
+console.log(spring.target)
+spring.target = 10
+
+/**
+ * Get & Set the config of the spring
+ */
+console.log(spring.config)
+spring.config = { mass: 0.1, tension: 500, friction: 5 }
+```
+
+#### Updating
+
+To simulate the spring and update its value, call the `simulate` method and pass in the number of milliseconds since the
+last update:
+
+```typescript
+// Tickloop is a library that exposes a simple requestAnimationFrame based update loop
+import { createTicker } from 'tickloop'
+import { createSpring } from 'coily'
+
+const spring = createSpring(0, { mass: 1, tension: 100, friction: 20 })
+
+const ticker = createTicker()
+ticker.add((_, delta) => {
+  spring.simulate(delta)
+})
+```
+
+#### Freezing
+
+To hold a spring in place (while maintaining its velocity), use the `freeze()` (and `unfreeze()`) methods.
+Calling `freeze()` will set the spring's `state` to `'frozen'`
+
+```typescript
+const spring = createSpring(0, { mass: 1, tension: 100, friction: 20 })
+
+spring.target = 100
+
+console.log(spring.value) // 0
+
+spring.freeze()
+spring.simulate(1000)
+
+console.log(spring.value) // 0
+```
+
+### Creating a Spring System
+
+Manually updating every spring with its `simulate` method would be tedious to say the least. Where possible, prefer
+using a `SpringSystem` to group springs together and provide a single call site for updating each spring:
+
+```typescript
+import { createSpringSystem } from 'coily'
+
+// First, create the system
+const system = createSpringSystem()
+
+// Then, create some springs
+const spring1 = system.createSpring(0, { mass: 1, tension: 100, friction: 20 })
+const spring2 = system.createSpring(0, { mass: 0.25, tension: 50, friction: 10 })
+
+// Simulate all springs at once from the system
+system.simulate(16)
+```
+
+Should a spring become irrelevant for some reason, remember to call the `cleanup` method so that the system stops
+updating it:
+
+```typescript
+import { createSpringSystem } from 'coily'
+
+const system = createSpringSystem()
+
+const spring = system.createSpring(0, { mass: 1, tension: 100, friction: 20 })
+
+// Later
+
+system.cleanup(spring)
+```
+
+### Spring Chains
+
+Sometimes the `target` of one spring should be the `value` of another.
+This can be tedious to set up manually and involves juggling multiple updates per frame to get a good look at the
+current state.
+
+Spring Chains help with this problem by building on the `createSpring` API. You'll still supply an `initial` target,
+a `SpringConfig`, and an optional `SpringOptions`. You'll also pass an array of chain "links" that describe additional
+values in the chain.
+
+The links take one of two forms:
+
+- A fixed, additive offset from the previous value, e.g. `50` will make Spring 2 target Spring 1's current value plus 50.
+- A function with the following signature:
+  ```typescript
+  const link = (
+    previousSpringValue: number,
+    previousSpringTarget: number,
+    currentSpringValue?: number,
+    currentSpringTarget?: number
+  ): number => /* ... */
+  ```
+  The `currentSpringTarget` and `currentSpringValue` will be `undefined` the first time the function is called, as the
+  targets are initialized for all springs.
+
+#### Creating
+
+```typescript
+const chain = createSpringChain(
+  0, // initial
+  [50, 50, (value) => value * 1.25],
+  { mass: 10, tension: 3000, friction: 300 } // config
+)
+```
+
+#### Reading State
+
+Spring Chains have almost the same interface as Springs do.
+
+Instead of a single `value`, they have an array of numbers as their value. The same goes for `targets`, `states`,
+and `velocities`. Each of these arrays are updated _in place_, which means it is safe to grab a reference to the value
+and read from it later.
+
+Additionally, Spring Chains have a singular `state` property which indicates if _any_ of its links are in a `'moving'` state or not.
+
+There is also a singular `target` property which returns the first target in the chain. Setting this will update the springs as well.
+
+```typescript
+chain.values // readonly number[]
+chain.velocities // readonly number[]
+chain.targets // readonly number[]
+chain.states // readonly number[]
+
+chain.target = 10 // get and set the first target
+chain.state // if any children are 'moving', this will be moving. if the chain is frozen, it will be 'frozen'. otherwise, it is 'resting'.
+```

package/dist/index.cjs

@@ -0,0 +1,317 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createSpring: () => createSpring,
+  createSpringChain: () => createSpringChain,
+  createSpringSystem: () => createSpringSystem
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/lib/createSpring.ts
+var import_mitt = __toESM(require("mitt"), 1);
+var getArrivalFunction = (behavior) => {
+  let result;
+  if (typeof behavior === "function") {
+    result = behavior;
+  } else {
+    let scalar;
+    if (typeof behavior === "number") {
+      scalar = behavior;
+    } else if (behavior === "bounce") {
+      scalar = -1;
+    } else if (behavior === "clamp") {
+      scalar = 0;
+    } else if (behavior === "none") {
+      scalar = 1;
+    }
+    result = (velocity) => velocity * scalar;
+  }
+  return result;
+};
+var createSpringImpl = (initial, config, options) => {
+  let state = "resting";
+  let velocity = 0;
+  let target = initial;
+  let value = initial;
+  const restingDistance = Math.max((options == null ? void 0 : options.restingDistance) ?? 1e-4, 0);
+  const restingVelocity = Math.max((options == null ? void 0 : options.restingVelocity) ?? 1e-4, 0);
+  const arrivalFunction = getArrivalFunction((options == null ? void 0 : options.arrivalBehavior) ?? 1);
+  const emitter = (0, import_mitt.default)();
+  const { emit, ...emitterApi } = emitter;
+  const spring = {
+    ...emitterApi,
+    get target() {
+      return target;
+    },
+    set target(val) {
+      target = val;
+      if (Math.abs(value - target) > restingDistance) {
+        state = "moving";
+        emit("update:state", state);
+      }
+    },
+    get value() {
+      return value;
+    },
+    get velocity() {
+      return velocity;
+    },
+    get state() {
+      return state;
+    },
+    get config() {
+      return config;
+    },
+    set config(value2) {
+      config = value2;
+    },
+    freeze: () => {
+      state = "frozen";
+      emit("update:state", state);
+    },
+    unfreeze: () => {
+      state = Math.abs(velocity) > restingVelocity || Math.abs(value - target) > restingDistance ? "moving" : "resting";
+      emit("update:state", state);
+    }
+  };
+  const simulate = (deltaTime) => {
+    if (state === "moving") {
+      const iterations = Math.ceil(deltaTime);
+      for (let n = 0; n < iterations; n++) {
+        const previousDelta = value - target;
+        const springForce = -config.tension * 1e-6 * previousDelta;
+        const dampingForce = -config.friction * 1e-3 * velocity;
+        const acceleration = (springForce + dampingForce) / config.mass;
+        velocity = velocity + acceleration;
+        value = value + velocity;
+        const delta = value - target;
+        const absDelta = Math.abs(delta);
+        if (Math.sign(delta) !== Math.sign(previousDelta)) {
+          velocity = arrivalFunction(velocity * 1e3) * 1e-3;
+          value = target + velocity * (absDelta / (absDelta + Math.abs(previousDelta)));
+        }
+        if (absDelta < restingDistance && Math.abs(velocity) < restingVelocity) {
+          value = target;
+          state = "resting";
+          emit("update:state", state);
+          break;
+        }
+      }
+      emit("update:value", value);
+    }
+  };
+  return [spring, simulate];
+};
+
+// src/lib/createSpringChain.ts
+var import_mitt2 = __toESM(require("mitt"), 1);
+var createSpringChainImpl = (initial, links, config, options) => {
+  const simulateFns = [];
+  const springs = [];
+  const targets = [];
+  const values = [];
+  const velocities = [];
+  const states = [];
+  let currentTarget = initial;
+  let currentLinks = links;
+  let state = "resting";
+  const updateChainState = (target, links2) => {
+    if (springs.length === 0) {
+      const [spring, simulate2] = createSpringImpl(target, config, options);
+      springs.push(spring);
+      simulateFns.push(simulate2);
+      targets.push(spring.target);
+      values.push(spring.value);
+      velocities.push(spring.velocity);
+      states.push(spring.state);
+    } else {
+      springs[0].target = target;
+      targets[0] = target;
+      states[0] = springs[0].state;
+      if (state === "resting" && springs[0].state === "moving") {
+        state = "moving";
+      }
+    }
+    for (const [index, link] of links2.entries()) {
+      const previousSpring = springs[index];
+      if (springs[index + 1]) {
+        const spring = springs[index + 1];
+        if (typeof link === "number") {
+          spring.target = previousSpring.value + link;
+        } else {
+          spring.target = link(previousSpring.value, previousSpring.target, spring.value, spring.target);
+        }
+        targets[index + 1] = spring.target;
+        states[index + 1] = spring.state;
+        if (state === "resting" && spring.state === "moving") {
+          state = "moving";
+        }
+      } else {
+        const [spring, simulate2] = createSpringImpl(typeof link === "number" ? previousSpring.value + link : link(previousSpring.value, previousSpring.target), config, options);
+        springs.push(spring);
+        simulateFns.push(simulate2);
+        targets[index + 1] = spring.target;
+        values[index + 1] = spring.value;
+        velocities[index + 1] = spring.velocity;
+        states[index + 1] = spring.state;
+      }
+    }
+    const cutoff = springs.length + 1;
+    if (springs.length > cutoff) {
+      const deleteCount = springs.length - cutoff;
+      springs.splice(cutoff, deleteCount);
+      simulateFns.splice(cutoff, deleteCount);
+      targets.splice(cutoff, deleteCount);
+      values.splice(cutoff, deleteCount);
+      velocities.splice(cutoff, deleteCount);
+      states.splice(cutoff, deleteCount);
+    }
+  };
+  updateChainState(currentTarget, currentLinks);
+  const emitter = (0, import_mitt2.default)();
+  const { emit, ...emitterApi } = emitter;
+  const simulate = (delta) => {
+    if (state === "moving") {
+      let moving = false;
+      for (let i = 0; i < springs.length; i++) {
+        simulateFns[i](delta);
+        if (i < springs.length - 1) {
+          const link = links[i];
+          springs[i + 1].target = typeof link === "number" ? springs[i].value + link : link(springs[i].value, springs[i].target, springs[i + 1].value);
+        }
+        targets[i] = springs[i].target;
+        values[i] = springs[i].value;
+        velocities[i] = springs[i].velocity;
+        states[i] = springs[i].state;
+        moving = moving || springs[i].state === "moving";
+      }
+      emit("update:value", values);
+      if (!moving) {
+        state = "resting";
+        emit("update:state", state);
+      }
+    }
+  };
+  return [
+    {
+      ...emitterApi,
+      get target() {
+        return targets[0];
+      },
+      set target(val) {
+        currentTarget = val;
+        updateChainState(currentTarget, currentLinks);
+      },
+      get targets() {
+        return targets;
+      },
+      get links() {
+        return links;
+      },
+      set links(val) {
+        currentLinks = val;
+        updateChainState(currentTarget, currentLinks);
+      },
+      get config() {
+        return config;
+      },
+      get values() {
+        return values;
+      },
+      get velocities() {
+        return velocities;
+      },
+      get state() {
+        return state;
+      },
+      get states() {
+        return states;
+      },
+      freeze: () => {
+        for (const spring of springs) {
+          spring.freeze();
+        }
+        state = "frozen";
+        emit("update:state", state);
+      },
+      unfreeze: () => {
+        let moving = false;
+        for (const spring of springs) {
+          spring.unfreeze();
+          moving = moving || spring.state === "moving";
+        }
+        state = moving ? "moving" : "resting";
+        emit("update:state", state);
+      }
+    },
+    simulate
+  ];
+};
+
+// src/createSpring.ts
+var createSpring = (initial, config, options) => {
+  const [spring, simulate] = createSpringImpl(initial, config, options);
+  return Object.assign(spring, { simulate });
+};
+
+// src/createSpringChain.ts
+var createSpringChain = (initial, links, config, options) => {
+  const [chain, simulate] = createSpringChainImpl(initial, links, config, options);
+  return Object.assign(chain, { simulate });
+};
+
+// src/createSpringSystem.ts
+var createSpringSystem = () => {
+  const springs = /* @__PURE__ */ new Map();
+  return {
+    createSpring: (initial, config, options) => {
+      const [spring, simulate] = createSpringImpl(initial, config, options);
+      springs.set(spring, simulate);
+      return spring;
+    },
+    createSpringChain: (initial, links, config, options) => {
+      const [chain, simulate] = createSpringChainImpl(initial, links, config, options);
+      springs.set(chain, simulate);
+      return chain;
+    },
+    cleanup: (spring) => {
+      springs.delete(spring);
+      spring.off("*");
+      spring.off("update:state");
+      spring.off("update:value");
+    },
+    simulate: (delta) => {
+      for (const simulate of springs.values()) {
+        simulate(delta);
+      }
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSpring,
+  createSpringChain,
+  createSpringSystem
+});

package/dist/index.d.ts

@@ -0,0 +1,67 @@
+import { Emitter } from 'mitt';
+
+interface SpringConfig {
+    mass: number;
+    tension: number;
+    friction: number;
+}
+declare type SpringArrivalBehavior = 'bounce' | 'clamp' | 'none' | number | ((velocity: number) => number);
+interface SpringOptions {
+    restingDistance?: number;
+    restingVelocity?: number;
+    arrivalBehavior?: SpringArrivalBehavior;
+}
+declare type SpringState = 'moving' | 'frozen' | 'resting';
+declare type SpringEmitter = Emitter<{
+    'update:value': number;
+    'update:state': SpringState;
+    '*': number | SpringState;
+}>;
+interface Spring extends Omit<SpringEmitter, 'emit'> {
+    target: number;
+    config: Readonly<SpringConfig>;
+    readonly value: number;
+    readonly velocity: number;
+    readonly state: SpringState;
+    readonly freeze: () => void;
+    readonly unfreeze: () => void;
+}
+declare type SimulateFn = (delta: number) => void;
+interface StandaloneSpring extends Spring {
+    readonly simulate: SimulateFn;
+}
+declare type SpringChainLinkGetter = number | ((previousValue: number, previousTarget: number, currentValue?: number, currentTarget?: number) => number);
+declare type SpringChainEmitter = Emitter<{
+    'update:value': number[];
+    'update:state': SpringState;
+    '*': number[] | SpringState;
+}>;
+interface SpringChain extends Omit<SpringChainEmitter, 'emit'> {
+    target: number;
+    links: SpringChainLinkGetter[];
+    config: Readonly<SpringConfig>;
+    readonly targets: ReadonlyArray<number>;
+    readonly values: ReadonlyArray<number>;
+    readonly velocities: ReadonlyArray<number>;
+    readonly state: SpringState;
+    readonly states: ReadonlyArray<SpringState>;
+    readonly freeze: () => void;
+    readonly unfreeze: () => void;
+}
+interface StandaloneSpringChain extends SpringChain {
+    readonly simulate: SimulateFn;
+}
+interface SpringSystem {
+    createSpring: (initial: number, config: SpringConfig, options?: SpringOptions) => Spring;
+    createSpringChain: (initial: number, links: SpringChainLinkGetter[], config: SpringConfig, options?: SpringOptions) => SpringChain;
+    cleanup: (spring: Spring | SpringChain) => void;
+    simulate: SimulateFn;
+}
+
+declare const createSpring: (initial: number, config: SpringConfig, options?: SpringOptions) => StandaloneSpring;
+
+declare const createSpringChain: (initial: number, links: SpringChainLinkGetter[], config: SpringConfig, options?: SpringOptions) => StandaloneSpringChain;
+
+declare const createSpringSystem: () => SpringSystem;
+
+export { SimulateFn, Spring, SpringArrivalBehavior, SpringChain, SpringChainLinkGetter, SpringConfig, SpringOptions, SpringState, SpringSystem, StandaloneSpring, StandaloneSpringChain, createSpring, createSpringChain, createSpringSystem };

package/dist/index.js

@@ -0,0 +1,285 @@
+// src/lib/createSpring.ts
+import mitt from "mitt";
+var getArrivalFunction = (behavior) => {
+  let result;
+  if (typeof behavior === "function") {
+    result = behavior;
+  } else {
+    let scalar;
+    if (typeof behavior === "number") {
+      scalar = behavior;
+    } else if (behavior === "bounce") {
+      scalar = -1;
+    } else if (behavior === "clamp") {
+      scalar = 0;
+    } else if (behavior === "none") {
+      scalar = 1;
+    }
+    result = (velocity) => velocity * scalar;
+  }
+  return result;
+};
+var createSpringImpl = (initial, config, options) => {
+  let state = "resting";
+  let velocity = 0;
+  let target = initial;
+  let value = initial;
+  const restingDistance = Math.max((options == null ? void 0 : options.restingDistance) ?? 1e-4, 0);
+  const restingVelocity = Math.max((options == null ? void 0 : options.restingVelocity) ?? 1e-4, 0);
+  const arrivalFunction = getArrivalFunction((options == null ? void 0 : options.arrivalBehavior) ?? 1);
+  const emitter = mitt();
+  const { emit, ...emitterApi } = emitter;
+  const spring = {
+    ...emitterApi,
+    get target() {
+      return target;
+    },
+    set target(val) {
+      target = val;
+      if (Math.abs(value - target) > restingDistance) {
+        state = "moving";
+        emit("update:state", state);
+      }
+    },
+    get value() {
+      return value;
+    },
+    get velocity() {
+      return velocity;
+    },
+    get state() {
+      return state;
+    },
+    get config() {
+      return config;
+    },
+    set config(value2) {
+      config = value2;
+    },
+    freeze: () => {
+      state = "frozen";
+      emit("update:state", state);
+    },
+    unfreeze: () => {
+      state = Math.abs(velocity) > restingVelocity || Math.abs(value - target) > restingDistance ? "moving" : "resting";
+      emit("update:state", state);
+    }
+  };
+  const simulate = (deltaTime) => {
+    if (state === "moving") {
+      const iterations = Math.ceil(deltaTime);
+      for (let n = 0; n < iterations; n++) {
+        const previousDelta = value - target;
+        const springForce = -config.tension * 1e-6 * previousDelta;
+        const dampingForce = -config.friction * 1e-3 * velocity;
+        const acceleration = (springForce + dampingForce) / config.mass;
+        velocity = velocity + acceleration;
+        value = value + velocity;
+        const delta = value - target;
+        const absDelta = Math.abs(delta);
+        if (Math.sign(delta) !== Math.sign(previousDelta)) {
+          velocity = arrivalFunction(velocity * 1e3) * 1e-3;
+          value = target + velocity * (absDelta / (absDelta + Math.abs(previousDelta)));
+        }
+        if (absDelta < restingDistance && Math.abs(velocity) < restingVelocity) {
+          value = target;
+          state = "resting";
+          emit("update:state", state);
+          break;
+        }
+      }
+      emit("update:value", value);
+    }
+  };
+  return [spring, simulate];
+};
+
+// src/lib/createSpringChain.ts
+import mitt2 from "mitt";
+var createSpringChainImpl = (initial, links, config, options) => {
+  const simulateFns = [];
+  const springs = [];
+  const targets = [];
+  const values = [];
+  const velocities = [];
+  const states = [];
+  let currentTarget = initial;
+  let currentLinks = links;
+  let state = "resting";
+  const updateChainState = (target, links2) => {
+    if (springs.length === 0) {
+      const [spring, simulate2] = createSpringImpl(target, config, options);
+      springs.push(spring);
+      simulateFns.push(simulate2);
+      targets.push(spring.target);
+      values.push(spring.value);
+      velocities.push(spring.velocity);
+      states.push(spring.state);
+    } else {
+      springs[0].target = target;
+      targets[0] = target;
+      states[0] = springs[0].state;
+      if (state === "resting" && springs[0].state === "moving") {
+        state = "moving";
+      }
+    }
+    for (const [index, link] of links2.entries()) {
+      const previousSpring = springs[index];
+      if (springs[index + 1]) {
+        const spring = springs[index + 1];
+        if (typeof link === "number") {
+          spring.target = previousSpring.value + link;
+        } else {
+          spring.target = link(previousSpring.value, previousSpring.target, spring.value, spring.target);
+        }
+        targets[index + 1] = spring.target;
+        states[index + 1] = spring.state;
+        if (state === "resting" && spring.state === "moving") {
+          state = "moving";
+        }
+      } else {
+        const [spring, simulate2] = createSpringImpl(typeof link === "number" ? previousSpring.value + link : link(previousSpring.value, previousSpring.target), config, options);
+        springs.push(spring);
+        simulateFns.push(simulate2);
+        targets[index + 1] = spring.target;
+        values[index + 1] = spring.value;
+        velocities[index + 1] = spring.velocity;
+        states[index + 1] = spring.state;
+      }
+    }
+    const cutoff = springs.length + 1;
+    if (springs.length > cutoff) {
+      const deleteCount = springs.length - cutoff;
+      springs.splice(cutoff, deleteCount);
+      simulateFns.splice(cutoff, deleteCount);
+      targets.splice(cutoff, deleteCount);
+      values.splice(cutoff, deleteCount);
+      velocities.splice(cutoff, deleteCount);
+      states.splice(cutoff, deleteCount);
+    }
+  };
+  updateChainState(currentTarget, currentLinks);
+  const emitter = mitt2();
+  const { emit, ...emitterApi } = emitter;
+  const simulate = (delta) => {
+    if (state === "moving") {
+      let moving = false;
+      for (let i = 0; i < springs.length; i++) {
+        simulateFns[i](delta);
+        if (i < springs.length - 1) {
+          const link = links[i];
+          springs[i + 1].target = typeof link === "number" ? springs[i].value + link : link(springs[i].value, springs[i].target, springs[i + 1].value);
+        }
+        targets[i] = springs[i].target;
+        values[i] = springs[i].value;
+        velocities[i] = springs[i].velocity;
+        states[i] = springs[i].state;
+        moving = moving || springs[i].state === "moving";
+      }
+      emit("update:value", values);
+      if (!moving) {
+        state = "resting";
+        emit("update:state", state);
+      }
+    }
+  };
+  return [
+    {
+      ...emitterApi,
+      get target() {
+        return targets[0];
+      },
+      set target(val) {
+        currentTarget = val;
+        updateChainState(currentTarget, currentLinks);
+      },
+      get targets() {
+        return targets;
+      },
+      get links() {
+        return links;
+      },
+      set links(val) {
+        currentLinks = val;
+        updateChainState(currentTarget, currentLinks);
+      },
+      get config() {
+        return config;
+      },
+      get values() {
+        return values;
+      },
+      get velocities() {
+        return velocities;
+      },
+      get state() {
+        return state;
+      },
+      get states() {
+        return states;
+      },
+      freeze: () => {
+        for (const spring of springs) {
+          spring.freeze();
+        }
+        state = "frozen";
+        emit("update:state", state);
+      },
+      unfreeze: () => {
+        let moving = false;
+        for (const spring of springs) {
+          spring.unfreeze();
+          moving = moving || spring.state === "moving";
+        }
+        state = moving ? "moving" : "resting";
+        emit("update:state", state);
+      }
+    },
+    simulate
+  ];
+};
+
+// src/createSpring.ts
+var createSpring = (initial, config, options) => {
+  const [spring, simulate] = createSpringImpl(initial, config, options);
+  return Object.assign(spring, { simulate });
+};
+
+// src/createSpringChain.ts
+var createSpringChain = (initial, links, config, options) => {
+  const [chain, simulate] = createSpringChainImpl(initial, links, config, options);
+  return Object.assign(chain, { simulate });
+};
+
+// src/createSpringSystem.ts
+var createSpringSystem = () => {
+  const springs = /* @__PURE__ */ new Map();
+  return {
+    createSpring: (initial, config, options) => {
+      const [spring, simulate] = createSpringImpl(initial, config, options);
+      springs.set(spring, simulate);
+      return spring;
+    },
+    createSpringChain: (initial, links, config, options) => {
+      const [chain, simulate] = createSpringChainImpl(initial, links, config, options);
+      springs.set(chain, simulate);
+      return chain;
+    },
+    cleanup: (spring) => {
+      springs.delete(spring);
+      spring.off("*");
+      spring.off("update:state");
+      spring.off("update:value");
+    },
+    simulate: (delta) => {
+      for (const simulate of springs.values()) {
+        simulate(delta);
+      }
+    }
+  };
+};
+export {
+  createSpring,
+  createSpringChain,
+  createSpringSystem
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "coily",
+  "version": "0.1.1",
+  "description": "Simulate values using spring physics",
+  "author": "Tim Morris <timthewebguy@gmail.com>",
+  "homepage": "https://github.com/tkofh/coily#readme",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tkofh/coily.git"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:ui": "vitest --ui",
+    "prepublish": "yarn test && yarn build"
+  },
+  "bugs": {
+    "url": "https://github.com/tkofh/coily/issues"
+  },
+  "devDependencies": {
+    "@vitest/ui": "^0.11.0",
+    "tsup": "^6.1.3",
+    "vitest": "^0.16.0"
+  },
+  "dependencies": {
+    "mitt": "^3.0.0"
+  },
+  "gitHead": "ed6733ca1768b44341f0ed05f8750466089ddbc1"
+}