@opendaw/studio-core 0.0.100 → 0.0.102

package/dist/ui/clipboard/ClipboardUtils.js

@@ -0,0 +1,94 @@
+import { ByteArrayInput, ByteArrayOutput, Option, UUID } from "@opendaw/lib-std";
+import { BoxGraph, PointerField } from "@opendaw/lib-box";
+import { BoxIO } from "@opendaw/studio-boxes";
+export var ClipboardUtils;
+(function (ClipboardUtils) {
+    ClipboardUtils.extractMetadata = (data) => {
+        const input = new ByteArrayInput(data);
+        const metadataLength = input.readInt();
+        const metadataBytes = new Int8Array(metadataLength);
+        input.readBytes(metadataBytes);
+        return metadataBytes.buffer;
+    };
+    ClipboardUtils.serializeBoxes = (boxes, metadata = new ArrayBuffer(0)) => {
+        const uniqueBoxes = UUID.newSet(box => box.address.uuid);
+        boxes.forEach(box => uniqueBoxes.add(box));
+        const typeCounts = new Map();
+        uniqueBoxes.forEach(box => typeCounts.set(box.name, (typeCounts.get(box.name) ?? 0) + 1));
+        const types = [...typeCounts.entries()].map(([type, count]) => `${type}: ${count}`).join(", ");
+        const clipboardGraph = new BoxGraph(Option.wrap(BoxIO.create));
+        clipboardGraph.beginTransaction();
+        uniqueBoxes.forEach(sourceBox => {
+            const input = new ByteArrayInput(sourceBox.toArrayBuffer());
+            clipboardGraph.createBox(sourceBox.name, sourceBox.address.uuid, box => box.read(input));
+        });
+        clipboardGraph.endTransaction();
+        const graphData = clipboardGraph.toArrayBuffer();
+        const output = ByteArrayOutput.create();
+        output.writeInt(metadata.byteLength);
+        output.writeBytes(new Int8Array(metadata));
+        output.writeInt(graphData.byteLength);
+        output.writeBytes(new Int8Array(graphData));
+        const arrayBuffer = output.toArrayBuffer();
+        console.debug(`Clipboard copy (${arrayBuffer.byteLength >> 10}kB): ${types}`);
+        return arrayBuffer;
+    };
+    ClipboardUtils.deserializeBoxes = (data, targetGraph, options) => {
+        const input = new ByteArrayInput(data);
+        input.skip(input.readInt());
+        const graphDataLength = input.readInt();
+        const graphData = new Int8Array(graphDataLength);
+        input.readBytes(graphData);
+        const clipboardGraph = new BoxGraph(Option.wrap(BoxIO.create));
+        clipboardGraph.fromArrayBuffer(graphData.buffer);
+        const skippedExternalUuids = UUID.newSet(uuid => uuid);
+        clipboardGraph.boxes().forEach(box => {
+            if (box.resource === "preserved" && targetGraph.findBox(box.address.uuid).nonEmpty()) {
+                skippedExternalUuids.add(box.address.uuid);
+            }
+        });
+        const shouldSkipBox = (box) => {
+            if (options.excludeBox?.(box)) {
+                return true;
+            }
+            if (box.resource === "preserved" && skippedExternalUuids.hasKey(box.address.uuid)) {
+                return true;
+            }
+            for (const [, targetAddress] of box.outgoingEdges()) {
+                if (skippedExternalUuids.hasKey(targetAddress.uuid) && !targetAddress.isBox()) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        const sourceBoxes = clipboardGraph.boxes().filter(box => !shouldSkipBox(box));
+        const typeCounts = new Map();
+        sourceBoxes.forEach(box => typeCounts.set(box.name, (typeCounts.get(box.name) ?? 0) + 1));
+        console.debug("Clipboard paste:", [...typeCounts.entries()].map(([type, count]) => `${type}: ${count}`).join(", "));
+        const uuidMap = UUID.newSet(({ source }) => source);
+        sourceBoxes.forEach(box => {
+            const isExternal = box.resource === "preserved";
+            uuidMap.add({ source: box.address.uuid, target: isExternal ? box.address.uuid : UUID.generate() });
+        });
+        skippedExternalUuids.forEach(uuid => uuidMap.add({ source: uuid, target: uuid }));
+        const result = [];
+        PointerField.decodeWith({
+            map: (pointer, address) => {
+                const remappedInternal = address.flatMap(addr => uuidMap.opt(addr.uuid).map(({ target }) => addr.moveTo(target)));
+                if (remappedInternal.nonEmpty()) {
+                    return remappedInternal;
+                }
+                return options.mapPointer(pointer, address);
+            }
+        }, () => sourceBoxes.forEach(sourceBox => {
+            const inputStream = new ByteArrayInput(sourceBox.toArrayBuffer());
+            const targetUuid = uuidMap.get(sourceBox.address.uuid).target;
+            targetGraph.createBox(sourceBox.name, targetUuid, box => {
+                box.read(inputStream);
+                options.modifyBox?.(box);
+                result.push(box);
+            });
+        }));
+        return result;
+    };
+})(ClipboardUtils || (ClipboardUtils = {}));

package/dist/ui/{generic → clipboard}/ContextMenu.d.ts

@@ -1,5 +1,5 @@
 import { Client, Subscription } from "@opendaw/lib-std";
-import { MenuItem } from "./MenuItems";
+import { MenuItem } from "../menu/MenuItems";
 export declare namespace ContextMenu {
     const CONTEXT_MENU_EVENT_TYPE: "--context-menu";
     type MenuFactory = (menuItem: MenuItem, client: Client) => void;

package/dist/ui/clipboard/ContextMenu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContextMenu.d.ts","sourceRoot":"","sources":["../../../src/ui/clipboard/ContextMenu.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAU,YAAY,EAAC,MAAM,kBAAkB,CAAA;AAE7D,OAAO,EAAC,QAAQ,EAAe,MAAM,mBAAmB,CAAA;AAExD,yBAAiB,WAAW,CAAC;IAClB,MAAM,uBAAuB,EAAG,gBAAyB,CAAA;IAEhE,KAAY,WAAW,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAEtE,UAAiB,SAAS;QACtB,QAAQ,CAAC,GAAG,KAAK,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAA;QAEpC,IAAI,MAAM,IAAI,MAAM,CAAA;KACvB;IAqCM,MAAM,OAAO,GAAI,OAAO,WAAW,EAAE,aAAa,WAAW,KAAG,YAkBhD,CAAA;IAEhB,MAAM,SAAS,GAAI,QAAQ,WAAW,EAAE,SAAS,CAAC,SAAS,EAAE,SAAS,KAAK,OAAO,KAAG,YAI/D,CAAA;CAChC"}

package/dist/ui/{generic → clipboard}/ContextMenu.js

@@ -1,6 +1,6 @@
 import { Option } from "@opendaw/lib-std";
 import { Events } from "@opendaw/lib-dom";
-import { MenuItem } from "./MenuItems";
+import { MenuItem } from "../menu/MenuItems";
 export var ContextMenu;
 (function (ContextMenu) {
     ContextMenu.CONTEXT_MENU_EVENT_TYPE = "--context-menu";

package/dist/ui/clipboard/types/AudioUnitsClipboardHandler.d.ts

@@ -0,0 +1,18 @@
+import { Option, Provider } from "@opendaw/lib-std";
+import { BoxEditing, BoxGraph } from "@opendaw/lib-box";
+import { AudioUnitBoxAdapter, RootBoxAdapter, UserEditing } from "@opendaw/studio-adapters";
+import { ClipboardEntry, ClipboardHandler } from "../ClipboardManager";
+type ClipboardAudioUnits = ClipboardEntry<"audio-units">;
+export declare namespace AudioUnitsClipboard {
+    type Context = {
+        readonly getEnabled: Provider<boolean>;
+        readonly editing: BoxEditing;
+        readonly boxGraph: BoxGraph;
+        readonly rootBoxAdapter: RootBoxAdapter;
+        readonly audioUnitEditing: UserEditing;
+        readonly getEditedAudioUnit: Provider<Option<AudioUnitBoxAdapter>>;
+    };
+    const createHandler: ({ getEnabled, editing, boxGraph, rootBoxAdapter, audioUnitEditing, getEditedAudioUnit }: Context) => ClipboardHandler<ClipboardAudioUnits>;
+}
+export {};
+//# sourceMappingURL=AudioUnitsClipboardHandler.d.ts.map

package/dist/ui/clipboard/types/AudioUnitsClipboardHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioUnitsClipboardHandler.d.ts","sourceRoot":"","sources":["../../../../src/ui/clipboard/types/AudioUnitsClipboardHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,MAAM,EAAE,QAAQ,EAAC,MAAM,kBAAkB,CAAA;AAClF,OAAO,EAAM,UAAU,EAAE,QAAQ,EAAa,MAAM,kBAAkB,CAAA;AAWtE,OAAO,EAAC,mBAAmB,EAAqB,cAAc,EAAE,WAAW,EAAC,MAAM,0BAA0B,CAAA;AAC5G,OAAO,EAAC,cAAc,EAAE,gBAAgB,EAAC,MAAM,qBAAqB,CAAA;AAGpE,KAAK,mBAAmB,GAAG,cAAc,CAAC,aAAa,CAAC,CAAA;AAMxD,yBAAiB,mBAAmB,CAAC;IACjC,KAAY,OAAO,GAAG;QAClB,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAA;QACtC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAA;QAC5B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;QAC3B,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAA;QACvC,QAAQ,CAAC,gBAAgB,EAAE,WAAW,CAAA;QACtC,QAAQ,CAAC,kBAAkB,EAAE,QAAQ,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC,CAAA;KACrE,CAAA;IAaM,MAAM,aAAa,GAAI,yFAOG,OAAO,KAAG,gBAAgB,CAAC,mBAAmB,CAsE9E,CAAA;CA6GJ"}

package/dist/ui/clipboard/types/AudioUnitsClipboardHandler.js

@@ -0,0 +1,215 @@
+import { ByteArrayInput, ByteArrayOutput, Option } from "@opendaw/lib-std";
+import { IndexedBox } from "@opendaw/lib-box";
+import { AudioUnitType, Pointers } from "@opendaw/studio-enums";
+import { AudioBusBox, AudioUnitBox, AuxSendBox, CaptureAudioBox, CaptureMidiBox, MIDIControllerBox, RootBox } from "@opendaw/studio-boxes";
+import { AudioUnitOrdering } from "@opendaw/studio-adapters";
+import { ClipboardUtils } from "../ClipboardUtils";
+export var AudioUnitsClipboard;
+(function (AudioUnitsClipboard) {
+    const encodeMetadata = (metadata) => {
+        const output = ByteArrayOutput.create();
+        output.writeString(metadata.type);
+        return output.toArrayBuffer();
+    };
+    const decodeMetadata = (buffer) => {
+        const input = new ByteArrayInput(buffer);
+        return { type: input.readString() };
+    };
+    AudioUnitsClipboard.createHandler = ({ getEnabled, editing, boxGraph, rootBoxAdapter, audioUnitEditing, getEditedAudioUnit }) => {
+        const copyAudioUnit = () => {
+            const optAudioUnit = getEditedAudioUnit();
+            if (optAudioUnit.isEmpty()) {
+                return Option.None;
+            }
+            const audioUnitAdapter = optAudioUnit.unwrap();
+            const audioUnitBox = audioUnitAdapter.box;
+            const isOutput = audioUnitAdapter.type === AudioUnitType.Output;
+            const dependencies = Array.from(audioUnitBox.graph.dependenciesOf(audioUnitBox, {
+                alwaysFollowMandatory: true,
+                stopAtResources: true,
+                excludeBox: (box) => {
+                    if (box.ephemeral) {
+                        return true;
+                    }
+                    if (box.name === RootBox.ClassName) {
+                        return true;
+                    }
+                    if (box.name === AudioBusBox.ClassName) {
+                        return true;
+                    }
+                    if (box.name === AuxSendBox.ClassName) {
+                        return true;
+                    }
+                    if (box.name === MIDIControllerBox.ClassName) {
+                        return true;
+                    }
+                    if (isOutput && box.name === CaptureAudioBox.ClassName) {
+                        return true;
+                    }
+                    if (isOutput && box.name === CaptureMidiBox.ClassName) {
+                        return true;
+                    }
+                    return false;
+                }
+            }).boxes);
+            const metadata = { type: audioUnitAdapter.type };
+            const allBoxes = [audioUnitBox, ...dependencies];
+            const data = ClipboardUtils.serializeBoxes(allBoxes, encodeMetadata(metadata));
+            return Option.wrap({ type: "audio-units", data });
+        };
+        return {
+            canCopy: () => getEnabled() && getEditedAudioUnit().nonEmpty(),
+            canCut: () => {
+                if (!getEnabled()) {
+                    return false;
+                }
+                const optAudioUnit = getEditedAudioUnit();
+                if (optAudioUnit.isEmpty()) {
+                    return false;
+                }
+                return !optAudioUnit.unwrap().isOutput;
+            },
+            canPaste: (entry) => getEnabled() && entry.type === "audio-units",
+            copy: copyAudioUnit,
+            cut: () => {
+                const optAudioUnit = getEditedAudioUnit();
+                if (optAudioUnit.isEmpty()) {
+                    return Option.None;
+                }
+                const audioUnit = optAudioUnit.unwrap();
+                if (audioUnit.isOutput) {
+                    return Option.None;
+                }
+                const result = copyAudioUnit();
+                result.ifSome(() => {
+                    editing.modify(() => {
+                        audioUnit.box.delete();
+                        rootBoxAdapter.audioUnits.adapters()
+                            .forEach((adapter, index) => adapter.indexField.setValue(index));
+                    });
+                });
+                return result;
+            },
+            paste: (entry) => {
+                if (entry.type !== "audio-units" || !getEnabled()) {
+                    return;
+                }
+                const metadata = decodeMetadata(ClipboardUtils.extractMetadata(entry.data));
+                const isOutputPaste = metadata.type === AudioUnitType.Output;
+                if (isOutputPaste) {
+                    // Split into two transactions to ensure deletion notifications fire
+                    // before new boxes are created (avoids "already has input" conflict)
+                    editing.modify(() => clearOutputContent(rootBoxAdapter));
+                    editing.modify(() => pasteOutputContent(entry.data, boxGraph, rootBoxAdapter));
+                }
+                else {
+                    editing.modify(() => {
+                        const pastedBox = pasteNewAudioUnit(entry.data, boxGraph, rootBoxAdapter, getEditedAudioUnit());
+                        if (pastedBox) {
+                            audioUnitEditing.edit(pastedBox.editing);
+                        }
+                    });
+                }
+            }
+        };
+    };
+    const clearOutputContent = (rootBoxAdapter) => {
+        const outputAdapter = rootBoxAdapter.audioUnits.adapters().find(adapter => adapter.isOutput);
+        if (!outputAdapter) {
+            return;
+        }
+        outputAdapter.tracks.collection.adapters().forEach(track => track.box.delete());
+        const inputAdapter = outputAdapter.input.adapter();
+        if (inputAdapter.nonEmpty() && inputAdapter.unwrap().type === "instrument") {
+            inputAdapter.unwrap().box.delete();
+        }
+        outputAdapter.midiEffects.adapters().forEach(effect => effect.box.delete());
+        outputAdapter.audioEffects.adapters().forEach(effect => effect.box.delete());
+    };
+    const pasteOutputContent = (data, boxGraph, rootBoxAdapter) => {
+        const outputAdapter = rootBoxAdapter.audioUnits.adapters().find(adapter => adapter.isOutput);
+        if (!outputAdapter) {
+            return;
+        }
+        const outputBox = outputAdapter.box;
+        const primaryBusAddress = rootBoxAdapter.audioBusses.adapters().at(0)?.address;
+        if (!primaryBusAddress) {
+            return;
+        }
+        ClipboardUtils.deserializeBoxes(data, boxGraph, {
+            mapPointer: (pointer, address) => {
+                if (pointer.pointerType === Pointers.TrackCollection) {
+                    return Option.wrap(outputBox.tracks.address);
+                }
+                if (pointer.pointerType === Pointers.InstrumentHost) {
+                    return Option.wrap(outputBox.input.address);
+                }
+                if (pointer.pointerType === Pointers.MIDIEffectHost) {
+                    return Option.wrap(outputBox.midiEffects.address);
+                }
+                if (pointer.pointerType === Pointers.AudioEffectHost) {
+                    return Option.wrap(outputBox.audioEffects.address);
+                }
+                if (pointer.pointerType === Pointers.AudioOutput) {
+                    return address.map(addr => addr.moveTo(primaryBusAddress.uuid));
+                }
+                return Option.None;
+            },
+            excludeBox: box => box.name === AudioUnitBox.ClassName || box.name === AudioBusBox.ClassName || box.name === RootBox.ClassName
+        });
+    };
+    const pasteNewAudioUnit = (data, boxGraph, rootBoxAdapter, currentAudioUnit) => {
+        const rootBox = rootBoxAdapter.box;
+        const primaryBusAddress = rootBoxAdapter.audioBusses.adapters().at(0)?.address;
+        if (!primaryBusAddress) {
+            return undefined;
+        }
+        const boxes = ClipboardUtils.deserializeBoxes(data, boxGraph, {
+            mapPointer: (pointer, address) => {
+                if (pointer.pointerType === Pointers.AudioUnits) {
+                    return Option.wrap(rootBox.audioUnits.address);
+                }
+                if (pointer.pointerType === Pointers.AudioOutput) {
+                    return address.map(addr => addr.moveTo(primaryBusAddress.uuid));
+                }
+                return Option.None;
+            }
+        });
+        const pastedAudioUnit = boxes.find(box => box.name === AudioUnitBox.ClassName);
+        if (!pastedAudioUnit) {
+            return undefined;
+        }
+        const insertAfterIndex = currentAudioUnit
+            .map(adapter => adapter.indexField.getValue())
+            .unwrapOrElse(() => -1);
+        reorderAudioUnitsAfterPaste(pastedAudioUnit, insertAfterIndex, rootBoxAdapter);
+        return pastedAudioUnit;
+    };
+    const reorderAudioUnitsAfterPaste = (pastedAudioUnit, insertAfterIndex, rootBoxAdapter) => {
+        const rootBox = rootBoxAdapter.box;
+        const allAudioUnits = IndexedBox.collectIndexedBoxes(rootBox.audioUnits, AudioUnitBox);
+        allAudioUnits.toSorted((a, b) => {
+            const orderA = AudioUnitOrdering[a.type.getValue()];
+            const orderB = AudioUnitOrdering[b.type.getValue()];
+            const orderDiff = orderA - orderB;
+            if (orderDiff !== 0) {
+                return orderDiff;
+            }
+            const aIsPasted = a === pastedAudioUnit;
+            const bIsPasted = b === pastedAudioUnit;
+            if (aIsPasted && !bIsPasted) {
+                if (insertAfterIndex === -1) {
+                    return -1;
+                }
+                return b.index.getValue() <= insertAfterIndex ? 1 : -1;
+            }
+            if (bIsPasted && !aIsPasted) {
+                if (insertAfterIndex === -1) {
+                    return 1;
+                }
+                return a.index.getValue() <= insertAfterIndex ? -1 : 1;
+            }
+            return a.index.getValue() - b.index.getValue();
+        }).forEach((box, index) => box.index.setValue(index));
+    };
+})(AudioUnitsClipboard || (AudioUnitsClipboard = {}));

package/dist/ui/clipboard/types/DevicesClipboardHandler.d.ts

@@ -0,0 +1,18 @@
+import { Option, Provider } from "@opendaw/lib-std";
+import { BoxEditing, BoxGraph } from "@opendaw/lib-box";
+import { BoxAdapters, DeviceBoxAdapter, DeviceHost, FilteredSelection } from "@opendaw/studio-adapters";
+import { ClipboardEntry, ClipboardHandler } from "../ClipboardManager";
+type ClipboardDevices = ClipboardEntry<"devices">;
+export declare namespace DevicesClipboard {
+    type Context = {
+        readonly getEnabled: Provider<boolean>;
+        readonly editing: BoxEditing;
+        readonly selection: FilteredSelection<DeviceBoxAdapter>;
+        readonly boxGraph: BoxGraph;
+        readonly boxAdapters: BoxAdapters;
+        readonly getHost: Provider<Option<DeviceHost>>;
+    };
+    const createHandler: ({ getEnabled, editing, selection, boxGraph, boxAdapters, getHost }: Context) => ClipboardHandler<ClipboardDevices>;
+}
+export {};
+//# sourceMappingURL=DevicesClipboardHandler.d.ts.map

package/dist/ui/clipboard/types/DevicesClipboardHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DevicesClipboardHandler.d.ts","sourceRoot":"","sources":["../../../../src/ui/clipboard/types/DevicesClipboardHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkD,MAAM,EAAY,QAAQ,EAAkB,MAAM,kBAAkB,CAAA;AAC7H,OAAO,EAAM,UAAU,EAAE,QAAQ,EAAC,MAAM,kBAAkB,CAAA;AAE1D,OAAO,EAEH,WAAW,EACX,gBAAgB,EAEhB,UAAU,EAGV,iBAAiB,EAGpB,MAAM,0BAA0B,CAAA;AACjC,OAAO,EAAC,cAAc,EAAE,gBAAgB,EAAC,MAAM,qBAAqB,CAAA;AAGpE,KAAK,gBAAgB,GAAG,cAAc,CAAC,SAAS,CAAC,CAAA;AAajD,yBAAiB,gBAAgB,CAAC;IAC9B,KAAY,OAAO,GAAG;QAClB,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAA;QACtC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAA;QAC5B,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAC,gBAAgB,CAAC,CAAA;QACvD,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;QAC3B,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;QACjC,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAA;KACjD,CAAA;IAyBM,MAAM,aAAa,GAAI,oEAOG,OAAO,KAAG,gBAAgB,CAAC,gBAAgB,CA0J3E,CAAA;CACJ"}

package/dist/ui/clipboard/types/DevicesClipboardHandler.js

@@ -0,0 +1,188 @@
+import { ByteArrayInput, ByteArrayOutput, isDefined, Option, RuntimeNotifier } from "@opendaw/lib-std";
+import { Pointers } from "@opendaw/studio-enums";
+import { DeviceBoxUtils, Devices } from "@opendaw/studio-adapters";
+import { ClipboardUtils } from "../ClipboardUtils";
+export var DevicesClipboard;
+(function (DevicesClipboard) {
+    const encodeMetadata = (metadata) => {
+        const output = ByteArrayOutput.create();
+        output.writeBoolean(metadata.hasInstrument);
+        output.writeString(metadata.instrumentContent);
+        output.writeInt(metadata.midiEffectCount);
+        output.writeInt(metadata.midiEffectMaxIndex);
+        output.writeInt(metadata.audioEffectCount);
+        output.writeInt(metadata.audioEffectMaxIndex);
+        return output.toArrayBuffer();
+    };
+    const decodeMetadata = (buffer) => {
+        const input = new ByteArrayInput(buffer);
+        return {
+            hasInstrument: input.readBoolean(),
+            instrumentContent: input.readString(),
+            midiEffectCount: input.readInt(),
+            midiEffectMaxIndex: input.readInt(),
+            audioEffectCount: input.readInt(),
+            audioEffectMaxIndex: input.readInt()
+        };
+    };
+    DevicesClipboard.createHandler = ({ getEnabled, editing, selection, boxGraph, boxAdapters, getHost }) => {
+        const isCopyable = (adapter) => adapter.box.tags.copyable !== false;
+        const copyableSelected = () => selection.selected().filter(isCopyable);
+        const copyDevices = () => {
+            const selected = copyableSelected();
+            if (selected.length === 0) {
+                return Option.None;
+            }
+            let instrument = null;
+            const midiEffects = [];
+            const audioEffects = [];
+            for (const adapter of selected) {
+                if (adapter.type === "instrument") {
+                    instrument = adapter;
+                }
+                else if (adapter.type === "midi-effect") {
+                    midiEffects.push(adapter);
+                }
+                else if (adapter.type === "audio-effect") {
+                    audioEffects.push(adapter);
+                }
+            }
+            if (instrument === null && midiEffects.length === 0 && audioEffects.length === 0) {
+                return Option.None;
+            }
+            midiEffects.sort((a, b) => a.indexField.getValue() - b.indexField.getValue());
+            audioEffects.sort((a, b) => a.indexField.getValue() - b.indexField.getValue());
+            const midiEffectMaxIndex = midiEffects.length > 0
+                ? midiEffects[midiEffects.length - 1].indexField.getValue()
+                : 0;
+            const audioEffectMaxIndex = audioEffects.length > 0
+                ? audioEffects[audioEffects.length - 1].indexField.getValue()
+                : 0;
+            const deviceBoxes = [
+                ...(instrument !== null ? [instrument.box] : []),
+                ...midiEffects.map(adapter => adapter.box),
+                ...audioEffects.map(adapter => adapter.box)
+            ];
+            const dependencies = deviceBoxes.flatMap(box => Array.from(boxGraph.dependenciesOf(box, {
+                alwaysFollowMandatory: true,
+                excludeBox: (dep) => dep.ephemeral || DeviceBoxUtils.isDeviceBox(dep)
+            }).boxes).filter(dep => dep.resource === "preserved"));
+            const allBoxes = [...deviceBoxes, ...dependencies];
+            const instrumentContent = instrument !== null
+                ? instrument.box.tags.content ?? ""
+                : "";
+            const metadata = {
+                hasInstrument: instrument !== null,
+                instrumentContent,
+                midiEffectCount: midiEffects.length,
+                midiEffectMaxIndex,
+                audioEffectCount: audioEffects.length,
+                audioEffectMaxIndex
+            };
+            const data = ClipboardUtils.serializeBoxes(allBoxes, encodeMetadata(metadata));
+            return Option.wrap({ type: "devices", data });
+        };
+        return {
+            canCopy: () => getEnabled() && copyableSelected().length > 0,
+            canCut: () => getEnabled() && copyableSelected().length > 0,
+            canPaste: (entry) => getEnabled() && entry.type === "devices",
+            copy: copyDevices,
+            cut: () => {
+                const result = copyDevices();
+                result.ifSome(() => {
+                    const optHost = getHost();
+                    if (optHost.isEmpty()) {
+                        return;
+                    }
+                    const host = optHost.unwrap();
+                    const selected = new Set(selection.selected().filter(adapter => adapter.type !== "instrument"));
+                    const remainingMidi = host.midiEffects.adapters().filter(adapter => !selected.has(adapter));
+                    const remainingAudio = host.audioEffects.adapters().filter(adapter => !selected.has(adapter));
+                    editing.modify(() => {
+                        selected.forEach(adapter => adapter.box.delete());
+                        remainingMidi.forEach((adapter, index) => adapter.indexField.setValue(index));
+                        remainingAudio.forEach((adapter, index) => adapter.indexField.setValue(index));
+                    });
+                });
+                return result;
+            },
+            paste: (entry) => {
+                if (entry.type !== "devices" || !getEnabled()) {
+                    return;
+                }
+                const optHost = getHost();
+                if (optHost.isEmpty()) {
+                    return;
+                }
+                const host = optHost.unwrap();
+                const metadata = decodeMetadata(ClipboardUtils.extractMetadata(entry.data));
+                const selected = selection.selected();
+                const selectedInstrument = selected.find(adapter => adapter.type === "instrument");
+                const selectedMidiEffects = selected.filter(adapter => adapter.type === "midi-effect");
+                const selectedAudioEffects = selected.filter(adapter => adapter.type === "audio-effect");
+                let replaceInstrument = metadata.hasInstrument && isDefined(selectedInstrument)
+                    && selectedInstrument.box.tags.copyable !== false;
+                if (replaceInstrument && isDefined(selectedInstrument)) {
+                    const selectedContent = selectedInstrument.box.tags.content;
+                    if (isDefined(selectedContent) && metadata.instrumentContent !== ""
+                        && selectedContent !== metadata.instrumentContent) {
+                        RuntimeNotifier.info({
+                            headline: "Incompatible Instrument",
+                            message: `Cannot replace a '${selectedContent}' instrument with a '${metadata.instrumentContent}' instrument.`
+                        }).finally();
+                        replaceInstrument = false;
+                    }
+                }
+                const midiInsertIndex = selectedMidiEffects.length > 0
+                    ? selectedMidiEffects.reduce((max, adapter) => Math.max(max, adapter.indexField.getValue()), -1) + 1
+                    : 0;
+                const audioInsertIndex = selectedAudioEffects.length > 0
+                    ? selectedAudioEffects.reduce((max, adapter) => Math.max(max, adapter.indexField.getValue()), -1) + 1
+                    : 0;
+                editing.modify(() => {
+                    selection.deselectAll();
+                    if (replaceInstrument && isDefined(selectedInstrument)) {
+                        selectedInstrument.box.delete();
+                    }
+                    for (const adapter of host.midiEffects.adapters()) {
+                        const currentIndex = adapter.indexField.getValue();
+                        if (currentIndex >= midiInsertIndex) {
+                            adapter.indexField.setValue(currentIndex + metadata.midiEffectCount);
+                        }
+                    }
+                    for (const adapter of host.audioEffects.adapters()) {
+                        const currentIndex = adapter.indexField.getValue();
+                        if (currentIndex >= audioInsertIndex) {
+                            adapter.indexField.setValue(currentIndex + metadata.audioEffectCount);
+                        }
+                    }
+                    const boxes = ClipboardUtils.deserializeBoxes(entry.data, boxGraph, {
+                        mapPointer: pointer => {
+                            if (pointer.pointerType === Pointers.InstrumentHost && replaceInstrument) {
+                                return Option.wrap(host.inputField.address);
+                            }
+                            if (pointer.pointerType === Pointers.MIDIEffectHost) {
+                                return Option.wrap(host.midiEffectsField.address);
+                            }
+                            if (pointer.pointerType === Pointers.AudioEffectHost) {
+                                return Option.wrap(host.audioEffectsField.address);
+                            }
+                            return Option.None;
+                        },
+                        excludeBox: box => DeviceBoxUtils.isInstrumentDeviceBox(box) && !replaceInstrument
+                    });
+                    const deviceBoxes = boxes.filter(box => DeviceBoxUtils.isDeviceBox(box));
+                    const newMidiEffects = deviceBoxes
+                        .filter((box) => DeviceBoxUtils.isEffectDeviceBox(box) && box.tags.deviceType === "midi-effect")
+                        .sort((a, b) => a.index.getValue() - b.index.getValue());
+                    const newAudioEffects = deviceBoxes
+                        .filter((box) => DeviceBoxUtils.isEffectDeviceBox(box) && box.tags.deviceType === "audio-effect")
+                        .sort((a, b) => a.index.getValue() - b.index.getValue());
+                    newMidiEffects.forEach((box, idx) => box.index.setValue(midiInsertIndex + idx));
+                    newAudioEffects.forEach((box, idx) => box.index.setValue(audioInsertIndex + idx));
+                    selection.select(...deviceBoxes.map(box => boxAdapters.adapterFor(box, Devices.isAny)));
+                });
+            }
+        };
+    };
+})(DevicesClipboard || (DevicesClipboard = {}));

package/dist/ui/clipboard/types/NotesClipboardHandler.d.ts

@@ -0,0 +1,21 @@
+import { Procedure, Provider, Selection } from "@opendaw/lib-std";
+import { Address, BoxEditing, BoxGraph } from "@opendaw/lib-box";
+import { ppqn } from "@opendaw/lib-dsp";
+import { BoxAdapters, NoteEventBoxAdapter } from "@opendaw/studio-adapters";
+import { ClipboardEntry, ClipboardHandler } from "../ClipboardManager";
+type ClipboardNotes = ClipboardEntry<"notes">;
+export declare namespace NotesClipboard {
+    type Context = {
+        readonly getEnabled: Provider<boolean>;
+        readonly getPosition: Provider<ppqn>;
+        readonly setPosition: Procedure<ppqn>;
+        readonly editing: BoxEditing;
+        readonly selection: Selection<NoteEventBoxAdapter>;
+        readonly targetAddress: Address;
+        readonly boxGraph: BoxGraph;
+        readonly boxAdapters: BoxAdapters;
+    };
+    const createHandler: ({ getEnabled, getPosition, setPosition, editing, selection, targetAddress, boxGraph, boxAdapters }: Context) => ClipboardHandler<ClipboardNotes>;
+}
+export {};
+//# sourceMappingURL=NotesClipboardHandler.d.ts.map

package/dist/ui/clipboard/types/NotesClipboardHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotesClipboardHandler.d.ts","sourceRoot":"","sources":["../../../../src/ui/clipboard/types/NotesClipboardHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0C,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAC,MAAM,kBAAkB,CAAA;AACxG,OAAO,EAAC,OAAO,EAAO,UAAU,EAAE,QAAQ,EAAC,MAAM,kBAAkB,CAAA;AACnE,OAAO,EAAC,IAAI,EAAC,MAAM,kBAAkB,CAAA;AAGrC,OAAO,EAAC,WAAW,EAAE,mBAAmB,EAAC,MAAM,0BAA0B,CAAA;AACzE,OAAO,EAAC,cAAc,EAAE,gBAAgB,EAAC,MAAM,qBAAqB,CAAA;AAGpE,KAAK,cAAc,GAAG,cAAc,CAAC,OAAO,CAAC,CAAA;AAE7C,yBAAiB,cAAc,CAAC;IAC5B,KAAY,OAAO,GAAG;QAClB,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAA;QACtC,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;QACpC,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC,IAAI,CAAC,CAAA;QACrC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAA;QAC5B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC,mBAAmB,CAAC,CAAA;QAClD,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAA;QAC/B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;QAC3B,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;KACpC,CAAA;IAcM,MAAM,aAAa,GAAI,oGASG,OAAO,KAAG,gBAAgB,CAAC,cAAc,CAsDzE,CAAA;CACJ"}