@blibliki/engine 0.1.17 → 0.1.19

package/src/core/midi/MidiEvent.ts

@@ -0,0 +1,91 @@
+import { now } from "tone";
+import { ISequence } from "../../modules";
+import Note, { INote } from "../Note";
+
+const EventType: { [key: number]: MidiEventType } = {
+  0x80: "noteOff",
+  0x90: "noteOn",
+  0xb0: "cc",
+};
+
+export type MidiEventType = "noteOn" | "noteOff" | "cc";
+
+export default class MidiEvent {
+  note: Note;
+  voiceNo?: number;
+  readonly triggeredAt: number;
+  _type: MidiEventType;
+  private data: Uint8Array;
+  private event: MIDIMessageEvent;
+
+  static fromSequence(sequence: ISequence, triggeredAt: number): MidiEvent[] {
+    return sequence.notes.map((noteName) =>
+      this.fromNote(noteName, true, triggeredAt)
+    );
+  }
+
+  static fromNote(
+    noteName: string | Note | INote,
+    noteOn: boolean = true,
+    triggeredAt?: number
+  ): MidiEvent {
+    const note = noteName instanceof Note ? noteName : new Note(noteName);
+
+    const event = new MidiEvent(
+      new MIDIMessageEvent("", { data: note.midiData(noteOn) }),
+      triggeredAt
+    );
+    event.note = note;
+
+    return event;
+  }
+
+  static fromCC(cc: number, value: number, triggeredAt?: number): MidiEvent {
+    return new MidiEvent(
+      new MIDIMessageEvent("", { data: new Uint8Array([0xb0, cc, value]) }),
+      triggeredAt
+    );
+  }
+
+  constructor(event: MIDIMessageEvent, triggeredAt?: number) {
+    this.event = event;
+    this.triggeredAt = triggeredAt || now();
+    this.data = event.data;
+    this.defineNotes();
+  }
+
+  get statusByte(): number {
+    return this.data[0];
+  }
+
+  get firstData(): number {
+    return this.data[1];
+  }
+
+  get secondData(): number {
+    return this.data[2];
+  }
+
+  get type() {
+    if (this._type) return this._type;
+
+    let type = EventType[this.statusByte & 0xf0];
+
+    if (type === "noteOn" && this.secondData === 0) {
+      type = "noteOff";
+    }
+
+    return (this._type = type);
+  }
+
+  get isNote() {
+    return this.type === "noteOn" || this.type === "noteOff";
+  }
+
+  defineNotes() {
+    if (!this.isNote) return;
+    if (this.note) return;
+
+    this.note = new Note(this.event);
+  }
+}

package/src/core/midi/index.ts

@@ -0,0 +1,5 @@
+export { default as MidiEvent } from "./MidiEvent";
+export { default as MidiDevice } from "./MidiDevice";
+export { default as MidiDeviceManager } from "./MidiDeviceManager";
+export type { MidiDeviceInterface } from "./MidiDevice";
+export type { MidiEventType } from "./MidiEvent";

package/src/index.ts

@@ -1,15 +1,11 @@
 export { default } from "./Engine";
-export { default as MidiDevice } from "./MidiDevice";
-export { default as MidiDeviceManager } from "./MidiDeviceManager";
-export { default as Note } from "./Note";
+export { MidiDevice, MidiDeviceManager } from "./core/midi";
+export { default as Note } from "./core/Note";
 
-export type { INote } from "./Note";
-export type { MidiDeviceInterface } from "./MidiDevice";
-export type {
-  ModuleInterface,
-  AudioModule,
-  ISequence,
-  IDataSequence,
-} from "./Module";
+export type { MidiDeviceInterface } from "./core/midi";
+export type { INote } from "./core/Note";
+export type { ModuleInterface, AudioModule } from "./core/Module";
+export type { ISequence } from "./modules";
 
-export type { SerializeInterface as IOProps } from "./Module/IO";
+export type { RouteInterface, RouteProps } from "./routes";
+export type { IIOSerialize as IOProps } from "./core/IO";

package/src/{Module → modules}/BitCrusher.ts

@@ -16,10 +16,21 @@ export default class BitCrusher extends Effect<
 > {
   static moduleName = "BitCrusher";
 
-  constructor(name: string, props: Partial<BitCrusherInterface>) {
-    super(name, new InternalBitCrasher(), {
-      ...InitialProps,
-      ...props,
+  constructor(params: {
+    id?: string;
+    name: string;
+    props: Partial<BitCrusherInterface>;
+  }) {
+    const { id, name, props } = params;
+
+    super({
+      id,
+      name,
+      internalModule: new InternalBitCrasher(),
+      props: {
+        ...InitialProps,
+        ...props,
+      },
     });
   }
 

package/src/{Module → modules}/Delay.ts

@@ -15,10 +15,21 @@ const InitialProps: Partial<DelayInterface> = {
 export default class Delay extends Effect<FeedbackDelay, DelayInterface> {
   static moduleName = "Delay";
 
-  constructor(name: string, props: Partial<DelayInterface>) {
-    super(name, new FeedbackDelay(), {
-      ...InitialProps,
-      ...props,
+  constructor(params: {
+    id?: string;
+    name: string;
+    props: Partial<DelayInterface>;
+  }) {
+    const { id, name, props } = params;
+
+    super({
+      id,
+      name,
+      internalModule: new FeedbackDelay(),
+      props: {
+        ...InitialProps,
+        ...props,
+      },
     });
   }
 

package/src/{Module → modules}/Distortion.ts

@@ -16,10 +16,21 @@ export default class Distortion extends Effect<
 > {
   static moduleName = "Distortion";
 
-  constructor(name: string, props: Partial<DistortionInterface>) {
-    super(name, new InternalDistortion(), {
-      ...InitialProps,
-      ...props,
+  constructor(params: {
+    id?: string;
+    name: string;
+    props: Partial<DistortionInterface>;
+  }) {
+    const { id, name, props } = params;
+
+    super({
+      id,
+      name,
+      internalModule: new InternalDistortion(),
+      props: {
+        ...InitialProps,
+        ...props,
+      },
     });
   }
 

package/src/{Module → modules}/Effect.ts

@@ -1,5 +1,5 @@
 import { Signal } from "tone";
-import Module, { Connectable } from "./Base";
+import Module, { Connectable } from "../core/Module";
 
 interface EffectLike extends Connectable {
   wet: Signal<"normalRange">;
@@ -17,12 +17,16 @@ export default abstract class Effect<
   InternalEffect extends EffectLike,
   ModuleInterface extends EffectInterface
 > extends Module<InternalEffect, ModuleInterface> {
-  constructor(
-    name: string,
-    internalModule: InternalEffect,
-    props: Partial<ModuleInterface>
-  ) {
+  constructor(params: {
+    id?: string;
+    name: string;
+    internalModule: InternalEffect;
+    props: Partial<ModuleInterface>;
+  }) {
+    const { id, name, internalModule, props } = params;
+
     super(internalModule, {
+      id,
       name,
       props: { ...InitialProps, ...props } as ModuleInterface,
     });

package/src/modules/Envelope/AmpEnvelope.ts

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

package/src/{Module → modules}/Envelope/Base.ts

@@ -1,9 +1,11 @@
 import { Envelope as Env } from "tone";
 
-import Module, { Connectable, Triggerable, Voicable } from "../Base";
-import PolyModule from "../PolyModule";
-import MidiEvent from "../../MidiEvent";
-import Note from "../../Note";
+import Module, {
+  PolyModule,
+  Connectable,
+  Triggerable,
+} from "../../core/Module";
+import Note from "../../core/Note";
 
 export const enum EnvelopeStages {
   Attack = "attack",
@@ -17,12 +19,11 @@ const MIN_TIME = 0.01;
 const SUSTAIN_MAX_VALUE = 1;
 const SUSTAIN_MIN_VALUE = 0;
 
-export interface EnvelopeInterface extends Voicable {
+export interface EnvelopeInterface {
   attack: number;
   decay: number;
   sustain: number;
   release: number;
-  voiceNo?: number;
 }
 
 const InitialProps: EnvelopeInterface = {
@@ -39,15 +40,22 @@ export default abstract class EnvelopeModule<EnvelopeLike extends Env>
   activeNote?: string;
   triggeredAt: number;
 
-  constructor(
-    name: string,
-    internalModule: EnvelopeLike,
-    props: EnvelopeInterface
-  ) {
+  constructor(params: {
+    id?: string;
+    name: string;
+    internalModule: EnvelopeLike;
+    props: EnvelopeInterface;
+  }) {
+    const { id, name, props, internalModule } = params;
+
     super(internalModule, {
+      id,
       name,
       props: { ...InitialProps, ...props },
     });
+
+    this.registerBasicInputs();
+    this.registerBasicOutputs();
   }
 
   get attack() {
@@ -110,14 +118,21 @@ export default abstract class EnvelopeModule<EnvelopeLike extends Env>
 }
 
 export abstract class PolyBase<
-  EnvelopeModule extends Module<Connectable, any>
+  EnvelopeModule extends Module<Connectable, EnvelopeInterface>
 > extends PolyModule<EnvelopeModule, EnvelopeInterface> {
-  constructor(
-    name: string,
-    child: new (name: string, props: EnvelopeInterface) => EnvelopeModule,
-    props: Partial<EnvelopeInterface>
-  ) {
+  constructor(params: {
+    id?: string;
+    name: string;
+    child: new (params: {
+      id?: string;
+      name: string;
+      props: EnvelopeInterface;
+    }) => EnvelopeModule;
+    props: Partial<EnvelopeInterface>;
+  }) {
+    const { id, name, child, props } = params;
     super({
+      id,
       name,
       child,
       props: { ...InitialProps, ...props },
@@ -125,30 +140,34 @@ export abstract class PolyBase<
 
     this.registerBasicInputs();
     this.registerBasicOutputs();
-    this.registerInputs();
-  }
-
-  private registerInputs() {
-    this.registerInput({
-      name: "midi in",
-      pluggable: this.midiTriggered,
-    });
   }
 }
 
 class MonoEnvelope extends EnvelopeModule<Env> {
-  constructor(name: string, props: EnvelopeInterface) {
-    super(name, new Env(), props);
+  constructor(params: { id?: string; name: string; props: EnvelopeInterface }) {
+    const { id, name, props } = params;
+    super({ id, name, internalModule: new Env(), props });
   }
 }
 
 export class Envelope extends PolyBase<MonoEnvelope> {
   static moduleName = "Envelope";
 
-  constructor(name: string, props: Partial<EnvelopeInterface>) {
-    super(name, MonoEnvelope, {
-      ...InitialProps,
-      ...props,
+  constructor(params: {
+    id?: string;
+    name: string;
+    props: Partial<EnvelopeInterface>;
+  }) {
+    const { id, name, props } = params;
+
+    super({
+      id,
+      name,
+      child: MonoEnvelope,
+      props: {
+        ...InitialProps,
+        ...props,
+      },
     });
   }
 }

package/src/{Module → modules}/Envelope/FreqEnvelope.ts

@@ -1,8 +1,6 @@
 import { FrequencyEnvelope } from "tone";
 
 import Filter from "../Filter";
-import { Output } from "../IO";
-
 import Base, { EnvelopeInterface, PolyBase } from "./Base";
 
 interface FreqEnvelopeInterface extends Partial<EnvelopeInterface> {
@@ -18,10 +16,17 @@ export class MonoFreqEnvelope extends Base<FrequencyEnvelope> {
   private _amount: number;
   filter: Filter;
 
-  constructor(name: string, props: EnvelopeInterface) {
-    super(name, new FrequencyEnvelope(), {
-      ...InitialProps,
-      ...props,
+  constructor(params: { id?: string; name: string; props: EnvelopeInterface }) {
+    const { id, name, props } = params;
+
+    super({
+      id,
+      name,
+      internalModule: new FrequencyEnvelope(),
+      props: {
+        ...InitialProps,
+        ...props,
+      },
     });
   }
 
@@ -48,22 +53,12 @@ export class MonoFreqEnvelope extends Base<FrequencyEnvelope> {
 export default class FreqEnvelope extends PolyBase<MonoFreqEnvelope> {
   static moduleName = "FreqEnvelope";
 
-  constructor(name: string, props: Partial<EnvelopeInterface>) {
-    super(name, MonoFreqEnvelope, props);
-
-    this.registerOutputs();
-  }
-
-  protected registerOutputs() {
-    this.registerOutput({
-      name: "frequency",
-      pluggable: this,
-      onPlug: (output: Output) => {
-        this.connect(output.audioModule, output.pluggable);
-      },
-      onUnPlug: (output: Output) => {
-        this.disconnect(output.audioModule, output.pluggable);
-      },
-    });
+  constructor(params: {
+    id?: string;
+    name: string;
+    props: Partial<EnvelopeInterface>;
+  }) {
+    const { id, name, props } = params;
+    super({ id, name, child: MonoFreqEnvelope, props });
   }
 }

package/src/{Module → modules}/Filter.ts

@@ -1,19 +1,15 @@
 import { Filter as InternalFilter, FilterRollOff } from "tone";
+import Module, { PolyModule } from "../core/Module";
 
-import { FreqEnvelope, MonoFreqEnvelope } from "./Envelope";
-import Module, { Voicable } from "./Base";
-import PolyModule from "./PolyModule";
-
-interface FilterInterface extends Voicable {
+interface FilterInterface {
   cutoff: number;
   filterType: BiquadFilterType;
   resonance: number;
   slope: FilterRollOff;
   envelopeAmount: number;
-  voiceNo?: number;
 }
 
-interface FilterProps extends Partial<FilterInterface> {}
+type FilterProps = Partial<FilterInterface>;
 
 const InitialProps: FilterInterface = {
   cutoff: 20000,
@@ -24,13 +20,17 @@ const InitialProps: FilterInterface = {
 };
 
 class MonoFilter extends Module<InternalFilter, FilterInterface> {
-  private _envelope: MonoFreqEnvelope;
+  constructor(params: { id?: string; name: string; props: FilterProps }) {
+    const { id, name, props } = params;
 
-  constructor(name: string, props: FilterProps) {
     super(new InternalFilter({ type: "lowpass" }), {
+      id,
       name,
       props: { ...InitialProps, ...props },
     });
+
+    this.registerBasicInputs();
+    this.registerBasicOutputs();
   }
 
   get cutoff() {
@@ -39,12 +39,7 @@ class MonoFilter extends Module<InternalFilter, FilterInterface> {
 
   set cutoff(value: number) {
     this._props = { ...this.props, cutoff: value };
-
-    if (this._envelope) {
-      this._envelope.frequency = value;
-    } else {
-      this.internalModule.frequency.value = value;
-    }
+    this.internalModule.frequency.value = value;
   }
 
   get filterType() {
@@ -85,24 +80,21 @@ class MonoFilter extends Module<InternalFilter, FilterInterface> {
 
   set envelopeAmount(value: number) {
     this._props = { ...this.props, envelopeAmount: value };
-
-    if (!this._envelope) return;
-
-    this._envelope.amount = value;
-  }
-
-  conntectedEnvelope(envelope: MonoFreqEnvelope) {
-    this._envelope = envelope;
-    this._envelope.frequency = this.cutoff;
-    this._envelope.amount = this.envelopeAmount;
   }
 }
 
 export default class Filter extends PolyModule<MonoFilter, FilterInterface> {
   static moduleName = "Filter";
 
-  constructor(name: string, props: Partial<FilterInterface>) {
+  constructor(params: {
+    id?: string;
+    name: string;
+    props: Partial<FilterInterface>;
+  }) {
+    const { id, name, props } = params;
+
     super({
+      id,
       name,
       child: MonoFilter,
       props: { ...InitialProps, ...props },
@@ -110,25 +102,5 @@ export default class Filter extends PolyModule<MonoFilter, FilterInterface> {
 
     this.registerBasicInputs();
     this.registerBasicOutputs();
-    this.registerInputs();
-  }
-
-  private registerInputs() {
-    this.registerInput({
-      name: "frequency",
-      pluggable: "frequency",
-      onPlug: (output) => {
-        this.conntectedEnvelope(output.audioModule as FreqEnvelope);
-      },
-    });
-  }
-
-  conntectedEnvelope(freqEnvelope: FreqEnvelope) {
-    freqEnvelope.audioModules.forEach((envelope) => {
-      if (envelope.voiceNo === undefined) return;
-
-      const filter = this.findVoice(envelope.voiceNo);
-      filter?.conntectedEnvelope(envelope);
-    });
   }
 }

package/src/{Module → modules}/Master.ts

@@ -1,5 +1,5 @@
 import { Destination, getDestination } from "tone";
-import Module from "./Base";
+import Module from "../core/Module";
 
 export interface MasterInterface {}
 
@@ -9,11 +9,17 @@ export default class Master extends Module<
 > {
   static moduleName = "Master";
 
-  constructor() {
+  constructor({ id }: { id?: string }) {
     super(getDestination(), {
+      id,
       name: "Master",
     });
 
     this.registerBasicInputs();
   }
+
+  dispose(): void {
+    this.inputs.unPlugAll();
+    this.outputs.unPlugAll();
+  }
 }

package/src/{Module → modules}/MidiSelector.ts

@@ -1,7 +1,7 @@
 import Engine from "../Engine";
-import MidiEvent from "../MidiEvent";
-import Module, { DummnyInternalModule } from "./Base";
-import { Output } from "./IO";
+import { MidiEvent } from "../core/midi";
+import Module, { DummnyInternalModule } from "../core/Module";
+import { MidiOutput } from "../core/IO";
 
 export interface MidiSelectorInterface {
   selectedId: string | null;
@@ -16,10 +16,16 @@ export default class MidiSelector extends Module<
   MidiSelectorInterface
 > {
   static moduleName = "MidiSelector";
-  midiOutput: Output;
-
-  constructor(name: string, props: Partial<MidiSelectorInterface>) {
+  midiOutput: MidiOutput;
+
+  constructor(params: {
+    id?: string;
+    name: string;
+    props: Partial<MidiSelectorInterface>;
+  }) {
+    const { id, name, props } = params;
     super(new DummnyInternalModule(), {
+      id,
       name,
       props: { ...InitialProps, ...props },
     });
@@ -46,15 +52,9 @@ export default class MidiSelector extends Module<
   }
 
   private registerOutputs() {
-    this.midiOutput = this.registerOutput({ name: "midi out" });
+    this.midiOutput = this.registerMidiOutput({ name: "midi out" });
   }
 
-  private onMidiEvent = (midiEvent: MidiEvent) => {
-    this.midiOutput.connections.forEach((input) => {
-      input.pluggable(midiEvent);
-    });
-  };
-
   private addEventListener(midiId: string | null) {
     if (!this.onMidiEvent || !midiId) return; // Ugly hack because of weird super bug
 
@@ -62,10 +62,14 @@ export default class MidiSelector extends Module<
     midiDevice?.addEventListener(this.onMidiEvent);
   }
 
+  private _onMidiEvent = (midiEvent: MidiEvent) => {
+    this.midiOutput.onMidiEvent(midiEvent);
+  };
+
   private removeEventListener() {
     if (!this.selectedId) return;
 
     const midiDevice = Engine.midiDeviceManager.find(this.selectedId);
-    midiDevice?.removeEventListener(this.onMidiEvent);
+    midiDevice?.removeEventListener(this._onMidiEvent);
   }
 }