@blibliki/engine 0.1.24 → 0.1.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blibliki/engine",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "source": "src/index.ts",
   "main": "dist/main.cjs.js",
   "module": "dist/main.esm.js",

package/src/Engine.ts

@@ -120,7 +120,7 @@ class Engine {
     if (audioModule instanceof PolyModule && numberOfVoices)
       audioModule.numberOfVoices = numberOfVoices;
 
-    //if (numberOfVoices) this.updateRoutes();
+    if (numberOfVoices) this.updateRoutes();
 
     return audioModule.serialize();
   }
@@ -134,6 +134,7 @@ class Engine {
   }
 
   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 };
 
@@ -143,6 +144,18 @@ class Engine {
     return route;
   }
 
+  validRoute(props: Optional<RouteInterface, "id">): boolean {
+    const { sourceId, sourceIOId, destinationId, destinationIOId } = props;
+
+    const output = this.findById(sourceId).outputs.find(sourceIOId);
+    const input = this.findById(destinationId).inputs.find(destinationIOId);
+
+    return (
+      !!(output?.isMidi && input?.isMidi) ||
+      !!(output?.isAudio && input?.isAudio)
+    );
+  }
+
   removeRoute(id: string) {
     delete this.routes[id];
     this.updateRoutes();

package/src/core/IO/AudioNode.ts

@@ -2,7 +2,8 @@ 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";
+import { ForwardAudioInput } from "./ForwardNode";
+import { AnyAudioInput, AnyAudioOuput } from ".";
 
 export type AudioIO = AudioInput | AudioOutput;
 
@@ -31,11 +32,11 @@ export class AudioInput extends IONode implements IAudioInput {
     this.internalModule = props.internalModule;
   }
 
-  plug(io: AudioOutput | ForwardOutput, plugOther: boolean = true) {
+  plug(io: AnyAudioOuput, plugOther: boolean = true) {
     super.plug(io, plugOther);
   }
 
-  unPlug(io: AudioOutput | ForwardOutput, plugOther: boolean = true) {
+  unPlug(io: AnyAudioOuput, plugOther: boolean = true) {
     super.unPlug(io, plugOther);
   }
 
@@ -57,16 +58,16 @@ export class AudioOutput extends IONode implements IAudioOutput {
     this.internalModule = props.internalModule;
   }
 
-  plug(io: AudioInput | ForwardInput, plugOther: boolean = true) {
+  plug(io: AnyAudioInput, plugOther: boolean = true) {
     super.plug(io, plugOther);
-    if (io instanceof ForwardInput) return;
+    if (io instanceof ForwardAudioInput) return;
 
     this.internalModule.connect(io.internalModule);
   }
 
-  unPlug(io: AudioInput | ForwardInput, plugOther: boolean = true) {
+  unPlug(io: AnyAudioInput, plugOther: boolean = true) {
     super.unPlug(io, plugOther);
-    if (io instanceof ForwardInput) return;
+    if (io instanceof ForwardAudioInput) return;
 
     try {
       this.internalModule.disconnect(io.internalModule);

package/src/core/IO/Collection.ts

@@ -3,7 +3,7 @@ import IO, { IOType } from "./Node";
 import { AudioInput, AudioOutput } from "./AudioNode";
 import { MidiInput, MidiOutput } from "./MidiNode";
 import { IAnyIO } from ".";
-import { ForwardInput, ForwardOutput } from "./ForwardNode";
+import { ForwardAudioInput, ForwardAudioOutput } from "./ForwardNode";
 
 export default class IOCollection<AnyIO extends IO> {
   plugableModule: AudioModule;
@@ -30,25 +30,25 @@ export default class IOCollection<AnyIO extends IO> {
 
         io = new AudioOutput(this.plugableModule, props);
         break;
-      case IOType.ForwardInput:
+      case IOType.MidiInput:
+        io = new MidiInput(this.plugableModule, props);
+        break;
+      case IOType.MidiOutput:
+        io = new MidiOutput(this.plugableModule, props);
+        break;
+      case IOType.ForwardAudioInput:
         if (this.plugableModule instanceof MonoModule) {
           throw Error("MonoModule is not supported");
         }
 
-        io = new ForwardInput(this.plugableModule, props);
+        io = new ForwardAudioInput(this.plugableModule, props);
         break;
-      case IOType.ForwardOutput:
+      case IOType.ForwardAudioOutput:
         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);
+        io = new ForwardAudioOutput(this.plugableModule, props);
         break;
       default:
         throw Error("Unknown IOType");

package/src/core/IO/ForwardNode/Base.ts

@@ -0,0 +1,99 @@
+import IONode, { IIONode, plugCompatibleIO, unPlugCompatibleIO } from "../Node";
+
+import Module, { Connectable, PolyModule } from "../../Module";
+import { AnyObject } from "../../../types";
+import { AnyIO, ForwardAudioInput, ForwardAudioOutput } from "..";
+
+export default class ForwardBaseNode extends IONode {
+  declare plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>;
+
+  constructor(
+    plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>,
+    props: IIONode
+  ) {
+    super(plugableModule, props);
+    this.checkNameValidity();
+  }
+
+  get voices() {
+    return this.subModules.length;
+  }
+
+  get subModules() {
+    return this.plugableModule.audioModules;
+  }
+
+  subModule(voiceNo: number) {
+    const adjustedVoiceNo = voiceNo % this.voices;
+    const mod = this.subModules.find((m) => m.voiceNo === adjustedVoiceNo);
+    if (!mod) throw Error(`Submodule with voiceNo ${voiceNo} not found`);
+
+    return mod;
+  }
+
+  get subIOs() {
+    const ios: IONode[] = [];
+
+    for (let voice = 0; voice < this.voices; voice++) {
+      ios.push(this.subIO(voice));
+    }
+
+    return ios;
+  }
+
+  subIO(voiceNo: number) {
+    const ios = this.ioType.includes("Input")
+      ? this.subModule(voiceNo).inputs
+      : this.subModule(voiceNo).outputs;
+
+    const io = ios.findByName(this.name);
+    if (!io) throw Error(`Could not forward io ${this.name}`);
+
+    return io;
+  }
+
+  plug(io: AnyIO, plugOther: boolean = true) {
+    this.plugUnplug(io, plugOther, true);
+  }
+
+  unPlug(io: AnyIO, plugOther: boolean = true) {
+    this.plugUnplug(io, plugOther, false);
+  }
+
+  unPlugAll() {
+    IONode.unPlugAll(this);
+  }
+
+  private plugUnplug(io: AnyIO, plugOther: boolean, isPlug: boolean) {
+    isPlug ? super.plug(io, plugOther) : super.unPlug(io, plugOther);
+    if (
+      !plugOther &&
+      (io instanceof ForwardAudioOutput || io instanceof ForwardAudioInput)
+    )
+      return;
+
+    const plugCallback = isPlug ? plugCompatibleIO : unPlugCompatibleIO;
+
+    if (io instanceof ForwardAudioOutput || io instanceof ForwardAudioInput) {
+      const maxVoices = Math.max(this.voices, io.voices);
+
+      for (let voice = 0; voice < maxVoices; voice++) {
+        const thisIO = this.subIO(voice);
+        const otherIO = io.subIO(voice);
+
+        plugCallback(thisIO, otherIO);
+      }
+    } else {
+      for (let voice = 0; voice < this.voices; voice++) {
+        const thisIO = this.subIO(voice);
+        plugCallback(thisIO, io);
+      }
+    }
+  }
+
+  private checkNameValidity() {
+    const io = this.subIO(0);
+
+    if (!io) throw Error("You should forward to existing input");
+  }
+}

package/src/core/IO/ForwardNode/index.ts

@@ -0,0 +1,60 @@
+import { IOType, IIONode } from "../Node";
+import Module, { Connectable, PolyModule } from "../../Module";
+import { AnyObject } from "../../../types";
+import { AnyAudioInput, AnyAudioOuput, AnyInput, AnyOuput } from "..";
+import ForwardBaseNode from "./Base";
+
+export interface IForwardAudioInput extends IIONode {
+  ioType: IOType.ForwardAudioInput;
+}
+export interface IForwardAudioOutput extends IIONode {
+  ioType: IOType.ForwardAudioOutput;
+}
+
+export class ForwardAudioInput
+  extends ForwardBaseNode
+  implements IForwardAudioInput
+{
+  declare plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>;
+  declare ioType: IOType.ForwardAudioInput;
+  declare connections: AnyAudioOuput[];
+
+  constructor(
+    plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>,
+    props: IForwardAudioInput
+  ) {
+    super(plugableModule, props);
+  }
+
+  plug(io: AnyOuput, plugOther: boolean = true) {
+    super.plug(io, plugOther);
+  }
+
+  unPlug(io: AnyOuput, plugOther: boolean = true) {
+    super.unPlug(io, plugOther);
+  }
+}
+
+export class ForwardAudioOutput
+  extends ForwardBaseNode
+  implements IForwardAudioOutput
+{
+  declare plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>;
+  declare ioType: IOType.ForwardAudioOutput;
+  declare connections: AnyAudioInput[];
+
+  constructor(
+    plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>,
+    props: IForwardAudioOutput
+  ) {
+    super(plugableModule, props);
+  }
+
+  plug(io: AnyInput, plugOther: boolean = true) {
+    super.plug(io, plugOther);
+  }
+
+  unPlug(io: AnyInput, plugOther: boolean = true) {
+    super.unPlug(io, plugOther);
+  }
+}

package/src/core/IO/MidiNode.ts

@@ -1,6 +1,6 @@
+import { AnyMidiInput, AnyMidiOuput } from ".";
 import { AudioModule } from "../Module";
 import { MidiEvent } from "../midi";
-import { ForwardInput, ForwardOutput } from "./ForwardNode";
 import IONode, { IOType, IIONode } from "./Node";
 
 export interface IMidiInput extends IIONode {
@@ -22,11 +22,11 @@ export class MidiInput extends IONode implements IMidiInput {
     this.onMidiEvent = props.onMidiEvent;
   }
 
-  plug(io: MidiOutput | ForwardOutput, plugOther: boolean = true) {
+  plug(io: AnyMidiOuput, plugOther: boolean = true) {
     super.plug(io, plugOther);
   }
 
-  unPlug(io: MidiOutput | ForwardOutput, plugOther: boolean = true) {
+  unPlug(io: AnyMidiOuput, plugOther: boolean = true) {
     super.unPlug(io, plugOther);
   }
 
@@ -43,11 +43,11 @@ export class MidiOutput extends IONode implements IMidiOutput {
     super(plugableModule, props);
   }
 
-  plug(io: MidiInput | ForwardInput, plugOther: boolean = true) {
+  plug(io: AnyMidiInput, plugOther: boolean = true) {
     super.plug(io, plugOther);
   }
 
-  unPlug(io: MidiInput | ForwardOutput, plugOther: boolean = true) {
+  unPlug(io: AnyMidiInput, plugOther: boolean = true) {
     super.unPlug(io, plugOther);
   }
 

package/src/core/IO/Node.ts

@@ -1,14 +1,5 @@
 import { AudioModule } from "../Module";
-import {
-  AnyInput,
-  AnyOuput,
-  AudioInput,
-  AudioOutput,
-  ForwardInput,
-  ForwardOutput,
-  MidiInput,
-  MidiOutput,
-} from ".";
+import { AnyIO } from ".";
 import { deterministicId } from "../../utils";
 
 export interface IIONode {
@@ -29,48 +20,42 @@ export enum IOType {
   AudioOutput = "audioOutput",
   MidiInput = "midiInput",
   MidiOutput = "midiOutput",
-  ForwardInput = "forwardInput",
-  ForwardOutput = "forwardOutput",
+  ForwardAudioInput = "forwardAudioInput",
+  ForwardAudioOutput = "forwardAudioOutput",
 }
 
-export function plugCompatibleIO(input: AnyInput, output: AnyOuput) {
-  if (input instanceof AudioInput && output instanceof AudioOutput) {
-    input.plug(output);
-  } else if (input instanceof MidiInput && output instanceof MidiOutput) {
-    input.plug(output);
-  } else if (input instanceof ForwardInput && output instanceof ForwardOutput) {
-    input.plug(output);
-  } else if (input instanceof ForwardInput && output instanceof MidiOutput) {
-    input.plug(output);
-  } else if (input instanceof ForwardInput && output instanceof AudioOutput) {
-    input.plug(output);
-  } else if (input instanceof AudioInput && output instanceof ForwardOutput) {
-    input.plug(output);
-  } else if (input instanceof MidiInput && output instanceof ForwardOutput) {
-    input.plug(output);
-  } else {
-    throw Error("Input and output type is not compatible");
-  }
+const AudioIO = [
+  IOType.AudioInput,
+  IOType.AudioOutput,
+  IOType.ForwardAudioInput,
+  IOType.ForwardAudioOutput,
+];
+
+const MidiIO = [IOType.MidiInput, IOType.MidiOutput];
+
+const IOInputs = [
+  IOType.AudioInput,
+  IOType.MidiInput,
+  IOType.ForwardAudioInput,
+];
+const IOOutputs = [
+  IOType.AudioOutput,
+  IOType.MidiOutput,
+  IOType.ForwardAudioOutput,
+];
+
+export function plugCompatibleIO(io1: AnyIO, io2: AnyIO): void {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  io1.plug(io2);
 }
 
-export function unPlugCompatibleIO(input: AnyInput, output: AnyOuput) {
-  if (input instanceof AudioInput && output instanceof AudioOutput) {
-    input.unPlug(output);
-  } else if (input instanceof MidiInput && output instanceof MidiOutput) {
-    input.unPlug(output);
-  } else if (input instanceof ForwardInput && output instanceof ForwardOutput) {
-    input.unPlug(output);
-  } else if (input instanceof ForwardInput && output instanceof MidiOutput) {
-    input.unPlug(output);
-  } else if (input instanceof ForwardInput && output instanceof AudioOutput) {
-    input.unPlug(output);
-  } else if (input instanceof AudioInput && output instanceof ForwardOutput) {
-    input.unPlug(output);
-  } else if (input instanceof MidiInput && output instanceof ForwardOutput) {
-    input.unPlug(output);
-  } else {
-    throw Error("Input and output type is not compatible");
-  }
+export function unPlugCompatibleIO(io1: AnyIO, io2: AnyIO) {
+  if (!io1.connections.some((io) => io.id === io2.id)) return;
+
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  io1.unPlug(io2);
 }
 
 export default abstract class IONode implements IIONode {
@@ -103,6 +88,22 @@ export default abstract class IONode implements IIONode {
     if (plugOther) io.unPlug(this, false);
   }
 
+  get isInput() {
+    return IOInputs.indexOf(this.ioType) > -1;
+  }
+
+  get isOutput() {
+    return IOOutputs.indexOf(this.ioType) > -1;
+  }
+
+  get isAudio() {
+    return AudioIO.indexOf(this.ioType) > -1;
+  }
+
+  get isMidi() {
+    return MidiIO.indexOf(this.ioType) > -1;
+  }
+
   abstract unPlugAll(): void;
 
   serialize(): IIOSerialize {

package/src/core/IO/index.ts

@@ -8,17 +8,27 @@ import {
 } from "./AudioNode";
 import { IMidiInput, IMidiOutput, MidiInput, MidiOutput } from "./MidiNode";
 import {
-  ForwardInput,
-  ForwardOutput,
-  IForwardInput,
-  IForwardOutput,
+  ForwardAudioInput,
+  ForwardAudioOutput,
+  IForwardAudioInput,
+  IForwardAudioOutput,
 } from "./ForwardNode";
 
-type AnyInput = AudioInput | MidiInput | ForwardInput;
-type AnyOuput = AudioOutput | MidiOutput | ForwardOutput;
-type IAnyInput = IAudioInput | IMidiInput | IForwardInput;
-type IAnyOutput = IAudioOutput | IMidiOutput | IForwardOutput;
-type IAnyIO = IAnyInput | IAnyOutput | IForwardOutput;
+type AnyAudioInput = AudioInput | ForwardAudioInput;
+type AnyMidiInput = MidiInput;
+type AnyAudioOuput = AudioOutput | ForwardAudioOutput;
+type AnyMidiOuput = MidiOutput;
+type AnyInput = AnyAudioInput | AnyMidiInput;
+type AnyOuput = AnyAudioOuput | AnyMidiOuput;
+type AnyIO = AnyInput | AnyOuput;
+
+type IAnyAudioInput = IAudioInput | IForwardAudioInput;
+type IAnyMidiInput = IMidiInput;
+type IAnyAudioOuput = IAudioOutput | IForwardAudioOutput;
+type IAnyMidiOuput = IMidiOutput;
+type IAnyInput = IAnyAudioInput | IAnyMidiInput;
+type IAnyOutput = IAnyAudioOuput | IAnyMidiOuput;
+type IAnyIO = IAnyInput | IAnyOutput;
 
 export {
   IOCollection,
@@ -27,8 +37,8 @@ export {
   AudioOutput,
   MidiInput,
   MidiOutput,
-  ForwardInput,
-  ForwardOutput,
+  ForwardAudioInput,
+  ForwardAudioOutput,
 };
 export type {
   IAnyIO,
@@ -37,11 +47,16 @@ export type {
   IAudioOutput,
   IMidiInput,
   IMidiOutput,
-  IForwardInput,
-  IForwardOutput,
+  IForwardAudioInput,
+  IForwardAudioOutput,
   IAnyInput,
   IAnyOutput,
   IIOSerialize,
+  AnyAudioInput,
+  AnyMidiInput,
+  AnyAudioOuput,
+  AnyMidiOuput,
   AnyInput,
   AnyOuput,
+  AnyIO,
 };

package/src/core/Module/PolyModule.ts

@@ -3,19 +3,23 @@ import { v4 as uuidv4 } from "uuid";
 import Module, { Connectable } from "./MonoModule";
 import {
   IOCollection,
-  ForwardInput,
-  ForwardOutput,
   IOType,
   IMidiInput,
   IMidiOutput,
-  IForwardInput,
-  IForwardOutput,
   MidiOutput,
   MidiInput,
+  AnyInput,
+  AnyOuput,
+  ForwardAudioInput,
 } from "../IO";
 import { AudioModule } from "./index";
 import { plugCompatibleIO } from "../IO/Node";
 import { deterministicId } from "../../utils";
+import {
+  ForwardAudioOutput,
+  IForwardAudioInput,
+  IForwardAudioOutput,
+} from "../IO/ForwardNode";
 
 interface PolyModuleInterface<MonoAudioModule, PropsInterface> {
   id?: string;
@@ -43,8 +47,8 @@ export default abstract class PolyModule<
   }) => MonoAudioModule;
   _name: string;
   audioModules: MonoAudioModule[];
-  inputs: IOCollection<ForwardInput | MidiInput>;
-  outputs: IOCollection<ForwardOutput | MidiOutput>;
+  inputs: IOCollection<AnyInput>;
+  outputs: IOCollection<AnyOuput>;
   private _numberOfVoices: number;
 
   constructor(params: PolyModuleInterface<MonoAudioModule, PropsInterface>) {
@@ -58,8 +62,8 @@ export default abstract class PolyModule<
     Object.assign(this, basicProps);
 
     this.numberOfVoices = params.numberOfVoices || 1;
-    this.inputs = new IOCollection<ForwardInput>(this);
-    this.outputs = new IOCollection<ForwardOutput>(this);
+    this.inputs = new IOCollection<AnyInput>(this);
+    this.outputs = new IOCollection<AnyOuput>(this);
 
     Object.assign(this, { props: extraProps });
   }
@@ -147,14 +151,16 @@ export default abstract class PolyModule<
     return this.audioModules.find((m) => m.voiceNo === voiceNo);
   }
 
-  protected registerInput(props: Omit<IForwardInput, "ioType">): ForwardInput {
-    return this.inputs.add({ ...props, ioType: IOType.ForwardInput });
+  protected registerForwardAudioInput(
+    props: Omit<IForwardAudioInput, "ioType">
+  ): ForwardAudioInput {
+    return this.inputs.add({ ...props, ioType: IOType.ForwardAudioInput });
   }
 
-  protected registerOutput(
-    props: Omit<IForwardOutput, "ioType">
-  ): ForwardOutput {
-    return this.outputs.add({ ...props, ioType: IOType.ForwardOutput });
+  protected registerForwardAudioOutput(
+    props: Omit<IForwardAudioOutput, "ioType">
+  ): ForwardAudioOutput {
+    return this.outputs.add({ ...props, ioType: IOType.ForwardAudioOutput });
   }
 
   protected registerMidiInput(props: Omit<IMidiInput, "ioType">): MidiInput {
@@ -166,11 +172,15 @@ export default abstract class PolyModule<
   }
 
   protected registerBasicOutputs() {
-    this.registerOutput({ name: "output" });
+    this.registerForwardAudioOutput({ name: "output" });
   }
 
   protected registerBasicInputs() {
-    this.registerInput({ name: "input" });
+    this.registerForwardAudioInput({ name: "input" });
+    this.registerMidiIn();
+  }
+
+  protected registerMidiIn() {
     this.registerMidiInput({
       name: "midi in",
       onMidiEvent: this.onMidiEvent,

package/src/modules/Filter.ts

@@ -34,7 +34,7 @@ class MonoFilter extends Module<InternalFilter, FilterInterface> {
       props: { ...InitialProps, ...props },
     });
 
-    this._cutoff = new Add(this.cutoff);
+    this._cutoff = new Add();
     this._cutoff.connect(this.internalModule.frequency);
 
     this._amount = new Multiply();
@@ -143,6 +143,6 @@ export default class Filter extends PolyModule<MonoFilter, FilterInterface> {
 
   private registerOutputs() {
     this.registerBasicOutputs();
-    this.registerInput({ name: "cutoff" });
+    this.registerForwardAudioInput({ name: "cutoff" });
   }
 }

package/src/modules/LFO.ts

@@ -110,7 +110,6 @@ class MonoLFO extends Module<LFOInternal, LFOInterface> implements Startable {
   };
 
   private registerInputs() {
-    this.registerDefaultMidiInput();
     this.registerAudioInput({
       name: "amount",
       internalModule: this.internalModule.amplitude,
@@ -136,8 +135,8 @@ export default class LFO extends PolyModule<MonoLFO, LFOInterface> {
     });
 
     this.registerBasicOutputs();
-    this.registerInput({ name: "midi in" });
-    this.registerInput({ name: "amount" });
+    this.registerMidiIn();
+    this.registerForwardAudioInput({ name: "amount" });
   }
 
   start(time: number) {

package/src/modules/Oscillator.ts

@@ -171,7 +171,6 @@ class MonoOscillator
   }
 
   private registerInputs() {
-    this.registerDefaultMidiInput();
     this.registerAudioInput({
       name: "fine",
       internalModule: this.fineSingal,
@@ -200,8 +199,8 @@ export default class Oscillator extends PolyModule<
     });
 
     this.registerBasicOutputs();
-    this.registerInput({ name: "midi in" });
-    this.registerInput({ name: "fine" });
+    this.registerMidiIn();
+    this.registerForwardAudioInput({ name: "fine" });
   }
 
   start(time: number) {