@opendaw/studio-core 0.0.105 → 0.0.106

package/dist/ui/transfer/TransferRegions.test.js

@@ -0,0 +1,242 @@
+import "../../polyfill";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { Terminable, UUID } from "@opendaw/lib-std";
+import { AudioUnitBox, CaptureAudioBox, TrackBox, ValueEventCollectionBox, ValueRegionBox } from "@opendaw/studio-boxes";
+import { AudioUnitType } from "@opendaw/studio-enums";
+import { ProjectSkeleton, TrackType } from "@opendaw/studio-adapters";
+import { Project } from "../../project";
+import { TransferRegions } from "./TransferRegions";
+const createEnv = () => ({
+    audioContext: {},
+    audioWorklets: {},
+    sampleManager: {
+        getOrCreate: () => ({}),
+        record: () => { },
+        remove: () => { },
+        invalidate: () => { },
+        register: () => Terminable.Empty
+    },
+    soundfontManager: {
+        getOrCreate: () => ({}),
+        remove: () => { },
+        invalidate: () => { }
+    }
+});
+const createProject = () => {
+    const skeleton = ProjectSkeleton.empty({ createDefaultUser: true, createOutputCompressor: false });
+    return Project.fromSkeleton(createEnv(), skeleton, false);
+};
+const createTrackWithRegion = (project, position = 100, duration = 200) => {
+    const { boxGraph } = project;
+    const captureBox = CaptureAudioBox.create(boxGraph, UUID.generate());
+    const audioUnitBox = AudioUnitBox.create(boxGraph, UUID.generate(), box => {
+        box.type.setValue(AudioUnitType.Instrument);
+        box.collection.refer(project.rootBox.audioUnits);
+        box.output.refer(project.masterBusBox.input);
+        box.capture.refer(captureBox);
+        box.index.setValue(1);
+    });
+    const trackBox = TrackBox.create(boxGraph, UUID.generate(), box => {
+        box.type.setValue(TrackType.Value);
+        box.tracks.refer(audioUnitBox.tracks);
+        box.target.refer(audioUnitBox);
+        box.index.setValue(0);
+    });
+    const collectionBox = ValueEventCollectionBox.create(boxGraph, UUID.generate());
+    const regionBox = ValueRegionBox.create(boxGraph, UUID.generate(), box => {
+        box.position.setValue(position);
+        box.duration.setValue(duration);
+        box.loopDuration.setValue(duration);
+        box.hue.setValue(42);
+        box.events.refer(collectionBox.owners);
+        box.regions.refer(trackBox.regions);
+    });
+    return { audioUnitBox, trackBox, regionBox, collectionBox };
+};
+describe("TransferRegions.transfer", () => {
+    let project;
+    beforeEach(() => { project = createProject(); });
+    afterEach(() => project.terminate());
+    describe("same graph", () => {
+        it("copies region to same track at new position", () => {
+            const { boxGraph } = project;
+            boxGraph.beginTransaction();
+            const { trackBox, regionBox } = createTrackWithRegion(project);
+            boxGraph.endTransaction();
+            boxGraph.beginTransaction();
+            const copied = TransferRegions.transfer(regionBox, trackBox, 500, false);
+            boxGraph.endTransaction();
+            expect(copied.position.getValue()).toBe(500);
+            expect(copied.graph).toBe(boxGraph);
+            expect(trackBox.regions.pointerHub.incoming().length).toBe(2);
+            boxGraph.verifyPointers();
+        });
+        it("copies region to different track", () => {
+            const { boxGraph } = project;
+            boxGraph.beginTransaction();
+            const { trackBox: trackA, regionBox, audioUnitBox } = createTrackWithRegion(project);
+            const trackB = TrackBox.create(boxGraph, UUID.generate(), box => {
+                box.type.setValue(TrackType.Value);
+                box.tracks.refer(audioUnitBox.tracks);
+                box.target.refer(audioUnitBox);
+                box.index.setValue(1);
+            });
+            boxGraph.endTransaction();
+            boxGraph.beginTransaction();
+            const copied = TransferRegions.transfer(regionBox, trackB, 300, false);
+            boxGraph.endTransaction();
+            expect(copied.position.getValue()).toBe(300);
+            const targetUuid = copied.regions.targetVertex.unwrap().box.address.uuid;
+            expect(UUID.equals(targetUuid, trackB.address.uuid)).toBe(true);
+            expect(trackB.regions.pointerHub.incoming().length).toBe(1);
+            expect(trackA.regions.pointerHub.incoming().length).toBe(1);
+            boxGraph.verifyPointers();
+        });
+        it("creates new UUID for copied region", () => {
+            const { boxGraph } = project;
+            boxGraph.beginTransaction();
+            const { trackBox, regionBox } = createTrackWithRegion(project);
+            boxGraph.endTransaction();
+            boxGraph.beginTransaction();
+            const copied = TransferRegions.transfer(regionBox, trackBox, 500, false);
+            boxGraph.endTransaction();
+            expect(UUID.equals(copied.address.uuid, regionBox.address.uuid)).toBe(false);
+        });
+        it("preserves region properties", () => {
+            const { boxGraph } = project;
+            boxGraph.beginTransaction();
+            const { trackBox, regionBox } = createTrackWithRegion(project);
+            boxGraph.endTransaction();
+            boxGraph.beginTransaction();
+            const copied = TransferRegions.transfer(regionBox, trackBox, 500, false);
+            boxGraph.endTransaction();
+            expect(copied.duration.getValue()).toBe(200);
+            expect(copied.loopDuration.getValue()).toBe(200);
+            expect(copied.hue.getValue()).toBe(42);
+        });
+        it("deletes source when deleteSource is true", () => {
+            const { boxGraph } = project;
+            boxGraph.beginTransaction();
+            const { trackBox, regionBox } = createTrackWithRegion(project);
+            boxGraph.endTransaction();
+            boxGraph.beginTransaction();
+            TransferRegions.transfer(regionBox, trackBox, 500);
+            boxGraph.endTransaction();
+            expect(regionBox.isAttached()).toBe(false);
+            expect(trackBox.regions.pointerHub.incoming().length).toBe(1);
+            boxGraph.verifyPointers();
+        });
+        it("keeps source when deleteSource is false", () => {
+            const { boxGraph } = project;
+            boxGraph.beginTransaction();
+            const { trackBox, regionBox } = createTrackWithRegion(project);
+            boxGraph.endTransaction();
+            boxGraph.beginTransaction();
+            TransferRegions.transfer(regionBox, trackBox, 500, false);
+            boxGraph.endTransaction();
+            expect(regionBox.isAttached()).toBe(true);
+            expect(trackBox.regions.pointerHub.incoming().length).toBe(2);
+        });
+        it("copies event collection dependency with new UUID", () => {
+            const { boxGraph } = project;
+            boxGraph.beginTransaction();
+            const { trackBox, regionBox, collectionBox } = createTrackWithRegion(project);
+            boxGraph.endTransaction();
+            boxGraph.beginTransaction();
+            const copied = TransferRegions.transfer(regionBox, trackBox, 500, false);
+            boxGraph.endTransaction();
+            const copiedEventsVertex = copied.events.targetVertex.unwrap();
+            const copiedCollectionUuid = copiedEventsVertex.box.address.uuid;
+            expect(UUID.equals(copiedCollectionUuid, collectionBox.address.uuid)).toBe(false);
+            boxGraph.verifyPointers();
+        });
+    });
+    describe("cross graph", () => {
+        let sourceProject;
+        beforeEach(() => { sourceProject = createProject(); });
+        afterEach(() => sourceProject.terminate());
+        it("copies region to target graph at given position", () => {
+            const sourceGraph = sourceProject.boxGraph;
+            sourceGraph.beginTransaction();
+            const { regionBox: sourceRegion } = createTrackWithRegion(sourceProject);
+            sourceGraph.endTransaction();
+            const { boxGraph } = project;
+            boxGraph.beginTransaction();
+            const { trackBox: targetTrack } = createTrackWithRegion(project);
+            boxGraph.endTransaction();
+            const regionsBefore = targetTrack.regions.pointerHub.incoming().length;
+            boxGraph.beginTransaction();
+            const copied = TransferRegions.transfer(sourceRegion, targetTrack, 500, false);
+            boxGraph.endTransaction();
+            expect(copied.position.getValue()).toBe(500);
+            expect(copied.graph).toBe(boxGraph);
+            expect(copied.graph).not.toBe(sourceGraph);
+            expect(targetTrack.regions.pointerHub.incoming().length).toBe(regionsBefore + 1);
+            boxGraph.verifyPointers();
+            sourceGraph.verifyPointers();
+        });
+        it("creates new UUID for copied region", () => {
+            const sourceGraph = sourceProject.boxGraph;
+            sourceGraph.beginTransaction();
+            const { regionBox: sourceRegion } = createTrackWithRegion(sourceProject);
+            sourceGraph.endTransaction();
+            const { boxGraph } = project;
+            boxGraph.beginTransaction();
+            const { trackBox: targetTrack } = createTrackWithRegion(project);
+            boxGraph.endTransaction();
+            boxGraph.beginTransaction();
+            const copied = TransferRegions.transfer(sourceRegion, targetTrack, 500, false);
+            boxGraph.endTransaction();
+            expect(UUID.equals(copied.address.uuid, sourceRegion.address.uuid)).toBe(false);
+        });
+        it("preserves region properties", () => {
+            const sourceGraph = sourceProject.boxGraph;
+            sourceGraph.beginTransaction();
+            const { regionBox: sourceRegion } = createTrackWithRegion(sourceProject, 100, 300);
+            sourceGraph.endTransaction();
+            const { boxGraph } = project;
+            boxGraph.beginTransaction();
+            const { trackBox: targetTrack } = createTrackWithRegion(project);
+            boxGraph.endTransaction();
+            boxGraph.beginTransaction();
+            const copied = TransferRegions.transfer(sourceRegion, targetTrack, 500, false);
+            boxGraph.endTransaction();
+            expect(copied.duration.getValue()).toBe(300);
+            expect(copied.loopDuration.getValue()).toBe(300);
+            expect(copied.hue.getValue()).toBe(42);
+        });
+        it("keeps source in source graph when deleteSource is false", () => {
+            const sourceGraph = sourceProject.boxGraph;
+            sourceGraph.beginTransaction();
+            const { regionBox: sourceRegion } = createTrackWithRegion(sourceProject);
+            sourceGraph.endTransaction();
+            const { boxGraph } = project;
+            boxGraph.beginTransaction();
+            const { trackBox: targetTrack } = createTrackWithRegion(project);
+            boxGraph.endTransaction();
+            boxGraph.beginTransaction();
+            TransferRegions.transfer(sourceRegion, targetTrack, 500, false);
+            boxGraph.endTransaction();
+            expect(sourceRegion.isAttached()).toBe(true);
+            sourceGraph.verifyPointers();
+        });
+        it("deletes source when deleteSource is true", () => {
+            const sourceGraph = sourceProject.boxGraph;
+            sourceGraph.beginTransaction();
+            const { regionBox: sourceRegion } = createTrackWithRegion(sourceProject);
+            sourceGraph.endTransaction();
+            const { boxGraph } = project;
+            boxGraph.beginTransaction();
+            const { trackBox: targetTrack } = createTrackWithRegion(project);
+            boxGraph.endTransaction();
+            sourceGraph.beginTransaction();
+            boxGraph.beginTransaction();
+            TransferRegions.transfer(sourceRegion, targetTrack, 500);
+            boxGraph.endTransaction();
+            sourceGraph.endTransaction();
+            expect(sourceRegion.isAttached()).toBe(false);
+            boxGraph.verifyPointers();
+            sourceGraph.verifyPointers();
+        });
+    });
+});

package/dist/ui/transfer/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./TransferRegions";
+//# sourceMappingURL=index.d.ts.map

package/dist/ui/transfer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ui/transfer/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA"}

package/dist/ui/transfer/index.js

@@ -0,0 +1 @@
+export * from "./TransferRegions";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opendaw/studio-core",
-  "version": "0.0.105",
+  "version": "0.0.106",
   "license": "LGPL-3.0-or-later",
   "publishConfig": {
     "access": "public"
@@ -33,17 +33,17 @@
     "test": "vitest run --config vitest.config.ts"
   },
   "dependencies": {
-    "@opendaw/lib-box": "^0.0.72",
-    "@opendaw/lib-dawproject": "^0.0.57",
-    "@opendaw/lib-dom": "^0.0.73",
-    "@opendaw/lib-dsp": "^0.0.71",
-    "@opendaw/lib-fusion": "^0.0.77",
-    "@opendaw/lib-runtime": "^0.0.69",
-    "@opendaw/lib-std": "^0.0.68",
+    "@opendaw/lib-box": "^0.0.73",
+    "@opendaw/lib-dawproject": "^0.0.58",
+    "@opendaw/lib-dom": "^0.0.74",
+    "@opendaw/lib-dsp": "^0.0.72",
+    "@opendaw/lib-fusion": "^0.0.78",
+    "@opendaw/lib-runtime": "^0.0.70",
+    "@opendaw/lib-std": "^0.0.69",
     "@opendaw/nam-wasm": "^1.0.3",
-    "@opendaw/studio-adapters": "^0.0.83",
-    "@opendaw/studio-boxes": "^0.0.74",
-    "@opendaw/studio-enums": "^0.0.63",
+    "@opendaw/studio-adapters": "^0.0.84",
+    "@opendaw/studio-boxes": "^0.0.75",
+    "@opendaw/studio-enums": "^0.0.64",
     "dropbox": "^10.34.0",
     "y-websocket": "^1.4.5",
     "yjs": "^13.6.27",
@@ -57,10 +57,10 @@
     "@ffmpeg/ffmpeg": "^0.12.15",
     "@ffmpeg/util": "^0.12.2",
     "@opendaw/eslint-config": "^0.0.27",
-    "@opendaw/studio-core-processors": "^0.0.86",
-    "@opendaw/studio-core-workers": "^0.0.78",
-    "@opendaw/studio-forge-boxes": "^0.0.74",
-    "@opendaw/typescript-config": "^0.0.28"
+    "@opendaw/studio-core-processors": "^0.0.87",
+    "@opendaw/studio-core-workers": "^0.0.79",
+    "@opendaw/studio-forge-boxes": "^0.0.75",
+    "@opendaw/typescript-config": "^0.0.29"
   },
-  "gitHead": "b39d786e60cee02599e0f3d7106e635a870c47c6"
+  "gitHead": "60447f48d38d7cd08ef6a74bb011700dffff68f7"
 }

package/dist/project/ProjectApi.test.d.ts

@@ -1,2 +0,0 @@
-import "./polyfill";
-//# sourceMappingURL=ProjectApi.test.d.ts.map

package/dist/project/ProjectApi.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ProjectApi.test.d.ts","sourceRoot":"","sources":["../../src/project/ProjectApi.test.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,CAAA"}

package/dist/project/ProjectApi.test.js

@@ -1,109 +0,0 @@
-import "./polyfill";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { asInstanceOf, Terminable, UUID } from "@opendaw/lib-std";
-import { AudioUnitBox, CaptureAudioBox, TrackBox, ValueEventCollectionBox, ValueRegionBox } from "@opendaw/studio-boxes";
-import { AudioUnitType } from "@opendaw/studio-enums";
-import { ProjectSkeleton, TrackType } from "@opendaw/studio-adapters";
-import { Project } from "./Project";
-const createEnv = () => ({
-    audioContext: {},
-    audioWorklets: {},
-    sampleManager: {
-        getOrCreate: () => ({}),
-        record: () => { },
-        remove: () => { },
-        invalidate: () => { },
-        register: () => Terminable.Empty
-    },
-    soundfontManager: {
-        getOrCreate: () => ({}),
-        remove: () => { },
-        invalidate: () => { }
-    }
-});
-describe("ProjectApi.copyRegionTo", () => {
-    let project;
-    beforeEach(() => {
-        const skeleton = ProjectSkeleton.empty({ createDefaultUser: true, createOutputCompressor: false });
-        project = Project.fromSkeleton(createEnv(), skeleton, false);
-    });
-    afterEach(() => project.terminate());
-    const createTrackWithRegion = (project) => {
-        const { boxGraph } = project;
-        const captureBox = CaptureAudioBox.create(boxGraph, UUID.generate());
-        const audioUnitBox = AudioUnitBox.create(boxGraph, UUID.generate(), box => {
-            box.type.setValue(AudioUnitType.Instrument);
-            box.collection.refer(project.rootBox.audioUnits);
-            box.output.refer(project.masterBusBox.input);
-            box.capture.refer(captureBox);
-            box.index.setValue(1);
-        });
-        const trackBox = TrackBox.create(boxGraph, UUID.generate(), box => {
-            box.type.setValue(TrackType.Value);
-            box.tracks.refer(audioUnitBox.tracks);
-            box.target.refer(audioUnitBox);
-            box.index.setValue(0);
-        });
-        const collectionBox = ValueEventCollectionBox.create(boxGraph, UUID.generate());
-        const regionBox = ValueRegionBox.create(boxGraph, UUID.generate(), box => {
-            box.position.setValue(100);
-            box.duration.setValue(200);
-            box.loopDuration.setValue(200);
-            box.hue.setValue(0);
-            box.events.refer(collectionBox.owners);
-            box.regions.refer(trackBox.regions);
-        });
-        return { audioUnitBox, trackBox, regionBox, collectionBox };
-    };
-    it("same graph: moves region to target track and updates position", () => {
-        const { boxGraph } = project;
-        boxGraph.beginTransaction();
-        const { trackBox: trackA, regionBox } = createTrackWithRegion(project);
-        const trackB = TrackBox.create(boxGraph, UUID.generate(), box => {
-            box.type.setValue(TrackType.Value);
-            box.tracks.refer(asInstanceOf(trackA.tracks.targetVertex.unwrap().box, AudioUnitBox).tracks);
-            box.target.refer(trackA.tracks.targetVertex.unwrap().box);
-            box.index.setValue(1);
-        });
-        boxGraph.endTransaction();
-        boxGraph.beginTransaction();
-        project.api.copyRegionTo(regionBox, trackB, 500);
-        boxGraph.endTransaction();
-        boxGraph.verifyPointers();
-        expect(regionBox.position.getValue()).toBe(500);
-        const targetUuid = regionBox.regions.targetVertex.unwrap().box.address.uuid;
-        expect(UUID.equals(targetUuid, trackB.address.uuid)).toBe(true);
-        expect(trackB.regions.pointerHub.incoming().length).toBe(1);
-        expect(trackA.regions.pointerHub.incoming().length).toBe(0);
-    });
-    it("different graph: copies region to target track at given position", () => {
-        const sourceSkeleton = ProjectSkeleton.empty({ createDefaultUser: true, createOutputCompressor: false });
-        const sourceProject = Project.fromSkeleton(createEnv(), sourceSkeleton, false);
-        const sourceGraph = sourceProject.boxGraph;
-        sourceGraph.beginTransaction();
-        const { regionBox: sourceRegion } = createTrackWithRegion(sourceProject);
-        sourceGraph.endTransaction();
-        const { boxGraph } = project;
-        boxGraph.beginTransaction();
-        const { trackBox: targetTrack } = createTrackWithRegion(project);
-        boxGraph.endTransaction();
-        const regionsBefore = targetTrack.regions.pointerHub.incoming().length;
-        boxGraph.beginTransaction();
-        project.api.copyRegionTo(sourceRegion, targetTrack, 500);
-        boxGraph.endTransaction();
-        const regionsAfter = targetTrack.regions.pointerHub.incoming();
-        expect(regionsAfter.length).toBe(regionsBefore + 1);
-        const copiedRegion = regionsAfter.find(vertex => {
-            const box = vertex.box;
-            return box.position.getValue() === 500;
-        });
-        expect(copiedRegion).toBeDefined();
-        const copiedBox = copiedRegion.box;
-        expect(copiedBox.duration.getValue()).toBe(200);
-        expect(copiedBox.loopDuration.getValue()).toBe(200);
-        expect(UUID.equals(copiedBox.address.uuid, sourceRegion.address.uuid)).toBe(false);
-        boxGraph.verifyPointers();
-        sourceGraph.verifyPointers();
-        sourceProject.terminate();
-    });
-});