@opendaw/studio-core 0.0.104 → 0.0.105

package/dist/project/ProjectApi.js

@@ -254,7 +254,7 @@ export class ProjectApi {
         }
         else {
             const adapter = this.#project.boxAdapters.adapterFor(region, UnionAdapterTypes.isRegion);
-            adapter.copyTo({ target: targetTrackBox.regions, position: insertPosition });
+            adapter.copyTo({ target: targetTrackBox.regions, position: insertPosition, consolidate: true });
         }
     }
     #createTrack({ field, target, trackType, insertIndex }) {

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

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,109 @@
+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();
+    });
+});

package/dist/project/polyfill.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=polyfill.d.ts.map

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

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

package/dist/project/polyfill.js

@@ -0,0 +1,14 @@
+"use strict";
+if (typeof globalThis.localStorage === "undefined") {
+    const store = new Map();
+    Object.defineProperty(globalThis, "localStorage", {
+        value: {
+            getItem: (key) => store.get(key) ?? null,
+            setItem: (key, value) => store.set(key, value),
+            removeItem: (key) => store.delete(key),
+            clear: () => store.clear(),
+            get length() { return store.size; },
+            key: (index) => [...store.keys()][index] ?? null
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opendaw/studio-core",
-  "version": "0.0.104",
+  "version": "0.0.105",
   "license": "LGPL-3.0-or-later",
   "publishConfig": {
     "access": "public"
@@ -62,5 +62,5 @@
     "@opendaw/studio-forge-boxes": "^0.0.74",
     "@opendaw/typescript-config": "^0.0.28"
   },
-  "gitHead": "99391fc2af474d2c0fd9f3a81c5655918cad4b96"
+  "gitHead": "b39d786e60cee02599e0f3d7106e635a870c47c6"
 }