@blibliki/engine 0.1.27 → 0.3.1

package/src/core/Module/PolyModule.ts

@@ -1,218 +0,0 @@
-import { MidiEvent } from "../midi";
-import { v4 as uuidv4 } from "uuid";
-import Module, { Connectable } from "./MonoModule";
-import {
-  IOCollection,
-  IOType,
-  IMidiInput,
-  IMidiOutput,
-  MidiOutput,
-  MidiInput,
-  AnyInput,
-  AnyOuput,
-  ForwardAudioInput,
-} from "../IO";
-import { AudioModule } from "./index";
-import { plugCompatibleIO } from "../IO/Node";
-import { deterministicId } from "../../utils";
-import {
-  ForwardAudioOutput,
-  IForwardAudioInput,
-  IForwardAudioOutput,
-} from "../IO/ForwardNode";
-
-interface PolyModuleInterface<MonoAudioModule, PropsInterface> {
-  id?: string;
-  name: string;
-  numberOfVoices?: number;
-  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<AnyInput>;
-  outputs: IOCollection<AnyOuput>;
-  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 = params.numberOfVoices || 1;
-    this.inputs = new IOCollection<AnyInput>(this);
-    this.outputs = new IOCollection<AnyOuput>(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,
-      numberOfVoices: this.numberOfVoices,
-      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 registerForwardAudioInput(
-    props: Omit<IForwardAudioInput, "ioType">
-  ): ForwardAudioInput {
-    return this.inputs.add({ ...props, ioType: IOType.ForwardAudioInput });
-  }
-
-  protected registerForwardAudioOutput(
-    props: Omit<IForwardAudioOutput, "ioType">
-  ): ForwardAudioOutput {
-    return this.outputs.add({ ...props, ioType: IOType.ForwardAudioOutput });
-  }
-
-  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.registerForwardAudioOutput({ name: "output" });
-  }
-
-  protected registerBasicInputs() {
-    this.registerForwardAudioInput({ name: "input" });
-    this.registerMidiIn();
-  }
-
-  protected registerMidiIn() {
-    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

@@ -1,15 +0,0 @@
-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/core/midi/index.ts

@@ -1,5 +0,0 @@
-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/main.ts

@@ -1 +0,0 @@
-console.log("Hello from Blibliki");

package/src/modules/BitCrusher.ts

@@ -1,45 +0,0 @@
-import { BitCrusher as InternalBitCrasher } from "tone";
-
-import Effect, { EffectInterface } from "./Effect";
-
-interface BitCrusherInterface extends EffectInterface {
-  bits: number;
-}
-
-const InitialProps: Partial<BitCrusherInterface> = {
-  bits: 16,
-};
-
-export default class BitCrusher extends Effect<
-  InternalBitCrasher,
-  BitCrusherInterface
-> {
-  static moduleName = "BitCrusher";
-
-  constructor(params: {
-    id?: string;
-    name: string;
-    props: Partial<BitCrusherInterface>;
-  }) {
-    const { id, name, props } = params;
-
-    super({
-      id,
-      name,
-      internalModule: new InternalBitCrasher(),
-      props: {
-        ...InitialProps,
-        ...props,
-      },
-    });
-  }
-
-  get bits() {
-    return this._props["bits"];
-  }
-
-  set bits(value: number) {
-    this._props = { ...this.props, bits: value };
-    this.internalModule.bits.value = this.bits;
-  }
-}

package/src/modules/Delay.ts

@@ -1,53 +0,0 @@
-import { FeedbackDelay } from "tone";
-
-import Effect, { EffectInterface } from "./Effect";
-
-interface DelayInterface extends EffectInterface {
-  delayTime: number;
-  feedback: number;
-}
-
-const InitialProps: Partial<DelayInterface> = {
-  delayTime: 1,
-  feedback: 0.3,
-};
-
-export default class Delay extends Effect<FeedbackDelay, DelayInterface> {
-  static moduleName = "Delay";
-
-  constructor(params: {
-    id?: string;
-    name: string;
-    props: Partial<DelayInterface>;
-  }) {
-    const { id, name, props } = params;
-
-    super({
-      id,
-      name,
-      internalModule: new FeedbackDelay(),
-      props: {
-        ...InitialProps,
-        ...props,
-      },
-    });
-  }
-
-  get delayTime() {
-    return this._props["delayTime"];
-  }
-
-  set delayTime(value: number) {
-    this._props = { ...this.props, delayTime: value };
-    this.internalModule.delayTime.value = this.delayTime;
-  }
-
-  get feedback() {
-    return this._props["feedback"];
-  }
-
-  set feedback(value: number) {
-    this._props = { ...this.props, feedback: value };
-    this.internalModule.feedback.value = this.feedback;
-  }
-}

package/src/modules/Distortion.ts

@@ -1,45 +0,0 @@
-import { Distortion as InternalDistortion } from "tone";
-
-import Effect, { EffectInterface } from "./Effect";
-
-interface DistortionInterface extends EffectInterface {
-  drive: number;
-}
-
-const InitialProps: Partial<DistortionInterface> = {
-  drive: 0.3,
-};
-
-export default class Distortion extends Effect<
-  InternalDistortion,
-  DistortionInterface
-> {
-  static moduleName = "Distortion";
-
-  constructor(params: {
-    id?: string;
-    name: string;
-    props: Partial<DistortionInterface>;
-  }) {
-    const { id, name, props } = params;
-
-    super({
-      id,
-      name,
-      internalModule: new InternalDistortion(),
-      props: {
-        ...InitialProps,
-        ...props,
-      },
-    });
-  }
-
-  get drive() {
-    return this._props["drive"];
-  }
-
-  set drive(value: number) {
-    this._props = { ...this.props, drive: value };
-    this.internalModule.distortion = this.drive;
-  }
-}

package/src/modules/Effect.ts

@@ -1,46 +0,0 @@
-import { Signal } from "tone";
-import Module, { Connectable } from "../core/Module";
-
-interface EffectLike extends Connectable {
-  wet: Signal<"normalRange">;
-}
-
-export interface EffectInterface {
-  wet: number;
-}
-
-const InitialProps: EffectInterface = {
-  wet: 1,
-};
-
-export default abstract class Effect<
-  InternalEffect extends EffectLike,
-  ModuleInterface extends EffectInterface
-> extends Module<InternalEffect, 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,
-    });
-
-    this.registerBasicInputs();
-    this.registerBasicOutputs();
-  }
-
-  get wet() {
-    return this._props["wet"];
-  }
-
-  set wet(value: number) {
-    this._props = { ...this.props, wet: value };
-    this.internalModule.wet.value = this.wet;
-  }
-}

package/src/modules/Envelope/AmpEnvelope.ts

@@ -1,23 +0,0 @@
-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/modules/Envelope/Base.ts

@@ -1,176 +0,0 @@
-import { Envelope as Env } from "tone";
-
-import Module, {
-  PolyModule,
-  Connectable,
-  Triggerable,
-} from "../../core/Module";
-import Note from "../../core/Note";
-
-export const enum EnvelopeStages {
-  Attack = "attack",
-  Decay = "decay",
-  Sustain = "sustain",
-  Release = "release",
-}
-
-const MAX_TIME = 2;
-const MIN_TIME = 0.01;
-const SUSTAIN_MAX_VALUE = 1;
-const SUSTAIN_MIN_VALUE = 0;
-
-export interface EnvelopeInterface {
-  attack: number;
-  decay: number;
-  sustain: number;
-  release: number;
-}
-
-const InitialProps: EnvelopeInterface = {
-  attack: MIN_TIME,
-  decay: MIN_TIME,
-  sustain: SUSTAIN_MAX_VALUE,
-  release: MIN_TIME,
-};
-
-export default abstract class EnvelopeModule<EnvelopeLike extends Env>
-  extends Module<EnvelopeLike, EnvelopeInterface>
-  implements Triggerable
-{
-  activeNote?: string;
-  triggeredAt: number;
-
-  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() {
-    return this._props["attack"];
-  }
-
-  set attack(value: number) {
-    this.setStage(EnvelopeStages.Attack, value);
-  }
-
-  get decay() {
-    return this._props["decay"];
-  }
-
-  set decay(value: number) {
-    this.setStage(EnvelopeStages.Decay, value);
-  }
-
-  get sustain() {
-    return this._props["sustain"];
-  }
-
-  set sustain(value: number) {
-    this.setStage(EnvelopeStages.Sustain, value);
-  }
-
-  get release() {
-    return this._props["release"];
-  }
-
-  set release(value: number) {
-    this.setStage(EnvelopeStages.Release, value);
-  }
-
-  setStage(stage: EnvelopeStages, value: number) {
-    const calculatedValue =
-      value === 0 ? this.minTime(stage) : this.maxTime(stage) * value;
-    this._props = { ...this.props, [stage]: value };
-    this.internalModule[stage] = calculatedValue;
-  }
-
-  triggerAttack = (note: Note, triggeredAt: number) => {
-    this.activeNote = note.fullName;
-    this.triggeredAt = triggeredAt;
-
-    this.internalModule.triggerAttack(triggeredAt, note.velocity);
-  };
-
-  triggerRelease = (note: Note, triggeredAt: number) => {
-    if (this.activeNote && this.activeNote !== note.fullName) return;
-
-    this.internalModule.triggerRelease(triggeredAt);
-    this.activeNote = undefined;
-  };
-
-  private maxTime(stage: EnvelopeStages): number {
-    return stage === EnvelopeStages.Sustain ? SUSTAIN_MAX_VALUE : MAX_TIME;
-  }
-
-  private minTime(stage: EnvelopeStages): number {
-    return stage === EnvelopeStages.Sustain ? SUSTAIN_MIN_VALUE : MIN_TIME;
-  }
-}
-
-export abstract class PolyBase<
-  EnvelopeModule extends Module<Connectable, EnvelopeInterface>
-> extends PolyModule<EnvelopeModule, 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 },
-    });
-
-    this.registerBasicInputs();
-    this.registerBasicOutputs();
-  }
-}
-
-class MonoEnvelope extends EnvelopeModule<Env> {
-  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(params: {
-    id?: string;
-    name: string;
-    props: Partial<EnvelopeInterface>;
-  }) {
-    const { id, name, props } = params;
-
-    super({
-      id,
-      name,
-      child: MonoEnvelope,
-      props: {
-        ...InitialProps,
-        ...props,
-      },
-    });
-  }
-}

package/src/modules/Envelope/FreqEnvelope.ts

@@ -1,64 +0,0 @@
-import { FrequencyEnvelope } from "tone";
-
-import Filter from "../Filter";
-import Base, { EnvelopeInterface, PolyBase } from "./Base";
-
-interface FreqEnvelopeInterface extends Partial<EnvelopeInterface> {
-  amount?: number;
-}
-
-const InitialProps: FreqEnvelopeInterface = {
-  amount: 0,
-};
-
-export class MonoFreqEnvelope extends Base<FrequencyEnvelope> {
-  private _frequency: number;
-  private _amount: number;
-  filter: Filter;
-
-  constructor(params: { id?: string; name: string; props: EnvelopeInterface }) {
-    const { id, name, props } = params;
-
-    super({
-      id,
-      name,
-      internalModule: new FrequencyEnvelope(),
-      props: {
-        ...InitialProps,
-        ...props,
-      },
-    });
-  }
-
-  get frequency() {
-    return this._frequency;
-  }
-
-  set frequency(value: number) {
-    this._frequency = value;
-    this.internalModule.baseFrequency = value;
-  }
-
-  get amount() {
-    return this._amount;
-  }
-
-  set amount(value: number) {
-    this._amount = value;
-
-    this.internalModule.octaves = value;
-  }
-}
-
-export default class FreqEnvelope extends PolyBase<MonoFreqEnvelope> {
-  static moduleName = "FreqEnvelope";
-
-  constructor(params: {
-    id?: string;
-    name: string;
-    props: Partial<EnvelopeInterface>;
-  }) {
-    const { id, name, props } = params;
-    super({ id, name, child: MonoFreqEnvelope, props });
-  }
-}

package/src/modules/Envelope/index.ts

@@ -1,3 +0,0 @@
-export { default, Envelope, EnvelopeStages } from "./Base";
-export { default as AmpEnvelope } from "./AmpEnvelope";
-export { default as FreqEnvelope, MonoFreqEnvelope } from "./FreqEnvelope";