@blibliki/engine 0.1.5 → 0.1.7

package/src/Module/Filter.ts

@@ -1,12 +1,12 @@
 import { Filter as InternalFilter } from "tone";
 
-import { FreqEnvelope } from "./Envelope";
-import Module, { ModuleType } from "./Base";
-import PolyModule, { PolyModuleType } from "./PolyModule";
-import { PolyFreqEnvelope } from "./Envelope/FreqEnvelope";
+import { FreqEnvelope, MonoFreqEnvelope } from "./Envelope";
+import Module, { Voicable } from "./Base";
+import PolyModule from "./PolyModule";
 
-interface FilterInterface {
+interface FilterInterface extends Voicable {
   cutoff: number;
+  filterType: BiquadFilterType;
   resonance: number;
   envelopeAmount: number;
   voiceNo?: number;
@@ -18,16 +18,16 @@ const InitialProps: FilterInterface = {
   cutoff: 20000,
   resonance: 0,
   envelopeAmount: 0,
+  filterType: "lowpass",
 };
 
-export default class Filter extends Module<InternalFilter, FilterInterface> {
-  private _envelope: FreqEnvelope;
+class MonoFilter extends Module<InternalFilter, FilterInterface> {
+  private _envelope: MonoFreqEnvelope;
 
   constructor(name: string, props: FilterProps) {
     super(new InternalFilter({ type: "lowpass" }), {
       name,
       props: { ...InitialProps, ...props },
-      type: ModuleType.Filter,
     });
   }
 
@@ -71,19 +71,21 @@ export default class Filter extends Module<InternalFilter, FilterInterface> {
     this._envelope.amount = value;
   }
 
-  conntectedEnvelope(envelope: FreqEnvelope) {
+  conntectedEnvelope(envelope: MonoFreqEnvelope) {
     this._envelope = envelope;
     this._envelope.frequency = this.cutoff;
     this._envelope.amount = this.envelopeAmount;
   }
 }
 
-export class PolyFilter extends PolyModule<Filter, FilterInterface> {
+export default class Filter extends PolyModule<MonoFilter, FilterInterface> {
+  static moduleName = "Filter";
+
   constructor(name: string, props: Partial<FilterInterface>) {
-    super(PolyModuleType.Filter, {
+    super({
       name,
+      child: MonoFilter,
       props: { ...InitialProps, ...props },
-      type: ModuleType.Filter,
     });
 
     this.registerBasicInputs();
@@ -96,13 +98,13 @@ export class PolyFilter extends PolyModule<Filter, FilterInterface> {
       name: "frequency",
       pluggable: "frequency",
       onPlug: (output) => {
-        this.conntectedEnvelope(output.audioModule as PolyFreqEnvelope);
+        this.conntectedEnvelope(output.audioModule as FreqEnvelope);
       },
     });
   }
 
-  conntectedEnvelope(polyFreqEnvelope: PolyFreqEnvelope) {
-    polyFreqEnvelope.audioModules.forEach((envelope) => {
+  conntectedEnvelope(freqEnvelope: FreqEnvelope) {
+    freqEnvelope.audioModules.forEach((envelope) => {
       if (envelope.voiceNo === undefined) return;
 
       const filter = this.findVoice(envelope.voiceNo);

package/src/Module/Master.ts

@@ -1,5 +1,5 @@
 import { Destination, getDestination } from "tone";
-import Module, { ModuleType } from "../Module";
+import Module from "./Base";
 
 export interface MasterInterface {}
 
@@ -7,10 +7,11 @@ export default class Master extends Module<
   typeof Destination,
   MasterInterface
 > {
+  static moduleName = "Master";
+
   constructor() {
     super(getDestination(), {
       name: "Master",
-      type: ModuleType.Master,
     });
 
     this.registerBasicInputs();

package/src/Module/MidiSelector.ts

@@ -1,6 +1,6 @@
 import Engine from "../Engine";
 import MidiEvent from "../MidiEvent";
-import Module, { ModuleType, DummnyInternalModule } from "./Base";
+import Module, { DummnyInternalModule } from "./Base";
 import { Output } from "./IO";
 
 export interface MidiSelectorInterface {
@@ -15,13 +15,13 @@ export default class MidiSelector extends Module<
   DummnyInternalModule,
   MidiSelectorInterface
 > {
+  static moduleName = "MidiSelector";
   midiOutput: Output;
 
   constructor(name: string, props: Partial<MidiSelectorInterface>) {
     super(new DummnyInternalModule(), {
       name,
       props: { ...InitialProps, ...props },
-      type: ModuleType.MidiSelector,
     });
 
     this.registerOutputs();
@@ -33,16 +33,18 @@ export default class MidiSelector extends Module<
   }
 
   set selectedId(value: string | null) {
-    if (this.selectedId) {
-      const prevMidiDevice = Engine.midiDeviceManager.find(this.selectedId);
-      prevMidiDevice?.removeEventListener(this.onMidiEvent);
-    }
+    this.removeEventListener();
 
     this._props = { ...this.props, selectedId: value };
 
     this.addEventListener(value);
   }
 
+  dispose() {
+    this.removeEventListener();
+    super.dispose();
+  }
+
   private registerOutputs() {
     this.midiOutput = this.registerOutput({ name: "midi out" });
   }
@@ -59,4 +61,11 @@ export default class MidiSelector extends Module<
     const midiDevice = Engine.midiDeviceManager.find(midiId);
     midiDevice?.addEventListener(this.onMidiEvent);
   }
+
+  private removeEventListener() {
+    if (!this.selectedId) return;
+
+    const midiDevice = Engine.midiDeviceManager.find(this.selectedId);
+    midiDevice?.removeEventListener(this.onMidiEvent);
+  }
 }

package/src/Module/Oscillator.ts

@@ -1,18 +1,17 @@
 import MidiEvent from "../MidiEvent";
 import { Oscillator as Osc, ToneOscillatorType } from "tone";
 
-import Module, { ModuleType } from "../Module";
 import Note from "../Note";
-import PolyModule, { PolyModuleType } from "./PolyModule";
+import Module, { Voicable } from "./Base";
+import PolyModule from "./PolyModule";
 
-export interface OscillatorInterface {
+export interface OscillatorInterface extends Voicable {
   noteName: string;
   fine: number;
   coarse: number;
   wave: string;
   volume: number;
   range: number;
-  voiceNo?: number;
 }
 
 const InitialProps: OscillatorInterface = {
@@ -24,14 +23,13 @@ const InitialProps: OscillatorInterface = {
   volume: 0,
 };
 
-export default class Oscillator extends Module<Osc, OscillatorInterface> {
+class MonoOscillator extends Module<Osc, OscillatorInterface> {
   private _note: Note;
 
   constructor(name: string, props: Partial<OscillatorInterface>) {
     super(new Osc(), {
       name,
       props: { ...InitialProps, ...props },
-      type: ModuleType.Oscillator,
     });
 
     this.note = new Note("C3");
@@ -142,15 +140,17 @@ export default class Oscillator extends Module<Osc, OscillatorInterface> {
   }
 }
 
-export class PolyOscillator extends PolyModule<
-  Oscillator,
+export default class Oscillator extends PolyModule<
+  MonoOscillator,
   OscillatorInterface
 > {
+  static moduleName = "Oscillator";
+
   constructor(name: string, props: Partial<OscillatorInterface>) {
-    super(PolyModuleType.Oscillator, {
+    super({
       name,
+      child: MonoOscillator,
       props: { ...InitialProps, ...props },
-      type: ModuleType.Oscillator,
     });
 
     this.registerBasicOutputs();

package/src/Module/PolyModule.ts

@@ -1,42 +1,35 @@
 import MidiEvent from "../MidiEvent";
 import { v4 as uuidv4 } from "uuid";
-import { createModule } from ".";
-import Module, { ModuleInterface, ModuleType, Connectable } from "./Base";
+import Module, { Connectable, Voicable } from "./Base";
 import { Input, Output, IOInterface } from "./IO";
 import { AudioModule } from "../Module";
 
-export enum PolyModuleType {
-  Oscillator = "oscillator",
-  Envelope = "envelope",
-  AmpEnvelope = "ampEnvelope",
-  FreqEnvelope = "freqEnvelope",
-  VoiceScheduler = "voiceScheduler",
-  Filter = "filter",
-  Volume = "volume",
+interface PolyModuleInterface<MonoAudioModule, PropsInterface> {
+  name: string;
+  child: new (name: string, props: PropsInterface) => MonoAudioModule;
+  props: PropsInterface;
 }
 
-interface PolyModuleInterface extends ModuleInterface {}
-
 export default abstract class PolyModule<
   MonoAudioModule extends Module<Connectable, any>,
-  PropsInterface
+  PropsInterface extends Voicable
 > {
+  static readonly moduleName: string;
+
   readonly id: string;
+  readonly child: new (name: string, props: PropsInterface) => MonoAudioModule;
   _name: string;
   audioModules: MonoAudioModule[];
   inputs: Input[] = [];
   outputs: Output[] = [];
-  readonly _type: PolyModuleType;
-  readonly childrenType: ModuleType;
   private _numberOfVoices: number;
 
-  constructor(type: PolyModuleType, props: PolyModuleInterface) {
+  constructor(params: PolyModuleInterface<MonoAudioModule, PropsInterface>) {
     this.id = uuidv4();
-    this._type = type;
-    this.childrenType = props.type;
     this.audioModules = [];
 
-    const { props: extraProps, ...basicProps } = props;
+    const { child, props: extraProps, ...basicProps } = params;
+    this.child = child;
     Object.assign(this, basicProps);
 
     this.numberOfVoices = 1;
@@ -45,10 +38,6 @@ export default abstract class PolyModule<
     this.registerNumberOfVoicesInput();
   }
 
-  get type() {
-    return this._type;
-  }
-
   get name() {
     return this._name;
   }
@@ -58,10 +47,6 @@ export default abstract class PolyModule<
     this.audioModules.forEach((m) => (m.name = value));
   }
 
-  // Do nothing
-  // This is a little hack to avoid override type by children module
-  set type(value: PolyModuleType) {}
-
   get props() {
     if (this.audioModules.length === 0) {
       throw Error("There isn't any initialized module");
@@ -114,10 +99,12 @@ export default abstract class PolyModule<
     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: this.type,
+      type: klass.moduleName,
       inputs: this.inputs.map((i) => i.serialize()),
       outputs: this.outputs.map((i) => i.serialize()),
     };
@@ -224,8 +211,10 @@ export default abstract class PolyModule<
       const audioModule = this.audioModules.pop();
       audioModule?.dispose();
     } else {
-      const props = this.audioModules.length ? this.props : {};
-      const audioModule = createModule(this.name, this.childrenType, {
+      const props = this.audioModules.length
+        ? this.props
+        : ({} as PropsInterface);
+      const audioModule = new this.child(this.name, {
         ...props,
         voiceNo: this.audioModules.length,
       });

package/src/Module/Reverb.ts

@@ -1,6 +1,5 @@
 import { Reverb as InternalReverb } from "tone";
 
-import { ModuleType } from "./Base";
 import Effect, { EffectInterface } from "./Effect";
 
 interface ReverbInterface extends EffectInterface {
@@ -14,8 +13,10 @@ const InitialProps: Partial<ReverbInterface> = {
 };
 
 export default class Reverb extends Effect<InternalReverb, ReverbInterface> {
+  static moduleName = "Reverb";
+
   constructor(name: string, props: Partial<ReverbInterface>) {
-    super(name, ModuleType.Reverb, new InternalReverb(), {
+    super(name, new InternalReverb(), {
       ...InitialProps,
       ...props,
     });

package/src/Module/VirtualMidi.ts

@@ -1,6 +1,6 @@
 import Engine from "../Engine";
 import MidiEvent from "../MidiEvent";
-import Module, { ModuleType, DummnyInternalModule } from "./Base";
+import Module, { DummnyInternalModule } from "./Base";
 import { Output } from "./IO";
 
 export interface VirtualMidiInterface {
@@ -15,13 +15,13 @@ export default class VirtualMidi extends Module<
   DummnyInternalModule,
   VirtualMidiInterface
 > {
+  static moduleName = "VirtualMidi";
   midiOutput: Output;
 
   constructor(name: string, props: VirtualMidiInterface) {
     super(new DummnyInternalModule(), {
       name,
       props: { ...InitialProps, ...props },
-      type: ModuleType.VirtualMidi,
     });
 
     this.registerInputs();

package/src/Module/VoiceScheduler.ts

@@ -1,9 +1,9 @@
-import Module, { ModuleType, DummnyInternalModule } from "./Base";
+import Module, { DummnyInternalModule, Voicable } from "./Base";
 import MidiEvent from "../MidiEvent";
 import { Input, Output } from "./IO";
-import PolyModule, { PolyModuleType } from "./PolyModule";
+import PolyModule from "./PolyModule";
 
-export interface VoiceSchedulerInterface {
+export interface VoiceSchedulerInterface extends Voicable {
   polyNumber: number;
 }
 
@@ -11,14 +11,15 @@ export default class VoiceScheduler extends PolyModule<
   Voice,
   VoiceSchedulerInterface
 > {
+  static moduleName = "VoiceScheduler";
   midiOutput: Output;
   numberOfVoicesOut: Output;
 
   constructor(name: string, props: VoiceSchedulerInterface) {
-    super(PolyModuleType.VoiceScheduler, {
+    super({
       name,
+      child: Voice,
       props,
-      type: ModuleType.Voice,
     });
 
     this.registerInputs();
@@ -111,11 +112,9 @@ export default class VoiceScheduler extends PolyModule<
   }
 }
 
-export interface VoiceInterface {
-  voiceNo?: number;
-}
+export interface VoiceInterface extends Voicable {}
 
-export class Voice extends Module<DummnyInternalModule, VoiceInterface> {
+class Voice extends Module<DummnyInternalModule, VoiceInterface> {
   midiEvent: MidiEvent | null;
   activeNote: string | null;
   triggeredAt: number;
@@ -124,7 +123,6 @@ export class Voice extends Module<DummnyInternalModule, VoiceInterface> {
   constructor(name: string, props: VoiceInterface) {
     super(new DummnyInternalModule(), {
       name,
-      type: ModuleType.Voice,
       props,
     });
   }

package/src/Module/Volume.ts

@@ -1,23 +1,21 @@
 import { Volume as Vol } from "tone";
 
-import Module, { ModuleType } from "../Module";
-import PolyModule, { PolyModuleType } from "./PolyModule";
+import Module, { Voicable } from "./Base";
+import PolyModule from "./PolyModule";
 
-export interface VolumeInterface {
+export interface VolumeInterface extends Voicable {
   volume: number;
-  voiceNo?: number;
 }
 
 const InitialProps: VolumeInterface = {
   volume: -100,
 };
 
-export default class Volume extends Module<Vol, VolumeInterface> {
+class MonoVolume extends Module<Vol, VolumeInterface> {
   constructor(name: string, props: Partial<VolumeInterface>) {
     super(new Vol(), {
       name,
       props: { ...InitialProps, ...props },
-      type: ModuleType.Volume,
     });
   }
 
@@ -32,12 +30,14 @@ export default class Volume extends Module<Vol, VolumeInterface> {
   }
 }
 
-export class PolyVolume extends PolyModule<Volume, VolumeInterface> {
+export default class Volume extends PolyModule<MonoVolume, VolumeInterface> {
+  static moduleName = "Volume";
+
   constructor(name: string, props: Partial<VolumeInterface>) {
-    super(PolyModuleType.Volume, {
+    super({
       name,
+      child: MonoVolume,
       props: { ...InitialProps, ...props },
-      type: ModuleType.Volume,
     });
 
     this.registerBasicInputs();

package/src/Module/index.ts

@@ -1,23 +1,21 @@
-import Module, { Connectable, ModuleType } from "./Base";
-import PolyModule, { PolyModuleType } from "./PolyModule";
-import Oscillator, { PolyOscillator } from "./Oscillator";
+import { camelCase, upperFirst } from "lodash";
+import Module, { Connectable } from "./Base";
+import PolyModule from "./PolyModule";
+import Oscillator from "./Oscillator";
 import { Envelope, AmpEnvelope, FreqEnvelope } from "./Envelope";
-import Filter, { PolyFilter } from "./Filter";
+import Filter from "./Filter";
 import Master from "./Master";
-import VoiceScheduler, { Voice } from "./VoiceScheduler";
+import VoiceScheduler from "./VoiceScheduler";
 import MidiSelector from "./MidiSelector";
-import { PolyAmpEnvelope } from "./Envelope/AmpEnvelope";
-import { PolyFreqEnvelope } from "./Envelope/FreqEnvelope";
-import { PolyEnvelope } from "./Envelope/Base";
-import Volume, { PolyVolume } from "./Volume";
+import Volume from "./Volume";
 import VirtualMidi from "./VirtualMidi";
 import Reverb from "./Reverb";
 import Delay from "./Delay";
 import Distortion from "./Distortion";
 import BitCrusher from "./BitCrusher";
 
-export { default, ModuleType } from "./Base";
-export { default as PolyModule, PolyModuleType } from "./PolyModule";
+export { default } from "./Base";
+export { default as PolyModule } from "./PolyModule";
 export type { ModuleInterface, Connectable, Triggerable } from "./Base";
 
 export { default as Filter } from "./Filter";
@@ -43,51 +41,39 @@ export function createModule(
   return new klass(name, props);
 }
 
-export function moduleClassFromType(type: string) {
+function moduleClassFromType(type: string) {
+  type = upperFirst(camelCase(type));
+
   switch (type) {
-    case ModuleType.Oscillator:
+    case Oscillator.moduleName:
       return Oscillator;
-    case ModuleType.Envelope:
+    case Envelope.moduleName:
       return Envelope;
-    case ModuleType.AmpEnvelope:
+    case AmpEnvelope.moduleName:
       return AmpEnvelope;
-    case ModuleType.FreqEnvelope:
+    case FreqEnvelope.moduleName:
       return FreqEnvelope;
-    case ModuleType.Filter:
+    case Filter.moduleName:
       return Filter;
-    case ModuleType.Volume:
+    case Volume.moduleName:
       return Volume;
-    case PolyModuleType.Oscillator:
-      return PolyOscillator;
-    case PolyModuleType.Envelope:
-      return PolyEnvelope;
-    case PolyModuleType.AmpEnvelope:
-      return PolyAmpEnvelope;
-    case PolyModuleType.FreqEnvelope:
-      return PolyFreqEnvelope;
-    case PolyModuleType.Filter:
-      return PolyFilter;
-    case PolyModuleType.Volume:
-      return PolyVolume;
-    case ModuleType.Master:
+    case Master.moduleName:
       return Master;
-    case ModuleType.Voice:
-      return Voice;
-    case PolyModuleType.VoiceScheduler:
+    case VoiceScheduler.moduleName:
       return VoiceScheduler;
-    case ModuleType.MidiSelector:
+    case MidiSelector.moduleName:
       return MidiSelector;
-    case ModuleType.VirtualMidi:
+    case VirtualMidi.moduleName:
       return VirtualMidi;
-    case ModuleType.Reverb:
+    case Reverb.moduleName:
       return Reverb;
-    case ModuleType.Delay:
+    case Delay.moduleName:
       return Delay;
-    case ModuleType.Distortion:
+    case Distortion.moduleName:
       return Distortion;
-    case ModuleType.BitCrusher:
+    case BitCrusher.moduleName:
       return BitCrusher;
     default:
-      throw Error("Unknown module type");
+      throw Error(`Unknown module type ${type}`);
   }
 }

package/src/index.ts

@@ -1,5 +1,4 @@
 export { default } from "./Engine";
-export { ModuleType, PolyModuleType } from "./Module";
 export { default as MidiDevice } from "./MidiDevice";
 export { default as MidiDeviceManager } from "./MidiDeviceManager";
 export { default as Note } from "./Note";