@thi.ng/timestep 0.5.8 → 0.5.9

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:04Z
+- **Last updated**: 2023-12-11T10:07:09Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/README.md

@@ -158,7 +158,7 @@ For Node.js REPL:
 const timestep = await import("@thi.ng/timestep");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 973 bytes
+Package sizes (brotli'd, pre-treeshake): ESM: 1.03 KB
 
 ## Dependencies
 

package/api.js

@@ -1,10 +1,6 @@
-/**
- * Event ID for {@link TimeStep.addListener} to be notified of calls to
- * {@link TimeStep.update} (triggered at the very end of a frame update).
- */
-export const EVENT_FRAME = "frame";
-/**
- * Event ID for {@link TimeStep.addListener} to be notified of individual
- * {@link ITimeStep.integrate} iterations.
- */
-export const EVENT_SUBFRAME = "subframe";
+const EVENT_FRAME = "frame";
+const EVENT_SUBFRAME = "subframe";
+export {
+  EVENT_FRAME,
+  EVENT_SUBFRAME
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/timestep",
-  "version": "0.5.8",
+  "version": "0.5.9",
   "description": "Deterministic fixed timestep simulation updates with state interpolation",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,12 +35,13 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/math": "^5.7.6",
-    "@thi.ng/vectors": "^7.8.8"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/math": "^5.7.7",
+    "@thi.ng/vectors": "^7.8.9"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -89,5 +92,5 @@
     "status": "alpha",
     "year": 2023
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }

package/state.js

@@ -1,117 +1,81 @@
 import { mix } from "@thi.ng/math/mix";
 import { mixN2, mixN3, mixN4 } from "@thi.ng/vectors/mixn";
 import { set2, set3, set4 } from "@thi.ng/vectors/set";
-export class NumericState {
-    value;
-    update;
-    curr;
-    prev;
-    constructor(value, update) {
-        this.value = value;
-        this.update = update;
-        this.reset(value);
-    }
-    deref() {
-        return this.value;
-    }
-    /**
-     * Sets {@link NumericState.prev}, {@link NumericState.curr} and
-     * {@link NumericState.value} to given new value.
-     *
-     * @param value
-     */
-    reset(value) {
-        this.prev = this.curr = this.value = value;
-    }
-    integrate(dt, ctx) {
-        this.prev = this.curr;
-        this.curr = this.update(this.curr, dt, ctx);
-    }
-    interpolate(alpha, _) {
-        this.value = mix(this.prev, this.curr, alpha);
-    }
+class NumericState {
+  constructor(value, update) {
+    this.value = value;
+    this.update = update;
+    this.reset(value);
+  }
+  curr;
+  prev;
+  deref() {
+    return this.value;
+  }
+  /**
+   * Sets {@link NumericState.prev}, {@link NumericState.curr} and
+   * {@link NumericState.value} to given new value.
+   *
+   * @param value
+   */
+  reset(value) {
+    this.prev = this.curr = this.value = value;
+  }
+  integrate(dt, ctx) {
+    this.prev = this.curr;
+    this.curr = this.update(this.curr, dt, ctx);
+  }
+  interpolate(alpha, _) {
+    this.value = mix(this.prev, this.curr, alpha);
+  }
 }
-export class VectorState {
-    value;
-    update;
-    prev;
-    curr;
-    setFn;
-    mixFn;
-    constructor(api, value, update) {
-        this.value = value;
-        this.update = update;
-        this.setFn = api.set;
-        this.mixFn = api.mixN;
-        this.prev = this.setFn([], value);
-        this.curr = this.setFn([], value);
-    }
-    deref() {
-        return this.value;
-    }
-    /**
-     * Copies given vector to {@link VectorState.prev}, {@link VectorState.curr}
-     * and {@link VectorState.value}.
-     *
-     * @param value
-     */
-    reset(value) {
-        const set = this.setFn;
-        set(this.prev, value);
-        set(this.curr, value);
-        set(this.value, value);
-    }
-    integrate(dt, ctx) {
-        this.setFn(this.prev, this.curr);
-        this.update(this.curr, dt, ctx);
-    }
-    interpolate(alpha) {
-        this.mixFn(this.value, this.prev, this.curr, alpha);
-    }
+class VectorState {
+  constructor(api, value, update) {
+    this.value = value;
+    this.update = update;
+    this.setFn = api.set;
+    this.mixFn = api.mixN;
+    this.prev = this.setFn([], value);
+    this.curr = this.setFn([], value);
+  }
+  prev;
+  curr;
+  setFn;
+  mixFn;
+  deref() {
+    return this.value;
+  }
+  /**
+   * Copies given vector to {@link VectorState.prev}, {@link VectorState.curr}
+   * and {@link VectorState.value}.
+   *
+   * @param value
+   */
+  reset(value) {
+    const set = this.setFn;
+    set(this.prev, value);
+    set(this.curr, value);
+    set(this.value, value);
+  }
+  integrate(dt, ctx) {
+    this.setFn(this.prev, this.curr);
+    this.update(this.curr, dt, ctx);
+  }
+  interpolate(alpha) {
+    this.mixFn(this.value, this.prev, this.curr, alpha);
+  }
 }
-/**
- * Returns a new {@link NumericState} wrapper for given value `x` and its update
- * function for use with {@link TimeStep.update}.
- *
- * @param x
- * @param update
- */
-export const defNumeric = (x, update) => new NumericState(x, update);
-/**
- * Returns a new {@link VectorState} wrapper for given vector `v` (arbitrary
- * length) and its update function for use with {@link TimeStep.update}. The
- * `api` object is used to provide dedicated vector ops used internally.
- *
- * @remarks
- * **IMPORTANT:** The `update` function MUST update the vector received as 1st
- * arg (which is {@link VectorState.curr}).
- *
- * Also see {@link defVector2}, {@link defVector3}, {@link defVector4} for
- * pre-configured versions.
- *
- * @param api
- * @param v
- * @param update
- */
-export const defVector = (api, v, update) => new VectorState(api, v, update);
-/**
- * 2D optimized version of {@link defVector}.
- *
- * @param v
- * @param update
- */
-export const defVector2 = (v, update) => new VectorState({ set: set2, mixN: mixN2 }, v, update);
-/**
- * 3D optimized version of {@link defVector}.
- *
- * @param v
- * @param update
- */
-export const defVector3 = (v, update) => new VectorState({ set: set3, mixN: mixN3 }, v, update);
-/**
- * 4D optimized version of {@link defVector}.
- *
- * @param v
- * @param update
- */
-export const defVector4 = (v, update) => new VectorState({ set: set4, mixN: mixN4 }, v, update);
+const defNumeric = (x, update) => new NumericState(x, update);
+const defVector = (api, v, update) => new VectorState(api, v, update);
+const defVector2 = (v, update) => new VectorState({ set: set2, mixN: mixN2 }, v, update);
+const defVector3 = (v, update) => new VectorState({ set: set3, mixN: mixN3 }, v, update);
+const defVector4 = (v, update) => new VectorState({ set: set4, mixN: mixN4 }, v, update);
+export {
+  NumericState,
+  VectorState,
+  defNumeric,
+  defVector,
+  defVector2,
+  defVector3,
+  defVector4
+};

package/timestep.js

@@ -1,109 +1,118 @@
-import { __decorate } from "tslib";
-import { INotifyMixin, } from "@thi.ng/api";
-import { EVENT_FRAME, EVENT_SUBFRAME, } from "./api.js";
-let TimeStep = class TimeStep {
-    start;
-    dt;
-    maxFrameTime;
-    scale;
-    t = 0;
-    current = 0;
-    accumulator = 0;
-    frame = 0;
-    updates = 0;
-    __eventFrame;
-    __eventSubFrame;
-    constructor(opts) {
-        const $opts = {
-            dt: 1 / 60,
-            maxFrameTime: 1 / 4,
-            startTime: 0,
-            scale: 1e-3,
-            ...opts,
-        };
-        this.dt = $opts.dt;
-        this.maxFrameTime = $opts.maxFrameTime;
-        this.scale = $opts.scale;
-        this.start = $opts.startTime * this.scale;
-        this.__eventFrame = Object.freeze({ id: EVENT_FRAME, target: this });
-        this.__eventSubFrame = Object.freeze({
-            id: EVENT_SUBFRAME,
-            target: this,
-        });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import {
+  INotifyMixin
+} from "@thi.ng/api";
+import {
+  EVENT_FRAME,
+  EVENT_SUBFRAME
+} from "./api.js";
+let TimeStep = class {
+  start;
+  dt;
+  maxFrameTime;
+  scale;
+  t = 0;
+  current = 0;
+  accumulator = 0;
+  frame = 0;
+  updates = 0;
+  __eventFrame;
+  __eventSubFrame;
+  constructor(opts) {
+    const $opts = {
+      dt: 1 / 60,
+      maxFrameTime: 1 / 4,
+      startTime: 0,
+      scale: 1e-3,
+      ...opts
+    };
+    this.dt = $opts.dt;
+    this.maxFrameTime = $opts.maxFrameTime;
+    this.scale = $opts.scale;
+    this.start = $opts.startTime * this.scale;
+    this.__eventFrame = Object.freeze({ id: EVENT_FRAME, target: this });
+    this.__eventSubFrame = Object.freeze({
+      id: EVENT_SUBFRAME,
+      target: this
+    });
+  }
+  // @ts-ignore mixin
+  // prettier-ignore
+  addListener(id, fn, scope) {
+  }
+  // @ts-ignore mixin
+  // prettier-ignore
+  removeListener(id, fn, scope) {
+  }
+  // @ts-ignore mixin
+  notify(event) {
+  }
+  /**
+   * Updates internal time to given new time `now` (given value will be scaled
+   * via {@link TimeStepOpts.scale}) and performs the required number of fixed
+   * timesteps to integrate and interpolate the given `state` values.
+   *
+   * @remarks
+   * If the scaled time difference since the last step is greater than
+   * {@link TimeStepOpts.maxFrameTime}, it will be limited to the latter.
+   *
+   * If `interpolate` is false, the {@link ITimeStep.interpolate} phase of the
+   * update cycle is skipped. This is useful when using this setup to simulate
+   * sub-steps (e.g. in XPBD) and only requiring the interpolation stage for
+   * the last step.
+   *
+   * @param now
+   * @param items
+   * @param interpolate
+   */
+  update(now, items, interpolate = true) {
+    now = now * this.scale - this.start;
+    this.accumulator += Math.min(now - this.current, this.maxFrameTime);
+    this.current = now;
+    const n = items.length;
+    const dt = this.dt;
+    while (this.accumulator >= dt) {
+      for (let i = 0; i < n; i++)
+        items[i].integrate(dt, this);
+      this.t += dt;
+      this.accumulator -= dt;
+      this.updates++;
+      this.notify(this.__eventSubFrame);
     }
-    // @ts-ignore mixin
-    // prettier-ignore
-    addListener(id, fn, scope) { }
-    // @ts-ignore mixin
-    // prettier-ignore
-    removeListener(id, fn, scope) { }
-    // @ts-ignore mixin
-    notify(event) { }
-    /**
-     * Updates internal time to given new time `now` (given value will be scaled
-     * via {@link TimeStepOpts.scale}) and performs the required number of fixed
-     * timesteps to integrate and interpolate the given `state` values.
-     *
-     * @remarks
-     * If the scaled time difference since the last step is greater than
-     * {@link TimeStepOpts.maxFrameTime}, it will be limited to the latter.
-     *
-     * If `interpolate` is false, the {@link ITimeStep.interpolate} phase of the
-     * update cycle is skipped. This is useful when using this setup to simulate
-     * sub-steps (e.g. in XPBD) and only requiring the interpolation stage for
-     * the last step.
-     *
-     * @param now
-     * @param items
-     * @param interpolate
-     */
-    update(now, items, interpolate = true) {
-        now = now * this.scale - this.start;
-        this.accumulator += Math.min(now - this.current, this.maxFrameTime);
-        this.current = now;
-        const n = items.length;
-        const dt = this.dt;
-        while (this.accumulator >= dt) {
-            for (let i = 0; i < n; i++)
-                items[i].integrate(dt, this);
-            this.t += dt;
-            this.accumulator -= dt;
-            this.updates++;
-            this.notify(this.__eventSubFrame);
-        }
-        if (interpolate) {
-            const alpha = this.accumulator / dt;
-            for (let i = 0; i < n; i++)
-                items[i].interpolate(alpha, this);
-        }
-        this.frame++;
-        this.notify(this.__eventFrame);
+    if (interpolate) {
+      const alpha = this.accumulator / dt;
+      for (let i = 0; i < n; i++)
+        items[i].interpolate(alpha, this);
     }
+    this.frame++;
+    this.notify(this.__eventFrame);
+  }
 };
-TimeStep = __decorate([
-    INotifyMixin
+TimeStep = __decorateClass([
+  INotifyMixin
 ], TimeStep);
-export { TimeStep };
-export const defTimeStep = (opts) => new TimeStep(opts);
-/**
- * Calls {@link ITimeStep.integrate} for all given items (in given order).
- *
- * @param dt
- * @param ctx
- * @param items
- */
-export const integrateAll = (dt, ctx, ...items) => {
-    for (let i = 0, n = items.length; i < n; i++)
-        items[i].integrate(dt, ctx);
+const defTimeStep = (opts) => new TimeStep(opts);
+const integrateAll = (dt, ctx, ...items) => {
+  for (let i = 0, n = items.length; i < n; i++)
+    items[i].integrate(dt, ctx);
+};
+const interpolateAll = (alpha, ctx, ...items) => {
+  for (let i = 0, n = items.length; i < n; i++)
+    items[i].interpolate(alpha, ctx);
 };
-/**
- * Calls {@link ITimeStep.interpolate} for all given items (in given order).
- *
- * @param dt
- * @param ctx
- * @param items
- */
-export const interpolateAll = (alpha, ctx, ...items) => {
-    for (let i = 0, n = items.length; i < n; i++)
-        items[i].interpolate(alpha, ctx);
+export {
+  TimeStep,
+  defTimeStep,
+  integrateAll,
+  interpolateAll
 };