@blibliki/engine 0.1.26 → 0.3.1

package/src/core/IO/Collection.ts

@@ -1,76 +1,152 @@
-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 { ForwardAudioInput, ForwardAudioOutput } from "./ForwardNode";
-
-export default class IOCollection<AnyIO extends IO> {
-  plugableModule: AudioModule;
-  collection: AnyIO[] = [];
-
-  constructor(plugableModule: AudioModule) {
-    this.plugableModule = plugableModule;
+import { assertNever } from "@blibliki/utils";
+import { ModuleType } from "@/modules";
+import { Module } from "../module";
+import { PolyModule } from "../module/PolyModule";
+import {
+  AudioInput,
+  AudioInputProps,
+  AudioOutput,
+  AudioOutputProps,
+} from "./AudioIO";
+import { Base, IOType } from "./Base";
+import {
+  MidiInput,
+  MidiInputProps,
+  MidiOutput,
+  MidiOutputProps,
+} from "./MidiIO";
+import {
+  PolyAudioInput,
+  PolyAudioInputProps,
+  PolyAudioOutput,
+  PolyAudioOutputProps,
+} from "./PolyAudioIO";
+
+export enum CollectionType {
+  Input = "Input",
+  Output = "Output",
+}
+
+type IMappedIOProps = {
+  [CollectionType.Input]:
+    | AudioInputProps
+    | PolyAudioInputProps
+    | MidiInputProps;
+  [CollectionType.Output]:
+    | AudioOutputProps
+    | PolyAudioOutputProps
+    | MidiOutputProps;
+};
+
+type IIOTypeTOClass = {
+  [IOType.AudioInput]: AudioInput;
+  [IOType.AudioOutput]: AudioOutput;
+  [IOType.PolyAudioInput]: PolyAudioInput;
+  [IOType.PolyAudioOutput]: PolyAudioOutput;
+  [IOType.MidiInput]: MidiInput;
+  [IOType.MidiOutput]: MidiOutput;
+};
+
+export default abstract class IOCollection<T extends CollectionType> {
+  module: Module<ModuleType> | PolyModule<ModuleType>;
+  collection: Base[] = [];
+  collectionType: T;
+
+  constructor(
+    collectionType: T,
+    module: Module<ModuleType> | PolyModule<ModuleType>,
+  ) {
+    this.collectionType = collectionType;
+    this.module = module;
   }
-  add<CurrentIO extends AnyIO>(props: IAnyIO): CurrentIO {
-    let io;
+
+  add<TT extends IMappedIOProps[T]>(props: TT): IIOTypeTOClass[TT["ioType"]] {
+    let io:
+      | AudioInput
+      | AudioOutput
+      | PolyAudioInput
+      | PolyAudioOutput
+      | MidiInput
+      | MidiOutput;
+    this.validateUniqName(props.name);
 
     switch (props.ioType) {
       case IOType.AudioInput:
-        if (this.plugableModule instanceof PolyModule) {
-          throw Error("PolyModule is not supported");
-        }
-
-        io = new AudioInput(this.plugableModule, props);
+        if (this.module instanceof PolyModule) throw Error("Not compatible");
+        io = new AudioInput(this.module, props);
         break;
       case IOType.AudioOutput:
-        if (this.plugableModule instanceof PolyModule) {
-          throw Error("PolyModule is not supported");
-        }
-
-        io = new AudioOutput(this.plugableModule, props);
+        if (this.module instanceof PolyModule) throw Error("Not compatible");
+        io = new AudioOutput(this.module, props);
         break;
-      case IOType.MidiInput:
-        io = new MidiInput(this.plugableModule, props);
+      case IOType.PolyAudioInput:
+        if (this.module instanceof Module) throw Error("Not compatible");
+        io = new PolyAudioInput(this.module, props);
         break;
-      case IOType.MidiOutput:
-        io = new MidiOutput(this.plugableModule, props);
+      case IOType.PolyAudioOutput:
+        if (this.module instanceof Module) throw Error("Not compatible");
+        io = new PolyAudioOutput(this.module, props);
         break;
-      case IOType.ForwardAudioInput:
-        if (this.plugableModule instanceof MonoModule) {
-          throw Error("MonoModule is not supported");
-        }
-
-        io = new ForwardAudioInput(this.plugableModule, props);
+      case IOType.MidiInput:
+        io = new MidiInput(this.module, props);
         break;
-      case IOType.ForwardAudioOutput:
-        if (this.plugableModule instanceof MonoModule) {
-          throw Error("MonoModule is not supported");
-        }
-
-        io = new ForwardAudioOutput(this.plugableModule, props);
+      case IOType.MidiOutput:
+        io = new MidiOutput(this.module, props);
         break;
       default:
-        throw Error("Unknown IOType");
+        assertNever(props);
     }
 
-    this.collection.push(io as unknown as CurrentIO);
-    return io as unknown as CurrentIO;
+    this.collection.push(io);
+
+    return io as IIOTypeTOClass[TT["ioType"]];
   }
 
   unPlugAll() {
-    this.collection.forEach((io) => io.unPlugAll());
+    this.collection.forEach((io) => {
+      io.unPlugAll();
+    });
+  }
+
+  rePlugAll(callback?: () => void) {
+    this.collection.forEach((io) => {
+      io.rePlugAll(callback);
+    });
   }
 
   find(id: string) {
-    return this.collection.find((io) => io.id === id);
+    const io = this.collection.find((io) => io.id === id);
+    if (!io) throw Error(`The io with id ${id} is not exists`);
+
+    return io;
   }
 
   findByName(name: string) {
-    return this.collection.find((io) => io.name === name);
+    const io = this.collection.find((io) => io.name === name);
+    if (!io) throw Error(`The io with name ${name} is not exists`);
+
+    return io;
   }
 
   serialize() {
     return this.collection.map((io) => io.serialize());
   }
+
+  private validateUniqName(name: string) {
+    if (this.collection.some((io) => io.name === name)) {
+      throw Error(`An io with name ${name} is already exists`);
+    }
+  }
+}
+
+export class InputCollection extends IOCollection<CollectionType.Input> {
+  constructor(module: Module<ModuleType> | PolyModule<ModuleType>) {
+    super(CollectionType.Input, module);
+  }
+}
+
+export class OutputCollection extends IOCollection<CollectionType.Output> {
+  constructor(module: Module<ModuleType> | PolyModule<ModuleType>) {
+    super(CollectionType.Output, module);
+  }
 }

package/src/core/IO/MidiIO.ts

@@ -0,0 +1,43 @@
+import { ModuleType } from "@/modules";
+import MidiEvent from "../midi/MidiEvent";
+import { Module } from "../module";
+import { PolyModule } from "../module/PolyModule";
+import IO, { IOProps, IOType } from "./Base";
+
+export type MidiIO = MidiInput | MidiOutput;
+
+export type MidiInputProps = IOProps & {
+  ioType: IOType.MidiInput;
+  onMidiEvent: (event: MidiEvent) => void;
+};
+
+export type MidiOutputProps = IOProps & {
+  ioType: IOType.MidiOutput;
+};
+
+export class MidiInput extends IO<MidiOutput> implements MidiInputProps {
+  declare ioType: IOType.MidiInput;
+  onMidiEvent: MidiInputProps["onMidiEvent"];
+
+  constructor(
+    module: Module<ModuleType> | PolyModule<ModuleType>,
+    props: MidiInputProps,
+  ) {
+    super(module, props);
+    this.onMidiEvent = props.onMidiEvent;
+  }
+}
+
+export class MidiOutput extends IO<MidiInput> implements MidiOutputProps {
+  declare ioType: IOType.MidiOutput;
+
+  onMidiEvent = (event: MidiEvent) => {
+    this.midiConnections.forEach((input) => {
+      input.onMidiEvent(event);
+    });
+  };
+
+  private get midiConnections() {
+    return this.connections.filter((input) => input instanceof MidiInput);
+  }
+}

package/src/core/IO/PolyAudioIO.ts

@@ -0,0 +1,115 @@
+import { ModuleType } from "@/modules";
+import { PolyModule } from "../module/PolyModule";
+import { AudioInput, AudioOutput } from "./AudioIO";
+import IO, { IOProps, IOType } from "./Base";
+
+export type PolyAudioIO = PolyAudioInput | PolyAudioOutput;
+
+export type PolyAudioInputProps = IOProps & {
+  ioType: IOType.PolyAudioInput;
+};
+
+export type PolyAudioOutputProps = IOProps & {
+  ioType: IOType.PolyAudioOutput;
+};
+
+export class PolyAudioInput
+  extends IO<PolyAudioOutput | AudioOutput>
+  implements PolyAudioInputProps
+{
+  declare ioType: IOType.PolyAudioInput;
+  declare module: PolyModule<ModuleType>;
+
+  plug(io: PolyAudioOutput | AudioOutput, plugOther = true) {
+    super.plug(io, plugOther);
+    if (!plugOther && io instanceof PolyAudioOutput) return;
+
+    plugOrUnplug(this, io, true);
+  }
+
+  unPlug(io: PolyAudioOutput | AudioOutput, plugOther = true) {
+    super.unPlug(io, plugOther);
+    if (!plugOther && io instanceof PolyAudioOutput) return;
+
+    plugOrUnplug(this, io, false);
+  }
+
+  findIOByVoice(voice: number): AudioInput {
+    return this.module
+      .findVoice(voice)
+      .inputs.findByName(this.name) as AudioInput;
+  }
+}
+
+export class PolyAudioOutput
+  extends IO<PolyAudioInput | AudioInput>
+  implements PolyAudioOutputProps
+{
+  declare ioType: IOType.PolyAudioOutput;
+  declare module: PolyModule<ModuleType>;
+
+  plug(io: PolyAudioInput | AudioInput, plugOther = true) {
+    super.plug(io, plugOther);
+    if (!plugOther && io instanceof PolyAudioInput) return;
+
+    plugOrUnplug(this, io, true);
+  }
+
+  unPlug(io: PolyAudioInput | AudioInput, plugOther = true) {
+    super.unPlug(io, plugOther);
+    if (!plugOther && io instanceof PolyAudioInput) return;
+
+    plugOrUnplug(this, io, false);
+  }
+
+  findIOByVoice(voice: number): AudioOutput {
+    return this.module
+      .findVoice(voice)
+      .outputs.findByName(this.name) as AudioOutput;
+  }
+}
+
+function plugOrUnplug(
+  thisIO: PolyAudioInput,
+  otherIO: PolyAudioOutput | AudioOutput,
+  isPlug: boolean,
+): void;
+function plugOrUnplug(
+  thisIO: PolyAudioOutput,
+  otherIO: PolyAudioInput | AudioInput,
+  isPlug: boolean,
+): void;
+function plugOrUnplug(
+  thisIO: PolyAudioInput | PolyAudioOutput,
+  otherIO: PolyAudioOutput | AudioOutput | PolyAudioInput | AudioInput,
+  isPlug: boolean,
+) {
+  if (otherIO instanceof PolyAudioInput || otherIO instanceof PolyAudioOutput) {
+    const maxVoices = Math.max(thisIO.module.voices, otherIO.module.voices);
+
+    for (let voice = 0; voice < maxVoices; voice++) {
+      const thisMonoIO = thisIO.findIOByVoice(voice % thisIO.module.voices);
+      const otherMonoIO = otherIO.findIOByVoice(voice % otherIO.module.voices);
+
+      if (isPlug) {
+        // @ts-expect-error: temp solution until guard this input plug to output
+        thisMonoIO.plug(otherMonoIO);
+      } else {
+        // @ts-expect-error: temp solution until guard this input plug to output
+        thisMonoIO.unPlug(otherMonoIO);
+      }
+    }
+  } else {
+    for (let voice = 0; voice < thisIO.module.voices; voice++) {
+      const thisMonoIO = thisIO.findIOByVoice(voice);
+
+      if (isPlug) {
+        // @ts-expect-error: temp solution until guard this input plug to output
+        thisMonoIO.plug(otherIO);
+      } else {
+        // @ts-expect-error: temp solution until guard this input plug to output
+        thisMonoIO.unPlug(otherIO);
+      }
+    }
+  }
+}

package/src/core/IO/index.ts

@@ -1,62 +1,8 @@
-import { default as IOCollection } from "./Collection";
-import { IIONode, IOType, IIOSerialize } from "./Node";
-import {
-  AudioInput,
-  AudioOutput,
-  IAudioInput,
-  IAudioOutput,
-} from "./AudioNode";
-import { IMidiInput, IMidiOutput, MidiInput, MidiOutput } from "./MidiNode";
-import {
-  ForwardAudioInput,
-  ForwardAudioOutput,
-  IForwardAudioInput,
-  IForwardAudioOutput,
-} from "./ForwardNode";
+export { InputCollection, OutputCollection } from "./Collection";
+export { AudioInput, AudioOutput } from "./AudioIO";
+export { MidiInput, MidiOutput } from "./MidiIO";
 
-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,
-  IOType,
-  AudioInput,
-  AudioOutput,
-  MidiInput,
-  MidiOutput,
-  ForwardAudioInput,
-  ForwardAudioOutput,
-};
-export type {
-  IAnyIO,
-  IIONode,
-  IAudioInput,
-  IAudioOutput,
-  IMidiInput,
-  IMidiOutput,
-  IForwardAudioInput,
-  IForwardAudioOutput,
-  IAnyInput,
-  IAnyOutput,
-  IIOSerialize,
-  AnyAudioInput,
-  AnyMidiInput,
-  AnyAudioOuput,
-  AnyMidiOuput,
-  AnyInput,
-  AnyOuput,
-  AnyIO,
-};
+export { IOType } from "./Base";
+export type { IIOSerialize } from "./Base";
+export type { AudioInputProps, AudioOutputProps } from "./AudioIO";
+export type { MidiInputProps, MidiOutputProps } from "./MidiIO";