Refactor object mangling and add midi support

src/API.ts

@@ -9,7 +9,7 @@ import { tryEvaluate, evaluateOnce } from "./Evaluator";
 import { DrunkWalk } from "./Utils/Drunk";
 import { Editor } from "./main";
 import { SoundEvent } from "./classes/SoundEvent";
-import { MidiEvent } from "./classes/MidiEvent";
+import { MidiEvent, MidiParams } from "./classes/MidiEvent";
 import { LRUCache } from "lru-cache";
 import { InputOptions, Player } from "./classes/ZPlayer";
 import {
@@ -390,9 +390,10 @@ export class UserAPI {
   };
 
   public midi = (
-    value: number | object = 60,
+    value: number | number[] = 60,
-    velocity?: number,
+    velocity?: number | number[],
-    channel?: number
+    channel?: number | number[],
+    port?: number | string | number[] | string[]
   ): MidiEvent => {
     /**
      * Sends a MIDI note to the current MIDI output.
@@ -402,24 +403,9 @@ export class UserAPI {
      *                { channel: 0, velocity: 100, duration: 0.5 }
      */
 
-    if (velocity !== undefined) {
+    const event = {note: value, velocity, channel, port} as MidiParams
-      // Check if value is of type number
-      if (typeof value === "number") {
-        value = { note: value };
-      }
-      // @ts-ignore
-      value["velocity"] = velocity;
-    }
 
-    if (channel !== undefined) {
+    return new MidiEvent(event, this.app);
-      if (typeof value === "number") {
-        value = { note: value };
-      }
-      // @ts-ignore
-      value["channel"] = channel;
-    }
-
-    return new MidiEvent(value, this.app);
   };
 
   public sysex = (data: Array<number>): void => {
@@ -1893,7 +1879,7 @@ export class UserAPI {
   // Trivial functions
   // =============================================================
 
-  sound = (sound: string | object) => {
+  sound = (sound: string | string[]) => {
     return new SoundEvent(sound, this.app);
   };
 

src/Utils/Generic.ts

@@ -0,0 +1,70 @@
+/*
+ * Transforms object with arrays into array of objects
+ * 
+ * @param {Record<string, any>} input - Object with arrays
+ * @param {string[]} ignoredKeys - Keys to ignore
+ * @returns {Record<string, any>[]} Array of objects
+ * 
+ */
+export function objectWithArraysToArrayOfObjects(input: Record<string, any>, ignoredKeys: string[]): Record<string, any>[] {
+    const keys = Object.keys(input).filter((k) => !ignoredKeys.includes(k));
+    const maxLength = Math.max(
+      ...keys.map((k) =>
+        Array.isArray(input[k]) ? (input[k] as any[]).length : 1
+      )
+    );
+
+    const output: Record<string, any>[] = [];
+
+    for (let i = 0; i < maxLength; i++) {
+      const event: Record<string, any> = {};
+      for (const k of keys) {
+        if (ignoredKeys.includes(k)) {
+           event[k] = input[k];
+        } else {
+          if (Array.isArray(input[k])) {
+            event[k] = (input[k] as any[])[i % (input[k] as any[]).length];
+          } else {
+            event[k] = input[k];
+          }
+        }
+      }
+      output.push(event);
+    }
+    return output;
+  };
+
+/* 
+ * Transforms array of objects into object with arrays
+ * 
+ * @param {Record<string, any>[]} array - Array of objects
+ * @param {Record<string, any>} mergeObject - Object that is merged to each object in the array
+ * @returns {object} Merged object with arrays
+ * 
+ */
+export function arrayOfObjectsToObjectWithArrays<T extends Record<string, any>>(array: T[], mergeObject: Record<string, any> = {}): Record<string, any> {
+    return array.reduce((acc, obj) => {
+      Object.keys(mergeObject).forEach((key) => {
+        obj[key as keyof T] = mergeObject[key];
+      });
+      Object.keys(obj).forEach((key) => {
+        if (!acc[key as keyof T]) {
+          acc[key as keyof T] = [];
+        }
+        (acc[key as keyof T] as unknown[]).push(obj[key]);
+      });
+      return acc;
+    }, {} as Record<keyof T, any[]>);
+  }
+
+  /* 
+   * Filter certain keys from object
+   *
+   * @param {Record<string, any>} obj - Object to filter
+   * @param {string[]} filter - Keys to filter
+   * @returns {object} Filtered object
+   *
+   */
+  export function filterObject(obj: Record<string, any>, filter: string[]): Record<string, any> {
+    return Object.fromEntries(Object.entries(obj).filter(([key]) => filter.includes(key)));
+  }

src/classes/AbstractEvents.ts

@@ -204,8 +204,11 @@ export abstract class Event {
     return this.modify(func);
   };
 
-  length = (value: number): Event => {
+  noteLength = (value: number): Event => {
-    this.values["length"] = value;
+    /**
+     * This function is used to set the note length of the Event.
+     */
+    this.values["noteLength"] = value;
     return this;
   };
 }
@@ -215,30 +218,63 @@ export abstract class AudibleEvent extends Event {
     super(app);
   }
 
+  pitch = (value: number): this => {
+    /* 
+      * This function is used to set the pitch of the Event.
+      * @param value - The pitch value
+      * @returns The Event
+      */
+    this.values["pitch"] = value;
+    if(this.values.key && this.values.parsedScale) this.update();
+    return this;
+  }
+
+  pc = this.pitch;
+
   octave = (value: number): this => {
+    /*
+      * This function is used to set the octave of the Event.
+      * @param value - The octave value
+      * @returns The Event
+      */
     this.values["octave"] = value;
-    this.update();
+    if(this.values.key && this.values.pitch && this.values.parsedScale) this.update();
     return this;
   };
 
   key = (value: string): this => {
+    /* 
+      * This function is used to set the key of the Event.
+      * @param value - The key value
+      * @returns The Event
+      */
     this.values["key"] = value;
-    this.update();
+    if(this.values.pitch && this.values.parsedScale) this.update();
     return this;
   };
 
   scale = (value: string): this => {
+    /*
+      * This function is used to set the scale of the Event.
+      * @param value - The scale value
+      * @returns The Event
+    */
     if (!isScale(value)) {
       this.values.parsedScale = parseScala(value) as number[];
     } else {
       this.values.scaleName = value;
       this.values.parsedScale = getScale(value) as number[];
     }
-    this.update();
+    if(this.values.key && this.values.pitch) this.update();
     return this;
   };
 
   freq = (value: number): this => {
+    /*
+      * This function is used to set the frequency of the Event.
+      * @param value - The frequency value
+      * @returns The Event
+    */
     this.values["freq"] = value;
     const midiNote = freqToMidi(value);
     if (midiNote % 1 !== 0) {

src/classes/MidiEvent.ts

@@ -1,7 +1,8 @@
 import { AudibleEvent } from "./AbstractEvents";
 import { type Editor } from "../main";
 import { MidiConnection } from "../IO/MidiConnection";
-import { midiToFreq, noteFromPc } from "zifferjs";
+import { noteFromPc, chord as parseChord } from "zifferjs";
+import { filterObject, arrayOfObjectsToObjectWithArrays, objectWithArraysToArrayOfObjects } from "../Utils/Generic";
 
 export type MidiParams = {
   note: number;
@@ -9,40 +10,49 @@ export type MidiParams = {
   channel?: number;
   port?: number;
   sustain?: number;
+  velocity?: number;
 }
 
 export class MidiEvent extends AudibleEvent {
   midiConnection: MidiConnection;
 
-  constructor(input: number | object, public app: Editor) {
+  constructor(input: MidiParams, public app: Editor) {
     super(app);
-    if (typeof input === "number") this.values["note"] = input;
+    this.values = input;
-    else this.values = input;
     this.midiConnection = app.api.MidiConnection;
   }
 
-  chord = (value: MidiParams[]): this => {
+  public chord = (value: string) => {
-    this.values["chord"] = value;
+      this.values.note = parseChord(value);
-    return this;
+      return this;
   };
   
-  note = (value: number): this => {
+  note = (value: number | number[]): this => {
     this.values["note"] = value;
     return this;
   };
 
-  sustain = (value: number): this => {
+  sustain = (value: number | number[]): this => {
     this.values["sustain"] = value;
     return this;
   };
 
-  channel = (value: number): this => {
+  velocity = (value: number | number[]): this => {
+    this.values["velocity"] = value;
+    return this;
+  }
+
+  channel = (value: number | number[]): this => {
     this.values["channel"] = value;
     return this;
   };
 
-  port = (value: number | string): this => {
+  port = (value: number | string | number[] | string[]): this => {
-    this.values["port"] = this.midiConnection.getMidiOutputIndex(value);
+    if(typeof value === "string"){
+      this.values["port"] = this.midiConnection.getMidiOutputIndex(value);
+    } else if(Array.isArray(value)){
+      this.values["port"] = value.map((v) => typeof v === "string" ? this.midiConnection.getMidiOutputIndex(v) : v);
+    }
     return this;
   };
 
@@ -75,36 +85,45 @@ export class MidiEvent extends AudibleEvent {
   };
 
   update = (): void => {
-    const [note, bend] = noteFromPc(
+    // Get key, pitch, parsedScale and octave from this.values object
-      this.values.key || "C4",
+    const filteredValues = filterObject(this.values, ["key", "pitch", "parsedScale", "octave"]);
-      this.values.pitch || 0,
+      
-      this.values.parsedScale || "MAJOR",
+    const events = objectWithArraysToArrayOfObjects(filteredValues,["parsedScale"]);
-      this.values.octave || 0
+
-    );
+    events.forEach((event) => {
-    this.values.note = note;
+      const [note, bend] = noteFromPc(
-    this.values.freq = midiToFreq(note);
+        event.key as number || "C4",
-    if (bend) this.values.bend = bend;
+        event.pitch as number || 0,
+        event.parsedScale as number[] || event.scale || "MAJOR",
+        event.octave as number || 0
+      );
+      event.note = note;
+      if(bend) event.bend = bend;
+    });
+
+    const newArrays = arrayOfObjectsToObjectWithArrays(events) as MidiParams;
+
+    this.values.note = newArrays.note;
+    if(newArrays.bend) this.values.bend = newArrays.bend;
   };
 
   out = (): void => {
-    function play(event: MidiEvent, params?: MidiParams): void {
+    function play(event: MidiEvent, params: MidiParams): void {
-      const paramChannel = params && params.channel ? params.channel : 0;
+      const channel = params.channel ? params.channel : 0;
-      const channel = event.values.channel ? event.values.channel : paramChannel;
+      const velocity = params.velocity ? params.velocity : 100;
-      const velocity = event.values.velocity ? event.values.velocity : 100;
+      const note = params.note ? params.note : 60;
-      const paramNote = params && params.note ? params.note : 60;
-      const note = event.values.note ? event.values.note : paramNote;
 
-      const sustain = event.values.sustain
+      const sustain = params.sustain
-        ? event.values.sustain *
+        ? params.sustain *
           event.app.clock.pulse_duration *
           event.app.api.ppqn()
         : event.app.clock.pulse_duration * event.app.api.ppqn();
 
-      const bend = event.values.bend ? event.values.bend : undefined;
+      const bend = params.bend ? params.bend : undefined;
 
-      const port = event.values.port
+      const port = params.port
-        ? event.midiConnection.getMidiOutputIndex(event.values.port)
+        ? event.midiConnection.getMidiOutputIndex(params.port)
-        : event.midiConnection.getCurrentMidiPortIndex();
+        : event.midiConnection.getCurrentMidiPortIndex() || 0;
         
       event.midiConnection.sendMidiNote(
         note,
@@ -116,13 +135,11 @@ export class MidiEvent extends AudibleEvent {
       );
     }
 
-    if(this.values.chord) {
+    const events = objectWithArraysToArrayOfObjects(this.values,["parsedScale"]) as MidiParams[];
-      this.values.chord.forEach((p: MidiParams) => {
+
-        play(this, p);
+    events.forEach((p: MidiParams) => {
-      });
+      play(this,p);
-    } else {
+    });
-      play(this);
-    }
     
   };
 }

src/classes/RestEvent.ts

@@ -4,11 +4,11 @@ import { Event } from "./AbstractEvents";
 export class RestEvent extends Event {
   constructor(length: number, app: Editor) {
     super(app);
-    this.values["length"] = length;
+    this.values["noteLength"] = length;
   }
 
   _fallbackMethod = (): Event => {
-    return RestEvent.createRestProxy(this.values["length"], this.app);
+    return RestEvent.createRestProxy(this.values["noteLength"], this.app);
   };
 
   public static createRestProxy = (

src/classes/SoundEvent.ts

@@ -1,5 +1,6 @@
 import { type Editor } from "../main";
 import { AudibleEvent } from "./AbstractEvents";
+import { filterObject, arrayOfObjectsToObjectWithArrays, objectWithArraysToArrayOfObjects } from "../Utils/Generic";
 import {
   chord as parseChord,
   midiToFreq,
@@ -12,22 +13,23 @@ import {
   // @ts-ignore
 } from "superdough";
 
-type EventObj = { [key: string]: number | number[] };
-
 export type SoundParams = {
-  dur: number;
+  dur: number | number[];
-  s?: string;
+  s?: undefined | string | string[];
-};
+  n?: undefined | number | number[];
-
+  analyze?: boolean;
-type ValuesType = {
+  note?: number | number[];
-  s: string | string[];
+  freq?: number | number[];
-  n?: string | string[];
+  pitch?: number | number[];
-  dur: number;
+  key?: string;
-  analyze: boolean;
+  scale?: string;
+  parsedScale?: number[];
+  octave?: number | number[];
 };
 
 export class SoundEvent extends AudibleEvent {
   nudge: number;
+  sound: any;
 
   private methodMap = {
     volume: ["volume", "vol"],
@@ -276,7 +278,7 @@ export class SoundEvent extends AudibleEvent {
   };
 
 
-  constructor(sound: string | string[] | object, public app: Editor) {
+  constructor(sound: string | string[] | SoundParams, public app: Editor) {
     super(app);
     this.nudge = app.dough_nudge / 100;
 
@@ -294,15 +296,15 @@ export class SoundEvent extends AudibleEvent {
     this.values = this.processSound(sound);
   }
 
-  private processSound = (sound: string | string[] | object): ValuesType => {
+  private processSound = (sound: string | string[] | SoundParams | SoundParams[]): SoundParams => {
-    if (Array.isArray(sound)) {
+    if (Array.isArray(sound) && typeof sound[0] === 'string') {
       const s: string[] = [];
-      const n: string[] = [];
+      const n: number[] = [];
       sound.forEach(str => {
-        const parts = str.split(":");
+        const parts = (str as string).split(":");
         s.push(parts[0]);
         if (parts[1]) {
-          n.push(parts[1]);
+          n.push(parseInt(parts[1]));
         }
       });
       return {
@@ -312,16 +314,17 @@ export class SoundEvent extends AudibleEvent {
         analyze: true
       };
     } else if (typeof sound === 'object') {
-      console.log(sound)
+      const validatedObj: SoundParams = {
-      const validatedObj: ValuesType = {
         dur: this.app.clock.convertPulseToSecond(this.app.clock.ppqn),
         analyze: true,
-        ...sound as Partial<ValuesType>
+        ...sound as Partial<SoundParams>
       };
       return validatedObj;
     } else {
       if (sound.includes(":")) {
-        const [s, n] = sound.split(":");
+        const vals = sound.split(":");
+        const s = vals[0];
+        const n = parseInt(vals[1]);
         return {
           s,
           n,
@@ -334,8 +337,7 @@ export class SoundEvent extends AudibleEvent {
     }
   }
 
-
+  private updateValue<T>(key: string, value: T | T[] | SoundParams[] | null): this {
-  private updateValue<T>(key: string, value: T | T[] | null): this {
     if (value == null) return this;
     this.values[key] = value;
     return this;
@@ -356,61 +358,31 @@ export class SoundEvent extends AudibleEvent {
   };
 
   update = (): void => {
-    const [note, _] = noteFromPc(
+    const filteredValues = filterObject(this.values, ["key", "pitch", "parsedScale", "octave"]);
-      this.values.key || "C4",
+    const events = objectWithArraysToArrayOfObjects(filteredValues,["parsedScale"]);
-      this.values.pitch || 0,
+
-      this.values.parsedScale || "MAJOR",
+    events.forEach((event) => {
-      this.values.octave || 0
+      const [note, _] = noteFromPc(
-    );
+        event.key as number || "C4",
-    this.values.freq = midiToFreq(note);
+        event.pitch as number || 0,
+        event.parsedScale as number[] || event.scale || "MAJOR",
+        event.octave as number || 0
+      );
+      event.note = note;
+      event.freq = midiToFreq(note);
+    });
+
+    const newArrays = arrayOfObjectsToObjectWithArrays(events) as SoundParams;
+
+    this.values.note = newArrays.note;
+    this.values.freq = newArrays.freq;
   };
 
-  generateEvents = (input: EventObj): EventObj[] => {
+  public chord = (value: string) => {
-    const keys = Object.keys(input);
-    const maxLength = Math.max(
-      ...keys.map((k) =>
-        Array.isArray(input[k]) ? (input[k] as number[]).length : 1
-      )
-    );
-
-    const output: EventObj[] = [];
-
-    for (let i = 0; i < maxLength; i++) {
-      const event: EventObj = {};
-      for (const k of keys) {
-        if (Array.isArray(input[k])) {
-          // @ts-ignore
-          event[k] = input[k][i % (input[k] as number[]).length];
-        } else {
-          event[k] = input[k];
-        }
-      }
-      output.push(event);
-    }
-
-    return output;
-  };
-
-  public chord = (
-    value: string | object[] | number[] | number,
-    ...kwargs: number[]
-  ) => {
-    if (typeof value === "string") {
       const chord = parseChord(value);
-      value = chord.map((note: number) => {
+      return this.updateValue("note", chord);
-        return { note: note, freq: midiToFreq(note) };
-      });
-    } else if (value instanceof Array && typeof value[0] === "number") {
-      value = (value as number[]).map((note: number) => {
-        return { note: note, freq: midiToFreq(note) };
-      });
-    } else if (typeof value === "number" && kwargs.length > 0) {
-      value = [value, ...kwargs].map((note: number) => {
-        return { note: note, freq: midiToFreq(note) };
-      });
-    }
-    return this.updateValue("chord", value);
   };
+
   public invert = (howMany: number = 0) => {
     if (this.values.chord) {
       let notes = this.values.chord.map(
@@ -438,17 +410,13 @@ export class SoundEvent extends AudibleEvent {
     }
   };
 
-
-
   out = (): void => {
-    const input = this.values.chord || this.values;
+    const events = objectWithArraysToArrayOfObjects(this.values,["parsedScale"]);
-    const events = this.generateEvents(input);
-    console.log(events);
     for (const event of events) {
       superdough(
-        { ...event, ...{ freq: event.freq, dur: this.values.dur } },
+        event,
         this.nudge,
-        this.values.dur
+        event.dur
       );
     }
   };

src/classes/ZPlayer.ts

@@ -5,6 +5,7 @@ import { SkipEvent } from "./SkipEvent";
 import { SoundEvent, SoundParams } from "./SoundEvent";
 import { MidiEvent, MidiParams } from "./MidiEvent";
 import { RestEvent } from "./RestEvent";
+import { arrayOfObjectsToObjectWithArrays } from "../Utils/Generic";
 
 export type InputOptions = { [key: string]: string | number };
 
@@ -139,37 +140,39 @@ export class Player extends Event {
   };
 
   sound(name?: string) {
-    
     if (this.areWeThereYet()) {
       const event = this.next() as Pitch | Chord | ZRest;
       const noteLengthInSeconds = this.app.clock.convertPulseToSecond(event.duration*4*this.app.clock.ppqn);
       if (event instanceof Pitch) {
         const obj = event.getExisting(
           "freq",
+          "note",
           "pitch",
           "key",
           "scale",
           "octave",
           "parsedScale"
-        );
+        ) as SoundParams;
         if(event.sound) name = event.sound as string;
-        if(event.soundIndex) obj.n = event.soundIndex;
+        if(event.soundIndex) obj.n = event.soundIndex as number;
         obj.dur = noteLengthInSeconds;
         return new SoundEvent(obj, this.app).sound(name || "sine");
       } else if (event instanceof Chord) {
         const pitches = event.pitches.map((p) => {
           return p.getExisting(
             "freq",
+            "note",
             "pitch",
             "key",
             "scale",
             "octave",
             "parsedScale"
           );
-        });
+        }) as SoundParams[];
-        const sound: SoundParams = {dur: noteLengthInSeconds};
+        const add = { dur: noteLengthInSeconds } as SoundParams;
-        if(name) sound.s = name;
+        if(name) add.s = name;
-        return new SoundEvent(sound, this.app).chord(pitches);
+        let sound = arrayOfObjectsToObjectWithArrays(pitches,add) as SoundParams;
+        return new SoundEvent(sound, this.app);
       } else if (event instanceof ZRest) {
         return RestEvent.createRestProxy(event.duration, this.app);
       }
@@ -189,16 +192,17 @@ export class Player extends Event {
         "scale",
         "octave",
         "parsedScale",
-      );
+      ) as MidiParams;
       if (event instanceof Pitch) {
-        if(event.soundIndex) obj.channel = event.soundIndex;
+        if(event.soundIndex) obj.channel = event.soundIndex as number;
         const note = new MidiEvent(obj, this.app);
         return value ? note.note(value) : note;
       } else if (event instanceof ZRest) {
         return RestEvent.createRestProxy(event.duration, this.app);
       } else if (event instanceof Chord) {
         const pitches = event.midiChord() as MidiParams[];
-        return new MidiEvent(obj, this.app).chord(pitches);
+        const obj = arrayOfObjectsToObjectWithArrays(pitches) as MidiParams;
+        return new MidiEvent(obj, this.app);
       }
     } else {
       return SkipEvent.createSkipProxy();