@msb235/blits 0.3.0 → 0.5.0

package/dist/store.js

@@ -1,22 +1,47 @@
+/** What every store reads before its first write: never written, so always empty. */
+const noWeak = new WeakMap();
+const noStrong = new Map();
 /**
  * Per-subject storage keyed by identity. Objects go in a WeakMap and are forgotten when the host
  * drops them; anything else — a string id, the unit subject of a mix with no subject dimension —
  * goes in a Map that only `drop` and `clear` empty, which is why a host keying by value should
- * call `drop`.
+ * call `drop`. Each map is made when first written, since a mix holds a store per voice and patch;
+ * until then it is a shared empty one, so the field always holds a map.
  */
 export class Store {
-    weak = new WeakMap();
-    strong = new Map();
+    weak = noWeak;
+    strong = noStrong;
+    /**
+     * The first key that is not an object, and its value, held here until a second comes: a voice of
+     * one subject keyed by id would otherwise spend a Map's smallest table on it.
+     */
+    oneKey = none;
+    oneValue = undefined;
     get(key) {
-        return typeof key === 'object' && key !== null
-            ? this.weak.get(key)
-            : this.strong.get(key);
+        if (typeof key === 'object' && key !== null)
+            return this.weak.get(key);
+        return same(this.oneKey, key) ? this.oneValue : this.strong.get(key);
     }
     set(key, value) {
-        if (typeof key === 'object' && key !== null)
+        if (typeof key === 'object' && key !== null) {
+            if (this.weak === noWeak)
+                this.weak = new WeakMap();
             this.weak.set(key, value);
-        else
-            this.strong.set(key, value);
+            return;
+        }
+        if (this.strong === noStrong && (this.oneKey === none || same(this.oneKey, key))) {
+            this.oneKey = key;
+            this.oneValue = value;
+            return;
+        }
+        if (this.strong === noStrong)
+            this.strong = new Map();
+        if (this.oneKey !== none) {
+            this.strong.set(this.oneKey, this.oneValue);
+            this.oneKey = none;
+            this.oneValue = undefined;
+        }
+        this.strong.set(key, value);
     }
     has(key) {
         return this.get(key) !== undefined;
@@ -24,10 +49,20 @@ export class Store {
     delete(key) {
         if (typeof key === 'object' && key !== null)
             this.weak.delete(key);
+        else if (same(this.oneKey, key)) {
+            this.oneKey = none;
+            this.oneValue = undefined;
+        }
         else
             this.strong.delete(key);
     }
     clear() {
+        this.oneKey = none;
+        this.oneValue = undefined;
         this.strong.clear();
     }
 }
+/** No key held inline. */
+const none = Symbol('none');
+/** A Map's key equality, SameValueZero: NaN finds NaN. */
+const same = (a, b) => a === b || Object.is(a, b);

package/dist/strays.d.ts

@@ -0,0 +1,21 @@
+import type { Mixer } from './mixer.js';
+import type { MotionOwner, Motions } from './motion.js';
+import type { Voice } from './voice.js';
+/** Notes a motion patch that may hold state for a subject no voice playing it reaches. */
+export declare function stray<I, O>(mix: Mixer<I, O>, motion: Motions<I>, subject: I): void;
+/** A motion voice left the list: if its patch plays on, its subjects' state there may stray. */
+export declare function unplay<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+/**
+ * What a motion patch asks of the mix playing it, by its voice's id. It holds the mix weakly, so a
+ * patch the host keeps does not keep a mix it has let go of alive; a retired voice's patch no
+ * longer asks.
+ */
+export declare function motionOwner<I, O>(mix: WeakRef<Mixer<I, O>>): MotionOwner;
+/** The voice in the list with this id, which is in id order. */
+export declare function cuedById<I, O>(mix: Mixer<I, O>, id: number): Voice<I, O> | undefined;
+/**
+ * A subject's voice time at the latest frame, where a motion patch places an untimed change and a
+ * `read` with no time; NaN until the voice has started and met the subject, and while the
+ * subject's own time is still short of its stagger. A retired voice's patch no longer asks.
+ */
+export declare function frameOf<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I): number;

package/dist/strays.js

@@ -0,0 +1,84 @@
+import { unpart } from './fade.js';
+/** Notes a motion patch that may hold state for a subject no voice playing it reaches. */
+export function stray(mix, motion, subject) {
+    const list = mix.strays.get(subject);
+    if (list === undefined)
+        mix.strays.set(subject, [motion]);
+    else if (!list.includes(motion))
+        list.push(motion);
+}
+/** A motion voice left the list: if its patch plays on, its subjects' state there may stray. */
+export function unplay(mix, voice) {
+    const motion = voice.motion;
+    if (motion === undefined)
+        return;
+    const left = (mix.playing.get(motion) ?? 1) - 1;
+    if (left <= 0) {
+        mix.playing.delete(motion);
+        mix.strayAll.delete(motion);
+        return;
+    }
+    mix.playing.set(motion, left);
+    if (voice.named === null)
+        mix.strayAll.add(motion);
+    else
+        for (const subject of voice.named)
+            stray(mix, motion, subject);
+}
+/**
+ * What a motion patch asks of the mix playing it, by its voice's id. It holds the mix weakly, so a
+ * patch the host keeps does not keep a mix it has let go of alive; a retired voice's patch no
+ * longer asks.
+ */
+export function motionOwner(mix) {
+    return {
+        frame(id, subject) {
+            const m = mix.deref();
+            const v = m === undefined ? undefined : cuedById(m, id);
+            return m === undefined || v === undefined ? Number.NaN : frameOf(m, v, subject);
+        },
+        revive(id, subject) {
+            const m = mix.deref();
+            if (m === undefined)
+                return;
+            m.stir();
+            const v = cuedById(m, id);
+            if (v === undefined)
+                return;
+            if (v.motion !== undefined && v.named !== null && !v.named.has(subject))
+                stray(m, v.motion, subject);
+            unpart(m, v, subject);
+        },
+    };
+}
+/** The voice in the list with this id, which is in id order. */
+export function cuedById(mix, id) {
+    const cued = mix.cued;
+    let lo = 0;
+    let hi = cued.length - 1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        const v = cued[mid];
+        if (v.id === id)
+            return v;
+        if (v.id < id)
+            lo = mid + 1;
+        else
+            hi = mid - 1;
+    }
+    return undefined;
+}
+/**
+ * A subject's voice time at the latest frame, where a motion patch places an untimed change and a
+ * `read` with no time; NaN until the voice has started and met the subject, and while the
+ * subject's own time is still short of its stagger. A retired voice's patch no longer asks.
+ */
+export function frameOf(mix, voice, subject) {
+    if (Number.isNaN(mix.now) || voice.state === 'pending')
+        return Number.NaN;
+    const held = voice.subjects.get(subject);
+    if (held === undefined || !held.reaches)
+        return Number.NaN;
+    const t = voice.elapsedAt(mix.now) - held.delay;
+    return t < 0 ? Number.NaN : t;
+}

package/dist/tweened.d.ts

@@ -0,0 +1,11 @@
+import type { Curve } from './easing.js';
+/** Turns the velocity `eased` works out on or off. */
+export declare function sloped(on: boolean): void;
+/** How far through a stretch released at `at` and lasting `ms` voice time `t` is, from 0. */
+export declare function progress(t: number, at: number, ms: number): number;
+/** The share of a tween's way left to go at `u`, 0 once it has arrived. */
+export declare function left(ease: Curve, u: number): number;
+/** An axis of a tween from `x0` to `goal` with `share` of the way left. */
+export declare function between(x0: number, goal: number, share: number): number;
+/** A tween's stretch at `u` into `xo` and `vo`: true once it has arrived. */
+export declare function eased(ease: Curve, n: number, u: number, ms: number, x0: ArrayLike<number>, x: number, to: ArrayLike<number>, g: number, xo: Float64Array, vo: Float64Array): boolean;

package/dist/tweened.js

@@ -0,0 +1,48 @@
+/** How far a tween's slope is read either side of `u`, for an easing that is only a function. */
+const SPAN = 1e-4;
+/**
+ * Whether an evaluation wants a tween's velocity, which costs two more reads of its easing. Only
+ * `read` asks for it; a mix and a retarget never use it.
+ */
+let slope = false;
+/** The last tween sample's time, curve and length, and the share of the way it had left to go. */
+const memo = { u: Number.NaN, ease: undefined, left: 0 };
+/** Turns the velocity `eased` works out on or off. */
+export function sloped(on) {
+    slope = on;
+}
+/** How far through a stretch released at `at` and lasting `ms` voice time `t` is, from 0. */
+export function progress(t, at, ms) {
+    return Math.max(0, t - at) / ms;
+}
+/** The share of a tween's way left to go at `u`, 0 once it has arrived. */
+export function left(ease, u) {
+    // Subjects released together share `u`, so a frame reads a bezier once, not once each.
+    if (u !== memo.u || ease !== memo.ease) {
+        memo.u = u;
+        memo.ease = ease;
+        memo.left = u >= 1 ? 0 : 1 - ease(u);
+    }
+    return memo.left;
+}
+/** An axis of a tween from `x0` to `goal` with `share` of the way left. */
+export function between(x0, goal, share) {
+    return share === 0 ? goal : goal + (x0 - goal) * share;
+}
+/** A tween's stretch at `u` into `xo` and `vo`: true once it has arrived. */
+export function eased(ease, n, u, ms, x0, x, to, g, xo, vo) {
+    const share = left(ease, u);
+    let rate = 0;
+    if (slope && u < 1) {
+        const lo = Math.max(0, u - SPAN);
+        const hi = Math.min(1, u + SPAN);
+        rate = ((ease(hi) - ease(lo)) / (hi - lo)) * (1000 / ms);
+    }
+    for (let i = 0; i < n; i++) {
+        const a = x0[x + i];
+        const goal = to[g + i];
+        xo[i] = between(a, goal, share);
+        vo[i] = -(a - goal) * rate;
+    }
+    return share === 0;
+}