@opendaw/studio-core 0.0.100 → 0.0.102

package/dist/ui/timeline/RegionKeepExistingResolver.js

@@ -0,0 +1,171 @@
+import { TrackBoxAdapter, TrackType } from "@opendaw/studio-adapters";
+/**
+ * Resolver for "keep-existing" overlap behavior.
+ * When overlap is detected, the INCOMING (selected/moved/copied) region moves to a track below.
+ * Existing regions stay in place.
+ */
+export class RegionKeepExistingResolver {
+    /**
+     * For selection-based operations (move, resize, copy).
+     * Returns:
+     * - postProcess: function to call AFTER changes are applied (handles moves)
+     * - trackResolver: function to get target track for copies (use BEFORE creating copy)
+     *
+     * NOTE: Track resolution is lazy - target tracks are computed when trackResolver is called
+     * or when postProcess runs. This is necessary because creating new tracks requires being
+     * inside a transaction.
+     */
+    static fromSelection(tracks, adapters, strategy, deltaIndex, projectApi, boxAdapters) {
+        const isCopy = strategy.showOrigin();
+        // Collect overlap info - don't compute target tracks yet (need to be in transaction)
+        const copyOverlaps = [];
+        const moveOverlaps = [];
+        for (const track of tracks) {
+            const selectedStrategy = strategy.selectedModifyStrategy();
+            for (const adapter of adapters) {
+                const adapterTrackIndex = adapter.trackBoxAdapter.unwrap().listIndex + deltaIndex;
+                if (adapterTrackIndex !== track.listIndex) {
+                    continue;
+                }
+                const position = selectedStrategy.readPosition(adapter);
+                const complete = selectedStrategy.readComplete(adapter);
+                let hasOverlap = false;
+                for (const region of track.regions.collection.iterateRange(0, complete)) {
+                    // For moves: skip the adapter itself (it's being moved)
+                    // For copies: DON'T skip - the copy might overlap with the original
+                    if (!isCopy && region === adapter) {
+                        continue;
+                    }
+                    // For moves: skip other selected regions (they move together)
+                    if (!isCopy && region.isSelected) {
+                        continue;
+                    }
+                    if (region.complete <= position) {
+                        continue;
+                    }
+                    if (region.position >= complete) {
+                        break;
+                    }
+                    hasOverlap = true;
+                    break;
+                }
+                if (hasOverlap) {
+                    const info = { track, position, complete, adapter };
+                    if (isCopy) {
+                        copyOverlaps.push(info);
+                    }
+                    else {
+                        moveOverlaps.push(info);
+                    }
+                }
+            }
+        }
+        // Cache for lazily computed target tracks
+        const targetTrackCache = new Map();
+        // Track which tracks were affected by copy redirects (for dispatchChange)
+        const copyAffectedTracks = [];
+        const getTargetTrack = (info) => {
+            let targetTrack = targetTrackCache.get(info.adapter);
+            if (targetTrack === undefined) {
+                targetTrack = RegionKeepExistingResolver.#findOrCreateTrackBelow(info.track, info.position, info.complete, projectApi, boxAdapters);
+                targetTrackCache.set(info.adapter, targetTrack);
+            }
+            return targetTrack;
+        };
+        // Lazy track resolver for copies - called inside the transaction
+        const trackResolver = (adapter, defaultTrack) => {
+            const info = copyOverlaps.find(overlap => overlap.adapter === adapter);
+            if (info !== undefined) {
+                const targetTrack = getTargetTrack(info);
+                // Track affected tracks for dispatchChange in postProcess
+                if (!copyAffectedTracks.includes(targetTrack)) {
+                    copyAffectedTracks.push(targetTrack);
+                }
+                if (!copyAffectedTracks.includes(info.track)) {
+                    copyAffectedTracks.push(info.track);
+                }
+                return targetTrack;
+            }
+            return defaultTrack;
+        };
+        // Post-process - handles moves and dispatches changes for copy-affected tracks
+        const postProcess = () => {
+            const affectedTracks = [...copyAffectedTracks];
+            for (const info of moveOverlaps) {
+                const targetTrack = getTargetTrack(info);
+                if (!affectedTracks.includes(targetTrack)) {
+                    affectedTracks.push(targetTrack);
+                }
+                if (!affectedTracks.includes(info.track)) {
+                    affectedTracks.push(info.track);
+                }
+                info.adapter.box.regions.refer(targetTrack.box.regions);
+            }
+            affectedTracks
+                .filter(track => track.listIndex >= 0)
+                .forEach(track => track.regions.dispatchChange());
+        };
+        return { postProcess, trackResolver };
+    }
+    /**
+     * For range-based operations (drop, duplicate).
+     * Returns the target track to use for creation (may be different from original if overlap exists).
+     */
+    static resolveTargetTrack(track, position, complete, projectApi, boxAdapters) {
+        if (track.type === TrackType.Value) {
+            return track;
+        }
+        // Check for overlap
+        for (const region of track.regions.collection.iterateRange(0, complete)) {
+            if (region.complete <= position) {
+                continue;
+            }
+            if (region.position >= complete) {
+                break;
+            }
+            // Found overlap, find track below
+            return RegionKeepExistingResolver.#findOrCreateTrackBelow(track, position, complete, projectApi, boxAdapters);
+        }
+        return track;
+    }
+    static #findOrCreateTrackBelow(sourceTrack, position, complete, projectApi, boxAdapters) {
+        const audioUnit = sourceTrack.audioUnit;
+        const trackType = sourceTrack.type;
+        // Get all tracks of same type in this audio unit, sorted by index
+        const siblingTracks = audioUnit.tracks.pointerHub.incoming()
+            .map(vertex => vertex.box)
+            .filter(trackBox => trackBox.type.getValue() === trackType)
+            .sort((boxA, boxB) => boxA.index.getValue() - boxB.index.getValue());
+        const sourceIndex = sourceTrack.indexField.getValue();
+        // Look for existing track below with space
+        for (const trackBox of siblingTracks) {
+            if (trackBox.index.getValue() <= sourceIndex) {
+                continue;
+            }
+            if (RegionKeepExistingResolver.#hasSpace(trackBox, position, complete)) {
+                return boxAdapters.adapterFor(trackBox, TrackBoxAdapter);
+            }
+        }
+        // No suitable existing track found, create new track below source
+        const insertIndex = sourceIndex + 1;
+        const newTrackBox = trackType === TrackType.Audio
+            ? projectApi.createAudioTrack(audioUnit, insertIndex)
+            : projectApi.createNoteTrack(audioUnit, insertIndex);
+        return boxAdapters.adapterFor(newTrackBox, TrackBoxAdapter);
+    }
+    static #hasSpace(trackBox, position, complete) {
+        for (const vertex of trackBox.regions.pointerHub.incoming()) {
+            const regionPosition = vertex.box.position.getValue();
+            const regionDuration = vertex.box.duration.getValue();
+            const regionComplete = regionPosition + regionDuration;
+            if (regionComplete <= position) {
+                continue;
+            }
+            if (regionPosition >= complete) {
+                continue;
+            }
+            return false;
+        }
+        return true;
+    }
+}

package/dist/ui/timeline/RegionOverlapResolver.d.ts

@@ -0,0 +1,33 @@
+import { Exec, int } from "@opendaw/lib-std";
+import { ppqn } from "@opendaw/lib-dsp";
+import { BoxEditing } from "@opendaw/lib-box";
+import { AnyRegionBoxAdapter, BoxAdapters, TrackBoxAdapter } from "@opendaw/studio-adapters";
+import { RegionModifyStrategies } from "./RegionModifyStrategies";
+import { ProjectApi } from "../../project";
+import { TrackResolver } from "./TrackResolver";
+export declare class RegionOverlapResolver {
+    #private;
+    constructor(editing: BoxEditing, projectApi: ProjectApi, boxAdapters: BoxAdapters);
+    /**
+     * For selection-based operations (move, resize, copy).
+     * @param tracks - The tracks involved in the operation
+     * @param adapters - The region adapters being modified
+     * @param strategy - The modify strategy (determines if it's a copy, etc.)
+     * @param deltaIndex - Track index delta (for cross-track moves)
+     * @param changes - Callback that performs the actual changes. Receives a TrackResolver
+     *                  that should be used to determine target tracks for copies.
+     */
+    apply(tracks: ReadonlyArray<TrackBoxAdapter>, adapters: ReadonlyArray<AnyRegionBoxAdapter>, strategy: RegionModifyStrategies, deltaIndex: int, changes: (trackResolver: TrackResolver) => void): void;
+    /**
+     * For range-based operations (drop, duplicate).
+     * Returns the target track to use (may differ from input track for keep-existing mode).
+     */
+    resolveTargetTrack(track: TrackBoxAdapter, position: ppqn, complete: ppqn): TrackBoxAdapter;
+    /**
+     * Creates a resolver function for range-based operations (to be called inside an existing transaction).
+     * Call this BEFORE creating the region to capture the "before" state.
+     * Then call the returned function AFTER creating the region.
+     */
+    fromRange(track: TrackBoxAdapter, position: ppqn, complete: ppqn): Exec;
+}
+//# sourceMappingURL=RegionOverlapResolver.d.ts.map

package/dist/ui/timeline/RegionOverlapResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegionOverlapResolver.d.ts","sourceRoot":"","sources":["../../../src/ui/timeline/RegionOverlapResolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAE,GAAG,EAAC,MAAM,kBAAkB,CAAA;AAC1C,OAAO,EAAC,IAAI,EAAC,MAAM,kBAAkB,CAAA;AACrC,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAC,mBAAmB,EAAE,WAAW,EAAE,eAAe,EAAC,MAAM,0BAA0B,CAAA;AAC1F,OAAO,EAAC,sBAAsB,EAAC,MAAM,0BAA0B,CAAA;AAK/D,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAA;AACxC,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAA;AAE7C,qBAAa,qBAAqB;;gBAKlB,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW;IAMjF;;;;;;;;OAQG;IACH,KAAK,CAAC,MAAM,EAAE,aAAa,CAAC,eAAe,CAAC,EACtC,QAAQ,EAAE,aAAa,CAAC,mBAAmB,CAAC,EAC5C,QAAQ,EAAE,sBAAsB,EAChC,UAAU,EAAE,GAAG,EACf,OAAO,EAAE,CAAC,aAAa,EAAE,aAAa,KAAK,IAAI,GAAG,IAAI;IA2B5D;;;OAGG;IACH,kBAAkB,CAAC,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,GAAG,eAAe;IAS3F;;;;OAIG;IACH,SAAS,CAAC,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,GAAG,IAAI;CAW1E"}

package/dist/ui/timeline/RegionOverlapResolver.js

@@ -0,0 +1,79 @@
+import { RegionClipResolver } from "./RegionClipResolver";
+import { RegionKeepExistingResolver } from "./RegionKeepExistingResolver";
+import { RegionPushExistingResolver } from "./RegionPushExistingResolver";
+import { StudioPreferences } from "../../StudioPreferences";
+export class RegionOverlapResolver {
+    #editing;
+    #projectApi;
+    #boxAdapters;
+    constructor(editing, projectApi, boxAdapters) {
+        this.#editing = editing;
+        this.#projectApi = projectApi;
+        this.#boxAdapters = boxAdapters;
+    }
+    /**
+     * For selection-based operations (move, resize, copy).
+     * @param tracks - The tracks involved in the operation
+     * @param adapters - The region adapters being modified
+     * @param strategy - The modify strategy (determines if it's a copy, etc.)
+     * @param deltaIndex - Track index delta (for cross-track moves)
+     * @param changes - Callback that performs the actual changes. Receives a TrackResolver
+     *                  that should be used to determine target tracks for copies.
+     */
+    apply(tracks, adapters, strategy, deltaIndex, changes) {
+        const behaviour = StudioPreferences.settings.editing["overlapping-regions-behaviour"];
+        if (behaviour === "clip") {
+            const { postProcess, trackResolver } = RegionClipResolver.fromSelection(tracks, adapters, strategy, deltaIndex);
+            this.#editing.modify(() => {
+                changes(trackResolver);
+                postProcess();
+            });
+            RegionClipResolver.validateTracks(tracks);
+        }
+        else if (behaviour === "push-existing") {
+            const { postProcess, trackResolver } = RegionPushExistingResolver.fromSelection(tracks, adapters, strategy, deltaIndex, this.#projectApi, this.#boxAdapters);
+            this.#editing.modify(() => {
+                changes(trackResolver);
+                postProcess();
+            });
+        }
+        else {
+            // keep-existing
+            const { postProcess, trackResolver } = RegionKeepExistingResolver.fromSelection(tracks, adapters, strategy, deltaIndex, this.#projectApi, this.#boxAdapters);
+            this.#editing.modify(() => {
+                changes(trackResolver);
+                postProcess();
+            });
+        }
+    }
+    /**
+     * For range-based operations (drop, duplicate).
+     * Returns the target track to use (may differ from input track for keep-existing mode).
+     */
+    resolveTargetTrack(track, position, complete) {
+        const behaviour = StudioPreferences.settings.editing["overlapping-regions-behaviour"];
+        if (behaviour === "keep-existing") {
+            return RegionKeepExistingResolver
+                .resolveTargetTrack(track, position, complete, this.#projectApi, this.#boxAdapters);
+        }
+        return track;
+    }
+    /**
+     * Creates a resolver function for range-based operations (to be called inside an existing transaction).
+     * Call this BEFORE creating the region to capture the "before" state.
+     * Then call the returned function AFTER creating the region.
+     */
+    fromRange(track, position, complete) {
+        const behaviour = StudioPreferences.settings.editing["overlapping-regions-behaviour"];
+        if (behaviour === "clip") {
+            return RegionClipResolver.fromRange(track, position, complete);
+        }
+        else if (behaviour === "push-existing") {
+            return RegionPushExistingResolver.fromRange(track, position, complete, this.#projectApi, this.#boxAdapters);
+        }
+        else {
+            // keep-existing: nothing to do after creation - caller should use resolveTargetTrack before creating
+            return () => { };
+        }
+    }
+}

package/dist/ui/timeline/RegionPushExistingResolver.d.ts

@@ -0,0 +1,31 @@
+import { Exec, int } from "@opendaw/lib-std";
+import { ppqn } from "@opendaw/lib-dsp";
+import { AnyRegionBoxAdapter, BoxAdapters, TrackBoxAdapter } from "@opendaw/studio-adapters";
+import { RegionModifyStrategies } from "./RegionModifyStrategies";
+import { ProjectApi } from "../../project";
+import { TrackResolver } from "./TrackResolver";
+/**
+ * Resolver for "push-existing" overlap behavior.
+ * When overlap is detected, the EXISTING (overlapped) regions move to a track below.
+ * Incoming regions stay where they were placed.
+ */
+export declare class RegionPushExistingResolver {
+    #private;
+    /**
+     * For selection-based operations (move, resize).
+     * Returns:
+     * - postProcess: function to call AFTER changes are applied
+     * - trackResolver: Identity (incoming regions stay where placed)
+     */
+    static fromSelection(tracks: ReadonlyArray<TrackBoxAdapter>, adapters: ReadonlyArray<AnyRegionBoxAdapter>, strategy: RegionModifyStrategies, deltaIndex: int, projectApi: ProjectApi, boxAdapters: BoxAdapters): {
+        postProcess: Exec;
+        trackResolver: TrackResolver;
+    };
+    /**
+     * For range-based operations (drop, duplicate).
+     * Returns a function that should be called AFTER the region is created.
+     */
+    static fromRange(track: TrackBoxAdapter, position: ppqn, complete: ppqn, projectApi: ProjectApi, boxAdapters: BoxAdapters): Exec;
+    private constructor();
+}
+//# sourceMappingURL=RegionPushExistingResolver.d.ts.map

package/dist/ui/timeline/RegionPushExistingResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegionPushExistingResolver.d.ts","sourceRoot":"","sources":["../../../src/ui/timeline/RegionPushExistingResolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,IAAI,EAAE,GAAG,EAAsB,MAAM,kBAAkB,CAAA;AAC1E,OAAO,EAAC,IAAI,EAAC,MAAM,kBAAkB,CAAA;AACrC,OAAO,EAAC,mBAAmB,EAAE,WAAW,EAAE,eAAe,EAAY,MAAM,0BAA0B,CAAA;AAErG,OAAO,EAAC,sBAAsB,EAAC,MAAM,0BAA0B,CAAA;AAC/D,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAA;AACxC,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAA;AAE7C;;;;GAIG;AACH,qBAAa,0BAA0B;;IACnC;;;;;OAKG;IACH,MAAM,CAAC,aAAa,CAAC,MAAM,EAAE,aAAa,CAAC,eAAe,CAAC,EACtC,QAAQ,EAAE,aAAa,CAAC,mBAAmB,CAAC,EAC5C,QAAQ,EAAE,sBAAsB,EAChC,UAAU,EAAE,GAAG,EACf,UAAU,EAAE,UAAU,EACtB,WAAW,EAAE,WAAW,GAAG;QAAE,WAAW,EAAE,IAAI,CAAC;QAAC,aAAa,EAAE,aAAa,CAAA;KAAE;IA6BnG;;;OAGG;IACH,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,eAAe,EACtB,QAAQ,EAAE,IAAI,EACd,QAAQ,EAAE,IAAI,EACd,UAAU,EAAE,UAAU,EACtB,WAAW,EAAE,WAAW,GAAG,IAAI;IAqEhD,OAAO;CAsBV"}

package/dist/ui/timeline/RegionPushExistingResolver.js

@@ -0,0 +1,159 @@
+import { EmptyExec, isDefined } from "@opendaw/lib-std";
+import { TrackBoxAdapter, TrackType } from "@opendaw/studio-adapters";
+import { TrackResolver } from "./TrackResolver";
+/**
+ * Resolver for "push-existing" overlap behavior.
+ * When overlap is detected, the EXISTING (overlapped) regions move to a track below.
+ * Incoming regions stay where they were placed.
+ */
+export class RegionPushExistingResolver {
+    /**
+     * For selection-based operations (move, resize).
+     * Returns:
+     * - postProcess: function to call AFTER changes are applied
+     * - trackResolver: Identity (incoming regions stay where placed)
+     */
+    static fromSelection(tracks, adapters, strategy, deltaIndex, projectApi, boxAdapters) {
+        const resolver = new RegionPushExistingResolver(projectApi, boxAdapters);
+        // Capture overlapped regions BEFORE changes
+        for (const track of tracks) {
+            const selectedStrategy = strategy.selectedModifyStrategy();
+            const overlapped = [];
+            for (const adapter of adapters) {
+                const adapterTrackIndex = adapter.trackBoxAdapter.unwrap().listIndex + deltaIndex;
+                if (adapterTrackIndex !== track.listIndex) {
+                    continue;
+                }
+                const position = selectedStrategy.readPosition(adapter);
+                const complete = selectedStrategy.readComplete(adapter);
+                for (const region of track.regions.collection.iterateRange(0, complete)) {
+                    if (region.complete <= position) {
+                        continue;
+                    }
+                    if (region.position >= complete) {
+                        break;
+                    }
+                    if (region.isSelected && !strategy.showOrigin()) {
+                        continue;
+                    }
+                    if (!overlapped.includes(region)) {
+                        overlapped.push(region);
+                    }
+                }
+            }
+            if (overlapped.length > 0) {
+                resolver.#overlappedByTrack.set(track, overlapped);
+            }
+        }
+        return {
+            postProcess: () => resolver.#solve(),
+            trackResolver: TrackResolver.Identity
+        };
+    }
+    /**
+     * For range-based operations (drop, duplicate).
+     * Returns a function that should be called AFTER the region is created.
+     */
+    static fromRange(track, position, complete, projectApi, boxAdapters) {
+        if (track.type === TrackType.Value) {
+            return () => { };
+        }
+        // Find overlapped regions BEFORE changes
+        const overlapped = [];
+        for (const region of track.regions.collection.iterateRange(0, complete)) {
+            if (region.complete <= position) {
+                continue;
+            }
+            if (region.position >= complete) {
+                break;
+            }
+            overlapped.push(region);
+        }
+        if (overlapped.length === 0) {
+            return EmptyExec;
+        }
+        return () => {
+            const targetTrack = RegionPushExistingResolver.#findOrCreateTrackBelow(track, overlapped, projectApi, boxAdapters);
+            if (isDefined(targetTrack)) {
+                for (const region of overlapped) {
+                    region.box.regions.refer(targetTrack.box.regions);
+                }
+                track.regions.dispatchChange();
+                targetTrack.regions.dispatchChange();
+            }
+        };
+    }
+    static #findOrCreateTrackBelow(sourceTrack, regionsToPlace, projectApi, boxAdapters) {
+        const trackType = sourceTrack.type;
+        if (trackType === TrackType.Value) {
+            return undefined;
+        }
+        const minPosition = Math.min(...regionsToPlace.map(region => region.position));
+        const maxComplete = Math.max(...regionsToPlace.map(region => region.complete));
+        const audioUnit = sourceTrack.audioUnit;
+        // Get all tracks of same type in this audio unit, sorted by index
+        const siblingTracks = audioUnit.tracks.pointerHub.incoming()
+            .map(vertex => vertex.box)
+            .filter(trackBox => trackBox.type.getValue() === trackType)
+            .sort((boxA, boxB) => boxA.index.getValue() - boxB.index.getValue());
+        const sourceIndex = sourceTrack.indexField.getValue();
+        // Look for existing track below with space
+        for (const trackBox of siblingTracks) {
+            if (trackBox.index.getValue() <= sourceIndex) {
+                continue;
+            }
+            if (RegionPushExistingResolver.#hasSpace(trackBox, minPosition, maxComplete)) {
+                return boxAdapters.adapterFor(trackBox, TrackBoxAdapter);
+            }
+        }
+        // No suitable existing track found, create new track below source
+        const insertIndex = sourceIndex + 1;
+        const newTrackBox = trackType === TrackType.Audio
+            ? projectApi.createAudioTrack(audioUnit, insertIndex)
+            : projectApi.createNoteTrack(audioUnit, insertIndex);
+        return boxAdapters.adapterFor(newTrackBox, TrackBoxAdapter);
+    }
+    static #hasSpace(trackBox, position, complete) {
+        for (const vertex of trackBox.regions.pointerHub.incoming()) {
+            const regionPosition = vertex.box.position.getValue();
+            const regionDuration = vertex.box.duration.getValue();
+            const regionComplete = regionPosition + regionDuration;
+            if (regionComplete <= position) {
+                continue;
+            }
+            if (regionPosition >= complete) {
+                continue;
+            }
+            return false;
+        }
+        return true;
+    }
+    #projectApi;
+    #boxAdapters;
+    #overlappedByTrack;
+    constructor(projectApi, boxAdapters) {
+        this.#projectApi = projectApi;
+        this.#boxAdapters = boxAdapters;
+        this.#overlappedByTrack = new Map();
+    }
+    #solve() {
+        const affectedTracks = [];
+        for (const [track, overlapped] of this.#overlappedByTrack) {
+            const targetTrack = RegionPushExistingResolver.#findOrCreateTrackBelow(track, overlapped, this.#projectApi, this.#boxAdapters);
+            if (!isDefined(targetTrack)) {
+                continue;
+            }
+            if (!affectedTracks.includes(targetTrack)) {
+                affectedTracks.push(targetTrack);
+            }
+            if (!affectedTracks.includes(track)) {
+                affectedTracks.push(track);
+            }
+            for (const region of overlapped) {
+                region.box.regions.refer(targetTrack.box.regions);
+            }
+        }
+        // Dispatch change on all affected tracks to ensure UI updates
+        affectedTracks.forEach(track => track.regions.dispatchChange());
+    }
+}

package/dist/ui/timeline/TimelineFocus.d.ts

@@ -0,0 +1,14 @@
+import { MutableObservableOption, Terminable } from "@opendaw/lib-std";
+import { AnyRegionBoxAdapter, TrackBoxAdapter } from "@opendaw/studio-adapters";
+export declare class TimelineFocus implements Terminable {
+    #private;
+    constructor();
+    get track(): MutableObservableOption<TrackBoxAdapter>;
+    get region(): MutableObservableOption<AnyRegionBoxAdapter>;
+    focusTrack(track: TrackBoxAdapter): void;
+    focusRegion(region: AnyRegionBoxAdapter): void;
+    clearRegionFocus(): void;
+    clear(): void;
+    terminate(): void;
+}
+//# sourceMappingURL=TimelineFocus.d.ts.map

package/dist/ui/timeline/TimelineFocus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TimelineFocus.d.ts","sourceRoot":"","sources":["../../../src/ui/timeline/TimelineFocus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,uBAAuB,EAAE,UAAU,EAAa,MAAM,kBAAkB,CAAA;AAChF,OAAO,EAAC,mBAAmB,EAAE,eAAe,EAAC,MAAM,0BAA0B,CAAA;AAE7E,qBAAa,aAAc,YAAW,UAAU;;;IAY5C,IAAI,KAAK,IAAI,uBAAuB,CAAC,eAAe,CAAC,CAAqB;IAC1E,IAAI,MAAM,IAAI,uBAAuB,CAAC,mBAAmB,CAAC,CAAsB;IAEhF,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI;IAWxC,WAAW,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI;IAW9C,gBAAgB,IAAI,IAAI;IAKxB,KAAK,IAAI,IAAI;IAOb,SAAS,IAAI,IAAI;CACpB"}

package/dist/ui/timeline/TimelineFocus.js

@@ -0,0 +1,45 @@
+import { MutableObservableOption, Terminator } from "@opendaw/lib-std";
+export class TimelineFocus {
+    #terminator = new Terminator();
+    #trackSubscription = this.#terminator.own(new Terminator());
+    #regionSubscription = this.#terminator.own(new Terminator());
+    #track;
+    #region;
+    constructor() {
+        this.#track = this.#terminator.own(new MutableObservableOption());
+        this.#region = this.#terminator.own(new MutableObservableOption());
+    }
+    get track() { return this.#track; }
+    get region() { return this.#region; }
+    focusTrack(track) {
+        this.#trackSubscription.terminate();
+        this.#trackSubscription.own(track.box.subscribeDeletion(() => {
+            console.debug("TimelineFocus: track deleted");
+            this.#trackSubscription.terminate();
+            this.#track.clear();
+        }));
+        this.#track.wrap(track);
+        this.clearRegionFocus();
+    }
+    focusRegion(region) {
+        region.trackBoxAdapter.ifSome(track => this.focusTrack(track));
+        this.#regionSubscription.terminate();
+        this.#regionSubscription.own(region.box.subscribeDeletion(() => {
+            console.debug("TimelineFocus: region deleted");
+            this.#regionSubscription.terminate();
+            this.#region.clear();
+        }));
+        this.#region.wrap(region);
+    }
+    clearRegionFocus() {
+        this.#regionSubscription.terminate();
+        this.#region.clear();
+    }
+    clear() {
+        this.#trackSubscription.terminate();
+        this.#regionSubscription.terminate();
+        this.#track.clear();
+        this.#region.clear();
+    }
+    terminate() { this.#terminator.terminate(); }
+}

package/dist/ui/timeline/TrackResolver.d.ts

@@ -0,0 +1,11 @@
+import { AnyRegionBoxAdapter, TrackBoxAdapter } from "@opendaw/studio-adapters";
+/**
+ * Function to resolve the target track for a region.
+ * Used by overlap resolvers to provide track overrides for copy operations.
+ */
+export type TrackResolver = (adapter: AnyRegionBoxAdapter, defaultTrack: TrackBoxAdapter) => TrackBoxAdapter;
+export declare namespace TrackResolver {
+    /** Identity resolver - always returns the default track */
+    const Identity: TrackResolver;
+}
+//# sourceMappingURL=TrackResolver.d.ts.map

package/dist/ui/timeline/TrackResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TrackResolver.d.ts","sourceRoot":"","sources":["../../../src/ui/timeline/TrackResolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,mBAAmB,EAAE,eAAe,EAAC,MAAM,0BAA0B,CAAA;AAE7E;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,eAAe,KAAK,eAAe,CAAA;AAE5G,yBAAiB,aAAa,CAAC;IAC3B,2DAA2D;IACpD,MAAM,QAAQ,EAAE,aAAwD,CAAA;CAClF"}

package/dist/ui/timeline/TrackResolver.js

@@ -0,0 +1,5 @@
+export var TrackResolver;
+(function (TrackResolver) {
+    /** Identity resolver - always returns the default track */
+    TrackResolver.Identity = (_adapter, defaultTrack) => defaultTrack;
+})(TrackResolver || (TrackResolver = {}));