@opendaw/studio-core 0.0.7 → 0.0.9

package/dist/Modifier.js

@@ -0,0 +1,168 @@
+import { assert, Option, panic, UUID } from "@opendaw/lib-std";
+import { PPQN } from "@opendaw/lib-dsp";
+import { AudioUnitType } from "@opendaw/studio-enums";
+import { AudioBusBox, AudioUnitBox, NoteClipBox, NoteEventCollectionBox, NoteRegionBox, TrackBox, ValueClipBox, ValueEventCollectionBox, ValueRegionBox } from "@opendaw/studio-boxes";
+import { IconSymbol, TrackType } from "@opendaw/studio-adapters";
+import { ColorCodes } from "./ColorCodes";
+export var Modifier;
+(function (Modifier) {
+    const AudioUnitOrdering = {
+        [AudioUnitType.Instrument]: 0,
+        [AudioUnitType.Aux]: 1,
+        [AudioUnitType.Bus]: 2,
+        [AudioUnitType.Output]: 3
+    };
+    Modifier.createAudioUnit = ({ boxGraph, rootBox, rootBoxAdapter, masterBusBox }, type, index) => {
+        const insertIndex = index ?? Modifier.pushAudioUnitsIndices(rootBoxAdapter, type, 1);
+        console.debug(`createAudioUnit type: ${type}, insertIndex: ${insertIndex}`);
+        return AudioUnitBox.create(boxGraph, UUID.generate(), box => {
+            box.collection.refer(rootBox.audioUnits);
+            box.output.refer(masterBusBox.input);
+            box.index.setValue(insertIndex);
+            box.type.setValue(type);
+        });
+    };
+    Modifier.pushAudioUnitsIndices = (rootBoxAdapter, type, count = 1) => {
+        const adapters = rootBoxAdapter.audioUnits.adapters();
+        const order = AudioUnitOrdering[type];
+        let index = 0 | 0;
+        for (; index < adapters.length; index++) {
+            if (AudioUnitOrdering[adapters[index].type] > order) {
+                break;
+            }
+        }
+        const insertIndex = index;
+        while (index < adapters.length) {
+            adapters[index].indexField.setValue(count + index++);
+        }
+        return insertIndex;
+    };
+    Modifier.deleteAudioUnit = ({ rootBoxAdapter }, adapter) => {
+        const adapters = rootBoxAdapter.audioUnits.adapters();
+        const boxIndex = adapter.indexField.getValue();
+        const deleteIndex = adapters.indexOf(adapter);
+        console.debug(`deleteAudioUnit adapter: ${adapter.toString()}, deleteIndex: ${deleteIndex}, indexField: ${boxIndex}`);
+        if (deleteIndex === -1) {
+            return panic(`Cannot delete ${adapter}. Does not exist.`);
+        }
+        if (deleteIndex !== boxIndex) {
+            console.debug("indices", adapters.map(x => x.box.index.getValue()).join(", "));
+            return panic(`Cannot delete ${adapter}. Wrong index.`);
+        }
+        for (let index = deleteIndex + 1; index < adapters.length; index++) {
+            adapters[index].indexField.setValue(index - 1);
+        }
+        adapter.box.delete();
+    };
+    Modifier.createAudioBus = (project, name, icon, type, color) => {
+        console.debug(`createAudioBus '${name}', type: ${type}, color: ${color}`);
+        const { rootBox, boxGraph } = project;
+        assert(rootBox.audioBusses.isAttached(), "rootBox not attached");
+        const uuid = UUID.generate();
+        const audioBusBox = AudioBusBox.create(boxGraph, uuid, box => {
+            box.collection.refer(rootBox.audioBusses);
+            box.label.setValue(name);
+            box.icon.setValue(IconSymbol.toName(icon));
+            box.color.setValue(color);
+        });
+        const audioUnitBox = Modifier.createAudioUnit(project, type);
+        TrackBox.create(boxGraph, UUID.generate(), box => {
+            box.tracks.refer(audioUnitBox.tracks);
+            box.target.refer(audioUnitBox);
+            box.index.setValue(0);
+            box.type.setValue(TrackType.Undefined);
+        });
+        audioBusBox.output.refer(audioUnitBox.input);
+        return audioBusBox;
+    };
+    Modifier.createEffect = (project, host, entry, newIndex) => {
+        let chain;
+        let field;
+        if (entry.type === "audio") {
+            chain = host.audioEffects.adapters();
+            field = host.audioEffects.field();
+        }
+        else if (entry.type === "midi") {
+            chain = host.midiEffects.adapters();
+            field = host.midiEffects.field();
+        }
+        else {
+            return panic(`Unknown factory type: ${entry.type}`);
+        }
+        return project.editing.modify(() => {
+            const box = entry.create(project, field, newIndex);
+            for (let index = newIndex; index < chain.length; index++) {
+                chain[index].indexField.setValue(index + 1);
+            }
+            return box;
+        });
+    };
+    Modifier.createClip = (clips, clipIndex, { name } = {}) => {
+        if (clips.collection.getAdapterByIndex(clipIndex).nonEmpty()) {
+            console.warn("Cannot create Clip on occupied cell.");
+            return Option.None;
+        }
+        const graph = clips.trackBoxAdapter.box.graph;
+        const type = clips.trackBoxAdapter.type;
+        switch (type) {
+            case TrackType.Notes: {
+                const events = NoteEventCollectionBox.create(graph, UUID.generate());
+                return Option.wrap(NoteClipBox.create(graph, UUID.generate(), box => {
+                    box.index.setValue(clipIndex);
+                    box.label.setValue(name ?? "Notes");
+                    box.hue.setValue(ColorCodes.forTrackType(type));
+                    box.mute.setValue(false);
+                    box.duration.setValue(PPQN.Bar);
+                    box.clips.refer(clips.trackBoxAdapter.box.clips);
+                    box.events.refer(events.owners);
+                }));
+            }
+            case TrackType.Value: {
+                const events = ValueEventCollectionBox.create(graph, UUID.generate());
+                return Option.wrap(ValueClipBox.create(graph, UUID.generate(), box => {
+                    box.index.setValue(clipIndex);
+                    box.label.setValue(name ?? "CV");
+                    box.hue.setValue(ColorCodes.forTrackType(type));
+                    box.mute.setValue(false);
+                    box.duration.setValue(PPQN.Bar);
+                    box.events.refer(events.owners);
+                    box.clips.refer(clips.trackBoxAdapter.box.clips);
+                }));
+            }
+        }
+        return Option.None;
+    };
+    Modifier.createRegion = (regions, position, duration, { name } = {}) => {
+        const graph = regions.trackBoxAdapter.box.graph;
+        const type = regions.trackBoxAdapter.type;
+        switch (type) {
+            case TrackType.Notes: {
+                const events = NoteEventCollectionBox.create(graph, UUID.generate());
+                return Option.wrap(NoteRegionBox.create(graph, UUID.generate(), box => {
+                    box.position.setValue(Math.max(position, 0));
+                    box.label.setValue(name ?? "Notes");
+                    box.hue.setValue(ColorCodes.forTrackType(type));
+                    box.mute.setValue(false);
+                    box.duration.setValue(duration);
+                    box.loopDuration.setValue(PPQN.Bar);
+                    box.events.refer(events.owners);
+                    box.regions.refer(regions.trackBoxAdapter.box.regions);
+                }));
+            }
+            case TrackType.Value: {
+                const events = ValueEventCollectionBox.create(graph, UUID.generate());
+                return Option.wrap(ValueRegionBox.create(graph, UUID.generate(), box => {
+                    box.position.setValue(Math.max(position, 0));
+                    box.label.setValue(name ?? "Automation");
+                    box.hue.setValue(ColorCodes.forTrackType(type));
+                    box.mute.setValue(false);
+                    box.duration.setValue(duration);
+                    box.loopDuration.setValue(PPQN.Bar);
+                    box.events.refer(events.owners);
+                    box.regions.refer(regions.trackBoxAdapter.box.regions);
+                }));
+            }
+        }
+        return Option.None;
+    };
+})(Modifier || (Modifier = {}));

package/dist/RecordingWorklet.d.ts

@@ -1,9 +1,6 @@
-import { int } from "@opendaw/lib-std";
-import { WorkletFactory } from "./WorkletFactory";
+import { RingBuffer } from "@opendaw/studio-adapters";
 export declare class RecordingWorklet extends AudioWorkletNode {
     #private;
-    static bootFactory(context: BaseAudioContext, url: string): Promise<WorkletFactory<RecordingWorklet>>;
-    static create(factory: WorkletFactory<RecordingWorklet>, numChannels: int, numChunks?: int): RecordingWorklet;
-    private constructor();
+    constructor(context: BaseAudioContext, config: RingBuffer.Config);
 }
 //# sourceMappingURL=RecordingWorklet.d.ts.map

package/dist/RecordingWorklet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RecordingWorklet.d.ts","sourceRoot":"","sources":["../src/RecordingWorklet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,GAAG,EAAC,MAAM,kBAAkB,CAAA;AAG/C,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAK/C,qBAAa,gBAAiB,SAAQ,gBAAgB;;WACrC,WAAW,CAAC,OAAO,EAAE,gBAAgB,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,gBAAgB,CAAC,CAAC;IAI3G,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,cAAc,CAAC,gBAAgB,CAAC,EAAE,WAAW,EAAE,GAAG,EAAE,SAAS,GAAE,GAAQ,GAAG,gBAAgB;IAUjH,OAAO;CAuBV"}
+{"version":3,"file":"RecordingWorklet.d.ts","sourceRoot":"","sources":["../src/RecordingWorklet.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,UAAU,EAAC,MAAM,0BAA0B,CAAA;AAIrE,qBAAa,gBAAiB,SAAQ,gBAAgB;;gBAGtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM;CAuBnE"}

package/dist/RecordingWorklet.js

@@ -1,25 +1,14 @@
 import { EmptyExec } from "@opendaw/lib-std";
 import { Files } from "@opendaw/lib-dom";
 import { mergeChunkPlanes, RingBuffer } from "@opendaw/studio-adapters";
-import { WorkletFactory } from "./WorkletFactory";
 import { encodeWavFloat } from "./Wav";
-const RenderQuantum = 128;
+import { RenderQuantum } from "./RenderQuantum";
 export class RecordingWorklet extends AudioWorkletNode {
-    static async bootFactory(context, url) {
-        return WorkletFactory.boot(context, url);
-    }
-    static create(factory, numChannels, numChunks = 64) {
-        const audioBytes = numChannels * numChunks * RenderQuantum * Float32Array.BYTES_PER_ELEMENT;
-        const pointerBytes = Int32Array.BYTES_PER_ELEMENT * 2;
-        const sab = new SharedArrayBuffer(audioBytes + pointerBytes);
-        const buffer = { sab, numChunks, numChannels, bufferSize: RenderQuantum };
-        return factory.create(context => new RecordingWorklet(context, buffer));
-    }
     #reader;
     constructor(context, config) {
         super(context, "recording-processor", {
             numberOfInputs: 1,
-            channelCount: config.numChannels,
+            channelCount: config.numberOfChannels,
             channelCountMode: "explicit",
             processorOptions: config
         });

package/dist/RenderQuantum.d.ts

@@ -0,0 +1,2 @@
+export declare const RenderQuantum = 128;
+//# sourceMappingURL=RenderQuantum.d.ts.map

package/dist/RenderQuantum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RenderQuantum.d.ts","sourceRoot":"","sources":["../src/RenderQuantum.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,MAAM,CAAA"}

package/dist/RenderQuantum.js

@@ -0,0 +1 @@
+export const RenderQuantum = 128;

package/dist/Worklets.d.ts

@@ -1,20 +1,14 @@
 import { int } from "@opendaw/lib-std";
 import { ExportStemsConfiguration } from "@opendaw/studio-adapters";
-import { WorkletFactory } from "./WorkletFactory";
 import { EngineWorklet } from "./EngineWorklet";
 import { MeterWorklet } from "./MeterWorklet";
 import { RecordingWorklet } from "./RecordingWorklet";
 import { Project } from "./Project";
-export type WorkletUrls = {
-    meter: string;
-    engine: string;
-    recording: string;
-};
 export declare class Worklets {
     #private;
-    static install(context: AudioContext, { engine, meter, recording }: WorkletUrls): Promise<Worklets>;
-    static get(context: AudioContext): Worklets;
-    constructor(engine: WorkletFactory<EngineWorklet>, meter: WorkletFactory<MeterWorklet>, recording: WorkletFactory<RecordingWorklet>);
+    static install(context: BaseAudioContext, workletURL: string): Promise<Worklets>;
+    static get(context: BaseAudioContext): Worklets;
+    constructor(context: BaseAudioContext);
     createMeter(numberOfChannels: int): MeterWorklet;
     createEngine(project: Project, exportConfiguration?: ExportStemsConfiguration): EngineWorklet;
     createRecording(numberOfChannels: int, numChunks: int): RecordingWorklet;

package/dist/Worklets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Worklets.d.ts","sourceRoot":"","sources":["../src/Worklets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,GAAG,EAAC,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAC,wBAAwB,EAAC,MAAM,0BAA0B,CAAA;AACjE,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAA;AAC7C,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAA;AAC3C,OAAO,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAA;AACnD,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAEjC,MAAM,MAAM,WAAW,GAAG;IACtB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,qBAAa,QAAQ;;WACJ,OAAO,CAAC,OAAO,EAAE,YAAY,EAAE,EAAC,MAAM,EAAE,KAAK,EAAE,SAAS,EAAC,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAYvG,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,YAAY,GAAG,QAAQ;gBAQ/B,MAAM,EAAE,cAAc,CAAC,aAAa,CAAC,EACrC,KAAK,EAAE,cAAc,CAAC,YAAY,CAAC,EACnC,SAAS,EAAE,cAAc,CAAC,gBAAgB,CAAC;IAMvD,WAAW,CAAC,gBAAgB,EAAE,GAAG,GAAG,YAAY;IAIhD,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,mBAAmB,CAAC,EAAE,wBAAwB,GAAG,aAAa;IAI7F,eAAe,CAAC,gBAAgB,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,GAAG,gBAAgB;CAG3E"}
+{"version":3,"file":"Worklets.d.ts","sourceRoot":"","sources":["../src/Worklets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,GAAG,EAAC,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAC,wBAAwB,EAAa,MAAM,0BAA0B,CAAA;AAC7E,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAA;AAC7C,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAA;AAC3C,OAAO,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAA;AACnD,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAGjC,qBAAa,QAAQ;;WACJ,OAAO,CAAC,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAQtF,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,gBAAgB,GAAG,QAAQ;gBAMnC,OAAO,EAAE,gBAAgB;IAErC,WAAW,CAAC,gBAAgB,EAAE,GAAG,GAAG,YAAY;IAIhD,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,mBAAmB,CAAC,EAAE,wBAAwB,GAAG,aAAa;IAI7F,eAAe,CAAC,gBAAgB,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,GAAG,gBAAgB;CAO3E"}

package/dist/Worklets.js

@@ -2,35 +2,30 @@ import { asDefined } from "@opendaw/lib-std";
 import { EngineWorklet } from "./EngineWorklet";
 import { MeterWorklet } from "./MeterWorklet";
 import { RecordingWorklet } from "./RecordingWorklet";
+import { RenderQuantum } from "./RenderQuantum";
 export class Worklets {
-    static async install(context, { engine, meter, recording }) {
-        return Promise.all([
-            EngineWorklet.bootFactory(context, engine),
-            MeterWorklet.bootFactory(context, meter),
-            RecordingWorklet.bootFactory(context, recording)
-        ]).then(([engine, meter, recording]) => {
-            const worklets = new Worklets(engine, meter, recording);
+    static async install(context, workletURL) {
+        return context.audioWorklet.addModule(workletURL).then(() => {
+            const worklets = new Worklets(context);
             this.#map.set(context, worklets);
             return worklets;
         });
     }
     static get(context) { return asDefined(this.#map.get(context), "Worklets not installed"); }
     static #map = new WeakMap();
-    #meter;
-    #engine;
-    #recording;
-    constructor(engine, meter, recording) {
-        this.#meter = meter;
-        this.#engine = engine;
-        this.#recording = recording;
-    }
+    #context;
+    constructor(context) { this.#context = context; }
     createMeter(numberOfChannels) {
-        return MeterWorklet.create(this.#meter, numberOfChannels);
+        return new MeterWorklet(this.#context, numberOfChannels);
     }
     createEngine(project, exportConfiguration) {
-        return this.#engine.create(context => new EngineWorklet(context, project, exportConfiguration));
+        return new EngineWorklet(this.#context, project, exportConfiguration);
     }
     createRecording(numberOfChannels, numChunks) {
-        return RecordingWorklet.create(this.#recording, numberOfChannels, numChunks);
+        const audioBytes = numberOfChannels * numChunks * RenderQuantum * Float32Array.BYTES_PER_ELEMENT;
+        const pointerBytes = Int32Array.BYTES_PER_ELEMENT * 2;
+        const sab = new SharedArrayBuffer(audioBytes + pointerBytes);
+        const buffer = { sab, numChunks, numberOfChannels, bufferSize: RenderQuantum };
+        return new RecordingWorklet(this.#context, buffer);
     }
 }

package/dist/index.d.ts

@@ -6,14 +6,17 @@ export * from "./samples/SampleStorage";
 export * from "./samples/MainThreadSampleLoader";
 export * from "./samples/MainThreadSampleManager";
 export * from "./samples/SampleProvider";
+export * from "./ColorCodes";
+export * from "./Colors";
+export * from "./Effects";
 export * from "./Engine";
 export * from "./EngineFacade";
 export * from "./EngineWorklet";
 export * from "./Mixer";
+export * from "./Modifier";
 export * from "./Project";
 export * from "./ProjectEnv";
 export * from "./Wav";
 export * from "./WorkerAgents";
-export * from "./WorkletFactory";
 export * from "./Worklets";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA;AAExC,cAAc,uBAAuB,CAAA;AACrC,cAAc,yBAAyB,CAAA;AACvC,cAAc,kCAAkC,CAAA;AAChD,cAAc,mCAAmC,CAAA;AACjD,cAAc,0BAA0B,CAAA;AAExC,cAAc,UAAU,CAAA;AACxB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,SAAS,CAAA;AACvB,cAAc,WAAW,CAAA;AACzB,cAAc,cAAc,CAAA;AAC5B,cAAc,OAAO,CAAA;AACrB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,kBAAkB,CAAA;AAChC,cAAc,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA;AAExC,cAAc,uBAAuB,CAAA;AACrC,cAAc,yBAAyB,CAAA;AACvC,cAAc,kCAAkC,CAAA;AAChD,cAAc,mCAAmC,CAAA;AACjD,cAAc,0BAA0B,CAAA;AAExC,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,WAAW,CAAA;AACzB,cAAc,UAAU,CAAA;AACxB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,SAAS,CAAA;AACvB,cAAc,YAAY,CAAA;AAC1B,cAAc,WAAW,CAAA;AACzB,cAAc,cAAc,CAAA;AAC5B,cAAc,OAAO,CAAA;AACrB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,YAAY,CAAA"}

package/dist/index.js

@@ -6,13 +6,16 @@ export * from "./samples/SampleStorage";
 export * from "./samples/MainThreadSampleLoader";
 export * from "./samples/MainThreadSampleManager";
 export * from "./samples/SampleProvider";
+export * from "./ColorCodes";
+export * from "./Colors";
+export * from "./Effects";
 export * from "./Engine";
 export * from "./EngineFacade";
 export * from "./EngineWorklet";
 export * from "./Mixer";
+export * from "./Modifier";
 export * from "./Project";
 export * from "./ProjectEnv";
 export * from "./Wav";
 export * from "./WorkerAgents";
-export * from "./WorkletFactory";
 export * from "./Worklets";