@opendaw/studio-core 0.0.102 → 0.0.103

package/dist/ui/timeline/RegionClipResolver.test.js

@@ -1,6 +1,16 @@
 import { describe, expect, it } from "vitest";
 import { RegionClipResolver } from "./RegionClipResolver";
 const createMask = (position, complete) => ({ type: "range", position, complete });
+const createRegion = (position, duration, isSelected = false) => ({
+    position,
+    duration,
+    complete: position + duration,
+    isSelected
+});
+const runCreateTasks = (regions, masks, showOrigin = false) => {
+    const maxComplete = masks.reduce((max, mask) => Math.max(max, mask.complete), 0);
+    return RegionClipResolver.createTasksFromMasks(regions, maxComplete, masks, showOrigin);
+};
 describe("RegionClipResolver.sortAndJoinMasks", () => {
     it("should handle single mask", () => {
         const masks = [createMask(0, 10)];
@@ -164,3 +174,393 @@ describe("RegionClipResolver.sortAndJoinMasks", () => {
         expect(result[3]).toEqual(createMask(60, 70));
     });
 });
+describe("RegionClipResolver.createTasksFromMasks", () => {
+    describe("single mask", () => {
+        it("should delete region fully contained in mask", () => {
+            const region = createRegion(5, 5);
+            const tasks = runCreateTasks([region], [createMask(0, 20)]);
+            expect(tasks).toHaveLength(1);
+            expect(tasks[0].type).toBe("delete");
+            expect(tasks[0].region).toBe(region);
+        });
+        it("should delete region exactly matching mask", () => {
+            const region = createRegion(5, 10);
+            const tasks = runCreateTasks([region], [createMask(5, 15)]);
+            expect(tasks).toHaveLength(1);
+            expect(tasks[0].type).toBe("delete");
+        });
+        it("should separate region spanning entire mask", () => {
+            const region = createRegion(0, 30);
+            const tasks = runCreateTasks([region], [createMask(10, 20)]);
+            expect(tasks).toHaveLength(1);
+            expect(tasks[0].type).toBe("separate");
+            if (tasks[0].type === "separate") {
+                expect(tasks[0].begin).toBe(10);
+                expect(tasks[0].end).toBe(20);
+            }
+        });
+        it("should trim start when region begins within mask", () => {
+            const region = createRegion(5, 20);
+            const tasks = runCreateTasks([region], [createMask(0, 10)]);
+            expect(tasks).toHaveLength(1);
+            expect(tasks[0].type).toBe("start");
+            if (tasks[0].type === "start") {
+                expect(tasks[0].position).toBe(10);
+            }
+        });
+        it("should trim end when region ends within mask", () => {
+            const region = createRegion(0, 15);
+            const tasks = runCreateTasks([region], [createMask(10, 20)]);
+            expect(tasks).toHaveLength(1);
+            expect(tasks[0].type).toBe("complete");
+            if (tasks[0].type === "complete") {
+                expect(tasks[0].position).toBe(10);
+            }
+        });
+        it("should skip region entirely before mask", () => {
+            const region = createRegion(0, 5);
+            const tasks = runCreateTasks([region], [createMask(10, 20)]);
+            expect(tasks).toHaveLength(0);
+        });
+        it("should skip region entirely after mask (within maxComplete)", () => {
+            const region = createRegion(25, 5);
+            const tasks = runCreateTasks([region], [createMask(10, 20)], false);
+            expect(tasks).toHaveLength(0);
+        });
+    });
+    describe("selected region filtering", () => {
+        it("should skip selected regions when showOrigin is false", () => {
+            const region = createRegion(5, 5, true);
+            const tasks = runCreateTasks([region], [createMask(0, 20)], false);
+            expect(tasks).toHaveLength(0);
+        });
+        it("should include selected regions when showOrigin is true", () => {
+            const region = createRegion(5, 5, true);
+            const tasks = runCreateTasks([region], [createMask(0, 20)], true);
+            expect(tasks).toHaveLength(1);
+            expect(tasks[0].type).toBe("delete");
+        });
+        it("should always include unselected regions regardless of showOrigin", () => {
+            const region = createRegion(5, 5, false);
+            const tasksFalse = runCreateTasks([region], [createMask(0, 20)], false);
+            const tasksTrue = runCreateTasks([region], [createMask(0, 20)], true);
+            expect(tasksFalse).toHaveLength(1);
+            expect(tasksTrue).toHaveLength(1);
+        });
+    });
+    describe("multiple regions with single mask", () => {
+        it("should create tasks for each overlapping region", () => {
+            const region1 = createRegion(0, 5);
+            const region2 = createRegion(5, 10);
+            const region3 = createRegion(20, 5);
+            const tasks = runCreateTasks([region1, region2, region3], [createMask(3, 12)]);
+            expect(tasks).toHaveLength(2);
+            expect(tasks[0].region).toBe(region1);
+            expect(tasks[0].type).toBe("complete");
+            expect(tasks[1].region).toBe(region2);
+            expect(tasks[1].type).toBe("start");
+        });
+        it("should handle mixed task types across regions", () => {
+            const region1 = createRegion(0, 30);
+            const region2 = createRegion(8, 4);
+            const region3 = createRegion(15, 20);
+            const tasks = runCreateTasks([region1, region2, region3], [createMask(5, 20)]);
+            expect(tasks).toHaveLength(3);
+            expect(tasks[0].type).toBe("separate");
+            expect(tasks[0].region).toBe(region1);
+            expect(tasks[1].type).toBe("delete");
+            expect(tasks[1].region).toBe(region2);
+            expect(tasks[2].type).toBe("start");
+            expect(tasks[2].region).toBe(region3);
+        });
+    });
+    describe("two non-adjacent masks (bug #676 scenario)", () => {
+        it("should create right-to-left tasks for region spanning both masks", () => {
+            const region = createRegion(0, 30);
+            const tasks = runCreateTasks([region], [createMask(5, 10), createMask(15, 20)]);
+            expect(tasks).toHaveLength(2);
+            expect(tasks[0].type).toBe("separate");
+            if (tasks[0].type === "separate") {
+                expect(tasks[0].begin).toBe(15);
+                expect(tasks[0].end).toBe(20);
+            }
+            expect(tasks[1].type).toBe("separate");
+            if (tasks[1].type === "separate") {
+                expect(tasks[1].begin).toBe(5);
+                expect(tasks[1].end).toBe(10);
+            }
+        });
+        it("should handle region overlapping both: complete on right, separate on left", () => {
+            const region = createRegion(3, 15);
+            const tasks = runCreateTasks([region], [createMask(5, 10), createMask(15, 20)]);
+            expect(tasks).toHaveLength(2);
+            expect(tasks[0].type).toBe("complete");
+            if (tasks[0].type === "complete") {
+                expect(tasks[0].position).toBe(15);
+            }
+            expect(tasks[1].type).toBe("separate");
+            if (tasks[1].type === "separate") {
+                expect(tasks[1].begin).toBe(5);
+                expect(tasks[1].end).toBe(10);
+            }
+        });
+        it("should handle region overlapping both: start on left, separate on right", () => {
+            const region = createRegion(7, 18);
+            const tasks = runCreateTasks([region], [createMask(5, 10), createMask(15, 20)]);
+            expect(tasks).toHaveLength(2);
+            expect(tasks[0].type).toBe("separate");
+            if (tasks[0].type === "separate") {
+                expect(tasks[0].begin).toBe(15);
+                expect(tasks[0].end).toBe(20);
+            }
+            expect(tasks[1].type).toBe("start");
+            if (tasks[1].type === "start") {
+                expect(tasks[1].position).toBe(10);
+            }
+        });
+        it("should handle region overlapping both: complete on right, start on left", () => {
+            const region = createRegion(7, 12);
+            const tasks = runCreateTasks([region], [createMask(5, 10), createMask(15, 20)]);
+            expect(tasks).toHaveLength(2);
+            expect(tasks[0].type).toBe("complete");
+            if (tasks[0].type === "complete") {
+                expect(tasks[0].position).toBe(15);
+            }
+            expect(tasks[1].type).toBe("start");
+            if (tasks[1].type === "start") {
+                expect(tasks[1].position).toBe(10);
+            }
+        });
+        it("should only create one task for region overlapping single mask", () => {
+            const region = createRegion(6, 3);
+            const tasks = runCreateTasks([region], [createMask(5, 10), createMask(15, 20)]);
+            expect(tasks).toHaveLength(1);
+            expect(tasks[0].type).toBe("delete");
+            expect(tasks[0].region).toBe(region);
+        });
+        it("should handle multiple regions with two masks", () => {
+            const region1 = createRegion(0, 30);
+            const regionInGap = createRegion(12, 2);
+            const regionInMask = createRegion(6, 3);
+            const tasks = runCreateTasks([region1, regionInMask, regionInGap], [createMask(5, 10), createMask(15, 20)]);
+            expect(tasks).toHaveLength(3);
+            expect(tasks[0].type).toBe("separate");
+            expect(tasks[0].region).toBe(region1);
+            expect(tasks[1].type).toBe("separate");
+            expect(tasks[1].region).toBe(region1);
+            expect(tasks[2].type).toBe("delete");
+            expect(tasks[2].region).toBe(regionInMask);
+            const gapTasks = tasks.filter(task => task.region === regionInGap);
+            expect(gapTasks).toHaveLength(0);
+        });
+    });
+    describe("three non-adjacent masks", () => {
+        it("should create three tasks for region spanning all masks", () => {
+            const region = createRegion(0, 35);
+            const tasks = runCreateTasks([region], [createMask(5, 10), createMask(15, 20), createMask(25, 30)]);
+            expect(tasks).toHaveLength(3);
+            expect(tasks[0].type).toBe("separate");
+            if (tasks[0].type === "separate") {
+                expect(tasks[0].begin).toBe(25);
+                expect(tasks[0].end).toBe(30);
+            }
+            expect(tasks[1].type).toBe("separate");
+            if (tasks[1].type === "separate") {
+                expect(tasks[1].begin).toBe(15);
+                expect(tasks[1].end).toBe(20);
+            }
+            expect(tasks[2].type).toBe("separate");
+            if (tasks[2].type === "separate") {
+                expect(tasks[2].begin).toBe(5);
+                expect(tasks[2].end).toBe(10);
+            }
+        });
+        it("should handle region overlapping only the last two masks", () => {
+            const region = createRegion(13, 22);
+            const tasks = runCreateTasks([region], [createMask(5, 10), createMask(15, 20), createMask(25, 30)]);
+            expect(tasks).toHaveLength(2);
+            expect(tasks[0].type).toBe("separate");
+            if (tasks[0].type === "separate") {
+                expect(tasks[0].begin).toBe(25);
+                expect(tasks[0].end).toBe(30);
+            }
+            expect(tasks[1].type).toBe("separate");
+            if (tasks[1].type === "separate") {
+                expect(tasks[1].begin).toBe(15);
+                expect(tasks[1].end).toBe(20);
+            }
+        });
+    });
+    describe("edge cases", () => {
+        it("should produce no tasks for empty region list", () => {
+            const tasks = runCreateTasks([], [createMask(0, 10)]);
+            expect(tasks).toHaveLength(0);
+        });
+        it("should produce no tasks when no regions overlap any mask", () => {
+            const region = createRegion(20, 5);
+            const tasks = runCreateTasks([region], [createMask(0, 10)]);
+            expect(tasks).toHaveLength(0);
+        });
+        it("should handle region touching mask boundary without overlap", () => {
+            const region = createRegion(0, 10);
+            const tasks = runCreateTasks([region], [createMask(10, 20)]);
+            expect(tasks).toHaveLength(0);
+        });
+        it("should handle region starting exactly at mask start", () => {
+            const region = createRegion(5, 10);
+            const tasks = runCreateTasks([region], [createMask(5, 20)]);
+            expect(tasks).toHaveLength(1);
+            expect(tasks[0].type).toBe("delete");
+        });
+        it("should handle region ending exactly at mask end", () => {
+            const region = createRegion(0, 20);
+            const tasks = runCreateTasks([region], [createMask(5, 20)]);
+            expect(tasks).toHaveLength(1);
+            expect(tasks[0].type).toBe("complete");
+        });
+        it("should handle multiple regions where some are skipped (selected) and some processed", () => {
+            const selected = createRegion(5, 5, true);
+            const unselected = createRegion(12, 5);
+            const tasks = runCreateTasks([selected, unselected], [createMask(0, 20)], false);
+            expect(tasks).toHaveLength(1);
+            expect(tasks[0].region).toBe(unselected);
+        });
+        it("should handle region spanning gap between two masks without overlapping either", () => {
+            const region = createRegion(11, 3);
+            const tasks = runCreateTasks([region], [createMask(5, 10), createMask(15, 20)]);
+            expect(tasks).toHaveLength(0);
+        });
+        it("should break early for regions past maxComplete", () => {
+            const region1 = createRegion(5, 5);
+            const region2 = createRegion(50, 5);
+            const tasks = runCreateTasks([region1, region2], [createMask(0, 20)]);
+            expect(tasks).toHaveLength(1);
+            expect(tasks[0].region).toBe(region1);
+        });
+    });
+    describe("task ordering for right-to-left multi-mask processing", () => {
+        it("should produce tasks in right-to-left order for execution correctness", () => {
+            const region = createRegion(3, 22);
+            const masks = [createMask(5, 10), createMask(15, 20)];
+            const tasks = runCreateTasks([region], masks);
+            expect(tasks).toHaveLength(2);
+            if (tasks[0].type === "separate") {
+                expect(tasks[0].begin).toBe(15);
+            }
+            if (tasks[1].type === "separate") {
+                expect(tasks[1].begin).toBe(5);
+            }
+        });
+        it("should produce complete before separate (right-to-left) for region ending in right mask", () => {
+            const region = createRegion(3, 16);
+            const masks = [createMask(5, 10), createMask(15, 20)];
+            const tasks = runCreateTasks([region], masks);
+            expect(tasks).toHaveLength(2);
+            expect(tasks[0].type).toBe("complete");
+            expect(tasks[1].type).toBe("separate");
+        });
+        it("should produce separate before start (right-to-left) for region starting in left mask", () => {
+            const region = createRegion(7, 18);
+            const masks = [createMask(5, 10), createMask(15, 20)];
+            const tasks = runCreateTasks([region], masks);
+            expect(tasks).toHaveLength(2);
+            expect(tasks[0].type).toBe("separate");
+            expect(tasks[1].type).toBe("start");
+        });
+        it("should produce complete then start for region within gap boundaries", () => {
+            const region = createRegion(7, 12);
+            const masks = [createMask(5, 10), createMask(15, 20)];
+            const tasks = runCreateTasks([region], masks);
+            expect(tasks).toHaveLength(2);
+            expect(tasks[0].type).toBe("complete");
+            if (tasks[0].type === "complete") {
+                expect(tasks[0].position).toBe(15);
+            }
+            expect(tasks[1].type).toBe("start");
+            if (tasks[1].type === "start") {
+                expect(tasks[1].position).toBe(10);
+            }
+        });
+    });
+    describe("execution correctness (simulated right-to-left processing)", () => {
+        it("separate + separate: region [3,25] with masks [5,10] and [15,20] produces valid segments", () => {
+            const region = createRegion(3, 22);
+            const tasks = runCreateTasks([region], [createMask(5, 10), createMask(15, 20)]);
+            expect(tasks).toHaveLength(2);
+            // Right-to-left execution:
+            // 1. separate at [15,20]: region [3,25] -> [3,15] + new [20,25]
+            // 2. separate at [5,10]: region [3,15] -> [3,5] + new [10,15]
+            // Expected segments: [3,5], [10,15], [20,25]
+            // Verify task 1 (rightmost) is a separate at [15,20]
+            expect(tasks[0].type).toBe("separate");
+            if (tasks[0].type === "separate") {
+                expect(tasks[0].begin).toBe(15);
+                expect(tasks[0].end).toBe(20);
+                // After this, region.complete (originally 25) would become 15.
+                // complete - end = 25 - 20 = 5 > 0, valid.
+            }
+            // Verify task 2 (leftmost) is a separate at [5,10]
+            expect(tasks[1].type).toBe("separate");
+            if (tasks[1].type === "separate") {
+                expect(tasks[1].begin).toBe(5);
+                expect(tasks[1].end).toBe(10);
+                // After task 1, region is [3,15]. complete - end = 15 - 10 = 5 > 0, valid.
+            }
+        });
+        it("complete + separate: region [3,18] with masks [5,10] and [15,20] produces valid segments", () => {
+            const region = createRegion(3, 15);
+            const tasks = runCreateTasks([region], [createMask(5, 10), createMask(15, 20)]);
+            expect(tasks).toHaveLength(2);
+            // 1. complete at 15: region [3,18] -> [3,15]
+            // 2. separate at [5,10]: region [3,15] -> [3,5] + new [10,15]
+            expect(tasks[0].type).toBe("complete");
+            if (tasks[0].type === "complete") {
+                expect(tasks[0].position).toBe(15);
+            }
+            expect(tasks[1].type).toBe("separate");
+            if (tasks[1].type === "separate") {
+                expect(tasks[1].begin).toBe(5);
+                expect(tasks[1].end).toBe(10);
+            }
+        });
+        it("separate + start: region [7,25] with masks [5,10] and [15,20] produces valid segments", () => {
+            const region = createRegion(7, 18);
+            const tasks = runCreateTasks([region], [createMask(5, 10), createMask(15, 20)]);
+            expect(tasks).toHaveLength(2);
+            // 1. separate at [15,20]: region [7,25] -> [7,15] + new [20,25]
+            // 2. start at 10: region [7,15] -> [10,15]
+            expect(tasks[0].type).toBe("separate");
+            if (tasks[0].type === "separate") {
+                expect(tasks[0].begin).toBe(15);
+                expect(tasks[0].end).toBe(20);
+            }
+            expect(tasks[1].type).toBe("start");
+            if (tasks[1].type === "start") {
+                expect(tasks[1].position).toBe(10);
+            }
+        });
+        it("complete + start: region [5,20] with masks [5,10] and [15,20] leaves gap only", () => {
+            const region = createRegion(5, 15);
+            const tasks = runCreateTasks([region], [createMask(5, 10), createMask(15, 20)]);
+            expect(tasks).toHaveLength(2);
+            // 1. complete at 15: region [5,20] -> [5,15]
+            // 2. start at 10: region [5,15] -> [10,15]
+            expect(tasks[0].type).toBe("complete");
+            expect(tasks[1].type).toBe("start");
+        });
+    });
+    describe("region fully within one mask of multiple masks", () => {
+        it("should delete region within first mask only", () => {
+            const region = createRegion(6, 3);
+            const tasks = runCreateTasks([region], [createMask(5, 10), createMask(15, 20)]);
+            expect(tasks).toHaveLength(1);
+            expect(tasks[0].type).toBe("delete");
+        });
+        it("should delete region within second mask only", () => {
+            const region = createRegion(16, 3);
+            const tasks = runCreateTasks([region], [createMask(5, 10), createMask(15, 20)]);
+            expect(tasks).toHaveLength(1);
+            expect(tasks[0].type).toBe("delete");
+        });
+    });
+});

package/dist/ysync/YService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"YService.d.ts","sourceRoot":"","sources":["../../src/ysync/YService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAyC,MAAM,kBAAkB,CAAA;AAQvF,OAAO,EAAC,OAAO,EAAE,UAAU,EAAC,MAAM,YAAY,CAAA;AAK9C,yBAAiB,QAAQ,CAAC;IAMf,MAAM,eAAe,GAAU,YAAY,MAAM,CAAC,OAAO,CAAC,EAC3B,KAAK,UAAU,EACf,UAAU,MAAM,KAAG,OAAO,CAAC,OAAO,CA4DvE,CAAA;CACJ"}
+{"version":3,"file":"YService.d.ts","sourceRoot":"","sources":["../../src/ysync/YService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAyC,MAAM,kBAAkB,CAAA;AAKvF,OAAO,EAAC,OAAO,EAAE,UAAU,EAAmB,MAAM,YAAY,CAAA;AAOhE,yBAAiB,QAAQ,CAAC;IAMf,MAAM,eAAe,GAAU,YAAY,MAAM,CAAC,OAAO,CAAC,EAC3B,KAAK,UAAU,EACf,UAAU,MAAM,KAAG,OAAO,CAAC,OAAO,CA4DvE,CAAA;CACJ"}

package/dist/ysync/YService.js

@@ -3,11 +3,10 @@ import { BoxGraph } from "@opendaw/lib-box";
 import { Promises } from "@opendaw/lib-runtime";
 import { BoxIO, UserInterfaceBox } from "@opendaw/studio-boxes";
 import { ProjectSkeleton } from "@opendaw/studio-adapters";
+import { Project, ProjectMigration } from "../project";
 import { YSync } from "./YSync";
 import * as Y from "yjs";
 import { WebsocketProvider } from "y-websocket";
-import { Project } from "../project";
-import { ProjectMigration } from "../project/ProjectMigration";
 // https://inspector.yjs.dev/
 export var YService;
 (function (YService) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opendaw/studio-core",
-  "version": "0.0.102",
+  "version": "0.0.103",
   "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.71",
-    "@opendaw/lib-dawproject": "^0.0.56",
-    "@opendaw/lib-dom": "^0.0.72",
-    "@opendaw/lib-dsp": "^0.0.70",
-    "@opendaw/lib-fusion": "^0.0.76",
-    "@opendaw/lib-runtime": "^0.0.68",
-    "@opendaw/lib-std": "^0.0.67",
+    "@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/nam-wasm": "^1.0.3",
-    "@opendaw/studio-adapters": "^0.0.81",
-    "@opendaw/studio-boxes": "^0.0.73",
-    "@opendaw/studio-enums": "^0.0.62",
+    "@opendaw/studio-adapters": "^0.0.82",
+    "@opendaw/studio-boxes": "^0.0.74",
+    "@opendaw/studio-enums": "^0.0.63",
     "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.84",
-    "@opendaw/studio-core-workers": "^0.0.76",
-    "@opendaw/studio-forge-boxes": "^0.0.73",
+    "@opendaw/studio-core-processors": "^0.0.85",
+    "@opendaw/studio-core-workers": "^0.0.77",
+    "@opendaw/studio-forge-boxes": "^0.0.74",
     "@opendaw/typescript-config": "^0.0.28"
   },
-  "gitHead": "410e32d862fae20e1ecfffcee7407451e6537655"
+  "gitHead": "5e97da8bbe6085b04c34b9ff7e816b22225bf915"
 }