@blibliki/engine 0.1.26 → 0.3.1

package/src/Engine.ts

@@ -1,245 +1,226 @@
-import { Context, now, setContext } from "tone";
-import { MidiEvent, MidiDeviceManager } from "./core/midi";
-
-import { AudioModule, PolyModule, Startable } from "./core/Module";
-import { createModule, VirtualMidi } from "./modules";
-import { applyRoutes, createRoute, RouteInterface } from "./routes";
-import { AnyObject, Optional } from "./types";
-
-type LatencyHint = "interactive" | "playback" | "balanced";
-
-interface ContextInterface {
-  latencyHint: LatencyHint;
-  lookAhead: number;
-}
-
-interface InitializeInterface {
-  context?: Partial<ContextInterface>;
-}
-
-export interface UpdateModuleProps {
+import { assertDefined, Optional, pick, uuidv4 } from "@blibliki/utils";
+import {
+  IAnyAudioContext,
+  IRoute,
+  Routes,
+  MidiDeviceManager,
+  IModule,
+  TTime,
+  Transport,
+  MidiEvent,
+} from "@/core";
+import {
+  ICreateModule,
+  ModuleParams,
+  ModuleType,
+  ModuleTypeToModuleMapping,
+  createModule,
+} from "@/modules";
+import { PolyModule } from "./core/module/PolyModule";
+import { loadProcessors } from "./processors";
+
+export type IUpdateModule<T extends ModuleType> = {
   id: string;
-  changes: {
-    name?: string;
-    numberOfVoices?: number;
-    props?: AnyObject;
+  moduleType: T;
+  changes: Partial<Omit<ICreateModule<T>, "id" | "moduleType" | "voice">> & {
+    voices?: number;
   };
-}
+};
+
+export type ICreateRoute = Optional<IRoute, "id">;
+
+export class Engine {
+  private static _engines = new Map<string, Engine>();
+  private static _currentId: string;
+  private propsUpdateCallbacks: (<T extends ModuleType>(
+    params: IModule<T>,
+  ) => void)[] = [];
+
+  readonly id: string;
+  context: IAnyAudioContext;
+  isInitialized = false;
+  routes: Routes;
+  transport: Transport;
+  modules: Map<
+    string,
+    ModuleTypeToModuleMapping[keyof ModuleTypeToModuleMapping]
+  >;
 
-class Engine {
   midiDeviceManager: MidiDeviceManager;
-  private static instance: Engine;
-  private context: Context;
-  private propsUpdateCallbacks: { (id: string, props: AnyObject): void }[];
-  private _isStarted = false;
 
-  modules: {
-    [Identifier: string]: AudioModule;
-  };
-
-  routes: {
-    [Identifier: string]: RouteInterface;
-  };
+  static getById(id: string): Engine {
+    const engine = Engine._engines.get(id);
+    assertDefined(engine);
 
-  private constructor() {
-    this.modules = {};
-    this.routes = {};
-    this.propsUpdateCallbacks = [];
+    return engine;
   }
 
-  public static getInstance(): Engine {
-    if (!Engine.instance) {
-      Engine.instance = new Engine();
-    }
+  static get current(): Engine {
+    assertDefined(this._currentId);
 
-    return Engine.instance;
+    return this.getById(this._currentId);
   }
 
-  initialize(props: InitializeInterface) {
-    return new Promise((resolve) => {
-      if (this.context) return resolve({});
+  constructor(context: IAnyAudioContext) {
+    this.id = uuidv4();
 
-      this.context = new Context(props.context);
-      setContext(this.context);
-      this.context.transport.start();
-
-      this.midiDeviceManager = new MidiDeviceManager();
-
-      setTimeout(() => {
-        resolve({});
-      }, 0);
+    this.context = context;
+    this.transport = new Transport({
+      onStart: this.onStart,
+      onStop: this.onStop,
     });
+    this.routes = new Routes(this);
+    this.modules = new Map();
+    this.midiDeviceManager = new MidiDeviceManager();
+
+    Engine._engines.set(this.id, this);
+    Engine._currentId = this.id;
   }
 
-  addModule(params: {
-    id?: string;
-    name: string;
-    numberOfVoices?: number;
-    type: string;
-    props?: AnyObject;
-  }) {
-    const { id, name, numberOfVoices, type, props = {} } = params;
-
-    const audioModule = createModule({
-      id,
-      name,
-      type,
-      props: {},
-    });
-    if (audioModule instanceof PolyModule && numberOfVoices) {
-      audioModule.numberOfVoices = numberOfVoices;
-    }
-    audioModule.props = props;
-    this.modules[audioModule.id] = audioModule;
+  get state() {
+    return this.transport.state;
+  }
 
-    this.updateRoutes();
+  async initialize() {
+    if (this.isInitialized) return;
 
-    return audioModule.serialize();
+    await loadProcessors(this.context);
+    await this.midiDeviceManager.initialize();
+    this.isInitialized = true;
   }
 
-  removeModule(id: string) {
-    this.modules[id].dispose();
-    const moduleRouteIds = this.moduleRouteIds(id);
+  addModule<T extends ModuleType>(params: ICreateModule<T>) {
+    const module = createModule(this.id, params as ModuleParams);
+    this.modules.set(module.id, module);
 
-    moduleRouteIds.forEach((routeId) => delete this.routes[routeId]);
-    this.updateRoutes();
-    delete this.modules[id];
-
-    return moduleRouteIds;
+    return module.serialize();
   }
 
-  updateModule(params: UpdateModuleProps) {
-    const {
-      id,
-      changes: { name, numberOfVoices, props = {} },
-    } = params;
-    const audioModule = this.findById(id);
+  updateModule<T extends ModuleType>(params: IUpdateModule<T>) {
+    const module = this.findModule(params.id);
+    if (module.moduleType !== params.moduleType) {
+      throw Error(
+        `The module id ${params.id} isn't moduleType ${params.moduleType}`,
+      );
+    }
 
-    audioModule.props = props;
-    if (name) audioModule.name = name;
-    if (audioModule instanceof PolyModule && numberOfVoices)
-      audioModule.numberOfVoices = numberOfVoices;
+    const updates = pick(params.changes, ["name", "props"]);
+    Object.assign(module, updates);
 
-    if (numberOfVoices) this.updateRoutes();
+    if (module instanceof PolyModule && params.changes.voices !== undefined) {
+      module.voices = params.changes.voices;
+    }
 
-    return audioModule.serialize();
+    return module.serialize();
   }
 
-  onPropsUpdate(callback: (id: string, props: AnyObject) => void) {
-    this.propsUpdateCallbacks.push(callback);
+  removeModule(id: string) {
+    this.modules.delete(id);
   }
 
-  _triggerPropsUpdate(id: string, props: AnyObject) {
-    this.propsUpdateCallbacks.forEach((callback) => callback(id, props));
+  addRoute(props: ICreateRoute): IRoute {
+    return this.routes.addRoute(props);
   }
 
-  addRoute(props: Optional<RouteInterface, "id">) {
-    if (!this.validRoute(props)) throw Error("Invalid route, incompatible IOs");
-    const route = createRoute(props);
-    const newRoutes = { ...this.routes, [route.id]: route };
-
-    this.routes = newRoutes;
-    this.updateRoutes();
-
-    return route;
+  removeRoute(id: string) {
+    this.routes.removeRoute(id);
   }
 
-  validRoute(props: Optional<RouteInterface, "id">): boolean {
-    const { sourceId, sourceIOId, destinationId, destinationIOId } = props;
+  validRoute(props: Optional<IRoute, "id">): boolean {
+    const { source, destination } = props;
 
-    const output = this.findById(sourceId).outputs.find(sourceIOId);
-    const input = this.findById(destinationId).inputs.find(destinationIOId);
+    const output = this.findIO(source.moduleId, source.ioName, "output");
+    const input = this.findIO(
+      destination.moduleId,
+      destination.ioName,
+      "input",
+    );
 
     return (
-      !!(output?.isMidi && input?.isMidi) ||
-      !!(output?.isAudio && input?.isAudio)
+      (output.isMidi() && input.isMidi()) ||
+      (output.isAudio() && input.isAudio())
     );
   }
 
-  removeRoute(id: string) {
-    delete this.routes[id];
-    this.updateRoutes();
+  start(props: { offset?: TTime; actionAt?: TTime } = {}) {
+    this.transport.start(props);
   }
 
-  triggerVirtualMidi(id: string, noteName: string, type: "noteOn" | "noteOff") {
-    const virtualMidi = this.findById(id) as VirtualMidi;
-
-    virtualMidi.sendMidi(MidiEvent.fromNote(noteName, type === "noteOn"));
+  stop(props: { actionAt?: TTime } = {}) {
+    this.transport.stop(props);
   }
 
-  dispose() {
-    Object.values(this.modules).forEach((m) => {
-      m.dispose();
-    });
-
-    this.modules = {};
-    this.routes = {};
+  pause(props: { actionAt?: TTime } = {}) {
+    this.transport.pause(props);
   }
 
-  findById(id: string): AudioModule {
-    const audioModule = this.modules[id];
-
-    if (!audioModule) throw Error(`Audio module with id ${id} not exists`);
-
-    return audioModule;
+  get bpm() {
+    return this.transport.bpm;
   }
 
-  get isStarted() {
-    return (
-      this.context !== undefined &&
-      this.context.transport.state === "started" &&
-      this._isStarted
-    );
+  set bpm(value: number) {
+    this.transport.bpm = value;
   }
 
-  start() {
-    const startTime = now();
-    this._isStarted = true;
-    this.updateRoutes();
-
-    Object.values(this.modules).forEach((audioModule) => {
-      const am = audioModule as unknown as Startable;
-      if (!am.start) return;
+  async resume() {
+    await this.context.resume();
+  }
 
-      am.start(startTime);
+  dispose() {
+    this.stop();
+    this.routes.clear();
+    this.modules.forEach((module) => {
+      module.dispose();
     });
+    this.modules.clear();
   }
 
-  stop() {
-    const startTime = now();
-    Object.values(this.modules).forEach((audioModule) => {
-      const am = audioModule as unknown as Startable;
-      if (!am.stop) return;
+  findModule(
+    id: string,
+  ): ModuleTypeToModuleMapping[keyof ModuleTypeToModuleMapping] {
+    const module = this.modules.get(id);
+    if (!module) throw Error(`The module with id ${id} is not exists`);
 
-      am.stop(startTime);
-    });
+    return module;
+  }
 
-    this._isStarted = false;
+  findIO(moduleId: string, ioName: string, type: "input" | "output") {
+    const module = this.findModule(moduleId);
+    return module[`${type}s`].findByName(ioName);
   }
 
-  get bpm() {
-    return this.context.transport.bpm.value;
+  findMidiDevice(id: string) {
+    return this.midiDeviceManager.find(id);
   }
 
-  set bpm(value: number) {
-    this.context.transport.bpm.value = value;
+  onPropsUpdate(callback: <T extends ModuleType>(params: IModule<T>) => void) {
+    this.propsUpdateCallbacks.push(callback);
   }
 
-  updateRoutes() {
-    applyRoutes(Object.values(this.routes));
+  _triggerPropsUpdate<T extends ModuleType>(params: IModule<T>) {
+    this.propsUpdateCallbacks.forEach((callback) => {
+      callback(params);
+    });
   }
 
-  private moduleRouteIds(id: string) {
-    const cloneRoutes = { ...this.routes };
+  // TODO: Find better way to support this
+  triggerVirtualMidi(id: string, noteName: string, type: "noteOn" | "noteOff") {
+    const virtualMidi = this.findModule(id);
+    if (virtualMidi.moduleType !== ModuleType.VirtualMidi)
+      throw Error("This is not a virtual mid");
 
-    const routeIds = Object.keys(cloneRoutes).filter((routeId) => {
-      const { sourceId, destinationId } = cloneRoutes[routeId];
+    virtualMidi.sendMidi(MidiEvent.fromNote(noteName, type === "noteOn"));
+  }
 
-      return sourceId === id || destinationId === id;
+  private onStart = (actionAt: TTime) => {
+    this.modules.forEach((module) => {
+      module.start(actionAt);
     });
+  };
 
-    return routeIds;
-  }
+  private onStop = (actionAt: TTime) => {
+    this.modules.forEach((module) => {
+      module.stop(actionAt);
+    });
+  };
 }
-
-export default Engine.getInstance();

package/src/core/IO/AudioIO.ts

@@ -0,0 +1,72 @@
+import { ModuleType } from "@/modules";
+import { Module } from "../module";
+import IO, { IOProps, IOType } from "./Base";
+import { PolyAudioInput, PolyAudioOutput } from "./PolyAudioIO";
+
+export type AudioIO = AudioInput | AudioOutput;
+
+export type AudioInputProps = IOProps & {
+  ioType: IOType.AudioInput;
+  getAudioNode: () => AudioNode | AudioParam | AudioDestinationNode;
+};
+
+export type AudioOutputProps = IOProps & {
+  ioType: IOType.AudioOutput;
+  getAudioNode: () => AudioNode;
+};
+
+export class AudioInput
+  extends IO<AudioOutput | PolyAudioOutput>
+  implements AudioInputProps
+{
+  declare ioType: IOType.AudioInput;
+  getAudioNode: AudioInputProps["getAudioNode"];
+
+  constructor(module: Module<ModuleType>, props: AudioInputProps) {
+    super(module, props);
+    this.getAudioNode = props.getAudioNode;
+  }
+}
+
+export class AudioOutput
+  extends IO<AudioInput | PolyAudioInput>
+  implements AudioOutputProps
+{
+  declare ioType: IOType.AudioOutput;
+  getAudioNode!: AudioOutputProps["getAudioNode"];
+
+  constructor(module: Module<ModuleType>, props: AudioOutputProps) {
+    super(module, props);
+    this.getAudioNode = props.getAudioNode;
+  }
+
+  plug(io: AudioInput | PolyAudioInput, plugOther = true) {
+    super.plug(io, plugOther);
+    if (io instanceof PolyAudioInput) return;
+
+    const input = io.getAudioNode();
+
+    if (input instanceof AudioParam) {
+      this.getAudioNode().connect(input);
+    } else {
+      this.getAudioNode().connect(input);
+    }
+  }
+
+  unPlug(io: AudioInput | PolyAudioInput, plugOther = true) {
+    super.unPlug(io, plugOther);
+    if (io instanceof PolyAudioInput) return;
+
+    const input = io.getAudioNode();
+
+    try {
+      if (input instanceof AudioParam) {
+        this.getAudioNode().disconnect(input);
+      } else {
+        this.getAudioNode().disconnect(input);
+      }
+    } catch {
+      // Ignore disconnect errors
+    }
+  }
+}

package/src/core/IO/Base.ts

@@ -0,0 +1,118 @@
+import { deterministicId } from "@blibliki/utils";
+import { ModuleType } from "@/modules";
+import { Module } from "../module";
+import { PolyModule } from "../module/PolyModule";
+import { AudioInput, AudioOutput } from "./AudioIO";
+import { MidiInput, MidiOutput } from "./MidiIO";
+import { PolyAudioInput, PolyAudioOutput } from "./PolyAudioIO";
+
+export type IOProps = {
+  name: string;
+  ioType: IOType;
+};
+
+export type IIOSerialize = IOProps & {
+  id: string;
+  moduleId: string;
+};
+
+export enum IOType {
+  AudioInput = "audioInput",
+  AudioOutput = "audioOutput",
+  PolyAudioInput = "polyAudioInput",
+  PolyAudioOutput = "polyAudioOutput",
+  MidiOutput = "midiOutput",
+  MidiInput = "midiInput",
+}
+
+export type IIO = {
+  id: string;
+  module: Module<ModuleType> | PolyModule<ModuleType>;
+} & IOProps;
+
+export abstract class Base implements IIO {
+  id: string;
+  ioType: IOType;
+  name: string;
+  module: Module<ModuleType> | PolyModule<ModuleType>;
+  connections: Base[];
+
+  constructor(
+    module: Module<ModuleType> | PolyModule<ModuleType>,
+    props: IOProps,
+  ) {
+    this.module = module;
+    this.name = props.name;
+    this.ioType = props.ioType;
+    this.id = deterministicId(this.module.id, this.name);
+    this.connections = [];
+  }
+
+  plug(io: Base, plugOther = true) {
+    this.connections.push(io);
+    if (plugOther) io.plug(this, false);
+  }
+
+  unPlug(io: Base, plugOther = true) {
+    this.connections = this.connections.filter(
+      (currentIO) => currentIO.id !== io.id,
+    );
+    if (plugOther) io.unPlug(this, false);
+  }
+
+  rePlugAll(callback?: () => void) {
+    const connections = this.connections;
+    this.unPlugAll();
+    if (callback) callback();
+
+    connections.forEach((otherIO) => {
+      this.plug(otherIO);
+    });
+  }
+
+  unPlugAll() {
+    this.connections.forEach((otherIO) => {
+      this.unPlug(otherIO);
+    });
+  }
+
+  isAudio(): this is
+    | AudioInput
+    | AudioOutput
+    | PolyAudioInput
+    | PolyAudioOutput {
+    return (
+      this.ioType === IOType.AudioInput ||
+      this.ioType === IOType.AudioOutput ||
+      this.ioType === IOType.PolyAudioInput ||
+      this.ioType === IOType.PolyAudioOutput
+    );
+  }
+
+  isMidi(): this is MidiInput | MidiOutput {
+    return (
+      this.ioType === IOType.MidiInput || this.ioType === IOType.MidiOutput
+    );
+  }
+
+  serialize(): IIOSerialize {
+    return {
+      id: this.id,
+      name: this.name,
+      ioType: this.ioType,
+      moduleId: this.module.id,
+    };
+  }
+}
+
+export default abstract class IO<Connection extends Base> extends Base {
+  declare connections: Connection[];
+
+  plug(io: Connection, plugOther?: boolean): void {
+    super.plug(io, plugOther);
+  }
+
+  unPlug(io: Connection, plugOther?: boolean): void {
+    super.unPlug(io, plugOther);
+  }
+}