@dawcore/transport 0.0.1 → 0.0.2

package/dist/index.mjs

@@ -172,34 +172,6 @@ var SampleTimeline = class {
   }
 };
 
-// src/timeline/tick-timeline.ts
-var TickTimeline = class {
-  constructor(ppqn = 960) {
-    this._ppqn = ppqn;
-  }
-  get ppqn() {
-    return this._ppqn;
-  }
-  ticksPerBeat() {
-    return this._ppqn;
-  }
-  ticksPerBar(beatsPerBar) {
-    return this._ppqn * beatsPerBar;
-  }
-  toPosition(ticks, beatsPerBar) {
-    const ticksPerBar = this.ticksPerBar(beatsPerBar);
-    const bar = Math.floor(ticks / ticksPerBar) + 1;
-    const remaining = ticks % ticksPerBar;
-    const beat = Math.floor(remaining / this._ppqn) + 1;
-    const tick = remaining % this._ppqn;
-    return { bar, beat, tick };
-  }
-  fromPosition(bar, beat, tick, beatsPerBar) {
-    const ticksPerBar = this.ticksPerBar(beatsPerBar);
-    return (bar - 1) * ticksPerBar + (beat - 1) * this._ppqn + tick;
-  }
-};
-
 // src/timeline/tempo-map.ts
 var TempoMap = class {
   constructor(ppqn = 960, initialBpm = 120) {
@@ -252,6 +224,10 @@ var TempoMap = class {
   secondsToBeats(seconds) {
     return this.secondsToTicks(seconds) / this._ppqn;
   }
+  clearTempos() {
+    const first = this._entries[0];
+    this._entries = [{ tick: 0, bpm: first.bpm, secondsAtTick: 0 }];
+  }
   _ticksToSecondsInternal(ticks) {
     const entry = this._entryAt(ticks);
     const ticksIntoSegment = ticks - entry.tick;
@@ -284,6 +260,179 @@ var TempoMap = class {
   }
 };
 
+// src/timeline/meter-map.ts
+function isPowerOf2(n) {
+  return n > 0 && (n & n - 1) === 0;
+}
+var MeterMap = class {
+  constructor(ppqn, numerator = 4, denominator = 4) {
+    this._ppqn = ppqn;
+    this._entries = [{ tick: 0, numerator, denominator, barAtTick: 0 }];
+  }
+  get ppqn() {
+    return this._ppqn;
+  }
+  getMeter(atTick = 0) {
+    const entry = this._entryAt(atTick);
+    return { numerator: entry.numerator, denominator: entry.denominator };
+  }
+  setMeter(numerator, denominator, atTick = 0) {
+    this._validateMeter(numerator, denominator);
+    if (atTick < 0) {
+      throw new Error("[waveform-playlist] MeterMap: atTick must be non-negative, got " + atTick);
+    }
+    if (atTick === 0) {
+      this._entries[0] = { ...this._entries[0], numerator, denominator };
+      this._resnapDownstreamEntries(0);
+      this._recomputeCache(0);
+      return;
+    }
+    const snapped = this._snapToBarBoundary(atTick);
+    if (snapped !== atTick) {
+      console.warn(
+        "[waveform-playlist] MeterMap.setMeter: tick " + atTick + " is not on a bar boundary, snapped to " + snapped
+      );
+    }
+    let i = this._entries.length - 1;
+    while (i > 0 && this._entries[i].tick > snapped) i--;
+    if (this._entries[i].tick === snapped) {
+      this._entries[i] = { ...this._entries[i], numerator, denominator };
+    } else {
+      const barAtTick = this._computeBarAtTick(snapped);
+      this._entries.splice(i + 1, 0, { tick: snapped, numerator, denominator, barAtTick });
+      i = i + 1;
+    }
+    this._resnapDownstreamEntries(i);
+    this._recomputeCache(i);
+  }
+  removeMeter(atTick) {
+    if (atTick === 0) {
+      throw new Error("[waveform-playlist] MeterMap: cannot remove meter at tick 0");
+    }
+    const idx = this._entries.findIndex((e) => e.tick === atTick);
+    if (idx > 0) {
+      this._entries.splice(idx, 1);
+      this._recomputeCache(idx);
+    } else if (idx === -1) {
+      console.warn("[waveform-playlist] MeterMap.removeMeter: no entry at tick " + atTick);
+    }
+  }
+  clearMeters() {
+    const first = this._entries[0];
+    this._entries = [{ ...first, barAtTick: 0 }];
+  }
+  ticksPerBeat(atTick = 0) {
+    const entry = this._entryAt(atTick);
+    return this._ppqn * (4 / entry.denominator);
+  }
+  ticksPerBar(atTick = 0) {
+    const entry = this._entryAt(atTick);
+    return entry.numerator * this._ppqn * (4 / entry.denominator);
+  }
+  barToTick(bar) {
+    if (bar < 1) {
+      throw new Error("[waveform-playlist] MeterMap: bar must be >= 1, got " + bar);
+    }
+    const targetBar = bar - 1;
+    for (let i = 0; i < this._entries.length; i++) {
+      const nextBar = i < this._entries.length - 1 ? this._entries[i + 1].barAtTick : Infinity;
+      if (targetBar < nextBar) {
+        const barsInto = targetBar - this._entries[i].barAtTick;
+        const tpb = this._ticksPerBarForEntry(this._entries[i]);
+        return this._entries[i].tick + barsInto * tpb;
+      }
+    }
+    return 0;
+  }
+  tickToBar(tick) {
+    const entry = this._entryAt(tick);
+    const ticksInto = tick - entry.tick;
+    const tpb = this._ticksPerBarForEntry(entry);
+    return entry.barAtTick + Math.floor(ticksInto / tpb) + 1;
+  }
+  isBarBoundary(tick) {
+    const entry = this._entryAt(tick);
+    const ticksInto = tick - entry.tick;
+    const tpb = this._ticksPerBarForEntry(entry);
+    return ticksInto % tpb === 0;
+  }
+  /** Internal: get the full entry at a tick (for MetronomePlayer beat grid anchoring) */
+  getEntryAt(tick) {
+    return this._entryAt(tick);
+  }
+  _entryAt(tick) {
+    let lo = 0;
+    let hi = this._entries.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (this._entries[mid].tick <= tick) {
+        lo = mid;
+      } else {
+        hi = mid - 1;
+      }
+    }
+    return this._entries[lo];
+  }
+  _ticksPerBarForEntry(entry) {
+    return entry.numerator * this._ppqn * (4 / entry.denominator);
+  }
+  _snapToBarBoundary(atTick) {
+    const entry = this._entryAt(atTick);
+    const tpb = this._ticksPerBarForEntry(entry);
+    const ticksInto = atTick - entry.tick;
+    if (ticksInto % tpb === 0) return atTick;
+    return entry.tick + Math.ceil(ticksInto / tpb) * tpb;
+  }
+  _computeBarAtTick(tick) {
+    const entry = this._entryAt(tick);
+    const ticksInto = tick - entry.tick;
+    const tpb = this._ticksPerBarForEntry(entry);
+    return entry.barAtTick + ticksInto / tpb;
+  }
+  _recomputeCache(fromIndex) {
+    for (let i = Math.max(1, fromIndex); i < this._entries.length; i++) {
+      const prev = this._entries[i - 1];
+      const tickDelta = this._entries[i].tick - prev.tick;
+      const tpb = this._ticksPerBarForEntry(prev);
+      this._entries[i] = {
+        ...this._entries[i],
+        barAtTick: prev.barAtTick + tickDelta / tpb
+      };
+    }
+  }
+  /**
+   * After changing a meter entry, re-snap downstream entries to bar boundaries
+   * of their preceding meter so barAtTick stays integer.
+   */
+  _resnapDownstreamEntries(fromIndex) {
+    for (let i = Math.max(1, fromIndex + 1); i < this._entries.length; i++) {
+      const prev = this._entries[i - 1];
+      const tpb = this._ticksPerBarForEntry(prev);
+      const tick = this._entries[i].tick;
+      const ticksIntoPrev = tick - prev.tick;
+      if (ticksIntoPrev % tpb !== 0) {
+        const snapped = prev.tick + Math.ceil(ticksIntoPrev / tpb) * tpb;
+        console.warn(
+          "[waveform-playlist] MeterMap: meter change moved entry from tick " + tick + " to " + snapped + " (bar boundary alignment)"
+        );
+        this._entries[i] = { ...this._entries[i], tick: snapped };
+      }
+    }
+  }
+  _validateMeter(numerator, denominator) {
+    if (!Number.isInteger(numerator) || numerator < 1 || numerator > 32) {
+      throw new Error(
+        "[waveform-playlist] MeterMap: numerator must be an integer 1-32, got " + numerator
+      );
+    }
+    if (!isPowerOf2(denominator) || denominator > 32) {
+      throw new Error(
+        "[waveform-playlist] MeterMap: denominator must be a power of 2 (1-32), got " + denominator
+      );
+    }
+  }
+};
+
 // src/audio/master-node.ts
 var MasterNode = class {
   constructor(audioContext) {
@@ -550,15 +699,14 @@ var ClipPlayer = class {
 
 // src/audio/metronome-player.ts
 var MetronomePlayer = class {
-  constructor(audioContext, tempoMap, tickTimeline, destination, toAudioTime) {
+  constructor(audioContext, tempoMap, meterMap, destination, toAudioTime) {
     this._enabled = false;
-    this._beatsPerBar = 4;
     this._accentBuffer = null;
     this._normalBuffer = null;
     this._activeSources = /* @__PURE__ */ new Set();
     this._audioContext = audioContext;
     this._tempoMap = tempoMap;
-    this._tickTimeline = tickTimeline;
+    this._meterMap = meterMap;
     this._destination = destination;
     this._toAudioTime = toAudioTime;
   }
@@ -568,9 +716,6 @@ var MetronomePlayer = class {
       this.silence();
     }
   }
-  setBeatsPerBar(beats) {
-    this._beatsPerBar = beats;
-  }
   setClickSounds(accent, normal) {
     this._accentBuffer = accent;
     this._normalBuffer = normal;
@@ -580,19 +725,27 @@ var MetronomePlayer = class {
       return [];
     }
     const events = [];
-    const ppqn = this._tickTimeline.ppqn;
     const fromTicks = this._tempoMap.secondsToTicks(fromTime);
     const toTicks = this._tempoMap.secondsToTicks(toTime);
-    const firstBeatTick = Math.ceil(fromTicks / ppqn) * ppqn;
-    for (let tick = firstBeatTick; tick < toTicks; tick += ppqn) {
+    let entry = this._meterMap.getEntryAt(fromTicks);
+    let beatSize = this._meterMap.ticksPerBeat(fromTicks);
+    const tickIntoSection = fromTicks - entry.tick;
+    let tick = entry.tick + Math.ceil(tickIntoSection / beatSize) * beatSize;
+    while (tick < toTicks) {
+      const currentEntry = this._meterMap.getEntryAt(tick);
+      if (currentEntry.tick !== entry.tick) {
+        entry = currentEntry;
+        beatSize = this._meterMap.ticksPerBeat(tick);
+      }
+      const isAccent = this._meterMap.isBarBoundary(tick);
       const transportTime = this._tempoMap.ticksToSeconds(tick);
-      const ticksPerBar = this._tickTimeline.ticksPerBar(this._beatsPerBar);
-      const isAccent = tick % ticksPerBar === 0;
       events.push({
         transportTime,
         isAccent,
         buffer: isAccent ? this._accentBuffer : this._normalBuffer
       });
+      beatSize = this._meterMap.ticksPerBeat(tick);
+      tick += beatSize;
     }
     return events;
   }
@@ -653,9 +806,10 @@ var Transport = class _Transport {
     const sampleRate = options.sampleRate ?? audioContext.sampleRate;
     const ppqn = options.ppqn ?? 960;
     const tempo = options.tempo ?? 120;
-    const beatsPerBar = options.beatsPerBar ?? 4;
+    const numerator = options.numerator ?? 4;
+    const denominator = options.denominator ?? 4;
     const lookahead = options.schedulerLookahead ?? 0.2;
-    _Transport._validateOptions(sampleRate, ppqn, tempo, beatsPerBar, lookahead);
+    _Transport._validateOptions(sampleRate, ppqn, tempo, numerator, denominator, lookahead);
     this._clock = new Clock(audioContext);
     this._scheduler = new Scheduler({
       lookahead,
@@ -664,9 +818,9 @@ var Transport = class _Transport {
       }
     });
     this._sampleTimeline = new SampleTimeline(sampleRate);
-    this._tickTimeline = new TickTimeline(ppqn);
+    this._meterMap = new MeterMap(ppqn, numerator, denominator);
     this._tempoMap = new TempoMap(ppqn, tempo);
-    this._initAudioGraph(audioContext, beatsPerBar);
+    this._initAudioGraph(audioContext);
     this._timer = new Timer(() => {
       const time = this._clock.getTime();
       if (this._endTime !== void 0 && time >= this._endTime) {
@@ -858,15 +1012,46 @@ var Transport = class _Transport {
     this._emit("loop");
   }
   // --- Tempo ---
-  setTempo(bpm) {
-    this._tempoMap.setTempo(bpm);
+  setTempo(bpm, atTick) {
+    this._tempoMap.setTempo(bpm, atTick);
     this._emit("tempochange");
   }
-  getTempo() {
-    return this._tempoMap.getTempo();
+  getTempo(atTick) {
+    return this._tempoMap.getTempo(atTick);
+  }
+  // --- Meter ---
+  setMeter(numerator, denominator, atTick) {
+    this._meterMap.setMeter(numerator, denominator, atTick);
+    this._emit("meterchange");
+  }
+  getMeter(atTick) {
+    return this._meterMap.getMeter(atTick);
+  }
+  removeMeter(atTick) {
+    this._meterMap.removeMeter(atTick);
+    this._emit("meterchange");
+  }
+  clearMeters() {
+    this._meterMap.clearMeters();
+    this._emit("meterchange");
+  }
+  clearTempos() {
+    this._tempoMap.clearTempos();
+    this._emit("tempochange");
   }
-  setBeatsPerBar(beats) {
-    this._metronomePlayer.setBeatsPerBar(beats);
+  barToTick(bar) {
+    return this._meterMap.barToTick(bar);
+  }
+  tickToBar(tick) {
+    return this._meterMap.tickToBar(tick);
+  }
+  /** Convert transport time (seconds) to tick position, using the tempo map. */
+  timeToTick(seconds) {
+    return this._tempoMap.secondsToTicks(seconds);
+  }
+  /** Convert tick position to transport time (seconds), using the tempo map. */
+  tickToTime(tick) {
+    return this._tempoMap.ticksToSeconds(tick);
   }
   // --- Metronome ---
   setMetronomeEnabled(enabled) {
@@ -913,7 +1098,7 @@ var Transport = class _Transport {
     this._listeners.clear();
   }
   // --- Private ---
-  static _validateOptions(sampleRate, ppqn, tempo, beatsPerBar, lookahead) {
+  static _validateOptions(sampleRate, ppqn, tempo, numerator, denominator, lookahead) {
     if (sampleRate <= 0) {
       throw new Error(
         "[waveform-playlist] Transport: sampleRate must be positive, got " + sampleRate
@@ -927,9 +1112,14 @@ var Transport = class _Transport {
     if (tempo <= 0) {
       throw new Error("[waveform-playlist] Transport: tempo must be positive, got " + tempo);
     }
-    if (beatsPerBar <= 0 || !Number.isInteger(beatsPerBar)) {
+    if (!Number.isInteger(numerator) || numerator < 1 || numerator > 32) {
+      throw new Error(
+        "[waveform-playlist] Transport: numerator must be an integer 1-32, got " + numerator
+      );
+    }
+    if (denominator <= 0 || (denominator & denominator - 1) !== 0 || denominator > 32) {
       throw new Error(
-        "[waveform-playlist] Transport: beatsPerBar must be a positive integer, got " + beatsPerBar
+        "[waveform-playlist] Transport: denominator must be a power of 2 (1-32), got " + denominator
       );
     }
     if (lookahead <= 0) {
@@ -938,7 +1128,7 @@ var Transport = class _Transport {
       );
     }
   }
-  _initAudioGraph(audioContext, beatsPerBar) {
+  _initAudioGraph(audioContext) {
     this._masterNode = new MasterNode(audioContext);
     this._masterNode.output.connect(audioContext.destination);
     const toAudioTime = (transportTime) => this._clock.toAudioTime(transportTime);
@@ -946,11 +1136,10 @@ var Transport = class _Transport {
     this._metronomePlayer = new MetronomePlayer(
       audioContext,
       this._tempoMap,
-      this._tickTimeline,
+      this._meterMap,
       this._masterNode.input,
       toAudioTime
     );
-    this._metronomePlayer.setBeatsPerBar(beatsPerBar);
     this._scheduler.addListener(this._clipPlayer);
     this._scheduler.addListener(this._metronomePlayer);
   }
@@ -1056,12 +1245,12 @@ export {
   ClipPlayer,
   Clock,
   MasterNode,
+  MeterMap,
   MetronomePlayer,
   NativePlayoutAdapter,
   SampleTimeline,
   Scheduler,
   TempoMap,
-  TickTimeline,
   Timer,
   TrackNode,
   Transport