@blibliki/engine 0.1.25 → 0.1.27

package/dist/{build → src}/modules/Volume.d.ts

@@ -1,6 +1,7 @@
-import { Volume as Vol } from "tone";
-import Module, { PolyModule } from "../core/Module";
-import Note from "../core/Note";
+import { default as Note } from '../core/Note';
+import { default as Module, PolyModule } from '../core/Module';
+import { Volume as Vol } from 'tone';
+
 export interface VolumeInterface {
     volume: number;
 }

package/dist/src/modules/index.d.ts

@@ -0,0 +1,18 @@
+import { AudioModule } from '../core/Module';
+
+export { default as Master } from './Master';
+export { default as Filter } from './Filter';
+export { default as Oscillator, MonoOscillator } from './Oscillator';
+export { default as VirtualMidi } from './VirtualMidi';
+export { default as VoiceScheduler } from './VoiceScheduler';
+export { default as Sequencer } from './Sequencer';
+export type { ISequence } from './Sequencer';
+export { Envelope, AmpEnvelope, FreqEnvelope, EnvelopeStages, } from './Envelope';
+export interface ICreateModule {
+    id?: string;
+    name: string;
+    numberOfVoices?: number;
+    type: string;
+    props: any;
+}
+export declare function createModule(params: ICreateModule): AudioModule;

package/dist/{build → src}/routes.d.ts

@@ -1,4 +1,5 @@
-import { Optional } from "./types";
+import { Optional } from './types';
+
 export interface RouteProps {
     sourceId: string;
     sourceIOId: string;

package/dist/test/MockingModules.d.ts

@@ -0,0 +1,22 @@
+import { default as Module, PolyModule } from '../src/core/Module';
+
+interface IMonoMocking {
+}
+export declare class MockInternalModule {
+    connect(): void;
+    disconnect(): void;
+    dispose(): void;
+}
+export declare class MonoMocking extends Module<MockInternalModule, IMonoMocking> {
+    constructor(params: {
+        name: string;
+        props: Partial<IMonoMocking>;
+    });
+}
+export declare class PolyMocking extends PolyModule<MonoMocking, IMonoMocking> {
+    constructor(params: {
+        name: string;
+        props: Partial<IMonoMocking>;
+    });
+}
+export {};

package/dist/test/Module/Oscillator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/core/IO.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,46 +1,45 @@
 {
   "name": "@blibliki/engine",
-  "version": "0.1.25",
+  "version": "0.1.27",
+  "type": "module",
   "source": "src/index.ts",
-  "main": "dist/main.cjs.js",
-  "module": "dist/main.esm.js",
-  "types": "dist/build/index.d.ts",
+  "main": "dist/index.umd.cjs",
+  "module": "dist/index.js",
+  "types": "dist/src/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"
   },
   "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/lodash": "^4.14.186",
     "@types/node": "^16.7.13",
     "@types/uuid": "^8.3.4",
     "@typescript-eslint/eslint-plugin": "^6.9.0",
     "@typescript-eslint/parser": "^6.9.0",
+    "@vitest/browser": "^1.5.2",
     "eslint": "^8.52.0",
-    "jest": "^29.2.2",
     "prettier": "^2.7.1",
-    "rollup": "^4.10.0",
-    "ts-jest": "^29.0.3",
     "typescript": "^5.2.2",
-    "typescript-language-server": "^4.0.0"
+    "vite": "^5.2.10",
+    "vite-plugin-dts": "^3.9.0",
+    "vitest": "^1.5.2",
+    "webdriverio": "^8.36.1"
   },
   "scripts": {
-    "start": "tsc -w -p tsconfig.json",
-    "build": "rollup -c",
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview",
     "lint": "eslint src",
     "tsc": "tsc --noEmit",
-    "test": "jest"
+    "test": "vitest"
   }
 }

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,
 };