@opendaw/studio-core 0.0.18 → 0.0.20

package/dist/dawproject/BuiltinDevices.d.ts

@@ -0,0 +1,9 @@
+import { EqualizerSchema } from "@opendaw/lib-dawproject";
+import { RevampDeviceBox } from "@opendaw/studio-boxes";
+import { BoxGraph, Field } from "@opendaw/lib-box";
+import { int } from "@opendaw/lib-std";
+import { Pointers } from "@opendaw/studio-enums";
+export declare namespace BuiltinDevices {
+    const equalizer: (boxGraph: BoxGraph, equalizer: EqualizerSchema, field: Field<Pointers.MidiEffectHost> | Field<Pointers.AudioEffectHost>, index: int) => RevampDeviceBox;
+}
+//# sourceMappingURL=BuiltinDevices.d.ts.map

package/dist/dawproject/BuiltinDevices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BuiltinDevices.d.ts","sourceRoot":"","sources":["../../src/dawproject/BuiltinDevices.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,eAAe,EAAmB,MAAM,yBAAyB,CAAA;AACjG,OAAO,EAAC,eAAe,EAA0B,MAAM,uBAAuB,CAAA;AAC9E,OAAO,EAAC,QAAQ,EAAE,KAAK,EAAC,MAAM,kBAAkB,CAAA;AAChD,OAAO,EAAY,GAAG,EAAO,MAAM,kBAAkB,CAAA;AACrD,OAAO,EAAC,QAAQ,EAAC,MAAM,uBAAuB,CAAA;AAG9C,yBAAiB,cAAc,CAAC;IACrB,MAAM,SAAS,GAAI,UAAU,QAAQ,EAClB,WAAW,eAAe,EAC1B,OAAO,KAAK,CAAC,QAAQ,CAAC,cAAc,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,eAAe,CAAC,EACvE,OAAO,GAAG,KAAG,eA4DtC,CAAA;CACJ"}

package/dist/dawproject/BuiltinDevices.js

@@ -0,0 +1,70 @@
+import { EqBandType, ParameterDecoder } from "@opendaw/lib-dawproject";
+import { RevampDeviceBox } from "@opendaw/studio-boxes";
+import { ifDefined, UUID } from "@opendaw/lib-std";
+import { semitoneToHz } from "@opendaw/lib-dsp";
+export var BuiltinDevices;
+(function (BuiltinDevices) {
+    BuiltinDevices.equalizer = (boxGraph, equalizer, field, index) => {
+        const mapOrder = (order) => {
+            switch (order) {
+                case 1:
+                case 2:
+                    return 0;
+                case 3:
+                case 4:
+                    return 1;
+                case 5:
+                case 6:
+                    return 2;
+                default:
+                    return 3;
+            }
+        };
+        const readPass = (schema, pass) => {
+            const { order, frequency, q, enabled } = pass;
+            order.setValue(mapOrder(schema.order));
+            frequency.setValue(semitoneToHz(schema.freq.value));
+            ifDefined(schema.Q?.value, value => q.setValue(value));
+            ifDefined(schema.enabled?.value, value => enabled.setValue(value));
+        };
+        const readShelf = (schema, pass) => {
+            const { frequency, gain, enabled } = pass;
+            frequency.setValue(ParameterDecoder.readValue(schema.freq));
+            ifDefined(schema.gain?.value, value => gain.setValue(value));
+            ifDefined(schema.enabled?.value, value => enabled.setValue(value));
+        };
+        return RevampDeviceBox.create(boxGraph, UUID.generate(), box => {
+            box.host.refer(field);
+            box.index.setValue(index);
+            box.label.setValue(equalizer.deviceName ?? "Revamp");
+            let bellIndex = 0;
+            equalizer.bands.forEach((band) => {
+                switch (band.type) {
+                    case EqBandType.HIGH_PASS:
+                        return readPass(band, box.highPass);
+                    case EqBandType.LOW_PASS:
+                        return readPass(band, box.lowPass);
+                    case EqBandType.HIGH_SHELF:
+                        return readShelf(band, box.highShelf);
+                    case EqBandType.LOW_SHELF:
+                        return readShelf(band, box.lowShelf);
+                    case EqBandType.BELL: {
+                        if (bellIndex === 3) {
+                            return;
+                        }
+                        const bell = [box.lowBell, box.midBell, box.highBell][bellIndex++];
+                        const { frequency, gain, q, enabled } = bell;
+                        frequency.setValue(ParameterDecoder.readValue(band.freq));
+                        ifDefined(band.Q?.value, value => q.setValue(value));
+                        ifDefined(band.gain?.value, value => gain.setValue(value));
+                        ifDefined(band.enabled?.value, value => enabled.setValue(value));
+                        return;
+                    }
+                    default:
+                        console.warn(`Cannot map band type: ${band.type} to Revamp`);
+                        return;
+                }
+            });
+        });
+    };
+})(BuiltinDevices || (BuiltinDevices = {}));

package/dist/dawproject/DawProject.d.ts

@@ -0,0 +1,22 @@
+import { UUID } from "@opendaw/lib-std";
+import { MetaDataSchema, ProjectSchema } from "@opendaw/lib-dawproject";
+import { Project } from "../Project";
+export declare namespace DawProject {
+    type Resource = {
+        uuid: UUID.Format;
+        path: string;
+        name: string;
+        buffer: ArrayBuffer;
+    };
+    interface ResourceProvider {
+        fromPath(path: string): Resource;
+        fromUUID(uuid: UUID.Format): Resource;
+    }
+    const decode: (buffer: ArrayBuffer | NonSharedBuffer) => Promise<{
+        metaData: MetaDataSchema;
+        project: ProjectSchema;
+        resources: ResourceProvider;
+    }>;
+    const encode: (project: Project, metaData: MetaDataSchema) => Promise<ArrayBuffer>;
+}
+//# sourceMappingURL=DawProject.d.ts.map

package/dist/dawproject/DawProject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DawProject.d.ts","sourceRoot":"","sources":["../../src/dawproject/DawProject.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,IAAI,EAAC,MAAM,kBAAkB,CAAA;AACvD,OAAO,EAAsB,cAAc,EAAE,aAAa,EAAC,MAAM,yBAAyB,CAAA;AAC1F,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAGlC,yBAAiB,UAAU,CAAC;IACxB,KAAY,QAAQ,GAAG;QAAE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,WAAW,CAAA;KAAE,CAAA;IAE7F,UAAiB,gBAAgB;QAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAA;QAChC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAA;KACxC;IAEM,MAAM,MAAM,GAAU,QAAQ,WAAW,GAAG,eAAe,KAAG,OAAO,CAAC;QACzE,QAAQ,EAAE,cAAc,CAAC;QACzB,OAAO,EAAE,aAAa,CAAC;QACvB,SAAS,EAAE,gBAAgB,CAAA;KAC9B,CAyBA,CAAA;IAEM,MAAM,MAAM,GAAI,SAAS,OAAO,EAAE,UAAU,cAAc,KAAG,OAAO,CAAC,WAAW,CAgBtF,CAAA;CACJ"}

package/dist/dawproject/DawProject.js

@@ -0,0 +1,49 @@
+import JSZip from "jszip";
+import { Xml } from "@opendaw/lib-xml";
+import { asDefined, panic, UUID } from "@opendaw/lib-std";
+import { FileReferenceSchema, MetaDataSchema, ProjectSchema } from "@opendaw/lib-dawproject";
+import { DawProjectExporter } from "./DawProjectExporter";
+export var DawProject;
+(function (DawProject) {
+    DawProject.decode = async (buffer) => {
+        const zip = await JSZip.loadAsync(buffer);
+        const metaData = Xml.parse(asDefined(await zip.file("metadata.xml")
+            ?.async("string"), "No metadata.xml found"), MetaDataSchema);
+        const projectXml = asDefined(await zip.file("project.xml")
+            ?.async("string"), "No project.xml found");
+        console.debug(projectXml);
+        const project = Xml.parse(projectXml, ProjectSchema);
+        const resourceFiles = Object.entries(zip.files).filter(([_, file]) => !file.dir && !file.name.endsWith(".xml"));
+        const resources = await Promise.all(resourceFiles.map(async ([path, file]) => {
+            const name = path.substring(path.lastIndexOf("/") + 1);
+            const buffer = await file.async("arraybuffer");
+            const uuid = await UUID.sha256(new Uint8Array(buffer).buffer);
+            return { uuid, path, name, buffer };
+        }));
+        return {
+            metaData, project, resources: {
+                fromPath: (path) => resources
+                    .find(resource => resource.path === path) ?? panic("Resource not found"),
+                fromUUID: (uuid) => resources
+                    .find(resource => UUID.equals(resource.uuid, uuid)) ?? panic("Resource not found")
+            }
+        };
+    };
+    DawProject.encode = (project, metaData) => {
+        const zip = new JSZip();
+        const projectSchema = DawProjectExporter.write(project, {
+            write: (path, buffer) => {
+                zip.file(path, buffer);
+                return Xml.element({ path, external: false }, FileReferenceSchema);
+            }
+        });
+        const metaDataXml = Xml.pretty(Xml.toElement("MetaData", metaData));
+        const projectXml = Xml.pretty(Xml.toElement("Project", projectSchema));
+        console.debug("encode");
+        console.debug(metaDataXml);
+        console.debug(projectXml);
+        zip.file("metadata.xml", metaDataXml);
+        zip.file("project.xml", projectXml);
+        return zip.generateAsync({ type: "arraybuffer" });
+    };
+})(DawProject || (DawProject = {}));

package/dist/dawproject/DawProjectExporter.d.ts

@@ -0,0 +1,9 @@
+import { FileReferenceSchema, ProjectSchema } from "@opendaw/lib-dawproject";
+import { Project } from "../Project";
+export declare namespace DawProjectExporter {
+    interface ResourcePacker {
+        write(path: string, buffer: ArrayBufferLike): FileReferenceSchema;
+    }
+    const write: (project: Project, resourcePacker: ResourcePacker) => ProjectSchema;
+}
+//# sourceMappingURL=DawProjectExporter.d.ts.map

package/dist/dawproject/DawProjectExporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DawProjectExporter.d.ts","sourceRoot":"","sources":["../../src/dawproject/DawProjectExporter.ts"],"names":[],"mappings":"AAGA,OAAO,EAaH,mBAAmB,EAKnB,aAAa,EAUhB,MAAM,yBAAyB,CAAA;AAchC,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAQlC,yBAAiB,kBAAkB,CAAC;IAChC,UAAiB,cAAc;QAAE,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,GAAG,mBAAmB,CAAA;KAAC;IAE5F,MAAM,KAAK,GAAI,SAAS,OAAO,EAAE,gBAAgB,cAAc,kBA4PrE,CAAA;CACJ"}

package/dist/dawproject/DawProjectExporter.js

@@ -0,0 +1,252 @@
+import { asDefined, asInstanceOf, Color, ifDefined, isInstanceOf, Option, UUID } from "@opendaw/lib-std";
+import { Xml } from "@opendaw/lib-xml";
+import { dbToGain, PPQN } from "@opendaw/lib-dsp";
+import { ApplicationSchema, ArrangementSchema, AudioAlgorithm, AudioSchema, BuiltinDeviceSchema, ChannelRole, ChannelSchema, ClipSchema, ClipsSchema, DeviceRole, FileReferenceSchema, LanesSchema, NoteSchema, NotesSchema, ParameterEncoder, ProjectSchema, RealParameterSchema, TimeSignatureParameterSchema, TimeUnit, TrackSchema, TransportSchema, Unit, WarpSchema, WarpsSchema } from "@opendaw/lib-dawproject";
+import { AddressIdEncoder, BooleanField } from "@opendaw/lib-box";
+import { AudioUnitType } from "@opendaw/studio-enums";
+import { AudioFileBox, AudioUnitBox, NoteEventBox, NoteEventCollectionBox, TrackBox } from "@opendaw/studio-boxes";
+import { AudioUnitExportLayout } from "./AudioUnitExportLayout";
+import { ColorCodes } from "../ColorCodes";
+import { Html } from "@opendaw/lib-dom";
+import { encodeWavFloat } from "../Wav";
+import { DeviceBoxUtils } from "@opendaw/studio-adapters";
+import { DeviceIO } from "./DeviceIO";
+export var DawProjectExporter;
+(function (DawProjectExporter) {
+    DawProjectExporter.write = (project, resourcePacker) => {
+        const ids = new AddressIdEncoder();
+        const { boxGraph, timelineBox, rootBox, sampleManager } = project;
+        const audioUnits = rootBox.audioUnits.pointerHub.incoming()
+            .map(({ box }) => asInstanceOf(box, AudioUnitBox))
+            .sort((a, b) => a.index.getValue() - b.index.getValue());
+        boxGraph.boxes().forEach(box => box.accept({
+            visitAudioFileBox: (box) => sampleManager.getOrCreate(box.address.uuid).data
+                .ifSome(({ frames, numberOfFrames, sampleRate, numberOfChannels }) => resourcePacker.write(`samples/${box.fileName.getValue()}.wav`, encodeWavFloat({
+                channels: frames,
+                duration: numberOfFrames * sampleRate,
+                numberOfChannels,
+                sampleRate,
+                numFrames: numberOfFrames
+            })))
+        }));
+        const writeTransport = () => Xml.element({
+            tempo: Xml.element({
+                id: ids.getOrCreate(timelineBox.bpm.address),
+                value: timelineBox.bpm.getValue(),
+                unit: Unit.BPM
+            }, RealParameterSchema),
+            timeSignature: Xml.element({
+                numerator: timelineBox.signature.nominator.getValue(),
+                denominator: timelineBox.signature.denominator.getValue()
+            }, TimeSignatureParameterSchema)
+        }, TransportSchema);
+        const writeDevices = (field, deviceRole) => field.pointerHub
+            .incoming().map(({ box }) => {
+            const enabled = ("enabled" in box && isInstanceOf(box.enabled, BooleanField)
+                ? Option.wrap(box.enabled)
+                : Option.None)
+                .mapOr(field => ParameterEncoder.bool(ids.getOrCreate(field.address), field.getValue(), "On/Off"), undefined);
+            const deviceID = box.name;
+            const deviceName = DeviceBoxUtils.lookupLabelField(box).getValue();
+            const deviceVendor = "openDAW";
+            const id = ids.getOrCreate(box.address);
+            return Xml.element({
+                id,
+                deviceID,
+                deviceRole,
+                deviceName,
+                deviceVendor,
+                enabled,
+                loaded: true,
+                automatedParameters: [],
+                state: resourcePacker
+                    .write(`presets/${UUID.toString(box.address.uuid)}`, DeviceIO.exportDevice(box))
+            }, BuiltinDeviceSchema);
+        });
+        const colorForAudioType = (unitType) => {
+            const cssColor = ColorCodes.forAudioType(unitType);
+            if (cssColor === "") {
+                return "red";
+            }
+            const [r, g, b] = Html.readCssVarColor(ColorCodes.forAudioType(unitType))[0];
+            const RR = Math.round(r * 255).toString(16).padStart(2, "0");
+            const GG = Math.round(g * 255).toString(16).padStart(2, "0");
+            const BB = Math.round(b * 255).toString(16).padStart(2, "0");
+            return `#${RR}${GG}${BB}`;
+        };
+        const writeStructure = () => {
+            const tracks = AudioUnitExportLayout.layout(audioUnits);
+            const writeAudioUnitBox = (audioUnitBox, tracks) => {
+                const unitType = audioUnitBox.type.getValue();
+                const color = colorForAudioType(unitType);
+                const isPrimary = unitType === AudioUnitType.Output;
+                const isAux = unitType === AudioUnitType.Aux;
+                const inputBox = audioUnitBox.input.pointerHub.incoming().at(0)?.box;
+                const contentType = isPrimary ? "audio notes" // we copied that value from bitwig
+                    : isAux ? "audio" : (() => 
+                    // TODO Another location to remember to put devices in...?
+                    //  We could also read the first track type?
+                    inputBox?.accept({
+                        visitTapeDeviceBox: () => "audio",
+                        visitVaporisateurDeviceBox: () => "notes",
+                        visitNanoDeviceBox: () => "notes",
+                        visitPlayfieldDeviceBox: () => "notes",
+                        visitAudioBusBox: () => "tracks"
+                    }))() ?? undefined;
+                return Xml.element({
+                    id: ids.getOrCreate(audioUnitBox.address),
+                    name: DeviceBoxUtils.lookupLabelField(inputBox).getValue(),
+                    loaded: true,
+                    color,
+                    contentType,
+                    channel: Xml.element({
+                        id: ifDefined(inputBox, ({ address }) => ids.getOrCreate(address)),
+                        destination: isPrimary
+                            ? undefined
+                            : audioUnitBox.output.targetVertex
+                                .mapOr(({ box }) => ids.getOrCreate(box.address), undefined),
+                        role: (() => {
+                            switch (unitType) {
+                                case AudioUnitType.Instrument:
+                                    return ChannelRole.REGULAR;
+                                case AudioUnitType.Aux:
+                                    return ChannelRole.EFFECT;
+                                case AudioUnitType.Bus:
+                                case AudioUnitType.Output:
+                                    return ChannelRole.MASTER;
+                            }
+                        })(),
+                        devices: [
+                            ...(writeDevices(audioUnitBox.midiEffects, DeviceRole.NOTE_FX)),
+                            ...(writeDevices(audioUnitBox.input, DeviceRole.INSTRUMENT)),
+                            ...(writeDevices(audioUnitBox.audioEffects, DeviceRole.AUDIO_FX))
+                        ],
+                        volume: ParameterEncoder.linear(ids.getOrCreate(audioUnitBox.volume.address), dbToGain(audioUnitBox.volume.getValue()), 0.0, 2.0, "Volume"),
+                        pan: ParameterEncoder.normalized(ids.getOrCreate(audioUnitBox.panning.address), (audioUnitBox.panning.getValue() + 1.0) / 2.0, 0.0, 1.0, "Pan")
+                    }, ChannelSchema),
+                    tracks
+                }, TrackSchema);
+            };
+            const writeTracks = (tracks) => tracks.map((track) => writeAudioUnitBox(track.audioUnit, writeTracks(track.children)));
+            return writeTracks(tracks);
+        };
+        const writeAudioRegion = (region) => {
+            const audioFileBox = asInstanceOf(region.file.targetVertex.unwrap("No file at region").box, AudioFileBox);
+            const audioElement = sampleManager.getOrCreate(audioFileBox.address.uuid).data
+                .map(({ numberOfFrames, sampleRate, numberOfChannels }) => Xml.element({
+                duration: numberOfFrames / sampleRate,
+                channels: numberOfChannels,
+                sampleRate,
+                algorithm: AudioAlgorithm.REPITCH,
+                file: Xml.element({
+                    path: `samples/${audioFileBox.fileName.getValue()}.wav`,
+                    external: false
+                }, FileReferenceSchema)
+            }, AudioSchema));
+            const duration = region.duration.getValue() / PPQN.Quarter;
+            return Xml.element({
+                clips: [Xml.element({
+                        time: region.position.getValue() / PPQN.Quarter,
+                        duration,
+                        contentTimeUnit: TimeUnit.BEATS,
+                        playStart: 0.0,
+                        loopStart: 0.0,
+                        loopEnd: region.loopDuration.getValue() / PPQN.Quarter,
+                        enable: !region.mute.getValue(),
+                        name: region.label.getValue(),
+                        color: Color.hslToHex(region.hue.getValue(), 1.0, 0.60),
+                        content: [Xml.element({
+                                content: audioElement.mapOr(element => [element], []),
+                                contentTimeUnit: "beats",
+                                warps: [
+                                    Xml.element({
+                                        time: 0.0,
+                                        contentTime: 0.0
+                                    }, WarpSchema),
+                                    Xml.element({
+                                        time: duration,
+                                        contentTime: audioElement.mapOr(element => element.duration, 0)
+                                    }, WarpSchema)
+                                ]
+                            }, WarpsSchema)]
+                    }, ClipSchema)]
+            }, ClipsSchema);
+        };
+        const writeNoteRegion = (region) => {
+            const collectionBox = asInstanceOf(region.events.targetVertex
+                .unwrap("No notes in region").box, NoteEventCollectionBox);
+            return Xml.element({
+                clips: [Xml.element({
+                        time: region.position.getValue() / PPQN.Quarter,
+                        duration: region.duration.getValue() / PPQN.Quarter,
+                        contentTimeUnit: TimeUnit.BEATS,
+                        playStart: 0.0,
+                        loopStart: 0.0,
+                        loopEnd: region.loopDuration.getValue() / PPQN.Quarter,
+                        enable: !region.mute.getValue(),
+                        name: region.label.getValue(),
+                        color: Color.hslToHex(region.hue.getValue(), 1.0, 0.60),
+                        content: [Xml.element({
+                                notes: collectionBox.events.pointerHub.incoming()
+                                    .map(({ box }) => asInstanceOf(box, NoteEventBox))
+                                    .map(box => Xml.element({
+                                    time: box.position.getValue() / PPQN.Quarter,
+                                    duration: box.duration.getValue() / PPQN.Quarter,
+                                    key: box.pitch.getValue(),
+                                    channel: 0,
+                                    vel: box.velocity.getValue(),
+                                    rel: box.velocity.getValue()
+                                }, NoteSchema))
+                            }, NotesSchema)]
+                    }, ClipSchema)]
+            }, ClipsSchema);
+        };
+        // TODO Implement!
+        const writeValueRegion = (region) => Xml.element({
+            clips: [Xml.element({
+                    time: region.position.getValue() / PPQN.Quarter,
+                    duration: region.duration.getValue() / PPQN.Quarter,
+                    contentTimeUnit: TimeUnit.BEATS,
+                    playStart: 0.0,
+                    loopStart: 0.0,
+                    loopEnd: region.loopDuration.getValue() / PPQN.Quarter,
+                    enable: !region.mute.getValue(),
+                    name: region.label.getValue(),
+                    color: Color.hslToHex(region.hue.getValue(), 1.0, 0.60),
+                    content: []
+                }, ClipSchema)]
+        }, ClipsSchema);
+        const writeLanes = () => {
+            return audioUnits
+                .flatMap(audioUnitBox => audioUnitBox.tracks.pointerHub.incoming()
+                .map(({ box }) => asInstanceOf(box, TrackBox))
+                .sort((a, b) => a.index.getValue() - b.index.getValue())
+                .map(trackBox => Xml.element({
+                id: ids.getOrCreate(trackBox.address),
+                track: ids.getOrCreate(audioUnitBox.address),
+                lanes: trackBox.regions.pointerHub.incoming()
+                    .map(({ box }) => asDefined(box.accept({
+                    visitAudioRegionBox: (region) => writeAudioRegion(region),
+                    visitNoteRegionBox: (region) => writeNoteRegion(region),
+                    visitValueRegionBox: (region) => writeValueRegion(region)
+                }), "Could not write region."))
+            }, LanesSchema)));
+        };
+        return Xml.element({
+            version: "1.0",
+            application: Xml.element({
+                name: "openDAW",
+                version: "0.1"
+            }, ApplicationSchema),
+            transport: writeTransport(),
+            structure: writeStructure(),
+            arrangement: Xml.element({
+                lanes: Xml.element({
+                    lanes: writeLanes(),
+                    timeUnit: TimeUnit.BEATS
+                }, LanesSchema)
+            }, ArrangementSchema),
+            scenes: []
+        }, ProjectSchema);
+    };
+})(DawProjectExporter || (DawProjectExporter = {}));

package/dist/dawproject/DawProjectExporter.test.d.ts

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

package/dist/dawproject/DawProjectExporter.test.d.ts.map

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

package/dist/dawproject/DawProjectExporter.test.js

@@ -0,0 +1,49 @@
+import { describe, it } from "vitest";
+import { fileURLToPath } from "url";
+import * as path from "node:path";
+import * as fs from "node:fs";
+import { Project } from "../Project";
+import { Option, panic, Terminable } from "@opendaw/lib-std";
+import { Xml } from "@opendaw/lib-xml";
+import { FileReferenceSchema } from "@opendaw/lib-dawproject";
+import { DawProjectExporter } from "./DawProjectExporter";
+describe("DawProjectExport", () => {
+    it("export", async () => {
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        const projectPath = "../../../../../test-files/all-devices.od";
+        const buffer = fs.readFileSync(path.join(__dirname, projectPath));
+        const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+        const project = Project.load({
+            sampleRate: 44100,
+            sampleManager: new class {
+                record(loader) {
+                    throw new Error("Method not implemented.");
+                }
+                getOrCreate(format) {
+                    return new class {
+                        data = Option.None;
+                        peaks = Option.None;
+                        uuid = format;
+                        state = { type: "progress", progress: 0.0 };
+                        meta = Option.None;
+                        invalidate() { throw new Error("Method not implemented."); }
+                        subscribe(_observer) {
+                            return Terminable.Empty;
+                        }
+                    };
+                }
+                invalidate(_uuid) {
+                    return panic("Method not implemented.");
+                }
+            }
+        }, arrayBuffer);
+        const schema = DawProjectExporter.write(project, {
+            write: (path, buffer) => {
+                console.debug(`store ${buffer.byteLength} bytes at ${path}`);
+                return Xml.element({ path, external: false }, FileReferenceSchema);
+            }
+        });
+        // console.dir(schema, {depth: Number.MAX_SAFE_INTEGER})
+        console.debug(Xml.pretty(Xml.toElement("Project", schema)));
+    });
+});

package/dist/dawproject/DawProjectImport.d.ts

@@ -0,0 +1,12 @@
+import { UUID } from "@opendaw/lib-std";
+import { ProjectSchema } from "@opendaw/lib-dawproject";
+import { ProjectDecoder } from "@opendaw/studio-adapters";
+import { DawProject } from "./DawProject";
+export declare namespace DawProjectImport {
+    type Result = {
+        audioIds: ReadonlyArray<UUID.Format>;
+        skeleton: ProjectDecoder.Skeleton;
+    };
+    const read: (schema: ProjectSchema, resources: DawProject.ResourceProvider) => Promise<Result>;
+}
+//# sourceMappingURL=DawProjectImport.d.ts.map

package/dist/dawproject/DawProjectImport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DawProjectImport.d.ts","sourceRoot":"","sources":["../../src/dawproject/DawProjectImport.ts"],"names":[],"mappings":"AAAA,OAAO,EAgBH,IAAI,EAEP,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAcH,aAAa,EAOhB,MAAM,yBAAyB,CAAA;AAuBhC,OAAO,EAAyC,cAAc,EAAY,MAAM,0BAA0B,CAAA;AAC1G,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAA;AAQvC,yBAAiB,gBAAgB,CAAC;IAW9B,KAAY,MAAM,GAAG;QACjB,QAAQ,EAAE,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACrC,QAAQ,EAAE,cAAc,CAAC,QAAQ,CAAA;KACpC,CAAA;IAOM,MAAM,IAAI,GAAU,QAAQ,aAAa,EAAE,WAAW,UAAU,CAAC,gBAAgB,KAAG,OAAO,CAAC,MAAM,CA6WxG,CAAA;CAaJ"}