@opendaw/studio-adapters 0.0.47 → 0.0.49

package/dist/preset/PresetDecoder.js

@@ -0,0 +1,154 @@
+import { asDefined, asInstanceOf, Attempts, ByteArrayInput, isDefined, isInstanceOf, Option, RuntimeNotifier, UUID } from "@opendaw/lib-std";
+import { BoxGraph, PointerField } from "@opendaw/lib-box";
+import { AudioUnitType } from "@opendaw/studio-enums";
+import { AudioFileBox, AudioUnitBox, BoxIO, CaptureAudioBox, CaptureMidiBox, SoundfontFileBox, TrackBox } from "@opendaw/studio-boxes";
+import { ProjectSkeleton } from "../project/ProjectSkeleton";
+import { ProjectUtils } from "../project/ProjectUtils";
+import { TrackType } from "../timeline/TrackType";
+import { PresetHeader } from "./PresetHeader";
+export var PresetDecoder;
+(function (PresetDecoder) {
+    PresetDecoder.decode = (bytes, target) => {
+        const header = new ByteArrayInput(bytes.slice(0, 8));
+        if (header.readInt() !== PresetHeader.MAGIC_HEADER_OPEN) {
+            RuntimeNotifier.info({
+                headline: "Could Not Import Preset",
+                message: "Invalid preset file"
+            }).then();
+            return;
+        }
+        if (header.readInt() !== PresetHeader.FORMAT_VERSION) {
+            RuntimeNotifier.info({
+                headline: "Could Not Import Preset",
+                message: "Invalid preset version"
+            }).then();
+            return;
+        }
+        const sourceBoxGraph = new BoxGraph(Option.wrap(BoxIO.create));
+        try {
+            sourceBoxGraph.fromArrayBuffer(bytes.slice(8));
+        }
+        catch (reason) {
+            RuntimeNotifier.info({
+                headline: "Could Not Import Preset",
+                message: String(reason)
+            }).then();
+            return;
+        }
+        const sourceAudioUnitBoxes = sourceBoxGraph.boxes()
+            .filter(box => isInstanceOf(box, AudioUnitBox))
+            .filter(box => box.type.getValue() !== AudioUnitType.Output);
+        ProjectUtils.extractAudioUnits(sourceAudioUnitBoxes, target, { excludeTimeline: true })
+            .filter(box => box.type.getValue() !== AudioUnitType.Output)
+            .forEach((audioUnitBox) => {
+            const inputBox = audioUnitBox.input.pointerHub.incoming().at(0)?.box;
+            if (isDefined(inputBox)) {
+                audioUnitBox.capture.targetVertex.ifSome(({ box: captureBox }) => {
+                    if (captureBox instanceof CaptureMidiBox) {
+                        TrackBox.create(target.boxGraph, UUID.generate(), box => {
+                            box.index.setValue(0);
+                            box.type.setValue(TrackType.Notes);
+                            box.target.refer(audioUnitBox);
+                            box.tracks.refer(audioUnitBox.tracks);
+                        });
+                    }
+                    else if (captureBox instanceof CaptureAudioBox) {
+                        TrackBox.create(target.boxGraph, UUID.generate(), box => {
+                            box.index.setValue(0);
+                            box.type.setValue(TrackType.Audio);
+                            box.target.refer(audioUnitBox);
+                            box.tracks.refer(audioUnitBox.tracks);
+                        });
+                    }
+                });
+            }
+        });
+    };
+    PresetDecoder.replaceAudioUnit = (arrayBuffer, targetAudioUnitBox, options) => {
+        console.debug("ReplaceAudioUnit with preset...");
+        const skeleton = ProjectSkeleton.empty({
+            createDefaultUser: false,
+            createOutputCompressor: false
+        });
+        const sourceBoxGraph = skeleton.boxGraph;
+        const targetBoxGraph = targetAudioUnitBox.graph;
+        sourceBoxGraph.beginTransaction();
+        PresetDecoder.decode(arrayBuffer, skeleton);
+        sourceBoxGraph.endTransaction();
+        const sourceAudioUnitBox = asDefined(skeleton.mandatoryBoxes.rootBox.audioUnits.pointerHub.incoming()
+            .map(({ box }) => asInstanceOf(box, AudioUnitBox))
+            .find((box) => box.type.getValue() !== AudioUnitType.Output), "Source has no audioUnitBox");
+        const sourceCaptureBox = sourceAudioUnitBox.capture.targetVertex.mapOr(({ box }) => box.name, "");
+        const targetCaptureBox = targetAudioUnitBox.capture.targetVertex.mapOr(({ box }) => box.name, "");
+        if (sourceCaptureBox !== targetCaptureBox) {
+            return Attempts.err("Cannot replace incompatible instruments");
+        }
+        const replaceMIDIEffects = options?.keepMIDIEffects !== true;
+        const replaceAudioEffects = options?.keepAudioEffects !== true;
+        console.debug("replaceMIDIEffects", replaceMIDIEffects);
+        console.debug("replaceAudioEffects", replaceAudioEffects);
+        asDefined(targetAudioUnitBox.input.pointerHub.incoming().at(0)?.box, "Target has no input").delete();
+        if (replaceMIDIEffects) {
+            targetAudioUnitBox.midiEffects.pointerHub.incoming().forEach(({ box }) => box.delete());
+        }
+        else {
+            sourceBoxGraph.beginTransaction();
+            sourceAudioUnitBox.midiEffects.pointerHub.incoming().forEach(({ box }) => box.delete());
+            sourceBoxGraph.endTransaction();
+        }
+        if (replaceAudioEffects) {
+            targetAudioUnitBox.audioEffects.pointerHub.incoming().forEach(({ box }) => box.delete());
+        }
+        else {
+            sourceBoxGraph.beginTransaction();
+            sourceAudioUnitBox.audioEffects.pointerHub.incoming().forEach(({ box }) => box.delete());
+            sourceBoxGraph.endTransaction();
+        }
+        // We do not take track or capture boxes into account
+        const excludeBox = (box) => box.accept({
+            visitTrackBox: (_box) => true,
+            visitCaptureMidiBox: (_box) => true,
+            visitCaptureAudioBox: (_box) => true
+        }) === true;
+        const uuidMap = UUID.newSet(({ source }) => source);
+        const dependencies = Array.from(sourceBoxGraph.dependenciesOf(sourceAudioUnitBox, {
+            excludeBox,
+            alwaysFollowMandatory: false
+        }).boxes);
+        uuidMap.addMany([
+            {
+                source: sourceAudioUnitBox.address.uuid,
+                target: targetAudioUnitBox.address.uuid
+            },
+            ...dependencies
+                .map(({ address: { uuid }, name }) => ({
+                source: uuid,
+                target: name === AudioFileBox.ClassName || name === SoundfontFileBox.ClassName
+                    ? uuid
+                    : UUID.generate()
+            }))
+        ]);
+        PointerField.decodeWith({
+            map: (_pointer, newAddress) => newAddress.map(address => uuidMap.opt(address.uuid).match({
+                none: () => address,
+                some: ({ target }) => address.moveTo(target)
+            }))
+        }, () => {
+            dependencies
+                .forEach((source) => {
+                const input = new ByteArrayInput(source.toArrayBuffer());
+                const key = source.name;
+                const uuid = uuidMap.get(source.address.uuid).target;
+                if (source instanceof AudioFileBox || source instanceof SoundfontFileBox) {
+                    // Those boxes keep their UUID. So if they are already in the graph, we can just read them.
+                    if (targetBoxGraph.findBox(source.address.uuid).nonEmpty()) {
+                        source.read(input);
+                        return;
+                    }
+                }
+                targetBoxGraph.createBox(key, uuid, box => box.read(input));
+            });
+        });
+        return Attempts.Ok;
+    };
+})(PresetDecoder || (PresetDecoder = {}));

package/dist/preset/PresetEncoder.d.ts

@@ -0,0 +1,5 @@
+import { AudioUnitBox } from "@opendaw/studio-boxes";
+export declare namespace PresetEncoder {
+    const encode: (audioUnitBox: AudioUnitBox) => ArrayBufferLike;
+}
+//# sourceMappingURL=PresetEncoder.d.ts.map

package/dist/preset/PresetEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PresetEncoder.d.ts","sourceRoot":"","sources":["../../src/preset/PresetEncoder.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,YAAY,EAAC,MAAM,uBAAuB,CAAA;AAKlD,yBAAiB,aAAa,CAAC;IACpB,MAAM,MAAM,GAAI,cAAc,YAAY,KAAG,eAWnD,CAAA;CACJ"}

package/dist/preset/PresetEncoder.js

@@ -0,0 +1,19 @@
+import { Arrays, ByteArrayOutput } from "@opendaw/lib-std";
+import { ProjectSkeleton } from "../project/ProjectSkeleton";
+import { ProjectUtils } from "../project/ProjectUtils";
+import { PresetHeader } from "./PresetHeader";
+export var PresetEncoder;
+(function (PresetEncoder) {
+    PresetEncoder.encode = (audioUnitBox) => {
+        const header = ByteArrayOutput.create();
+        header.writeInt(PresetHeader.MAGIC_HEADER_OPEN);
+        header.writeInt(PresetHeader.FORMAT_VERSION);
+        const preset = ProjectSkeleton.empty({ createOutputCompressor: false, createDefaultUser: false });
+        preset.boxGraph.beginTransaction();
+        ProjectUtils.extractAudioUnits([audioUnitBox], preset, { excludeTimeline: true });
+        preset.boxGraph.endTransaction();
+        console.debug("SAVING...");
+        preset.boxGraph.debugBoxes();
+        return Arrays.concatArrayBuffers(header.toArrayBuffer(), preset.boxGraph.toArrayBuffer());
+    };
+})(PresetEncoder || (PresetEncoder = {}));

package/dist/preset/PresetHeader.d.ts

@@ -0,0 +1,5 @@
+export declare namespace PresetHeader {
+    const MAGIC_HEADER_OPEN = 1330664005;
+    const FORMAT_VERSION = 1;
+}
+//# sourceMappingURL=PresetHeader.d.ts.map

package/dist/preset/PresetHeader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PresetHeader.d.ts","sourceRoot":"","sources":["../../src/preset/PresetHeader.ts"],"names":[],"mappings":"AAAA,yBAAiB,YAAY,CAAC;IACnB,MAAM,iBAAiB,aAAa,CAAA;IACpC,MAAM,cAAc,IAAI,CAAA;CAClC"}

package/dist/preset/PresetHeader.js

@@ -0,0 +1,5 @@
+export var PresetHeader;
+(function (PresetHeader) {
+    PresetHeader.MAGIC_HEADER_OPEN = 0x4F505245; // OPRE
+    PresetHeader.FORMAT_VERSION = 1;
+})(PresetHeader || (PresetHeader = {}));

package/dist/project/ProjectQueries.d.ts

@@ -0,0 +1,5 @@
+import { RootBox } from "@opendaw/studio-boxes";
+export declare namespace ProjectQueries {
+    const existingInstrumentNames: (rootBox: RootBox) => string[];
+}
+//# sourceMappingURL=ProjectQueries.d.ts.map

package/dist/project/ProjectQueries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProjectQueries.d.ts","sourceRoot":"","sources":["../../src/project/ProjectQueries.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,OAAO,EAAC,MAAM,uBAAuB,CAAA;AAG3D,yBAAiB,cAAc,CAAC;IACrB,MAAM,uBAAuB,GAAI,SAAS,OAAO,aAGtD,CAAA;CACL"}

package/dist/project/ProjectQueries.js

@@ -0,0 +1,10 @@
+import { asDefined, asInstanceOf } from "@opendaw/lib-std";
+import { AudioUnitBox } from "@opendaw/studio-boxes";
+import { StringField } from "@opendaw/lib-box";
+export var ProjectQueries;
+(function (ProjectQueries) {
+    ProjectQueries.existingInstrumentNames = (rootBox) => rootBox.audioUnits.pointerHub.incoming().map(({ box }) => {
+        const inputBox = asDefined(asInstanceOf(box, AudioUnitBox).input.pointerHub.incoming().at(0)).box;
+        return "label" in inputBox && inputBox.label instanceof StringField ? inputBox.label.getValue() : "N/A";
+    });
+})(ProjectQueries || (ProjectQueries = {}));

package/dist/project/ProjectSkeleton.d.ts

@@ -1,8 +1,17 @@
 import { BoxGraph } from "@opendaw/lib-box";
 import { BoxIO } from "@opendaw/studio-boxes";
-import { ProjectMandatoryBoxes } from "../index";
+import { ProjectMandatoryBoxes } from "./ProjectMandatoryBoxes";
 export type ProjectSkeleton = {
     boxGraph: BoxGraph<BoxIO.TypeMap>;
     mandatoryBoxes: ProjectMandatoryBoxes;
 };
+export declare namespace ProjectSkeleton {
+    const empty: (options: {
+        createOutputCompressor: boolean;
+        createDefaultUser: boolean;
+    }) => ProjectSkeleton;
+    const encode: (boxGraph: BoxGraph) => ArrayBufferLike;
+    const decode: (arrayBuffer: ArrayBufferLike) => ProjectSkeleton;
+    const findMandatoryBoxes: (boxGraph: BoxGraph) => ProjectMandatoryBoxes;
+}
 //# sourceMappingURL=ProjectSkeleton.d.ts.map

package/dist/project/ProjectSkeleton.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProjectSkeleton.d.ts","sourceRoot":"","sources":["../../src/project/ProjectSkeleton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,kBAAkB,CAAA;AACzC,OAAO,EAAC,KAAK,EAAC,MAAM,uBAAuB,CAAA;AAC3C,OAAO,EAAC,qBAAqB,EAAC,MAAM,UAAU,CAAA;AAE9C,MAAM,MAAM,eAAe,GAAG;IAC1B,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAClC,cAAc,EAAE,qBAAqB,CAAA;CACxC,CAAA"}
+{"version":3,"file":"ProjectSkeleton.d.ts","sourceRoot":"","sources":["../../src/project/ProjectSkeleton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,kBAAkB,CAAA;AACzC,OAAO,EAGH,KAAK,EAOR,MAAM,uBAAuB,CAAA;AAa9B,OAAO,EAAC,qBAAqB,EAAC,MAAM,yBAAyB,CAAA;AAE7D,MAAM,MAAM,eAAe,GAAG;IAC1B,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAClC,cAAc,EAAE,qBAAqB,CAAA;CACxC,CAAA;AAED,yBAAiB,eAAe,CAAC;IAItB,MAAM,KAAK,GAAI,SAAS;QAC3B,sBAAsB,EAAE,OAAO,CAAC;QAChC,iBAAiB,EAAE,OAAO,CAAA;KAC7B,KAAG,eAqDH,CAAA;IAEM,MAAM,MAAM,GAAI,UAAU,QAAQ,oBAQxC,CAAA;IAEM,MAAM,MAAM,GAAI,aAAa,eAAe,KAAG,eAYrD,CAAA;IAEM,MAAM,kBAAkB,GAAI,UAAU,QAAQ,KAAG,qBAiBvD,CAAA;CACJ"}

package/dist/project/ProjectSkeleton.js

@@ -1 +1,100 @@
-export {};
+import { BoxGraph } from "@opendaw/lib-box";
+import { AudioBusBox, AudioUnitBox, BoxIO, CompressorDeviceBox, GrooveShuffleBox, RootBox, TimelineBox, UserInterfaceBox } from "@opendaw/studio-boxes";
+import { asInstanceOf, assert, ByteArrayInput, ByteArrayOutput, isDefined, Option, panic, UUID } from "@opendaw/lib-std";
+import { AudioUnitType, IconSymbol } from "@opendaw/studio-enums";
+export var ProjectSkeleton;
+(function (ProjectSkeleton) {
+    const MAGIC_HEADER_OPEN = 0x4F50454E;
+    const FORMAT_VERSION = 2;
+    ProjectSkeleton.empty = (options) => {
+        const boxGraph = new BoxGraph(Option.wrap(BoxIO.create));
+        const isoString = new Date().toISOString();
+        console.debug(`New Project created on ${isoString}`);
+        boxGraph.beginTransaction();
+        const grooveShuffleBox = GrooveShuffleBox.create(boxGraph, UUID.generate(), box => {
+            box.label.setValue("Groove Shuffle");
+        });
+        const rootBox = RootBox.create(boxGraph, UUID.generate(), box => {
+            box.groove.refer(grooveShuffleBox);
+            box.created.setValue(isoString);
+        });
+        const primaryAudioBus = AudioBusBox.create(boxGraph, UUID.generate(), box => {
+            box.collection.refer(rootBox.audioBusses);
+            box.label.setValue("Output");
+            box.icon.setValue(IconSymbol.toName(IconSymbol.SpeakerHeadphone));
+            box.color.setValue(/*Colors.blue*/ "hsl(189, 100%, 65%)"); // TODO
+        });
+        const primaryAudioOutputUnit = AudioUnitBox.create(boxGraph, UUID.generate(), box => {
+            box.type.setValue(AudioUnitType.Output);
+            box.collection.refer(rootBox.audioUnits);
+            box.output.refer(rootBox.outputDevice);
+            box.index.setValue(0);
+        });
+        if (options.createOutputCompressor) {
+            CompressorDeviceBox.create(boxGraph, UUID.generate(), box => {
+                box.label.setValue("Compressor");
+                box.index.setValue(0);
+                box.host.refer(primaryAudioOutputUnit.audioEffects);
+                box.threshold.setValue(0);
+                box.ratio.setValue(24);
+            });
+        }
+        const timelineBox = TimelineBox.create(boxGraph, UUID.generate());
+        rootBox.timeline.refer(timelineBox.root);
+        primaryAudioBus.output.refer(primaryAudioOutputUnit.input);
+        const userInterfaceBoxes = [];
+        if (options.createDefaultUser) {
+            const userInterfaceBox = UserInterfaceBox.create(boxGraph, UUID.generate());
+            userInterfaceBox.root.refer(rootBox.users);
+            userInterfaceBoxes.push(userInterfaceBox);
+        }
+        boxGraph.endTransaction();
+        return {
+            boxGraph,
+            mandatoryBoxes: {
+                rootBox,
+                primaryAudioBus,
+                primaryAudioOutputUnit,
+                timelineBox,
+                userInterfaceBoxes
+            }
+        };
+    };
+    ProjectSkeleton.encode = (boxGraph) => {
+        const output = ByteArrayOutput.create();
+        output.writeInt(MAGIC_HEADER_OPEN);
+        output.writeInt(FORMAT_VERSION);
+        const boxGraphChunk = boxGraph.toArrayBuffer();
+        output.writeInt(boxGraphChunk.byteLength);
+        output.writeBytes(new Int8Array(boxGraphChunk));
+        return output.toArrayBuffer();
+    };
+    ProjectSkeleton.decode = (arrayBuffer) => {
+        const input = new ByteArrayInput(arrayBuffer);
+        assert(input.readInt() === MAGIC_HEADER_OPEN, "Corrupt header. Probably not an openDAW project file.");
+        assert(input.readInt() === FORMAT_VERSION, "Deprecated Format");
+        const boxGraphChunkLength = input.readInt();
+        const boxGraphChunk = new Int8Array(boxGraphChunkLength);
+        input.readBytes(boxGraphChunk);
+        const boxGraph = new BoxGraph(Option.wrap(BoxIO.create));
+        boxGraph.fromArrayBuffer(boxGraphChunk.buffer);
+        return { boxGraph, mandatoryBoxes: ProjectSkeleton.findMandatoryBoxes(boxGraph) };
+    };
+    ProjectSkeleton.findMandatoryBoxes = (boxGraph) => {
+        const rootBox = boxGraph.boxes().find(box => box.accept({ visitRootBox: () => true }));
+        if (isDefined(rootBox)) {
+            const primaryAudioOutputUnit = asInstanceOf(rootBox.outputDevice.pointerHub.incoming().at(0)?.box, AudioUnitBox);
+            const primaryAudioBus = asInstanceOf(primaryAudioOutputUnit.input.pointerHub.incoming().at(0)?.box, AudioBusBox);
+            const timelineBox = asInstanceOf(rootBox.timeline.targetVertex.unwrap("TimelineBox not found").box, TimelineBox);
+            const userInterfaceBoxes = rootBox.users.pointerHub.incoming().map(({ box }) => asInstanceOf(box, UserInterfaceBox));
+            return {
+                rootBox,
+                primaryAudioBus,
+                primaryAudioOutputUnit,
+                timelineBox,
+                userInterfaceBoxes
+            };
+        }
+        return panic("Could not find mandatory boxes");
+    };
+})(ProjectSkeleton || (ProjectSkeleton = {}));

package/dist/project/ProjectUtils.d.ts

@@ -0,0 +1,13 @@
+import { ppqn } from "@opendaw/lib-dsp";
+import { AudioUnitBox } from "@opendaw/studio-boxes";
+import { ProjectSkeleton } from "./ProjectSkeleton";
+import { AnyRegionBox } from "../unions";
+export declare namespace ProjectUtils {
+    const extractAudioUnits: (audioUnitBoxes: ReadonlyArray<AudioUnitBox>, { boxGraph, mandatoryBoxes: { primaryAudioBus, rootBox } }: ProjectSkeleton, options?: {
+        includeAux?: boolean;
+        includeBus?: boolean;
+        excludeTimeline?: boolean;
+    }) => ReadonlyArray<AudioUnitBox>;
+    const extractRegions: (regionBoxes: ReadonlyArray<AnyRegionBox>, { boxGraph, mandatoryBoxes: { primaryAudioBus, rootBox } }: ProjectSkeleton, insertPosition?: ppqn) => void;
+}
+//# sourceMappingURL=ProjectUtils.d.ts.map

package/dist/project/ProjectUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProjectUtils.d.ts","sourceRoot":"","sources":["../../src/project/ProjectUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,kBAAkB,CAAA;AAcrC,OAAO,EAEH,YAAY,EAQf,MAAM,uBAAuB,CAAA;AAE9B,OAAO,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAA;AACjD,OAAO,EAAC,YAAY,EAAgB,MAAM,WAAW,CAAA;AAGrD,yBAAiB,YAAY,CAAC;IASnB,MAAM,iBAAiB,GAAI,gBAAgB,aAAa,CAAC,YAAY,CAAC,EAC3C,4DAAwD,eAAe,EACvE,UAAS;QACL,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,eAAe,CAAC,EAAE,OAAO,CAAC;KACxB,KAClC,aAAa,CAAC,YAAY,CAgB/B,CAAA;IAEM,MAAM,cAAc,GAAI,aAAa,aAAa,CAAC,YAAY,CAAC,EACxC,4DAAwD,eAAe,EACvE,iBAAgB,IAAU,KAAG,IA8C3D,CAAA;CAqFJ"}

package/dist/project/ProjectUtils.js

@@ -0,0 +1,142 @@
+import { Arrays, asInstanceOf, assert, ByteArrayInput, isInstanceOf, Predicates, SetMultimap, UUID } from "@opendaw/lib-std";
+import { AudioFileBox, AudioUnitBox, AuxSendBox, SelectionBox, SoundfontFileBox, TrackBox } from "@opendaw/studio-boxes";
+import { IndexedBox, PointerField } from "@opendaw/lib-box";
+import { UnionBoxTypes } from "../unions";
+import { AudioUnitOrdering } from "../factories/AudioUnitOrdering";
+export var ProjectUtils;
+(function (ProjectUtils) {
+    const isSameGraph = ({ graph: a }, { graph: b }) => a === b;
+    const compareIndex = (a, b) => a.index.getValue() - b.index.getValue();
+    const excludeTimelinePredicate = (box) => box.accept({
+        visitTrackBox: (_box) => true
+    }) === true;
+    ProjectUtils.extractAudioUnits = (audioUnitBoxes, { boxGraph, mandatoryBoxes: { primaryAudioBus, rootBox } }, options = {}) => {
+        assert(Arrays.satisfy(audioUnitBoxes, isSameGraph), "AudioUnits must share the same BoxGraph");
+        // TODO Implement include options.
+        assert(!options.includeAux && !options.includeBus, "Options are not yet implemented");
+        const excludeBox = options?.excludeTimeline === true ? excludeTimelinePredicate : Predicates.alwaysFalse;
+        const dependencies = audioUnitBoxes
+            .flatMap(box => Array.from(box.graph.dependenciesOf(box, { alwaysFollowMandatory: true, excludeBox }).boxes))
+            .filter(box => box.name !== SelectionBox.ClassName && box.name !== AuxSendBox.ClassName);
+        const uuidMap = generateTransferMap(audioUnitBoxes, dependencies, rootBox.audioUnits.address.uuid, primaryAudioBus.address.uuid);
+        copy(uuidMap, boxGraph, audioUnitBoxes, dependencies);
+        reorderAudioUnits(uuidMap, audioUnitBoxes, rootBox);
+        console.debug("inTransaction", boxGraph.inTransaction());
+        return audioUnitBoxes.map(source => asInstanceOf(rootBox.graph
+            .findBox(uuidMap.get(source.address.uuid).target)
+            .unwrap("Target Track has not been copied"), AudioUnitBox));
+    };
+    ProjectUtils.extractRegions = (regionBoxes, { boxGraph, mandatoryBoxes: { primaryAudioBus, rootBox } }, insertPosition = 0.0) => {
+        assert(Arrays.satisfy(regionBoxes, isSameGraph), "Region smust be from the same BoxGraph");
+        const regionBoxSet = new Set(regionBoxes);
+        const trackBoxSet = new Set();
+        const audioUnitBoxSet = new SetMultimap();
+        // Collect AudioUnits and Tracks
+        regionBoxes.forEach(regionBox => {
+            const trackBox = asInstanceOf(regionBox.regions.targetVertex.unwrap().box, TrackBox);
+            trackBoxSet.add(trackBox);
+            const audioUnitBox = asInstanceOf(trackBox.tracks.targetVertex.unwrap().box, AudioUnitBox);
+            audioUnitBoxSet.add(audioUnitBox, trackBox);
+        });
+        console.debug(`Found ${audioUnitBoxSet.keyCount()} audioUnits`);
+        console.debug(`Found ${trackBoxSet.size} tracks`);
+        const audioUnitBoxes = [...audioUnitBoxSet.keys()];
+        const excludeBox = box => (isInstanceOf(box, TrackBox) && !trackBoxSet.has(box))
+            || (UnionBoxTypes.isRegionBox(box) && !regionBoxSet.has(box));
+        const dependencies = audioUnitBoxes
+            .flatMap(box => Array.from(box.graph.dependenciesOf(box, { excludeBox, alwaysFollowMandatory: true }).boxes))
+            .filter(box => box.name !== SelectionBox.ClassName && box.name !== AuxSendBox.ClassName);
+        const uuidMap = generateTransferMap(audioUnitBoxes, dependencies, rootBox.audioUnits.address.uuid, primaryAudioBus.address.uuid);
+        copy(uuidMap, boxGraph, audioUnitBoxes, dependencies);
+        reorderAudioUnits(uuidMap, audioUnitBoxes, rootBox);
+        // reorder track indices
+        audioUnitBoxSet.forEach((_, trackBoxes) => [...trackBoxes]
+            .sort(compareIndex)
+            .forEach((source, index) => {
+            const box = boxGraph
+                .findBox(uuidMap.get(source.address.uuid).target)
+                .unwrap("Target Track has not been copied");
+            asInstanceOf(box, TrackBox).index.setValue(index);
+        }));
+        // move new regions to the target position
+        const minPosition = regionBoxes.reduce((min, region) => Math.min(min, region.position.getValue()), Number.MAX_VALUE);
+        const delta = insertPosition - minPosition;
+        regionBoxes.forEach((source) => {
+            const box = boxGraph
+                .findBox(uuidMap.get(source.address.uuid).target)
+                .unwrap("Target Track has not been copied");
+            const position = UnionBoxTypes.asRegionBox(box).position;
+            position.setValue(position.getValue() + delta);
+        });
+    };
+    const generateTransferMap = (audioUnitBoxes, dependencies, rootBoxUUID, masterBusBoxUUID) => {
+        const uuidMap = UUID.newSet(({ source }) => source);
+        uuidMap.addMany([
+            ...audioUnitBoxes
+                .filter(({ output: { targetAddress } }) => targetAddress.nonEmpty())
+                .map(box => ({
+                source: box.output.targetAddress.unwrap().uuid,
+                target: masterBusBoxUUID
+            })),
+            ...audioUnitBoxes
+                .map(box => ({
+                source: box.collection.targetAddress.unwrap("AudioUnitBox was not connected to a RootBox").uuid,
+                target: rootBoxUUID
+            })),
+            ...audioUnitBoxes
+                .map(box => ({
+                source: box.address.uuid,
+                target: UUID.generate()
+            })),
+            ...dependencies
+                .map(({ address: { uuid }, name }) => ({
+                source: uuid,
+                target: name === AudioFileBox.ClassName || name === SoundfontFileBox.ClassName
+                    ? uuid
+                    : UUID.generate()
+            }))
+        ]);
+        return uuidMap;
+    };
+    const copy = (uuidMap, boxGraph, audioUnitBoxes, dependencies) => {
+        PointerField.decodeWith({
+            map: (_pointer, newAddress) => newAddress.map(address => uuidMap.opt(address.uuid).match({
+                none: () => address,
+                some: ({ target }) => address.moveTo(target)
+            }))
+        }, () => {
+            audioUnitBoxes
+                .forEach((source) => {
+                const input = new ByteArrayInput(source.toArrayBuffer());
+                const key = source.name;
+                const uuid = uuidMap.get(source.address.uuid).target;
+                boxGraph.createBox(key, uuid, box => box.read(input));
+            });
+            dependencies
+                .forEach((source) => {
+                const input = new ByteArrayInput(source.toArrayBuffer());
+                const key = source.name;
+                const uuid = uuidMap.get(source.address.uuid).target;
+                if (source instanceof AudioFileBox || source instanceof SoundfontFileBox) {
+                    // Those boxes keep their UUID. So if they are already in the graph, we can just read them.
+                    if (boxGraph.findBox(source.address.uuid).nonEmpty()) {
+                        source.read(input);
+                        return;
+                    }
+                }
+                boxGraph.createBox(key, uuid, box => box.read(input));
+            });
+        });
+    };
+    const reorderAudioUnits = (uuidMap, audioUnitBoxes, rootBox) => audioUnitBoxes
+        .toSorted(compareIndex)
+        .map(source => (asInstanceOf(rootBox.graph
+        .findBox(uuidMap.get(source.address.uuid).target)
+        .unwrap("Target Track has not been copied"), AudioUnitBox)))
+        .forEach((target) => IndexedBox.collectIndexedBoxes(rootBox.audioUnits, AudioUnitBox).toSorted((a, b) => {
+        const orderA = AudioUnitOrdering[a.type.getValue()];
+        const orderB = AudioUnitOrdering[b.type.getValue()];
+        const orderDifference = orderA - orderB;
+        return orderDifference === 0 ? b === target ? -1 : 1 : orderDifference;
+    }).forEach((box, index) => box.index.setValue(index)));
+})(ProjectUtils || (ProjectUtils = {}));

package/dist/protocols.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"protocols.d.ts","sourceRoot":"","sources":["../src/protocols.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAC,MAAM,kBAAkB,CAAA;AAChE,OAAO,EAAC,IAAI,EAAC,MAAM,kBAAkB,CAAA;AACrC,OAAO,EAAC,SAAS,EAAC,MAAM,mBAAmB,CAAA;AAC3C,OAAO,EAAC,qBAAqB,EAAC,MAAM,qBAAqB,CAAA;AACzD,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAA;AACvC,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,YAAY,CAAA;AAE1C,MAAM,WAAW,cAAe,SAAQ,UAAU;IAC9C,IAAI,IAAI,IAAI,CAAA;IACZ,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAA;IAC1B,WAAW,CAAC,QAAQ,EAAE,IAAI,GAAG,IAAI,CAAA;IACjC,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAA;IAC7C,aAAa,IAAI,IAAI,CAAA;IAErB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAA;IAC3C,2BAA2B,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAA;IACnD,mBAAmB,CAAC,KAAK,EAAE,GAAG,GAAG,IAAI,CAAA;IACrC,oBAAoB,IAAI,OAAO,CAAC,OAAO,CAAC,CAAA;IAExC,KAAK,IAAI,IAAI,CAAA;IAEb,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAAA;IACpC,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAA;IAExC,gBAAgB,CAAC,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAA;IAC1D,gBAAgB,CAAC,QAAQ,EAAE,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAA;CAC9D;AAED,MAAM,WAAW,cAAc;IAC3B,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,KAAK,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAAA;IAC5B,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,SAAS,CAAC,CAAA;IAChD,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,CAAA;IACrD,yBAAyB,CAAC,OAAO,EAAE,qBAAqB,GAAG,IAAI,CAAA;IAC/D,iBAAiB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,GAAG,IAAI,CAAA;IAC3D,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAA;IACpF,KAAK,IAAI,IAAI,CAAA;CAChB"}
+{"version":3,"file":"protocols.d.ts","sourceRoot":"","sources":["../src/protocols.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAC,MAAM,kBAAkB,CAAA;AAChE,OAAO,EAAC,IAAI,EAAC,MAAM,kBAAkB,CAAA;AACrC,OAAO,EAAC,SAAS,EAAC,MAAM,mBAAmB,CAAA;AAC3C,OAAO,EAAC,qBAAqB,EAAC,MAAM,qBAAqB,CAAA;AACzD,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAA;AACvC,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,YAAY,CAAA;AAE1C,MAAM,WAAW,cAAe,SAAQ,UAAU;IAC9C,IAAI,IAAI,IAAI,CAAA;IACZ,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAA;IAC1B,WAAW,CAAC,QAAQ,EAAE,IAAI,GAAG,IAAI,CAAA;IACjC,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAA;IAC7C,aAAa,IAAI,IAAI,CAAA;IACrB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAA;IAC3C,2BAA2B,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAA;IACnD,mBAAmB,CAAC,KAAK,EAAE,GAAG,GAAG,IAAI,CAAA;IACrC,oBAAoB,IAAI,OAAO,CAAC,OAAO,CAAC,CAAA;IAExC,KAAK,IAAI,IAAI,CAAA;IAEb,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAAA;IACpC,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAA;IAExC,gBAAgB,CAAC,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAA;IAC1D,gBAAgB,CAAC,QAAQ,EAAE,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAA;CAC9D;AAED,MAAM,WAAW,cAAc;IAC3B,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,KAAK,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAAA;IAC5B,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,SAAS,CAAC,CAAA;IAChD,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,CAAA;IACrD,yBAAyB,CAAC,OAAO,EAAE,qBAAqB,GAAG,IAAI,CAAA;IAC/D,iBAAiB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,GAAG,IAAI,CAAA;IAC3D,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAA;IACpF,KAAK,IAAI,IAAI,CAAA;CAChB"}

package/dist/selection/FilteredSelection.js

@@ -1,59 +1,72 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _FilteredSelection_selection, _FilteredSelection_filter, _FilteredSelection_mapping, _FilteredSelection_set, _FilteredSelection_listeners, _FilteredSelection_subscription;
 import { Listeners } from "@opendaw/lib-std";
 import { Address } from "@opendaw/lib-box";
 export class FilteredSelection {
-    #selection;
-    #filter;
-    #mapping;
-    #set;
-    #listeners;
-    #subscription;
     constructor(selection, filter, mapping) {
-        this.#selection = selection;
-        this.#filter = filter;
-        this.#mapping = mapping;
-        this.#set = Address.newSet(addressable => addressable.address);
-        this.#listeners = new Listeners();
-        this.#selection.selected()
-            .filter(element => this.#filter(element))
-            .forEach(element => this.#set.add(this.#mapping.fy(element)));
-        this.#subscription = this.#selection.catchupAndSubscribe({
+        _FilteredSelection_selection.set(this, void 0);
+        _FilteredSelection_filter.set(this, void 0);
+        _FilteredSelection_mapping.set(this, void 0);
+        _FilteredSelection_set.set(this, void 0);
+        _FilteredSelection_listeners.set(this, void 0);
+        _FilteredSelection_subscription.set(this, void 0);
+        __classPrivateFieldSet(this, _FilteredSelection_selection, selection, "f");
+        __classPrivateFieldSet(this, _FilteredSelection_filter, filter, "f");
+        __classPrivateFieldSet(this, _FilteredSelection_mapping, mapping, "f");
+        __classPrivateFieldSet(this, _FilteredSelection_set, Address.newSet(addressable => addressable.address), "f");
+        __classPrivateFieldSet(this, _FilteredSelection_listeners, new Listeners(), "f");
+        __classPrivateFieldGet(this, _FilteredSelection_selection, "f").selected()
+            .filter(element => __classPrivateFieldGet(this, _FilteredSelection_filter, "f").call(this, element))
+            .forEach(element => __classPrivateFieldGet(this, _FilteredSelection_set, "f").add(__classPrivateFieldGet(this, _FilteredSelection_mapping, "f").fy(element)));
+        __classPrivateFieldSet(this, _FilteredSelection_subscription, __classPrivateFieldGet(this, _FilteredSelection_selection, "f").catchupAndSubscribe({
             onSelected: (element) => {
-                if (this.#filter(element)) {
-                    const value = this.#mapping.fy(element);
-                    this.#set.add(value);
-                    this.#listeners.proxy.onSelected(value);
+                if (__classPrivateFieldGet(this, _FilteredSelection_filter, "f").call(this, element)) {
+                    const value = __classPrivateFieldGet(this, _FilteredSelection_mapping, "f").fy(element);
+                    __classPrivateFieldGet(this, _FilteredSelection_set, "f").add(value);
+                    __classPrivateFieldGet(this, _FilteredSelection_listeners, "f").proxy.onSelected(value);
                 }
             },
             onDeselected: (element) => {
-                if (this.#filter(element)) {
-                    this.#listeners.proxy.onDeselected(this.#set.removeByKey(element.address));
+                if (__classPrivateFieldGet(this, _FilteredSelection_filter, "f").call(this, element)) {
+                    __classPrivateFieldGet(this, _FilteredSelection_listeners, "f").proxy.onDeselected(__classPrivateFieldGet(this, _FilteredSelection_set, "f").removeByKey(element.address));
                 }
             }
-        });
+        }), "f");
     }
-    terminate() { this.#subscription.terminate(); }
+    terminate() { __classPrivateFieldGet(this, _FilteredSelection_subscription, "f").terminate(); }
     select(...selectables) {
-        this.#selection.select(...selectables.map(selectable => this.#mapping.fx(selectable)));
+        __classPrivateFieldGet(this, _FilteredSelection_selection, "f").select(...selectables.map(selectable => __classPrivateFieldGet(this, _FilteredSelection_mapping, "f").fx(selectable)));
     }
     deselect(...selectables) {
-        this.#selection.deselect(...selectables.map(selectable => this.#mapping.fx(selectable)));
+        __classPrivateFieldGet(this, _FilteredSelection_selection, "f").deselect(...selectables.map(selectable => __classPrivateFieldGet(this, _FilteredSelection_mapping, "f").fx(selectable)));
     }
     deselectAll() {
-        this.#selection.deselect(...(this.#set.values().map(selectable => this.#mapping.fx(selectable))));
+        __classPrivateFieldGet(this, _FilteredSelection_selection, "f").deselect(...(__classPrivateFieldGet(this, _FilteredSelection_set, "f").values().map(selectable => __classPrivateFieldGet(this, _FilteredSelection_mapping, "f").fx(selectable))));
     }
     distance(inventory) {
-        return this.#selection.distance(inventory.map(selectable => this.#mapping.fx(selectable))).map(item => this.#mapping.fy(item));
+        return __classPrivateFieldGet(this, _FilteredSelection_selection, "f").distance(inventory.map(selectable => __classPrivateFieldGet(this, _FilteredSelection_mapping, "f").fx(selectable))).map(item => __classPrivateFieldGet(this, _FilteredSelection_mapping, "f").fy(item));
     }
-    isEmpty() { return this.#set.size() === 0; }
-    nonEmpty() { return this.#set.size() > 0; }
-    count() { return this.#set.size(); }
-    isSelected(selectable) { return this.#set.hasKey(selectable.address); }
-    selected() { return this.#set.values(); }
+    isEmpty() { return __classPrivateFieldGet(this, _FilteredSelection_set, "f").size() === 0; }
+    nonEmpty() { return __classPrivateFieldGet(this, _FilteredSelection_set, "f").size() > 0; }
+    count() { return __classPrivateFieldGet(this, _FilteredSelection_set, "f").size(); }
+    isSelected(selectable) { return __classPrivateFieldGet(this, _FilteredSelection_set, "f").hasKey(selectable.address); }
+    selected() { return __classPrivateFieldGet(this, _FilteredSelection_set, "f").values(); }
     subscribe(listener) {
-        return this.#listeners.subscribe(listener);
+        return __classPrivateFieldGet(this, _FilteredSelection_listeners, "f").subscribe(listener);
     }
     catchupAndSubscribe(listener) {
-        this.#set.forEach(selectable => listener.onSelected(selectable));
+        __classPrivateFieldGet(this, _FilteredSelection_set, "f").forEach(selectable => listener.onSelected(selectable));
         return this.subscribe(listener);
     }
 }
+_FilteredSelection_selection = new WeakMap(), _FilteredSelection_filter = new WeakMap(), _FilteredSelection_mapping = new WeakMap(), _FilteredSelection_set = new WeakMap(), _FilteredSelection_listeners = new WeakMap(), _FilteredSelection_subscription = new WeakMap();