@opendaw/studio-adapters 0.0.6

package/dist/timeline/clip/ValueClipBoxAdapter.js

@@ -0,0 +1,98 @@
+import { PPQN } from "@opendaw/lib-dsp";
+import { DefaultObservableValue, Notifier, Option, safeExecute, Terminable, Terminator, UUID } from "@opendaw/lib-std";
+import { Propagation } from "@opendaw/lib-box";
+import { TrackBoxAdapter } from "../TrackBoxAdapter";
+import { ValueEventCollectionBoxAdapter } from "../collection/ValueEventCollectionBoxAdapter";
+import { ValueClipBox } from "@opendaw/studio-boxes";
+export class ValueClipBoxAdapter {
+    type = "value-clip";
+    #terminator = new Terminator();
+    #context;
+    #box;
+    #selectedValue;
+    #changeNotifier;
+    #isConstructing; // Prevents stack overflow due to infinite adapter queries
+    #eventCollectionSubscription = Terminable.Empty;
+    constructor(context, box) {
+        this.#context = context;
+        this.#box = box;
+        this.#isConstructing = true;
+        this.#selectedValue = this.#terminator.own(new DefaultObservableValue(false));
+        this.#changeNotifier = this.#terminator.own(new Notifier());
+        this.#terminator.own(this.#box.pointerHub.subscribeImmediate({
+            onAdd: () => this.#dispatchChange(),
+            onRemove: () => this.#dispatchChange()
+        }));
+        this.#terminator.own(this.#box.subscribe(Propagation.Children, (_update) => this.#dispatchChange()));
+        this.#terminator.own(this.#box.events.catchupAndSubscribe(({ targetVertex }) => {
+            this.#eventCollectionSubscription.terminate();
+            this.#eventCollectionSubscription = targetVertex.match({
+                none: () => Terminable.Empty,
+                some: ({ box }) => this.#context.boxAdapters
+                    .adapterFor(box, ValueEventCollectionBoxAdapter)
+                    .subscribeChange(() => this.#dispatchChange())
+            });
+            this.#dispatchChange();
+        }));
+        this.#isConstructing = false;
+    }
+    valueAt(position, fallback) {
+        const content = this.optCollection;
+        return content.isEmpty() ? fallback : content.unwrap().valueAt(position % this.duration, fallback);
+    }
+    catchupAndSubscribeSelected(observer) {
+        return this.#selectedValue.catchupAndSubscribe(observer);
+    }
+    subscribeChange(observer) { return this.#changeNotifier.subscribe(observer); }
+    accept(visitor) { return safeExecute(visitor.visitValueClipBoxAdapter, this); }
+    consolidate() { this.#box.events.refer(this.optCollection.unwrap().copy().box.owners); }
+    clone(consolidate) {
+        const events = consolidate ? this.optCollection.unwrap().copy().box.owners : this.#box.events.targetVertex.unwrap();
+        ValueClipBox.create(this.#context.boxGraph, UUID.generate(), box => {
+            box.index.setValue(this.indexField.getValue());
+            box.label.setValue(this.label);
+            box.hue.setValue(this.hue);
+            box.duration.setValue(this.duration);
+            box.mute.setValue(this.mute);
+            box.clips.refer(this.#box.clips.targetVertex.unwrap());
+            box.events.refer(events);
+        });
+    }
+    onSelected() { this.#selectedValue.setValue(true); }
+    onDeselected() { this.#selectedValue.setValue(false); }
+    get isSelected() { return this.#selectedValue.getValue(); }
+    terminate() {
+        this.#eventCollectionSubscription.terminate();
+        this.#terminator.terminate();
+    }
+    get box() { return this.#box; }
+    get uuid() { return this.#box.address.uuid; }
+    get address() { return this.#box.address; }
+    get indexField() { return this.#box.index; }
+    get duration() { return this.#box.duration.getValue(); }
+    get mute() { return this.#box.mute.getValue(); }
+    get hue() { return this.#box.hue.getValue(); }
+    get hasCollection() { return !this.optCollection.isEmpty(); }
+    get events() {
+        return this.optCollection.map(collection => collection.events);
+    }
+    get optCollection() {
+        return this.#box.events.targetVertex
+            .map(vertex => this.#context.boxAdapters.adapterFor(vertex.box, ValueEventCollectionBoxAdapter));
+    }
+    get label() { return this.#box.label.getValue(); }
+    get trackBoxAdapter() {
+        if (this.#isConstructing) {
+            return Option.None;
+        }
+        return this.#box.clips.targetVertex
+            .map(vertex => this.#context.boxAdapters.adapterFor(vertex.box, TrackBoxAdapter));
+    }
+    get isMirrowed() { return this.optCollection.mapOr(adapter => adapter.numOwners > 1, false); }
+    get canMirror() { return true; }
+    toString() { return `{ValueClipBoxAdapter ${UUID.toString(this.#box.address.uuid)} d: ${PPQN.toString(this.duration)}}`; }
+    #dispatchChange() {
+        this.#changeNotifier.notify();
+        this.trackBoxAdapter.unwrapOrNull()?.clips?.dispatchChange();
+    }
+}

package/dist/timeline/collection/NoteEventCollectionBoxAdapter.d.ts

@@ -0,0 +1,40 @@
+import { NoteEventCollectionBox } from "@opendaw/studio-boxes";
+import { Coordinates, float, int, Observer, SelectableLocator, Subscription, UUID } from "@opendaw/lib-std";
+import { Address } from "@opendaw/lib-box";
+import { EventCollection, ppqn } from "@opendaw/lib-dsp";
+import { BoxAdapter } from "../../BoxAdapter";
+import { NoteEventBoxAdapter } from "../event/NoteEventBoxAdapter";
+import { BoxAdaptersContext } from "../../BoxAdaptersContext";
+type CreateEventParams = {
+    position: ppqn;
+    duration: ppqn;
+    pitch: int;
+    cent: number;
+    velocity: float;
+    chance: int;
+    playCount: int;
+};
+export declare class NoteEventCollectionBoxAdapter implements BoxAdapter, SelectableLocator<NoteEventBoxAdapter, ppqn, int> {
+    #private;
+    constructor(context: BoxAdaptersContext, box: NoteEventCollectionBox);
+    copy(): NoteEventCollectionBoxAdapter;
+    createEvent({ position, duration, velocity, pitch, chance, playCount, cent }: CreateEventParams): NoteEventBoxAdapter;
+    subscribeChange(observer: Observer<this>): Subscription;
+    selectable(): Iterable<NoteEventBoxAdapter>;
+    selectableAt(coordinates: Coordinates<ppqn, int>): Iterable<NoteEventBoxAdapter>;
+    selectablesBetween(begin: Coordinates<ppqn, int>, end: Coordinates<ppqn, int>): Iterable<NoteEventBoxAdapter>;
+    requestSorting(): void;
+    onEventPropertyChanged(): void;
+    terminate(): void;
+    get box(): NoteEventCollectionBox;
+    get uuid(): UUID.Format;
+    get address(): Address;
+    get numOwners(): int;
+    get events(): EventCollection<NoteEventBoxAdapter>;
+    get minPitch(): int;
+    get maxPitch(): int;
+    get maxDuration(): number;
+    toString(): string;
+}
+export {};
+//# sourceMappingURL=NoteEventCollectionBoxAdapter.d.ts.map

package/dist/timeline/collection/NoteEventCollectionBoxAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NoteEventCollectionBoxAdapter.d.ts","sourceRoot":"","sources":["../../../src/timeline/collection/NoteEventCollectionBoxAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,sBAAsB,EAAC,MAAM,uBAAuB,CAAA;AACtF,OAAO,EAEH,WAAW,EACX,KAAK,EACL,GAAG,EAIH,QAAQ,EACR,iBAAiB,EAEjB,YAAY,EAEZ,IAAI,EACP,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,OAAO,EAAM,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAC,eAAe,EAAa,IAAI,EAAC,MAAM,kBAAkB,CAAA;AAEjE,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAC,mBAAmB,EAAC,MAAM,8BAA8B,CAAA;AAChE,OAAO,EAAC,kBAAkB,EAAC,MAAM,0BAA0B,CAAA;AAE3D,KAAK,iBAAiB,GAAG;IACrB,QAAQ,EAAE,IAAI,CAAA;IACd,QAAQ,EAAE,IAAI,CAAA;IACd,KAAK,EAAE,GAAG,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,KAAK,CAAA;IACf,MAAM,EAAE,GAAG,CAAA;IACX,SAAS,EAAE,GAAG,CAAA;CACjB,CAAA;AAED,qBAAa,6BAA8B,YAAW,UAAU,EAAE,iBAAiB,CAAC,mBAAmB,EAAE,IAAI,EAAE,GAAG,CAAC;;gBAenG,OAAO,EAAE,kBAAkB,EAAE,GAAG,EAAE,sBAAsB;IA+BpE,IAAI,IAAI,6BAA6B;IAOrC,WAAW,CACP,EAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,EAAC,EAAE,iBAAiB,GAAG,mBAAmB;IAa3G,eAAe,CAAC,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,YAAY;IAEvD,UAAU,IAAI,QAAQ,CAAC,mBAAmB,CAAC;IAE3C,YAAY,CAAC,WAAW,EAAE,WAAW,CAAC,IAAI,EAAE,GAAG,CAAC,GAAG,QAAQ,CAAC,mBAAmB,CAAC;IAShF,kBAAkB,CAAC,KAAK,EAAE,WAAW,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,WAAW,CAAC,IAAI,EAAE,GAAG,CAAC,GAAG,QAAQ,CAAC,mBAAmB,CAAC;IAW7G,cAAc,IAAI,IAAI;IAKtB,sBAAsB,IAAI,IAAI;IAE9B,SAAS;IAET,IAAI,GAAG,IAAI,sBAAsB,CAAmB;IACpD,IAAI,IAAI,IAAI,IAAI,CAAC,MAAM,CAAgC;IACvD,IAAI,OAAO,IAAI,OAAO,CAA2B;IACjD,IAAI,SAAS,IAAI,GAAG,CAAiF;IACrG,IAAI,MAAM,IAAI,eAAe,CAAC,mBAAmB,CAAC,CAKjD;IAED,IAAI,QAAQ,IAAI,GAAG,CAGlB;IACD,IAAI,QAAQ,IAAI,GAAG,CAGlB;IACD,IAAI,WAAW,IAAI,MAAM,CAGxB;IAED,QAAQ,IAAI,MAAM;CAqBrB"}

package/dist/timeline/collection/NoteEventCollectionBoxAdapter.js

@@ -0,0 +1,136 @@
+import { NoteEventBox, NoteEventCollectionBox } from "@opendaw/studio-boxes";
+import { asDefined, Intervals, Iterables, Notifier, Terminator, UUID } from "@opendaw/lib-std";
+import { EventCollection, NoteEvent } from "@opendaw/lib-dsp";
+import { Pointers } from "@opendaw/studio-enums";
+import { NoteEventBoxAdapter } from "../event/NoteEventBoxAdapter";
+export class NoteEventCollectionBoxAdapter {
+    #terminator = new Terminator();
+    #context;
+    #box;
+    #changeNotifier;
+    #adapters;
+    #events;
+    #minPitch = 60;
+    #maxPitch = 60;
+    #maxDuration = 0;
+    #computedExtremas = false;
+    constructor(context, box) {
+        this.#context = context;
+        this.#box = box;
+        this.#changeNotifier = new Notifier();
+        this.#adapters = UUID.newSet(adapter => adapter.uuid);
+        this.#events = EventCollection.create(NoteEvent.Comparator);
+        const addNoteProcedure = (box) => {
+            const adapter = asDefined(box.accept({
+                visitNoteEventBox: (box) => this.#context.boxAdapters.adapterFor(box, NoteEventBoxAdapter)
+            }), `Could not find adapter for ${box}`);
+            if (this.#adapters.add(adapter)) {
+                this.#events.add(adapter);
+                this.#onEventsChanged();
+            }
+        };
+        this.#box.events.pointerHub.incoming().forEach(({ box }) => addNoteProcedure(box));
+        this.#terminator.own(this.#box.events.pointerHub.subscribeTransactual({
+            onAdd: ({ box }) => addNoteProcedure(box),
+            onRemove: ({ box: { address: { uuid } } }) => {
+                this.#events.remove(this.#adapters.removeByKey(uuid));
+                this.#onEventsChanged();
+            }
+        }));
+        this.#terminator.own(this.#box.owners.pointerHub.subscribeTransactual({
+            onAdd: () => this.#changeNotifier.notify(this),
+            onRemove: () => this.#changeNotifier.notify(this)
+        }));
+    }
+    copy() {
+        const graph = this.#context.boxGraph;
+        const boxCopy = NoteEventCollectionBox.create(graph, UUID.generate());
+        this.#events.asArray().forEach(source => source.copyTo({ events: boxCopy.events }));
+        return this.#context.boxAdapters.adapterFor(boxCopy, NoteEventCollectionBoxAdapter);
+    }
+    createEvent({ position, duration, velocity, pitch, chance, playCount, cent }) {
+        return this.#context.boxAdapters.adapterFor(NoteEventBox.create(this.#context.boxGraph, UUID.generate(), box => {
+            box.position.setValue(position);
+            box.duration.setValue(duration);
+            box.velocity.setValue(velocity);
+            box.pitch.setValue(pitch);
+            box.chance.setValue(chance);
+            box.playCount.setValue(playCount);
+            box.cent.setValue(cent);
+            box.events.refer(this.#box.events);
+        }), NoteEventBoxAdapter);
+    }
+    subscribeChange(observer) { return this.#changeNotifier.subscribe(observer); }
+    selectable() { return this.#events.asArray(); }
+    selectableAt(coordinates) {
+        for (const element of this.#events.asArray()) { // TODO Optimise
+            if (element.position <= coordinates.u && coordinates.u < element.complete && element.pitch === coordinates.v) {
+                return Iterables.one(element);
+            }
+        }
+        return Iterables.empty();
+    }
+    selectablesBetween(begin, end) {
+        const events = [];
+        for (const element of this.#events.asArray()) { // TODO Optimise
+            if (Intervals.intersect1D(element.position, element.complete, begin.u, end.u)
+                && Intervals.intersect1D(element.pitch, element.pitch, begin.v, end.v)) {
+                events.push(element);
+            }
+        }
+        return events;
+    }
+    requestSorting() {
+        this.#events.onIndexingChanged();
+        this.onEventPropertyChanged();
+    }
+    onEventPropertyChanged() { this.#onEventsChanged(); }
+    terminate() { this.#terminator.terminate(); }
+    get box() { return this.#box; }
+    get uuid() { return this.#box.address.uuid; }
+    get address() { return this.#box.address; }
+    get numOwners() { return this.#box.owners.pointerHub.filter(Pointers.NoteEventCollection).length; }
+    get events() {
+        if (!this.#computedExtremas) {
+            this.#computeExtremas();
+        }
+        return this.#events;
+    }
+    get minPitch() {
+        if (!this.#computedExtremas) {
+            this.#computeExtremas();
+        }
+        return this.#minPitch;
+    }
+    get maxPitch() {
+        if (!this.#computedExtremas) {
+            this.#computeExtremas();
+        }
+        return this.#maxPitch;
+    }
+    get maxDuration() {
+        if (!this.#computedExtremas) {
+            this.#computeExtremas();
+        }
+        return this.#maxDuration;
+    }
+    toString() { return `{NoteEventCollectionBox ${UUID.toString(this.#box.address.uuid)}}`; }
+    #onEventsChanged() {
+        this.#computedExtremas = false;
+        this.#changeNotifier.notify(this);
+    }
+    #computeExtremas() {
+        let min = 127 | 0;
+        let max = 0 | 0;
+        let maxDuration = 0;
+        this.#events.asArray().forEach(({ pitch, duration }) => {
+            min = Math.min(min, pitch);
+            max = Math.max(max, pitch);
+            maxDuration = Math.max(maxDuration, duration);
+        });
+        this.#minPitch = min;
+        this.#maxPitch = max;
+        this.#maxDuration = maxDuration;
+        this.#computedExtremas = true;
+    }
+}

package/dist/timeline/collection/ValueEventCollectionBoxAdapter.d.ts

@@ -0,0 +1,33 @@
+import { ValueEventCollectionBox } from "@opendaw/studio-boxes";
+import { int, Observer, Option, Subscription, unitValue, UUID } from "@opendaw/lib-std";
+import { Address } from "@opendaw/lib-box";
+import { EventCollection, Interpolation, ppqn } from "@opendaw/lib-dsp";
+import { BoxAdapter } from "../../BoxAdapter";
+import { BoxAdaptersContext } from "../../BoxAdaptersContext";
+import { ValueEventBoxAdapter } from "../event/ValueEventBoxAdapter";
+type CreateEventParams = {
+    position: ppqn;
+    index: int;
+    value: unitValue;
+    interpolation: Interpolation;
+};
+export declare class ValueEventCollectionBoxAdapter implements BoxAdapter {
+    #private;
+    constructor(context: BoxAdaptersContext, box: ValueEventCollectionBox);
+    valueAt(position: ppqn, fallback: unitValue): unitValue;
+    copy(): ValueEventCollectionBoxAdapter;
+    cut(position: ppqn): Option<ValueEventBoxAdapter>;
+    subscribeChange(observer: Observer<this>): Subscription;
+    createEvent({ position, index, value, interpolation }: CreateEventParams): ValueEventBoxAdapter;
+    requestSorting(): void;
+    onEventPropertyChanged(): void;
+    terminate(): void;
+    get box(): ValueEventCollectionBox;
+    get uuid(): UUID.Format;
+    get address(): Address;
+    get numOwners(): int;
+    get events(): EventCollection<ValueEventBoxAdapter>;
+    toString(): string;
+}
+export {};
+//# sourceMappingURL=ValueEventCollectionBoxAdapter.d.ts.map

package/dist/timeline/collection/ValueEventCollectionBoxAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValueEventCollectionBoxAdapter.d.ts","sourceRoot":"","sources":["../../../src/timeline/collection/ValueEventCollectionBoxAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,uBAAuB,EAAC,MAAM,uBAAuB,CAAA;AACxF,OAAO,EAGH,GAAG,EAGH,QAAQ,EACR,MAAM,EAGN,YAAY,EAEZ,SAAS,EACT,IAAI,EACP,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,OAAO,EAAM,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAC,eAAe,EAAE,aAAa,EAAE,IAAI,EAAa,MAAM,kBAAkB,CAAA;AAEjF,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAC,kBAAkB,EAAC,MAAM,0BAA0B,CAAA;AAC3D,OAAO,EAAC,oBAAoB,EAAC,MAAM,+BAA+B,CAAA;AAGlE,KAAK,iBAAiB,GAAG;IACrB,QAAQ,EAAE,IAAI,CAAC;IACf,KAAK,EAAE,GAAG,CAAC;IACX,KAAK,EAAE,SAAS,CAAC;IACjB,aAAa,EAAE,aAAa,CAAA;CAC/B,CAAA;AAED,qBAAa,8BAA+B,YAAW,UAAU;;gBAUjD,OAAO,EAAE,kBAAkB,EAAE,GAAG,EAAE,uBAAuB;IA+BrE,OAAO,CAAC,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,GAAG,SAAS;IAEvD,IAAI,IAAI,8BAA8B;IAOtC,GAAG,CAAC,QAAQ,EAAE,IAAI,GAAG,MAAM,CAAC,oBAAoB,CAAC;IA+DjD,eAAe,CAAC,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,YAAY;IAEvD,WAAW,CAAC,EAAC,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,aAAa,EAAC,EAAE,iBAAiB,GAAG,oBAAoB;IAW7F,cAAc,IAAI,IAAI;IAKtB,sBAAsB,IAAI,IAAI;IAE9B,SAAS;IAET,IAAI,GAAG,IAAI,uBAAuB,CAAmB;IACrD,IAAI,IAAI,IAAI,IAAI,CAAC,MAAM,CAAgC;IACvD,IAAI,OAAO,IAAI,OAAO,CAA2B;IACjD,IAAI,SAAS,IAAI,GAAG,CAAkF;IACtG,IAAI,MAAM,IAAI,eAAe,CAAC,oBAAoB,CAAC,CAAsB;IAEzE,QAAQ,IAAI,MAAM;CAGrB"}

package/dist/timeline/collection/ValueEventCollectionBoxAdapter.js

@@ -0,0 +1,139 @@
+import { ValueEventBox, ValueEventCollectionBox } from "@opendaw/studio-boxes";
+import { asDefined, Curve, linear, Notifier, Option, panic, Terminator, UUID } from "@opendaw/lib-std";
+import { EventCollection, Interpolation, ValueEvent } from "@opendaw/lib-dsp";
+import { Pointers } from "@opendaw/studio-enums";
+import { ValueEventBoxAdapter } from "../event/ValueEventBoxAdapter";
+import { InterpolationFieldAdapter } from "../event/InterpolationFieldAdapter";
+export class ValueEventCollectionBoxAdapter {
+    #terminator = new Terminator();
+    #context;
+    #box;
+    #changeNotifier;
+    #adapters;
+    #events;
+    constructor(context, box) {
+        this.#context = context;
+        this.#box = box;
+        this.#changeNotifier = new Notifier();
+        this.#adapters = UUID.newSet(adapter => adapter.uuid);
+        this.#events = EventCollection.create(ValueEventBoxAdapter.Comparator);
+        const addValueProcedure = (box) => {
+            const adapter = asDefined(box.accept({
+                visitValueEventBox: (box) => this.#context.boxAdapters.adapterFor(box, ValueEventBoxAdapter)
+            }), `Could not find adapter for ${box}`);
+            if (this.#adapters.add(adapter)) {
+                this.#events.add(adapter);
+                this.#onEventsChanged();
+            }
+        };
+        this.#box.events.pointerHub.incoming().forEach(({ box }) => addValueProcedure(box));
+        this.#terminator.own(this.#box.events.pointerHub.subscribeTransactual({
+            onAdd: ({ box }) => addValueProcedure(box),
+            onRemove: ({ box: { address: { uuid } } }) => {
+                this.#events.remove(this.#adapters.removeByKey(uuid));
+                this.#onEventsChanged();
+            }
+        }));
+        this.#terminator.own(this.#box.owners.pointerHub.subscribeTransactual({
+            onAdd: () => this.#changeNotifier.notify(this),
+            onRemove: () => this.#changeNotifier.notify(this)
+        }));
+    }
+    valueAt(position, fallback) { return ValueEvent.valueAt(this.#events, position, fallback); }
+    copy() {
+        const graph = this.#context.boxGraph;
+        const boxCopy = ValueEventCollectionBox.create(graph, UUID.generate());
+        this.#events.asArray().forEach(source => source.copyTo({ events: boxCopy.events }));
+        return this.#context.boxAdapters.adapterFor(boxCopy, ValueEventCollectionBoxAdapter);
+    }
+    cut(position) {
+        const low = this.events.lowerEqual(position);
+        const high = this.events.greaterEqual(position);
+        if (null === high) {
+            if (null === low) {
+                return Option.None;
+            }
+            return Option.wrap(this.createEvent({
+                position,
+                value: low.value,
+                index: low.index,
+                interpolation: low.interpolation
+            }));
+        }
+        if (null === low) {
+            return Option.wrap(this.createEvent({
+                position,
+                value: high.value,
+                index: high.index,
+                interpolation: high.interpolation
+            }));
+        }
+        if (low.position === position) {
+            return Option.wrap(low);
+        }
+        if (low.interpolation.type === "none") {
+            return Option.wrap(this.createEvent({
+                position,
+                value: low.value,
+                index: low.index,
+                interpolation: low.interpolation
+            }));
+        }
+        if (low.interpolation.type === "linear") {
+            const { position: p0, value: v0 } = low;
+            const { position: p1, value: v1 } = high;
+            return Option.wrap(this.createEvent({
+                position,
+                value: linear(v0, v1, (position - p0) / (p1 - p0)),
+                index: 0,
+                interpolation: low.interpolation
+            }));
+        }
+        if (low.interpolation.type === "curve") {
+            const { position: p0, value: y0 } = low;
+            const { position: p1, value: y1 } = high;
+            const steps = p1 - p0;
+            const cutOffset = position - p0;
+            const curve = Curve.byHalf(steps, y0, Curve.valueAt({
+                slope: low.interpolation.slope,
+                steps,
+                y0,
+                y1
+            }, steps * 0.5), y1);
+            const cutValue = Curve.valueAt(curve, cutOffset);
+            const lowSlope = Curve.slopeByHalf(y0, Curve.valueAt(curve, cutOffset * 0.5), cutValue);
+            InterpolationFieldAdapter.write(low.box.interpolation, Interpolation.Curve(lowSlope));
+            return Option.wrap(this.createEvent({
+                position,
+                value: cutValue,
+                index: 0,
+                interpolation: Interpolation.Curve(Curve.slopeByHalf(cutValue, Curve.valueAt(curve, (cutOffset + steps) * 0.5), y1))
+            }));
+        }
+        return panic("Unknown interpolation type");
+    }
+    subscribeChange(observer) { return this.#changeNotifier.subscribe(observer); }
+    createEvent({ position, index, value, interpolation }) {
+        const eventBox = ValueEventBox.create(this.#context.boxGraph, UUID.generate(), box => {
+            box.position.setValue(position);
+            box.index.setValue(index);
+            box.value.setValue(value);
+            box.events.refer(this.#box.events);
+        });
+        InterpolationFieldAdapter.write(eventBox.interpolation, interpolation);
+        return this.#context.boxAdapters.adapterFor(eventBox, ValueEventBoxAdapter);
+    }
+    requestSorting() {
+        this.#events.onIndexingChanged();
+        this.onEventPropertyChanged();
+    }
+    onEventPropertyChanged() { this.#onEventsChanged(); }
+    terminate() { this.#terminator.terminate(); }
+    get box() { return this.#box; }
+    get uuid() { return this.#box.address.uuid; }
+    get address() { return this.#box.address; }
+    get numOwners() { return this.#box.owners.pointerHub.filter(Pointers.ValueEventCollection).length; }
+    get events() { return this.#events; }
+    toString() { return `{ValueEventCollectionBox ${UUID.toString(this.#box.address.uuid)}}`; }
+    #onEventsChanged() { this.#changeNotifier.notify(this); }
+}

package/dist/timeline/event/InterpolationFieldAdapter.d.ts

@@ -0,0 +1,8 @@
+import { Pointers } from "@opendaw/studio-enums";
+import { Int32Field } from "@opendaw/lib-box";
+import { Interpolation } from "@opendaw/lib-dsp";
+export declare namespace InterpolationFieldAdapter {
+    const write: (field: Int32Field<Pointers.ValueInterpolation>, value: Interpolation) => void;
+    const read: (field: Int32Field<Pointers.ValueInterpolation>) => Interpolation;
+}
+//# sourceMappingURL=InterpolationFieldAdapter.d.ts.map

package/dist/timeline/event/InterpolationFieldAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InterpolationFieldAdapter.d.ts","sourceRoot":"","sources":["../../../src/timeline/event/InterpolationFieldAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,uBAAuB,CAAA;AAC9C,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAC,aAAa,EAAC,MAAM,kBAAkB,CAAA;AAI9C,yBAAiB,yBAAyB,CAAC;IAChC,MAAM,KAAK,GAAI,OAAO,UAAU,CAAC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,aAAa,KAAG,IAoB5F,CAAA;IAEM,MAAM,IAAI,GAAI,OAAO,UAAU,CAAC,QAAQ,CAAC,kBAAkB,CAAC,KAAG,aAarE,CAAA;CACJ"}

package/dist/timeline/event/InterpolationFieldAdapter.js

@@ -0,0 +1,47 @@
+import { Pointers } from "@opendaw/studio-enums";
+import { Interpolation } from "@opendaw/lib-dsp";
+import { ValueEventCurveBox } from "@opendaw/studio-boxes";
+import { assertInstanceOf, isDefined, panic, UUID } from "@opendaw/lib-std";
+export var InterpolationFieldAdapter;
+(function (InterpolationFieldAdapter) {
+    InterpolationFieldAdapter.write = (field, value) => {
+        if (value.type === "none") {
+            field.disconnect();
+            field.setValue(0);
+        }
+        else if (value.type === "linear") {
+            field.disconnect();
+            field.setValue(1);
+        }
+        else if (value.type === "curve") {
+            field.setValue(0);
+            const curveBox = field.pointerHub.filter(Pointers.ValueInterpolation).at(0)?.box;
+            if (isDefined(curveBox)) {
+                assertInstanceOf(curveBox, ValueEventCurveBox);
+                curveBox.slope.setValue(value.slope);
+            }
+            else {
+                ValueEventCurveBox.create(field.box.graph, UUID.generate(), box => {
+                    box.slope.setValue(value.slope);
+                    box.event.refer(field);
+                });
+            }
+        }
+    };
+    InterpolationFieldAdapter.read = (field) => {
+        const curveBox = field.pointerHub.incoming().at(0)?.box;
+        if (isDefined(curveBox)) {
+            assertInstanceOf(curveBox, ValueEventCurveBox);
+            return { type: "curve", slope: curveBox.slope.getValue() };
+        }
+        if (field.getValue() === 0) {
+            return Interpolation.None;
+        }
+        else if (field.getValue() === 1) {
+            return Interpolation.Linear;
+        }
+        else {
+            return panic("Unknown Interpolation value");
+        }
+    };
+})(InterpolationFieldAdapter || (InterpolationFieldAdapter = {}));

package/dist/timeline/event/NoteEventBoxAdapter.d.ts

@@ -0,0 +1,45 @@
+import { NoteEvent, ppqn } from "@opendaw/lib-dsp";
+import { float, int, Option, Selectable, unitValue, UUID } from "@opendaw/lib-std";
+import { NoteEventBox } from "@opendaw/studio-boxes";
+import { Address, Field } from "@opendaw/lib-box";
+import { Pointers } from "@opendaw/studio-enums";
+import { BoxAdapter } from "../../BoxAdapter";
+import { BoxAdaptersContext } from "../../BoxAdaptersContext";
+import { NoteEventCollectionBoxAdapter } from "../collection/NoteEventCollectionBoxAdapter";
+type CopyToParams = {
+    position?: ppqn;
+    duration?: ppqn;
+    pitch?: int;
+    playCount?: int;
+    events?: Field<Pointers.NoteEvents>;
+};
+export declare class NoteEventBoxAdapter implements NoteEvent, BoxAdapter, Selectable {
+    #private;
+    readonly type = "note-event";
+    constructor(context: BoxAdaptersContext, box: NoteEventBox);
+    onSelected(): void;
+    onDeselected(): void;
+    terminate(): void;
+    get box(): NoteEventBox;
+    get uuid(): UUID.Format;
+    get address(): Address;
+    get position(): ppqn;
+    get duration(): ppqn;
+    get complete(): int;
+    get velocity(): float;
+    get pitch(): int;
+    get cent(): number;
+    get chance(): int;
+    get playCount(): int;
+    get playCurve(): int;
+    get isSelected(): boolean;
+    get collection(): Option<NoteEventCollectionBoxAdapter>;
+    normalizedPitch(): unitValue;
+    copyAsNoteEvent(): NoteEvent;
+    copyTo(options?: CopyToParams): NoteEventBoxAdapter;
+    computeCurveValue(ratio: unitValue): unitValue;
+    canConsolidate(): boolean;
+    consolidate(): ReadonlyArray<NoteEventBoxAdapter>;
+}
+export {};
+//# sourceMappingURL=NoteEventBoxAdapter.d.ts.map

package/dist/timeline/event/NoteEventBoxAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NoteEventBoxAdapter.d.ts","sourceRoot":"","sources":["../../../src/timeline/event/NoteEventBoxAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAE,IAAI,EAAC,MAAM,kBAAkB,CAAA;AAChD,OAAO,EAAS,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,EAAgB,SAAS,EAAE,IAAI,EAAC,MAAM,kBAAkB,CAAA;AACtG,OAAO,EAAC,YAAY,EAAC,MAAM,uBAAuB,CAAA;AAClD,OAAO,EAAC,OAAO,EAAE,KAAK,EAAsB,MAAM,kBAAkB,CAAA;AACpE,OAAO,EAAC,QAAQ,EAAC,MAAM,uBAAuB,CAAA;AAC9C,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAC,kBAAkB,EAAC,MAAM,0BAA0B,CAAA;AAC3D,OAAO,EAAC,6BAA6B,EAAC,MAAM,6CAA6C,CAAA;AAEzF,KAAK,YAAY,GAAG;IAChB,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,SAAS,CAAC,EAAE,GAAG,CAAC;IAChB,MAAM,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAA;CACtC,CAAA;AAED,qBAAa,mBAAoB,YAAW,SAAS,EAAE,UAAU,EAAE,UAAU;;IACzE,QAAQ,CAAC,IAAI,gBAAe;gBAShB,OAAO,EAAE,kBAAkB,EAAE,GAAG,EAAE,YAAY;IAoB1D,UAAU,IAAI,IAAI;IAIlB,YAAY,IAAI,IAAI;IAKpB,SAAS,IAAI,IAAI;IAEjB,IAAI,GAAG,IAAI,YAAY,CAAmB;IAC1C,IAAI,IAAI,IAAI,IAAI,CAAC,MAAM,CAAgC;IACvD,IAAI,OAAO,IAAI,OAAO,CAA2B;IACjD,IAAI,QAAQ,IAAI,IAAI,CAAuC;IAC3D,IAAI,QAAQ,IAAI,IAAI,CAAuC;IAC3D,IAAI,QAAQ,IAAI,GAAG,CAAuC;IAC1D,IAAI,QAAQ,IAAI,KAAK,CAAuC;IAC5D,IAAI,KAAK,IAAI,GAAG,CAAoC;IACpD,IAAI,IAAI,IAAI,MAAM,CAAmC;IACrD,IAAI,MAAM,IAAI,GAAG,CAAqC;IACtD,IAAI,SAAS,IAAI,GAAG,CAAwC;IAC5D,IAAI,SAAS,IAAI,GAAG,CAAwC;IAC5D,IAAI,UAAU,IAAI,OAAO,CAA0B;IACnD,IAAI,UAAU,IAAI,MAAM,CAAC,6BAA6B,CAAC,CAGtD;IACD,eAAe,IAAI,SAAS;IAM5B,eAAe,IAAI,SAAS;IAW5B,MAAM,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,mBAAmB;IAanD,iBAAiB,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS;IAC9C,cAAc,IAAI,OAAO;IACzB,WAAW,IAAI,aAAa,CAAC,mBAAmB,CAAC;CAgBpD"}