@dawcore/components 0.0.18 → 0.0.20

package/dist/index.mjs

@@ -174,7 +174,7 @@ var DawTrackElement = class extends LitElement2 {
     this.pan = 0;
     this.muted = false;
     this.soloed = false;
-    this.renderMode = "waveform";
+    this._renderMode = "waveform";
     this.spectrogramConfig = null;
     this.trackId = crypto.randomUUID();
     // Track removal is detected by the editor's MutationObserver,
@@ -182,6 +182,21 @@ var DawTrackElement = class extends LitElement2 {
     // cannot bubble events to ancestors).
     this._hasRendered = false;
   }
+  get renderMode() {
+    return this._renderMode;
+  }
+  set renderMode(value) {
+    const old = this._renderMode;
+    let next = value;
+    if (next === "both") {
+      console.warn(
+        `[dawcore] <daw-track render-mode="both"> is not yet supported; falling back to 'spectrogram'`
+      );
+      next = "spectrogram";
+    }
+    this._renderMode = next;
+    this.requestUpdate("renderMode", old);
+  }
   // Light DOM so <daw-clip> children are queryable.
   createRenderRoot() {
     return this;
@@ -244,8 +259,8 @@ __decorateClass([
   property2({ type: Boolean })
 ], DawTrackElement.prototype, "soloed", 2);
 __decorateClass([
-  property2({ attribute: "render-mode" })
-], DawTrackElement.prototype, "renderMode", 2);
+  property2({ attribute: "render-mode", noAccessor: true })
+], DawTrackElement.prototype, "renderMode", 1);
 __decorateClass([
   property2({ attribute: false })
 ], DawTrackElement.prototype, "spectrogramConfig", 2);
@@ -2725,15 +2740,10 @@ var RecordingController = class {
 import {
   SpectrogramOrchestrator
 } from "@dawcore/spectrogram";
-var LIBRARY_DEFAULTS = {
-  fftSize: 2048,
-  windowFunction: "hann",
-  frequencyScale: "mel",
-  minFrequency: 0,
-  gainDb: 20,
-  rangeDb: 80
-};
-var LIBRARY_DEFAULT_COLOR_MAP = "viridis";
+import {
+  SPECTROGRAM_DEFAULTS as LIBRARY_DEFAULTS,
+  DEFAULT_SPECTROGRAM_COLOR_MAP as LIBRARY_DEFAULT_COLOR_MAP
+} from "@waveform-playlist/core";
 var SpectrogramController = class {
   constructor(host, workerFactory) {
     this.orchestrator = null;
@@ -2807,7 +2817,21 @@ var SpectrogramController = class {
         const detail = e.detail;
         this.host.dispatchEvent(
           new CustomEvent("daw-spectrogram-ready", {
-            detail,
+            detail: { trackId: detail.trackId, generation: detail.generation },
+            bubbles: true,
+            composed: true
+          })
+        );
+      });
+      this.orchestrator.addEventListener("viewport-error", (e) => {
+        const detail = e.detail;
+        this.host.dispatchEvent(
+          new CustomEvent("daw-spectrogram-error", {
+            detail: {
+              trackId: detail.trackId,
+              generation: detail.generation,
+              error: detail.error
+            },
             bubbles: true,
             composed: true
           })
@@ -3446,6 +3470,108 @@ async function loadFiles(host, files) {
   return { loaded, failed };
 }
 
+// src/interactions/midi-loader.ts
+var INSTALL_HINT = "@dawcore/midi is required for loadMidi(). Install with: npm install @dawcore/midi";
+async function loadMidiImpl(host, source, options = {}) {
+  const startTime = options.startTime ?? 0;
+  if (!Number.isFinite(startTime) || startTime < 0) {
+    throw new RangeError(
+      "loadMidi: startTime must be a non-negative finite number (got " + String(options.startTime) + ")"
+    );
+  }
+  let midiModule;
+  try {
+    midiModule = await import("@dawcore/midi");
+  } catch (originalErr) {
+    console.warn("[dawcore] @dawcore/midi dynamic import failed: " + String(originalErr));
+    throw new Error(INSTALL_HINT);
+  }
+  const { parseMidiUrl, parseMidiFile } = midiModule;
+  let parsed;
+  if (typeof source === "string") {
+    parsed = await parseMidiUrl(source, void 0, options.signal);
+  } else {
+    let buffer;
+    try {
+      buffer = await source.arrayBuffer();
+    } catch (err) {
+      throw new Error(
+        'loadMidi: failed to read File "' + source.name + '" (' + source.size + " bytes): " + String(err)
+      );
+    }
+    parsed = parseMidiFile(buffer);
+  }
+  const childrenBefore = new Set(host.querySelectorAll("daw-track"));
+  const settlements = await Promise.allSettled(
+    parsed.tracks.map(
+      (t) => host.addTrack({
+        name: t.name,
+        renderMode: "piano-roll",
+        clips: [
+          {
+            midiNotes: t.notes,
+            midiChannel: t.channel,
+            midiProgram: t.programNumber,
+            start: startTime
+          }
+        ]
+      })
+    )
+  );
+  const succeeded = [];
+  const rejections = [];
+  for (const s of settlements) {
+    if (s.status === "fulfilled") {
+      succeeded.push(s.value);
+    } else {
+      rejections.push(s.reason);
+    }
+  }
+  if (rejections.length > 0) {
+    const appendedTracks = Array.from(host.querySelectorAll("daw-track")).filter(
+      (el) => !childrenBefore.has(el)
+    );
+    for (const el of appendedTracks) {
+      try {
+        el.remove();
+      } catch (cleanupErr) {
+        console.warn("[dawcore] loadMidi cleanup failed for a track: " + String(cleanupErr));
+      }
+    }
+    await Promise.resolve();
+    for (let i = 1; i < rejections.length; i++) {
+      console.warn(
+        "[dawcore] loadMidi: additional track failure (" + i + "): " + stringifyReason(rejections[i])
+      );
+    }
+    const first = rejections[0];
+    if (rejections.length > 1) {
+      const message = "loadMidi: " + rejections.length + " of " + settlements.length + " tracks failed; first: " + (first instanceof Error ? first.message : stringifyReason(first));
+      throw new Error(message);
+    }
+    throw first instanceof Error ? first : new Error(stringifyReason(first));
+  }
+  return {
+    trackIds: succeeded.map((el) => el.trackId),
+    bpm: parsed.bpm,
+    timeSignature: parsed.timeSignature,
+    duration: parsed.duration,
+    name: parsed.name
+  };
+}
+function stringifyReason(reason) {
+  if (reason === null) return "null";
+  if (reason === void 0) return "undefined";
+  if (typeof reason === "object") {
+    try {
+      return JSON.stringify(reason);
+    } catch {
+      return Object.prototype.toString.call(reason);
+    }
+  }
+  return String(reason);
+}
+
 // src/interactions/recording-clip.ts
 import { createClip as createClip2 } from "@waveform-playlist/core";
 function addRecordedClip(host, trackId, buf, startSample, durSamples, offsetSamples = 0) {
@@ -3784,7 +3910,10 @@ var DawEditorElement = class extends LitElement10 {
      * `_selectedTrackId`, etc.) — most of which don't affect the spectrogram
      * viewport. Skip the cross-controller call when nothing changed.
      *
-     * The orchestrator dedupes too, but this avoids the call entirely.
+     * The orchestrator dedupes identical viewports too, so removing this cache
+     * wouldn't change observable behavior — but it would push a fresh
+     * `setViewport` call (with object allocation) into every Lit reactive
+     * update for properties unrelated to the viewport.
      */
     this._lastSpectrogramViewport = null;
     // --- Track Events ---
@@ -4027,9 +4156,10 @@ var DawEditorElement = class extends LitElement10 {
     this._spectrogramController?.unregisterCanvas(canvasId);
   }
   /**
-   * Push a clip's decoded audio into the spectrogram controller. No-op
-   * unless the track is in spectrogram render-mode and the controller
-   * already exists (it bootstraps from canvas registration).
+   * Forward a clip's AudioBuffer to the spectrogram controller if the parent
+   * track is in spectrogram render-mode. Eagerly creates the controller via
+   * `_ensureSpectrogramController` so the audio data is queued for the first
+   * render — even if no canvases have been registered yet.
    */
   _maybeRegisterSpectrogramClipAudio(trackId, clip) {
     const descriptor = this._tracks.get(trackId);
@@ -5017,6 +5147,22 @@ var DawEditorElement = class extends LitElement10 {
   async loadFiles(files) {
     return loadFiles(this, files);
   }
+  /**
+   * Imperatively load a `.mid` file (URL or File) and create N `<daw-track>`
+   * elements — one per note-bearing MIDI track. On any per-track failure,
+   * every `<daw-track>` appended during the call is removed (both successful
+   * and failed) so the editor returns to its pre-call state.
+   *
+   * `options.signal` is forwarded to `fetch()` only for URL sources; aborting
+   * after parsing does not cancel in-flight `addTrack` calls.
+   *
+   * Requires the optional `@dawcore/midi` peer dep — throws with an install
+   * hint (and `console.warn`s the original error) when the dynamic import
+   * fails for any reason.
+   */
+  async loadMidi(source, options) {
+    return loadMidiImpl(this, source, options);
+  }
   // --- Programmatic Track API ---
   /**
    * Build the engine if it hasn't been built yet. Lets consumers obtain a
@@ -5130,6 +5276,13 @@ var DawEditorElement = class extends LitElement10 {
     }
     const oldDesc = this._tracks.get(trackId);
     if (!oldDesc) return;
+    let normalizedRenderMode = partial.renderMode;
+    if (normalizedRenderMode === "both") {
+      console.warn(
+        `[dawcore] render-mode="both" is not yet supported; falling back to 'spectrogram'`
+      );
+      normalizedRenderMode = "spectrogram";
+    }
     const newDesc = {
       ...oldDesc,
       ...partial.name !== void 0 && { name: partial.name },
@@ -5137,7 +5290,7 @@ var DawEditorElement = class extends LitElement10 {
       ...partial.pan !== void 0 && { pan: partial.pan },
       ...partial.muted !== void 0 && { muted: partial.muted },
       ...partial.soloed !== void 0 && { soloed: partial.soloed },
-      ...partial.renderMode !== void 0 && { renderMode: partial.renderMode }
+      ...normalizedRenderMode !== void 0 && { renderMode: normalizedRenderMode }
     };
     this._tracks = new Map(this._tracks).set(trackId, newDesc);
     if (this._engine) {
@@ -6434,6 +6587,7 @@ var DawSpectrogramElement = class extends LitElement14 {
     this.originX = 0;
     this._canvases = [];
     this._registeredCanvasIds = [];
+    this._warnedNoHost = false;
   }
   get samplesPerPixel() {
     return this._samplesPerPixel;
@@ -6500,7 +6654,15 @@ var DawSpectrogramElement = class extends LitElement14 {
   }
   _registerCanvases() {
     const editor = this._findHostEditor();
-    if (!editor || typeof editor._spectrogramRegisterCanvas !== "function") return;
+    if (!editor || typeof editor._spectrogramRegisterCanvas !== "function") {
+      if (!this._warnedNoHost) {
+        this._warnedNoHost = true;
+        console.warn(
+          "[dawcore] <daw-spectrogram> (clip " + this.clipId + ") could not find host <daw-editor>. Canvases will not render. Ensure the element is mounted inside a <daw-editor>."
+        );
+      }
+      return;
+    }
     for (let i = 0; i < this._canvases.length; i++) {
       const canvas = this._canvases[i];
       const canvasId = this.clipId + "-ch" + this.channelIndex + "-chunk" + i;