@dawcore/components 0.0.18 → 0.0.19

package/dist/index.mjs

@@ -3446,6 +3446,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) {
@@ -5017,6 +5119,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