@opendaw/studio-core 0.0.56 → 0.0.57

package/dist/ui/RegionClipResolver.js

@@ -0,0 +1,179 @@
+import { asDefined, assert, mod, panic } from "@opendaw/lib-std";
+import { EventCollection, TimeBase } from "@opendaw/lib-dsp";
+import { AudioRegionBoxAdapter, RegionEditing, TrackType, UnionAdapterTypes } from "@opendaw/studio-adapters";
+import { RegionModifyStrategies } from "./RegionModifyStrategies";
+// AudioRegions in absolute time-domain are allowed to overlap. Their duration changes when the tempo changes,
+// but we do not truncate them to keep the original durations.
+const allowOverlap = (region) => region instanceof AudioRegionBoxAdapter && region.timeBase !== TimeBase.Musical;
+export class RegionClipResolver {
+    static fromSelection(tracks, adapters, strategy, deltaIndex = 0) {
+        const clipResolvers = new Map(tracks.map(track => ([track.listIndex, new RegionClipResolver(strategy, track)])));
+        adapters.forEach(adapter => {
+            const index = adapter.trackBoxAdapter.unwrap().listIndex + deltaIndex;
+            asDefined(clipResolvers.get(index), `Cannot find clip resolver for index(${index})`)
+                .addMask(adapter);
+        });
+        const tasks = Array.from(clipResolvers.values()).flatMap(resolver => resolver.#createSolver());
+        return () => tasks.forEach(task => task());
+    }
+    static fromRange(track, position, complete) {
+        // IdentityIncludeOrigin will include selected regions
+        const clipResolver = new RegionClipResolver(RegionModifyStrategies.IdentityIncludeOrigin, track);
+        clipResolver.addMaskRange(position, complete);
+        return clipResolver.#createSolver();
+    }
+    static validateTracks(tracks) {
+        for (const track of tracks) {
+            this.validateTrack(track);
+        }
+    }
+    static validateTrack(track) {
+        const array = track.regions.collection.asArray();
+        if (array.length === 0) {
+            return;
+        }
+        try {
+            let prev = array[0];
+            assert(prev.duration > 0, `duration(${prev.duration}) must be positive`);
+            for (let i = 1; i < array.length; i++) {
+                const next = array[i];
+                assert(next.duration > 0, `duration(${next.duration}) must be positive`);
+                if (!allowOverlap(prev) && prev.complete > next.position) {
+                    return panic("Overlapping detected after clipping");
+                }
+                prev = next;
+            }
+        }
+        catch (error) {
+            console.error(JSON.stringify({
+                track: TrackType[track.type],
+                regions: array.map(x => ({ p: x.position, d: x.duration }))
+            }));
+            throw error;
+        }
+    }
+    static sortAndJoinMasks(masks) {
+        if (masks.length === 0) {
+            return panic("No clip-masks to solve");
+        }
+        if (masks.length === 1) {
+            return [masks[0]];
+        }
+        // Sort by position (start time) - create a copy to avoid mutating input
+        const sorted = [...masks].sort(EventCollection.DefaultComparator);
+        const merged = [];
+        let current = sorted[0];
+        for (let i = 1; i < sorted.length; i++) {
+            const next = sorted[i];
+            // Check if the next mask overlaps or is adjacent to the current
+            if (next.position <= current.complete) {
+                // Merge: extend current to cover both ranges
+                current = {
+                    type: "range",
+                    position: current.position,
+                    complete: Math.max(current.complete, next.complete)
+                };
+            }
+            else {
+                // No overlap or adjacency: save current and move to next
+                merged.push(current);
+                current = next;
+            }
+        }
+        merged.push(current);
+        return merged;
+    }
+    #strategy;
+    #ground;
+    #masks;
+    constructor(strategy, ground) {
+        this.#strategy = strategy;
+        this.#ground = ground;
+        this.#masks = [];
+    }
+    addMask(region) {
+        const strategy = this.#strategy.selectedModifyStrategy();
+        this.addMaskRange(strategy.readPosition(region), strategy.readComplete(region));
+    }
+    addMaskRange(position, complete) {
+        this.#masks.push({ type: "range", position, complete });
+    }
+    #createSolver() {
+        const tasks = this.#createTasksFromMasks(RegionClipResolver.sortAndJoinMasks(this.#masks));
+        this.#masks.length = 0;
+        return () => this.#executeTasks(tasks);
+    }
+    #createTasksFromMasks(masks) {
+        const tasks = [];
+        masks.forEach(({ position, complete }) => {
+            for (const region of this.#ground.regions.collection.iterateRange(position, complete)) {
+                if (region.isSelected && !this.#strategy.showOrigin()) {
+                    continue;
+                }
+                else if (region.duration <= 0) {
+                    return panic(`Invalid duration(${region.duration})`);
+                }
+                else if (region.complete <= position || region.position >= complete) {
+                    return panic("Not overlapping");
+                }
+                const positionIn = region.position >= position;
+                const completeIn = region.complete <= complete;
+                if (positionIn && completeIn) {
+                    tasks.push({ type: "delete", region });
+                }
+                else if (!positionIn && !completeIn) {
+                    tasks.push({ type: "separate", region, begin: position, end: complete });
+                }
+                else if (completeIn) {
+                    tasks.push({ type: "complete", region, position });
+                }
+                else {
+                    tasks.push({ type: "start", region, position: complete });
+                }
+            }
+        });
+        return tasks;
+    }
+    #executeTasks(tasks) {
+        tasks
+            .toSorted(({ type: a }, { type: b }) => {
+            if (a === "delete" && b !== "delete") {
+                return 1;
+            }
+            if (b === "delete" && a !== "delete") {
+                return -1;
+            }
+            return 0;
+        })
+            .forEach(task => {
+            const { type, region } = task;
+            switch (type) {
+                case "delete":
+                    region.box.delete();
+                    break;
+                case "start":
+                    if (UnionAdapterTypes.isLoopableRegion(region)) {
+                        const delta = task.position - region.position;
+                        region.box.position.setValue(region.position + delta);
+                        region.box.duration.setValue(region.duration - delta);
+                        region.box.loopOffset.setValue(mod(region.loopOffset + delta, region.loopDuration));
+                    }
+                    else {
+                        return panic("Not yet implemented");
+                    }
+                    break;
+                case "complete":
+                    if (UnionAdapterTypes.isLoopableRegion(region)) {
+                        region.box.duration.setValue(task.position - task.region.position);
+                    }
+                    else {
+                        return panic("Not yet implemented");
+                    }
+                    break;
+                case "separate":
+                    RegionEditing.clip(region, task.begin, task.end);
+                    break;
+            }
+        });
+    }
+}

package/dist/ui/RegionClipResolver.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=RegionClipResolver.test.d.ts.map

package/dist/ui/RegionClipResolver.test.d.ts.map

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

package/dist/ui/RegionClipResolver.test.js

@@ -0,0 +1,166 @@
+import { describe, expect, it } from "vitest";
+import { RegionClipResolver } from "./RegionClipResolver";
+const createMask = (position, complete) => ({ type: "range", position, complete });
+describe("RegionClipResolver.sortAndJoinMasks", () => {
+    it("should handle single mask", () => {
+        const masks = [createMask(0, 10)];
+        const result = RegionClipResolver.sortAndJoinMasks(masks);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual(createMask(0, 10));
+    });
+    it("should merge two adjacent masks", () => {
+        const masks = [createMask(0, 10), createMask(10, 20)];
+        const result = RegionClipResolver.sortAndJoinMasks(masks);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual(createMask(0, 20));
+    });
+    it("should keep two non-adjacent masks separate", () => {
+        const masks = [createMask(0, 10), createMask(15, 20)];
+        const result = RegionClipResolver.sortAndJoinMasks(masks);
+        expect(result).toHaveLength(2);
+        expect(result[0]).toEqual(createMask(0, 10));
+        expect(result[1]).toEqual(createMask(15, 20));
+    });
+    it("should merge two overlapping masks", () => {
+        const masks = [createMask(0, 15), createMask(10, 20)];
+        const result = RegionClipResolver.sortAndJoinMasks(masks);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual(createMask(0, 20));
+    });
+    it("should handle mask completely contained in another", () => {
+        const masks = [createMask(0, 100), createMask(10, 20)];
+        const result = RegionClipResolver.sortAndJoinMasks(masks);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual(createMask(0, 100));
+    });
+    it("should handle multiple masks completely contained in one", () => {
+        const masks = [
+            createMask(0, 100),
+            createMask(10, 20),
+            createMask(30, 40),
+            createMask(50, 60)
+        ];
+        const result = RegionClipResolver.sortAndJoinMasks(masks);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual(createMask(0, 100));
+    });
+    it("should sort unsorted masks before merging", () => {
+        const masks = [createMask(20, 30), createMask(0, 10), createMask(10, 20)];
+        const result = RegionClipResolver.sortAndJoinMasks(masks);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual(createMask(0, 30));
+    });
+    it("should merge multiple overlapping masks into one", () => {
+        const masks = [
+            createMask(0, 15),
+            createMask(10, 25),
+            createMask(20, 35),
+            createMask(30, 40)
+        ];
+        const result = RegionClipResolver.sortAndJoinMasks(masks);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual(createMask(0, 40));
+    });
+    it("should create multiple ranges for separated groups", () => {
+        const masks = [
+            createMask(0, 10),
+            createMask(10, 20),
+            createMask(30, 40),
+            createMask(40, 50),
+            createMask(60, 70)
+        ];
+        const result = RegionClipResolver.sortAndJoinMasks(masks);
+        expect(result).toHaveLength(3);
+        expect(result[0]).toEqual(createMask(0, 20));
+        expect(result[1]).toEqual(createMask(30, 50));
+        expect(result[2]).toEqual(createMask(60, 70));
+    });
+    it("should handle complex mix of overlapping and separated masks", () => {
+        const masks = [
+            createMask(0, 15),
+            createMask(10, 25),
+            createMask(50, 60),
+            createMask(55, 70),
+            createMask(100, 110)
+        ];
+        const result = RegionClipResolver.sortAndJoinMasks(masks);
+        expect(result).toHaveLength(3);
+        expect(result[0]).toEqual(createMask(0, 25));
+        expect(result[1]).toEqual(createMask(50, 70));
+        expect(result[2]).toEqual(createMask(100, 110));
+    });
+    it("should handle masks with same start position", () => {
+        const masks = [
+            createMask(0, 10),
+            createMask(0, 20),
+            createMask(0, 15)
+        ];
+        const result = RegionClipResolver.sortAndJoinMasks(masks);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual(createMask(0, 20));
+    });
+    it("should handle masks with same end position", () => {
+        const masks = [
+            createMask(0, 20),
+            createMask(10, 20),
+            createMask(5, 20)
+        ];
+        const result = RegionClipResolver.sortAndJoinMasks(masks);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual(createMask(0, 20));
+    });
+    it("should handle identical masks", () => {
+        const masks = [
+            createMask(0, 10),
+            createMask(0, 10),
+            createMask(0, 10)
+        ];
+        const result = RegionClipResolver.sortAndJoinMasks(masks);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual(createMask(0, 10));
+    });
+    it("should handle zero-length masks (position equals complete)", () => {
+        const masks = [createMask(10, 10), createMask(20, 20)];
+        const result = RegionClipResolver.sortAndJoinMasks(masks);
+        expect(result).toHaveLength(2);
+        expect(result[0]).toEqual(createMask(10, 10));
+        expect(result[1]).toEqual(createMask(20, 20));
+    });
+    it("should merge adjacent zero-length and non-zero-length masks", () => {
+        const masks = [createMask(10, 10), createMask(10, 20)];
+        const result = RegionClipResolver.sortAndJoinMasks(masks);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual(createMask(10, 20));
+    });
+    it("should not mutate input array", () => {
+        const masks = [createMask(20, 30), createMask(0, 10), createMask(10, 20)];
+        const original = [...masks];
+        RegionClipResolver.sortAndJoinMasks(masks);
+        expect(masks).toEqual(original);
+    });
+    it("should handle large number of masks", () => {
+        const masks = [];
+        for (let i = 0; i < 100; i++) {
+            masks.push(createMask(i * 5, i * 5 + 10));
+        }
+        const result = RegionClipResolver.sortAndJoinMasks(masks);
+        // All masks overlap, should merge into one
+        expect(result).toHaveLength(1);
+        expect(result[0].position).toBe(0);
+        expect(result[0].complete).toBe(505); // 99 * 5 + 10
+    });
+    it("should handle masks in reverse order", () => {
+        const masks = [
+            createMask(60, 70),
+            createMask(40, 50),
+            createMask(20, 30),
+            createMask(0, 10)
+        ];
+        const result = RegionClipResolver.sortAndJoinMasks(masks);
+        expect(result).toHaveLength(4);
+        expect(result[0]).toEqual(createMask(0, 10));
+        expect(result[1]).toEqual(createMask(20, 30));
+        expect(result[2]).toEqual(createMask(40, 50));
+        expect(result[3]).toEqual(createMask(60, 70));
+    });
+});

package/dist/ui/RegionModifyStrategies.d.ts

@@ -0,0 +1,25 @@
+import { ppqn, RegionCollection } from "@opendaw/lib-dsp";
+import { int } from "@opendaw/lib-std";
+import { AnyRegionBoxAdapter } from "@opendaw/studio-adapters";
+export interface RegionModifyStrategies {
+    showOrigin(): boolean;
+    selectedModifyStrategy(): RegionModifyStrategy;
+    unselectedModifyStrategy(): RegionModifyStrategy;
+}
+export declare namespace RegionModifyStrategies {
+    const Identity: RegionModifyStrategies;
+    const IdentityIncludeOrigin: RegionModifyStrategies;
+}
+export interface RegionModifyStrategy {
+    readPosition(region: AnyRegionBoxAdapter): ppqn;
+    readComplete(region: AnyRegionBoxAdapter): ppqn;
+    readLoopOffset(region: AnyRegionBoxAdapter): ppqn;
+    readLoopDuration(region: AnyRegionBoxAdapter): ppqn;
+    readMirror(region: AnyRegionBoxAdapter): boolean;
+    translateTrackIndex(value: int): int;
+    iterateRange<R extends AnyRegionBoxAdapter>(regions: RegionCollection<R>, from: ppqn, to: ppqn): Iterable<R>;
+}
+export declare namespace RegionModifyStrategy {
+    const Identity: RegionModifyStrategy;
+}
+//# sourceMappingURL=RegionModifyStrategies.d.ts.map

package/dist/ui/RegionModifyStrategies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegionModifyStrategies.d.ts","sourceRoot":"","sources":["../../src/ui/RegionModifyStrategies.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAU,gBAAgB,EAAC,MAAM,kBAAkB,CAAA;AAC/D,OAAO,EAAC,GAAG,EAAC,MAAM,kBAAkB,CAAA;AACpC,OAAO,EAA8B,mBAAmB,EAAC,MAAM,0BAA0B,CAAA;AAEzF,MAAM,WAAW,sBAAsB;IACnC,UAAU,IAAI,OAAO,CAAA;IACrB,sBAAsB,IAAI,oBAAoB,CAAA;IAC9C,wBAAwB,IAAI,oBAAoB,CAAA;CACnD;AAED,yBAAiB,sBAAsB,CAAC;IAC7B,MAAM,QAAQ,EAAE,sBAIrB,CAAA;IACK,MAAM,qBAAqB,EAAE,sBAIlC,CAAA;CACL;AAED,MAAM,WAAW,oBAAoB;IACjC,YAAY,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI,CAAA;IAC/C,YAAY,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI,CAAA;IAC/C,cAAc,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI,CAAA;IACjD,gBAAgB,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI,CAAA;IACnD,UAAU,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAA;IAChD,mBAAmB,CAAC,KAAK,EAAE,GAAG,GAAG,GAAG,CAAA;IACpC,YAAY,CAAC,CAAC,SAAS,mBAAmB,EAAE,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAA;CAC/G;AAED,yBAAiB,oBAAoB,CAAC;IAC3B,MAAM,QAAQ,EAAE,oBASrB,CAAA;CACL"}

package/dist/ui/RegionModifyStrategies.js

@@ -0,0 +1,25 @@
+export var RegionModifyStrategies;
+(function (RegionModifyStrategies) {
+    RegionModifyStrategies.Identity = Object.freeze({
+        showOrigin: () => false,
+        selectedModifyStrategy: () => RegionModifyStrategy.Identity,
+        unselectedModifyStrategy: () => RegionModifyStrategy.Identity
+    });
+    RegionModifyStrategies.IdentityIncludeOrigin = Object.freeze({
+        showOrigin: () => true,
+        selectedModifyStrategy: () => RegionModifyStrategy.Identity,
+        unselectedModifyStrategy: () => RegionModifyStrategy.Identity
+    });
+})(RegionModifyStrategies || (RegionModifyStrategies = {}));
+export var RegionModifyStrategy;
+(function (RegionModifyStrategy) {
+    RegionModifyStrategy.Identity = Object.freeze({
+        readPosition: (region) => region.position,
+        readComplete: (region) => region.complete,
+        readLoopOffset: (region) => region.loopOffset,
+        readLoopDuration: (region) => region.loopDuration,
+        readMirror: (region) => region.isMirrowed,
+        translateTrackIndex: (value) => value,
+        iterateRange: (regions, from, to) => regions.iterateRange(from, to)
+    });
+})(RegionModifyStrategy || (RegionModifyStrategy = {}));

package/dist/ui/index.d.ts

@@ -1,3 +1,5 @@
+export * from "./RegionClipResolver";
+export * from "./RegionModifyStrategies";
 export * from "./TimeGrid";
 export * from "./TimelineRange";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ui/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,iBAAiB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ui/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA;AACpC,cAAc,0BAA0B,CAAA;AACxC,cAAc,YAAY,CAAA;AAC1B,cAAc,iBAAiB,CAAA"}

package/dist/ui/index.js

@@ -1,2 +1,4 @@
+export * from "./RegionClipResolver";
+export * from "./RegionModifyStrategies";
 export * from "./TimeGrid";
 export * from "./TimelineRange";