@dawcore/components 0.0.3 → 0.0.5

package/dist/index.mjs

@@ -755,7 +755,12 @@ DawStopButtonElement = __decorateClass([
 // src/elements/daw-editor.ts
 import { LitElement as LitElement8, html as html7, css as css7 } from "lit";
 import { customElement as customElement10, property as property6, state as state3 } from "lit/decorators.js";
-import { createClipFromSeconds as createClipFromSeconds2, createTrack as createTrack2, clipPixelWidth } from "@waveform-playlist/core";
+import {
+  createClip as createClip2,
+  createClipFromSeconds as createClipFromSeconds2,
+  createTrack as createTrack2,
+  clipPixelWidth
+} from "@waveform-playlist/core";
 
 // src/workers/peaksWorker.ts
 import WaveformData from "waveform-data";
@@ -1083,6 +1088,13 @@ var PeakPipeline = class {
     this._baseScale = baseScale;
     this._bits = bits;
   }
+  /**
+   * Inject externally-loaded WaveformData (e.g., from a .dat file) into the cache.
+   * Prevents worker generation for this AudioBuffer on all subsequent calls.
+   */
+  cacheWaveformData(audioBuffer, waveformData) {
+    this._cache.set(audioBuffer, waveformData);
+  }
   /**
    * Generate PeakData for a clip from its AudioBuffer.
    * Uses cached WaveformData when available; otherwise generates via worker.
@@ -1090,8 +1102,9 @@ var PeakPipeline = class {
    */
   async generatePeaks(audioBuffer, samplesPerPixel, isMono, offsetSamples, durationSamples) {
     const waveformData = await this._getWaveformData(audioBuffer);
+    const effectiveScale = this._clampScale(waveformData, samplesPerPixel);
     try {
-      return extractPeaks(waveformData, samplesPerPixel, isMono, offsetSamples, durationSamples);
+      return extractPeaks(waveformData, effectiveScale, isMono, offsetSamples, durationSamples);
     } catch (err) {
       console.warn("[dawcore] extractPeaks failed: " + String(err));
       throw err;
@@ -1099,23 +1112,29 @@ var PeakPipeline = class {
   }
   /**
    * Re-extract peaks for all clips at a new zoom level using cached WaveformData.
-   * Only works for zoom levels coarser than (or equal to) the cached base scale.
-   * Returns a new Map of clipId → PeakData. Clips without cached data or where
-   * the target scale is finer than the cached base are skipped.
+   * Returns a new Map of clipId → PeakData. Clips without cached data are skipped.
+   * When the requested scale is finer than cached data, peaks are clamped to the
+   * cached scale and a single summary warning is logged.
    */
   reextractPeaks(clipBuffers, samplesPerPixel, isMono, clipOffsets) {
     const result = /* @__PURE__ */ new Map();
+    let clampedCount = 0;
+    let clampedScale = 0;
     for (const [clipId, audioBuffer] of clipBuffers) {
       const cached = this._cache.get(audioBuffer);
       if (cached) {
-        if (samplesPerPixel < cached.scale) continue;
+        const effectiveScale = this._clampScale(cached, samplesPerPixel, false);
+        if (effectiveScale !== samplesPerPixel) {
+          clampedCount++;
+          clampedScale = effectiveScale;
+        }
         try {
           const offsets = clipOffsets?.get(clipId);
           result.set(
             clipId,
             extractPeaks(
               cached,
-              samplesPerPixel,
+              effectiveScale,
               isMono,
               offsets?.offsetSamples,
               offsets?.durationSamples
@@ -1126,8 +1145,42 @@ var PeakPipeline = class {
         }
       }
     }
+    if (clampedCount > 0) {
+      console.warn(
+        "[dawcore] Requested zoom " + samplesPerPixel + " spp is finer than pre-computed peaks (" + clampedScale + " spp) \u2014 " + clampedCount + " clip(s) using available resolution"
+      );
+    }
     return result;
   }
+  /**
+   * Clamp requested scale to cached WaveformData scale.
+   * WaveformData.resample() can only go coarser — if the requested zoom is
+   * finer than the cached data, use the cached scale. Set warn=true to log
+   * (default); reextractPeaks passes false and logs a single summary instead.
+   */
+  _clampScale(waveformData, requestedScale, warn = true) {
+    if (requestedScale < waveformData.scale) {
+      if (warn) {
+        console.warn(
+          "[dawcore] Requested zoom " + requestedScale + " spp is finer than pre-computed peaks (" + waveformData.scale + " spp) \u2014 using available resolution"
+        );
+      }
+      return waveformData.scale;
+    }
+    return requestedScale;
+  }
+  /**
+   * Return the coarsest (largest) scale among cached WaveformData entries
+   * that correspond to the given clip buffers. Returns 0 if none are cached.
+   */
+  getMaxCachedScale(clipBuffers) {
+    let max = 0;
+    for (const audioBuffer of clipBuffers.values()) {
+      const cached = this._cache.get(audioBuffer);
+      if (cached && cached.scale > max) max = cached.scale;
+    }
+    return max;
+  }
   terminate() {
     this._worker?.terminate();
     this._worker = null;
@@ -2436,6 +2489,7 @@ async function loadFiles(host, files) {
         clips: [
           {
             src: "",
+            peaksSrc: "",
             start: 0,
             duration: audioBuffer.duration,
             offset: 0,
@@ -2521,6 +2575,7 @@ function addRecordedClip(host, trackId, buf, startSample, durSamples, offsetSamp
       const sr = host.effectiveSampleRate;
       const clipDesc = {
         src: "",
+        peaksSrc: "",
         start: startSample / sr,
         duration: durSamples / sr,
         offset: 0,
@@ -2722,11 +2777,29 @@ function findAudioBufferForClip(host, clip, track) {
   return null;
 }
 
+// src/interactions/peaks-loader.ts
+import WaveformData2 from "waveform-data";
+async function loadWaveformDataFromUrl(src) {
+  const response = await fetch(src);
+  if (!response.ok) {
+    throw new Error("[dawcore] Failed to fetch peaks data: " + response.statusText);
+  }
+  const { pathname } = new URL(src, globalThis.location?.href ?? "http://localhost");
+  const isBinary = pathname.toLowerCase().endsWith(".dat");
+  if (isBinary) {
+    const arrayBuffer = await response.arrayBuffer();
+    return WaveformData2.create(arrayBuffer);
+  } else {
+    const json = await response.json();
+    return WaveformData2.create(json);
+  }
+}
+
 // src/elements/daw-editor.ts
 var DawEditorElement = class extends LitElement8 {
   constructor() {
     super(...arguments);
-    this.samplesPerPixel = 1024;
+    this._samplesPerPixel = 1024;
     this.waveHeight = 128;
     this.timescale = false;
     this.mono = false;
@@ -2753,9 +2826,12 @@ var DawEditorElement = class extends LitElement8 {
     this._engine = null;
     this._enginePromise = null;
     this._audioCache = /* @__PURE__ */ new Map();
+    this._peaksCache = /* @__PURE__ */ new Map();
     this._clipBuffers = /* @__PURE__ */ new Map();
     this._clipOffsets = /* @__PURE__ */ new Map();
     this._peakPipeline = new PeakPipeline();
+    /** Coarsest scale from pre-computed peaks — zoom cannot go finer than this. 0 = no limit. */
+    this._minSamplesPerPixel = 0;
     this._trackElements = /* @__PURE__ */ new Map();
     this._childObserver = null;
     this._audioResume = new AudioResumeController(this);
@@ -2841,6 +2917,7 @@ var DawEditorElement = class extends LitElement8 {
         this._onTrackRemoved(trackId);
       }
     };
+    this._contextConfigurePromise = null;
     // --- File Drop ---
     this._onDragOver = (e) => {
       if (!this.fileDrop) return;
@@ -2877,6 +2954,21 @@ var DawEditorElement = class extends LitElement8 {
     // --- Recording ---
     this.recordingStream = null;
   }
+  get samplesPerPixel() {
+    return this._samplesPerPixel;
+  }
+  set samplesPerPixel(value) {
+    const old = this._samplesPerPixel;
+    if (!Number.isFinite(value) || value <= 0) return;
+    const clamped = this._minSamplesPerPixel > 0 && value < this._minSamplesPerPixel ? this._minSamplesPerPixel : value;
+    if (clamped !== value) {
+      console.warn(
+        "[dawcore] Zoom " + value + " spp rejected \u2014 pre-computed peaks limit is " + this._minSamplesPerPixel + " spp"
+      );
+    }
+    this._samplesPerPixel = clamped;
+    this.requestUpdate("samplesPerPixel", old);
+  }
   get _clipHandler() {
     return this.interactiveClips ? this._clipPointer : null;
   }
@@ -2972,9 +3064,12 @@ var DawEditorElement = class extends LitElement8 {
     this._childObserver = null;
     this._trackElements.clear();
     this._audioCache.clear();
+    this._peaksCache.clear();
     this._clipBuffers.clear();
     this._clipOffsets.clear();
     this._peakPipeline.terminate();
+    this._minSamplesPerPixel = 0;
+    this._contextConfigurePromise = null;
     try {
       this._disposeEngine();
     } catch (err) {
@@ -3024,6 +3119,7 @@ var DawEditorElement = class extends LitElement8 {
     if (this._engine) {
       this._engine.removeTrack(trackId);
     }
+    this._minSamplesPerPixel = this._peakPipeline.getMaxCachedScale(this._clipBuffers);
     if (nextEngine.size === 0) {
       this._currentTime = 0;
       this._stopPlayhead();
@@ -3035,6 +3131,7 @@ var DawEditorElement = class extends LitElement8 {
     if (clipEls.length === 0 && trackEl.src) {
       clips.push({
         src: trackEl.src,
+        peaksSrc: "",
         start: 0,
         duration: 0,
         offset: 0,
@@ -3048,6 +3145,7 @@ var DawEditorElement = class extends LitElement8 {
       for (const clipEl of clipEls) {
         clips.push({
           src: clipEl.src,
+          peaksSrc: clipEl.peaksSrc,
           start: clipEl.start,
           duration: clipEl.duration,
           offset: clipEl.offset,
@@ -3075,7 +3173,88 @@ var DawEditorElement = class extends LitElement8 {
       const clips = [];
       for (const clipDesc of descriptor.clips) {
         if (!clipDesc.src) continue;
-        const audioBuffer = await this._fetchAndDecode(clipDesc.src);
+        const waveformDataPromise = clipDesc.peaksSrc ? this._fetchPeaks(clipDesc.peaksSrc) : null;
+        const audioPromise = this._fetchAndDecode(clipDesc.src);
+        let waveformData = null;
+        if (waveformDataPromise) {
+          try {
+            const wd = await waveformDataPromise;
+            await this._ensureContextConfigured();
+            const { getGlobalAudioContext } = await import("@waveform-playlist/playout");
+            const contextRate = getGlobalAudioContext().sampleRate;
+            if (wd.sample_rate === contextRate) {
+              waveformData = wd;
+            } else {
+              console.warn(
+                "[dawcore] Pre-computed peaks at " + wd.sample_rate + " Hz do not match AudioContext at " + contextRate + " Hz \u2014 ignoring " + clipDesc.peaksSrc + ", generating from audio"
+              );
+            }
+          } catch (err) {
+            console.warn(
+              "[dawcore] Failed to load peaks from " + clipDesc.peaksSrc + ": " + String(err) + " \u2014 falling back to AudioBuffer generation"
+            );
+          }
+        }
+        if (waveformData) {
+          const wdRate = waveformData.sample_rate;
+          const clip2 = createClip2({
+            waveformData,
+            startSample: Math.round(clipDesc.start * wdRate),
+            durationSamples: Math.round((clipDesc.duration || waveformData.duration) * wdRate),
+            offsetSamples: Math.round(clipDesc.offset * wdRate),
+            gain: clipDesc.gain,
+            name: clipDesc.name,
+            sampleRate: wdRate,
+            sourceDurationSamples: Math.ceil(waveformData.duration * wdRate)
+          });
+          const effectiveScale = Math.max(this.samplesPerPixel, waveformData.scale);
+          const peakData2 = extractPeaks(
+            waveformData,
+            effectiveScale,
+            this.mono,
+            clip2.offsetSamples,
+            clip2.durationSamples
+          );
+          this._clipOffsets.set(clip2.id, {
+            offsetSamples: clip2.offsetSamples,
+            durationSamples: clip2.durationSamples
+          });
+          this._peaksData = new Map(this._peaksData).set(clip2.id, peakData2);
+          this._minSamplesPerPixel = Math.max(this._minSamplesPerPixel, waveformData.scale);
+          const previewTrack = createTrack2({
+            name: descriptor.name,
+            clips: [clip2],
+            volume: descriptor.volume,
+            pan: descriptor.pan,
+            muted: descriptor.muted,
+            soloed: descriptor.soloed
+          });
+          previewTrack.id = trackId;
+          this._engineTracks = new Map(this._engineTracks).set(trackId, previewTrack);
+          this._recomputeDuration();
+          let audioBuffer2;
+          try {
+            audioBuffer2 = await audioPromise;
+          } catch (audioErr) {
+            const nextPeaks = new Map(this._peaksData);
+            nextPeaks.delete(clip2.id);
+            this._peaksData = nextPeaks;
+            this._clipOffsets.delete(clip2.id);
+            const nextEngine = new Map(this._engineTracks);
+            nextEngine.delete(trackId);
+            this._engineTracks = nextEngine;
+            this._minSamplesPerPixel = this._peakPipeline.getMaxCachedScale(this._clipBuffers);
+            this._recomputeDuration();
+            throw audioErr;
+          }
+          this._resolvedSampleRate = audioBuffer2.sampleRate;
+          const updatedClip = { ...clip2, audioBuffer: audioBuffer2 };
+          this._clipBuffers = new Map(this._clipBuffers).set(clip2.id, audioBuffer2);
+          this._peakPipeline.cacheWaveformData(audioBuffer2, waveformData);
+          clips.push(updatedClip);
+          continue;
+        }
+        const audioBuffer = await audioPromise;
         this._resolvedSampleRate = audioBuffer.sampleRate;
         const clip = createClipFromSeconds2({
           audioBuffer,
@@ -3134,6 +3313,30 @@ var DawEditorElement = class extends LitElement8 {
       );
     }
   }
+  /**
+   * Ensure the global AudioContext is configured with the editor's sample-rate hint
+   * before the first audio operation. Idempotent — concurrent callers await the
+   * same promise so no one proceeds to getGlobalAudioContext() before configuration.
+   */
+  _ensureContextConfigured() {
+    if (!this._contextConfigurePromise) {
+      this._contextConfigurePromise = (async () => {
+        const { configureGlobalContext } = await import("@waveform-playlist/playout");
+        const actualRate = configureGlobalContext({
+          sampleRate: this.sampleRate
+        });
+        if (actualRate !== this.sampleRate) {
+          console.warn(
+            "[dawcore] Requested sampleRate " + this.sampleRate + " but AudioContext is running at " + actualRate
+          );
+        }
+      })().catch((err) => {
+        this._contextConfigurePromise = null;
+        throw err;
+      });
+    }
+    return this._contextConfigurePromise;
+  }
   async _fetchAndDecode(src) {
     if (this._audioCache.has(src)) {
       return this._audioCache.get(src);
@@ -3146,6 +3349,7 @@ var DawEditorElement = class extends LitElement8 {
         );
       }
       const arrayBuffer = await response.arrayBuffer();
+      await this._ensureContextConfigured();
       const { getGlobalAudioContext } = await import("@waveform-playlist/playout");
       return getGlobalAudioContext().decodeAudioData(arrayBuffer);
     })();
@@ -3157,6 +3361,16 @@ var DawEditorElement = class extends LitElement8 {
       throw err;
     }
   }
+  _fetchPeaks(src) {
+    const cached = this._peaksCache.get(src);
+    if (cached) return cached;
+    const promise = loadWaveformDataFromUrl(src).catch((err) => {
+      this._peaksCache.delete(src);
+      throw err;
+    });
+    this._peaksCache.set(src, promise);
+    return promise;
+  }
   _recomputeDuration() {
     let maxSample = 0;
     for (const track of this._engineTracks.values()) {
@@ -3569,8 +3783,8 @@ DawEditorElement.styles = [
 ];
 DawEditorElement._CONTROL_PROPS = /* @__PURE__ */ new Set(["volume", "pan", "muted", "soloed"]);
 __decorateClass([
-  property6({ type: Number, attribute: "samples-per-pixel" })
-], DawEditorElement.prototype, "samplesPerPixel", 2);
+  property6({ type: Number, attribute: "samples-per-pixel", noAccessor: true })
+], DawEditorElement.prototype, "samplesPerPixel", 1);
 __decorateClass([
   property6({ type: Number, attribute: "wave-height" })
 ], DawEditorElement.prototype, "waveHeight", 2);