@blibliki/engine 0.1.17 → 0.1.19

package/src/MidiEvent.ts

@@ -1,93 +0,0 @@
-import { now } from "tone";
-import { ISequence } from "./Module/Sequencer";
-import { IDataSequence } from "./Module/DataSequencer";
-import Note, { INote } from "./Note";
-
-const EventType: { [key: number]: EType } = {
-  8: "noteOff",
-  9: "noteOn",
-};
-
-export type EType = "noteOn" | "noteOff";
-
-export default class MidiEvent {
-  notes: Note[];
-  readonly triggeredAt: number;
-  _type: EType;
-  private data: Uint8Array;
-  private event: MIDIMessageEvent;
-
-  static fromDataSequence(sequence: IDataSequence, triggeredAt: number) {
-    const event = new MidiEvent(
-      new MIDIMessageEvent("", { data: new Uint8Array([0, 0, 0]) }),
-      triggeredAt
-    );
-    event._type = "noteOn";
-    const note = new Note(sequence.frequency);
-    note.velocity = sequence.amplitude;
-    event.notes = [note];
-
-    return event;
-  }
-
-  static fromSequence(sequence: ISequence, triggeredAt: number) {
-    const event = new MidiEvent(
-      new MIDIMessageEvent("", { data: new Uint8Array([0, 0, 0]) }),
-      triggeredAt
-    );
-    event._type = "noteOn";
-    event.notes = sequence.notes.map((n) => new Note(n));
-
-    return event;
-  }
-
-  static fromNote(
-    noteName: string | Note | INote,
-    type: EType,
-    triggeredAt?: number
-  ) {
-    const event = new MidiEvent(
-      new MIDIMessageEvent("", { data: new Uint8Array([0, 0, 0]) }),
-      triggeredAt
-    );
-
-    if (noteName instanceof Note) {
-      event.notes = [noteName];
-    } else {
-      event.notes = [new Note(noteName)];
-    }
-    event._type = type;
-
-    return event;
-  }
-
-  constructor(event: MIDIMessageEvent, triggeredAt?: number) {
-    this.event = event;
-    this.triggeredAt = triggeredAt || now();
-    this.data = event.data;
-    this.defineNotes();
-  }
-
-  get type() {
-    if (this._type) return this._type;
-
-    let type = EventType[this.data[0] >> 4];
-
-    if (type === "noteOn" && this.data[2] === 0) {
-      type = "noteOff";
-    }
-
-    return (this._type = type);
-  }
-
-  get isNote() {
-    return this.type === "noteOn" || this.type === "noteOff";
-  }
-
-  defineNotes() {
-    if (!this.isNote) return;
-    if (this.notes) return;
-
-    this.notes = [new Note(this.event)];
-  }
-}

package/src/Module/Base.ts

@@ -1,223 +0,0 @@
-import { v4 as uuidv4 } from "uuid";
-import { InputNode } from "tone";
-
-import { Input, Output, IOInterface } from "./IO";
-import MidiEvent from "../MidiEvent";
-import { AudioModule, PolyModule } from "../Module";
-import Note from "../Note";
-
-export interface Connectable {
-  connect: (inputNode: InputNode) => void;
-  disconnect: (inputNode?: InputNode) => void;
-  dispose: () => void;
-}
-
-export interface Triggerable {
-  triggerAttack: Function;
-  triggerRelease: Function;
-}
-
-export interface Voicable {
-  voiceNo?: number;
-}
-
-export interface ModuleInterface<PropsInterface> {
-  name: string;
-  props: PropsInterface;
-  voiceNo?: number;
-}
-
-export class DummnyInternalModule implements Connectable {
-  connect(inputNode: InputNode) {
-    throw Error("This module is not connectable");
-  }
-
-  disconnect(inputNode?: InputNode) {}
-
-  dispose() {}
-}
-
-class Module<InternalModule extends Connectable, PropsInterface>
-  implements ModuleInterface<PropsInterface>
-{
-  static readonly moduleName: string;
-
-  readonly id: string;
-  name: string;
-  internalModule: InternalModule;
-  inputs: Input[] = [];
-  outputs: Output[] = [];
-  readonly voiceNo?: number;
-  updatedAt: Date;
-  _props: PropsInterface = {} as PropsInterface;
-
-  constructor(
-    internalModule: InternalModule,
-    props: Partial<ModuleInterface<PropsInterface>>
-  ) {
-    this.internalModule = internalModule;
-    this.id = uuidv4();
-
-    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.find((i) => i.name === from);
-    if (!output) throw Error(`Output ${from} not exist`);
-
-    const input = audioModule.inputs.find((i) => i.name === to);
-    if (!input)
-      throw Error(`Input ${to} in module ${audioModule.name} not exist`);
-
-    output.plug(input);
-  }
-
-  unplugAll() {
-    this.outputs.forEach((o) => o.unPlugAll());
-  }
-
-  connect = (
-    inputAudioModule: AudioModule,
-    attribute: string = "internalModule"
-  ) => {
-    if (inputAudioModule instanceof PolyModule) {
-      inputAudioModule.audioModules.forEach((m) => {
-        this.internalModule.connect((m as any)[attribute] as InputNode);
-      });
-      return;
-    }
-
-    this.internalModule.connect(
-      (inputAudioModule as any)[attribute] as InputNode
-    );
-  };
-
-  disconnect = (
-    inputAudioModule: AudioModule,
-    attribute: string = "internalModule"
-  ) => {
-    if (inputAudioModule instanceof PolyModule) {
-      inputAudioModule.audioModules.forEach((m) => {
-        this.internalModule.disconnect((m as any)[attribute] as InputNode);
-      });
-      return;
-    }
-
-    this.internalModule.disconnect(
-      (inputAudioModule as any)[attribute] as InputNode
-    );
-  };
-
-  dispose() {
-    this.internalModule.dispose();
-  }
-
-  triggerAttack(note: Note, triggeredAt: number) {
-    throw Error("triggerAttack not implemented");
-  }
-
-  triggerRelease(note: Note, triggeredAt: number) {
-    throw Error("triggerRelease not implemented");
-  }
-
-  midiTriggered = (midiEvent: MidiEvent, noteIndex?: number) => {
-    const { notes, triggeredAt } = midiEvent;
-
-    switch (midiEvent.type) {
-      case "noteOn":
-        const { duration } = notes[0];
-
-        this.triggerer(this.triggerAttack, notes, triggeredAt, noteIndex);
-
-        if (duration) {
-          const releaseTriggeredAt =
-            triggeredAt + (this.internalModule as any).toSeconds(duration);
-          this.triggerer(
-            this.triggerRelease,
-            notes,
-            releaseTriggeredAt,
-            noteIndex
-          );
-        }
-        break;
-      case "noteOff":
-        this.triggerer(this.triggerRelease, notes, triggeredAt, noteIndex);
-        break;
-      default:
-        throw Error("This type is not a note");
-    }
-  };
-
-  private triggerer(
-    trigger: Function,
-    notes: Note[],
-    triggeredAt: number,
-    noteIndex?: number
-  ) {
-    if (noteIndex !== undefined && this.voiceNo !== undefined) {
-      trigger(notes[noteIndex], triggeredAt);
-      return;
-    }
-
-    notes.forEach((note) => 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.map((i) => i.serialize()),
-      outputs: this.outputs.map((i) => i.serialize()),
-    };
-  }
-
-  protected registerInput(props: IOInterface): Input {
-    const input = new Input(this, props);
-    this.inputs.push(input);
-
-    return input;
-  }
-
-  protected registerOutput(props: IOInterface): Output {
-    const output = new Output(this, props);
-    this.outputs.push(output);
-
-    return output;
-  }
-
-  protected registerBasicOutputs() {
-    this.registerOutput({
-      name: "output",
-      onPlug: (output: Output) => {
-        this.connect(output.audioModule);
-      },
-      onUnPlug: (output: Output) => {
-        this.disconnect(output.audioModule);
-      },
-    });
-  }
-
-  protected registerBasicInputs() {
-    this.registerInput({
-      name: "input",
-    });
-  }
-}
-
-export default Module;

package/src/Module/DataSequencer.ts

@@ -1,121 +0,0 @@
-import { Loop, now } from "tone";
-
-import Module, { DummnyInternalModule } from "./Base";
-import { Output } from "./IO";
-import MidiEvent from "../MidiEvent";
-import { sortBy, uniq } from "lodash";
-import Engine from "../Engine";
-
-interface IDataSequencer {
-  sequences: IDataSequence[];
-}
-
-export interface IDataSequence {
-  voiceNo: number;
-  time: number;
-  frequency: number;
-  amplitude: number;
-}
-
-const InitialProps = () => ({
-  sequences: [],
-});
-
-export default class DataSequencer extends Module<
-  DummnyInternalModule,
-  IDataSequencer
-> {
-  static moduleName = "DataSequencer";
-  private midiOutput: Output;
-  private prevNumberOfVoices: number;
-  private loop: Loop;
-
-  constructor(name: string, props: Partial<IDataSequence>) {
-    super(new DummnyInternalModule(), {
-      name,
-      props: { ...InitialProps(), ...props },
-    });
-
-    this.start(now());
-    this.registerOutputs();
-  }
-
-  get sequences() {
-    return this._props["sequences"];
-  }
-
-  set sequences(value: IDataSequence[]) {
-    const sequences = sortBy(value, (seq) => -seq.time);
-    this._props = { ...this.props, sequences };
-    this.updateNumberOfVoices();
-    this.start(now());
-  }
-
-  start(time: number) {
-    if (!Engine.isStarted) return;
-    Engine.updateRoutes();
-
-    const loopLength = 0.1;
-    const tempSequences = [...this.sequences];
-    const iterate = (maxTime: number) => {
-      const sequence = tempSequences.pop();
-      if (!sequence) return;
-
-      const seqTime = time + sequence.time;
-      this.onPartEvent(seqTime, sequence);
-      if (seqTime > maxTime) return;
-
-      iterate(maxTime);
-    };
-
-    this.loop = new Loop((t) => {
-      iterate(time + t + loopLength);
-    }, loopLength).start(time);
-  }
-
-  stop() {
-    if (!this.loop) return;
-
-    this.loop.stop();
-    this.loop.dispose();
-  }
-
-  private onPartEvent = (time: number, sequence: IDataSequence) => {
-    const { voiceNo } = sequence;
-    const event = MidiEvent.fromDataSequence(sequence, time);
-
-    this.midiOutput.connections.forEach((input) => {
-      input.pluggable(event, voiceNo);
-    });
-  };
-
-  private get numberOfVoices() {
-    return uniq(this.sequences.map((sequence) => sequence.voiceNo)).length;
-  }
-
-  private updateNumberOfVoices() {
-    if (!this.midiOutput) return;
-
-    this.midiOutput.connections.forEach((input) => {
-      if (input.audioModule instanceof Module) return;
-
-      input.audioModule.numberOfVoices = this.numberOfVoices;
-    });
-
-    if (this.prevNumberOfVoices !== this.numberOfVoices) {
-      Engine.updateRoutes();
-    }
-    this.prevNumberOfVoices = this.numberOfVoices;
-  }
-
-  private registerOutputs() {
-    this.midiOutput = this.registerOutput({
-      name: "midi out",
-      onPlug: (input) => {
-        if (input.audioModule instanceof Module) return;
-
-        input.audioModule.numberOfVoices = this.numberOfVoices;
-      },
-    });
-  }
-}

package/src/Module/Envelope/AmpEnvelope.ts

@@ -1,17 +0,0 @@
-import { AmplitudeEnvelope } from "tone";
-
-import Base, { EnvelopeInterface, PolyBase } from "./Base";
-
-class MonoAmpEnvelope extends Base<AmplitudeEnvelope> {
-  constructor(name: string, props: EnvelopeInterface) {
-    super(name, new AmplitudeEnvelope(), props);
-  }
-}
-
-export default class AmpEnvelope extends PolyBase<MonoAmpEnvelope> {
-  static moduleName = "AmpEnvelope";
-
-  constructor(name: string, props: Partial<EnvelopeInterface>) {
-    super(name, MonoAmpEnvelope, props);
-  }
-}

package/src/Module/IO.ts

@@ -1,85 +0,0 @@
-import { v4 as uuidv4 } from "uuid";
-import { AudioModule } from "../Module";
-
-export interface IOInterface {
-  name: string;
-  pluggable?: any;
-  onPlug?: (io: IO) => void;
-  onUnPlug?: (io: IO) => void;
-}
-
-export interface SerializeInterface {
-  id: string;
-  name: string;
-  moduleId: string;
-  moduleName: string;
-}
-
-enum IOType {
-  Input = "input",
-  Output = "output",
-}
-
-abstract class IO {
-  id: string;
-  ioType: IOType;
-  name: string;
-  audioModule: AudioModule;
-  pluggable: any;
-  onPlug: (io: IO) => void;
-  onUnPlug: (io: IO) => void;
-  connections: Input[] | Output[] = [];
-
-  constructor(ioType: IOType, audioModule: AudioModule, props: IOInterface) {
-    this.id = uuidv4();
-    this.ioType = ioType;
-    this.audioModule = audioModule;
-
-    Object.assign(this, props);
-  }
-
-  plug(io: IO) {
-    this.connections.push(io);
-
-    if (this.onPlug) this.onPlug(io);
-
-    if (this.ioType === IOType.Output) io.plug(this);
-  }
-
-  unPlug(io: IO) {
-    if (this.onUnPlug) this.onUnPlug(io);
-
-    if (this.ioType === IOType.Output) {
-      io.unPlug(this);
-    }
-
-    this.connections = this.connections.filter(
-      (current_io) => current_io.id !== io.id
-    );
-  }
-
-  unPlugAll() {
-    this.connections.forEach((c) => this.unPlug(c));
-  }
-
-  serialize(): SerializeInterface {
-    return {
-      id: this.id,
-      name: this.name,
-      moduleId: this.audioModule.id,
-      moduleName: this.audioModule.name,
-    };
-  }
-}
-
-export class Input extends IO {
-  constructor(audioModule: AudioModule, props: IOInterface) {
-    super(IOType.Input, audioModule, props);
-  }
-}
-
-export class Output extends IO {
-  constructor(audioModule: AudioModule, props: IOInterface) {
-    super(IOType.Output, audioModule, props);
-  }
-}