smplr 0.8.0 → 0.8.1

package/dist/index.d.ts

@@ -94,6 +94,19 @@ type SampleStart = {
     stopId?: string | number;
     time?: number;
 } & SampleOptions;
+type SampleRegion = {
+    sampleName: string;
+    sampleCenter: number;
+    rangeMidi?: [number, number];
+    rangeVol?: [number, number];
+    offsetVol?: number;
+    offsetDetune?: number;
+    sample?: Partial<SampleOptions>;
+};
+type SampleLayer = {
+    regions: SampleRegion[];
+    sample: Partial<SampleOptions>;
+};
 
 declare function getDrumMachineNames(): string[];
 type DrumMachineConfig = ChannelOptions & SampleOptions & {
@@ -305,13 +318,14 @@ declare class Soundfont {
     readonly context: AudioContext;
     readonly config: Readonly<SoundfontConfig>;
     private readonly player;
-    readonly load: Promise<unknown>;
+    readonly load: Promise<this>;
+    readonly layer: SampleLayer;
     constructor(context: AudioContext, options: SoundfontOptions);
     get output(): OutputChannel;
-    loaded(): Promise<unknown>;
     get hasLoops(): boolean;
+    loaded(): Promise<this>;
     disconnect(): void;
-    start(sample: SampleStart): (time?: number | undefined) => void;
+    start(sample: SampleStart | string | number): (time?: number | undefined) => void;
     stop(sample?: SampleStop | string | number): void;
 }
 

package/dist/index.js

@@ -140,16 +140,6 @@ function toMidi(note) {
 function midiVelToGain(vel) {
   return vel * vel / 16129;
 }
-function findNearestMidi(midi, isAvailable) {
-  let i = 0;
-  while (isAvailable[midi + i] === void 0 && i < 128) {
-    if (i > 0)
-      i = -i;
-    else
-      i = -i + 1;
-  }
-  return i === 127 ? [midi, 0] : [midi + i, -i * 100];
-}
 
 // src/player/signals.ts
 function createControl(initialValue) {
@@ -1165,7 +1155,7 @@ var Mellotron = class {
   start(sample) {
     const found = findFirstSampleInLayer(
       this.layer,
-      typeof sample === "object" ? __spreadValues({}, sample) : { note: sample }
+      typeof sample === "object" ? sample : { note: sample }
     );
     if (!found)
       return () => void 0;
@@ -1366,8 +1356,8 @@ function gleitzKitUrl(name, kit) {
   const format = (_a = findFirstSupportedFormat(["ogg", "mp3"])) != null ? _a : "mp3";
   return `https://gleitz.github.io/midi-js-soundfonts/${kit}/${name}-${format}.js`;
 }
-function soundfontInstrumentLoader(url, storage) {
-  return (context, buffers) => __async(this, null, function* () {
+function soundfontInstrumentLoader(url, buffers, layer) {
+  return (context, storage) => __async(this, null, function* () {
     const sourceFile = yield (yield storage.fetch(url)).text();
     const json = midiJsToJson(sourceFile);
     const noteNames = Object.keys(json);
@@ -1380,9 +1370,14 @@ function soundfontInstrumentLoader(url, storage) {
           removeBase64Prefix(json[noteName])
         );
         const buffer = yield context.decodeAudioData(audioData);
-        buffers[midi] = buffer;
+        buffers[noteName] = buffer;
+        layer.regions.push({
+          sampleName: noteName,
+          sampleCenter: midi
+        });
       }))
     );
+    spreadRegions(layer.regions);
   });
 }
 function midiJsToJson(source) {
@@ -1545,26 +1540,25 @@ function getGoldstSoundfontLoopsUrl(instrument, kit) {
 }
 function fetchSoundfontLoopData(url) {
   return __async(this, null, function* () {
+    if (!url)
+      return void 0;
     try {
       const req = yield fetch(url);
       if (req.status !== 200)
-        return { status: "error", code: req.status };
+        return;
       const raw = yield req.json();
-      const loopData = { status: "loaded", data: {} };
+      const loopData = {};
       const sampleRate = 41e3;
       Object.keys(raw).forEach((key) => {
         const midi = toMidi(key);
         if (midi) {
           const offsets = raw[key];
-          loopData.data[midi] = [
-            offsets[0] / sampleRate,
-            offsets[1] / sampleRate
-          ];
+          loopData[midi] = [offsets[0] / sampleRate, offsets[1] / sampleRate];
         }
       });
       return loopData;
     } catch (err) {
-      return { status: "error", code: 0 };
+      return void 0;
     }
   });
 }
@@ -1576,64 +1570,79 @@ function getSoundfontKits() {
 function getSoundfontNames() {
   return SOUNDFONT_INSTRUMENTS;
 }
-var _loops;
+var _hasLoops;
 var Soundfont = class {
   constructor(context, options) {
     this.context = context;
-    __privateAdd(this, _loops, void 0);
+    __privateAdd(this, _hasLoops, void 0);
     this.config = getSoundfontConfig(options);
     this.player = new DefaultPlayer(context, options);
-    const loader = soundfontInstrumentLoader(
+    this.layer = createEmptySampleLayer();
+    __privateSet(this, _hasLoops, false);
+    const loader = soundfontLoader(
       this.config.instrumentUrl,
-      this.config.storage
+      this.config.loopDataUrl,
+      this.player.buffers,
+      this.layer
     );
-    this.load = loader(context, this.player.buffers).then(() => this);
-    __privateSet(this, _loops, { status: "not-loaded" });
-    if (this.config.loopDataUrl) {
-      __privateSet(this, _loops, { status: "loading" });
-      this.load = Promise.all([
-        this.load,
-        fetchSoundfontLoopData(this.config.loopDataUrl).then((loopData) => {
-          __privateSet(this, _loops, loopData);
-        })
-      ]).then(() => this);
-    }
+    this.load = loader(context, this.config.storage).then((hasLoops) => {
+      __privateSet(this, _hasLoops, hasLoops);
+      return this;
+    });
     const gain = new GainNode(context, { gain: this.config.extraGain });
     this.player.output.addInsert(gain);
   }
   get output() {
     return this.player.output;
   }
+  get hasLoops() {
+    return __privateGet(this, _hasLoops);
+  }
   loaded() {
     return __async(this, null, function* () {
       console.warn("deprecated: use load instead");
       return this.load;
     });
   }
-  get hasLoops() {
-    return __privateGet(this, _loops).status === "loaded";
-  }
   disconnect() {
-    console.log("disconnecting");
     this.player.disconnect();
   }
   start(sample) {
-    const midi = toMidi(sample.note);
-    const [note, detune] = midi === void 0 ? ["", 0] : findNearestMidi(midi, this.player.buffers);
-    const loop = typeof midi === "number" && __privateGet(this, _loops).status === "loaded" ? __privateGet(this, _loops).data[midi] : void 0;
-    return this.player.start(__spreadProps(__spreadValues({}, sample), {
-      note,
-      detune,
-      loop: loop !== void 0,
-      loopStart: loop == null ? void 0 : loop[0],
-      loopEnd: loop == null ? void 0 : loop[1]
-    }));
+    const found = findFirstSampleInLayer(
+      this.layer,
+      typeof sample === "object" ? sample : { note: sample }
+    );
+    if (!found)
+      return () => void 0;
+    return this.player.start(found);
   }
   stop(sample) {
     return this.player.stop(sample);
   }
 };
-_loops = new WeakMap();
+_hasLoops = new WeakMap();
+function soundfontLoader(url, loopsUrl, buffers, layer) {
+  const loadInstrument = soundfontInstrumentLoader(url, buffers, layer);
+  return (context, storage) => __async(this, null, function* () {
+    const [_, loops] = yield Promise.all([
+      loadInstrument(context, storage),
+      fetchSoundfontLoopData(loopsUrl)
+    ]);
+    if (loops) {
+      layer.regions.forEach((region) => {
+        var _a;
+        const loop = loops[region.sampleCenter];
+        if (loop) {
+          (_a = region.sample) != null ? _a : region.sample = {};
+          region.sample.loop = true;
+          region.sample.loopStart = loop[0];
+          region.sample.loopEnd = loop[1];
+        }
+      });
+    }
+    return !!loops;
+  });
+}
 function getSoundfontConfig(options) {
   var _a, _b, _c, _d;
   if (!options.instrument && !options.instrumentUrl) {