@opendaw/studio-core 0.0.10 → 0.0.12

package/dist/ProjectApi.js

@@ -0,0 +1,217 @@
+import { assert, Option, panic, Strings, UUID } from "@opendaw/lib-std";
+import { AudioUnitType } from "@opendaw/studio-enums";
+import { AudioBusBox, AudioUnitBox, NoteClipBox, NoteEventBox, NoteEventCollectionBox, NoteRegionBox, TrackBox, ValueClipBox, ValueEventCollectionBox, ValueRegionBox } from "@opendaw/studio-boxes";
+import { AudioUnitBoxAdapter, IconSymbol, NoteEventBoxAdapter, TrackType } from "@opendaw/studio-adapters";
+import { ColorCodes } from "./ColorCodes";
+import { PPQN } from "@opendaw/lib-dsp";
+export class ProjectApi {
+    static AudioUnitOrdering = {
+        [AudioUnitType.Instrument]: 0,
+        [AudioUnitType.Aux]: 1,
+        [AudioUnitType.Bus]: 2,
+        [AudioUnitType.Output]: 3
+    };
+    #project;
+    constructor(project) { this.#project = project; }
+    createInstrument({ create, defaultIcon, defaultName, trackType }, { name, icon, index } = {}) {
+        const { boxGraph, boxAdapters, rootBoxAdapter, userEditingManager } = this.#project;
+        const existingNames = rootBoxAdapter.audioUnits.adapters()
+            .map(adapter => adapter.input.getValue().match({
+            none: () => "Untitled",
+            some: adapter => adapter.labelField.getValue()
+        }));
+        const audioUnitBox = this.#createAudioUnit(AudioUnitType.Instrument, index);
+        const audioUnitBoxAdapter = boxAdapters.adapterFor(audioUnitBox, AudioUnitBoxAdapter);
+        const uniqueName = Strings.getUniqueName(existingNames, name ?? defaultName);
+        const iconSymbol = icon ?? defaultIcon;
+        const instrumentBox = create(boxGraph, audioUnitBoxAdapter, uniqueName, iconSymbol);
+        const trackBox = TrackBox.create(boxGraph, UUID.generate(), box => {
+            box.index.setValue(0);
+            box.type.setValue(trackType);
+            box.tracks.refer(audioUnitBoxAdapter.tracksField);
+            box.target.refer(audioUnitBoxAdapter.audioUnitBoxAdapter().box);
+        });
+        userEditingManager.audioUnit.edit(audioUnitBox.editing);
+        return { audioUnitBox, instrumentBox, trackBox };
+    }
+    createEffect(host, factory, newIndex) {
+        let chain;
+        let field;
+        if (factory.type === "audio") {
+            chain = host.audioEffects.adapters();
+            field = host.audioEffects.field();
+        }
+        else if (factory.type === "midi") {
+            chain = host.midiEffects.adapters();
+            field = host.midiEffects.field();
+        }
+        else {
+            return panic(`Unknown factory type: ${factory.type}`);
+        }
+        const box = factory.create(this.#project, field, newIndex);
+        for (let index = newIndex; index < chain.length; index++) {
+            chain[index].indexField.setValue(index + 1);
+        }
+        return box;
+    }
+    createAudioBus(name, icon, type, color) {
+        console.debug(`createAudioBus '${name}', type: ${type}, color: ${color}`);
+        const { rootBox, boxGraph } = this.#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 = this.#createAudioUnit(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;
+    }
+    createNoteTrack(adapter, index = 0) {
+        return this.#createTrack(adapter, TrackType.Notes, index);
+    }
+    createAudioTrack(adapter, index = 0) {
+        return this.#createTrack(adapter, TrackType.Audio, index);
+    }
+    createAutomationTrack(adapter, index = 0) {
+        return this.#createTrack(adapter, TrackType.Value, index);
+    }
+    createClip(trackBox, clipIndex, { name, hue } = {}) {
+        const { boxGraph } = this.#project;
+        const type = trackBox.type.getValue();
+        switch (type) {
+            case TrackType.Notes: {
+                const events = NoteEventCollectionBox.create(boxGraph, UUID.generate());
+                return Option.wrap(NoteClipBox.create(boxGraph, UUID.generate(), box => {
+                    box.index.setValue(clipIndex);
+                    box.label.setValue(name ?? "Notes");
+                    box.hue.setValue(hue ?? ColorCodes.forTrackType(type));
+                    box.mute.setValue(false);
+                    box.duration.setValue(PPQN.Bar);
+                    box.clips.refer(trackBox.clips);
+                    box.events.refer(events.owners);
+                }));
+            }
+            case TrackType.Value: {
+                const events = ValueEventCollectionBox.create(boxGraph, UUID.generate());
+                return Option.wrap(ValueClipBox.create(boxGraph, UUID.generate(), box => {
+                    box.index.setValue(clipIndex);
+                    box.label.setValue(name ?? "CV");
+                    box.hue.setValue(hue ?? ColorCodes.forTrackType(type));
+                    box.mute.setValue(false);
+                    box.duration.setValue(PPQN.Bar);
+                    box.events.refer(events.owners);
+                    box.clips.refer(trackBox.clips);
+                }));
+            }
+        }
+        return Option.None;
+    }
+    createRegion(trackBox, position, duration, { name, hue } = {}) {
+        const { boxGraph } = this.#project;
+        const type = trackBox.type.getValue();
+        switch (type) {
+            case TrackType.Notes: {
+                const events = NoteEventCollectionBox.create(boxGraph, UUID.generate());
+                return Option.wrap(NoteRegionBox.create(boxGraph, UUID.generate(), box => {
+                    box.position.setValue(Math.max(position, 0));
+                    box.label.setValue(name ?? "Notes");
+                    box.hue.setValue(hue ?? ColorCodes.forTrackType(type));
+                    box.mute.setValue(false);
+                    box.duration.setValue(duration);
+                    box.loopDuration.setValue(PPQN.Bar);
+                    box.events.refer(events.owners);
+                    box.regions.refer(trackBox.regions);
+                }));
+            }
+            case TrackType.Value: {
+                const events = ValueEventCollectionBox.create(boxGraph, UUID.generate());
+                return Option.wrap(ValueRegionBox.create(boxGraph, UUID.generate(), box => {
+                    box.position.setValue(Math.max(position, 0));
+                    box.label.setValue(name ?? "Automation");
+                    box.hue.setValue(hue ?? ColorCodes.forTrackType(type));
+                    box.mute.setValue(false);
+                    box.duration.setValue(duration);
+                    box.loopDuration.setValue(PPQN.Bar);
+                    box.events.refer(events.owners);
+                    box.regions.refer(trackBox.regions);
+                }));
+            }
+        }
+        return Option.None;
+    }
+    createNoteEvent({ owner, position, duration, velocity, pitch, chance, cent }) {
+        const { boxAdapters, boxGraph } = this.#project;
+        return boxAdapters.adapterFor(NoteEventBox.create(boxGraph, UUID.generate(), box => {
+            box.position.setValue(position);
+            box.duration.setValue(duration);
+            box.velocity.setValue(velocity ?? 1.0);
+            box.pitch.setValue(pitch);
+            box.chance.setValue(chance ?? 100.0);
+            box.cent.setValue(cent ?? 0.0);
+            box.events.refer(owner.events.targetVertex
+                .unwrap("Owner has no event-collection").box
+                .asBox(NoteEventCollectionBox).events);
+        }), NoteEventBoxAdapter);
+    }
+    deleteAudioUnit(adapter) {
+        const { rootBoxAdapter } = this.#project;
+        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();
+    }
+    #createAudioUnit(type, index) {
+        const { boxGraph, rootBox, rootBoxAdapter, masterBusBox } = this.#project;
+        const insertIndex = index ?? this.#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);
+        });
+    }
+    #createTrack(adapter, trackType, index = 0) {
+        return TrackBox.create(this.#project.boxGraph, UUID.generate(), box => {
+            box.index.setValue(index);
+            box.type.setValue(trackType);
+            box.tracks.refer(adapter.tracksField);
+            box.target.refer(adapter.audioUnitBoxAdapter().box);
+        });
+    }
+    #pushAudioUnitsIndices(rootBoxAdapter, type, count = 1) {
+        const adapters = rootBoxAdapter.audioUnits.adapters();
+        const order = ProjectApi.AudioUnitOrdering[type];
+        let index = 0 | 0;
+        for (; index < adapters.length; index++) {
+            if (ProjectApi.AudioUnitOrdering[adapters[index].type] > order) {
+                break;
+            }
+        }
+        const insertIndex = index;
+        while (index < adapters.length) {
+            adapters[index].indexField.setValue(count + index++);
+        }
+        return insertIndex;
+    }
+}

package/dist/ProjectMigration.d.ts

@@ -0,0 +1,5 @@
+import { ProjectDecoder } from "@opendaw/studio-adapters";
+export declare class ProjectMigration {
+    static migrate({ boxGraph, mandatoryBoxes }: ProjectDecoder.Skeleton): void;
+}
+//# sourceMappingURL=ProjectMigration.d.ts.map

package/dist/ProjectMigration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProjectMigration.d.ts","sourceRoot":"","sources":["../src/ProjectMigration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAC,MAAM,0BAA0B,CAAA;AAUvD,qBAAa,gBAAgB;IACzB,MAAM,CAAC,OAAO,CAAC,EAAC,QAAQ,EAAE,cAAc,EAAC,EAAE,cAAc,CAAC,QAAQ,GAAG,IAAI;CAoD5E"}

package/dist/ProjectMigration.js

@@ -0,0 +1,60 @@
+import { GrooveShuffleBox, ValueEventCurveBox } from "@opendaw/studio-boxes";
+import { asInstanceOf, UUID } from "@opendaw/lib-std";
+export class ProjectMigration {
+    static migrate({ boxGraph, mandatoryBoxes }) {
+        const { rootBox } = mandatoryBoxes;
+        if (rootBox.groove.targetAddress.isEmpty()) {
+            console.debug("Migrate to global GrooveShuffleBox");
+            boxGraph.beginTransaction();
+            rootBox.groove.refer(GrooveShuffleBox.create(boxGraph, UUID.generate()));
+            boxGraph.endTransaction();
+        }
+        const globalShuffle = asInstanceOf(rootBox.groove.targetVertex.unwrap(), GrooveShuffleBox).label;
+        if (globalShuffle.getValue() !== "Groove Shuffle") {
+            boxGraph.beginTransaction();
+            globalShuffle.setValue("Groove Shuffle");
+            boxGraph.endTransaction();
+        }
+        // TODO We can remove this when we delete all not-migrated, local(!) project files from my machine
+        boxGraph.boxes().forEach(box => box.accept({
+            visitZeitgeistDeviceBox: (box) => {
+                if (box.groove.targetAddress.isEmpty()) {
+                    console.debug("Migrate 'ZeitgeistDeviceBox' to GrooveShuffleBox");
+                    boxGraph.beginTransaction();
+                    box.groove.refer(rootBox.groove.targetVertex.unwrap());
+                    boxGraph.endTransaction();
+                }
+            },
+            visitValueEventBox: (eventBox) => {
+                const slope = eventBox.slope.getValue();
+                if (isNaN(slope)) {
+                    return;
+                } // already migrated, nothing to do
+                if (slope === 0.0) { // never set
+                    console.debug("Migrate 'ValueEventBox'");
+                    boxGraph.beginTransaction();
+                    eventBox.slope.setValue(NaN);
+                    boxGraph.endTransaction();
+                }
+                else if (eventBox.interpolation.getValue() === 1) { // linear
+                    if (slope === 0.5) {
+                        console.debug("Migrate 'ValueEventBox' to linear");
+                        boxGraph.beginTransaction();
+                        eventBox.slope.setValue(NaN);
+                        boxGraph.endTransaction();
+                    }
+                    else {
+                        console.debug("Migrate 'ValueEventBox' to new ValueEventCurveBox");
+                        boxGraph.beginTransaction();
+                        ValueEventCurveBox.create(boxGraph, UUID.generate(), box => {
+                            box.event.refer(eventBox.interpolation);
+                            box.slope.setValue(slope);
+                        });
+                        eventBox.slope.setValue(NaN);
+                        boxGraph.endTransaction();
+                    }
+                }
+            }
+        }));
+    }
+}

package/dist/index.d.ts

@@ -8,14 +8,19 @@ export * from "./samples/MainThreadSampleManager";
 export * from "./samples/SampleProvider";
 export * from "./ColorCodes";
 export * from "./Colors";
-export * from "./Effects";
+export * from "./EffectFactory";
+export * from "./EffectFactories";
 export * from "./Engine";
 export * from "./EngineFacade";
 export * from "./EngineWorklet";
-export * from "./Instruments";
+export * from "./InstrumentBox";
+export * from "./InstrumentFactories";
+export * from "./InstrumentFactory";
+export * from "./InstrumentOptions";
+export * from "./InstrumentProduct";
 export * from "./Mixer";
-export * from "./Modifier";
 export * from "./Project";
+export * from "./ProjectApi";
 export * from "./ProjectEnv";
 export * from "./Wav";
 export * from "./WorkerAgents";

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,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,eAAe,CAAA;AAC7B,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"}
+{"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,iBAAiB,CAAA;AAC/B,cAAc,mBAAmB,CAAA;AACjC,cAAc,UAAU,CAAA;AACxB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,SAAS,CAAA;AACvB,cAAc,WAAW,CAAA;AACzB,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA;AAC5B,cAAc,OAAO,CAAA;AACrB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,YAAY,CAAA"}

package/dist/index.js

@@ -8,14 +8,19 @@ export * from "./samples/MainThreadSampleManager";
 export * from "./samples/SampleProvider";
 export * from "./ColorCodes";
 export * from "./Colors";
-export * from "./Effects";
+export * from "./EffectFactory";
+export * from "./EffectFactories";
 export * from "./Engine";
 export * from "./EngineFacade";
 export * from "./EngineWorklet";
-export * from "./Instruments";
+export * from "./InstrumentBox";
+export * from "./InstrumentFactories";
+export * from "./InstrumentFactory";
+export * from "./InstrumentOptions";
+export * from "./InstrumentProduct";
 export * from "./Mixer";
-export * from "./Modifier";
 export * from "./Project";
+export * from "./ProjectApi";
 export * from "./ProjectEnv";
 export * from "./Wav";
 export * from "./WorkerAgents";