@blibliki/engine 0.1.27 → 0.3.1

package/src/core/module/Module.ts

@@ -0,0 +1,233 @@
+import { Optional, upperFirst, uuidv4 } from "@blibliki/utils";
+import { Engine } from "@/Engine";
+import { AnyModule, ModuleType, ModuleTypeToPropsMapping } from "@/modules";
+import { IAnyAudioContext } from "../";
+import {
+  AudioInputProps,
+  AudioOutputProps,
+  IIOSerialize,
+  IOType,
+  InputCollection,
+  OutputCollection,
+  MidiInputProps,
+  MidiOutputProps,
+} from "../IO";
+import Note from "../Note";
+import { TTime } from "../Timing/Time";
+import MidiEvent, { MidiEventType } from "../midi/MidiEvent";
+
+export type IModule<T extends ModuleType> = {
+  id: string;
+  name: string;
+  voiceNo: number;
+  moduleType: T;
+  props: ModuleTypeToPropsMapping[T];
+};
+
+export type IModuleSerialize<T extends ModuleType> = IModule<T> & {
+  inputs: IIOSerialize[];
+  outputs: IIOSerialize[];
+};
+
+export type IModuleConstructor<T extends ModuleType> = Optional<
+  IModule<T>,
+  "id" | "voiceNo"
+> & {
+  audioNodeConstructor?: (context: IAnyAudioContext) => AudioNode;
+};
+
+export abstract class Module<T extends ModuleType> implements IModule<T> {
+  id: string;
+  engineId: string;
+  name: string;
+  moduleType: T;
+  voiceNo: number;
+  audioNode: AudioNode | undefined;
+  inputs: InputCollection;
+  outputs: OutputCollection;
+  protected _props!: ModuleTypeToPropsMapping[T];
+  protected superInitialized = false;
+  protected activeNotes: Note[];
+
+  constructor(engineId: string, params: IModuleConstructor<T>) {
+    const { id, name, moduleType, voiceNo, audioNodeConstructor, props } =
+      params;
+
+    this.id = id ?? uuidv4();
+    this.engineId = engineId;
+    this.name = name;
+    this.moduleType = moduleType;
+    this.voiceNo = voiceNo ?? 0;
+    this.activeNotes = [];
+    this.audioNode = audioNodeConstructor?.(this.context);
+    this._props = {} as ModuleTypeToPropsMapping[T];
+    this.props = props;
+
+    this.inputs = new InputCollection(this);
+    this.outputs = new OutputCollection(this);
+
+    this.superInitialized = true;
+  }
+
+  get props(): ModuleTypeToPropsMapping[T] {
+    return this._props;
+  }
+
+  set props(value: Partial<ModuleTypeToPropsMapping[T]>) {
+    Object.keys(value).forEach((key) => {
+      const onSetAttr = `onSet${upperFirst(key)}`;
+
+      // @ts-expect-error TS7053 ignore this error
+      // eslint-disable-next-line
+      this[onSetAttr]?.(value[key]);
+    });
+
+    this._props = { ...this._props, ...value };
+
+    Object.keys(value).forEach((key) => {
+      const onSetAttr = `onAfterSet${upperFirst(key)}`;
+
+      // @ts-expect-error TS7053 ignore this error
+      // eslint-disable-next-line
+      this[onSetAttr]?.(value[key]);
+    });
+  }
+
+  serialize(): IModuleSerialize<T> {
+    return {
+      id: this.id,
+      name: this.name,
+      moduleType: this.moduleType,
+      voiceNo: this.voiceNo,
+      props: this.props,
+      inputs: this.inputs.serialize(),
+      outputs: this.outputs.serialize(),
+    };
+  }
+
+  plug({
+    audioModule,
+    from,
+    to,
+  }: {
+    audioModule: AnyModule;
+    from: string;
+    to: string;
+  }) {
+    const output = this.outputs.findByName(from);
+    const input = audioModule.inputs.findByName(to);
+
+    output.plug(input);
+  }
+
+  protected rePlugAll(callback?: () => void) {
+    this.inputs.rePlugAll(callback);
+    this.outputs.rePlugAll(callback);
+  }
+
+  protected unPlugAll() {
+    this.inputs.unPlugAll();
+    this.outputs.unPlugAll();
+  }
+
+  start(_time: TTime): void {
+    // Optional implementation in modules
+  }
+
+  stop(_time: TTime): void {
+    // Optional implementation in modules
+  }
+
+  triggerAttack(note: Note, _triggeredAt: TTime): void {
+    if (this.activeNotes.some((n) => n.fullName === note.fullName)) return;
+
+    this.activeNotes.push(note);
+  }
+
+  triggerRelease(note: Note, _triggeredAt: TTime): void {
+    this.activeNotes = this.activeNotes.filter(
+      (n) => n.fullName !== note.fullName,
+    );
+  }
+
+  onMidiEvent = (midiEvent: MidiEvent) => {
+    const { note, triggeredAt } = midiEvent;
+
+    switch (midiEvent.type) {
+      case MidiEventType.noteOn: {
+        this.triggerAttack(note!, triggeredAt);
+        break;
+      }
+      case MidiEventType.noteOff:
+        this.triggerRelease(note!, triggeredAt);
+        break;
+      default:
+        throw Error("This type is not a note");
+    }
+  };
+
+  protected triggerPropsUpdate() {
+    this.engine._triggerPropsUpdate({
+      id: this.id,
+      moduleType: this.moduleType,
+      voiceNo: this.voiceNo,
+      name: this.name,
+      props: this.props,
+    });
+  }
+
+  dispose() {
+    this.inputs.unPlugAll();
+    this.outputs.unPlugAll();
+  }
+
+  protected registerDefaultIOs(value: "both" | "in" | "out" = "both") {
+    this.registerMidiInput({
+      name: "midi in",
+      onMidiEvent: this.onMidiEvent,
+    });
+
+    if (!this.audioNode) return;
+
+    if (value === "in" || value === "both") {
+      this.registerAudioInput({
+        name: "in",
+        getAudioNode: () => this.audioNode!,
+      });
+    }
+
+    if (value === "out" || value === "both") {
+      this.registerAudioOutput({
+        name: "out",
+        getAudioNode: () => this.audioNode!,
+      });
+    }
+  }
+
+  protected registerAudioInput(props: Omit<AudioInputProps, "ioType">) {
+    return this.inputs.add({ ...props, ioType: IOType.AudioInput });
+  }
+
+  protected registerAudioOutput(props: Omit<AudioOutputProps, "ioType">) {
+    return this.outputs.add({ ...props, ioType: IOType.AudioOutput });
+  }
+
+  protected registerMidiInput(props: Omit<MidiInputProps, "ioType">) {
+    return this.inputs.add({ ...props, ioType: IOType.MidiInput });
+  }
+
+  protected registerMidiOutput(props: Omit<MidiOutputProps, "ioType">) {
+    return this.outputs.add({
+      ...props,
+      ioType: IOType.MidiOutput,
+    });
+  }
+
+  protected get engine() {
+    return Engine.getById(this.engineId);
+  }
+
+  protected get context() {
+    return this.engine.context;
+  }
+}

package/src/core/module/PolyModule.ts

@@ -0,0 +1,246 @@
+import { deterministicId, Optional, uuidv4 } from "@blibliki/utils";
+import { Engine } from "@/Engine";
+import { ModuleType, ModuleTypeToPropsMapping } from "@/modules";
+import {
+  IIOSerialize,
+  InputCollection,
+  IOType,
+  MidiInputProps,
+  MidiOutputProps,
+  OutputCollection,
+} from "../IO";
+import { PolyAudioInputProps, PolyAudioOutputProps } from "../IO/PolyAudioIO";
+import { TTime } from "../Timing";
+import MidiEvent from "../midi/MidiEvent";
+import { IModule, IModuleConstructor, Module } from "./Module";
+
+export type IPolyModule<T extends ModuleType> = Omit<IModule<T>, "voiceNo"> & {
+  voices: number;
+};
+
+export type IPolyModuleSerialize<T extends ModuleType> = IPolyModule<T> & {
+  inputs: IIOSerialize[];
+  outputs: IIOSerialize[];
+};
+
+export type IPolyModuleConstructor<T extends ModuleType> = Optional<
+  IPolyModule<T>,
+  "id"
+> & {
+  monoModuleConstructor: (
+    engineId: string,
+    params: IModuleConstructor<T>,
+  ) => Module<T>;
+};
+
+export abstract class PolyModule<T extends ModuleType>
+  implements IPolyModule<T>
+{
+  id: string;
+  engineId: string;
+  moduleType: T;
+  audioModules!: Module<T>[];
+  inputs: InputCollection;
+  outputs: OutputCollection;
+  protected monoModuleConstructor: IPolyModuleConstructor<T>["monoModuleConstructor"];
+  protected _props!: ModuleTypeToPropsMapping[T];
+  protected superInitialized = false;
+  private _voices!: number;
+  private _name!: string;
+
+  constructor(engineId: string, params: IPolyModuleConstructor<T>) {
+    const { id, name, moduleType, voices, monoModuleConstructor, props } =
+      params;
+
+    this.audioModules = [];
+
+    this.monoModuleConstructor = monoModuleConstructor;
+    this.id = id ?? uuidv4();
+    this.engineId = engineId;
+    this.name = name;
+    this.moduleType = moduleType;
+    this.voices = voices || 1;
+    this._props = {} as ModuleTypeToPropsMapping[T];
+    this.props = props;
+
+    this.inputs = new InputCollection(
+      this as unknown as PolyModule<ModuleType>,
+    );
+    this.outputs = new OutputCollection(
+      this as unknown as PolyModule<ModuleType>,
+    );
+
+    this.superInitialized = true;
+  }
+
+  get name() {
+    return this._name;
+  }
+
+  set name(value: string) {
+    this._name = value;
+    this.audioModules.forEach((m) => (m.name = value));
+  }
+
+  get props(): ModuleTypeToPropsMapping[T] {
+    return this._props;
+  }
+
+  set props(value: Partial<ModuleTypeToPropsMapping[T]>) {
+    this._props = { ...this._props, ...value };
+    this.audioModules.forEach((m) => (m.props = value));
+  }
+
+  get voices() {
+    return this._voices;
+  }
+
+  set voices(value: number) {
+    this._voices = value;
+    this.adjustNumberOfModules();
+    this.rePlugAll();
+  }
+
+  start(time: TTime): void {
+    this.audioModules.forEach((m) => {
+      m.start(time);
+    });
+  }
+
+  stop(time: TTime): void {
+    this.audioModules.forEach((m) => {
+      m.stop(time);
+    });
+  }
+
+  serialize(): IPolyModuleSerialize<T> {
+    return {
+      id: this.id,
+      name: this.name,
+      moduleType: this.moduleType,
+      voices: this.voices,
+      props: this.props,
+      inputs: this.inputs.serialize(),
+      outputs: this.outputs.serialize(),
+    };
+  }
+
+  plug({
+    audioModule,
+    from,
+    to,
+  }: {
+    audioModule: Module<ModuleType> | PolyModule<ModuleType>;
+    from: string;
+    to: string;
+  }) {
+    const output = this.outputs.findByName(from);
+    const input = audioModule.inputs.findByName(to);
+
+    output.plug(input);
+  }
+
+  rePlugAll(callback?: () => void) {
+    if (!this.superInitialized) return;
+
+    this.inputs.rePlugAll(callback);
+    this.outputs.rePlugAll(callback);
+  }
+
+  protected unPlugAll() {
+    this.inputs.unPlugAll();
+    this.outputs.unPlugAll();
+  }
+
+  dispose() {
+    this.inputs.unPlugAll();
+    this.outputs.unPlugAll();
+    this.audioModules.forEach((m) => {
+      m.dispose();
+    });
+  }
+
+  onMidiEvent = (midiEvent: MidiEvent) => {
+    const voiceNo = midiEvent.voiceNo ?? 0;
+    const audioModule = this.findVoice(voiceNo);
+    audioModule.onMidiEvent(midiEvent);
+  };
+
+  findVoice(voiceNo: number) {
+    const moduleByVoice = this.audioModules.find((m) => m.voiceNo === voiceNo);
+    if (!moduleByVoice)
+      throw Error(`Voice ${voiceNo} on module ${this.name} not found`);
+
+    return moduleByVoice;
+  }
+
+  protected registerDefaultIOs(value: "both" | "in" | "out" = "both") {
+    this.registerMidiInput({
+      name: "midi in",
+      onMidiEvent: this.onMidiEvent,
+    });
+
+    if (value === "in" || value === "both") {
+      this.registerAudioInput({
+        name: "in",
+      });
+    }
+
+    if (value === "out" || value === "both") {
+      this.registerAudioOutput({
+        name: "out",
+      });
+    }
+  }
+
+  protected registerAudioInput(props: Omit<PolyAudioInputProps, "ioType">) {
+    return this.inputs.add({ ...props, ioType: IOType.PolyAudioInput });
+  }
+
+  protected registerAudioOutput(props: Omit<PolyAudioOutputProps, "ioType">) {
+    return this.outputs.add({ ...props, ioType: IOType.PolyAudioOutput });
+  }
+
+  protected registerMidiInput(props: Omit<MidiInputProps, "ioType">) {
+    return this.inputs.add({ ...props, ioType: IOType.MidiInput });
+  }
+
+  protected registerMidiOutput(props: Omit<MidiOutputProps, "ioType">) {
+    return this.outputs.add({
+      ...props,
+      ioType: IOType.MidiOutput,
+    });
+  }
+
+  private adjustNumberOfModules() {
+    if (this.audioModules.length === this.voices) return;
+
+    if (this.audioModules.length > this.voices) {
+      const audioModule = this.audioModules.pop();
+      audioModule?.dispose();
+    } else {
+      const voiceNo = this.audioModules.length;
+      const id = deterministicId(this.id, voiceNo.toString());
+
+      const audioModule = this.monoModuleConstructor(this.engineId, {
+        id,
+        name: this.name,
+        moduleType: this.moduleType,
+        voiceNo,
+        props: { ...this.props },
+      });
+
+      this.audioModules.push(audioModule);
+    }
+
+    this.adjustNumberOfModules();
+  }
+
+  protected get engine() {
+    return Engine.getById(this.engineId);
+  }
+
+  protected get context() {
+    return this.engine.context;
+  }
+}

package/src/core/module/VoiceScheduler.ts

@@ -0,0 +1,121 @@
+import { EmptyObject } from "@blibliki/utils";
+import { ICreateModule, ModuleType } from "@/modules";
+import { MidiOutput } from "../IO";
+import { nt, t, TTime } from "../Timing/Time";
+import MidiEvent, { MidiEventType } from "../midi/MidiEvent";
+import { PropSchema } from "../schema";
+import { IModuleConstructor, Module } from "./Module";
+import { IPolyModuleConstructor, PolyModule } from "./PolyModule";
+
+export type IVoiceSchedulerProps = EmptyObject;
+export const voiceSchedulerPropSchema: PropSchema<IVoiceSchedulerProps> = {};
+const DEFAULT_PROPS = {};
+
+class Voice extends Module<ModuleType.VoiceScheduler> {
+  declare audioNode: undefined;
+  activeNote: string | null = null;
+  triggeredAt: TTime = t(0);
+
+  constructor(
+    engineId: string,
+    params: ICreateModule<ModuleType.VoiceScheduler>,
+  ) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+
+    super(engineId, {
+      ...params,
+      props,
+    });
+  }
+
+  midiTriggered = (midiEvent: MidiEvent) => {
+    const { triggeredAt, note, type } = midiEvent;
+
+    if (!note) return;
+    const noteName = note.fullName;
+
+    switch (type) {
+      case MidiEventType.noteOn:
+        this.activeNote = noteName;
+        this.triggeredAt = triggeredAt;
+
+        break;
+      case MidiEventType.noteOff:
+        this.activeNote = null;
+        break;
+      default:
+        throw Error("This type is not a note");
+    }
+  };
+}
+
+export default class VoiceScheduler extends PolyModule<ModuleType.VoiceScheduler> {
+  declare audioModules: Voice[];
+  midiOutput!: MidiOutput;
+
+  constructor(
+    engineId: string,
+    params: IPolyModuleConstructor<ModuleType.VoiceScheduler>,
+  ) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+    const monoModuleConstructor = (
+      engineId: string,
+      params: IModuleConstructor<ModuleType.VoiceScheduler>,
+    ) => new Voice(engineId, params);
+
+    super(engineId, {
+      ...params,
+      props,
+      monoModuleConstructor,
+    });
+
+    this.registerInputs();
+    this.registerOutputs();
+  }
+
+  onMidiEvent = (midiEvent: MidiEvent) => {
+    let voice: Voice | undefined;
+
+    switch (midiEvent.type) {
+      case MidiEventType.noteOn:
+        voice = this.findFreeVoice();
+
+        break;
+      case MidiEventType.noteOff:
+        voice = this.audioModules.find(
+          (v) => v.activeNote === midiEvent.note!.fullName,
+        );
+        break;
+      default:
+        throw Error("This type is not a note");
+    }
+
+    if (!voice) return;
+
+    voice.midiTriggered(midiEvent);
+    midiEvent.voiceNo = voice.voiceNo;
+    this.midiOutput.onMidiEvent(midiEvent);
+  };
+
+  private findFreeVoice(): Voice {
+    let voice = this.audioModules.find((v) => !v.activeNote);
+
+    // If no available voice, get the one with the lowest triggeredAt
+    voice ??= this.audioModules.sort((a, b) => {
+      return nt(a.triggeredAt) - nt(b.triggeredAt);
+    })[0];
+
+    return voice;
+  }
+
+  private registerInputs() {
+    this.registerMidiInput({
+      name: "midi in",
+      onMidiEvent: this.onMidiEvent,
+    });
+  }
+
+  private registerOutputs() {
+    this.midiOutput = this.registerMidiOutput({ name: "midi out" });
+  }
+}

package/src/core/module/index.ts

@@ -0,0 +1,3 @@
+export { Module } from "./Module";
+export type { IModule, IModuleSerialize } from "./Module";
+export type { IPolyModule, IPolyModuleSerialize } from "./PolyModule";

package/src/core/schema.ts

@@ -0,0 +1,41 @@
+type BasePropType = {
+  label?: string;
+  description?: string;
+};
+
+export type NumberProp = BasePropType & {
+  kind: "number";
+  min?: number;
+  max?: number;
+  step?: number;
+};
+
+export type EnumProp<T extends string | number> = BasePropType & {
+  kind: "enum";
+  options: T[];
+};
+
+export type StringProp = BasePropType & {
+  kind: "string";
+  pattern?: RegExp;
+};
+
+export type BooleanProp = BasePropType & {
+  kind: "boolean";
+};
+
+export type ArrayProp = BasePropType & {
+  kind: "array";
+};
+
+export type PropDefinition<T> = T extends number
+  ? NumberProp | EnumProp<number>
+  : T extends boolean
+    ? BooleanProp
+    : T extends string
+      ? StringProp | EnumProp<string>
+      : T extends (string | number)[]
+        ? ArrayProp
+        : never;
+
+export type PropSchema<T> = { [K in keyof T]: PropDefinition<T[K]> };

package/src/index.ts

@@ -1,11 +1,33 @@
-export { default } from "./Engine";
-export { MidiDevice, MidiDeviceManager } from "./core/midi";
-export { default as Note } from "./core/Note";
+export { Engine } from "./Engine";
+export type { ICreateRoute, IUpdateModule } from "./Engine";
 
-export type { MidiDeviceInterface } from "./core/midi";
-export type { INote } from "./core/Note";
-export type { ModuleInterface, AudioModule } from "./core/Module";
-export type { ISequence } from "./modules";
+export type {
+  IRoute,
+  IIOSerialize,
+  IModule,
+  IModuleSerialize,
+  IPolyModuleSerialize,
+  IMidiDevice,
+  PropDefinition,
+  PropSchema,
+  StringProp,
+  NumberProp,
+  EnumProp,
+  BooleanProp,
+  ArrayProp,
+  INote,
+} from "./core";
+export { TransportState, MidiDevice, MidiPortState, Note } from "./core";
 
-export type { RouteInterface, RouteProps } from "./routes";
-export type { IIOSerialize as IOProps } from "./core/IO";
+export { ModuleType, moduleSchemas, OscillatorWave } from "./modules";
+export type {
+  IOscillator,
+  IGain,
+  IMaster,
+  ISequence,
+  IStepSequencerProps,
+  IStepSequencer,
+  ModuleTypeToPropsMapping,
+  ICreateModule,
+  ModuleParams,
+} from "./modules";