@opendaw/studio-scripting 0.0.2

package/dist/NoteTrackWriter.d.ts

@@ -0,0 +1,9 @@
+import { NoteTrackImpl } from "./impl";
+import { AudioUnitBox } from "@opendaw/studio-boxes";
+import { BoxGraph } from "@opendaw/lib-box";
+import { IndexRef } from "./IndexRef";
+export declare class NoteTrackWriter {
+    #private;
+    write(boxGraph: BoxGraph, audioUnitBox: AudioUnitBox, noteTracks: ReadonlyArray<NoteTrackImpl>, indexRef: IndexRef): void;
+}
+//# sourceMappingURL=NoteTrackWriter.d.ts.map

package/dist/NoteTrackWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NoteTrackWriter.d.ts","sourceRoot":"","sources":["../src/NoteTrackWriter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,aAAa,EAAC,MAAM,QAAQ,CAAA;AAEpD,OAAO,EAAC,YAAY,EAAgE,MAAM,uBAAuB,CAAA;AAEjH,OAAO,EAAC,QAAQ,EAAC,MAAM,kBAAkB,CAAA;AAEzC,OAAO,EAAC,QAAQ,EAAC,MAAM,YAAY,CAAA;AAEnC,qBAAa,eAAe;;IAGxB,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAClB,YAAY,EAAE,YAAY,EAC1B,UAAU,EAAE,aAAa,CAAC,aAAa,CAAC,EACxC,QAAQ,EAAE,QAAQ,GAAG,IAAI;CAyClC"}

package/dist/NoteTrackWriter.js

@@ -0,0 +1,45 @@
+import { asDefined, isDefined, UUID } from "@opendaw/lib-std";
+import { NoteEventBox, NoteEventCollectionBox, NoteRegionBox, TrackBox } from "@opendaw/studio-boxes";
+import { TrackType } from "@opendaw/studio-adapters";
+export class NoteTrackWriter {
+    #map = new Map();
+    write(boxGraph, audioUnitBox, noteTracks, indexRef) {
+        noteTracks.forEach(({ enabled, regions }) => {
+            const trackBox = TrackBox.create(boxGraph, UUID.generate(), box => {
+                box.type.setValue(TrackType.Notes);
+                box.enabled.setValue(enabled);
+                box.index.setValue(indexRef.index++);
+                box.target.refer(audioUnitBox);
+                box.tracks.refer(audioUnitBox.tracks);
+            });
+            regions.forEach((region) => {
+                const { position, duration, loopDuration, loopOffset, events, hue, label, mute, mirror } = region;
+                const noteEventCollectionBox = isDefined(mirror)
+                    ? asDefined(this.#map.get(mirror), "mirror region not found in map")
+                    : NoteEventCollectionBox.create(boxGraph, UUID.generate());
+                this.#map.set(region, noteEventCollectionBox);
+                events.forEach(event => {
+                    NoteEventBox.create(boxGraph, UUID.generate(), box => {
+                        box.position.setValue(event.position);
+                        box.duration.setValue(event.duration);
+                        box.pitch.setValue(event.pitch);
+                        box.cent.setValue(event.cents); // TODO rename to plural
+                        box.velocity.setValue(event.velocity);
+                        box.events.refer(noteEventCollectionBox.events);
+                    });
+                });
+                NoteRegionBox.create(boxGraph, UUID.generate(), box => {
+                    box.position.setValue(position);
+                    box.duration.setValue(duration);
+                    box.loopDuration.setValue(loopDuration);
+                    box.loopOffset.setValue(loopOffset);
+                    box.hue.setValue(hue);
+                    box.label.setValue(label);
+                    box.mute.setValue(mute);
+                    box.regions.refer(trackBox.regions);
+                    box.events.refer(noteEventCollectionBox.owners);
+                });
+            });
+        });
+    }
+}

package/dist/ProjectConverter.d.ts

@@ -0,0 +1,6 @@
+import { ProjectSkeleton } from "@opendaw/studio-adapters";
+import { ProjectImpl } from "./impl";
+export declare namespace ProjectConverter {
+    const toSkeleton: (project: ProjectImpl) => ProjectSkeleton;
+}
+//# sourceMappingURL=ProjectConverter.d.ts.map

package/dist/ProjectConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProjectConverter.d.ts","sourceRoot":"","sources":["../src/ProjectConverter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,eAAe,EAAY,MAAM,0BAA0B,CAAA;AACnE,OAAO,EAAC,WAAW,EAAC,MAAM,QAAQ,CAAA;AAIlC,yBAAiB,gBAAgB,CAAC;IACvB,MAAM,UAAU,GAAI,SAAS,WAAW,KAAG,eAgCjD,CAAA;CACJ"}

package/dist/ProjectConverter.js

@@ -0,0 +1,39 @@
+import { asInstanceOf, isDefined } from "@opendaw/lib-std";
+import { AudioUnitBox } from "@opendaw/studio-boxes";
+import { ProjectSkeleton, Validator } from "@opendaw/studio-adapters";
+import { Asserts } from "./Asserts";
+import { AudioUnitBoxFactory } from "./AudioUnitBoxFactory";
+export var ProjectConverter;
+(function (ProjectConverter) {
+    ProjectConverter.toSkeleton = (project) => {
+        Asserts.assertNoNaN(project);
+        console.time("convert");
+        const skeleton = ProjectSkeleton.empty({
+            createDefaultUser: true,
+            createOutputCompressor: false
+        });
+        const { boxGraph, mandatoryBoxes: { rootBox, timelineBox, userInterfaceBoxes: [defaultUser] } } = skeleton;
+        const { bpm, timeSignature } = project;
+        boxGraph.beginTransaction();
+        timelineBox.bpm.setValue(Validator.clampBpm(bpm));
+        const [numerator, denominator] = Validator.isTimeSignatureValid(timeSignature.numerator, timeSignature.denominator).result();
+        timelineBox.signature.nominator.setValue(numerator);
+        timelineBox.signature.denominator.setValue(denominator);
+        AudioUnitBoxFactory.create(skeleton, project);
+        // select the first audio unit as the editing device
+        const firstAudioUnitBox = rootBox.audioUnits.pointerHub.incoming()
+            .map(({ box }) => asInstanceOf(box, AudioUnitBox))
+            .sort(({ index: a }, { index: b }) => a.getValue() - b.getValue())
+            .at(0);
+        if (isDefined(firstAudioUnitBox)) {
+            defaultUser.editingDeviceChain.refer(firstAudioUnitBox.editing);
+        }
+        boxGraph.endTransaction();
+        console.timeEnd("convert");
+        boxGraph.verifyPointers();
+        if (Validator.hasOverlappingRegions(boxGraph)) {
+            throw new Error("Project contains overlapping regions");
+        }
+        return skeleton;
+    };
+})(ProjectConverter || (ProjectConverter = {}));

package/dist/ProjectUnpacker.d.ts

@@ -0,0 +1,6 @@
+import { Project } from "./Api";
+import { ApiImpl } from "./impl";
+export declare namespace ProjectUnpacker {
+    const unpack: (api: ApiImpl, buffer: ArrayBufferLike, name: string) => Project;
+}
+//# sourceMappingURL=ProjectUnpacker.d.ts.map

package/dist/ProjectUnpacker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProjectUnpacker.d.ts","sourceRoot":"","sources":["../src/ProjectUnpacker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAC,MAAM,OAAO,CAAA;AAE7B,OAAO,EAAC,OAAO,EAAc,MAAM,QAAQ,CAAA;AAE3C,yBAAiB,eAAe,CAAC;IACtB,MAAM,MAAM,GAAI,KAAK,OAAO,EAAE,QAAQ,eAAe,EAAE,MAAM,MAAM,KAAG,OAU5E,CAAA;CACJ"}

package/dist/ProjectUnpacker.js

@@ -0,0 +1,14 @@
+import { ProjectSkeleton } from "@opendaw/studio-adapters";
+import { ProjectImpl } from "./impl";
+export var ProjectUnpacker;
+(function (ProjectUnpacker) {
+    ProjectUnpacker.unpack = (api, buffer, name) => {
+        const { boxGraph, mandatoryBoxes: { timelineBox } } = ProjectSkeleton.decode(buffer);
+        const project = new ProjectImpl(api, name);
+        project.bpm = timelineBox.bpm.getValue();
+        project.timeSignature.numerator = timelineBox.signature.nominator.getValue();
+        project.timeSignature.denominator = timelineBox.signature.denominator.getValue();
+        // TODO
+        return project;
+    };
+})(ProjectUnpacker || (ProjectUnpacker = {}));

package/dist/ScriptExecutionProtocol.d.ts

@@ -0,0 +1,7 @@
+export type ScriptExecutionContext = {
+    sampleRate: number;
+};
+export interface ScriptExecutionProtocol {
+    executeScript(script: string, context: ScriptExecutionContext): Promise<void>;
+}
+//# sourceMappingURL=ScriptExecutionProtocol.d.ts.map

package/dist/ScriptExecutionProtocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScriptExecutionProtocol.d.ts","sourceRoot":"","sources":["../src/ScriptExecutionProtocol.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,sBAAsB,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAA;AAE3D,MAAM,WAAW,uBAAuB;IACpC,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAChF"}

package/dist/ScriptExecutionProtocol.js

@@ -0,0 +1 @@
+export {};

package/dist/ScriptHost.d.ts

@@ -0,0 +1,8 @@
+import { ScriptExecutionContext, ScriptExecutionProtocol } from "./ScriptExecutionProtocol";
+import { ScriptHostProtocol } from "./ScriptHostProtocol";
+export declare class ScriptHost implements ScriptExecutionProtocol {
+    #private;
+    constructor(host: ScriptHostProtocol, scriptURL: string);
+    executeScript(script: string, context: ScriptExecutionContext): Promise<void>;
+}
+//# sourceMappingURL=ScriptHost.d.ts.map

package/dist/ScriptHost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScriptHost.d.ts","sourceRoot":"","sources":["../src/ScriptHost.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,sBAAsB,EAAE,uBAAuB,EAAC,MAAM,2BAA2B,CAAA;AACzF,OAAO,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAA;AAEvD,qBAAa,UAAW,YAAW,uBAAuB;;gBAG1C,IAAI,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM;IAWjD,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;CAStF"}

package/dist/ScriptHost.js

@@ -0,0 +1,23 @@
+import { RuntimeNotifier } from "@opendaw/lib-std";
+import { Communicator, Messenger, Promises } from "@opendaw/lib-runtime";
+export class ScriptHost {
+    #executor;
+    constructor(host, scriptURL) {
+        const messenger = Messenger.for(new Worker(scriptURL, { type: "module" }));
+        Communicator.executor(messenger.channel("scripting-host"), host);
+        this.#executor = Communicator.sender(messenger.channel("scripting-execution"), dispatcher => new class {
+            executeScript(script, context) {
+                return dispatcher.dispatchAndReturn(this.executeScript, script, context);
+            }
+        });
+    }
+    async executeScript(script, context) {
+        const progressUpdater = RuntimeNotifier.progress({ headline: "Executing Script..." });
+        const { status, error } = await Promises.tryCatch(this.#executor.executeScript(script, context));
+        progressUpdater.terminate();
+        if (status === "rejected") {
+            console.warn(error);
+            await RuntimeNotifier.info({ headline: "The script caused an error", message: String(error) });
+        }
+    }
+}

package/dist/ScriptHostProtocol.d.ts

@@ -0,0 +1,10 @@
+import { AudioData, Sample } from "@opendaw/studio-adapters";
+export interface ScriptHostProtocol {
+    openProject(buffer: ArrayBufferLike, name?: string): void;
+    fetchProject(): Promise<{
+        buffer: ArrayBuffer;
+        name: string;
+    }>;
+    addSample(data: AudioData, name: string): Promise<Sample>;
+}
+//# sourceMappingURL=ScriptHostProtocol.d.ts.map

package/dist/ScriptHostProtocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScriptHostProtocol.d.ts","sourceRoot":"","sources":["../src/ScriptHostProtocol.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAE,MAAM,EAAC,MAAM,0BAA0B,CAAA;AAE1D,MAAM,WAAW,kBAAkB;IAC/B,WAAW,CAAC,MAAM,EAAE,eAAe,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAEzD,YAAY,IAAI,OAAO,CAAC;QAAE,MAAM,EAAE,WAAW,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAE9D,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;CAC5D"}

package/dist/ScriptHostProtocol.js

@@ -0,0 +1 @@
+export {};

package/dist/ScriptRunner.d.ts

@@ -0,0 +1,8 @@
+import { ScriptHostProtocol } from "./ScriptHostProtocol";
+import { ScriptExecutionContext } from "./ScriptExecutionProtocol";
+export declare class ScriptRunner {
+    #private;
+    constructor(protocol: ScriptHostProtocol);
+    run(jsCode: string, context: ScriptExecutionContext): Promise<void>;
+}
+//# sourceMappingURL=ScriptRunner.d.ts.map

package/dist/ScriptRunner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScriptRunner.d.ts","sourceRoot":"","sources":["../src/ScriptRunner.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAC,sBAAsB,EAAC,MAAM,2BAA2B,CAAA;AAIhE,qBAAa,YAAY;;gBAGT,QAAQ,EAAE,kBAAkB;IAElC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB;CAc5D"}

package/dist/ScriptRunner.js

@@ -0,0 +1,22 @@
+import { Chord, dbToGain, FFT, gainToDb, Interpolation, midiToHz, PPQN } from "@opendaw/lib-dsp";
+import { AudioPlayback } from "@opendaw/studio-enums";
+import { ApiImpl } from "./impl";
+export class ScriptRunner {
+    #api;
+    constructor(protocol) { this.#api = new ApiImpl(protocol); }
+    async run(jsCode, context) {
+        Object.assign(globalThis, {
+            ...context,
+            openDAW: this.#api,
+            AudioPlayback, midiToHz, PPQN, FFT, Chord, Interpolation, dbToGain, gainToDb
+        });
+        const blob = new Blob([jsCode], { type: "text/javascript" });
+        const url = URL.createObjectURL(blob);
+        try {
+            await import(url);
+        }
+        finally {
+            URL.revokeObjectURL(url);
+        }
+    }
+}

package/dist/ScriptWorker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ScriptWorker.d.ts.map

package/dist/ScriptWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScriptWorker.d.ts","sourceRoot":"","sources":["../src/ScriptWorker.ts"],"names":[],"mappings":""}

package/dist/ScriptWorker.js

@@ -0,0 +1,21 @@
+import { Communicator, Messenger } from "@opendaw/lib-runtime";
+import { ScriptRunner } from "./ScriptRunner";
+const messenger = Messenger.for(self);
+const hostProtocol = Communicator.sender(messenger.channel("scripting-host"), dispatcher => new class {
+    openProject(buffer, name) {
+        dispatcher.dispatchAndForget(this.openProject, buffer, name);
+    }
+    fetchProject() {
+        return dispatcher.dispatchAndReturn(this.fetchProject);
+    }
+    addSample(data, name) {
+        return dispatcher.dispatchAndReturn(this.addSample, data, name);
+    }
+});
+Communicator.executor(messenger.channel("scripting-execution"), new class {
+    #scriptExecutor = new ScriptRunner(hostProtocol);
+    // TODO We might return information about the script execution, e.g. warnings
+    executeScript(script, context) {
+        return this.#scriptExecutor.run(script, context);
+    }
+});

package/dist/ValueTrackWriter.d.ts

@@ -0,0 +1,10 @@
+import { ValueTrackImpl } from "./impl";
+import { AudioUnitBox } from "@opendaw/studio-boxes";
+import { Box, BoxGraph } from "@opendaw/lib-box";
+import { AnyDevice } from "./Api";
+import { IndexRef } from "./IndexRef";
+export declare class ValueTrackWriter {
+    #private;
+    write(boxGraph: BoxGraph, devices: Map<AnyDevice, Box>, audioUnitBox: AudioUnitBox, valueTracks: ReadonlyArray<ValueTrackImpl>, indexRef: IndexRef): void;
+}
+//# sourceMappingURL=ValueTrackWriter.d.ts.map

package/dist/ValueTrackWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValueTrackWriter.d.ts","sourceRoot":"","sources":["../src/ValueTrackWriter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,cAAc,EAAC,MAAM,QAAQ,CAAA;AAEtE,OAAO,EAAC,YAAY,EAAmE,MAAM,uBAAuB,CAAA;AAEpH,OAAO,EAAC,GAAG,EAAE,QAAQ,EAAC,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAC,SAAS,EAAc,MAAM,OAAO,CAAA;AAC5C,OAAO,EAAC,QAAQ,EAAC,MAAM,YAAY,CAAA;AAEnC,qBAAa,gBAAgB;;IAGzB,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,GAAG,CAAC,SAAS,EAAE,GAAG,CAAC,EAC5B,YAAY,EAAE,YAAY,EAC1B,WAAW,EAAE,aAAa,CAAC,cAAc,CAAC,EAC1C,QAAQ,EAAE,QAAQ,GAAG,IAAI;CAsElC"}

package/dist/ValueTrackWriter.js

@@ -0,0 +1,78 @@
+import { asDefined, isDefined, UUID } from "@opendaw/lib-std";
+import { TrackBox, ValueEventBox, ValueEventCollectionBox, ValueRegionBox } from "@opendaw/studio-boxes";
+import { InterpolationFieldAdapter, TrackType } from "@opendaw/studio-adapters";
+export class ValueTrackWriter {
+    #map = new Map();
+    write(boxGraph, devices, audioUnitBox, valueTracks, indexRef) {
+        valueTracks.forEach(({ enabled, regions, device, parameter }) => {
+            const box = asDefined(devices.get(device), `Could not find ${device.constructor.name}`);
+            const field = box[parameter];
+            const trackBox = TrackBox.create(boxGraph, UUID.generate(), box => {
+                box.type.setValue(TrackType.Value);
+                box.enabled.setValue(enabled);
+                box.index.setValue(indexRef.index++);
+                box.target.refer(field);
+                box.tracks.refer(audioUnitBox.tracks);
+            });
+            regions.forEach((region) => {
+                const { position, duration, loopDuration, loopOffset, events, hue, label, mute, mirror } = region;
+                const valueEventCollectionBox = isDefined(mirror)
+                    ? asDefined(this.#map.get(mirror), "mirror region not found in map")
+                    : ValueEventCollectionBox.create(boxGraph, UUID.generate());
+                this.#map.set(region, valueEventCollectionBox);
+                this.#orderValueEvents(events).forEach(event => {
+                    const valueEvent = ValueEventBox.create(boxGraph, UUID.generate(), box => {
+                        box.position.setValue(event.position);
+                        box.value.setValue(event.value);
+                        box.slope.setValue(NaN); // deprecated
+                        box.index.setValue(event.index);
+                        box.events.refer(valueEventCollectionBox.events);
+                    });
+                    InterpolationFieldAdapter.write(valueEvent.interpolation, event.interpolation);
+                });
+                ValueRegionBox.create(boxGraph, UUID.generate(), box => {
+                    box.position.setValue(position);
+                    box.duration.setValue(duration);
+                    box.loopDuration.setValue(loopDuration);
+                    box.loopOffset.setValue(loopOffset);
+                    box.hue.setValue(hue);
+                    box.label.setValue(label);
+                    box.mute.setValue(mute);
+                    box.regions.refer(trackBox.regions);
+                    box.events.refer(valueEventCollectionBox.owners);
+                });
+            });
+        });
+    }
+    #orderValueEvents(events) {
+        if (events.length === 0)
+            return [];
+        const sorted = events.toSorted((a, b) => a.position - b.position);
+        const result = [];
+        let index = 0;
+        while (index < sorted.length) {
+            const position = sorted[index].position;
+            const start = index;
+            while (index < sorted.length && sorted[index].position === position) {
+                index++;
+            }
+            const end = index - 1;
+            if (start === end) {
+                sorted[start].index = 0;
+                result.push(sorted[start]);
+            }
+            else {
+                if (sorted[start].value === sorted[end].value) {
+                    sorted[end].index = 0;
+                    result.push(sorted[end]);
+                }
+                else {
+                    sorted[start].index = 0;
+                    sorted[end].index = 1;
+                    result.push(sorted[start], sorted[end]);
+                }
+            }
+        }
+        return result;
+    }
+}

package/dist/impl/ApiImpl.d.ts

@@ -0,0 +1,12 @@
+import { Api, Project } from "../Api";
+import { ScriptHostProtocol } from "../ScriptHostProtocol";
+import { AudioData, Sample } from "@opendaw/studio-adapters";
+export declare class ApiImpl implements Api {
+    #private;
+    constructor(protocol: ScriptHostProtocol);
+    newProject(name?: string): Project;
+    getProject(): Promise<Project>;
+    openProject(buffer: ArrayBufferLike, name?: string): void;
+    addSample(data: AudioData, name: string): Promise<Sample>;
+}
+//# sourceMappingURL=ApiImpl.d.ts.map

package/dist/impl/ApiImpl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiImpl.d.ts","sourceRoot":"","sources":["../../src/impl/ApiImpl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,EAAE,OAAO,EAAC,MAAM,QAAQ,CAAA;AAEnC,OAAO,EAAC,kBAAkB,EAAC,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAC,SAAS,EAAE,MAAM,EAAC,MAAM,0BAA0B,CAAA;AAG1D,qBAAa,OAAQ,YAAW,GAAG;;gBAGnB,QAAQ,EAAE,kBAAkB;IAExC,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO;IAI5B,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC;IAKpC,WAAW,CAAC,MAAM,EAAE,eAAe,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI;IAIzD,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAG5D"}

package/dist/impl/ApiImpl.js

@@ -0,0 +1,19 @@
+import { ProjectImpl } from "./ProjectImpl";
+import { ProjectUnpacker } from "../ProjectUnpacker";
+export class ApiImpl {
+    #protocol;
+    constructor(protocol) { this.#protocol = protocol; }
+    newProject(name) {
+        return new ProjectImpl(this, name ?? `Scripted Project`);
+    }
+    async getProject() {
+        const { buffer, name } = await this.#protocol.fetchProject();
+        return ProjectUnpacker.unpack(this, buffer, name);
+    }
+    openProject(buffer, name) {
+        this.#protocol.openProject(buffer, name);
+    }
+    addSample(data, name) {
+        return this.#protocol.addSample(data, name);
+    }
+}

package/dist/impl/AudioRegionImpl.d.ts

@@ -0,0 +1,19 @@
+import { AudioRegion, AudioTrack } from "../Api";
+import { ppqn } from "@opendaw/lib-dsp";
+import { int } from "@opendaw/lib-std";
+import { Sample } from "@opendaw/studio-adapters";
+import { AudioPlayback } from "@opendaw/studio-enums";
+export declare class AudioRegionImpl implements AudioRegion {
+    readonly track: AudioTrack;
+    sample: Sample;
+    playback: AudioPlayback.NoSync | AudioPlayback.Pitch;
+    position: ppqn;
+    duration: ppqn;
+    mute: boolean;
+    label: string;
+    hue: int;
+    loopDuration: ppqn;
+    loopOffset: ppqn;
+    constructor(track: AudioTrack, sample: Sample, props?: Partial<AudioRegion>);
+}
+//# sourceMappingURL=AudioRegionImpl.d.ts.map

package/dist/impl/AudioRegionImpl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioRegionImpl.d.ts","sourceRoot":"","sources":["../../src/impl/AudioRegionImpl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAE,UAAU,EAAC,MAAM,QAAQ,CAAA;AAC9C,OAAO,EAAO,IAAI,EAAC,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAC,GAAG,EAAC,MAAM,kBAAkB,CAAA;AACpC,OAAO,EAAa,MAAM,EAAY,MAAM,0BAA0B,CAAA;AACtE,OAAO,EAAC,aAAa,EAAC,MAAM,uBAAuB,CAAA;AAEnD,qBAAa,eAAgB,YAAW,WAAW;IAC/C,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;IAE1B,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,aAAa,CAAC,MAAM,GAAG,aAAa,CAAC,KAAK,CAAA;IAEpD,QAAQ,EAAE,IAAI,CAAA;IACd,QAAQ,EAAE,IAAI,CAAA;IACd,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,GAAG,CAAA;IACR,YAAY,EAAE,IAAI,CAAA;IAClB,UAAU,EAAE,IAAI,CAAA;gBAEJ,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC;CAY9E"}

package/dist/impl/AudioRegionImpl.js

@@ -0,0 +1,27 @@
+import { PPQN } from "@opendaw/lib-dsp";
+import { ColorCodes, TrackType } from "@opendaw/studio-adapters";
+import { AudioPlayback } from "@opendaw/studio-enums";
+export class AudioRegionImpl {
+    track;
+    sample;
+    playback;
+    position;
+    duration;
+    mute;
+    label;
+    hue;
+    loopDuration;
+    loopOffset;
+    constructor(track, sample, props) {
+        this.track = track;
+        this.sample = sample;
+        this.playback = props?.playback ?? AudioPlayback.Pitch;
+        this.position = props?.position ?? 0.0;
+        this.duration = props?.duration ?? PPQN.Bar;
+        this.loopDuration = props?.loopDuration ?? this.duration;
+        this.loopOffset = props?.loopOffset ?? 0.0;
+        this.mute = props?.mute ?? false;
+        this.label = props?.label ?? "";
+        this.hue = props?.hue ?? ColorCodes.forTrackType(TrackType.Audio);
+    }
+}

package/dist/impl/AudioTrackImpl.d.ts

@@ -0,0 +1,12 @@
+import { AudioRegion, AudioTrack, AudioUnit } from "../Api";
+import { AudioRegionImpl } from "./AudioRegionImpl";
+import { AudioUnitImpl } from "./AudioUnitImpl";
+export declare class AudioTrackImpl implements AudioTrack {
+    #private;
+    readonly audioUnit: AudioUnit;
+    enabled: boolean;
+    constructor(audioUnit: AudioUnitImpl, props?: Partial<AudioTrack>);
+    addRegion(sample: Sample, props?: Partial<AudioRegion>): AudioRegion;
+    get regions(): ReadonlyArray<AudioRegionImpl>;
+}
+//# sourceMappingURL=AudioTrackImpl.d.ts.map

package/dist/impl/AudioTrackImpl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioTrackImpl.d.ts","sourceRoot":"","sources":["../../src/impl/AudioTrackImpl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAE,UAAU,EAAE,SAAS,EAAC,MAAM,QAAQ,CAAA;AACzD,OAAO,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAA;AACjD,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAA;AAE7C,qBAAa,cAAe,YAAW,UAAU;;IAC7C,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAA;IAG7B,OAAO,EAAE,OAAO,CAAA;gBAEJ,SAAS,EAAE,aAAa,EAAE,KAAK,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC;IAOjE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,WAAW;IAMpE,IAAI,OAAO,IAAI,aAAa,CAAC,eAAe,CAAC,CAAuB;CACvE"}

package/dist/impl/AudioTrackImpl.js

@@ -0,0 +1,17 @@
+import { AudioRegionImpl } from "./AudioRegionImpl";
+export class AudioTrackImpl {
+    audioUnit;
+    #regions;
+    enabled;
+    constructor(audioUnit, props) {
+        this.audioUnit = audioUnit;
+        this.#regions = [];
+        this.enabled = props?.enabled ?? true;
+    }
+    addRegion(sample, props) {
+        const region = new AudioRegionImpl(this, sample, props);
+        this.#regions.push(region);
+        return region;
+    }
+    get regions() { return this.#regions; }
+}

package/dist/impl/AudioUnitImpl.d.ts

@@ -0,0 +1,25 @@
+import { AnyDevice, AudioEffects, AudioTrack, AudioUnit, GroupAudioUnit, MIDIEffects, NoteTrack, OutputAudioUnit, ValueTrack } from "../Api";
+import { NoteTrackImpl } from "./NoteTrackImpl";
+import { ValueTrackImpl } from "./ValueTrackImpl";
+import { bipolar, Nullable } from "@opendaw/lib-std";
+import { AudioTrackImpl } from "./AudioTrackImpl";
+export declare abstract class AudioUnitImpl implements AudioUnit {
+    #private;
+    output?: Nullable<OutputAudioUnit | GroupAudioUnit>;
+    volume: number;
+    panning: bipolar;
+    mute: boolean;
+    solo: boolean;
+    protected constructor(props?: Partial<AudioUnit>);
+    addMIDIEffect<T extends keyof MIDIEffects>(type: T, props?: Partial<MIDIEffects[T]>): MIDIEffects[T];
+    addAudioEffect<T extends keyof AudioEffects>(type: T, props?: Partial<AudioEffects[T]>): AudioEffects[T];
+    addNoteTrack(props?: Partial<NoteTrack>): NoteTrack;
+    addAudioTrack(props?: Partial<AudioTrack>): AudioTrack;
+    addValueTrack<DEVICE extends AnyDevice, PARAMETER extends keyof DEVICE>(device: DEVICE, parameter: PARAMETER, props?: Partial<ValueTrack>): ValueTrack;
+    get audioEffects(): ReadonlyArray<AudioEffects[keyof AudioEffects]>;
+    get midiEffects(): ReadonlyArray<MIDIEffects[keyof MIDIEffects]>;
+    get noteTracks(): ReadonlyArray<NoteTrackImpl>;
+    get audioTracks(): ReadonlyArray<AudioTrackImpl>;
+    get valueTracks(): ReadonlyArray<ValueTrackImpl>;
+}
+//# sourceMappingURL=AudioUnitImpl.d.ts.map

package/dist/impl/AudioUnitImpl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioUnitImpl.d.ts","sourceRoot":"","sources":["../../src/impl/AudioUnitImpl.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,SAAS,EACT,YAAY,EACZ,UAAU,EACV,SAAS,EACT,cAAc,EACd,WAAW,EACX,SAAS,EACT,eAAe,EACf,UAAU,EACb,MAAM,QAAQ,CAAA;AAEf,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAA;AAC7C,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAG/C,OAAO,EAAC,OAAO,EAAE,QAAQ,EAAC,MAAM,kBAAkB,CAAA;AAClD,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAE/C,8BAAsB,aAAc,YAAW,SAAS;;IAOpD,MAAM,CAAC,EAAE,QAAQ,CAAC,eAAe,GAAG,cAAc,CAAC,CAAA;IACnD,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,OAAO,CAAA;IACb,IAAI,EAAE,OAAO,CAAA;IAEb,SAAS,aAAa,KAAK,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC;IAchD,aAAa,CAAC,CAAC,SAAS,MAAM,WAAW,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC;IAapG,cAAc,CAAC,CAAC,SAAS,MAAM,YAAY,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC;IAaxG,YAAY,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,SAAS;IAMnD,aAAa,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,UAAU;IAMtD,aAAa,CAAC,MAAM,SAAS,SAAS,EAAE,SAAS,SAAS,MAAM,MAAM,EAClE,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,UAAU;IAMlE,IAAI,YAAY,IAAI,aAAa,CAAC,YAAY,CAAC,MAAM,YAAY,CAAC,CAAC,CAA4B;IAC/F,IAAI,WAAW,IAAI,aAAa,CAAC,WAAW,CAAC,MAAM,WAAW,CAAC,CAAC,CAA2B;IAC3F,IAAI,UAAU,IAAI,aAAa,CAAC,aAAa,CAAC,CAA0B;IACxE,IAAI,WAAW,IAAI,aAAa,CAAC,cAAc,CAAC,CAA2B;IAC3E,IAAI,WAAW,IAAI,aAAa,CAAC,cAAc,CAAC,CAA2B;CAC9E"}

package/dist/impl/AudioUnitImpl.js

@@ -0,0 +1,73 @@
+import { NoteTrackImpl } from "./NoteTrackImpl";
+import { ValueTrackImpl } from "./ValueTrackImpl";
+import { DelayEffectImpl } from "./DelayEffectImpl";
+import { PitchEffectImpl } from "./PitchEffectImpl";
+import { AudioTrackImpl } from "./AudioTrackImpl";
+export class AudioUnitImpl {
+    #audioEffects;
+    #midiEffects;
+    #noteTracks;
+    #valueTracks;
+    #audioTracks;
+    output;
+    volume;
+    panning;
+    mute;
+    solo;
+    constructor(props) {
+        this.#audioEffects = [];
+        this.#midiEffects = [];
+        this.#noteTracks = [];
+        this.#audioTracks = [];
+        this.#valueTracks = [];
+        this.output = props?.output;
+        this.volume = props?.volume ?? 0.0;
+        this.panning = props?.panning ?? 0.0;
+        this.mute = props?.mute ?? false;
+        this.solo = props?.solo ?? false;
+    }
+    addMIDIEffect(type, props) {
+        let effect;
+        switch (type) {
+            case "pitch":
+                effect = new PitchEffectImpl(props);
+                break;
+            default:
+                throw new Error(`Unknown MIDI effect type: ${type}`);
+        }
+        this.#midiEffects.push(effect);
+        return effect;
+    }
+    addAudioEffect(type, props) {
+        let effect;
+        switch (type) {
+            case "delay":
+                effect = new DelayEffectImpl(props);
+                break;
+            default:
+                throw new Error(`Unknown Audio effect type: ${type}`);
+        }
+        this.#audioEffects.push(effect);
+        return effect;
+    }
+    addNoteTrack(props) {
+        const track = new NoteTrackImpl(this, props);
+        this.#noteTracks.push(track);
+        return track;
+    }
+    addAudioTrack(props) {
+        const track = new AudioTrackImpl(this, props);
+        this.#audioTracks.push(track);
+        return track;
+    }
+    addValueTrack(device, parameter, props) {
+        const track = new ValueTrackImpl(this, device, parameter, props);
+        this.#valueTracks.push(track);
+        return track;
+    }
+    get audioEffects() { return this.#audioEffects; }
+    get midiEffects() { return this.#midiEffects; }
+    get noteTracks() { return this.#noteTracks; }
+    get audioTracks() { return this.#audioTracks; }
+    get valueTracks() { return this.#valueTracks; }
+}

package/dist/impl/AuxAudioUnitImpl.d.ts

@@ -0,0 +1,13 @@
+import { AuxAudioUnit, GroupAudioUnit, Send } from "../Api";
+import { AudioUnitImpl } from "./AudioUnitImpl";
+import { SendImpl } from "./SendImpl";
+export declare class AuxAudioUnitImpl extends AudioUnitImpl implements AuxAudioUnit {
+    #private;
+    readonly kind: "auxiliary";
+    label: string;
+    constructor(props?: Partial<GroupAudioUnit>);
+    addSend(target: AuxAudioUnit | GroupAudioUnit, props?: Partial<Send>): Send;
+    removeSend(send: Send): void;
+    get sends(): ReadonlyArray<SendImpl>;
+}
+//# sourceMappingURL=AuxAudioUnitImpl.d.ts.map

package/dist/impl/AuxAudioUnitImpl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuxAudioUnitImpl.d.ts","sourceRoot":"","sources":["../../src/impl/AuxAudioUnitImpl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAE,cAAc,EAAE,IAAI,EAAC,MAAM,QAAQ,CAAA;AACzD,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAA;AAC7C,OAAO,EAAC,QAAQ,EAAC,MAAM,YAAY,CAAA;AAGnC,qBAAa,gBAAiB,SAAQ,aAAc,YAAW,YAAY;;IACvE,QAAQ,CAAC,IAAI,EAAG,WAAW,CAAS;IAIpC,KAAK,EAAE,MAAM,CAAA;gBAED,KAAK,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC;IAM3C,OAAO,CAAC,MAAM,EAAE,YAAY,GAAG,cAAc,EAAE,KAAK,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAM3E,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAE5B,IAAI,KAAK,IAAI,aAAa,CAAC,QAAQ,CAAC,CAAqB;CAC5D"}