@blibliki/engine 0.1.17 → 0.1.18

package/src/core/IO/Node.ts

@@ -0,0 +1,117 @@
+import { AudioModule } from "../Module";
+import {
+  AnyInput,
+  AnyOuput,
+  AudioInput,
+  AudioOutput,
+  ForwardInput,
+  ForwardOutput,
+  MidiInput,
+  MidiOutput,
+} 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",
+  ForwardInput = "forwardInput",
+  ForwardOutput = "forwardOutput",
+}
+
+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");
+  }
+}
+
+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 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);
+  }
+
+  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/IO/index.ts

@@ -0,0 +1,47 @@
+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 {
+  ForwardInput,
+  ForwardOutput,
+  IForwardInput,
+  IForwardOutput,
+} 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;
+
+export {
+  IOCollection,
+  IOType,
+  AudioInput,
+  AudioOutput,
+  MidiInput,
+  MidiOutput,
+  ForwardInput,
+  ForwardOutput,
+};
+export type {
+  IAnyIO,
+  IIONode,
+  IAudioInput,
+  IAudioOutput,
+  IMidiInput,
+  IMidiOutput,
+  IForwardInput,
+  IForwardOutput,
+  IAnyInput,
+  IAnyOutput,
+  IIOSerialize,
+  AnyInput,
+  AnyOuput,
+};

package/src/core/Module/MonoModule.ts

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

package/src/core/Module/PolyModule.ts

@@ -0,0 +1,206 @@
+import { MidiEvent } from "../midi";
+import { v4 as uuidv4 } from "uuid";
+import Module, { Connectable } from "./MonoModule";
+import {
+  IOCollection,
+  ForwardInput,
+  ForwardOutput,
+  IOType,
+  IMidiInput,
+  IMidiOutput,
+  IForwardInput,
+  IForwardOutput,
+  MidiOutput,
+  MidiInput,
+} from "../IO";
+import { AudioModule } from "./index";
+import { plugCompatibleIO } from "../IO/Node";
+import { deterministicId } from "../../utils";
+
+interface PolyModuleInterface<MonoAudioModule, PropsInterface> {
+  id?: string;
+  name: string;
+  child: new (params: {
+    id?: string;
+    name: string;
+    props: PropsInterface;
+  }) => MonoAudioModule;
+  props: PropsInterface;
+}
+
+export default abstract class PolyModule<
+  MonoAudioModule extends Module<Connectable, PropsInterface>,
+  PropsInterface
+> {
+  static readonly moduleName: string;
+
+  readonly id: string;
+  readonly child: new (params: {
+    id?: string;
+    name: string;
+    props: PropsInterface;
+  }) => MonoAudioModule;
+  _name: string;
+  audioModules: MonoAudioModule[];
+  inputs: IOCollection<ForwardInput | MidiInput>;
+  outputs: IOCollection<ForwardOutput | MidiOutput>;
+  private _numberOfVoices: number;
+
+  constructor(params: PolyModuleInterface<MonoAudioModule, PropsInterface>) {
+    this.id = params.id || uuidv4();
+    delete params.id;
+
+    this.audioModules = [];
+
+    const { child, props: extraProps, ...basicProps } = params;
+    this.child = child;
+    Object.assign(this, basicProps);
+
+    this.numberOfVoices = 1;
+    this.inputs = new IOCollection<ForwardInput>(this);
+    this.outputs = new IOCollection<ForwardOutput>(this);
+
+    Object.assign(this, { props: extraProps });
+  }
+
+  get name() {
+    return this._name;
+  }
+
+  set name(value: string) {
+    this._name = value;
+    this.audioModules.forEach((m) => (m.name = value));
+  }
+
+  get props() {
+    if (this.audioModules.length === 0) {
+      throw Error("There isn't any initialized module");
+    }
+
+    return this.audioModules[0].props;
+  }
+
+  set props(value: PropsInterface) {
+    Object.assign(this, value);
+    this.audioModules.forEach((m) => (m.props = value));
+  }
+
+  get numberOfVoices() {
+    return this._numberOfVoices;
+  }
+
+  set numberOfVoices(value: number) {
+    this._numberOfVoices = value;
+    this.adjustNumberOfModules();
+  }
+
+  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.unPlugAll();
+    this.audioModules.forEach((m) => m.dispose());
+  }
+
+  onMidiEvent = (midiEvent: MidiEvent) => {
+    const voiceNo = midiEvent.voiceNo || 0;
+    const audioModule = this.findVoice(voiceNo);
+    audioModule?.onMidiEvent(midiEvent);
+  };
+
+  serialize() {
+    if (this.audioModules.length === 0)
+      throw Error("There isn't any initialized module");
+
+    const klass = this.constructor as typeof PolyModule;
+
+    return {
+      ...this.audioModules[0].serialize(),
+      id: this.id,
+      type: klass.moduleName,
+      inputs: this.inputs.serialize(),
+      outputs: this.outputs.serialize(),
+    };
+  }
+
+  protected find(callback: (audioModule: MonoAudioModule) => boolean) {
+    const audioModule = this.audioModules.find(callback);
+    if (!audioModule) throw Error(`Audio module not found`);
+
+    return audioModule;
+  }
+
+  protected findVoice(voiceNo: number) {
+    return this.audioModules.find((m) => m.voiceNo === voiceNo);
+  }
+
+  protected registerInput(props: Omit<IForwardInput, "ioType">): ForwardInput {
+    return this.inputs.add({ ...props, ioType: IOType.ForwardInput });
+  }
+
+  protected registerOutput(
+    props: Omit<IForwardOutput, "ioType">
+  ): ForwardOutput {
+    return this.outputs.add({ ...props, ioType: IOType.ForwardOutput });
+  }
+
+  protected registerMidiInput(props: Omit<IMidiInput, "ioType">): MidiInput {
+    return this.inputs.add({ ...props, ioType: IOType.MidiInput });
+  }
+
+  protected registerMidiOutput(props: Omit<IMidiOutput, "ioType">): MidiOutput {
+    return this.outputs.add({ ...props, ioType: IOType.MidiOutput });
+  }
+
+  protected registerBasicOutputs() {
+    this.registerOutput({ name: "output" });
+  }
+
+  protected registerBasicInputs() {
+    this.registerInput({ name: "input" });
+    this.registerMidiInput({
+      name: "midi in",
+      onMidiEvent: this.onMidiEvent,
+    });
+  }
+
+  private adjustNumberOfModules() {
+    if (this.audioModules.length === this.numberOfVoices) return;
+
+    if (this.audioModules.length > this.numberOfVoices) {
+      const audioModule = this.audioModules.pop();
+      audioModule?.dispose();
+    } else {
+      const voiceNo = this.audioModules.length;
+      const id = deterministicId(this.id, voiceNo.toString());
+      const props = voiceNo === 0 ? ({} as PropsInterface) : this.props;
+      const audioModule = new this.child({
+        id,
+        name: this.name,
+        props: {
+          ...props,
+          voiceNo,
+        },
+      });
+
+      if (audioModule instanceof PolyModule) {
+        throw Error("Polymodule not supported");
+      }
+
+      this.audioModules.push(audioModule);
+    }
+
+    this.adjustNumberOfModules();
+  }
+}

package/src/core/Module/index.ts

@@ -0,0 +1,15 @@
+import Module, { Connectable } from "./MonoModule";
+import PolyModule from "./PolyModule";
+
+export { default, DummnyInternalModule } from "./MonoModule";
+export { default as PolyModule } from "./PolyModule";
+export type {
+  ModuleInterface,
+  Connectable,
+  Triggerable,
+  Startable,
+} from "./MonoModule";
+
+export type AudioModule =
+  | Module<Connectable, any>
+  | PolyModule<Module<Connectable, any>, any>;

package/src/{Note → core/Note}/index.ts

@@ -4,6 +4,8 @@ const Notes = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
 
 const NotesLength = Notes.length;
 
+const MIDI_OCTAVE_SYTSTEM = 2;
+
 export interface INote {
   note: string;
   frequency: number;
@@ -15,7 +17,7 @@ export default class Note {
   static _notes: Note[];
   name: string;
   octave: number;
-  velocity: number = 1;
+  velocity = 1;
   duration: string;
   frequency: number;
 
@@ -33,7 +35,7 @@ export default class Note {
     }
   }
 
-  static notes(octave: number = 3) {
+  static notes(octave = 3) {
     return Notes.map((note: string) => new Note(`${note}${octave}`));
   }
 
@@ -45,11 +47,24 @@ export default class Note {
     return `${this.name}${this.octave}`;
   }
 
-  adjustFrequency(range: number = 0, coarse: number = 0) {
+  midiData(noteOn: boolean = true): Uint8Array {
+    const statusByte = noteOn ? 0x90 : 0x80;
+    return new Uint8Array([statusByte, 0, this.velocity * 100]);
+  }
+
+  get midiNumber(): number {
+    return (this.octave + MIDI_OCTAVE_SYTSTEM) * 12 + this.noteIndex;
+  }
+
+  get noteIndex(): number {
+    return Notes.indexOf(this.name);
+  }
+
+  adjustFrequency(range = 0, coarse = 0) {
     if (this.frequency) return this.frequency;
 
     let newOctave = this.octave + range;
-    let coarseIndex = Notes.indexOf(this.name) + coarse;
+    const coarseIndex = Notes.indexOf(this.name) + coarse;
     let nameIndex = coarseIndex;
 
     if (coarseIndex >= NotesLength) {

package/src/{MidiDeviceManager.ts → core/midi/MidiDeviceManager.ts}

@@ -2,13 +2,15 @@ import MidiDevice from "./MidiDevice";
 
 export default class MidiDeviceManager {
   devices: { [Key: string]: MidiDevice } = {};
-  private initialized: boolean = false;
+  private initialized = false;
 
   constructor() {
-    this.initializeDevices().then(() => {
-      this.listenChanges();
-      this.initialized = true;
-    });
+    this.initializeDevices()
+      .then(() => {
+        this.listenChanges();
+        this.initialized = true;
+      })
+      .catch(() => {});
   }
 
   find(id: string): MidiDevice | null {
@@ -20,20 +22,23 @@ export default class MidiDeviceManager {
   }
 
   onStateChange(callback: (device: MidiDevice) => void) {
-    navigator.requestMIDIAccess().then((access: MIDIAccess) => {
-      access.onstatechange = (e) => {
-        const isMidiEvent = e instanceof MIDIConnectionEvent;
+    navigator
+      .requestMIDIAccess()
+      .then((access: MIDIAccess) => {
+        access.onstatechange = (e) => {
+          const isMidiEvent = e instanceof MIDIConnectionEvent;
 
-        if (!isMidiEvent) return;
-        if (e.port instanceof MIDIOutput) return;
+          if (!isMidiEvent) return;
+          if (e.port instanceof MIDIOutput) return;
 
-        const input = e.port as MIDIInput;
+          const input = e.port as MIDIInput;
 
-        const midi = new MidiDevice(input);
+          const midi = new MidiDevice(input);
 
-        callback(midi);
-      };
-    });
+          callback(midi);
+        };
+      })
+      .catch(() => {});
   }
 
   private listenChanges() {