@blibliki/engine 0.1.0

package/src/Module/index.ts

@@ -0,0 +1,78 @@
+import Module, { Connectable, ModuleType } from "./Base";
+import PolyModule, { PolyModuleType } from "./PolyModule";
+import Oscillator, { PolyOscillator } from "./Oscillator";
+import { Envelope, AmpEnvelope, FreqEnvelope } from "./Envelope";
+import Filter, { PolyFilter } from "./Filter";
+import Master from "./Master";
+import VoiceScheduler, { Voice } 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";
+
+export { default, ModuleType } from "./Base";
+export { default as PolyModule, PolyModuleType } from "./PolyModule";
+export type { ModuleInterface, Connectable, Triggerable } from "./Base";
+
+export { default as Filter } from "./Filter";
+export { default as Oscillator } from "./Oscillator";
+export {
+  Envelope,
+  AmpEnvelope,
+  FreqEnvelope,
+  EnvelopeStages,
+} from "./Envelope";
+
+export type AudioModule =
+  | Module<Connectable, any>
+  | PolyModule<Module<Connectable, any>, any>;
+
+export function createModule(
+  name: string,
+  type: string,
+  props: any
+): AudioModule {
+  const klass = moduleClassFromType(type);
+
+  return new klass(name, props);
+}
+
+export function moduleClassFromType(type: string) {
+  switch (type) {
+    case ModuleType.Oscillator:
+      return Oscillator;
+    case ModuleType.Envelope:
+      return Envelope;
+    case ModuleType.AmpEnvelope:
+      return AmpEnvelope;
+    case ModuleType.FreqEnvelope:
+      return FreqEnvelope;
+    case ModuleType.Filter:
+      return Filter;
+    case ModuleType.Volume:
+      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:
+      return Master;
+    case ModuleType.Voice:
+      return Voice;
+    case PolyModuleType.VoiceScheduler:
+      return VoiceScheduler;
+    case ModuleType.MidiSelector:
+      return MidiSelector;
+    default:
+      throw Error("Unknown module type");
+  }
+}

package/src/Note/frequencyTable.ts

@@ -0,0 +1,146 @@
+const frequencyTable: { [key: string]: number } = {
+  C0: 16.35,
+  "C#0": 17.32,
+  Db0: 17.32,
+  D0: 18.35,
+  "D#0": 19.45,
+  Eb0: 19.45,
+  E0: 20.6,
+  F0: 21.83,
+  "F#0": 23.12,
+  Gb0: 23.12,
+  G0: 24.5,
+  "G#0": 25.96,
+  Ab0: 25.96,
+  A0: 27.5,
+  "A#0": 29.14,
+  Bb0: 29.14,
+  B0: 30.87,
+  C1: 32.7,
+  "C#1": 34.65,
+  Db1: 34.65,
+  D1: 36.71,
+  "D#1": 38.89,
+  Eb1: 38.89,
+  E1: 41.2,
+  F1: 43.65,
+  "F#1": 46.25,
+  Gb1: 46.25,
+  G1: 49.0,
+  "G#1": 51.91,
+  Ab1: 51.91,
+  A1: 55.0,
+  "A#1": 58.27,
+  Bb1: 58.27,
+  B1: 61.74,
+  C2: 65.41,
+  "C#2": 69.3,
+  Db2: 69.3,
+  D2: 73.42,
+  "D#2": 77.78,
+  Eb2: 77.78,
+  E2: 82.41,
+  F2: 87.31,
+  "F#2": 92.5,
+  Gb2: 92.5,
+  G2: 98.0,
+  "G#2": 103.83,
+  Ab2: 103.83,
+  A2: 110.0,
+  "A#2": 116.54,
+  Bb2: 116.54,
+  B2: 123.47,
+  C3: 130.81,
+  "C#3": 138.59,
+  Db3: 138.59,
+  D3: 146.83,
+  "D#3": 155.56,
+  Eb3: 155.56,
+  E3: 164.81,
+  F3: 174.61,
+  "F#3": 185.0,
+  Gb3: 185.0,
+  G3: 196.0,
+  "G#3": 207.65,
+  Ab3: 207.65,
+  A3: 220.0,
+  "A#3": 233.08,
+  Bb3: 233.08,
+  B3: 246.94,
+  C4: 261.63,
+  "C#4": 277.18,
+  Db4: 277.18,
+  D4: 293.66,
+  "D#4": 311.13,
+  Eb4: 311.13,
+  E4: 329.63,
+  F4: 349.23,
+  "F#4": 369.99,
+  Gb4: 369.99,
+  G4: 392.0,
+  "G#4": 415.3,
+  Ab4: 415.3,
+  A4: 440.0,
+  "A#4": 466.16,
+  Bb4: 466.16,
+  B4: 493.88,
+  C5: 523.25,
+  "C#5": 554.37,
+  Db5: 554.37,
+  D5: 587.33,
+  "D#5": 622.25,
+  Eb5: 622.25,
+  E5: 659.26,
+  F5: 698.46,
+  "F#5": 739.99,
+  Gb5: 739.99,
+  G5: 783.99,
+  "G#5": 830.61,
+  Ab5: 830.61,
+  A5: 880.0,
+  "A#5": 932.33,
+  Bb5: 932.33,
+  B5: 987.77,
+  C6: 1046.5,
+  "C#6": 1108.73,
+  Db6: 1108.73,
+  D6: 1174.66,
+  "D#6": 1244.51,
+  Eb6: 1244.51,
+  E6: 1318.51,
+  F6: 1396.91,
+  "F#6": 1479.98,
+  Gb6: 1479.98,
+  G6: 1567.98,
+  "G#6": 1661.22,
+  Ab6: 1661.22,
+  A6: 1760.0,
+  "A#6": 1864.66,
+  Bb6: 1864.66,
+  B6: 1975.53,
+  C7: 2093.0,
+  "C#7": 2217.46,
+  Db7: 2217.46,
+  D7: 2349.32,
+  "D#7": 2489.02,
+  Eb7: 2489.02,
+  E7: 2637.02,
+  F7: 2793.83,
+  "F#7": 2959.96,
+  Gb7: 2959.96,
+  G7: 3135.96,
+  "G#7": 3322.44,
+  Ab7: 3322.44,
+  A7: 3520.0,
+  "A#7": 3729.31,
+  Bb7: 3729.31,
+  B7: 3951.07,
+  C8: 4186.01,
+  "C#8": 4434.92,
+  Db8: 4434.92,
+  D8: 4698.64,
+  "D#8": 4978.03,
+  Eb8: 4978.03,
+};
+
+export default frequencyTable;

package/src/Note/index.ts

@@ -0,0 +1,65 @@
+import frequencyTable from "./frequencyTable";
+
+const Notes = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
+
+const NotesLength = Notes.length;
+
+export default class Note {
+  static _notes: Note[];
+  name: string;
+  octave: number;
+
+  constructor(eventOrString: MIDIMessageEvent | string) {
+    if (typeof eventOrString === "string") {
+      this.fromString(eventOrString);
+    } else {
+      this.fromEvent(eventOrString);
+    }
+  }
+
+  static notes(octave: number = 3) {
+    return Notes.map((note: string) => new Note(`${note}${octave}`));
+  }
+
+  get isSemi() {
+    return this.name.slice(-1) === "#";
+  }
+
+  get fullName() {
+    return `${this.name}${this.octave}`;
+  }
+
+  frequency(range: number = 0, coarse: number = 0) {
+    let newOctave = this.octave + range;
+    let coarseIndex = Notes.indexOf(this.name) + coarse;
+    let nameIndex = coarseIndex;
+
+    if (coarseIndex >= NotesLength) {
+      newOctave++;
+      nameIndex = coarseIndex % NotesLength;
+    } else if (coarseIndex < 0) {
+      newOctave--;
+      nameIndex = NotesLength + nameIndex;
+    }
+
+    const newName = Notes[nameIndex];
+
+    return frequencyTable[`${newName}${newOctave}`];
+  }
+
+  valueOf() {
+    return this.fullName;
+  }
+
+  private fromString(string: string) {
+    const matches = string.match(/(\w#?)(\d)?/) || [];
+
+    this.name = matches[1];
+    this.octave = matches[2] ? parseInt(matches[2]) : 1;
+  }
+
+  private fromEvent(event: MIDIMessageEvent) {
+    this.name = Notes[event.data[1] % 12];
+    this.octave = Math.floor(event.data[1] / 12) - 2;
+  }
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+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";
+
+export type { MidiDeviceInterface } from "./MidiDevice";
+export type { ModuleInterface, AudioModule } from "./Module";
+
+export type { SerializeInterface as IOProps } from "./Module/IO";

package/src/routes.ts

@@ -0,0 +1,41 @@
+import { v4 as uuidv4 } from "uuid";
+
+import Engine from "./";
+
+export interface RouteProps {
+  sourceId: string;
+  outputName: string;
+  destinationId: string;
+  inputName: string;
+}
+
+export interface RouteInterface extends RouteProps {
+  id: string;
+}
+
+export function createRoute(props: RouteProps) {
+  const 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, outputName, destinationId, inputName } = route;
+
+    const source = Engine.findById(sourceId);
+    const destination = Engine.findById(destinationId);
+
+    source.plug(destination, outputName, inputName);
+
+    return true;
+  });
+
+  if (succesedConnections.every((v) => v)) {
+    console.log("######## Routes succesfully applied");
+  } else {
+    console.log("######## Routes partialy applied");
+  }
+}

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "module": "esnext",
+    "moduleResolution": "node",
+    "target": "esnext",
+    "declaration": true,
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "strict": true,
+    "allowJs": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strictPropertyInitialization": false,
+    "forceConsistentCasingInFileNames": true,
+    "noFallthroughCasesInSwitch": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "sourceMap": true,
+    "outDir": "build"
+  },
+  "include": ["src"]
+}