@opendaw/studio-adapters 0.0.48 → 0.0.49

package/dist/FieldAdapter.js

@@ -1,21 +1,33 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _FieldAdapter_field, _FieldAdapter_valueMapping, _FieldAdapter_stringMapping, _FieldAdapter_name, _FieldAdapter_anchor, _FieldAdapter_terminator, _FieldAdapter_valueChangeNotifier, _FieldAdapter_trackBoxAdapter;
 import { clamp, Notifier, Option, Terminator } from "@opendaw/lib-std";
 export class FieldAdapter {
-    #field;
-    #valueMapping;
-    #stringMapping;
-    #name;
-    #anchor;
-    #terminator = new Terminator();
-    #valueChangeNotifier;
-    #trackBoxAdapter = Option.None;
     constructor(field, valueMapping, stringMapping, name, anchor) {
-        this.#field = field;
-        this.#valueMapping = valueMapping;
-        this.#stringMapping = stringMapping;
-        this.#name = name;
-        this.#anchor = anchor ?? 0.0;
-        this.#valueChangeNotifier = this.#terminator.own(new Notifier());
-        this.#terminator.own(this.#field.subscribe(() => this.#valueChangeNotifier.notify(this)));
+        _FieldAdapter_field.set(this, void 0);
+        _FieldAdapter_valueMapping.set(this, void 0);
+        _FieldAdapter_stringMapping.set(this, void 0);
+        _FieldAdapter_name.set(this, void 0);
+        _FieldAdapter_anchor.set(this, void 0);
+        _FieldAdapter_terminator.set(this, new Terminator());
+        _FieldAdapter_valueChangeNotifier.set(this, void 0);
+        _FieldAdapter_trackBoxAdapter.set(this, Option.None);
+        __classPrivateFieldSet(this, _FieldAdapter_field, field, "f");
+        __classPrivateFieldSet(this, _FieldAdapter_valueMapping, valueMapping, "f");
+        __classPrivateFieldSet(this, _FieldAdapter_stringMapping, stringMapping, "f");
+        __classPrivateFieldSet(this, _FieldAdapter_name, name, "f");
+        __classPrivateFieldSet(this, _FieldAdapter_anchor, anchor ?? 0.0, "f");
+        __classPrivateFieldSet(this, _FieldAdapter_valueChangeNotifier, __classPrivateFieldGet(this, _FieldAdapter_terminator, "f").own(new Notifier()), "f");
+        __classPrivateFieldGet(this, _FieldAdapter_terminator, "f").own(__classPrivateFieldGet(this, _FieldAdapter_field, "f").subscribe(() => __classPrivateFieldGet(this, _FieldAdapter_valueChangeNotifier, "f").notify(this)));
         /*
         For debugging: It's not live because floating errors expose false positives,
             and I am too lazy to implement this in the mappings itself.
@@ -24,26 +36,26 @@ export class FieldAdapter {
             console.warn(`${name} (${field.getValue()}) is out of bounds`, valueMapping);
         }
     }
-    get field() { return this.#field; }
-    get valueMapping() { return this.#valueMapping; }
-    get stringMapping() { return this.#stringMapping; }
-    get name() { return this.#name; }
-    get anchor() { return this.#anchor; }
-    get type() { return this.#field.type; }
-    get address() { return this.#field.address; }
-    get track() { return this.#trackBoxAdapter; }
-    subscribe(observer) { return this.#valueChangeNotifier.subscribe(observer); }
+    get field() { return __classPrivateFieldGet(this, _FieldAdapter_field, "f"); }
+    get valueMapping() { return __classPrivateFieldGet(this, _FieldAdapter_valueMapping, "f"); }
+    get stringMapping() { return __classPrivateFieldGet(this, _FieldAdapter_stringMapping, "f"); }
+    get name() { return __classPrivateFieldGet(this, _FieldAdapter_name, "f"); }
+    get anchor() { return __classPrivateFieldGet(this, _FieldAdapter_anchor, "f"); }
+    get type() { return __classPrivateFieldGet(this, _FieldAdapter_field, "f").type; }
+    get address() { return __classPrivateFieldGet(this, _FieldAdapter_field, "f").address; }
+    get track() { return __classPrivateFieldGet(this, _FieldAdapter_trackBoxAdapter, "f"); }
+    subscribe(observer) { return __classPrivateFieldGet(this, _FieldAdapter_valueChangeNotifier, "f").subscribe(observer); }
     catchupAndSubscribe(observer) {
         observer(this);
         return this.subscribe(observer);
     }
-    getValue() { return this.#field.getValue(); }
-    setValue(value) { this.#field.setValue(this.#valueMapping.clamp(value)); }
-    setUnitValue(value) { this.setValue(this.#valueMapping.y(value)); }
-    getUnitValue() { return this.#valueMapping.x(this.getValue()); }
-    getPrintValue() { return this.#stringMapping.x(this.getValue()); }
+    getValue() { return __classPrivateFieldGet(this, _FieldAdapter_field, "f").getValue(); }
+    setValue(value) { __classPrivateFieldGet(this, _FieldAdapter_field, "f").setValue(__classPrivateFieldGet(this, _FieldAdapter_valueMapping, "f").clamp(value)); }
+    setUnitValue(value) { this.setValue(__classPrivateFieldGet(this, _FieldAdapter_valueMapping, "f").y(value)); }
+    getUnitValue() { return __classPrivateFieldGet(this, _FieldAdapter_valueMapping, "f").x(this.getValue()); }
+    getPrintValue() { return __classPrivateFieldGet(this, _FieldAdapter_stringMapping, "f").x(this.getValue()); }
     setPrintValue(text) {
-        const result = this.#stringMapping.y(text);
+        const result = __classPrivateFieldGet(this, _FieldAdapter_stringMapping, "f").y(text);
         if (result.type === "unitValue") {
             this.setUnitValue(clamp(result.value, 0.0, 1.0));
         }
@@ -54,6 +66,7 @@ export class FieldAdapter {
             console.debug(`Unknown text input: '${result.value}'`);
         }
     }
-    reset() { this.setValue(this.#valueMapping.clamp(this.#field.initValue)); }
-    terminate() { this.#terminator.terminate(); }
+    reset() { this.setValue(__classPrivateFieldGet(this, _FieldAdapter_valueMapping, "f").clamp(__classPrivateFieldGet(this, _FieldAdapter_field, "f").initValue)); }
+    terminate() { __classPrivateFieldGet(this, _FieldAdapter_terminator, "f").terminate(); }
 }
+_FieldAdapter_field = new WeakMap(), _FieldAdapter_valueMapping = new WeakMap(), _FieldAdapter_stringMapping = new WeakMap(), _FieldAdapter_name = new WeakMap(), _FieldAdapter_anchor = new WeakMap(), _FieldAdapter_terminator = new WeakMap(), _FieldAdapter_valueChangeNotifier = new WeakMap(), _FieldAdapter_trackBoxAdapter = new WeakMap();

package/dist/IndexedBoxAdapterCollection.js

@@ -1,52 +1,64 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _IndexedBoxAdapterCollection_field, _IndexedBoxAdapterCollection_entries, _IndexedBoxAdapterCollection_listeners, _IndexedBoxAdapterCollection_subscription, _IndexedBoxAdapterCollection_sorted;
 import { assert, BinarySearch, clamp, Listeners, Option, UUID } from "@opendaw/lib-std";
 import { IndexComparator } from "./IndexComparator";
 export class IndexedBoxAdapterCollection {
     static create(field, provider, pointers) {
         return new IndexedBoxAdapterCollection(field, provider, pointers);
     }
-    #field;
-    #entries;
-    #listeners;
-    #subscription;
-    #sorted = null;
     constructor(field, provider, pointers) {
-        this.#field = field;
-        this.#entries = UUID.newSet(entry => entry.adapter.uuid);
-        this.#listeners = new Listeners();
-        this.#subscription = field.pointerHub.catchupAndSubscribe({
+        _IndexedBoxAdapterCollection_field.set(this, void 0);
+        _IndexedBoxAdapterCollection_entries.set(this, void 0);
+        _IndexedBoxAdapterCollection_listeners.set(this, void 0);
+        _IndexedBoxAdapterCollection_subscription.set(this, void 0);
+        _IndexedBoxAdapterCollection_sorted.set(this, null);
+        __classPrivateFieldSet(this, _IndexedBoxAdapterCollection_field, field, "f");
+        __classPrivateFieldSet(this, _IndexedBoxAdapterCollection_entries, UUID.newSet(entry => entry.adapter.uuid), "f");
+        __classPrivateFieldSet(this, _IndexedBoxAdapterCollection_listeners, new Listeners(), "f");
+        __classPrivateFieldSet(this, _IndexedBoxAdapterCollection_subscription, field.pointerHub.catchupAndSubscribe({
             onAdded: (pointer) => {
-                this.#sorted = null;
+                __classPrivateFieldSet(this, _IndexedBoxAdapterCollection_sorted, null, "f");
                 const adapter = provider(pointer.box);
                 const subscription = adapter.indexField.subscribe(() => {
-                    this.#sorted = null;
-                    this.#listeners.proxy.onReorder(adapter);
+                    __classPrivateFieldSet(this, _IndexedBoxAdapterCollection_sorted, null, "f");
+                    __classPrivateFieldGet(this, _IndexedBoxAdapterCollection_listeners, "f").proxy.onReorder(adapter);
                 });
-                const added = this.#entries.add({ adapter, subscription });
+                const added = __classPrivateFieldGet(this, _IndexedBoxAdapterCollection_entries, "f").add({ adapter, subscription });
                 assert(added, `Could not add ${adapter}`);
-                this.#listeners.proxy.onAdd(adapter);
+                __classPrivateFieldGet(this, _IndexedBoxAdapterCollection_listeners, "f").proxy.onAdd(adapter);
             },
             onRemoved: (pointer) => {
-                this.#sorted = null;
+                __classPrivateFieldSet(this, _IndexedBoxAdapterCollection_sorted, null, "f");
                 const uuid = pointer.box.address.uuid;
-                const { adapter, subscription } = this.#entries.removeByKey(uuid);
+                const { adapter, subscription } = __classPrivateFieldGet(this, _IndexedBoxAdapterCollection_entries, "f").removeByKey(uuid);
                 subscription.terminate();
-                this.#listeners.proxy.onRemove(adapter);
+                __classPrivateFieldGet(this, _IndexedBoxAdapterCollection_listeners, "f").proxy.onRemove(adapter);
             }
-        }, pointers);
+        }, pointers), "f");
     }
-    field() { return this.#field; }
+    field() { return __classPrivateFieldGet(this, _IndexedBoxAdapterCollection_field, "f"); }
     subscribe(listener) {
-        return this.#listeners.subscribe(listener);
+        return __classPrivateFieldGet(this, _IndexedBoxAdapterCollection_listeners, "f").subscribe(listener);
     }
     catchupAndSubscribe(listener) {
-        this.#entries.forEach(({ adapter }) => listener.onAdd(adapter));
+        __classPrivateFieldGet(this, _IndexedBoxAdapterCollection_entries, "f").forEach(({ adapter }) => listener.onAdd(adapter));
         return this.subscribe(listener);
     }
     getAdapterByIndex(index) {
         const idx = BinarySearch.exactMapped(this.adapters(), index, IndexComparator, adapter => adapter.indexField.getValue());
         return idx === -1 ? Option.None : Option.wrap(this.adapters()[idx]);
     }
-    getAdapterById(uuid) { return this.#entries.opt(uuid).map(({ adapter }) => adapter); }
+    getAdapterById(uuid) { return __classPrivateFieldGet(this, _IndexedBoxAdapterCollection_entries, "f").opt(uuid).map(({ adapter }) => adapter); }
     getMinFreeIndex() {
         const adapters = this.adapters();
         for (let index = 0; index < adapters.length; index++) {
@@ -57,12 +69,12 @@ export class IndexedBoxAdapterCollection {
         return adapters.length;
     }
     adapters() {
-        if (this.#sorted === null) {
-            this.#sorted = this.#entries.values()
+        if (__classPrivateFieldGet(this, _IndexedBoxAdapterCollection_sorted, "f") === null) {
+            __classPrivateFieldSet(this, _IndexedBoxAdapterCollection_sorted, __classPrivateFieldGet(this, _IndexedBoxAdapterCollection_entries, "f").values()
                 .map(({ adapter }) => adapter)
-                .sort((a, b) => a.indexField.getValue() - b.indexField.getValue());
+                .sort((a, b) => a.indexField.getValue() - b.indexField.getValue()), "f");
         }
-        return this.#sorted;
+        return __classPrivateFieldGet(this, _IndexedBoxAdapterCollection_sorted, "f");
     }
     move(adapter, delta) {
         this.moveIndex(adapter.indexField.getValue(), delta);
@@ -88,13 +100,14 @@ export class IndexedBoxAdapterCollection {
             console.warn(`moveIndex had no effect: startIndex: ${startIndex}, delta: ${delta}`);
         }
     }
-    size() { return this.#entries.size(); }
+    size() { return __classPrivateFieldGet(this, _IndexedBoxAdapterCollection_entries, "f").size(); }
     isEmpty() { return this.size() === 0; }
     terminate() {
-        this.#sorted = null;
-        this.#entries.forEach(({ subscription }) => subscription.terminate());
-        this.#entries.clear();
-        this.#listeners.terminate();
-        this.#subscription.terminate();
+        __classPrivateFieldSet(this, _IndexedBoxAdapterCollection_sorted, null, "f");
+        __classPrivateFieldGet(this, _IndexedBoxAdapterCollection_entries, "f").forEach(({ subscription }) => subscription.terminate());
+        __classPrivateFieldGet(this, _IndexedBoxAdapterCollection_entries, "f").clear();
+        __classPrivateFieldGet(this, _IndexedBoxAdapterCollection_listeners, "f").terminate();
+        __classPrivateFieldGet(this, _IndexedBoxAdapterCollection_subscription, "f").terminate();
     }
 }
+_IndexedBoxAdapterCollection_field = new WeakMap(), _IndexedBoxAdapterCollection_entries = new WeakMap(), _IndexedBoxAdapterCollection_listeners = new WeakMap(), _IndexedBoxAdapterCollection_subscription = new WeakMap(), _IndexedBoxAdapterCollection_sorted = new WeakMap();

package/dist/NoteBroadcaster.js

@@ -1,27 +1,40 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _NoteBroadcaster_terminator, _NoteBroadcaster_broadcaster, _NoteBroadcaster_address, _NoteBroadcaster_bits;
 import { Bits, EmptyExec, Terminator } from "@opendaw/lib-std";
 export class NoteBroadcaster {
-    #terminator = new Terminator();
-    #broadcaster;
-    #address;
-    #bits;
     constructor(broadcaster, address) {
-        this.#broadcaster = broadcaster;
-        this.#address = address;
-        this.#bits = new Bits(128);
-        this.#terminator.own(this.#broadcaster.broadcastIntegers(this.#address, new Int32Array(this.#bits.buffer), EmptyExec));
+        _NoteBroadcaster_terminator.set(this, new Terminator());
+        _NoteBroadcaster_broadcaster.set(this, void 0);
+        _NoteBroadcaster_address.set(this, void 0);
+        _NoteBroadcaster_bits.set(this, void 0);
+        __classPrivateFieldSet(this, _NoteBroadcaster_broadcaster, broadcaster, "f");
+        __classPrivateFieldSet(this, _NoteBroadcaster_address, address, "f");
+        __classPrivateFieldSet(this, _NoteBroadcaster_bits, new Bits(128), "f");
+        __classPrivateFieldGet(this, _NoteBroadcaster_terminator, "f").own(__classPrivateFieldGet(this, _NoteBroadcaster_broadcaster, "f").broadcastIntegers(__classPrivateFieldGet(this, _NoteBroadcaster_address, "f"), new Int32Array(__classPrivateFieldGet(this, _NoteBroadcaster_bits, "f").buffer), EmptyExec));
     }
     noteOn(note) {
         if (note >= 0 && note < 128) {
-            this.#bits.setBit(note, true);
+            __classPrivateFieldGet(this, _NoteBroadcaster_bits, "f").setBit(note, true);
         }
     }
     noteOff(note) {
         if (note >= 0 && note < 128) {
-            this.#bits.setBit(note, false);
+            __classPrivateFieldGet(this, _NoteBroadcaster_bits, "f").setBit(note, false);
         }
     }
     reset() { }
-    clear() { this.#bits.clear(); }
-    terminate() { this.#terminator.terminate(); }
+    clear() { __classPrivateFieldGet(this, _NoteBroadcaster_bits, "f").clear(); }
+    terminate() { __classPrivateFieldGet(this, _NoteBroadcaster_terminator, "f").terminate(); }
     toString() { return `{${this.constructor.name}}`; }
 }
+_NoteBroadcaster_terminator = new WeakMap(), _NoteBroadcaster_broadcaster = new WeakMap(), _NoteBroadcaster_address = new WeakMap(), _NoteBroadcaster_bits = new WeakMap();

package/dist/NoteStreamReceiver.js

@@ -1,23 +1,36 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _NoteStreamReceiver_terminator, _NoteStreamReceiver_receiver, _NoteStreamReceiver_address, _NoteStreamReceiver_bits, _NoteStreamReceiver_notifier;
 import { Bits, Notifier, Terminator } from "@opendaw/lib-std";
 export class NoteStreamReceiver {
-    #terminator = new Terminator();
-    #receiver;
-    #address;
-    #bits;
-    #notifier;
     constructor(receiver, address) {
-        this.#receiver = receiver;
-        this.#address = address;
-        this.#bits = new Bits(128);
-        this.#notifier = new Notifier();
-        this.#terminator.own(this.#receiver.subscribeIntegers(this.#address, (array) => {
-            if (this.#bits.replace(array.buffer)) {
-                this.#notifier.notify(this);
+        _NoteStreamReceiver_terminator.set(this, new Terminator());
+        _NoteStreamReceiver_receiver.set(this, void 0);
+        _NoteStreamReceiver_address.set(this, void 0);
+        _NoteStreamReceiver_bits.set(this, void 0);
+        _NoteStreamReceiver_notifier.set(this, void 0);
+        __classPrivateFieldSet(this, _NoteStreamReceiver_receiver, receiver, "f");
+        __classPrivateFieldSet(this, _NoteStreamReceiver_address, address, "f");
+        __classPrivateFieldSet(this, _NoteStreamReceiver_bits, new Bits(128), "f");
+        __classPrivateFieldSet(this, _NoteStreamReceiver_notifier, new Notifier(), "f");
+        __classPrivateFieldGet(this, _NoteStreamReceiver_terminator, "f").own(__classPrivateFieldGet(this, _NoteStreamReceiver_receiver, "f").subscribeIntegers(__classPrivateFieldGet(this, _NoteStreamReceiver_address, "f"), (array) => {
+            if (__classPrivateFieldGet(this, _NoteStreamReceiver_bits, "f").replace(array.buffer)) {
+                __classPrivateFieldGet(this, _NoteStreamReceiver_notifier, "f").notify(this);
             }
         }));
     }
-    isNoteOn(note) { return this.#bits.getBit(note); }
-    isAnyNoteOn() { return this.#bits.nonEmpty(); }
-    subscribe(observer) { return this.#notifier.subscribe(observer); }
-    terminate() { this.#terminator.terminate(); }
+    isNoteOn(note) { return __classPrivateFieldGet(this, _NoteStreamReceiver_bits, "f").getBit(note); }
+    isAnyNoteOn() { return __classPrivateFieldGet(this, _NoteStreamReceiver_bits, "f").nonEmpty(); }
+    subscribe(observer) { return __classPrivateFieldGet(this, _NoteStreamReceiver_notifier, "f").subscribe(observer); }
+    terminate() { __classPrivateFieldGet(this, _NoteStreamReceiver_terminator, "f").terminate(); }
 }
+_NoteStreamReceiver_terminator = new WeakMap(), _NoteStreamReceiver_receiver = new WeakMap(), _NoteStreamReceiver_address = new WeakMap(), _NoteStreamReceiver_bits = new WeakMap(), _NoteStreamReceiver_notifier = new WeakMap();

package/dist/ParameterAdapterSet.js

@@ -1,28 +1,41 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ParameterAdapterSet_context, _ParameterAdapterSet_parameters;
 import { Address } from "@opendaw/lib-box";
 import { assert } from "@opendaw/lib-std";
 import { AutomatableParameterFieldAdapter } from "./AutomatableParameterFieldAdapter";
 export class ParameterAdapterSet {
-    #context;
-    #parameters;
     constructor(context) {
-        this.#context = context;
-        this.#parameters = Address.newSet(adapter => adapter.address);
+        _ParameterAdapterSet_context.set(this, void 0);
+        _ParameterAdapterSet_parameters.set(this, void 0);
+        __classPrivateFieldSet(this, _ParameterAdapterSet_context, context, "f");
+        __classPrivateFieldSet(this, _ParameterAdapterSet_parameters, Address.newSet(adapter => adapter.address), "f");
     }
     terminate() {
-        this.#parameters.forEach(parameter => parameter.terminate());
-        this.#parameters.clear();
+        __classPrivateFieldGet(this, _ParameterAdapterSet_parameters, "f").forEach(parameter => parameter.terminate());
+        __classPrivateFieldGet(this, _ParameterAdapterSet_parameters, "f").clear();
     }
-    parameters() { return this.#parameters.values(); }
+    parameters() { return __classPrivateFieldGet(this, _ParameterAdapterSet_parameters, "f").values(); }
     parameterAt(address) {
-        return this.#parameters.getOrThrow(address, () => new Error(`No ParameterAdapter found at [${address.toString()}]`));
+        return __classPrivateFieldGet(this, _ParameterAdapterSet_parameters, "f").getOrThrow(address, () => new Error(`No ParameterAdapter found at [${address.toString()}]`));
     }
     createParameter(field, valueMapping, stringMapping, name, anchor) {
-        const adapter = new AutomatableParameterFieldAdapter(this.#context, field, valueMapping, stringMapping, name, anchor);
-        const added = this.#parameters.add(adapter);
+        const adapter = new AutomatableParameterFieldAdapter(__classPrivateFieldGet(this, _ParameterAdapterSet_context, "f"), field, valueMapping, stringMapping, name, anchor);
+        const added = __classPrivateFieldGet(this, _ParameterAdapterSet_parameters, "f").add(adapter);
         assert(added, `Could not add adapter for ${field}`);
         return adapter;
     }
     removeParameter(address) {
-        return this.#parameters.removeByKey(address);
+        return __classPrivateFieldGet(this, _ParameterAdapterSet_parameters, "f").removeByKey(address);
     }
 }
+_ParameterAdapterSet_context = new WeakMap(), _ParameterAdapterSet_parameters = new WeakMap();

package/dist/ParameterFieldAdapters.js

@@ -1,13 +1,26 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ParameterFieldAdapters_set;
 import { Address } from "@opendaw/lib-box";
 export class ParameterFieldAdapters {
-    #set;
     constructor() {
-        this.#set = Address.newSet(adapter => adapter.field.address);
+        _ParameterFieldAdapters_set.set(this, void 0);
+        __classPrivateFieldSet(this, _ParameterFieldAdapters_set, Address.newSet(adapter => adapter.field.address), "f");
     }
     register(adapter) {
-        this.#set.add(adapter);
-        return { terminate: () => this.#set.removeByValue(adapter) };
+        __classPrivateFieldGet(this, _ParameterFieldAdapters_set, "f").add(adapter);
+        return { terminate: () => __classPrivateFieldGet(this, _ParameterFieldAdapters_set, "f").removeByValue(adapter) };
     }
-    get(address) { return this.#set.get(address); }
-    opt(address) { return this.#set.opt(address); }
+    get(address) { return __classPrivateFieldGet(this, _ParameterFieldAdapters_set, "f").get(address); }
+    opt(address) { return __classPrivateFieldGet(this, _ParameterFieldAdapters_set, "f").opt(address); }
 }
+_ParameterFieldAdapters_set = new WeakMap();

package/dist/Parsing.d.ts

@@ -0,0 +1,5 @@
+import { Attempt, int } from "@opendaw/lib-std";
+export declare namespace Parsing {
+    const parseTimeSignature: (input: string) => Attempt<[int, int], string>;
+}
+//# sourceMappingURL=Parsing.d.ts.map

package/dist/Parsing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Parsing.d.ts","sourceRoot":"","sources":["../src/Parsing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAE,GAAG,EAAC,MAAM,kBAAkB,CAAA;AAG7C,yBAAiB,OAAO,CAAC;IACd,MAAM,kBAAkB,GAAI,OAAO,MAAM,KAAG,OAAO,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,MAAM,CAK5E,CAAA;CACJ"}

package/dist/Parsing.js

@@ -0,0 +1,10 @@
+import { Validator } from "./Validator";
+export var Parsing;
+(function (Parsing) {
+    Parsing.parseTimeSignature = (input) => {
+        const [first, second] = input.split("/");
+        const numerator = parseInt(first, 10);
+        const denominator = parseInt(second, 10);
+        return Validator.isTimeSignatureValid(numerator, denominator);
+    };
+})(Parsing || (Parsing = {}));

package/dist/PianoModeAdapter.js

@@ -1,28 +1,41 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PianoModeAdapter_object, _PianoModeAdapter_keyboard, _PianoModeAdapter_timeRangeInQuarters, _PianoModeAdapter_noteScale, _PianoModeAdapter_noteLabels, _PianoModeAdapter_transpose;
 import { StringMapping, ValueMapping } from "@opendaw/lib-std";
 import { FieldAdapter } from "./FieldAdapter";
 import { Propagation } from "@opendaw/lib-box";
 export class PianoModeAdapter {
-    #object;
-    #keyboard;
-    #timeRangeInQuarters;
-    #noteScale;
-    #noteLabels;
-    #transpose;
     constructor(object) {
-        this.#object = object;
-        this.#keyboard = new FieldAdapter(this.#object.keyboard, ValueMapping.values([88, 76, 61, 49]), StringMapping.numeric({ fractionDigits: 1 }), "Keyboard Type");
-        this.#timeRangeInQuarters = new FieldAdapter(this.#object.timeRangeInQuarters, ValueMapping.exponential(1, 64), StringMapping.numeric({ fractionDigits: 1 }), "Time-Range");
-        this.#noteScale = new FieldAdapter(this.#object.noteScale, ValueMapping.exponential(0.5, 2.0), StringMapping.numeric({ fractionDigits: 1 }), "Note Scale");
-        this.#noteLabels = new FieldAdapter(this.#object.noteLabels, ValueMapping.bool, StringMapping.bool, "Note Labels");
-        this.#transpose = new FieldAdapter(this.#object.transpose, ValueMapping.linearInteger(-48, 48), StringMapping.numeric({ fractionDigits: 0 }), "Transpose");
+        _PianoModeAdapter_object.set(this, void 0);
+        _PianoModeAdapter_keyboard.set(this, void 0);
+        _PianoModeAdapter_timeRangeInQuarters.set(this, void 0);
+        _PianoModeAdapter_noteScale.set(this, void 0);
+        _PianoModeAdapter_noteLabels.set(this, void 0);
+        _PianoModeAdapter_transpose.set(this, void 0);
+        __classPrivateFieldSet(this, _PianoModeAdapter_object, object, "f");
+        __classPrivateFieldSet(this, _PianoModeAdapter_keyboard, new FieldAdapter(__classPrivateFieldGet(this, _PianoModeAdapter_object, "f").keyboard, ValueMapping.values([88, 76, 61, 49]), StringMapping.numeric({ fractionDigits: 1 }), "Keyboard Type"), "f");
+        __classPrivateFieldSet(this, _PianoModeAdapter_timeRangeInQuarters, new FieldAdapter(__classPrivateFieldGet(this, _PianoModeAdapter_object, "f").timeRangeInQuarters, ValueMapping.exponential(1, 64), StringMapping.numeric({ fractionDigits: 1 }), "Time-Range"), "f");
+        __classPrivateFieldSet(this, _PianoModeAdapter_noteScale, new FieldAdapter(__classPrivateFieldGet(this, _PianoModeAdapter_object, "f").noteScale, ValueMapping.exponential(0.5, 2.0), StringMapping.numeric({ fractionDigits: 1 }), "Note Scale"), "f");
+        __classPrivateFieldSet(this, _PianoModeAdapter_noteLabels, new FieldAdapter(__classPrivateFieldGet(this, _PianoModeAdapter_object, "f").noteLabels, ValueMapping.bool, StringMapping.bool, "Note Labels"), "f");
+        __classPrivateFieldSet(this, _PianoModeAdapter_transpose, new FieldAdapter(__classPrivateFieldGet(this, _PianoModeAdapter_object, "f").transpose, ValueMapping.linearInteger(-48, 48), StringMapping.numeric({ fractionDigits: 0 }), "Transpose"), "f");
     }
     subscribe(observer) {
-        return this.#object.box.subscribe(Propagation.Children, () => observer(this));
+        return __classPrivateFieldGet(this, _PianoModeAdapter_object, "f").box.subscribe(Propagation.Children, () => observer(this));
     }
-    get object() { return this.#object; }
-    get keyboard() { return this.#keyboard; }
-    get timeRangeInQuarters() { return this.#timeRangeInQuarters; }
-    get noteScale() { return this.#noteScale; }
-    get noteLabels() { return this.#noteLabels; }
-    get transpose() { return this.#transpose; }
+    get object() { return __classPrivateFieldGet(this, _PianoModeAdapter_object, "f"); }
+    get keyboard() { return __classPrivateFieldGet(this, _PianoModeAdapter_keyboard, "f"); }
+    get timeRangeInQuarters() { return __classPrivateFieldGet(this, _PianoModeAdapter_timeRangeInQuarters, "f"); }
+    get noteScale() { return __classPrivateFieldGet(this, _PianoModeAdapter_noteScale, "f"); }
+    get noteLabels() { return __classPrivateFieldGet(this, _PianoModeAdapter_noteLabels, "f"); }
+    get transpose() { return __classPrivateFieldGet(this, _PianoModeAdapter_transpose, "f"); }
 }
+_PianoModeAdapter_object = new WeakMap(), _PianoModeAdapter_keyboard = new WeakMap(), _PianoModeAdapter_timeRangeInQuarters = new WeakMap(), _PianoModeAdapter_noteScale = new WeakMap(), _PianoModeAdapter_noteLabels = new WeakMap(), _PianoModeAdapter_transpose = new WeakMap();

package/dist/RootBoxAdapter.js

@@ -1,3 +1,15 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _RootBoxAdapter_context, _RootBoxAdapter_box, _RootBoxAdapter_audioUnits, _RootBoxAdapter_audioBusses, _RootBoxAdapter_pianoMode;
 import { MIDIOutputBox } from "@opendaw/studio-boxes";
 import { asInstanceOf } from "@opendaw/lib-std";
 import { AudioBusBoxAdapter } from "./audio-unit/AudioBusBoxAdapter";
@@ -9,40 +21,41 @@ import { TimelineBoxAdapter } from "./timeline/TimelineBoxAdapter";
 import { GrooveShuffleBoxAdapter } from "./grooves/GrooveShuffleBoxAdapter";
 import { PianoModeAdapter } from "./PianoModeAdapter";
 export class RootBoxAdapter {
-    #context;
-    #box;
-    #audioUnits;
-    #audioBusses;
-    #pianoMode;
     constructor(context, box) {
-        this.#context = context;
-        this.#box = box;
-        this.#audioUnits = IndexedBoxAdapterCollection.create(this.#box.audioUnits, box => this.#context.boxAdapters.adapterFor(box, AudioUnitBoxAdapter), Pointers.AudioUnits);
-        this.#audioBusses = new BoxAdapterCollection(this.#box.audioBusses.pointerHub, box => this.#context.boxAdapters.adapterFor(box, AudioBusBoxAdapter), Pointers.AudioBusses);
-        this.#pianoMode = new PianoModeAdapter(this.#box.pianoMode);
+        _RootBoxAdapter_context.set(this, void 0);
+        _RootBoxAdapter_box.set(this, void 0);
+        _RootBoxAdapter_audioUnits.set(this, void 0);
+        _RootBoxAdapter_audioBusses.set(this, void 0);
+        _RootBoxAdapter_pianoMode.set(this, void 0);
+        __classPrivateFieldSet(this, _RootBoxAdapter_context, context, "f");
+        __classPrivateFieldSet(this, _RootBoxAdapter_box, box, "f");
+        __classPrivateFieldSet(this, _RootBoxAdapter_audioUnits, IndexedBoxAdapterCollection.create(__classPrivateFieldGet(this, _RootBoxAdapter_box, "f").audioUnits, box => __classPrivateFieldGet(this, _RootBoxAdapter_context, "f").boxAdapters.adapterFor(box, AudioUnitBoxAdapter), Pointers.AudioUnits), "f");
+        __classPrivateFieldSet(this, _RootBoxAdapter_audioBusses, new BoxAdapterCollection(__classPrivateFieldGet(this, _RootBoxAdapter_box, "f").audioBusses.pointerHub, box => __classPrivateFieldGet(this, _RootBoxAdapter_context, "f").boxAdapters.adapterFor(box, AudioBusBoxAdapter), Pointers.AudioBusses), "f");
+        __classPrivateFieldSet(this, _RootBoxAdapter_pianoMode, new PianoModeAdapter(__classPrivateFieldGet(this, _RootBoxAdapter_box, "f").pianoMode), "f");
     }
-    get uuid() { return this.#box.address.uuid; }
-    get address() { return this.#box.address; }
-    get box() { return this.#box; }
-    get audioBusses() { return this.#audioBusses; }
-    get audioUnits() { return this.#audioUnits; }
+    get uuid() { return __classPrivateFieldGet(this, _RootBoxAdapter_box, "f").address.uuid; }
+    get address() { return __classPrivateFieldGet(this, _RootBoxAdapter_box, "f").address; }
+    get box() { return __classPrivateFieldGet(this, _RootBoxAdapter_box, "f"); }
+    get audioBusses() { return __classPrivateFieldGet(this, _RootBoxAdapter_audioBusses, "f"); }
+    get audioUnits() { return __classPrivateFieldGet(this, _RootBoxAdapter_audioUnits, "f"); }
     get clips() {
-        return this.#audioUnits.adapters()
+        return __classPrivateFieldGet(this, _RootBoxAdapter_audioUnits, "f").adapters()
             .flatMap(adapter => adapter.tracks.collection.adapters())
             .flatMap(track => track.clips.collection.adapters());
     }
     get groove() {
-        return this.#context.boxAdapters
-            .adapterFor(this.#box.groove.targetVertex.unwrap("no groove").box, GrooveShuffleBoxAdapter);
+        return __classPrivateFieldGet(this, _RootBoxAdapter_context, "f").boxAdapters
+            .adapterFor(__classPrivateFieldGet(this, _RootBoxAdapter_box, "f").groove.targetVertex.unwrap("no groove").box, GrooveShuffleBoxAdapter);
     }
     get timeline() {
-        return this.#context.boxAdapters
-            .adapterFor(this.#box.timeline.targetVertex.unwrap("no timeline").box, TimelineBoxAdapter);
+        return __classPrivateFieldGet(this, _RootBoxAdapter_context, "f").boxAdapters
+            .adapterFor(__classPrivateFieldGet(this, _RootBoxAdapter_box, "f").timeline.targetVertex.unwrap("no timeline").box, TimelineBoxAdapter);
     }
-    get pianoMode() { return this.#pianoMode; }
-    get created() { return new Date(this.#box.created.getValue()); }
+    get pianoMode() { return __classPrivateFieldGet(this, _RootBoxAdapter_pianoMode, "f"); }
+    get created() { return new Date(__classPrivateFieldGet(this, _RootBoxAdapter_box, "f").created.getValue()); }
     get midiOutputDevices() {
-        return this.#box.outputMidiDevices.pointerHub.incoming().map(({ box }) => asInstanceOf(box, MIDIOutputBox));
+        return __classPrivateFieldGet(this, _RootBoxAdapter_box, "f").outputMidiDevices.pointerHub.incoming().map(({ box }) => asInstanceOf(box, MIDIOutputBox));
     }
-    terminate() { this.#audioUnits.terminate(); }
+    terminate() { __classPrivateFieldGet(this, _RootBoxAdapter_audioUnits, "f").terminate(); }
 }
+_RootBoxAdapter_context = new WeakMap(), _RootBoxAdapter_box = new WeakMap(), _RootBoxAdapter_audioUnits = new WeakMap(), _RootBoxAdapter_audioBusses = new WeakMap(), _RootBoxAdapter_pianoMode = new WeakMap();

package/dist/Validator.d.ts

@@ -0,0 +1,10 @@
+import { BoxGraph } from "@opendaw/lib-box";
+import { Attempt, int } from "@opendaw/lib-std";
+export declare namespace Validator {
+    const isTimeSignatureValid: (numerator: int, denominator: int) => Attempt<[int, int], string>;
+    const MIN_BPM = 30;
+    const MAX_BPM = 1000;
+    const clampBpm: (bpm: number) => number;
+    const hasOverlappingRegions: (boxGraph: BoxGraph) => boolean;
+}
+//# sourceMappingURL=Validator.d.ts.map

package/dist/Validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Validator.d.ts","sourceRoot":"","sources":["../src/Validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,kBAAkB,CAAA;AAEzC,OAAO,EAAS,OAAO,EAAmB,GAAG,EAAC,MAAM,kBAAkB,CAAA;AAItE,yBAAiB,SAAS,CAAC;IAChB,MAAM,oBAAoB,GAAI,WAAW,GAAG,EAAE,aAAa,GAAG,KAAG,OAAO,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,MAAM,CAQjG,CAAA;IAEM,MAAM,OAAO,KAAO,CAAA;IACpB,MAAM,OAAO,OAAS,CAAA;IAEtB,MAAM,QAAQ,GAAI,KAAK,MAAM,KAAG,MAAqE,CAAA;IAErG,MAAM,qBAAqB,GAAI,UAAU,QAAQ,KAAG,OAe3C,CAAA;CACnB"}