coily 0.10.1 → 0.11.0

package/dist/api.mjs

@@ -1,460 +0,0 @@
-class Scheduler {
-  #solvers = /* @__PURE__ */ new Set();
-  tick(delta) {
-    for (const solver of this.#solvers.values()) {
-      solver.tick(delta);
-      if (solver.resting) {
-        this.#solvers.delete(solver);
-      }
-    }
-  }
-  add(solver) {
-    this.#solvers.add(solver);
-  }
-  remove(solver) {
-    this.#solvers.delete(solver);
-  }
-  has(solver) {
-    return this.#solvers.has(solver);
-  }
-}
-
-class Emitter {
-  #handlers = /* @__PURE__ */ new Map();
-  on(type, handler) {
-    const handlers = this.#handlers.get(type);
-    if (handlers) {
-      handlers.push(handler);
-    } else {
-      this.#handlers.set(type, [handler]);
-    }
-    return () => {
-      this.off(type, handler);
-    };
-  }
-  off(type, handler) {
-    const handlers = this.#handlers.get(type);
-    if (handlers) {
-      if (handler) {
-        handlers.splice(handlers.indexOf(handler) >>> 0, 1);
-      } else {
-        this.#handlers.set(type, []);
-      }
-    }
-  }
-  emit(type, evt) {
-    const handlers = this.#handlers?.get(type);
-    if (handlers) {
-      handlers.slice().map((handler) => {
-        handler(evt);
-      });
-    }
-  }
-}
-
-function invariant(condition, message) {
-  if (condition) {
-    return;
-  }
-  throw new Error(message ?? "Invariant Failed");
-}
-function roundTo(value, precision) {
-  const p = 10 ** precision;
-  return Math.round(value * p) / p;
-}
-
-class State {
-  #precision;
-  #restingMagnitude;
-  #position;
-  #velocity;
-  constructor(position, velocity, precision) {
-    this.#precision = precision;
-    this.#restingMagnitude = 1 / 10 ** this.#precision;
-    this.#position = roundTo(position, this.#precision);
-    this.#velocity = roundTo(velocity, this.#precision);
-  }
-  get position() {
-    return this.#position;
-  }
-  set position(value) {
-    this.#position = roundTo(value, this.#precision);
-  }
-  get velocity() {
-    return this.#velocity;
-  }
-  set velocity(value) {
-    this.#velocity = roundTo(value, this.#precision);
-  }
-  get precision() {
-    return this.#precision;
-  }
-  set precision(value) {
-    this.#precision = value;
-    this.#restingMagnitude = 1 / 10 ** this.#precision;
-    this.#position = roundTo(this.#position, this.#precision);
-    this.#velocity = roundTo(this.#velocity, this.#precision);
-  }
-  get resting() {
-    return Math.abs(this.#velocity) < this.#restingMagnitude && Math.abs(this.#position) < this.#restingMagnitude;
-  }
-}
-
-class Solver {
-  #mass;
-  #tension;
-  #damping;
-  #state;
-  #underdampedSolver = null;
-  #criticallyDampedSolver = null;
-  #overdampedSolver = null;
-  #currentSolver;
-  #needsUpdate = false;
-  #needsReset = false;
-  #emitter;
-  constructor(options) {
-    this.#mass = options.mass;
-    this.#tension = options.tension;
-    this.#damping = options.damping;
-    this.#state = new State(
-      options.position,
-      options.velocity,
-      options.precision
-    );
-    this.#emitter = new Emitter();
-    this.#updateSolver();
-  }
-  get mass() {
-    return this.#mass;
-  }
-  set mass(value) {
-    this.#mass = value;
-    this.#needsUpdate = true;
-  }
-  get tension() {
-    return this.#tension;
-  }
-  set tension(value) {
-    this.#tension = value;
-    this.#needsUpdate = true;
-  }
-  get damping() {
-    return this.#damping;
-  }
-  set damping(value) {
-    this.#damping = value;
-    this.#needsUpdate = true;
-  }
-  get position() {
-    return this.#state.position;
-  }
-  set position(value) {
-    this.#state.position = value;
-    this.#needsReset = true;
-    if (!this.#state.resting) {
-      this.#emitter.emit("start");
-    }
-  }
-  get velocity() {
-    return this.#state.velocity;
-  }
-  set velocity(value) {
-    this.#state.velocity = value;
-    this.#needsReset = true;
-  }
-  get precision() {
-    return this.#state.precision;
-  }
-  set precision(value) {
-    this.#state.precision = value;
-  }
-  get resting() {
-    return this.#state.resting;
-  }
-  get naturalFrequency() {
-    return Math.sqrt(this.#tension / this.#mass);
-  }
-  get criticalDamping() {
-    return 2 * this.#mass * this.naturalFrequency;
-  }
-  get dampingRatio() {
-    return this.#damping / this.criticalDamping;
-  }
-  tick(dt, emit = true) {
-    if (this.#needsUpdate) {
-      this.#updateSolver();
-      this.#needsUpdate = false;
-    }
-    if (this.#needsReset) {
-      this.#currentSolver.reset();
-      this.#needsReset = false;
-    }
-    this.#currentSolver.tick(dt);
-    if (emit) {
-      this.#emitter.emit("update");
-      if (this.#state.resting) {
-        this.#emitter.emit("stop");
-      }
-    }
-  }
-  onUpdate(callback) {
-    return this.#emitter.on("update", callback);
-  }
-  onStart(callback) {
-    return this.#emitter.on("start", callback);
-  }
-  onStop(callback) {
-    return this.#emitter.on("stop", callback);
-  }
-  #updateSolver() {
-    if (this.dampingRatio < 1) {
-      this.#underdampedSolver ||= new UnderdampedSolver(this, this.#state);
-      this.#currentSolver = this.#underdampedSolver;
-    } else if (this.dampingRatio === 1) {
-      this.#criticallyDampedSolver ||= new CriticallyDampedSolver(
-        this,
-        this.#state
-      );
-      this.#currentSolver = this.#criticallyDampedSolver;
-    } else {
-      this.#overdampedSolver ||= new OverdampedSolver(this, this.#state);
-      this.#currentSolver = this.#overdampedSolver;
-    }
-  }
-}
-class UnderdampedSolver {
-  #solver;
-  #state;
-  #dampedFrequency;
-  #t = 0;
-  #c1 = 0;
-  #c2 = 0;
-  constructor(solver, state) {
-    this.#solver = solver;
-    this.#state = state;
-    this.reset();
-  }
-  reset() {
-    this.#dampedFrequency = this.#solver.naturalFrequency * Math.sqrt(1 - this.#solver.dampingRatio ** 2);
-    this.#t = 0;
-    this.#c1 = this.#state.position;
-    this.#c2 = (this.#state.velocity + this.#solver.dampingRatio * this.#solver.naturalFrequency * this.#state.position) / this.#dampedFrequency;
-    this.tick(0);
-  }
-  tick(dt) {
-    this.#t += dt;
-    const sin = Math.sin(this.#dampedFrequency * this.#t);
-    const cos = Math.cos(this.#dampedFrequency * this.#t);
-    const decay = Math.exp(
-      -this.#solver.dampingRatio * this.#solver.naturalFrequency * this.#t
-    );
-    const decayVelocity = -this.#solver.dampingRatio * this.#solver.naturalFrequency * decay;
-    const oscillation = this.#c1 * cos + this.#c2 * sin;
-    const oscillationVelocity = -this.#c1 * this.#dampedFrequency * sin + this.#c2 * this.#dampedFrequency * cos;
-    this.#state.position = decay * oscillation;
-    this.#state.velocity = decay * oscillationVelocity + decayVelocity * oscillation;
-  }
-}
-class CriticallyDampedSolver {
-  #solver;
-  #state;
-  #t = 0;
-  #c1 = 0;
-  #c2 = 0;
-  constructor(solver, state) {
-    this.#solver = solver;
-    this.#state = state;
-    this.reset();
-  }
-  reset() {
-    this.#t = 0;
-    this.#c1 = this.#state.position;
-    this.#c2 = this.#state.velocity + this.#solver.naturalFrequency * this.#state.position;
-    this.tick(0);
-  }
-  tick(dt) {
-    this.#t += dt;
-    const decay = Math.exp(-this.#solver.naturalFrequency * this.#t);
-    const decayVelocity = -this.#solver.naturalFrequency * decay;
-    const scale = this.#c1 + this.#c2 * this.#t;
-    const scaleVelocity = this.#c2;
-    this.#state.position = scale * decay;
-    this.#state.velocity = scaleVelocity * decay + decayVelocity * scale;
-  }
-}
-class OverdampedSolver {
-  #solver;
-  #state;
-  #dampedFrequency;
-  #t = 0;
-  #c1 = 0;
-  #c2 = 0;
-  constructor(solver, state) {
-    this.#solver = solver;
-    this.#state = state;
-    this.reset();
-  }
-  reset() {
-    this.#dampedFrequency = this.#solver.naturalFrequency * Math.sqrt(this.#solver.dampingRatio ** 2 - 1);
-    this.#t = 0;
-    this.#c1 = this.#state.velocity + this.#solver.dampingRatio * this.#solver.naturalFrequency * this.#state.position;
-    this.#c2 = this.#state.position * this.#dampedFrequency;
-  }
-  tick(dt) {
-    this.#t += dt;
-    const decay = Math.exp(
-      -this.#solver.dampingRatio * this.#solver.naturalFrequency * this.#t
-    );
-    const decayVelocity = -this.#solver.dampingRatio * this.#solver.naturalFrequency * decay;
-    const clamped = Math.min(this.#dampedFrequency * this.#t, 300);
-    const sinh = Math.sinh(clamped);
-    const cosh = Math.cosh(clamped);
-    const scale = this.#c1 * sinh + this.#c2 * cosh;
-    const scaleVelocity = -this.#c1 * this.#dampedFrequency * sinh + this.#c2 * this.#dampedFrequency * cosh;
-    this.#state.position = scale * decay / this.#dampedFrequency;
-    this.#state.velocity = (scale * decayVelocity + scaleVelocity * decay) / this.#dampedFrequency;
-  }
-}
-
-class Spring {
-  #target;
-  #solver;
-  #scheduler;
-  constructor(scheduler, options) {
-    invariant(options.mass > 0, "Mass must be greater than 0");
-    invariant(options.tension > 0, "Tension must be greater than 0");
-    invariant(
-      options.damping >= 0,
-      "Damping must be greater than or equal to 0"
-    );
-    invariant(
-      options.precision === void 0 || options.precision > 0,
-      "Precision must be greater than 0"
-    );
-    this.#target = options.target ?? options.value ?? 0;
-    this.#solver = new Solver({
-      mass: options.mass,
-      tension: options.tension,
-      damping: options.damping,
-      position: (options.value ?? this.#target) - this.#target,
-      velocity: 0,
-      precision: options.precision ?? 2
-    });
-    this.#scheduler = scheduler;
-    if (!this.#solver.resting) {
-      this.#scheduler.add(this.#solver);
-    }
-  }
-  get target() {
-    return this.#target;
-  }
-  set target(value) {
-    if (value !== this.#target) {
-      if (!this.#scheduler.has(this.#solver)) {
-        this.#scheduler.add(this.#solver);
-      }
-      const currentValue = this.value;
-      this.#target = value;
-      this.#solver.position = currentValue - this.#target;
-      this.#solver.tick(0);
-    }
-  }
-  get value() {
-    return this.#target + this.#solver.position;
-  }
-  set value(value) {
-    const position = value - this.#target;
-    if (position !== this.#solver.position) {
-      if (!this.#scheduler.has(this.#solver)) {
-        this.#scheduler.add(this.#solver);
-      }
-      this.#solver.position = position;
-      this.#solver.tick(0);
-    }
-  }
-  get velocity() {
-    return this.#solver.velocity;
-  }
-  set velocity(value) {
-    if (!this.#scheduler.has(this.#solver)) {
-      this.#scheduler.add(this.#solver);
-    }
-    this.#solver.velocity = value;
-  }
-  get mass() {
-    return this.#solver.mass;
-  }
-  set mass(value) {
-    invariant(value > 0, "Mass must be greater than 0");
-    if (!this.#scheduler.has(this.#solver)) {
-      this.#scheduler.add(this.#solver);
-    }
-    this.#solver.mass = value;
-  }
-  get tension() {
-    return this.#solver.tension;
-  }
-  set tension(value) {
-    invariant(value > 0, "Tension must be greater than 0");
-    if (!this.#scheduler.has(this.#solver)) {
-      this.#scheduler.add(this.#solver);
-    }
-    this.#solver.tension = value;
-  }
-  get damping() {
-    return this.#solver.damping;
-  }
-  set damping(value) {
-    invariant(value >= 0, "Damping must be greater than or equal to 0");
-    if (!this.#scheduler.has(this.#solver)) {
-      this.#scheduler.add(this.#solver);
-    }
-    this.#solver.damping = value;
-  }
-  get precision() {
-    return this.#solver.precision;
-  }
-  set precision(value) {
-    invariant(value > 0, "Precision must be greater than 0");
-    if (!this.#scheduler.has(this.#solver)) {
-      this.#scheduler.add(this.#solver);
-    }
-    this.#solver.precision = value;
-  }
-  get resting() {
-    return this.#solver.resting;
-  }
-  onUpdate(callback) {
-    return this.#solver.onUpdate(callback);
-  }
-  onStart(callback) {
-    return this.#solver.onStart(callback);
-  }
-  onStop(callback) {
-    return this.#solver.onStop(callback);
-  }
-  jumpTo(value) {
-    this.#target = value;
-    this.#solver.position = 0;
-    this.#solver.velocity = 0;
-    this.#solver.tick(0);
-  }
-}
-
-class SpringSystemImpl {
-  #scheduler;
-  constructor() {
-    this.#scheduler = new Scheduler();
-  }
-  createSpring(options) {
-    return new Spring(this.#scheduler, options);
-  }
-  tick(dt) {
-    this.#scheduler.tick(dt);
-  }
-}
-function createSpringSystem() {
-  return new SpringSystemImpl();
-}
-
-export { createSpringSystem };

package/dist/loop.d.mts

@@ -1,5 +0,0 @@
-import { SpringSystem } from './api.mjs';
-
-declare function start(system: SpringSystem): () => void;
-
-export { start };

package/dist/loop.d.ts

@@ -1,5 +0,0 @@
-import { SpringSystem } from './api.js';
-
-declare function start(system: SpringSystem): () => void;
-
-export { start };

package/dist/loop.mjs

@@ -1,14 +0,0 @@
-import { createTicker } from 'tickloop';
-
-function start(system) {
-  const ticker = createTicker();
-  ticker.start();
-  ticker.add((_, delta) => {
-    system.tick(delta / 1e3);
-  });
-  return () => {
-    ticker.stop();
-  };
-}
-
-export { start };