@blibliki/engine 0.1.26 → 0.3.1

package/src/modules/LFO.ts

@@ -1,149 +0,0 @@
-import { now, LFO as LFOInternal, ToneOscillatorType } from "tone";
-import Engine from "../Engine";
-import Module, { PolyModule, Startable } from "../core/Module";
-import { TWave } from "./Oscillator";
-import Note from "../core/Note";
-
-export interface LFOInterface {
-  wave: TWave;
-  frequency: number;
-  min: number;
-  max: number;
-  amount: number;
-}
-
-const InitialProps: LFOInterface = {
-  wave: "sine",
-  frequency: 0.1,
-  min: 0,
-  max: 1,
-  amount: 1,
-};
-
-class MonoLFO extends Module<LFOInternal, LFOInterface> implements Startable {
-  constructor(params: {
-    id?: string;
-    name: string;
-    props: Partial<LFOInterface>;
-  }) {
-    const { id, name, props } = params;
-
-    super(new LFOInternal(), {
-      id,
-      name,
-      props: { ...InitialProps, ...props },
-    });
-
-    this.registerBasicOutputs();
-    this.registerInputs();
-    this.start(now());
-  }
-
-  get wave() {
-    return this._props["wave"];
-  }
-
-  set wave(value: TWave) {
-    this._props = { ...this.props, wave: value };
-    this.internalModule.type = this.wave as ToneOscillatorType;
-  }
-
-  get min() {
-    return this._props["min"];
-  }
-
-  set min(value: number) {
-    this._props = { ...this.props, min: value };
-    this.internalModule.min = this.min;
-  }
-
-  get max() {
-    return this._props["max"];
-  }
-
-  set max(value: number) {
-    this._props = { ...this.props, max: value };
-    this.internalModule.max = this.max;
-  }
-
-  get frequency() {
-    return this._props["frequency"];
-  }
-
-  set frequency(value: number) {
-    this._props = { ...this.props, frequency: value };
-    this.internalModule.frequency.value = this.frequency;
-  }
-
-  get amount() {
-    return this._props["amount"];
-  }
-
-  set amount(value: number) {
-    this._props = { ...this.props, amount: value };
-    this.internalModule.amplitude.value = this.amount;
-  }
-
-  start(time: number) {
-    if (!Engine.isStarted) return;
-
-    const oscState = this.internalModule.state;
-
-    if (oscState === "started") {
-      this.internalModule.stop(time - 2);
-      this.internalModule.start(time);
-    } else {
-      this.internalModule.start(time);
-    }
-  }
-
-  stop(time?: number) {
-    this.internalModule.stop(time);
-  }
-
-  triggerAttack = (_: Note, triggeredAt: number) => {
-    this.start(triggeredAt);
-  };
-
-  triggerRelease = () => {
-    // Do nothing
-  };
-
-  private registerInputs() {
-    this.registerAudioInput({
-      name: "amount",
-      internalModule: this.internalModule.amplitude,
-    });
-  }
-}
-
-export default class LFO extends PolyModule<MonoLFO, LFOInterface> {
-  static moduleName = "LFO";
-
-  constructor(params: {
-    id?: string;
-    name: string;
-    props: Partial<LFOInterface>;
-  }) {
-    const { id, name, props } = params;
-
-    super({
-      id,
-      name,
-      child: MonoLFO,
-      props: { ...InitialProps, ...props },
-    });
-
-    this.registerBasicOutputs();
-    this.registerMidiIn();
-    this.registerForwardAudioInput({ name: "amount" });
-  }
-
-  start(time: number) {
-    this.audioModules.forEach((audioModule) => audioModule.start(time));
-  }
-
-  stop(time?: number) {
-    this.audioModules.forEach((audioModule) => audioModule.stop(time));
-  }
-}

package/src/modules/Reverb.ts

@@ -1,53 +0,0 @@
-import { Reverb as InternalReverb } from "tone";
-
-import Effect, { EffectInterface } from "./Effect";
-
-interface ReverbInterface extends EffectInterface {
-  decay: number;
-  preDelay: number;
-}
-
-const InitialProps: Partial<ReverbInterface> = {
-  decay: 1.5,
-  preDelay: 0.025,
-};
-
-export default class Reverb extends Effect<InternalReverb, ReverbInterface> {
-  static moduleName = "Reverb";
-
-  constructor(params: {
-    id?: string;
-    name: string;
-    props: Partial<ReverbInterface>;
-  }) {
-    const { id, name, props } = params;
-
-    super({
-      id,
-      name,
-      internalModule: new InternalReverb(),
-      props: {
-        ...InitialProps,
-        ...props,
-      },
-    });
-  }
-
-  get decay() {
-    return this._props["decay"];
-  }
-
-  set decay(value: number) {
-    this._props = { ...this.props, decay: value };
-    this.internalModule.decay = this.decay;
-  }
-
-  get preDelay() {
-    return this._props["preDelay"];
-  }
-
-  set preDelay(value: number) {
-    this._props = { ...this.props, preDelay: value };
-    this.internalModule.preDelay = this.preDelay;
-  }
-}

package/src/modules/Sequencer.ts

@@ -1,178 +0,0 @@
-import { now, Part } from "tone";
-import Module, { DummnyInternalModule } from "../core/Module";
-import { INote } from "../core/Note";
-import { MidiOutput } from "../core/IO";
-import { MidiEvent } from "../core/midi";
-import Engine from "../Engine";
-
-export interface ISequence {
-  active: boolean;
-  time: string;
-  notes: INote[];
-}
-interface ISequencer {
-  sequences: ISequence[][];
-  steps: number;
-  bars: number;
-}
-
-const InitialProps = () => ({
-  sequences: [],
-  steps: 16,
-  bars: 1,
-});
-
-export default class Sequencer extends Module<
-  DummnyInternalModule,
-  ISequencer
-> {
-  static moduleName = "Sequencer";
-  midiOutput: MidiOutput;
-  private part: Part<ISequence>;
-
-  constructor(params: {
-    id?: string;
-    name: string;
-    props: Partial<ISequencer>;
-  }) {
-    const { id, name, props } = params;
-    super(new DummnyInternalModule(), {
-      id,
-      name,
-      props: { ...InitialProps(), ...props },
-    });
-
-    this.initializePart();
-    this.start(now());
-    this.registerOutputs();
-  }
-
-  get props() {
-    return super.props;
-  }
-
-  set props(value: ISequencer) {
-    if (!this.sequences) this._props["sequences"] = [];
-
-    super.props = { ...this.props, ...value };
-    this.adjust();
-  }
-
-  get steps() {
-    return this._props["steps"];
-  }
-
-  set steps(value: number) {
-    this._props = { ...this.props, steps: value };
-  }
-
-  get bars() {
-    return this.props["bars"];
-  }
-
-  set bars(value: number) {
-    this._props = { ...this.props, bars: value };
-  }
-
-  get sequences() {
-    return this._props["sequences"];
-  }
-
-  set sequences(value: ISequence[][]) {
-    const sequences = value;
-    this._props = { ...this.props, sequences };
-  }
-
-  start(time: number) {
-    if (!Engine.isStarted) return;
-
-    this.part.start(time);
-  }
-
-  stop() {
-    this.part.stop();
-  }
-
-  private registerOutputs() {
-    this.midiOutput = this.registerMidiOutput({ name: "midi out" });
-  }
-
-  private initializePart() {
-    this.part = new Part(this.onPartEvent, [] as ISequence[]);
-    this.part.loop = true;
-    this.part.loopEnd = this.loopEnd;
-  }
-
-  private adjust() {
-    if (!this.part) return;
-
-    this.adjustNumberOfBars();
-    this.adjustNumberOfSteps();
-    this.updateBarParts();
-  }
-
-  private adjustNumberOfBars() {
-    const currentBar = this.sequences.length;
-    const num = currentBar - this.bars;
-    const sequences = [...this.sequences];
-
-    if (num === 0) return;
-
-    if (num > 0) {
-      sequences.pop();
-    } else {
-      sequences.push([]);
-    }
-
-    this.sequences = sequences;
-    this.adjustNumberOfBars();
-  }
-
-  private adjustNumberOfSteps(bar = 0) {
-    if (!this.bars) return;
-
-    const allSequences = [...this.sequences];
-    const sequences = [...allSequences[bar]];
-    const num = sequences.length - this.steps;
-
-    if (num === 0) {
-      if (bar === this.bars - 1) return;
-
-      this.adjustNumberOfSteps(bar + 1);
-      return;
-    }
-
-    if (num > 0) {
-      sequences.pop();
-    } else {
-      const index = sequences.length;
-      sequences.push({ active: false, time: `${bar}:0:${index}`, notes: [] });
-    }
-    allSequences[bar] = sequences;
-    this.sequences = allSequences;
-
-    this.adjustNumberOfSteps(bar);
-  }
-
-  private updateBarParts() {
-    this.part.clear();
-
-    this.sequences.forEach((barSeqs) => {
-      barSeqs.forEach((seq) => this.part.add(seq.time, seq));
-    });
-
-    this.part.loopEnd = this.loopEnd;
-  }
-
-  private get loopEnd() {
-    return `${this.bars}:0:0`;
-  }
-
-  private onPartEvent = (time: number, sequence: ISequence) => {
-    if (!sequence.active) return;
-
-    MidiEvent.fromSequence(sequence, time).forEach((event) => {
-      this.midiOutput.onMidiEvent(event);
-    });
-  };
-}

package/src/modules/VoiceScheduler.ts

@@ -1,145 +0,0 @@
-import { MidiEvent } from "../core/midi";
-import Module, { PolyModule, DummnyInternalModule } from "../core/Module";
-import { MidiOutput } from "../core/IO";
-
-export interface VoiceSchedulerInterface {
-  polyNumber: number;
-}
-
-export default class VoiceScheduler extends PolyModule<
-  Voice,
-  VoiceSchedulerInterface
-> {
-  static moduleName = "VoiceScheduler";
-  midiOutput: MidiOutput;
-
-  constructor(params: {
-    id?: string;
-    name: string;
-    props: VoiceSchedulerInterface;
-  }) {
-    const { id, name, props } = params;
-
-    super({
-      id,
-      name,
-      child: Voice,
-      props,
-    });
-
-    this.registerInputs();
-    this.registerOutputs();
-    this.polyNumber = this.numberOfVoices;
-  }
-
-  set polyNumber(value: number) {
-    super.numberOfVoices = value;
-  }
-
-  get polyNumber() {
-    return this.numberOfVoices;
-  }
-
-  onMidiEvent = (midiEvent: MidiEvent) => {
-    let voice: Voice | undefined;
-
-    switch (midiEvent.type) {
-      case "noteOn":
-        voice = this.findFreeVoice();
-
-        break;
-      case "noteOff":
-        voice = this.audioModules.find(
-          (v) => v.activeNote === midiEvent.note.fullName
-        );
-        break;
-      default:
-        throw Error("This type is not a note");
-    }
-
-    if (!voice) return;
-
-    voice.midiTriggered(midiEvent);
-    midiEvent.voiceNo = voice.voiceNo;
-    this.midiOutput.onMidiEvent(midiEvent);
-  };
-
-  serialize() {
-    const serialize = super.serialize();
-
-    return {
-      ...serialize,
-      props: { ...serialize.props, polyNumber: this.polyNumber },
-    };
-  }
-
-  private findFreeVoice(): Voice {
-    let voice = this.audioModules.find((v) => !v.activeNote);
-
-    // If no available voice, get the one with the lowest triggeredAt
-    if (!voice) {
-      voice = this.audioModules.sort((a, b) => {
-        if (!a || !b) return 0;
-
-        return a.triggeredAt - b.triggeredAt;
-      })[0];
-    }
-
-    return voice;
-  }
-
-  private registerInputs() {
-    this.registerMidiInput({
-      name: "midi in",
-      onMidiEvent: this.onMidiEvent,
-    });
-  }
-
-  private registerOutputs() {
-    this.midiOutput = this.registerMidiOutput({ name: "midi out" });
-  }
-}
-
-class Voice extends Module<DummnyInternalModule, VoiceSchedulerInterface> {
-  midiEvent: MidiEvent | null;
-  activeNote: string | null;
-  triggeredAt: number;
-
-  constructor(params: {
-    id?: string;
-    name: string;
-    props: VoiceSchedulerInterface;
-  }) {
-    const { id, name, props } = params;
-
-    super(new DummnyInternalModule(), {
-      id,
-      name,
-      props,
-    });
-  }
-
-  midiTriggered = (midiEvent: MidiEvent) => {
-    if (this.voiceNo === undefined) throw Error("Voice without voiceNo");
-
-    const { triggeredAt, note, type } = midiEvent;
-
-    if (!note) return;
-    const noteName = note.fullName;
-
-    switch (type) {
-      case "noteOn":
-        this.activeNote = noteName;
-        this.triggeredAt = triggeredAt;
-        this.midiEvent = midiEvent;
-
-        break;
-      case "noteOff":
-        this.activeNote = null;
-        this.midiEvent = null;
-        break;
-      default:
-        throw Error("This type is not a note");
-    }
-  };
-}

package/src/modules/Volume.ts

@@ -1,72 +0,0 @@
-import { Volume as Vol } from "tone";
-
-import Module, { PolyModule } from "../core/Module";
-import Note from "../core/Note";
-
-export interface VolumeInterface {
-  volume: number;
-}
-
-const InitialProps: VolumeInterface = {
-  volume: -Infinity,
-};
-
-class MonoVolume extends Module<Vol, VolumeInterface> {
-  constructor(params: {
-    id?: string;
-    name: string;
-    props: Partial<VolumeInterface>;
-  }) {
-    const { id, name, props } = params;
-
-    super(new Vol(), {
-      id,
-      name,
-      props: { ...InitialProps, ...props },
-    });
-
-    this.registerBasicInputs();
-    this.registerBasicOutputs();
-  }
-
-  get volume() {
-    return this._props["volume"];
-  }
-
-  set volume(value: number) {
-    this._props = { ...this.props, volume: value };
-
-    this.internalModule.volume.value = this.volume;
-  }
-
-  triggerAttack = (note: Note, triggeredAt: number) => {
-    const db = 20 * Math.log10(note.velocity);
-    this.internalModule.volume.exponentialRampToValueAtTime(db, triggeredAt);
-  };
-
-  triggerRelease = () => {
-    // Do nothing
-  };
-}
-
-export default class Volume extends PolyModule<MonoVolume, VolumeInterface> {
-  static moduleName = "Volume";
-
-  constructor(params: {
-    id?: string;
-    name: string;
-    props: Partial<VolumeInterface>;
-  }) {
-    const { id, name, props } = params;
-
-    super({
-      id,
-      name,
-      child: MonoVolume,
-      props: { ...InitialProps, ...props },
-    });
-
-    this.registerBasicInputs();
-    this.registerBasicOutputs();
-  }
-}

package/src/routes.ts

@@ -1,49 +0,0 @@
-import { v4 as uuidv4 } from "uuid";
-
-import Engine from "./";
-import { plugCompatibleIO } from "./core/IO/Node";
-import { Optional } from "./types";
-
-export interface RouteProps {
-  sourceId: string;
-  sourceIOId: string;
-  destinationId: string;
-  destinationIOId: string;
-}
-
-export interface RouteInterface extends RouteProps {
-  id: string;
-}
-
-export function createRoute(props: Optional<RouteInterface, "id">) {
-  const id = props.id || uuidv4();
-
-  return { ...props, id };
-}
-
-export function applyRoutes(routes: RouteInterface[]) {
-  Object.values(Engine.modules).forEach((m) => {
-    m.unPlugAll();
-  });
-
-  const succesedConnections = routes.map((route) => {
-    const { sourceId, sourceIOId, destinationId, destinationIOId } = route;
-
-    const source = Engine.findById(sourceId);
-    const destination = Engine.findById(destinationId);
-
-    const output = source.outputs.find(sourceIOId);
-    const input = destination.inputs.find(destinationIOId);
-    if (!input || !output) throw Error("IO not found");
-
-    plugCompatibleIO(input, output);
-
-    return true;
-  });
-
-  if (succesedConnections.every((v) => v)) {
-    console.log("######## Routes succesfully applied");
-  } else {
-    console.log("######## Routes partialy applied");
-  }
-}

package/src/types.ts

@@ -1,3 +0,0 @@
-export type AnyObject = { [Key: string]: any };
-export type AtLeast<T, K extends keyof T> = Partial<T> & Pick<T, K>;
-export type Optional<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;

package/src/utils.ts

@@ -1,18 +0,0 @@
-import CryptoJS from "crypto-js";
-
-export function deterministicId(
-  originalId: string,
-  additionalString: string
-): string {
-  const combinedString = `${originalId}:${additionalString}`;
-  const hash = CryptoJS.SHA256(combinedString).toString(CryptoJS.enc.Hex);
-
-  const newId = `${hash.substring(0, 8)}-${hash.substring(
-    8,
-    12
-  )}-4${hash.substring(13, 16)}-${
-    "89AB"[parseInt(hash.substring(17, 18), 16) % 4]
-  }${hash.substring(18, 21)}-${hash.substring(21, 33)}`;
-
-  return newId;
-}