@opendaw/studio-adapters 0.0.48 → 0.0.50

package/dist/modular/connector.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 _ModuleConnectorAdapter_boxAdapters, _ModuleConnectorAdapter_field, _ModuleConnectorAdapter_direction, _ModuleConnectorAdapter_name;
 import { Pointers } from "@opendaw/studio-enums";
 import { Arrays } from "@opendaw/lib-std";
 import { ModuleConnectionAdapter } from "./connection";
@@ -10,15 +22,15 @@ export class ModuleConnectorAdapter {
     static create(boxAdapters, field, direction, name) {
         return new ModuleConnectorAdapter(boxAdapters, field, direction, name ?? field.fieldName);
     }
-    #boxAdapters;
-    #field;
-    #direction;
-    #name;
     constructor(boxAdapters, field, direction, name) {
-        this.#boxAdapters = boxAdapters;
-        this.#field = field;
-        this.#direction = direction;
-        this.#name = name;
+        _ModuleConnectorAdapter_boxAdapters.set(this, void 0);
+        _ModuleConnectorAdapter_field.set(this, void 0);
+        _ModuleConnectorAdapter_direction.set(this, void 0);
+        _ModuleConnectorAdapter_name.set(this, void 0);
+        __classPrivateFieldSet(this, _ModuleConnectorAdapter_boxAdapters, boxAdapters, "f");
+        __classPrivateFieldSet(this, _ModuleConnectorAdapter_field, field, "f");
+        __classPrivateFieldSet(this, _ModuleConnectorAdapter_direction, direction, "f");
+        __classPrivateFieldSet(this, _ModuleConnectorAdapter_name, name, "f");
     }
     matches(other) {
         return this.direction !== other.direction && this.field.pointerRules.accepts
@@ -26,17 +38,18 @@ export class ModuleConnectorAdapter {
             .some(type => type === accepts));
     }
     get connections() {
-        if (this.#field.pointerHub.isEmpty()) {
+        if (__classPrivateFieldGet(this, _ModuleConnectorAdapter_field, "f").pointerHub.isEmpty()) {
             return Arrays.empty();
         }
-        return this.#field.pointerHub.filter(Pointers.VoltageConnection)
-            .map(({ box }) => this.#boxAdapters.adapterFor(box, ModuleConnectionAdapter));
+        return __classPrivateFieldGet(this, _ModuleConnectorAdapter_field, "f").pointerHub.filter(Pointers.VoltageConnection)
+            .map(({ box }) => __classPrivateFieldGet(this, _ModuleConnectorAdapter_boxAdapters, "f").adapterFor(box, ModuleConnectionAdapter));
     }
-    get field() { return this.#field; }
-    get address() { return this.#field.address; }
-    get direction() { return this.#direction; }
-    get name() { return this.#name; }
+    get field() { return __classPrivateFieldGet(this, _ModuleConnectorAdapter_field, "f"); }
+    get address() { return __classPrivateFieldGet(this, _ModuleConnectorAdapter_field, "f").address; }
+    get direction() { return __classPrivateFieldGet(this, _ModuleConnectorAdapter_direction, "f"); }
+    get name() { return __classPrivateFieldGet(this, _ModuleConnectorAdapter_name, "f"); }
     toString() {
-        return `{ModuleConnectorAdapter address: ${this.#field.address.toString()}, direction: ${this.#direction}}`;
+        return `{ModuleConnectorAdapter address: ${__classPrivateFieldGet(this, _ModuleConnectorAdapter_field, "f").address.toString()}, direction: ${__classPrivateFieldGet(this, _ModuleConnectorAdapter_direction, "f")}}`;
     }
 }
+_ModuleConnectorAdapter_boxAdapters = new WeakMap(), _ModuleConnectorAdapter_field = new WeakMap(), _ModuleConnectorAdapter_direction = new WeakMap(), _ModuleConnectorAdapter_name = new WeakMap();

package/dist/modular/modular.js

@@ -1,68 +1,81 @@
+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 _ModularAdapter_terminator, _ModularAdapter_listeners, _ModularAdapter_context, _ModularAdapter_box, _ModularAdapter_modules, _ModularAdapter_connections;
 import { asDefined, ifDefined, Listeners, Terminator, UUID } from "@opendaw/lib-std";
 import { ModuleConnectionAdapter } from "./connection";
 import { Pointers } from "@opendaw/studio-enums";
 import { Modules } from "./module";
 import { ModularDeviceBoxAdapter } from "../devices/audio-effects/ModularDeviceBoxAdapter";
 export class ModularAdapter {
-    #terminator = new Terminator();
-    #listeners;
-    #context;
-    #box;
-    #modules;
-    #connections;
     constructor(context, box) {
-        this.#context = context;
-        this.#box = box;
-        this.#listeners = this.#terminator.own(new Listeners());
-        this.#modules = UUID.newSet(adapter => adapter.uuid);
-        this.#connections = UUID.newSet(adapter => adapter.uuid);
+        _ModularAdapter_terminator.set(this, new Terminator());
+        _ModularAdapter_listeners.set(this, void 0);
+        _ModularAdapter_context.set(this, void 0);
+        _ModularAdapter_box.set(this, void 0);
+        _ModularAdapter_modules.set(this, void 0);
+        _ModularAdapter_connections.set(this, void 0);
+        __classPrivateFieldSet(this, _ModularAdapter_context, context, "f");
+        __classPrivateFieldSet(this, _ModularAdapter_box, box, "f");
+        __classPrivateFieldSet(this, _ModularAdapter_listeners, __classPrivateFieldGet(this, _ModularAdapter_terminator, "f").own(new Listeners()), "f");
+        __classPrivateFieldSet(this, _ModularAdapter_modules, UUID.newSet(adapter => adapter.uuid), "f");
+        __classPrivateFieldSet(this, _ModularAdapter_connections, UUID.newSet(adapter => adapter.uuid), "f");
         const addModule = (pointer) => {
-            const adapter = Modules.adapterFor(this.#context.boxAdapters, pointer.box);
-            const added = this.#modules.add(adapter);
+            const adapter = Modules.adapterFor(__classPrivateFieldGet(this, _ModularAdapter_context, "f").boxAdapters, pointer.box);
+            const added = __classPrivateFieldGet(this, _ModularAdapter_modules, "f").add(adapter);
             // assert(added, `Could not add ${pointer}`)
             // TODO Implement catchupAndSubscribeTransactual that deals with that situation
             if (!added) {
                 return;
             }
-            this.#listeners.proxy.onModuleAdded(adapter);
+            __classPrivateFieldGet(this, _ModularAdapter_listeners, "f").proxy.onModuleAdded(adapter);
         };
-        const removeModule = (pointer) => this.#listeners.proxy.onModuleRemoved(this.#modules.removeByKey(pointer.address.uuid));
+        const removeModule = (pointer) => __classPrivateFieldGet(this, _ModularAdapter_listeners, "f").proxy.onModuleRemoved(__classPrivateFieldGet(this, _ModularAdapter_modules, "f").removeByKey(pointer.address.uuid));
         const addConnection = (pointer) => {
-            const adapter = this.#context.boxAdapters.adapterFor(pointer.box, ModuleConnectionAdapter);
-            const added = this.#connections.add(adapter);
+            const adapter = __classPrivateFieldGet(this, _ModularAdapter_context, "f").boxAdapters.adapterFor(pointer.box, ModuleConnectionAdapter);
+            const added = __classPrivateFieldGet(this, _ModularAdapter_connections, "f").add(adapter);
             // assert(added, `Could not add ${pointer}`)
             // TODO Implement catchupAndSubscribeTransactual that deals with that situation
             if (!added) {
                 return;
             }
-            this.#listeners.proxy.onConnectionAdded(adapter);
+            __classPrivateFieldGet(this, _ModularAdapter_listeners, "f").proxy.onConnectionAdded(adapter);
         };
-        const removeConnection = (pointer) => this.#listeners.proxy.onConnectionRemoved(this.#connections.removeByKey(pointer.address.uuid));
-        this.#box.modules.pointerHub.filter(Pointers.ModuleCollection).forEach(addModule);
-        this.#box.connections.pointerHub.filter(Pointers.ConnectionCollection).forEach(addConnection);
-        this.#terminator.own(this.#box.modules.pointerHub
+        const removeConnection = (pointer) => __classPrivateFieldGet(this, _ModularAdapter_listeners, "f").proxy.onConnectionRemoved(__classPrivateFieldGet(this, _ModularAdapter_connections, "f").removeByKey(pointer.address.uuid));
+        __classPrivateFieldGet(this, _ModularAdapter_box, "f").modules.pointerHub.filter(Pointers.ModuleCollection).forEach(addModule);
+        __classPrivateFieldGet(this, _ModularAdapter_box, "f").connections.pointerHub.filter(Pointers.ConnectionCollection).forEach(addConnection);
+        __classPrivateFieldGet(this, _ModularAdapter_terminator, "f").own(__classPrivateFieldGet(this, _ModularAdapter_box, "f").modules.pointerHub
             .subscribe({ onAdded: addModule, onRemoved: removeModule }, Pointers.ModuleCollection));
-        this.#terminator.own(this.#box.connections.pointerHub
+        __classPrivateFieldGet(this, _ModularAdapter_terminator, "f").own(__classPrivateFieldGet(this, _ModularAdapter_box, "f").connections.pointerHub
             .subscribe({ onAdded: addConnection, onRemoved: removeConnection }, Pointers.ConnectionCollection));
     }
     catchupAndSubscribe(listener) {
-        ifDefined(listener.onModuleAdded, fn => this.#modules.forEach(adapter => fn(adapter)));
-        ifDefined(listener.onConnectionAdded, fn => this.#connections.forEach(adapter => fn(adapter)));
-        return this.#listeners.subscribe(listener);
+        ifDefined(listener.onModuleAdded, fn => __classPrivateFieldGet(this, _ModularAdapter_modules, "f").forEach(adapter => fn(adapter)));
+        ifDefined(listener.onConnectionAdded, fn => __classPrivateFieldGet(this, _ModularAdapter_connections, "f").forEach(adapter => fn(adapter)));
+        return __classPrivateFieldGet(this, _ModularAdapter_listeners, "f").subscribe(listener);
     }
-    get box() { return this.#box; }
-    get address() { return this.#box.address; }
-    get uuid() { return this.#box.address.uuid; }
-    get editingField() { return this.#box.editing; }
-    get labelField() { return this.#box.label; }
-    get modules() { return this.#modules.values(); }
-    get connections() { return this.#connections.values(); }
+    get box() { return __classPrivateFieldGet(this, _ModularAdapter_box, "f"); }
+    get address() { return __classPrivateFieldGet(this, _ModularAdapter_box, "f").address; }
+    get uuid() { return __classPrivateFieldGet(this, _ModularAdapter_box, "f").address.uuid; }
+    get editingField() { return __classPrivateFieldGet(this, _ModularAdapter_box, "f").editing; }
+    get labelField() { return __classPrivateFieldGet(this, _ModularAdapter_box, "f").label; }
+    get modules() { return __classPrivateFieldGet(this, _ModularAdapter_modules, "f").values(); }
+    get connections() { return __classPrivateFieldGet(this, _ModularAdapter_connections, "f").values(); }
     get device() {
-        return this.#context.boxAdapters
-            .adapterFor(asDefined(this.#box.device.pointerHub.incoming().at(0), "No device found").box, ModularDeviceBoxAdapter);
+        return __classPrivateFieldGet(this, _ModularAdapter_context, "f").boxAdapters
+            .adapterFor(asDefined(__classPrivateFieldGet(this, _ModularAdapter_box, "f").device.pointerHub.incoming().at(0), "No device found").box, ModularDeviceBoxAdapter);
     }
     terminate() {
         console.debug(`terminate ${this}`);
-        this.#terminator.terminate();
+        __classPrivateFieldGet(this, _ModularAdapter_terminator, "f").terminate();
     }
 }
+_ModularAdapter_terminator = new WeakMap(), _ModularAdapter_listeners = new WeakMap(), _ModularAdapter_context = new WeakMap(), _ModularAdapter_box = new WeakMap(), _ModularAdapter_modules = new WeakMap(), _ModularAdapter_connections = new WeakMap();

package/dist/modular/modules/audio-input.js

@@ -1,17 +1,30 @@
+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 _ModularAudioInputAdapter_voltageOutput;
 import { Arrays } from "@opendaw/lib-std";
 import { AbstractModuleAdapter } from "../abstract";
 import { Direction, ModuleConnectorAdapter } from "../connector";
 export class ModularAudioInputAdapter extends AbstractModuleAdapter {
-    #voltageOutput;
     constructor(context, box) {
         super(context, box);
-        this.#voltageOutput = ModuleConnectorAdapter.create(context.boxAdapters, box.output, Direction.Output, "Output");
+        _ModularAudioInputAdapter_voltageOutput.set(this, void 0);
+        __classPrivateFieldSet(this, _ModularAudioInputAdapter_voltageOutput, ModuleConnectorAdapter.create(context.boxAdapters, box.output, Direction.Output, "Output"), "f");
     }
-    get voltageOutput() { return this.#voltageOutput; }
+    get voltageOutput() { return __classPrivateFieldGet(this, _ModularAudioInputAdapter_voltageOutput, "f"); }
     get inputs() {
         return Arrays.empty();
     }
     get outputs() {
-        return [this.#voltageOutput];
+        return [__classPrivateFieldGet(this, _ModularAudioInputAdapter_voltageOutput, "f")];
     }
 }
+_ModularAudioInputAdapter_voltageOutput = new WeakMap();

package/dist/modular/modules/audio-output.js

@@ -1,17 +1,30 @@
+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 _ModularAudioOutputAdapter_voltageInput;
 import { Arrays } from "@opendaw/lib-std";
 import { AbstractModuleAdapter } from "../abstract";
 import { Direction, ModuleConnectorAdapter } from "../connector";
 export class ModularAudioOutputAdapter extends AbstractModuleAdapter {
-    #voltageInput;
     constructor(context, box) {
         super(context, box);
-        this.#voltageInput = ModuleConnectorAdapter.create(context.boxAdapters, box.input, Direction.Input, "Input");
+        _ModularAudioOutputAdapter_voltageInput.set(this, void 0);
+        __classPrivateFieldSet(this, _ModularAudioOutputAdapter_voltageInput, ModuleConnectorAdapter.create(context.boxAdapters, box.input, Direction.Input, "Input"), "f");
     }
-    get voltageInput() { return this.#voltageInput; }
+    get voltageInput() { return __classPrivateFieldGet(this, _ModularAudioOutputAdapter_voltageInput, "f"); }
     get inputs() {
-        return [this.#voltageInput];
+        return [__classPrivateFieldGet(this, _ModularAudioOutputAdapter_voltageInput, "f")];
     }
     get outputs() {
         return Arrays.empty();
     }
 }
+_ModularAudioOutputAdapter_voltageInput = new WeakMap();

package/dist/modular/modules/delay.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 _ModuleDelayAdapter_parameterTime, _ModuleDelayAdapter_voltageInput, _ModuleDelayAdapter_voltageOutput;
 import { StringMapping, ValueMapping } from "@opendaw/lib-std";
 import { AbstractModuleAdapter } from "../abstract";
 import { Direction, ModuleConnectorAdapter } from "../connector";
 export class ModuleDelayAdapter extends AbstractModuleAdapter {
-    #parameterTime;
-    #voltageInput;
-    #voltageOutput;
     constructor(context, box) {
         super(context, box);
-        this.#parameterTime = this.parameters.createParameter(box.time, ValueMapping.exponential(1.0, 10000.0), StringMapping.numeric({ unit: "ms" }), "Time");
-        this.#voltageInput = ModuleConnectorAdapter.create(context.boxAdapters, box.voltageInput, Direction.Input, "Input");
-        this.#voltageOutput = ModuleConnectorAdapter.create(context.boxAdapters, box.voltageOutput, Direction.Output, "Output");
+        _ModuleDelayAdapter_parameterTime.set(this, void 0);
+        _ModuleDelayAdapter_voltageInput.set(this, void 0);
+        _ModuleDelayAdapter_voltageOutput.set(this, void 0);
+        __classPrivateFieldSet(this, _ModuleDelayAdapter_parameterTime, this.parameters.createParameter(box.time, ValueMapping.exponential(1.0, 10000.0), StringMapping.numeric({ unit: "ms" }), "Time"), "f");
+        __classPrivateFieldSet(this, _ModuleDelayAdapter_voltageInput, ModuleConnectorAdapter.create(context.boxAdapters, box.voltageInput, Direction.Input, "Input"), "f");
+        __classPrivateFieldSet(this, _ModuleDelayAdapter_voltageOutput, ModuleConnectorAdapter.create(context.boxAdapters, box.voltageOutput, Direction.Output, "Output"), "f");
     }
-    get parameterTime() { return this.#parameterTime; }
-    get voltageInput() { return this.#voltageInput; }
-    get voltageOutput() { return this.#voltageOutput; }
+    get parameterTime() { return __classPrivateFieldGet(this, _ModuleDelayAdapter_parameterTime, "f"); }
+    get voltageInput() { return __classPrivateFieldGet(this, _ModuleDelayAdapter_voltageInput, "f"); }
+    get voltageOutput() { return __classPrivateFieldGet(this, _ModuleDelayAdapter_voltageOutput, "f"); }
     get inputs() {
-        return [this.#voltageInput];
+        return [__classPrivateFieldGet(this, _ModuleDelayAdapter_voltageInput, "f")];
     }
     get outputs() {
-        return [this.#voltageOutput];
+        return [__classPrivateFieldGet(this, _ModuleDelayAdapter_voltageOutput, "f")];
     }
 }
+_ModuleDelayAdapter_parameterTime = new WeakMap(), _ModuleDelayAdapter_voltageInput = new WeakMap(), _ModuleDelayAdapter_voltageOutput = new WeakMap();

package/dist/modular/modules/gain.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 _ModuleGainAdapter_parameterGain, _ModuleGainAdapter_voltageInput, _ModuleGainAdapter_voltageOutput;
 import { StringMapping, ValueMapping } from "@opendaw/lib-std";
 import { AbstractModuleAdapter } from "../abstract";
 import { Direction, ModuleConnectorAdapter } from "../connector";
 export class ModuleGainAdapter extends AbstractModuleAdapter {
-    #parameterGain;
-    #voltageInput;
-    #voltageOutput;
     constructor(context, box) {
         super(context, box);
-        this.#parameterGain = this.parameters.createParameter(box.gain, ValueMapping.DefaultDecibel, StringMapping.numeric({ unit: "db" }), "Gain");
-        this.#voltageInput = ModuleConnectorAdapter.create(context.boxAdapters, box.voltageInput, Direction.Input, "Input");
-        this.#voltageOutput = ModuleConnectorAdapter.create(context.boxAdapters, box.voltageOutput, Direction.Output, "Output");
+        _ModuleGainAdapter_parameterGain.set(this, void 0);
+        _ModuleGainAdapter_voltageInput.set(this, void 0);
+        _ModuleGainAdapter_voltageOutput.set(this, void 0);
+        __classPrivateFieldSet(this, _ModuleGainAdapter_parameterGain, this.parameters.createParameter(box.gain, ValueMapping.DefaultDecibel, StringMapping.numeric({ unit: "db" }), "Gain"), "f");
+        __classPrivateFieldSet(this, _ModuleGainAdapter_voltageInput, ModuleConnectorAdapter.create(context.boxAdapters, box.voltageInput, Direction.Input, "Input"), "f");
+        __classPrivateFieldSet(this, _ModuleGainAdapter_voltageOutput, ModuleConnectorAdapter.create(context.boxAdapters, box.voltageOutput, Direction.Output, "Output"), "f");
     }
-    get parameterGain() { return this.#parameterGain; }
-    get voltageInput() { return this.#voltageInput; }
-    get voltageOutput() { return this.#voltageOutput; }
+    get parameterGain() { return __classPrivateFieldGet(this, _ModuleGainAdapter_parameterGain, "f"); }
+    get voltageInput() { return __classPrivateFieldGet(this, _ModuleGainAdapter_voltageInput, "f"); }
+    get voltageOutput() { return __classPrivateFieldGet(this, _ModuleGainAdapter_voltageOutput, "f"); }
     get inputs() {
-        return [this.#voltageInput];
+        return [__classPrivateFieldGet(this, _ModuleGainAdapter_voltageInput, "f")];
     }
     get outputs() {
-        return [this.#voltageOutput];
+        return [__classPrivateFieldGet(this, _ModuleGainAdapter_voltageOutput, "f")];
     }
 }
+_ModuleGainAdapter_parameterGain = new WeakMap(), _ModuleGainAdapter_voltageInput = new WeakMap(), _ModuleGainAdapter_voltageOutput = new WeakMap();

package/dist/modular/modules/multiplier.js

@@ -1,19 +1,32 @@
+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 _ModuleMultiplierAdapter_voltageInputX, _ModuleMultiplierAdapter_voltageInputY, _ModuleMultiplierAdapter_voltageOutput;
 import { AbstractModuleAdapter } from "../abstract";
 import { Direction, ModuleConnectorAdapter } from "../connector";
 export class ModuleMultiplierAdapter extends AbstractModuleAdapter {
-    #voltageInputX;
-    #voltageInputY;
-    #voltageOutput;
     constructor(context, box) {
         super(context, box);
-        this.#voltageInputX = ModuleConnectorAdapter.create(context.boxAdapters, box.voltageInputX, Direction.Input, "X");
-        this.#voltageInputY = ModuleConnectorAdapter.create(context.boxAdapters, box.voltageInputY, Direction.Input, "Y");
-        this.#voltageOutput = ModuleConnectorAdapter.create(context.boxAdapters, box.voltageOutput, Direction.Output, "Result");
+        _ModuleMultiplierAdapter_voltageInputX.set(this, void 0);
+        _ModuleMultiplierAdapter_voltageInputY.set(this, void 0);
+        _ModuleMultiplierAdapter_voltageOutput.set(this, void 0);
+        __classPrivateFieldSet(this, _ModuleMultiplierAdapter_voltageInputX, ModuleConnectorAdapter.create(context.boxAdapters, box.voltageInputX, Direction.Input, "X"), "f");
+        __classPrivateFieldSet(this, _ModuleMultiplierAdapter_voltageInputY, ModuleConnectorAdapter.create(context.boxAdapters, box.voltageInputY, Direction.Input, "Y"), "f");
+        __classPrivateFieldSet(this, _ModuleMultiplierAdapter_voltageOutput, ModuleConnectorAdapter.create(context.boxAdapters, box.voltageOutput, Direction.Output, "Result"), "f");
     }
     get inputs() {
-        return [this.#voltageInputX, this.#voltageInputY];
+        return [__classPrivateFieldGet(this, _ModuleMultiplierAdapter_voltageInputX, "f"), __classPrivateFieldGet(this, _ModuleMultiplierAdapter_voltageInputY, "f")];
     }
     get outputs() {
-        return [this.#voltageOutput];
+        return [__classPrivateFieldGet(this, _ModuleMultiplierAdapter_voltageOutput, "f")];
     }
 }
+_ModuleMultiplierAdapter_voltageInputX = new WeakMap(), _ModuleMultiplierAdapter_voltageInputY = new WeakMap(), _ModuleMultiplierAdapter_voltageOutput = new WeakMap();

package/dist/modular/user-interface.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 _DeviceInterfaceKnobAdapter_instances, _DeviceInterfaceKnobAdapter_context, _DeviceInterfaceKnobAdapter_box, _DeviceInterfaceKnobAdapter_parameterTarget_get;
 import { Modules } from "./module";
 export class DeviceInterfaceKnobAdapter {
-    #context;
-    #box;
     constructor(context, box) {
-        this.#context = context;
-        this.#box = box;
+        _DeviceInterfaceKnobAdapter_instances.add(this);
+        _DeviceInterfaceKnobAdapter_context.set(this, void 0);
+        _DeviceInterfaceKnobAdapter_box.set(this, void 0);
+        __classPrivateFieldSet(this, _DeviceInterfaceKnobAdapter_context, context, "f");
+        __classPrivateFieldSet(this, _DeviceInterfaceKnobAdapter_box, box, "f");
     }
-    get box() { return this.#box; }
-    get uuid() { return this.#box.address.uuid; }
-    get address() { return this.#box.address; }
+    get box() { return __classPrivateFieldGet(this, _DeviceInterfaceKnobAdapter_box, "f"); }
+    get uuid() { return __classPrivateFieldGet(this, _DeviceInterfaceKnobAdapter_box, "f").address.uuid; }
+    get address() { return __classPrivateFieldGet(this, _DeviceInterfaceKnobAdapter_box, "f").address; }
     get moduleAdapter() {
-        return Modules.adapterFor(this.#context.boxAdapters, this.#parameterTarget.box);
+        return Modules.adapterFor(__classPrivateFieldGet(this, _DeviceInterfaceKnobAdapter_context, "f").boxAdapters, __classPrivateFieldGet(this, _DeviceInterfaceKnobAdapter_instances, "a", _DeviceInterfaceKnobAdapter_parameterTarget_get).box);
     }
     get parameterAdapter() {
-        return this.moduleAdapter.parameters.parameterAt(this.#parameterTarget.address);
-    }
-    get #parameterTarget() {
-        return this.#box.parameter.targetVertex.unwrap("Parameter not assigned");
+        return this.moduleAdapter.parameters.parameterAt(__classPrivateFieldGet(this, _DeviceInterfaceKnobAdapter_instances, "a", _DeviceInterfaceKnobAdapter_parameterTarget_get).address);
     }
     terminate() {
     }
 }
+_DeviceInterfaceKnobAdapter_context = new WeakMap(), _DeviceInterfaceKnobAdapter_box = new WeakMap(), _DeviceInterfaceKnobAdapter_instances = new WeakSet(), _DeviceInterfaceKnobAdapter_parameterTarget_get = function _DeviceInterfaceKnobAdapter_parameterTarget_get() {
+    return __classPrivateFieldGet(this, _DeviceInterfaceKnobAdapter_box, "f").parameter.targetVertex.unwrap("Parameter not assigned");
+};

package/dist/preset/PresetDecoder.d.ts

@@ -0,0 +1,11 @@
+import { Attempt } from "@opendaw/lib-std";
+import { AudioUnitBox } from "@opendaw/studio-boxes";
+import { ProjectSkeleton } from "../project/ProjectSkeleton";
+export declare namespace PresetDecoder {
+    const decode: (bytes: ArrayBufferLike, target: ProjectSkeleton) => void;
+    const replaceAudioUnit: (arrayBuffer: ArrayBuffer, targetAudioUnitBox: AudioUnitBox, options?: {
+        keepMIDIEffects?: boolean;
+        keepAudioEffects?: boolean;
+    }) => Attempt<void, string>;
+}
+//# sourceMappingURL=PresetDecoder.d.ts.map

package/dist/preset/PresetDecoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PresetDecoder.d.ts","sourceRoot":"","sources":["../../src/preset/PresetDecoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,OAAO,EAQV,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAEH,YAAY,EAOf,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAC,eAAe,EAAC,MAAM,4BAA4B,CAAA;AAK1D,yBAAiB,aAAa,CAAC;IACpB,MAAM,MAAM,GAAI,OAAO,eAAe,EAAE,QAAQ,eAAe,SAqDrE,CAAA;IAEM,MAAM,gBAAgB,GAAI,aAAa,WAAW,EAAE,oBAAoB,YAAY,EAAE,UAAU;QACnG,eAAe,CAAC,EAAE,OAAO,CAAA;QACzB,gBAAgB,CAAC,EAAE,OAAO,CAAA;KAC7B,KAAG,OAAO,CAAC,IAAI,EAAE,MAAM,CAgGvB,CAAA;CACJ"}

package/dist/preset/PresetDecoder.js

@@ -0,0 +1,154 @@
+import { asDefined, asInstanceOf, Attempts, ByteArrayInput, isDefined, isInstanceOf, Option, RuntimeNotifier, UUID } from "@opendaw/lib-std";
+import { BoxGraph, PointerField } from "@opendaw/lib-box";
+import { AudioUnitType } from "@opendaw/studio-enums";
+import { AudioFileBox, AudioUnitBox, BoxIO, CaptureAudioBox, CaptureMidiBox, SoundfontFileBox, TrackBox } from "@opendaw/studio-boxes";
+import { ProjectSkeleton } from "../project/ProjectSkeleton";
+import { ProjectUtils } from "../project/ProjectUtils";
+import { TrackType } from "../timeline/TrackType";
+import { PresetHeader } from "./PresetHeader";
+export var PresetDecoder;
+(function (PresetDecoder) {
+    PresetDecoder.decode = (bytes, target) => {
+        const header = new ByteArrayInput(bytes.slice(0, 8));
+        if (header.readInt() !== PresetHeader.MAGIC_HEADER_OPEN) {
+            RuntimeNotifier.info({
+                headline: "Could Not Import Preset",
+                message: "Invalid preset file"
+            }).then();
+            return;
+        }
+        if (header.readInt() !== PresetHeader.FORMAT_VERSION) {
+            RuntimeNotifier.info({
+                headline: "Could Not Import Preset",
+                message: "Invalid preset version"
+            }).then();
+            return;
+        }
+        const sourceBoxGraph = new BoxGraph(Option.wrap(BoxIO.create));
+        try {
+            sourceBoxGraph.fromArrayBuffer(bytes.slice(8));
+        }
+        catch (reason) {
+            RuntimeNotifier.info({
+                headline: "Could Not Import Preset",
+                message: String(reason)
+            }).then();
+            return;
+        }
+        const sourceAudioUnitBoxes = sourceBoxGraph.boxes()
+            .filter(box => isInstanceOf(box, AudioUnitBox))
+            .filter(box => box.type.getValue() !== AudioUnitType.Output);
+        ProjectUtils.extractAudioUnits(sourceAudioUnitBoxes, target, { excludeTimeline: true })
+            .filter(box => box.type.getValue() !== AudioUnitType.Output)
+            .forEach((audioUnitBox) => {
+            const inputBox = audioUnitBox.input.pointerHub.incoming().at(0)?.box;
+            if (isDefined(inputBox)) {
+                audioUnitBox.capture.targetVertex.ifSome(({ box: captureBox }) => {
+                    if (captureBox instanceof CaptureMidiBox) {
+                        TrackBox.create(target.boxGraph, UUID.generate(), box => {
+                            box.index.setValue(0);
+                            box.type.setValue(TrackType.Notes);
+                            box.target.refer(audioUnitBox);
+                            box.tracks.refer(audioUnitBox.tracks);
+                        });
+                    }
+                    else if (captureBox instanceof CaptureAudioBox) {
+                        TrackBox.create(target.boxGraph, UUID.generate(), box => {
+                            box.index.setValue(0);
+                            box.type.setValue(TrackType.Audio);
+                            box.target.refer(audioUnitBox);
+                            box.tracks.refer(audioUnitBox.tracks);
+                        });
+                    }
+                });
+            }
+        });
+    };
+    PresetDecoder.replaceAudioUnit = (arrayBuffer, targetAudioUnitBox, options) => {
+        console.debug("ReplaceAudioUnit with preset...");
+        const skeleton = ProjectSkeleton.empty({
+            createDefaultUser: false,
+            createOutputCompressor: false
+        });
+        const sourceBoxGraph = skeleton.boxGraph;
+        const targetBoxGraph = targetAudioUnitBox.graph;
+        sourceBoxGraph.beginTransaction();
+        PresetDecoder.decode(arrayBuffer, skeleton);
+        sourceBoxGraph.endTransaction();
+        const sourceAudioUnitBox = asDefined(skeleton.mandatoryBoxes.rootBox.audioUnits.pointerHub.incoming()
+            .map(({ box }) => asInstanceOf(box, AudioUnitBox))
+            .find((box) => box.type.getValue() !== AudioUnitType.Output), "Source has no audioUnitBox");
+        const sourceCaptureBox = sourceAudioUnitBox.capture.targetVertex.mapOr(({ box }) => box.name, "");
+        const targetCaptureBox = targetAudioUnitBox.capture.targetVertex.mapOr(({ box }) => box.name, "");
+        if (sourceCaptureBox !== targetCaptureBox) {
+            return Attempts.err("Cannot replace incompatible instruments");
+        }
+        const replaceMIDIEffects = options?.keepMIDIEffects !== true;
+        const replaceAudioEffects = options?.keepAudioEffects !== true;
+        console.debug("replaceMIDIEffects", replaceMIDIEffects);
+        console.debug("replaceAudioEffects", replaceAudioEffects);
+        asDefined(targetAudioUnitBox.input.pointerHub.incoming().at(0)?.box, "Target has no input").delete();
+        if (replaceMIDIEffects) {
+            targetAudioUnitBox.midiEffects.pointerHub.incoming().forEach(({ box }) => box.delete());
+        }
+        else {
+            sourceBoxGraph.beginTransaction();
+            sourceAudioUnitBox.midiEffects.pointerHub.incoming().forEach(({ box }) => box.delete());
+            sourceBoxGraph.endTransaction();
+        }
+        if (replaceAudioEffects) {
+            targetAudioUnitBox.audioEffects.pointerHub.incoming().forEach(({ box }) => box.delete());
+        }
+        else {
+            sourceBoxGraph.beginTransaction();
+            sourceAudioUnitBox.audioEffects.pointerHub.incoming().forEach(({ box }) => box.delete());
+            sourceBoxGraph.endTransaction();
+        }
+        // We do not take track or capture boxes into account
+        const excludeBox = (box) => box.accept({
+            visitTrackBox: (_box) => true,
+            visitCaptureMidiBox: (_box) => true,
+            visitCaptureAudioBox: (_box) => true
+        }) === true;
+        const uuidMap = UUID.newSet(({ source }) => source);
+        const dependencies = Array.from(sourceBoxGraph.dependenciesOf(sourceAudioUnitBox, {
+            excludeBox,
+            alwaysFollowMandatory: false
+        }).boxes);
+        uuidMap.addMany([
+            {
+                source: sourceAudioUnitBox.address.uuid,
+                target: targetAudioUnitBox.address.uuid
+            },
+            ...dependencies
+                .map(({ address: { uuid }, name }) => ({
+                source: uuid,
+                target: name === AudioFileBox.ClassName || name === SoundfontFileBox.ClassName
+                    ? uuid
+                    : UUID.generate()
+            }))
+        ]);
+        PointerField.decodeWith({
+            map: (_pointer, newAddress) => newAddress.map(address => uuidMap.opt(address.uuid).match({
+                none: () => address,
+                some: ({ target }) => address.moveTo(target)
+            }))
+        }, () => {
+            dependencies
+                .forEach((source) => {
+                const input = new ByteArrayInput(source.toArrayBuffer());
+                const key = source.name;
+                const uuid = uuidMap.get(source.address.uuid).target;
+                if (source instanceof AudioFileBox || source instanceof SoundfontFileBox) {
+                    // Those boxes keep their UUID. So if they are already in the graph, we can just read them.
+                    if (targetBoxGraph.findBox(source.address.uuid).nonEmpty()) {
+                        source.read(input);
+                        return;
+                    }
+                }
+                targetBoxGraph.createBox(key, uuid, box => box.read(input));
+            });
+        });
+        return Attempts.Ok;
+    };
+})(PresetDecoder || (PresetDecoder = {}));