@blibliki/engine 0.1.17 → 0.1.19

package/package.json

@@ -1,42 +1,46 @@
 {
   "name": "@blibliki/engine",
-  "version": "0.1.17",
-  "main": "build/index.js",
-  "types": "build/index.d.ts",
+  "version": "0.1.19",
+  "main": "dist/main.cjs.js",
+  "module": "dist/main.esm.js",
+  "types": "dist/build/index.d.ts",
+  "files": [
+    "README.md",
+    "src",
+    "dist"
+  ],
   "dependencies": {
     "@types/lodash": "^4.14.186",
+    "crypto-js": "^4.2.0",
     "lodash": "^4.17.21",
     "tone": "^14.7.77",
     "uuid": "^8.3.2"
   },
   "scripts": {
     "start": "tsc -w -p tsconfig.json",
-    "build": "rm -rf build && tsc"
-  },
-  "eslintConfig": {
-    "extends": []
-  },
-  "browserslist": {
-    "production": [
-      ">0.2%",
-      "not dead",
-      "not op_mini all"
-    ],
-    "development": [
-      "last 1 chrome version",
-      "last 1 firefox version",
-      "last 1 safari version"
-    ]
+    "build": "rollup -c",
+    "lint": "eslint src",
+    "ts:check": "tsc --noEmit",
+    "test": "jest"
   },
   "devDependencies": {
+    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^11.1.6",
+    "@types/crypto-js": "^4.2.2",
     "@types/jest": "^29.2.0",
     "@types/node": "^16.7.13",
     "@types/uuid": "^8.3.4",
-    "eslint": "^8.18.0",
+    "@typescript-eslint/eslint-plugin": "^6.9.0",
+    "@typescript-eslint/parser": "^6.9.0",
+    "eslint": "^8.52.0",
     "jest": "^29.2.2",
     "prettier": "^2.7.1",
+    "rollup": "^4.10.0",
+    "rollup-plugin-dts": "^6.1.0",
     "ts-jest": "^29.0.3",
-    "typescript": "^4.7.4",
-    "typescript-language-server": "^0.11.1"
+    "typescript": "^5.2.2",
+    "typescript-language-server": "^4.0.0"
   }
 }

package/src/Engine.ts

@@ -1,12 +1,10 @@
 import { Context, now, setContext } from "tone";
-import MidiDeviceManager from "./MidiDeviceManager";
-import MidiEvent, { EType } from "./MidiEvent";
+import { MidiEvent, MidiDeviceManager } from "./core/midi";
 
-import { AudioModule, createModule } from "./Module";
-import Master from "./Module/Master";
-import VirtualMidi from "./Module/VirtualMidi";
-import VoiceScheduler from "./Module/VoiceScheduler";
-import { applyRoutes, createRoute, RouteInterface, RouteProps } from "./routes";
+import { AudioModule, Startable } from "./core/Module";
+import { createModule, VirtualMidi, VoiceScheduler } from "./modules";
+import { applyRoutes, createRoute, RouteInterface } from "./routes";
+import { AnyObject, Optional } from "./types";
 
 type LatencyHint = "interactive" | "playback" | "balanced";
 
@@ -22,10 +20,9 @@ interface InitializeInterface {
 class Engine {
   midiDeviceManager: MidiDeviceManager;
   private static instance: Engine;
-  private _master: Master;
   private context: Context;
-  private propsUpdateCallbacks: { (id: string, props: any): void }[];
-  private _isStarted: boolean = false;
+  private propsUpdateCallbacks: { (id: string, props: AnyObject): void }[];
+  private _isStarted = false;
 
   modules: {
     [Identifier: string]: AudioModule;
@@ -51,7 +48,7 @@ class Engine {
 
   initialize(props: InitializeInterface) {
     return new Promise((resolve) => {
-      if (this.context) return resolve({ master: this.master });
+      if (this.context) return resolve({});
 
       this.context = new Context(props.context);
       setContext(this.context);
@@ -60,15 +57,20 @@ class Engine {
       this.midiDeviceManager = new MidiDeviceManager();
 
       setTimeout(() => {
-        resolve({ master: this.master });
+        resolve({});
       }, 0);
     });
   }
 
-  addModule(params: { name: string; type: string; props?: any }) {
-    const { name, type, props = {} } = params;
+  addModule(params: {
+    id?: string;
+    name: string;
+    type: string;
+    props?: AnyObject;
+  }) {
+    const { id, name, type, props = {} } = params;
 
-    const audioModule = createModule(name, type, {});
+    const audioModule = createModule({ id, name, type, props: {} });
     audioModule.props = props;
     this.modules[audioModule.id] = audioModule;
 
@@ -95,15 +97,15 @@ class Engine {
     return audioModule.serialize();
   }
 
-  onPropsUpdate(callback: (id: string, props: any) => void) {
+  onPropsUpdate(callback: (id: string, props: AnyObject) => void) {
     this.propsUpdateCallbacks.push(callback);
   }
 
-  _triggerPropsUpdate(id: string, props: any) {
+  _triggerPropsUpdate(id: string, props: AnyObject) {
     this.propsUpdateCallbacks.forEach((callback) => callback(id, props));
   }
 
-  updatePropsModule(id: string, props: any) {
+  updatePropsModule(id: string, props: AnyObject) {
     const audioModule = this.findById(id);
 
     const applyRoutesRequired = this.applyRoutesRequired(audioModule, props);
@@ -113,7 +115,7 @@ class Engine {
     return audioModule.serialize();
   }
 
-  addRoute(props: RouteProps) {
+  addRoute(props: Optional<RouteInterface, "id">) {
     const route = createRoute(props);
     const newRoutes = { ...this.routes, [route.id]: route };
 
@@ -128,29 +130,18 @@ class Engine {
     this.updateRoutes();
   }
 
-  get master() {
-    if (this._master) return this._master.serialize();
-
-    const masterProps = this.addModule({ name: "Master", type: "Master" });
-    this._master = this.modules[masterProps.id] as Master;
-
-    return masterProps;
-  }
-
-  triggerVirtualMidi(id: string, noteName: string, type: EType) {
+  triggerVirtualMidi(id: string, noteName: string, type: "noteOn" | "noteOff") {
     const virtualMidi = this.findById(id) as VirtualMidi;
 
-    virtualMidi.sendMidi(MidiEvent.fromNote(noteName, type));
+    virtualMidi.sendMidi(MidiEvent.fromNote(noteName, type === "noteOn"));
   }
 
   dispose() {
     Object.values(this.modules).forEach((m) => {
-      if (m instanceof Master) return;
-
       m.dispose();
     });
 
-    this.modules = this._master ? { [this._master.id]: this._master } : {};
+    this.modules = {};
     this.routes = {};
   }
 
@@ -176,7 +167,7 @@ class Engine {
     this.updateRoutes();
 
     Object.values(this.modules).forEach((audioModule) => {
-      const am = audioModule as any;
+      const am = audioModule as unknown as Startable;
       if (!am.start) return;
 
       am.start(startTime);
@@ -186,7 +177,7 @@ class Engine {
   stop() {
     const startTime = now();
     Object.values(this.modules).forEach((audioModule) => {
-      const am = audioModule as any;
+      const am = audioModule as unknown as Startable;
       if (!am.stop) return;
 
       am.stop(startTime);
@@ -207,7 +198,7 @@ class Engine {
     applyRoutes(Object.values(this.routes));
   }
 
-  private applyRoutesRequired(audioModule: AudioModule, props: any) {
+  private applyRoutesRequired(audioModule: AudioModule, props: AnyObject) {
     if (!props.polyNumber) return false;
     if (!(audioModule instanceof VoiceScheduler)) return false;
 

package/src/core/IO/AudioNode.ts

@@ -0,0 +1,77 @@
+import { InputNode } from "tone";
+import IONode, { IOType, IIONode } from "./Node";
+import MonoModule, { Connectable } from "../Module/index";
+import { AnyObject } from "../../types";
+import { ForwardInput, ForwardOutput } from "./ForwardNode";
+
+export type AudioIO = AudioInput | AudioOutput;
+
+export interface IAudioInput extends IIONode {
+  ioType: IOType.AudioInput;
+  internalModule: InputNode;
+}
+
+export interface IAudioOutput extends IIONode {
+  ioType: IOType.AudioOutput;
+  internalModule: IInternalModule;
+}
+
+interface IInternalModule extends Connectable {}
+
+export class AudioInput extends IONode implements IAudioInput {
+  declare ioType: IOType.AudioInput;
+  internalModule!: InputNode;
+  declare connections: AudioOutput[];
+
+  constructor(
+    plugableModule: MonoModule<Connectable, AnyObject>,
+    props: IAudioInput
+  ) {
+    super(plugableModule, props);
+    this.internalModule = props.internalModule;
+  }
+
+  plug(io: AudioOutput | ForwardOutput, plugOther: boolean = true) {
+    super.plug(io, plugOther);
+  }
+
+  unPlug(io: AudioOutput | ForwardOutput, plugOther: boolean = true) {
+    super.unPlug(io, plugOther);
+  }
+
+  unPlugAll() {
+    IONode.unPlugAll(this);
+  }
+}
+
+export class AudioOutput extends IONode implements IAudioOutput {
+  declare ioType: IOType.AudioOutput;
+  internalModule!: IInternalModule;
+  declare connections: AudioInput[];
+
+  constructor(
+    plugableModule: MonoModule<Connectable, AnyObject>,
+    props: IAudioOutput
+  ) {
+    super(plugableModule, props);
+    this.internalModule = props.internalModule;
+  }
+
+  plug(io: AudioInput | ForwardInput, plugOther: boolean = true) {
+    super.plug(io, plugOther);
+    if (io instanceof ForwardInput) return;
+
+    this.internalModule.connect(io.internalModule);
+  }
+
+  unPlug(io: AudioInput | ForwardInput, plugOther: boolean = true) {
+    super.unPlug(io, plugOther);
+    if (io instanceof ForwardInput) return;
+
+    this.internalModule.disconnect(io.internalModule);
+  }
+
+  unPlugAll() {
+    IONode.unPlugAll(this);
+  }
+}

package/src/core/IO/Collection.ts

@@ -0,0 +1,76 @@
+import MonoModule, { AudioModule, PolyModule } from "../Module";
+import IO, { IOType } from "./Node";
+import { AudioInput, AudioOutput } from "./AudioNode";
+import { MidiInput, MidiOutput } from "./MidiNode";
+import { IAnyIO } from ".";
+import { ForwardInput, ForwardOutput } from "./ForwardNode";
+
+export default class IOCollection<AnyIO extends IO> {
+  plugableModule: AudioModule;
+  collection: AnyIO[] = [];
+
+  constructor(plugableModule: AudioModule) {
+    this.plugableModule = plugableModule;
+  }
+  add<CurrentIO extends AnyIO>(props: IAnyIO): CurrentIO {
+    let io;
+
+    switch (props.ioType) {
+      case IOType.AudioInput:
+        if (this.plugableModule instanceof PolyModule) {
+          throw Error("PolyModule is not supported");
+        }
+
+        io = new AudioInput(this.plugableModule, props);
+        break;
+      case IOType.AudioOutput:
+        if (this.plugableModule instanceof PolyModule) {
+          throw Error("PolyModule is not supported");
+        }
+
+        io = new AudioOutput(this.plugableModule, props);
+        break;
+      case IOType.ForwardInput:
+        if (this.plugableModule instanceof MonoModule) {
+          throw Error("MonoModule is not supported");
+        }
+
+        io = new ForwardInput(this.plugableModule, props);
+        break;
+      case IOType.ForwardOutput:
+        if (this.plugableModule instanceof MonoModule) {
+          throw Error("MonoModule is not supported");
+        }
+
+        io = new ForwardOutput(this.plugableModule, props);
+        break;
+      case IOType.MidiInput:
+        io = new MidiInput(this.plugableModule, props);
+        break;
+      case IOType.MidiOutput:
+        io = new MidiOutput(this.plugableModule, props);
+        break;
+      default:
+        throw Error("Unknown IOType");
+    }
+
+    this.collection.push(io as unknown as CurrentIO);
+    return io as unknown as CurrentIO;
+  }
+
+  unPlugAll() {
+    this.collection.forEach((io) => io.unPlugAll());
+  }
+
+  find(id: string) {
+    return this.collection.find((io) => io.id === id);
+  }
+
+  findByName(name: string) {
+    return this.collection.find((io) => io.name === name);
+  }
+
+  serialize() {
+    return this.collection.map((io) => io.serialize());
+  }
+}

package/src/core/IO/ForwardNode.ts

@@ -0,0 +1,192 @@
+import IONode, {
+  IOType,
+  IIONode,
+  plugCompatibleIO,
+  unPlugCompatibleIO,
+} from "./Node";
+import Module, { Connectable, PolyModule } from "../Module";
+import { AnyObject } from "../../types";
+import { AnyInput, AnyOuput } from ".";
+
+export interface IForwardInput extends IIONode {
+  ioType: IOType.ForwardInput;
+}
+export interface IForwardOutput extends IIONode {
+  ioType: IOType.ForwardOutput;
+}
+
+export class ForwardInput extends IONode implements IForwardInput {
+  declare plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>;
+  declare ioType: IOType.ForwardInput;
+  declare connections: ForwardOutput[];
+
+  constructor(
+    plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>,
+    props: IForwardInput
+  ) {
+    super(plugableModule, props);
+    this.checkNameValidity();
+  }
+
+  get subInputs() {
+    return this.plugableModule.audioModules.map((am) => {
+      const input = am.inputs.findByName(this.name);
+      if (!input) throw Error(`Could not forward input ${this.name}`);
+
+      return input;
+    });
+  }
+
+  get subModules() {
+    return this.plugableModule.audioModules;
+  }
+
+  subModule(voiceNo: number) {
+    const mod = this.subModules.find((m) => m.voiceNo === voiceNo);
+    if (!mod) throw Error(`Submodule with voiceNo ${voiceNo} not found`);
+
+    return mod;
+  }
+
+  subInput(voiceNo: number) {
+    const input = this.subModule(voiceNo).inputs.findByName(this.name);
+    if (!input) throw Error(`Could not forward input ${this.name}`);
+
+    return input;
+  }
+
+  plug(io: AnyOuput, plugOther: boolean = true) {
+    super.plug(io, plugOther);
+    if (!plugOther && io instanceof ForwardOutput) return;
+
+    if (io instanceof ForwardOutput) {
+      this.subModules.forEach((am) => {
+        const input = am.inputs.findByName(this.name);
+        if (!input) throw Error(`Could not forward input ${this.name}`);
+
+        const output = io.subOutput(am.voiceNo as number);
+        plugCompatibleIO(input, output);
+      });
+    } else {
+      this.subInputs.forEach((input) => plugCompatibleIO(input, io));
+    }
+  }
+
+  unPlug(io: AnyOuput, plugOther: boolean = true) {
+    super.unPlug(io, plugOther);
+    if (!plugOther && io instanceof ForwardOutput) return;
+
+    if (io instanceof ForwardOutput) {
+      this.subModules.forEach((am) => {
+        const input = am.inputs.findByName(this.name);
+        if (!input) throw Error(`Could not forward input ${this.name}`);
+
+        const output = io.subOutput(am.voiceNo as number);
+        unPlugCompatibleIO(input, output);
+      });
+    } else {
+      this.subInputs.forEach((input) => unPlugCompatibleIO(input, io));
+    }
+  }
+
+  unPlugAll() {
+    IONode.unPlugAll(this);
+  }
+
+  private checkNameValidity() {
+    const input = this.plugableModule.audioModules[0].inputs.findByName(
+      this.name
+    );
+
+    if (!input) throw Error("You should forward to existing input");
+  }
+}
+
+export class ForwardOutput extends IONode implements IForwardOutput {
+  declare plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>;
+  declare ioType: IOType.ForwardOutput;
+  declare connections: ForwardInput[];
+
+  constructor(
+    plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>,
+    props: IForwardOutput
+  ) {
+    super(plugableModule, props);
+    this.checkNameValidity();
+  }
+
+  get subOutputs() {
+    return this.subModules.map((am) => {
+      const output = am.outputs.findByName(this.name);
+      if (!output) throw Error(`Could not forward input ${this.name}`);
+
+      return output;
+    });
+  }
+
+  get subModules() {
+    return this.plugableModule.audioModules;
+  }
+
+  subModule(voiceNo: number) {
+    const mod = this.subModules.find((m) => m.voiceNo === voiceNo);
+    if (!mod) throw Error(`Submodule with voiceNo ${voiceNo} not found`);
+
+    return mod;
+  }
+
+  subOutput(voiceNo: number) {
+    const output = this.subModule(voiceNo).outputs.findByName(this.name);
+    if (!output) throw Error(`Could not forward input ${this.name}`);
+
+    return output;
+  }
+
+  plug(io: AnyInput, plugOther: boolean = true) {
+    super.plug(io, plugOther);
+    if (!plugOther && io instanceof ForwardInput) return;
+
+    if (io instanceof ForwardInput) {
+      this.subModules.forEach((am) => {
+        const output = am.outputs.findByName(this.name);
+        if (!output) throw Error(`Could not forward output ${this.name}`);
+
+        const input = io.subInput(am.voiceNo as number);
+
+        plugCompatibleIO(input, output);
+      });
+    } else {
+      this.subOutputs.forEach((output) => plugCompatibleIO(io, output));
+    }
+  }
+
+  unPlug(io: AnyInput, plugOther: boolean = true) {
+    super.unPlug(io, plugOther);
+    if (!plugOther && io instanceof ForwardInput) return;
+
+    if (io instanceof ForwardInput) {
+      this.subModules.forEach((am) => {
+        const output = am.outputs.findByName(this.name);
+        if (!output) throw Error(`Could not forward output ${this.name}`);
+
+        const input = io.subInput(am.voiceNo as number);
+
+        unPlugCompatibleIO(input, output);
+      });
+    } else {
+      this.subOutputs.forEach((output) => unPlugCompatibleIO(io, output));
+    }
+  }
+
+  unPlugAll() {
+    IONode.unPlugAll(this);
+  }
+
+  private checkNameValidity() {
+    const output = this.plugableModule.audioModules[0].outputs.findByName(
+      this.name
+    );
+
+    if (!output) throw Error("You should forward to existing output");
+  }
+}

package/src/core/IO/MidiNode.ts

@@ -0,0 +1,67 @@
+import { AudioModule } from "../Module";
+import { MidiEvent } from "../midi";
+import { ForwardInput, ForwardOutput } from "./ForwardNode";
+import IONode, { IOType, IIONode } from "./Node";
+
+export interface IMidiInput extends IIONode {
+  ioType: IOType.MidiInput;
+  onMidiEvent: (event: MidiEvent) => void;
+}
+export interface IMidiOutput extends IIONode {
+  ioType: IOType.MidiOutput;
+}
+
+export class MidiInput extends IONode implements IMidiInput {
+  declare ioType: IOType.MidiInput;
+  declare connections: MidiOutput[];
+  onMidiEvent: (event: MidiEvent) => void;
+
+  constructor(plugableModule: AudioModule, props: IMidiInput) {
+    super(plugableModule, props);
+
+    this.onMidiEvent = props.onMidiEvent;
+  }
+
+  plug(io: MidiOutput | ForwardOutput, plugOther: boolean = true) {
+    super.plug(io, plugOther);
+  }
+
+  unPlug(io: MidiOutput | ForwardOutput, plugOther: boolean = true) {
+    super.unPlug(io, plugOther);
+  }
+
+  unPlugAll() {
+    IONode.unPlugAll(this);
+  }
+}
+
+export class MidiOutput extends IONode implements IMidiOutput {
+  declare ioType: IOType.MidiOutput;
+  declare connections: MidiInput[];
+
+  constructor(plugableModule: AudioModule, props: IIONode) {
+    super(plugableModule, props);
+  }
+
+  plug(io: MidiInput | ForwardInput, plugOther: boolean = true) {
+    super.plug(io, plugOther);
+  }
+
+  unPlug(io: MidiInput | ForwardOutput, plugOther: boolean = true) {
+    super.unPlug(io, plugOther);
+  }
+
+  unPlugAll() {
+    IONode.unPlugAll(this);
+  }
+
+  onMidiEvent = (event: MidiEvent) => {
+    this.midiConnections.forEach((input) => {
+      input.onMidiEvent(event);
+    });
+  };
+
+  private get midiConnections() {
+    return this.connections.filter((input) => input instanceof MidiInput);
+  }
+}