@opendaw/studio-core 0.0.8 → 0.0.10

package/dist/ColorCodes.d.ts

@@ -0,0 +1,7 @@
+import { AudioUnitType } from "@opendaw/studio-enums";
+import { TrackType } from "@opendaw/studio-adapters";
+export declare namespace ColorCodes {
+    const forAudioType: (type?: AudioUnitType) => string;
+    const forTrackType: (type?: TrackType) => number;
+}
+//# sourceMappingURL=ColorCodes.d.ts.map

package/dist/ColorCodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColorCodes.d.ts","sourceRoot":"","sources":["../src/ColorCodes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,aAAa,EAAC,MAAM,uBAAuB,CAAA;AACnD,OAAO,EAAC,SAAS,EAAC,MAAM,0BAA0B,CAAA;AAGlD,yBAAiB,UAAU,CAAC;IACjB,MAAM,YAAY,GAAI,OAAO,aAAa,KAAG,MAanD,CAAA;IAEM,MAAM,YAAY,GAAI,OAAO,SAAS,KAAG,MAW/C,CAAA;CACJ"}

package/dist/ColorCodes.js

@@ -0,0 +1,32 @@
+import { AudioUnitType } from "@opendaw/studio-enums";
+import { TrackType } from "@opendaw/studio-adapters";
+import { Colors } from "./Colors";
+export var ColorCodes;
+(function (ColorCodes) {
+    ColorCodes.forAudioType = (type) => {
+        switch (type) {
+            case AudioUnitType.Output:
+                return Colors.blue;
+            case AudioUnitType.Aux:
+                return Colors.purple;
+            case AudioUnitType.Bus:
+                return Colors.orange;
+            case AudioUnitType.Instrument:
+                return Colors.green;
+            default:
+                return Colors.dark;
+        }
+    };
+    ColorCodes.forTrackType = (type) => {
+        switch (type) {
+            case TrackType.Audio:
+                return 200;
+            case TrackType.Notes:
+                return 45;
+            case TrackType.Value:
+                return 156;
+            default:
+                return 0;
+        }
+    };
+})(ColorCodes || (ColorCodes = {}));

package/dist/Colors.d.ts

@@ -0,0 +1,15 @@
+export declare const Colors: {
+    blue: string;
+    green: string;
+    yellow: string;
+    cream: string;
+    orange: string;
+    red: string;
+    purple: string;
+    bright: string;
+    gray: string;
+    dark: string;
+    shadow: string;
+    black: string;
+};
+//# sourceMappingURL=Colors.d.ts.map

package/dist/Colors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Colors.d.ts","sourceRoot":"","sources":["../src/Colors.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,MAAM;;;;;;;;;;;;;CAalB,CAAA"}

package/dist/Colors.js

@@ -0,0 +1,15 @@
+const computedStyle = getComputedStyle(document.documentElement);
+export const Colors = {
+    blue: computedStyle.getPropertyValue("--color-blue"),
+    green: computedStyle.getPropertyValue("--color-green"),
+    yellow: computedStyle.getPropertyValue("--color-yellow"),
+    cream: computedStyle.getPropertyValue("--color-cream"),
+    orange: computedStyle.getPropertyValue("--color-orange"),
+    red: computedStyle.getPropertyValue("--color-red"),
+    purple: computedStyle.getPropertyValue("--color-purple"),
+    bright: computedStyle.getPropertyValue("--color-bright"),
+    gray: computedStyle.getPropertyValue("--color-gray"),
+    dark: computedStyle.getPropertyValue("--color-dark"),
+    shadow: computedStyle.getPropertyValue("--color-shadow"),
+    black: computedStyle.getPropertyValue("--color-black")
+};

package/dist/Effects.d.ts

@@ -0,0 +1,154 @@
+import { int } from "@opendaw/lib-std";
+import { Box, Field } from "@opendaw/lib-box";
+import { ArpeggioDeviceBox, DelayDeviceBox, ModularDeviceBox, PitchDeviceBox, RevampDeviceBox, ReverbDeviceBox, StereoToolDeviceBox, ZeitgeistDeviceBox } from "@opendaw/studio-boxes";
+import { EffectPointerType, IconSymbol } from "@opendaw/studio-adapters";
+import { Project } from "./Project";
+export declare namespace Effects {
+    interface Entry {
+        get name(): string;
+        get description(): string;
+        get icon(): IconSymbol;
+        get separatorBefore(): boolean;
+        get type(): "audio" | "midi";
+        create(project: Project, unit: Field<EffectPointerType>, index: int): Box;
+    }
+    const MidiNamed: {
+        arpeggio: {
+            name: string;
+            description: string;
+            icon: IconSymbol.Stack;
+            separatorBefore: false;
+            type: "midi";
+            create: ({ boxGraph }: Project, unit: Field<EffectPointerType, import("@opendaw/lib-box").Fields>, index: number) => ArpeggioDeviceBox;
+        };
+        pitch: {
+            name: string;
+            description: string;
+            icon: IconSymbol.Note;
+            separatorBefore: false;
+            type: "midi";
+            create: ({ boxGraph }: Project, unit: Field<EffectPointerType, import("@opendaw/lib-box").Fields>, index: number) => PitchDeviceBox;
+        };
+        Zeitgeist: {
+            name: string;
+            description: string;
+            icon: IconSymbol.Zeitgeist;
+            separatorBefore: false;
+            type: "midi";
+            create: ({ boxGraph, rootBoxAdapter }: Project, unit: Field<EffectPointerType, import("@opendaw/lib-box").Fields>, index: number) => ZeitgeistDeviceBox;
+        };
+    };
+    const AudioNamed: {
+        StereoTool: {
+            name: string;
+            description: string;
+            icon: IconSymbol.Stereo;
+            separatorBefore: false;
+            type: "audio";
+            create: ({ boxGraph }: Project, unit: Field<EffectPointerType, import("@opendaw/lib-box").Fields>, index: number) => StereoToolDeviceBox;
+        };
+        Delay: {
+            name: string;
+            description: string;
+            icon: IconSymbol.Time;
+            separatorBefore: false;
+            type: "audio";
+            create: ({ boxGraph }: Project, unit: Field<EffectPointerType, import("@opendaw/lib-box").Fields>, index: number) => DelayDeviceBox;
+        };
+        Reverb: {
+            name: string;
+            description: string;
+            icon: IconSymbol.Cube;
+            separatorBefore: false;
+            type: "audio";
+            create: ({ boxGraph }: Project, unit: Field<EffectPointerType, import("@opendaw/lib-box").Fields>, index: number) => ReverbDeviceBox;
+        };
+        Revamp: {
+            name: string;
+            description: string;
+            icon: IconSymbol.EQ;
+            separatorBefore: false;
+            type: "audio";
+            create: ({ boxGraph }: Project, unit: Field<EffectPointerType, import("@opendaw/lib-box").Fields>, index: number) => RevampDeviceBox;
+        };
+        Modular: {
+            name: string;
+            description: string;
+            icon: IconSymbol.Box;
+            separatorBefore: true;
+            type: "audio";
+            create: (project: Project, unit: Field<EffectPointerType, import("@opendaw/lib-box").Fields>, index: number) => ModularDeviceBox;
+        };
+    };
+    const MidiList: ReadonlyArray<Readonly<Entry>>;
+    const AudioList: ReadonlyArray<Readonly<Entry>>;
+    const MergedNamed: {
+        StereoTool: {
+            name: string;
+            description: string;
+            icon: IconSymbol.Stereo;
+            separatorBefore: false;
+            type: "audio";
+            create: ({ boxGraph }: Project, unit: Field<EffectPointerType, import("@opendaw/lib-box").Fields>, index: number) => StereoToolDeviceBox;
+        };
+        Delay: {
+            name: string;
+            description: string;
+            icon: IconSymbol.Time;
+            separatorBefore: false;
+            type: "audio";
+            create: ({ boxGraph }: Project, unit: Field<EffectPointerType, import("@opendaw/lib-box").Fields>, index: number) => DelayDeviceBox;
+        };
+        Reverb: {
+            name: string;
+            description: string;
+            icon: IconSymbol.Cube;
+            separatorBefore: false;
+            type: "audio";
+            create: ({ boxGraph }: Project, unit: Field<EffectPointerType, import("@opendaw/lib-box").Fields>, index: number) => ReverbDeviceBox;
+        };
+        Revamp: {
+            name: string;
+            description: string;
+            icon: IconSymbol.EQ;
+            separatorBefore: false;
+            type: "audio";
+            create: ({ boxGraph }: Project, unit: Field<EffectPointerType, import("@opendaw/lib-box").Fields>, index: number) => RevampDeviceBox;
+        };
+        Modular: {
+            name: string;
+            description: string;
+            icon: IconSymbol.Box;
+            separatorBefore: true;
+            type: "audio";
+            create: (project: Project, unit: Field<EffectPointerType, import("@opendaw/lib-box").Fields>, index: number) => ModularDeviceBox;
+        };
+        arpeggio: {
+            name: string;
+            description: string;
+            icon: IconSymbol.Stack;
+            separatorBefore: false;
+            type: "midi";
+            create: ({ boxGraph }: Project, unit: Field<EffectPointerType, import("@opendaw/lib-box").Fields>, index: number) => ArpeggioDeviceBox;
+        };
+        pitch: {
+            name: string;
+            description: string;
+            icon: IconSymbol.Note;
+            separatorBefore: false;
+            type: "midi";
+            create: ({ boxGraph }: Project, unit: Field<EffectPointerType, import("@opendaw/lib-box").Fields>, index: number) => PitchDeviceBox;
+        };
+        Zeitgeist: {
+            name: string;
+            description: string;
+            icon: IconSymbol.Zeitgeist;
+            separatorBefore: false;
+            type: "midi";
+            create: ({ boxGraph, rootBoxAdapter }: Project, unit: Field<EffectPointerType, import("@opendaw/lib-box").Fields>, index: number) => ZeitgeistDeviceBox;
+        };
+    };
+    type MidiEffectKeys = keyof typeof MidiNamed;
+    type AudioEffectKeys = keyof typeof AudioNamed;
+}
+//# sourceMappingURL=Effects.d.ts.map

package/dist/Effects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Effects.d.ts","sourceRoot":"","sources":["../src/Effects.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,EAAuB,MAAM,kBAAkB,CAAA;AAC1D,OAAO,EAAC,GAAG,EAAE,KAAK,EAAC,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EACH,iBAAiB,EACjB,cAAc,EAKd,gBAAgB,EAEhB,cAAc,EACd,eAAe,EACf,eAAe,EACf,mBAAmB,EACnB,kBAAkB,EACrB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAC,iBAAiB,EAAE,UAAU,EAAC,MAAM,0BAA0B,CAAA;AACtE,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAEjC,yBAAiB,OAAO,CAAC;IACrB,UAAiB,KAAK;QAClB,IAAI,IAAI,IAAI,MAAM,CAAA;QAClB,IAAI,WAAW,IAAI,MAAM,CAAA;QACzB,IAAI,IAAI,IAAI,UAAU,CAAA;QACtB,IAAI,eAAe,IAAI,OAAO,CAAA;QAC9B,IAAI,IAAI,IAAI,OAAO,GAAG,MAAM,CAAA;QAE5B,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,iBAAiB,CAAC,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG,CAAA;KAC5E;IAEM,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;KA+CrB,CAAA;IAEM,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA4GtB,CAAA;IAEM,MAAM,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,CAA4B,CAAA;IACzE,MAAM,SAAS,EAAE,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,CAA6B,CAAA;IAC3E,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAgC,CAAA;IAExD,KAAY,cAAc,GAAG,MAAM,OAAO,SAAS,CAAA;IACnD,KAAY,eAAe,GAAG,MAAM,OAAO,UAAU,CAAA;CACxD"}

package/dist/Effects.js

@@ -0,0 +1,166 @@
+import { INVERSE_SQRT_2, UUID } from "@opendaw/lib-std";
+import { ArpeggioDeviceBox, DelayDeviceBox, GrooveShuffleBox, ModularAudioInputBox, ModularAudioOutputBox, ModularBox, ModularDeviceBox, ModuleConnectionBox, PitchDeviceBox, RevampDeviceBox, ReverbDeviceBox, StereoToolDeviceBox, ZeitgeistDeviceBox } from "@opendaw/studio-boxes";
+import { IconSymbol } from "@opendaw/studio-adapters";
+export var Effects;
+(function (Effects) {
+    Effects.MidiNamed = {
+        arpeggio: {
+            name: "Arpeggio",
+            description: "Generates rhythmic note sequences from chords",
+            icon: IconSymbol.Stack,
+            separatorBefore: false,
+            type: "midi",
+            create: ({ boxGraph }, unit, index) => ArpeggioDeviceBox.create(boxGraph, UUID.generate(), box => {
+                box.label.setValue("Arpeggio");
+                box.index.setValue(index);
+                box.host.refer(unit);
+            })
+        },
+        pitch: {
+            name: "Pitch",
+            description: "Shifts the pitch of incoming notes",
+            icon: IconSymbol.Note,
+            separatorBefore: false,
+            type: "midi",
+            create: ({ boxGraph }, unit, index) => PitchDeviceBox.create(boxGraph, UUID.generate(), box => {
+                box.label.setValue("Pitch");
+                box.index.setValue(index);
+                box.host.refer(unit);
+            })
+        },
+        Zeitgeist: {
+            name: "Zeitgeist",
+            description: "Distorts space and time",
+            icon: IconSymbol.Zeitgeist,
+            separatorBefore: false,
+            type: "midi",
+            create: ({ boxGraph, rootBoxAdapter }, unit, index) => {
+                const useGlobal = false; // TODO First Zeitgeist should be true
+                const shuffleBox = useGlobal
+                    ? rootBoxAdapter.groove.box
+                    : GrooveShuffleBox.create(boxGraph, UUID.generate(), box => {
+                        box.label.setValue("Shuffle");
+                        box.duration.setValue(480);
+                    });
+                return ZeitgeistDeviceBox.create(boxGraph, UUID.generate(), box => {
+                    box.label.setValue("Zeitgeist");
+                    box.groove.refer(shuffleBox);
+                    box.index.setValue(index);
+                    box.host.refer(unit);
+                });
+            }
+        }
+    };
+    Effects.AudioNamed = {
+        StereoTool: {
+            name: "Stereo Tool",
+            description: "Computes a stereo transformation matrix with volume, panning, phase inversion and stereo width.",
+            icon: IconSymbol.Stereo,
+            separatorBefore: false,
+            type: "audio",
+            create: ({ boxGraph }, unit, index) => StereoToolDeviceBox.create(boxGraph, UUID.generate(), box => {
+                box.label.setValue("Stereo Tool");
+                box.index.setValue(index);
+                box.host.refer(unit);
+            })
+        },
+        Delay: {
+            name: "Delay",
+            description: "Echoes the input signal with time-based repeats",
+            icon: IconSymbol.Time,
+            separatorBefore: false,
+            type: "audio",
+            create: ({ boxGraph }, unit, index) => DelayDeviceBox.create(boxGraph, UUID.generate(), box => {
+                box.label.setValue("Delay");
+                box.index.setValue(index);
+                box.host.refer(unit);
+            })
+        },
+        Reverb: {
+            name: "Reverb",
+            description: "Simulates space and depth with reflections",
+            icon: IconSymbol.Cube,
+            separatorBefore: false,
+            type: "audio",
+            create: ({ boxGraph }, unit, index) => ReverbDeviceBox.create(boxGraph, UUID.generate(), box => {
+                box.label.setValue("Reverb");
+                box.preDelay.setInitValue(0.001);
+                box.index.setValue(index);
+                box.host.refer(unit);
+            })
+        },
+        Revamp: {
+            name: "Revamp",
+            description: "Shapes the frequency balance of the sound",
+            icon: IconSymbol.EQ,
+            separatorBefore: false,
+            type: "audio",
+            create: ({ boxGraph }, unit, index) => RevampDeviceBox.create(boxGraph, UUID.generate(), box => {
+                box.label.setValue("Revamp");
+                box.highPass.frequency.setInitValue(40.0);
+                box.highPass.order.setInitValue(2);
+                box.highPass.q.setInitValue(INVERSE_SQRT_2);
+                box.highPass.enabled.setInitValue(true);
+                box.lowShelf.frequency.setInitValue(80.0);
+                box.lowShelf.gain.setInitValue(6);
+                box.lowBell.frequency.setInitValue(120.0);
+                box.lowBell.gain.setInitValue(6);
+                box.lowBell.q.setInitValue(INVERSE_SQRT_2);
+                box.midBell.frequency.setInitValue(640.0);
+                box.midBell.q.setInitValue(INVERSE_SQRT_2);
+                box.midBell.gain.setInitValue(6);
+                box.highBell.frequency.setInitValue(3600.0);
+                box.highBell.q.setInitValue(INVERSE_SQRT_2);
+                box.highBell.gain.setInitValue(6);
+                box.highShelf.frequency.setInitValue(10000.0);
+                box.highShelf.gain.setInitValue(6);
+                box.lowPass.frequency.setInitValue(15000.0);
+                box.lowPass.order.setInitValue(2);
+                box.lowPass.q.setInitValue(INVERSE_SQRT_2);
+                box.index.setValue(index);
+                box.host.refer(unit);
+            })
+        },
+        Modular: {
+            name: "🔇 Create New Modular Audio Effect (inaudible yet)",
+            description: "",
+            icon: IconSymbol.Box,
+            separatorBefore: true,
+            type: "audio",
+            create: (project, unit, index) => {
+                const graph = project.boxGraph;
+                const moduleSetupBox = ModularBox.create(graph, UUID.generate(), box => {
+                    box.collection.refer(project.rootBox.modularSetups);
+                    box.label.setValue("Modular");
+                });
+                const modularInput = ModularAudioInputBox.create(graph, UUID.generate(), box => {
+                    box.attributes.collection.refer(moduleSetupBox.modules);
+                    box.attributes.label.setValue("Modular Input");
+                    box.attributes.x.setValue(-256);
+                    box.attributes.y.setValue(32);
+                });
+                const modularOutput = ModularAudioOutputBox.create(graph, UUID.generate(), box => {
+                    box.attributes.collection.refer(moduleSetupBox.modules);
+                    box.attributes.label.setValue("Modular Output");
+                    box.attributes.x.setValue(256);
+                    box.attributes.y.setValue(32);
+                });
+                ModuleConnectionBox.create(graph, UUID.generate(), box => {
+                    box.collection.refer(moduleSetupBox.connections);
+                    box.source.refer(modularInput.output);
+                    box.target.refer(modularOutput.input);
+                });
+                project.userEditingManager.modularSystem.edit(moduleSetupBox.editing);
+                return ModularDeviceBox.create(graph, UUID.generate(), box => {
+                    box.label.setValue("Modular");
+                    box.modularSetup.refer(moduleSetupBox.device);
+                    box.index.setValue(index);
+                    box.host.refer(unit);
+                });
+            }
+        }
+    };
+    Effects.MidiList = Object.values(Effects.MidiNamed);
+    Effects.AudioList = Object.values(Effects.AudioNamed);
+    Effects.MergedNamed = { ...Effects.MidiNamed, ...Effects.AudioNamed };
+})(Effects || (Effects = {}));

package/dist/Instruments.d.ts

@@ -0,0 +1,35 @@
+import { NanoDeviceBox, PlayfieldDeviceBox, TapeDeviceBox, TrackBox, VaporisateurDeviceBox } from "@opendaw/studio-boxes";
+import { BoxGraph } from "@opendaw/lib-box";
+import { DeviceHost, IconSymbol } from "@opendaw/studio-adapters";
+import { Project } from "./Project";
+export declare namespace Instruments {
+    interface Factory {
+        defaultName: string;
+        icon: IconSymbol;
+        description: string;
+        createDevice: (boxGraph: BoxGraph, deviceHost: DeviceHost, name: string, icon: IconSymbol) => DeviceBox;
+        createTrack: (boxGraph: BoxGraph, deviceHost: DeviceHost) => TrackBox;
+    }
+    type CreationOptions = {
+        name?: string;
+        icon?: IconSymbol;
+    };
+    type DeviceBox = TapeDeviceBox | VaporisateurDeviceBox | NanoDeviceBox | PlayfieldDeviceBox;
+    type FactoryResult = {
+        device: DeviceBox;
+        track: TrackBox;
+    };
+    const Tape: Factory;
+    const Nano: Factory;
+    const Playfield: Factory;
+    const Vaporisateur: Factory;
+    const create: (project: Project, factory: Factory, { name, icon }?: CreationOptions) => FactoryResult;
+    const Named: {
+        Vaporisateur: Factory;
+        Playfield: Factory;
+        Nano: Factory;
+        Tape: Factory;
+    };
+    type Keys = keyof typeof Named;
+}
+//# sourceMappingURL=Instruments.d.ts.map

package/dist/Instruments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Instruments.d.ts","sourceRoot":"","sources":["../src/Instruments.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,aAAa,EACb,kBAAkB,EAElB,aAAa,EACb,QAAQ,EACR,qBAAqB,EACxB,MAAM,uBAAuB,CAAA;AAG9B,OAAO,EAAC,QAAQ,EAAC,MAAM,kBAAkB,CAAA;AAEzC,OAAO,EAAsB,UAAU,EAAE,UAAU,EAAY,MAAM,0BAA0B,CAAA;AAE/F,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAEjC,yBAAiB,WAAW,CAAC;IACzB,UAAiB,OAAO;QACpB,WAAW,EAAE,MAAM,CAAA;QACnB,IAAI,EAAE,UAAU,CAAA;QAChB,WAAW,EAAE,MAAM,CAAA;QACnB,YAAY,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,KAAK,SAAS,CAAA;QACvG,WAAW,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,KAAK,QAAQ,CAAA;KACxE;IAED,KAAY,eAAe,GAAG;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,UAAU,CAAA;KAAE,CAAA;IAElE,KAAY,SAAS,GAAG,aAAa,GAAG,qBAAqB,GAAG,aAAa,GAAG,kBAAkB,CAAA;IAElG,KAAY,aAAa,GAAG;QACxB,MAAM,EAAE,SAAS,CAAA;QACjB,KAAK,EAAE,QAAQ,CAAA;KAClB,CAAA;IAOM,MAAM,IAAI,EAAE,OAqBlB,CAAA;IAEM,MAAM,IAAI,EAAE,OAwBlB,CAAA;IAEM,MAAM,SAAS,EAAE,OAuCvB,CAAA;IAEM,MAAM,YAAY,EAAE,OAuB1B,CAAA;IAEM,MAAM,MAAM,GAAI,SAAS,OAAO,EAChB,SAAS,OAAO,EAAE,iBAAc,eAAoB,KAAG,aAe7E,CAAA;IAEM,MAAM,KAAK;;;;;KAAwC,CAAA;IAC1D,KAAY,IAAI,GAAG,MAAM,OAAO,KAAK,CAAA;CACxC"}

package/dist/Instruments.js

@@ -0,0 +1,135 @@
+import { AudioFileBox, NanoDeviceBox, PlayfieldDeviceBox, PlayfieldSampleBox, TapeDeviceBox, TrackBox, VaporisateurDeviceBox } from "@opendaw/studio-boxes";
+import { Strings, UUID } from "@opendaw/lib-std";
+import { Waveform } from "@opendaw/lib-dsp";
+import { AudioUnitType } from "@opendaw/studio-enums";
+import { AudioUnitBoxAdapter, IconSymbol, TrackType } from "@opendaw/studio-adapters";
+import { Modifier } from "./Modifier";
+export var Instruments;
+(function (Instruments) {
+    const useFile = (boxGraph, fileUUID, name) => boxGraph.findBox(fileUUID)
+        .unwrapOrElse(() => AudioFileBox.create(boxGraph, fileUUID, box => {
+        box.fileName.setValue(name);
+    }));
+    Instruments.Tape = {
+        defaultName: "Tape",
+        icon: IconSymbol.Tape,
+        description: "Plays audio regions & clips",
+        createDevice: (boxGraph, deviceHost, name, icon) => TapeDeviceBox.create(boxGraph, UUID.generate(), box => {
+            box.label.setValue(name);
+            box.icon.setValue(IconSymbol.toName(icon));
+            box.flutter.setValue(0.2);
+            box.wow.setValue(0.05);
+            box.noise.setValue(0.02);
+            box.saturation.setValue(0.5);
+            box.host.refer(deviceHost.inputField);
+        }),
+        createTrack: (boxGraph, deviceHost) => TrackBox.create(boxGraph, UUID.generate(), box => {
+            box.index.setValue(0);
+            box.type.setValue(TrackType.Audio);
+            box.tracks.refer(deviceHost.tracksField);
+            box.target.refer(deviceHost.audioUnitBoxAdapter().box);
+        })
+    };
+    Instruments.Nano = {
+        defaultName: "Nano",
+        icon: IconSymbol.NanoWave,
+        description: "Simple Sampler",
+        createDevice: (boxGraph, deviceHost, name, icon) => {
+            const fileUUID = UUID.parse("c1678daa-4a47-4cba-b88f-4f4e384663c3");
+            const audioFileBox = boxGraph.findBox(fileUUID)
+                .unwrapOrElse(() => AudioFileBox.create(boxGraph, fileUUID, box => {
+                box.fileName.setValue("Rhode");
+            }));
+            return NanoDeviceBox.create(boxGraph, UUID.generate(), box => {
+                box.label.setValue(name);
+                box.icon.setValue(IconSymbol.toName(icon));
+                box.file.refer(audioFileBox);
+                box.host.refer(deviceHost.inputField);
+            });
+        },
+        createTrack: (boxGraph, deviceHost) => TrackBox.create(boxGraph, UUID.generate(), box => {
+            box.index.setValue(0);
+            box.type.setValue(TrackType.Notes);
+            box.tracks.refer(deviceHost.tracksField);
+            box.target.refer(deviceHost.audioUnitBoxAdapter().box);
+        })
+    };
+    Instruments.Playfield = {
+        defaultName: "Playfield",
+        icon: IconSymbol.Playfield,
+        description: "Drumcomputer",
+        createDevice: (boxGraph, deviceHost, name, icon) => {
+            const deviceBox = PlayfieldDeviceBox.create(boxGraph, UUID.generate(), box => {
+                box.label.setValue(name);
+                box.icon.setValue(IconSymbol.toName(icon));
+                box.host.refer(deviceHost.inputField);
+            });
+            const files = [
+                useFile(boxGraph, UUID.parse("8bb2c6e8-9a6d-4d32-b7ec-1263594ef367"), "909 Bassdrum"),
+                useFile(boxGraph, UUID.parse("0017fa18-a5eb-4d9d-b6f2-e2ddd30a3010"), "909 Snare"),
+                useFile(boxGraph, UUID.parse("28d14cb9-1dc6-4193-9dd7-4e881f25f520"), "909 Low Tom"),
+                useFile(boxGraph, UUID.parse("21f92306-d6e7-446c-a34b-b79620acfefc"), "909 Mid Tom"),
+                useFile(boxGraph, UUID.parse("ad503883-8a72-46ab-a05b-a84149953e17"), "909 High Tom"),
+                useFile(boxGraph, UUID.parse("cfee850b-7658-4d08-9e3b-79d196188504"), "909 Rimshot"),
+                useFile(boxGraph, UUID.parse("32a6f36f-06eb-4b84-bb57-5f51103eb9e6"), "909 Clap"),
+                useFile(boxGraph, UUID.parse("e0ac4b39-23fb-4a56-841d-c9e0ff440cab"), "909 Closed Hat"),
+                useFile(boxGraph, UUID.parse("51c5eea4-391c-4743-896a-859692ec1105"), "909 Open Hat"),
+                useFile(boxGraph, UUID.parse("42a56ff6-89b6-4f2e-8a66-5a41d316f4cb"), "909 Crash"),
+                useFile(boxGraph, UUID.parse("87cde966-b799-4efc-a994-069e703478d3"), "909 Ride")
+            ];
+            const samples = files.map((file, index) => PlayfieldSampleBox.create(boxGraph, UUID.generate(), box => {
+                box.device.refer(deviceBox.samples);
+                box.file.refer(file);
+                box.index.setValue(60 + index);
+            }));
+            samples[7].exclude.setValue(true);
+            samples[8].exclude.setValue(true);
+            return deviceBox;
+        },
+        createTrack: (boxGraph, deviceHost) => TrackBox.create(boxGraph, UUID.generate(), box => {
+            box.index.setValue(0);
+            box.type.setValue(TrackType.Notes);
+            box.tracks.refer(deviceHost.tracksField);
+            box.target.refer(deviceHost.audioUnitBoxAdapter().box);
+        })
+    };
+    Instruments.Vaporisateur = {
+        defaultName: "Vaporisateur",
+        icon: IconSymbol.Piano,
+        description: "Classic subtractive synthesizer",
+        createDevice: (boxGraph, deviceHost, name, icon) => VaporisateurDeviceBox.create(boxGraph, UUID.generate(), box => {
+            box.label.setValue(name);
+            box.icon.setValue(IconSymbol.toName(icon));
+            box.tune.setInitValue(0.0);
+            box.cutoff.setInitValue(1000.0);
+            box.resonance.setInitValue(0.1);
+            box.attack.setInitValue(0.005);
+            box.release.setInitValue(0.1);
+            box.waveform.setInitValue(Waveform.sine);
+            box.host.refer(deviceHost.inputField);
+        }),
+        createTrack: (boxGraph, deviceHost) => TrackBox.create(boxGraph, UUID.generate(), box => {
+            box.index.setValue(0);
+            box.type.setValue(TrackType.Notes);
+            box.tracks.refer(deviceHost.tracksField);
+            box.target.refer(deviceHost.audioUnitBoxAdapter().box);
+        })
+    };
+    Instruments.create = (project, factory, { name, icon } = {}) => {
+        const { boxGraph, boxAdapters, rootBoxAdapter, userEditingManager } = project;
+        const existingNames = rootBoxAdapter.audioUnits.adapters()
+            .map(adapter => adapter.input.getValue().match({
+            none: () => "Untitled",
+            some: adapter => adapter.labelField.getValue()
+        }));
+        const audioUnitBox = Modifier.createAudioUnit(project, AudioUnitType.Instrument);
+        const audioUnitBoxAdapter = boxAdapters.adapterFor(audioUnitBox, AudioUnitBoxAdapter);
+        const uniqueName = Strings.getUniqueName(existingNames, name ?? factory.defaultName);
+        const iconSymbol = icon ?? factory.icon;
+        const device = factory.createDevice(boxGraph, audioUnitBoxAdapter, uniqueName, iconSymbol);
+        const track = factory.createTrack(boxGraph, audioUnitBoxAdapter);
+        userEditingManager.audioUnit.edit(audioUnitBox.editing);
+        return { device, track };
+    };
+    Instruments.Named = { Vaporisateur: Instruments.Vaporisateur, Playfield: Instruments.Playfield, Nano: Instruments.Nano, Tape: Instruments.Tape };
+})(Instruments || (Instruments = {}));

package/dist/Modifier.d.ts

@@ -0,0 +1,21 @@
+import { int, Option } from "@opendaw/lib-std";
+import { ppqn } from "@opendaw/lib-dsp";
+import { AudioUnitType } from "@opendaw/studio-enums";
+import { AudioBusBox, AudioUnitBox, NoteRegionBox, ValueRegionBox } from "@opendaw/studio-boxes";
+import { AnyClipBox, AudioUnitBoxAdapter, DeviceHost, IconSymbol, RootBoxAdapter, TrackClips, TrackRegions } from "@opendaw/studio-adapters";
+import { Project } from "./Project";
+import { Effects } from "./Effects";
+export declare namespace Modifier {
+    const createAudioUnit: ({ boxGraph, rootBox, rootBoxAdapter, masterBusBox }: Project, type: AudioUnitType, index?: int) => AudioUnitBox;
+    const pushAudioUnitsIndices: (rootBoxAdapter: RootBoxAdapter, type: AudioUnitType, count?: int) => int;
+    const deleteAudioUnit: ({ rootBoxAdapter }: Project, adapter: AudioUnitBoxAdapter) => void;
+    const createAudioBus: (project: Project, name: string, icon: IconSymbol, type: AudioUnitType, color: string) => AudioBusBox;
+    const createEffect: (project: Project, host: DeviceHost, entry: Effects.Entry, newIndex: int) => Option<import("@opendaw/lib-box").Box<import("@opendaw/lib-box").PointerTypes, any>>;
+    const createClip: (clips: TrackClips, clipIndex: int, { name }?: {
+        name?: string;
+    }) => Option<AnyClipBox>;
+    const createRegion: (regions: TrackRegions, position: ppqn, duration: ppqn, { name }?: {
+        name?: string;
+    }) => Option<NoteRegionBox> | Option<ValueRegionBox>;
+}
+//# sourceMappingURL=Modifier.d.ts.map

package/dist/Modifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Modifier.d.ts","sourceRoot":"","sources":["../src/Modifier.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,GAAG,EAAE,MAAM,EAAc,MAAM,kBAAkB,CAAA;AACjE,OAAO,EAAC,IAAI,EAAO,MAAM,kBAAkB,CAAA;AAE3C,OAAO,EAAC,aAAa,EAAC,MAAM,uBAAuB,CAAA;AACnD,OAAO,EACH,WAAW,EACX,YAAY,EAGZ,aAAa,EAIb,cAAc,EACjB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EACH,UAAU,EACV,mBAAmB,EACnB,UAAU,EAGV,UAAU,EACV,cAAc,EACd,UAAU,EACV,YAAY,EAEf,MAAM,0BAA0B,CAAA;AACjC,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAEjC,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAEjC,yBAAiB,QAAQ,CAAC;IAQf,MAAM,eAAe,GACvB,qDAAmD,OAAO,EAAE,MAAM,aAAa,EAAE,QAAQ,GAAG,iBAS5F,CAAA;IAEE,MAAM,qBAAqB,GAAI,gBAAgB,cAAc,EAAE,MAAM,aAAa,EAAE,QAAO,GAAO,KAAG,GAY3G,CAAA;IAEM,MAAM,eAAe,GAAI,oBAAkB,OAAO,EAAE,SAAS,mBAAmB,KAAG,IAczF,CAAA;IAEM,MAAM,cAAc,GAAI,SAAS,OAAO,EAChB,MAAM,MAAM,EACZ,MAAM,UAAU,EAChB,MAAM,aAAa,EACnB,OAAO,MAAM,KAAG,WAoB9C,CAAA;IAEM,MAAM,YAAY,GAAI,SAAS,OAAO,EAAE,MAAM,UAAU,EAAE,OAAO,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,yFAmBnG,CAAA;IAEM,MAAM,UAAU,GAAI,OAAO,UAAU,EAAE,WAAW,GAAG,EAAE,WAAQ;QAClE,IAAI,CAAC,EAAE,MAAM,CAAA;KACX,KAAG,MAAM,CAAC,UAAU,CAkCzB,CAAA;IAEM,MAAM,YAAY,GAAI,SAAS,YAAY,EACrB,UAAU,IAAI,EACd,UAAU,IAAI,EAAE,WAAQ;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAO,mDAgC1E,CAAA;CACJ"}