@opendaw/studio-adapters 0.0.110 → 0.0.111

package/dist/VaryingTempoMap.d.ts

@@ -1,6 +1,23 @@
-import { bpm, ppqn, seconds, TempoMap } from "@opendaw/lib-dsp";
+import { bpm, ppqn, seconds, TempoMap, ValueEvent } from "@opendaw/lib-dsp";
 import { Observer, Subscription, Terminable } from "@opendaw/lib-std";
 import { TimelineBoxAdapter } from "./timeline/TimelineBoxAdapter";
+/**
+ * Allocation-free cursor that reproduces {@link ValueEvent.valueAt} for monotonically non-decreasing ppqn.
+ * Tracks the current segment and the recurrence coefficients m, q so that a step of exactly
+ * TempoChangeGrid within the same zone can be resolved as v = m * v + q.
+ */
+export declare class TempoGridCursor {
+    #private;
+    /**
+     * Integrates the seconds elapsed across [fromPPQN, toPPQN] by stepping the TempoChangeGrid.
+     */
+    integrate(events: ReadonlyArray<ValueEvent>, fromPPQN: ppqn, toPPQN: ppqn, storageBpm: bpm): seconds;
+    /**
+     * Walks the TempoChangeGrid forward from fromPPQN, accumulating seconds starting at fromSeconds,
+     * until targetSeconds is reached.
+     */
+    advance(events: ReadonlyArray<ValueEvent>, fromPPQN: ppqn, fromSeconds: seconds, targetSeconds: seconds, storageBpm: bpm): ppqn;
+}
 /**
  * TempoMap implementation that handles varying tempo (tempo automation).
  * Steps through at TempoChangeGrid intervals to match BlockRenderer behavior.

package/dist/VaryingTempoMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VaryingTempoMap.d.ts","sourceRoot":"","sources":["../src/VaryingTempoMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,EAAE,IAAI,EAAQ,OAAO,EAAmB,QAAQ,EAAC,MAAM,kBAAkB,CAAA;AACpF,OAAO,EAGH,QAAQ,EAER,YAAY,EACZ,UAAU,EAEb,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,kBAAkB,EAAC,MAAM,+BAA+B,CAAA;AAIhE;;;GAGG;AACH,qBAAa,eAAgB,YAAW,QAAQ,EAAE,UAAU;;gBAM5C,OAAO,EAAE,kBAAkB;IAQvC,SAAS,IAAI,IAAI;IAkCjB,UAAU,CAAC,QAAQ,EAAE,IAAI,GAAG,GAAG;IAQ/B,aAAa,CAAC,QAAQ,EAAE,IAAI,GAAG,OAAO;IAwCtC,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IA6ClC,iBAAiB,CAAC,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAG,OAAO;IAIxD,cAAc,CAAC,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,GAAG,IAAI;IAO9D,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,GAAG,YAAY;CAQxD"}
+{"version":3,"file":"VaryingTempoMap.d.ts","sourceRoot":"","sources":["../src/VaryingTempoMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,EAAE,IAAI,EAAQ,OAAO,EAAmB,QAAQ,EAAE,UAAU,EAAC,MAAM,kBAAkB,CAAA;AAChG,OAAO,EAKH,QAAQ,EAER,YAAY,EACZ,UAAU,EAEb,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,kBAAkB,EAAC,MAAM,+BAA+B,CAAA;AAIhE;;;;GAIG;AACH,qBAAa,eAAe;;IASxB;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,GAAG,OAAO;IAepG;;;OAGG;IACH,OAAO,CAAC,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,EACjC,QAAQ,EAAE,IAAI,EACd,WAAW,EAAE,OAAO,EACpB,aAAa,EAAE,OAAO,EACtB,UAAU,EAAE,GAAG,GAAG,IAAI;CAuFjC;AAED;;;GAGG;AACH,qBAAa,eAAgB,YAAW,QAAQ,EAAE,UAAU;;gBAO5C,OAAO,EAAE,kBAAkB;IAQvC,SAAS,IAAI,IAAI;IA4BjB,UAAU,CAAC,QAAQ,EAAE,IAAI,GAAG,GAAG;IAQ/B,aAAa,CAAC,QAAQ,EAAE,IAAI,GAAG,OAAO;IA+BtC,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IA8BlC,iBAAiB,CAAC,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAG,OAAO;IAIxD,cAAc,CAAC,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,GAAG,IAAI;IAO9D,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,GAAG,YAAY;CAQxD"}

package/dist/VaryingTempoMap.js

@@ -1,17 +1,154 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _VaryingTempoMap_instances, _VaryingTempoMap_terminator, _VaryingTempoMap_adapter, _VaryingTempoMap_ppqnCache, _VaryingTempoMap_secondsCache, _VaryingTempoMap_rebuildCache, _VaryingTempoMap_ppqnToSecondsPositive, _VaryingTempoMap_absoluteSecondsToPPQN;
+var _TempoGridCursor_instances, _TempoGridCursor_events, _TempoGridCursor_storageBpm, _TempoGridCursor_segmentIndex, _TempoGridCursor_lastPPQN, _TempoGridCursor_lastBpm, _TempoGridCursor_m, _TempoGridCursor_q, _TempoGridCursor_reset, _TempoGridCursor_bpmAt, _TempoGridCursor_zoneAt, _VaryingTempoMap_instances, _VaryingTempoMap_terminator, _VaryingTempoMap_adapter, _VaryingTempoMap_ppqnCache, _VaryingTempoMap_secondsCache, _VaryingTempoMap_cursor, _VaryingTempoMap_rebuildCache, _VaryingTempoMap_ppqnToSecondsPositive, _VaryingTempoMap_absoluteSecondsToPPQN;
 import { PPQN, TempoChangeGrid } from "@opendaw/lib-dsp";
-import { BinarySearch, NumberComparator, quantizeCeil, Terminator } from "@opendaw/lib-std";
+import { BinarySearch, Curve, NumberComparator, quantizeCeil, Terminator } from "@opendaw/lib-std";
+/**
+ * Allocation-free cursor that reproduces {@link ValueEvent.valueAt} for monotonically non-decreasing ppqn.
+ * Tracks the current segment and the recurrence coefficients m, q so that a step of exactly
+ * TempoChangeGrid within the same zone can be resolved as v = m * v + q.
+ */
+export class TempoGridCursor {
+    constructor() {
+        _TempoGridCursor_instances.add(this);
+        _TempoGridCursor_events.set(this, []);
+        _TempoGridCursor_storageBpm.set(this, 0.0);
+        _TempoGridCursor_segmentIndex.set(this, -2);
+        _TempoGridCursor_lastPPQN.set(this, Number.NEGATIVE_INFINITY);
+        _TempoGridCursor_lastBpm.set(this, 0.0);
+        _TempoGridCursor_m.set(this, 1.0);
+        _TempoGridCursor_q.set(this, 0.0
+        /**
+         * Integrates the seconds elapsed across [fromPPQN, toPPQN] by stepping the TempoChangeGrid.
+         */
+        );
+    }
+    /**
+     * Integrates the seconds elapsed across [fromPPQN, toPPQN] by stepping the TempoChangeGrid.
+     */
+    integrate(events, fromPPQN, toPPQN, storageBpm) {
+        __classPrivateFieldGet(this, _TempoGridCursor_instances, "m", _TempoGridCursor_reset).call(this, events, storageBpm);
+        let acc = 0.0;
+        let current = fromPPQN;
+        while (current < toPPQN) {
+            const currentBpm = __classPrivateFieldGet(this, _TempoGridCursor_instances, "m", _TempoGridCursor_bpmAt).call(this, current);
+            const nextGrid = quantizeCeil(current, TempoChangeGrid);
+            const segmentEnd = nextGrid <= current ? nextGrid + TempoChangeGrid : nextGrid;
+            const actualEnd = Math.min(segmentEnd, toPPQN);
+            acc += PPQN.pulsesToSeconds(actualEnd - current, currentBpm);
+            current = actualEnd;
+        }
+        return acc;
+    }
+    /**
+     * Walks the TempoChangeGrid forward from fromPPQN, accumulating seconds starting at fromSeconds,
+     * until targetSeconds is reached.
+     */
+    advance(events, fromPPQN, fromSeconds, targetSeconds, storageBpm) {
+        __classPrivateFieldGet(this, _TempoGridCursor_instances, "m", _TempoGridCursor_reset).call(this, events, storageBpm);
+        let accumulatedSeconds = fromSeconds;
+        let accumulatedPPQN = fromPPQN;
+        while (accumulatedSeconds < targetSeconds) {
+            const currentBpm = __classPrivateFieldGet(this, _TempoGridCursor_instances, "m", _TempoGridCursor_bpmAt).call(this, accumulatedPPQN);
+            const nextGrid = quantizeCeil(accumulatedPPQN, TempoChangeGrid);
+            const segmentEnd = nextGrid <= accumulatedPPQN ? nextGrid + TempoChangeGrid : nextGrid;
+            const segmentPPQN = segmentEnd - accumulatedPPQN;
+            const segmentSeconds = PPQN.pulsesToSeconds(segmentPPQN, currentBpm);
+            if (accumulatedSeconds + segmentSeconds >= targetSeconds) {
+                accumulatedPPQN += PPQN.secondsToPulses(targetSeconds - accumulatedSeconds, currentBpm);
+                break;
+            }
+            accumulatedSeconds += segmentSeconds;
+            accumulatedPPQN = segmentEnd;
+        }
+        return accumulatedPPQN;
+    }
+}
+_TempoGridCursor_events = new WeakMap(), _TempoGridCursor_storageBpm = new WeakMap(), _TempoGridCursor_segmentIndex = new WeakMap(), _TempoGridCursor_lastPPQN = new WeakMap(), _TempoGridCursor_lastBpm = new WeakMap(), _TempoGridCursor_m = new WeakMap(), _TempoGridCursor_q = new WeakMap(), _TempoGridCursor_instances = new WeakSet(), _TempoGridCursor_reset = function _TempoGridCursor_reset(events, storageBpm) {
+    __classPrivateFieldSet(this, _TempoGridCursor_events, events, "f");
+    __classPrivateFieldSet(this, _TempoGridCursor_storageBpm, storageBpm, "f");
+    __classPrivateFieldSet(this, _TempoGridCursor_segmentIndex, -2, "f");
+    __classPrivateFieldSet(this, _TempoGridCursor_lastPPQN, Number.NEGATIVE_INFINITY, "f");
+    __classPrivateFieldSet(this, _TempoGridCursor_lastBpm, 0.0, "f");
+    __classPrivateFieldSet(this, _TempoGridCursor_m, 1.0, "f");
+    __classPrivateFieldSet(this, _TempoGridCursor_q, 0.0, "f");
+}, _TempoGridCursor_bpmAt = function _TempoGridCursor_bpmAt(position) {
+    const events = __classPrivateFieldGet(this, _TempoGridCursor_events, "f");
+    if (events.length === 0) {
+        return __classPrivateFieldGet(this, _TempoGridCursor_storageBpm, "f");
+    }
+    const zone = __classPrivateFieldGet(this, _TempoGridCursor_instances, "m", _TempoGridCursor_zoneAt).call(this, position);
+    if (zone === __classPrivateFieldGet(this, _TempoGridCursor_segmentIndex, "f") && position === __classPrivateFieldGet(this, _TempoGridCursor_lastPPQN, "f") + TempoChangeGrid) {
+        __classPrivateFieldSet(this, _TempoGridCursor_lastPPQN, position, "f");
+        return __classPrivateFieldSet(this, _TempoGridCursor_lastBpm, __classPrivateFieldGet(this, _TempoGridCursor_m, "f") * __classPrivateFieldGet(this, _TempoGridCursor_lastBpm, "f") + __classPrivateFieldGet(this, _TempoGridCursor_q, "f"), "f");
+    }
+    __classPrivateFieldSet(this, _TempoGridCursor_segmentIndex, zone, "f");
+    __classPrivateFieldSet(this, _TempoGridCursor_lastPPQN, position, "f");
+    if (zone < 0) {
+        __classPrivateFieldSet(this, _TempoGridCursor_m, 1.0, "f");
+        __classPrivateFieldSet(this, _TempoGridCursor_q, 0.0, "f");
+        return __classPrivateFieldSet(this, _TempoGridCursor_lastBpm, zone === -1 ? events[0].value : events[events.length - 1].value, "f");
+    }
+    const a = events[zone];
+    const b = events[zone + 1];
+    const interpolation = a.interpolation;
+    if (interpolation.type === "none") {
+        __classPrivateFieldSet(this, _TempoGridCursor_m, 1.0, "f");
+        __classPrivateFieldSet(this, _TempoGridCursor_q, 0.0, "f");
+        return __classPrivateFieldSet(this, _TempoGridCursor_lastBpm, a.value, "f");
+    }
+    else if (interpolation.type === "linear") {
+        __classPrivateFieldSet(this, _TempoGridCursor_m, 1.0, "f");
+        __classPrivateFieldSet(this, _TempoGridCursor_q, (b.value - a.value) * TempoChangeGrid / (b.position - a.position), "f");
+        return __classPrivateFieldSet(this, _TempoGridCursor_lastBpm, a.value + (position - a.position) / (b.position - a.position) * (b.value - a.value), "f");
+    }
+    else {
+        const { m, q } = Curve.coefficients({
+            slope: interpolation.slope,
+            steps: (b.position - a.position) / TempoChangeGrid,
+            y0: a.value,
+            y1: b.value
+        });
+        __classPrivateFieldSet(this, _TempoGridCursor_m, m, "f");
+        __classPrivateFieldSet(this, _TempoGridCursor_q, q, "f");
+        return __classPrivateFieldSet(this, _TempoGridCursor_lastBpm, Curve.valueAt({
+            slope: interpolation.slope,
+            steps: b.position - a.position,
+            y0: a.value,
+            y1: b.value
+        }, position - a.position), "f");
+    }
+}, _TempoGridCursor_zoneAt = function _TempoGridCursor_zoneAt(position) {
+    const events = __classPrivateFieldGet(this, _TempoGridCursor_events, "f");
+    if (position < events[0].position) {
+        return -1;
+    }
+    const last = events.length - 1;
+    if (position >= events[last].position) {
+        return -3;
+    }
+    let low = 0;
+    let high = last;
+    while (low < high) {
+        const mid = (low + high + 1) >> 1;
+        if (events[mid].position <= position) {
+            low = mid;
+        }
+        else {
+            high = mid - 1;
+        }
+    }
+    return low;
+};
 /**
  * TempoMap implementation that handles varying tempo (tempo automation).
  * Steps through at TempoChangeGrid intervals to match BlockRenderer behavior.
@@ -23,6 +160,7 @@ export class VaryingTempoMap {
         _VaryingTempoMap_adapter.set(this, void 0);
         _VaryingTempoMap_ppqnCache.set(this, []);
         _VaryingTempoMap_secondsCache.set(this, []);
+        _VaryingTempoMap_cursor.set(this, new TempoGridCursor());
         __classPrivateFieldSet(this, _VaryingTempoMap_adapter, adapter, "f");
         __classPrivateFieldGet(this, _VaryingTempoMap_terminator, "f").ownAll(adapter.box.bpm.subscribe(() => __classPrivateFieldGet(this, _VaryingTempoMap_instances, "m", _VaryingTempoMap_rebuildCache).call(this)), adapter.catchupAndSubscribeTempoAutomation(() => __classPrivateFieldGet(this, _VaryingTempoMap_instances, "m", _VaryingTempoMap_rebuildCache).call(this)));
     }
@@ -59,7 +197,7 @@ export class VaryingTempoMap {
         return terminator;
     }
 }
-_VaryingTempoMap_terminator = new WeakMap(), _VaryingTempoMap_adapter = new WeakMap(), _VaryingTempoMap_ppqnCache = new WeakMap(), _VaryingTempoMap_secondsCache = new WeakMap(), _VaryingTempoMap_instances = new WeakSet(), _VaryingTempoMap_rebuildCache = function _VaryingTempoMap_rebuildCache() {
+_VaryingTempoMap_terminator = new WeakMap(), _VaryingTempoMap_adapter = new WeakMap(), _VaryingTempoMap_ppqnCache = new WeakMap(), _VaryingTempoMap_secondsCache = new WeakMap(), _VaryingTempoMap_cursor = new WeakMap(), _VaryingTempoMap_instances = new WeakSet(), _VaryingTempoMap_rebuildCache = function _VaryingTempoMap_rebuildCache() {
     __classPrivateFieldGet(this, _VaryingTempoMap_ppqnCache, "f").length = 0;
     __classPrivateFieldGet(this, _VaryingTempoMap_secondsCache, "f").length = 0;
     const tempoEvents = __classPrivateFieldGet(this, _VaryingTempoMap_adapter, "f").tempoTrackEvents;
@@ -80,14 +218,8 @@ _VaryingTempoMap_terminator = new WeakMap(), _VaryingTempoMap_adapter = new Weak
         if (eventPosition <= currentPPQN) {
             continue;
         }
-        while (currentPPQN < eventPosition) {
-            const currentBpm = collection.valueAt(currentPPQN, storageBpm);
-            const nextGrid = quantizeCeil(currentPPQN, TempoChangeGrid);
-            const segmentEnd = nextGrid <= currentPPQN ? nextGrid + TempoChangeGrid : nextGrid;
-            const actualEnd = Math.min(segmentEnd, eventPosition);
-            accumulatedSeconds += PPQN.pulsesToSeconds(actualEnd - currentPPQN, currentBpm);
-            currentPPQN = actualEnd;
-        }
+        accumulatedSeconds += __classPrivateFieldGet(this, _VaryingTempoMap_cursor, "f").integrate(events, currentPPQN, eventPosition, storageBpm);
+        currentPPQN = eventPosition;
         entries.push({ ppqn: eventPosition, seconds: accumulatedSeconds, bpm: collection.valueAt(eventPosition, storageBpm) });
     }
     __classPrivateFieldGet(this, _VaryingTempoMap_ppqnCache, "f").push(...entries);
@@ -106,6 +238,7 @@ _VaryingTempoMap_terminator = new WeakMap(), _VaryingTempoMap_adapter = new Weak
     if (collection.events.isEmpty()) {
         return PPQN.pulsesToSeconds(position, storageBpm);
     }
+    const events = collection.events.asArray();
     let startPPQN = 0.0;
     let startSeconds = 0.0;
     if (__classPrivateFieldGet(this, _VaryingTempoMap_ppqnCache, "f").length > 0) {
@@ -119,17 +252,7 @@ _VaryingTempoMap_terminator = new WeakMap(), _VaryingTempoMap_adapter = new Weak
             }
         }
     }
-    let accumulatedSeconds = startSeconds;
-    let currentPPQN = startPPQN;
-    while (currentPPQN < position) {
-        const currentBpm = collection.valueAt(currentPPQN, storageBpm);
-        const nextGrid = quantizeCeil(currentPPQN, TempoChangeGrid);
-        const segmentEnd = nextGrid <= currentPPQN ? nextGrid + TempoChangeGrid : nextGrid;
-        const actualEnd = Math.min(segmentEnd, position);
-        accumulatedSeconds += PPQN.pulsesToSeconds(actualEnd - currentPPQN, currentBpm);
-        currentPPQN = actualEnd;
-    }
-    return accumulatedSeconds;
+    return startSeconds + __classPrivateFieldGet(this, _VaryingTempoMap_cursor, "f").integrate(events, startPPQN, position, storageBpm);
 }, _VaryingTempoMap_absoluteSecondsToPPQN = function _VaryingTempoMap_absoluteSecondsToPPQN(targetSeconds) {
     if (targetSeconds <= 0) {
         return 0.0;
@@ -143,6 +266,7 @@ _VaryingTempoMap_terminator = new WeakMap(), _VaryingTempoMap_adapter = new Weak
     if (collection.events.isEmpty()) {
         return PPQN.secondsToPulses(targetSeconds, storageBpm);
     }
+    const events = collection.events.asArray();
     let startPPQN = 0.0;
     let startSeconds = 0.0;
     if (__classPrivateFieldGet(this, _VaryingTempoMap_secondsCache, "f").length > 0) {
@@ -156,21 +280,5 @@ _VaryingTempoMap_terminator = new WeakMap(), _VaryingTempoMap_adapter = new Weak
             }
         }
     }
-    let accumulatedSeconds = startSeconds;
-    let accumulatedPPQN = startPPQN;
-    while (accumulatedSeconds < targetSeconds) {
-        const currentBpm = collection.valueAt(accumulatedPPQN, storageBpm);
-        const nextGrid = quantizeCeil(accumulatedPPQN, TempoChangeGrid);
-        const segmentEnd = nextGrid <= accumulatedPPQN ? nextGrid + TempoChangeGrid : nextGrid;
-        const segmentPPQN = segmentEnd - accumulatedPPQN;
-        const segmentSeconds = PPQN.pulsesToSeconds(segmentPPQN, currentBpm);
-        if (accumulatedSeconds + segmentSeconds >= targetSeconds) {
-            const remainingSeconds = targetSeconds - accumulatedSeconds;
-            accumulatedPPQN += PPQN.secondsToPulses(remainingSeconds, currentBpm);
-            break;
-        }
-        accumulatedSeconds += segmentSeconds;
-        accumulatedPPQN = segmentEnd;
-    }
-    return accumulatedPPQN;
+    return __classPrivateFieldGet(this, _VaryingTempoMap_cursor, "f").advance(events, startPPQN, startSeconds, targetSeconds, storageBpm);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opendaw/studio-adapters",
-  "version": "0.0.110",
+  "version": "0.0.111",
   "license": "LGPL-3.0-or-later",
   "publishConfig": {
     "access": "public"
@@ -36,5 +36,5 @@
     "@opendaw/eslint-config": "^0.0.28",
     "@opendaw/typescript-config": "^0.0.32"
   },
-  "gitHead": "b507627ec60d6992ccbddfb8acc580cea71918d6"
+  "gitHead": "513f0659d9ce582c3b75839310a717a3be22cfa4"
 }