@opendaw/studio-core 0.0.99 → 0.0.101

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 === "external"));
+            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"}

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

@@ -0,0 +1,72 @@
+import { ByteArrayInput, ByteArrayOutput, Option } from "@opendaw/lib-std";
+import { Pointers } from "@opendaw/studio-enums";
+import { NoteEventBox } from "@opendaw/studio-boxes";
+import { NoteEventBoxAdapter } from "@opendaw/studio-adapters";
+import { ClipboardUtils } from "../ClipboardUtils";
+export var NotesClipboard;
+(function (NotesClipboard) {
+    const encodeMetadata = (min, max) => {
+        const output = ByteArrayOutput.create();
+        output.writeFloat(min);
+        output.writeFloat(max);
+        return output.toArrayBuffer();
+    };
+    const decodeMetadata = (buffer) => {
+        const input = new ByteArrayInput(buffer);
+        return { min: input.readFloat(), max: input.readFloat() };
+    };
+    NotesClipboard.createHandler = ({ getEnabled, getPosition, setPosition, editing, selection, targetAddress, boxGraph, boxAdapters }) => {
+        const copyNotes = () => {
+            const selected = selection.selected();
+            if (selected.length === 0) {
+                return Option.None;
+            }
+            const min = selected.reduce((acc, { position }) => Math.min(acc, position), Number.POSITIVE_INFINITY);
+            const max = selected.reduce((acc, { complete }) => Math.max(acc, complete), Number.NEGATIVE_INFINITY);
+            const eventBoxes = selected.map(adapter => adapter.box);
+            const dependencies = eventBoxes.flatMap(box => Array.from(boxGraph.dependenciesOf(box, {
+                alwaysFollowMandatory: true,
+                excludeBox: (dep) => dep.ephemeral
+            }).boxes));
+            const allBoxes = [...eventBoxes, ...dependencies];
+            const data = ClipboardUtils.serializeBoxes(allBoxes, encodeMetadata(min, max));
+            setPosition(max);
+            return Option.wrap({ type: "notes", data });
+        };
+        return {
+            canCopy: () => getEnabled() && selection.nonEmpty(),
+            canCut: () => getEnabled() && selection.nonEmpty(),
+            canPaste: (entry) => getEnabled() && entry.type === "notes",
+            copy: copyNotes,
+            cut: () => {
+                const result = copyNotes();
+                result.ifSome(() => editing.modify(() => selection.selected().forEach(adapter => adapter.box.delete())));
+                return result;
+            },
+            paste: (entry) => {
+                if (entry.type !== "notes" || !getEnabled()) {
+                    return;
+                }
+                const position = getPosition();
+                const { min, max } = decodeMetadata(ClipboardUtils.extractMetadata(entry.data));
+                const positionOffset = Math.max(0, position) - min;
+                editing.modify(() => {
+                    selection.deselectAll();
+                    const boxes = ClipboardUtils.deserializeBoxes(entry.data, boxGraph, {
+                        mapPointer: pointer => pointer.pointerType === Pointers.NoteEvents
+                            ? Option.wrap(targetAddress)
+                            : Option.None,
+                        modifyBox: box => {
+                            if (box instanceof NoteEventBox) {
+                                box.position.setValue(box.position.getValue() + positionOffset);
+                            }
+                        }
+                    });
+                    const noteEventBoxes = boxes.filter((box) => box instanceof NoteEventBox);
+                    selection.select(...noteEventBoxes.map(box => boxAdapters.adapterFor(box, NoteEventBoxAdapter)));
+                    setPosition(Math.max(0, position) + (max - min));
+                });
+            }
+        };
+    };
+})(NotesClipboard || (NotesClipboard = {}));

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

@@ -0,0 +1,24 @@
+import { Option, Procedure, Provider, Selection } from "@opendaw/lib-std";
+import { BoxEditing, BoxGraph } from "@opendaw/lib-box";
+import { ppqn } from "@opendaw/lib-dsp";
+import { AnyRegionBoxAdapter, BoxAdapters, TrackBoxAdapter } from "@opendaw/studio-adapters";
+import { ClipboardEntry, ClipboardHandler } from "../ClipboardManager";
+import { RegionOverlapResolver } from "../../timeline/RegionOverlapResolver";
+type ClipboardRegions = ClipboardEntry<"regions">;
+export declare namespace RegionsClipboard {
+    type Context = {
+        readonly getEnabled: Provider<boolean>;
+        readonly getPosition: Provider<ppqn>;
+        readonly setPosition: Procedure<ppqn>;
+        readonly editing: BoxEditing;
+        readonly selection: Selection<AnyRegionBoxAdapter>;
+        readonly boxGraph: BoxGraph;
+        readonly boxAdapters: BoxAdapters;
+        readonly getTracks: Provider<ReadonlyArray<TrackBoxAdapter>>;
+        readonly getFocusedTrack: Provider<Option<TrackBoxAdapter>>;
+        readonly overlapResolver: RegionOverlapResolver;
+    };
+    const createHandler: ({ getEnabled, getPosition, setPosition, editing, selection, boxGraph, boxAdapters, getTracks, getFocusedTrack, overlapResolver }: Context) => ClipboardHandler<ClipboardRegions>;
+}
+export {};
+//# sourceMappingURL=RegionsClipboardHandler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RegionsClipboardHandler.d.ts","sourceRoot":"","sources":["../../../../src/ui/clipboard/types/RegionsClipboardHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAO,MAAM,kBAAkB,CAAA;AAC9G,OAAO,EAAM,UAAU,EAAE,QAAQ,EAAC,MAAM,kBAAkB,CAAA;AAC1D,OAAO,EAAC,IAAI,EAAC,MAAM,kBAAkB,CAAA;AAErC,OAAO,EACH,mBAAmB,EACnB,WAAW,EAEX,eAAe,EAGlB,MAAM,0BAA0B,CAAA;AACjC,OAAO,EAAC,cAAc,EAAE,gBAAgB,EAAC,MAAM,qBAAqB,CAAA;AAEpE,OAAO,EAAC,qBAAqB,EAAC,MAAM,sCAAsC,CAAA;AAE1E,KAAK,gBAAgB,GAAG,cAAc,CAAC,SAAS,CAAC,CAAA;AAcjD,yBAAiB,gBAAgB,CAAC;IAC9B,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,QAAQ,EAAE,QAAQ,CAAA;QAC3B,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;QACjC,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,CAAA;QAC5D,QAAQ,CAAC,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,CAAA;QAC3D,QAAQ,CAAC,eAAe,EAAE,qBAAqB,CAAA;KAClD,CAAA;IA+BM,MAAM,aAAa,GAAI,kIAWG,OAAO,KAAG,gBAAgB,CAAC,gBAAgB,CAgG3E,CAAA;CACJ"}