@blibliki/engine 0.1.27 → 0.3.2

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

@@ -1,99 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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,67 +0,0 @@
-import { AnyMidiInput, AnyMidiOuput } from ".";
-import { AudioModule } from "../Module";
-import { MidiEvent } from "../midi";
-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: AnyMidiOuput, plugOther: boolean = true) {
-    super.plug(io, plugOther);
-  }
-
-  unPlug(io: AnyMidiOuput, 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: AnyMidiInput, plugOther: boolean = true) {
-    super.plug(io, plugOther);
-  }
-
-  unPlug(io: AnyMidiInput, 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);
-  }
-}

package/src/core/IO/Node.ts

@@ -1,118 +0,0 @@
-import { AudioModule } from "../Module";
-import { AnyIO } from ".";
-import { deterministicId } from "../../utils";
-
-export interface IIONode {
-  name: string;
-  ioType: IOType;
-}
-
-export interface IIOSerialize {
-  id: string;
-  name: string;
-  ioType: IOType;
-  moduleId: string;
-  moduleName: string;
-}
-
-export enum IOType {
-  AudioInput = "audioInput",
-  AudioOutput = "audioOutput",
-  MidiInput = "midiInput",
-  MidiOutput = "midiOutput",
-  ForwardAudioInput = "forwardAudioInput",
-  ForwardAudioOutput = "forwardAudioOutput",
-}
-
-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(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 {
-  id: string;
-  ioType!: IOType;
-  name!: string;
-  plugableModule: AudioModule;
-  connections: IONode[] = [];
-
-  static unPlugAll(io: IONode): void {
-    io.connections.forEach((otherIO) => io.unPlug(otherIO));
-  }
-
-  constructor(plugableModule: AudioModule, props: IIONode) {
-    this.plugableModule = plugableModule;
-    this.id = deterministicId(plugableModule.id, props.name);
-
-    Object.assign(this, props);
-  }
-
-  plug(io: IONode, plugOther: boolean = true) {
-    this.connections.push(io);
-    if (plugOther) io.plug(this, false);
-  }
-
-  unPlug(io: IONode, plugOther: boolean = true) {
-    this.connections = this.connections.filter(
-      (currentIO) => currentIO.id !== io.id
-    );
-    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 {
-    return {
-      id: this.id,
-      name: this.name,
-      moduleId: this.plugableModule.id,
-      moduleName: this.plugableModule.name,
-      ioType: this.ioType,
-    };
-  }
-}

package/src/core/Module/MonoModule.ts

@@ -1,219 +0,0 @@
-import { v4 as uuidv4 } from "uuid";
-import { InputNode, Time } from "tone";
-
-import {
-  IOCollection,
-  AudioInput,
-  AudioOutput,
-  MidiInput,
-  IMidiInput,
-  IAudioInput,
-  IAudioOutput,
-  IOType,
-  MidiOutput,
-  IMidiOutput,
-} from "../IO";
-import { MidiEvent } from "../../core/midi";
-import { AudioModule } from "./index";
-import Note from "../../core/Note";
-import { plugCompatibleIO } from "../IO/Node";
-import { AtLeast } from "../../types";
-
-export interface Startable {
-  start(time: number): void;
-  stop(time: number): void;
-}
-
-export interface Connectable {
-  connect: (inputNode: InputNode) => void;
-  disconnect: (inputNode?: InputNode) => void;
-  dispose: () => void;
-}
-
-export interface Triggerable {
-  triggerAttack: (note: Note, triggeredAt: number) => void;
-  triggerRelease: (note: Note, triggeredAt: number) => void;
-}
-
-export interface ModuleInterface<PropsInterface> {
-  id: string;
-  name: string;
-  props: PropsInterface;
-  voiceNo?: number;
-}
-
-export class DummnyInternalModule implements Connectable {
-  connect() {
-    throw Error("This module is not connectable");
-  }
-
-  disconnect() {
-    throw Error("This module is not connectable");
-  }
-
-  dispose() {
-    // do nothing
-  }
-}
-
-abstract class Module<InternalModule extends Connectable, PropsInterface>
-  implements ModuleInterface<PropsInterface>
-{
-  static readonly moduleName: string;
-
-  readonly id: string;
-  name: string;
-  internalModule: InternalModule;
-  inputs: IOCollection<AudioInput | MidiInput>;
-  outputs: IOCollection<AudioOutput | MidiOutput>;
-  readonly voiceNo?: number;
-  updatedAt: Date;
-  _props: PropsInterface = {} as PropsInterface;
-
-  constructor(
-    internalModule: InternalModule,
-    props: AtLeast<ModuleInterface<PropsInterface>, "name">
-  ) {
-    this.internalModule = internalModule;
-    this.id = props.id || uuidv4();
-    delete props.id;
-
-    this.inputs = new IOCollection<AudioInput | MidiInput>(this);
-    this.outputs = new IOCollection<AudioOutput | MidiOutput>(this);
-
-    Object.assign(this, props);
-  }
-
-  set props(value: PropsInterface) {
-    if (!value) return;
-
-    this.updatedAt = new Date();
-
-    Object.assign(this, value);
-  }
-
-  get props() {
-    return this._props;
-  }
-
-  plug(audioModule: AudioModule, from: string, to: string) {
-    const output = this.outputs.findByName(from);
-    if (!output) throw Error(`Output ${from} not exist`);
-
-    const input = audioModule.inputs.findByName(to);
-    if (!input) throw Error(`Input ${to} not exist`);
-
-    plugCompatibleIO(input, output);
-  }
-
-  unPlugAll() {
-    this.outputs.unPlugAll();
-  }
-
-  dispose() {
-    this.inputs.unPlugAll();
-    this.outputs.unPlugAll();
-    this.internalModule.dispose();
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  triggerAttack = (note: Note, triggeredAt: number): void => {
-    throw Error("triggerAttack not implemented");
-  };
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  triggerRelease = (note: Note, triggeredAt: number): void => {
-    throw Error("triggerRelease not implemented");
-  };
-
-  onMidiEvent = (midiEvent: MidiEvent) => {
-    if (midiEvent.voiceNo !== undefined && midiEvent.voiceNo !== this.voiceNo)
-      return;
-
-    const { note, triggeredAt } = midiEvent;
-
-    switch (midiEvent.type) {
-      case "noteOn": {
-        const { duration } = note;
-
-        this.triggerer(this.triggerAttack, note, triggeredAt);
-
-        if (duration) {
-          const releaseTriggeredAt = triggeredAt + Time(duration).toSeconds();
-
-          this.triggerer(this.triggerRelease, note, releaseTriggeredAt);
-        }
-        break;
-      }
-      case "noteOff":
-        this.triggerer(this.triggerRelease, note, triggeredAt);
-        break;
-      default:
-        throw Error("This type is not a note");
-    }
-  };
-
-  private triggerer(
-    trigger: (note: Note, triggeredAt: number) => void,
-    note: Note,
-    triggeredAt: number
-  ) {
-    trigger(note, triggeredAt);
-  }
-
-  serialize() {
-    const klass = this.constructor as typeof Module;
-
-    return {
-      id: this.id,
-      name: this.name,
-      type: klass.moduleName,
-      props: this.props,
-      inputs: this.inputs.serialize(),
-      outputs: this.outputs.serialize(),
-    };
-  }
-
-  protected registerMidiInput(props: Omit<IMidiInput, "ioType">): MidiInput {
-    return this.inputs.add({ ...props, ioType: IOType.MidiInput });
-  }
-
-  protected registerAudioInput(props: Omit<IAudioInput, "ioType">): AudioInput {
-    return this.inputs.add({ ...props, ioType: IOType.AudioInput });
-  }
-
-  protected registerMidiOutput(props: Omit<IMidiOutput, "ioType">): MidiOutput {
-    return this.outputs.add({ ...props, ioType: IOType.MidiOutput });
-  }
-
-  protected registerAudioOutput(
-    props: Omit<IAudioOutput, "ioType">
-  ): AudioOutput {
-    return this.outputs.add({ ...props, ioType: IOType.AudioOutput });
-  }
-
-  protected registerBasicOutputs() {
-    this.registerAudioOutput({
-      name: "output",
-      internalModule: this.internalModule,
-    });
-  }
-
-  protected registerBasicInputs() {
-    this.registerAudioInput({
-      name: "input",
-      internalModule: this.internalModule as unknown as InputNode,
-    });
-
-    this.registerDefaultMidiInput();
-  }
-
-  protected registerDefaultMidiInput() {
-    this.registerMidiInput({
-      name: "midi in",
-      onMidiEvent: this.onMidiEvent,
-    });
-  }
-}
-
-export default Module;