@opendaw/studio-core 0.0.8 → 0.0.9

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/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"}

package/dist/Modifier.js

@@ -0,0 +1,168 @@
+import { assert, Option, panic, UUID } from "@opendaw/lib-std";
+import { PPQN } from "@opendaw/lib-dsp";
+import { AudioUnitType } from "@opendaw/studio-enums";
+import { AudioBusBox, AudioUnitBox, NoteClipBox, NoteEventCollectionBox, NoteRegionBox, TrackBox, ValueClipBox, ValueEventCollectionBox, ValueRegionBox } from "@opendaw/studio-boxes";
+import { IconSymbol, TrackType } from "@opendaw/studio-adapters";
+import { ColorCodes } from "./ColorCodes";
+export var Modifier;
+(function (Modifier) {
+    const AudioUnitOrdering = {
+        [AudioUnitType.Instrument]: 0,
+        [AudioUnitType.Aux]: 1,
+        [AudioUnitType.Bus]: 2,
+        [AudioUnitType.Output]: 3
+    };
+    Modifier.createAudioUnit = ({ boxGraph, rootBox, rootBoxAdapter, masterBusBox }, type, index) => {
+        const insertIndex = index ?? Modifier.pushAudioUnitsIndices(rootBoxAdapter, type, 1);
+        console.debug(`createAudioUnit type: ${type}, insertIndex: ${insertIndex}`);
+        return AudioUnitBox.create(boxGraph, UUID.generate(), box => {
+            box.collection.refer(rootBox.audioUnits);
+            box.output.refer(masterBusBox.input);
+            box.index.setValue(insertIndex);
+            box.type.setValue(type);
+        });
+    };
+    Modifier.pushAudioUnitsIndices = (rootBoxAdapter, type, count = 1) => {
+        const adapters = rootBoxAdapter.audioUnits.adapters();
+        const order = AudioUnitOrdering[type];
+        let index = 0 | 0;
+        for (; index < adapters.length; index++) {
+            if (AudioUnitOrdering[adapters[index].type] > order) {
+                break;
+            }
+        }
+        const insertIndex = index;
+        while (index < adapters.length) {
+            adapters[index].indexField.setValue(count + index++);
+        }
+        return insertIndex;
+    };
+    Modifier.deleteAudioUnit = ({ rootBoxAdapter }, adapter) => {
+        const adapters = rootBoxAdapter.audioUnits.adapters();
+        const boxIndex = adapter.indexField.getValue();
+        const deleteIndex = adapters.indexOf(adapter);
+        console.debug(`deleteAudioUnit adapter: ${adapter.toString()}, deleteIndex: ${deleteIndex}, indexField: ${boxIndex}`);
+        if (deleteIndex === -1) {
+            return panic(`Cannot delete ${adapter}. Does not exist.`);
+        }
+        if (deleteIndex !== boxIndex) {
+            console.debug("indices", adapters.map(x => x.box.index.getValue()).join(", "));
+            return panic(`Cannot delete ${adapter}. Wrong index.`);
+        }
+        for (let index = deleteIndex + 1; index < adapters.length; index++) {
+            adapters[index].indexField.setValue(index - 1);
+        }
+        adapter.box.delete();
+    };
+    Modifier.createAudioBus = (project, name, icon, type, color) => {
+        console.debug(`createAudioBus '${name}', type: ${type}, color: ${color}`);
+        const { rootBox, boxGraph } = project;
+        assert(rootBox.audioBusses.isAttached(), "rootBox not attached");
+        const uuid = UUID.generate();
+        const audioBusBox = AudioBusBox.create(boxGraph, uuid, box => {
+            box.collection.refer(rootBox.audioBusses);
+            box.label.setValue(name);
+            box.icon.setValue(IconSymbol.toName(icon));
+            box.color.setValue(color);
+        });
+        const audioUnitBox = Modifier.createAudioUnit(project, type);
+        TrackBox.create(boxGraph, UUID.generate(), box => {
+            box.tracks.refer(audioUnitBox.tracks);
+            box.target.refer(audioUnitBox);
+            box.index.setValue(0);
+            box.type.setValue(TrackType.Undefined);
+        });
+        audioBusBox.output.refer(audioUnitBox.input);
+        return audioBusBox;
+    };
+    Modifier.createEffect = (project, host, entry, newIndex) => {
+        let chain;
+        let field;
+        if (entry.type === "audio") {
+            chain = host.audioEffects.adapters();
+            field = host.audioEffects.field();
+        }
+        else if (entry.type === "midi") {
+            chain = host.midiEffects.adapters();
+            field = host.midiEffects.field();
+        }
+        else {
+            return panic(`Unknown factory type: ${entry.type}`);
+        }
+        return project.editing.modify(() => {
+            const box = entry.create(project, field, newIndex);
+            for (let index = newIndex; index < chain.length; index++) {
+                chain[index].indexField.setValue(index + 1);
+            }
+            return box;
+        });
+    };
+    Modifier.createClip = (clips, clipIndex, { name } = {}) => {
+        if (clips.collection.getAdapterByIndex(clipIndex).nonEmpty()) {
+            console.warn("Cannot create Clip on occupied cell.");
+            return Option.None;
+        }
+        const graph = clips.trackBoxAdapter.box.graph;
+        const type = clips.trackBoxAdapter.type;
+        switch (type) {
+            case TrackType.Notes: {
+                const events = NoteEventCollectionBox.create(graph, UUID.generate());
+                return Option.wrap(NoteClipBox.create(graph, UUID.generate(), box => {
+                    box.index.setValue(clipIndex);
+                    box.label.setValue(name ?? "Notes");
+                    box.hue.setValue(ColorCodes.forTrackType(type));
+                    box.mute.setValue(false);
+                    box.duration.setValue(PPQN.Bar);
+                    box.clips.refer(clips.trackBoxAdapter.box.clips);
+                    box.events.refer(events.owners);
+                }));
+            }
+            case TrackType.Value: {
+                const events = ValueEventCollectionBox.create(graph, UUID.generate());
+                return Option.wrap(ValueClipBox.create(graph, UUID.generate(), box => {
+                    box.index.setValue(clipIndex);
+                    box.label.setValue(name ?? "CV");
+                    box.hue.setValue(ColorCodes.forTrackType(type));
+                    box.mute.setValue(false);
+                    box.duration.setValue(PPQN.Bar);
+                    box.events.refer(events.owners);
+                    box.clips.refer(clips.trackBoxAdapter.box.clips);
+                }));
+            }
+        }
+        return Option.None;
+    };
+    Modifier.createRegion = (regions, position, duration, { name } = {}) => {
+        const graph = regions.trackBoxAdapter.box.graph;
+        const type = regions.trackBoxAdapter.type;
+        switch (type) {
+            case TrackType.Notes: {
+                const events = NoteEventCollectionBox.create(graph, UUID.generate());
+                return Option.wrap(NoteRegionBox.create(graph, UUID.generate(), box => {
+                    box.position.setValue(Math.max(position, 0));
+                    box.label.setValue(name ?? "Notes");
+                    box.hue.setValue(ColorCodes.forTrackType(type));
+                    box.mute.setValue(false);
+                    box.duration.setValue(duration);
+                    box.loopDuration.setValue(PPQN.Bar);
+                    box.events.refer(events.owners);
+                    box.regions.refer(regions.trackBoxAdapter.box.regions);
+                }));
+            }
+            case TrackType.Value: {
+                const events = ValueEventCollectionBox.create(graph, UUID.generate());
+                return Option.wrap(ValueRegionBox.create(graph, UUID.generate(), box => {
+                    box.position.setValue(Math.max(position, 0));
+                    box.label.setValue(name ?? "Automation");
+                    box.hue.setValue(ColorCodes.forTrackType(type));
+                    box.mute.setValue(false);
+                    box.duration.setValue(duration);
+                    box.loopDuration.setValue(PPQN.Bar);
+                    box.events.refer(events.owners);
+                    box.regions.refer(regions.trackBoxAdapter.box.regions);
+                }));
+            }
+        }
+        return Option.None;
+    };
+})(Modifier || (Modifier = {}));

package/dist/index.d.ts

@@ -6,10 +6,14 @@ export * from "./samples/SampleStorage";
 export * from "./samples/MainThreadSampleLoader";
 export * from "./samples/MainThreadSampleManager";
 export * from "./samples/SampleProvider";
+export * from "./ColorCodes";
+export * from "./Colors";
+export * from "./Effects";
 export * from "./Engine";
 export * from "./EngineFacade";
 export * from "./EngineWorklet";
 export * from "./Mixer";
+export * from "./Modifier";
 export * from "./Project";
 export * from "./ProjectEnv";
 export * from "./Wav";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA;AAExC,cAAc,uBAAuB,CAAA;AACrC,cAAc,yBAAyB,CAAA;AACvC,cAAc,kCAAkC,CAAA;AAChD,cAAc,mCAAmC,CAAA;AACjD,cAAc,0BAA0B,CAAA;AAExC,cAAc,UAAU,CAAA;AACxB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,SAAS,CAAA;AACvB,cAAc,WAAW,CAAA;AACzB,cAAc,cAAc,CAAA;AAC5B,cAAc,OAAO,CAAA;AACrB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA;AAExC,cAAc,uBAAuB,CAAA;AACrC,cAAc,yBAAyB,CAAA;AACvC,cAAc,kCAAkC,CAAA;AAChD,cAAc,mCAAmC,CAAA;AACjD,cAAc,0BAA0B,CAAA;AAExC,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,WAAW,CAAA;AACzB,cAAc,UAAU,CAAA;AACxB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,SAAS,CAAA;AACvB,cAAc,YAAY,CAAA;AAC1B,cAAc,WAAW,CAAA;AACzB,cAAc,cAAc,CAAA;AAC5B,cAAc,OAAO,CAAA;AACrB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,YAAY,CAAA"}

package/dist/index.js

@@ -6,10 +6,14 @@ export * from "./samples/SampleStorage";
 export * from "./samples/MainThreadSampleLoader";
 export * from "./samples/MainThreadSampleManager";
 export * from "./samples/SampleProvider";
+export * from "./ColorCodes";
+export * from "./Colors";
+export * from "./Effects";
 export * from "./Engine";
 export * from "./EngineFacade";
 export * from "./EngineWorklet";
 export * from "./Mixer";
+export * from "./Modifier";
 export * from "./Project";
 export * from "./ProjectEnv";
 export * from "./Wav";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opendaw/studio-core",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "license": "LGPL-3.0-or-later",
   "publishConfig": {
     "access": "public"
@@ -26,22 +26,22 @@
     "test": "echo \"No tests to run\""
   },
   "dependencies": {
-    "@opendaw/lib-box": "^0.0.8",
-    "@opendaw/lib-dom": "^0.0.8",
-    "@opendaw/lib-dsp": "^0.0.8",
-    "@opendaw/lib-fusion": "^0.0.8",
-    "@opendaw/lib-runtime": "^0.0.8",
-    "@opendaw/lib-std": "^0.0.8",
-    "@opendaw/studio-adapters": "^0.0.8",
-    "@opendaw/studio-boxes": "^0.0.8",
-    "@opendaw/studio-enums": "^0.0.8"
+    "@opendaw/lib-box": "^0.0.9",
+    "@opendaw/lib-dom": "^0.0.9",
+    "@opendaw/lib-dsp": "^0.0.9",
+    "@opendaw/lib-fusion": "^0.0.9",
+    "@opendaw/lib-runtime": "^0.0.9",
+    "@opendaw/lib-std": "^0.0.9",
+    "@opendaw/studio-adapters": "^0.0.9",
+    "@opendaw/studio-boxes": "^0.0.9",
+    "@opendaw/studio-enums": "^0.0.9"
   },
   "devDependencies": {
-    "@opendaw/eslint-config": "^0.0.8",
-    "@opendaw/studio-core-processors": "^0.0.8",
-    "@opendaw/studio-core-workers": "^0.0.2",
-    "@opendaw/studio-forge-boxes": "^0.0.8",
-    "@opendaw/typescript-config": "^0.0.8"
+    "@opendaw/eslint-config": "^0.0.9",
+    "@opendaw/studio-core-processors": "^0.0.9",
+    "@opendaw/studio-core-workers": "^0.0.3",
+    "@opendaw/studio-forge-boxes": "^0.0.9",
+    "@opendaw/typescript-config": "^0.0.9"
   },
-  "gitHead": "752dd75794d8c9bbd0202a906b23e14113909085"
+  "gitHead": "3282403ddf3a1f562a64af2ec7395aa333d40f42"
 }