scribbletune 5.1.0 → 5.2.0

package/dist/index.mjs

@@ -0,0 +1,515 @@
+// src/index.ts
+import { scales, chords, scale as scale2, chord as chord2 } from "harmonics";
+
+// src/utils.ts
+import { chord, inlineChord } from "harmonics";
+var isNote = (str) => /^[a-gA-G](?:#|b)?\d$/.test(str);
+var expandStr = (str) => {
+  str = JSON.stringify(str.split(""));
+  str = str.replace(/,"\[",/g, ", [");
+  str = str.replace(/"\[",/g, "[");
+  str = str.replace(/,"\]"/g, "]");
+  return JSON.parse(str);
+};
+var shuffle = (arr, fullShuffle = true) => {
+  const lastIndex = arr.length - 1;
+  arr.forEach((el, idx) => {
+    if (idx >= lastIndex) {
+      return;
+    }
+    const rnd = fullShuffle ? (
+      // Pick random number from idx+1 to lastIndex (Modified algorithm, (N-1)! combinations)
+      // Math.random -> [0, 1) -> [0, lastIndex-idx ) --floor-> [0, lastIndex-idx-1]
+      // rnd = [0, lastIndex-idx-1] + 1 + idx = [1 + idx, lastIndex]
+      // (Original algorithm would pick rnd = [idx, lastIndex], thus any element could arrive back into its slot)
+      Math.floor(Math.random() * (lastIndex - idx)) + 1 + idx
+    ) : (
+      // Pick random number from idx to lastIndex (Unmodified Richard Durstenfeld, N! combinations)
+      Math.floor(Math.random() * (lastIndex + 1 - idx)) + idx
+    );
+    arr[idx] = arr[rnd];
+    arr[rnd] = el;
+  });
+  return arr;
+};
+var pickOne = (arr) => arr.length > 1 ? arr[Math.round(Math.random())] : arr[0];
+var dice = () => !!Math.round(Math.random());
+var errorHasMessage = (x) => {
+  return typeof x.message === "string";
+};
+var convertChordToNotes = (el) => {
+  let c1;
+  let c2;
+  let e1;
+  let e2;
+  try {
+    c1 = inlineChord(el);
+  } catch (e) {
+    e1 = e;
+  }
+  try {
+    c2 = chord(el.replace(/_/g, " "));
+  } catch (e) {
+    e2 = e;
+  }
+  if (!e1 && !e2) {
+    if (c1.toString() !== c2.toString()) {
+      throw new Error(`Chord ${el} cannot decode, guessing ${c1} or ${c2}`);
+    }
+    return c1;
+  }
+  if (!e1) {
+    return c1;
+  }
+  if (!e2) {
+    return c2;
+  }
+  return chord(el);
+};
+var convertChordsToNotes = (el) => {
+  if (typeof el === "string" && isNote(el)) {
+    return [el];
+  }
+  if (Array.isArray(el)) {
+    el.forEach((n) => {
+      if (Array.isArray(n)) {
+        n.forEach((n1) => {
+          if (typeof n1 !== "string" || !isNote(n1)) {
+            throw new TypeError("array of arrays must comprise valid notes");
+          }
+        });
+      } else if (typeof n !== "string" || !isNote(n)) {
+        throw new TypeError("array must comprise valid notes");
+      }
+    });
+    return el;
+  }
+  if (!Array.isArray(el)) {
+    const c = convertChordToNotes(el);
+    if (c && c.length) {
+      return c;
+    }
+  }
+  throw new Error(`Chord ${el} not found`);
+};
+var randomInt = (num = 1) => Math.round(Math.random() * num);
+
+// src/clip.ts
+var getDefaultParams = () => ({
+  notes: ["C4"],
+  pattern: "x",
+  shuffle: false,
+  sizzle: false,
+  sizzleReps: 1,
+  arpegiate: false,
+  subdiv: "4n",
+  amp: 100,
+  accentLow: 70,
+  randomNotes: null,
+  offlineRendering: false
+});
+var hdr = {
+  "1m": 2048,
+  "2m": 4096,
+  "3m": 6144,
+  "4m": 8192,
+  "1n": 512,
+  "2n": 256,
+  "4n": 128,
+  "8n": 64,
+  "16n": 32
+};
+var clip = (params) => {
+  params = { ...getDefaultParams(), ...params || {} };
+  if (typeof params.notes === "string") {
+    params.notes = params.notes.replace(/\s{2,}/g, " ");
+    params.notes = params.notes.split(" ");
+  }
+  params.notes = params.notes ? params.notes.map(convertChordsToNotes) : [];
+  if (/[^x\-_[\]R]/.test(params.pattern)) {
+    throw new TypeError(
+      `pattern can only comprise x - _ [ ] R, found ${params.pattern}`
+    );
+  }
+  if (params.shuffle) {
+    params.notes = shuffle(params.notes);
+  }
+  if (params.randomNotes && typeof params.randomNotes === "string") {
+    params.randomNotes = params.randomNotes.replace(/\s{2,}/g, " ").split(/\s/);
+  }
+  if (params.randomNotes) {
+    params.randomNotes = params.randomNotes.map(
+      convertChordsToNotes
+    );
+  }
+  const clipNotes = [];
+  let step = 0;
+  const recursivelyApplyPatternToNotes = (patternArr, length, parentNoteLength) => {
+    let totalLength = 0;
+    patternArr.forEach((char, idx) => {
+      var _a;
+      if (typeof char === "string") {
+        let note = null;
+        if (char === "-") {
+        } else if (char === "R" && randomInt() && // Use 1/2 probability for R to pick from param.notes
+        params.randomNotes && params.randomNotes.length > 0) {
+          note = params.randomNotes[randomInt(params.randomNotes.length - 1)];
+        } else if (params.notes) {
+          note = params.notes[step];
+        }
+        if (char === "x" || char === "R") {
+          step++;
+        }
+        if (char === "x" || char === "-" || char === "R") {
+          clipNotes.push({
+            note,
+            length,
+            level: char === "R" && !params.randomNotes ? params.accentLow : params.amp
+          });
+          totalLength += length;
+        }
+        if (char === "_" && clipNotes.length) {
+          clipNotes[clipNotes.length - 1].length += length;
+          totalLength += length;
+        }
+        if (parentNoteLength && totalLength !== parentNoteLength && idx === patternArr.length - 1) {
+          const diff = Math.abs(
+            parentNoteLength - totalLength
+          );
+          const lastClipNote = clipNotes[clipNotes.length - 1];
+          if (lastClipNote.length > diff) {
+            lastClipNote.length = lastClipNote.length - diff;
+          } else {
+            lastClipNote.length = lastClipNote.length + diff;
+          }
+        }
+        if (step === ((_a = params.notes) == null ? void 0 : _a.length)) {
+          step = 0;
+        }
+      }
+      if (Array.isArray(char)) {
+        let isTriplet = false;
+        if (char.length % 2 !== 0 || length % 2 !== 0) {
+          isTriplet = true;
+        }
+        recursivelyApplyPatternToNotes(
+          char,
+          Math.round(length / char.length),
+          isTriplet && length
+        );
+        totalLength += length;
+      }
+    });
+  };
+  recursivelyApplyPatternToNotes(
+    expandStr(params.pattern),
+    hdr[params.subdiv] || hdr["4n"],
+    false
+  );
+  if (params.sizzle) {
+    const volArr = [];
+    const style = params.sizzle === true ? "sin" : params.sizzle;
+    const beats = clipNotes.length;
+    const amp = params.amp;
+    const sizzleReps = params.sizzleReps;
+    const stepLevel = amp / (beats / sizzleReps);
+    if (style === "sin" || style === "cos") {
+      for (let i = 0; i < beats; i++) {
+        const level = Math[style](i * Math.PI / (beats / sizzleReps)) * amp;
+        volArr.push(Math.round(Math.abs(level)));
+      }
+    }
+    if (style === "rampUp") {
+      let level = 0;
+      for (let i = 0; i < beats; i++) {
+        if (i % (beats / sizzleReps) === 0) {
+          level = 0;
+        } else {
+          level = level + stepLevel;
+        }
+        volArr.push(Math.round(Math.abs(level)));
+      }
+    }
+    if (style === "rampDown") {
+      let level = amp;
+      for (let i = 0; i < beats; i++) {
+        if (i % (beats / sizzleReps) === 0) {
+          level = amp;
+        } else {
+          level = level - stepLevel;
+        }
+        volArr.push(Math.round(Math.abs(level)));
+      }
+    }
+    for (let i = 0; i < volArr.length; i++) {
+      clipNotes[i].level = volArr[i] ? volArr[i] : 1;
+    }
+  }
+  if (params.accent) {
+    if (/[^x-]/.test(params.accent)) {
+      throw new TypeError("Accent can only have x and - characters");
+    }
+    let a = 0;
+    for (const clipNote of clipNotes) {
+      let level = params.accent[a] === "x" ? params.amp : params.accentLow;
+      if (params.sizzle) {
+        level = (clipNote.level + level) / 2;
+      }
+      clipNote.level = Math.round(level);
+      a = a + 1;
+      if (a === params.accent.length) {
+        a = 0;
+      }
+    }
+  }
+  return clipNotes;
+};
+
+// src/progression.ts
+import { scale } from "harmonics";
+var getChordDegrees = (mode) => {
+  const theRomans = {
+    ionian: ["I", "ii", "iii", "IV", "V", "vi", "vii\xB0"],
+    dorian: ["i", "ii", "III", "IV", "v", "vi\xB0", "VII"],
+    phrygian: ["i", "II", "III", "iv", "v\xB0", "VI", "vii"],
+    lydian: ["I", "II", "iii", "iv\xB0", "V", "vi", "vii"],
+    mixolydian: ["I", "ii", "iii\xB0", "IV", "v", "vi", "VII"],
+    aeolian: ["i", "ii\xB0", "III", "iv", "v", "VI", "VII"],
+    locrian: ["i\xB0", "II", "iii", "iv", "V", "VI", "vii"],
+    "melodic minor": ["i", "ii", "III+", "IV", "V", "vi\xB0", "vii\xB0"],
+    "harmonic minor": ["i", "ii\xB0", "III+", "iv", "V", "VI", "vii\xB0"]
+  };
+  theRomans.major = theRomans.ionian;
+  theRomans.minor = theRomans.aeolian;
+  return theRomans[mode] || [];
+};
+var idxByDegree = {
+  i: 0,
+  ii: 1,
+  iii: 2,
+  iv: 3,
+  v: 4,
+  vi: 5,
+  vii: 6
+};
+var getChordName = (roman) => {
+  const str = roman.replace(/\W/g, "");
+  let prefix = "M";
+  if (str.toLowerCase() === str) {
+    prefix = "m";
+  }
+  if (roman.indexOf("\xB0") > -1) {
+    return prefix + "7b5";
+  }
+  if (roman.indexOf("+") > -1) {
+    return prefix + "#5";
+  }
+  if (roman.indexOf("7") > -1) {
+    return prefix === "M" ? "maj7" : "m7";
+  }
+  return prefix;
+};
+var getChordsByProgression = (noteOctaveScale, chordDegress) => {
+  const noteOctaveScaleArr = noteOctaveScale.split(" ");
+  if (!noteOctaveScaleArr[0].match(/\d/)) {
+    noteOctaveScaleArr[0] += "4";
+    noteOctaveScale = noteOctaveScaleArr.join(" ");
+  }
+  const mode = scale(noteOctaveScale);
+  const chordDegreesArr = chordDegress.replace(/\s*,+\s*/g, " ").split(" ");
+  const chordFamily = chordDegreesArr.map((roman) => {
+    const chordName = getChordName(roman);
+    const scaleId = idxByDegree[roman.replace(/\W|\d/g, "").toLowerCase()];
+    const note = mode[scaleId];
+    const oct = note.replace(/\D+/, "");
+    return note.replace(/\d/, "") + chordName + "_" + oct;
+  });
+  return chordFamily.toString().replace(/,/g, " ");
+};
+var getProgFactory = ({ T, P, D }) => {
+  return (count = 4) => {
+    const chords2 = [];
+    chords2.push(pickOne(T));
+    let i = 1;
+    if (i < count - 1) {
+      chords2.push(pickOne(P));
+      i++;
+    }
+    if (i < count - 1 && dice()) {
+      chords2.push(pickOne(P));
+      i++;
+    }
+    if (i < count - 1) {
+      chords2.push(pickOne(D));
+      i++;
+    }
+    if (i < count - 1) {
+      chords2.push(pickOne(P));
+      i++;
+    }
+    if (i < count - 1) {
+      chords2.push(pickOne(D));
+      i++;
+    }
+    if (i < count - 1 && dice()) {
+      chords2.push(pickOne(P));
+      i++;
+    }
+    while (i < count) {
+      chords2.push(pickOne(D));
+      i++;
+    }
+    return chords2;
+  };
+};
+var M = getProgFactory({ T: ["I", "vi"], P: ["ii", "IV"], D: ["V"] });
+var m = getProgFactory({ T: ["i", "VI"], P: ["ii", "iv"], D: ["V"] });
+var progression = (scaleType, count = 4) => {
+  if (scaleType === "major" || scaleType === "M") {
+    return M(count);
+  }
+  if (scaleType === "minor" || scaleType === "m") {
+    return m(count);
+  }
+  return [];
+};
+
+// src/arp.ts
+import { inlineChord as inlineChord2 } from "harmonics";
+var DEFAULT_OCTAVE = 4;
+var fillArr = (arr, len) => {
+  const bumpOctave = (el) => {
+    if (!el) {
+      throw new Error("Empty element");
+    }
+    const note = el.replace(/\d/, "");
+    const oct = el.replace(/\D/g, "") || DEFAULT_OCTAVE;
+    if (!note) {
+      throw new Error("Incorrect note");
+    }
+    return note + (+oct + 1);
+  };
+  const arr1 = arr.map(bumpOctave);
+  const arr2 = arr1.map(bumpOctave);
+  const finalArr = [...arr, ...arr1, ...arr2];
+  return finalArr.slice(0, len);
+};
+var arp = (chordsOrParams) => {
+  let finalArr = [];
+  const params = {
+    count: 4,
+    order: "0123",
+    chords: ""
+  };
+  if (typeof chordsOrParams === "string") {
+    params.chords = chordsOrParams;
+  } else {
+    if (chordsOrParams.order && chordsOrParams.order.match(/\D/g)) {
+      throw new TypeError("Invalid value for order");
+    }
+    if (chordsOrParams.count > 8 || chordsOrParams.count < 2) {
+      throw new TypeError("Invalid value for count");
+    }
+    if (chordsOrParams.count && !chordsOrParams.order) {
+      params.order = Array.from(Array(chordsOrParams.count).keys()).join("");
+    }
+    Object.assign(params, chordsOrParams);
+  }
+  if (typeof params.chords === "string") {
+    const chordsArr = params.chords.split(" ");
+    chordsArr.forEach((c, i) => {
+      try {
+        const filledArr = fillArr(inlineChord2(c), params.count);
+        const reorderedArr = params.order.split("").map((idx) => filledArr[idx]);
+        finalArr = [...finalArr, ...reorderedArr];
+      } catch (e) {
+        throw new Error(
+          `Cannot decode chord ${i + 1} "${c}" in given "${params.chords}"`
+        );
+      }
+    });
+  } else if (Array.isArray(params.chords)) {
+    params.chords.forEach((c, i) => {
+      try {
+        const filledArr = fillArr(c, params.count);
+        const reorderedArr = params.order.split("").map((idx) => filledArr[idx]);
+        finalArr = [...finalArr, ...reorderedArr];
+      } catch (e) {
+        throw new Error(
+          `${errorHasMessage(e) ? e.message : e} in chord ${i + 1} "${c}"`
+        );
+      }
+    });
+  } else {
+    throw new TypeError("Invalid value for chords");
+  }
+  return finalArr;
+};
+
+// src/midi.ts
+import fs from "fs";
+import * as jsmidgen from "jsmidgen";
+var midi = (notes, fileName = "music.mid", bpm) => {
+  const file = createFileFromNotes(notes, bpm);
+  const bytes = file.toBytes();
+  if (fileName === null) {
+    return bytes;
+  }
+  if (!fileName.endsWith(".mid")) {
+    fileName = fileName + ".mid";
+  }
+  if (typeof window !== "undefined" && window.URL && window.URL.createObjectURL) {
+    return createDownloadLink(bytes, fileName);
+  }
+  fs.writeFileSync(fileName, bytes, "binary");
+  console.log(`MIDI file generated: ${fileName}.`);
+};
+var createDownloadLink = (b, fileName) => {
+  const bytes = new Uint8Array(b.length);
+  for (let i = 0; i < b.length; i++) {
+    const ascii = b.charCodeAt(i);
+    bytes[i] = ascii;
+  }
+  const blob = new Blob([bytes], { type: "audio/midi" });
+  const link = document.createElement("a");
+  link.href = typeof window !== "undefined" && typeof window.URL !== "undefined" && typeof window.URL.createObjectURL !== "undefined" && window.URL.createObjectURL(blob) || "";
+  link.download = fileName;
+  link.innerText = "Download MIDI file";
+  return link;
+};
+var createFileFromNotes = (notes, bpm) => {
+  const file = new jsmidgen.File();
+  const track = new jsmidgen.Track();
+  if (typeof bpm === "number") {
+    track.setTempo(bpm);
+  }
+  file.addTrack(track);
+  for (const noteObj of notes) {
+    const level = noteObj.level || 127;
+    if (noteObj.note) {
+      if (typeof noteObj.note === "string") {
+        track.noteOn(0, noteObj.note, noteObj.length, level);
+        track.noteOff(0, noteObj.note, noteObj.length, level);
+      } else {
+        track.addChord(0, noteObj.note, noteObj.length, level);
+      }
+    } else {
+      track.noteOff(0, "", noteObj.length);
+    }
+  }
+  return file;
+};
+export {
+  arp,
+  chord2 as chord,
+  chords,
+  clip,
+  getChordDegrees,
+  getChordsByProgression,
+  midi,
+  scale2 as mode,
+  scales as modes,
+  progression,
+  scale2 as scale,
+  scales
+};

package/dist/lib/arp.d.ts

@@ -0,0 +1,10 @@
+import type { ArpParams } from './types';
+/**
+ *
+ * @param chordsOrParams a string that denotes space (comma?) separated chords to be used or an object with additional properties
+ * By default, if this is a string, the count of notes generated is 8 and the order is ascending.
+ * For instance arp('CM FM') will result in an array of notes [C4, E4, G4, F4, A4, C4, C5, E5]
+ * You can even provide Params as an object.
+ * For e.g. arp({count: 8, order: '10325476', chords: 'FM_4 Gm7b5_4 AbM_4 Bbm_4 Cm_5 DbM_5 EbM_5})
+ */
+export declare const arp: (chordsOrParams: string | ArpParams) => string[];

package/dist/lib/browser-clip.d.ts

@@ -0,0 +1,14 @@
+import { Channel } from './channel';
+import type { ClipParams } from './types';
+export declare const getNote: (el: string, params: ClipParams, counter: number) => string | (string | string[])[];
+export declare const getDuration: (params: ClipParams, counter: number) => string | number | undefined;
+export declare const recursivelyApplyPatternToDurations: (patternArr: string[], length: number, durations?: number[]) => number[];
+export declare const totalPatternDuration: (pattern: string, subdivOrLength: string | number) => number;
+export declare const renderingDuration: (pattern: string, subdivOrLength: string | number, notes: string | (string | string[])[], randomNotes: undefined | null | string | (string | string[])[]) => number;
+/**
+ * @param  {Object}
+ * @return {Tone.js Sequence Object}
+ * Take a object literal that may have a Tone.js player OR instrument
+ * or simply a sample or synth with a pattern and return a Tone.js sequence
+ */
+export declare const clip: (params: ClipParams, channel: Channel) => any;

package/dist/lib/browser-index.d.ts

@@ -0,0 +1,7 @@
+import { scales, chords, scale, chord } from 'harmonics';
+import { clip } from './browser-clip';
+import { getChordDegrees, getChordsByProgression, progression } from './progression';
+import { arp } from './arp';
+import { Session } from './session';
+export * from './types';
+export { scale, scale as mode, scales, scales as modes, chord, chords, clip, getChordDegrees, getChordsByProgression, progression, arp, Session, };

package/dist/lib/channel.d.ts

@@ -0,0 +1,61 @@
+import type { ChannelParams, ClipParams, SeqFn } from './types';
+/**
+ * Channel
+ * A channel is made up of a Tone.js Player/Instrument, one or more
+ * Tone.js sequences (known as clips in Scribbletune)
+ * & optionally a set of effects (with or without presets)
+ *
+ * API:
+ * clips -> Get all clips for this channel
+ * addClip -> Add a new clip to the channel
+ * startClip -> Start a clip at the provided index
+ * stopClip -> Stop a clip at the provided index
+ * activeClipIdx -> Get the clip that is currently playing
+ */
+export declare class Channel {
+    idx: number | string;
+    name: string;
+    activePatternIdx: number;
+    channelClips: any;
+    clipNoteCount: number;
+    instrument: any;
+    external: any;
+    initializerTask: Promise<void>;
+    hasLoaded: boolean;
+    hasFailed: boolean | Error;
+    private eventCbFn;
+    private playerCbFn;
+    private counterResetTask;
+    constructor(params: ChannelParams);
+    static setTransportTempo(valueBpm: number): void;
+    static startTransport(): void;
+    static stopTransport(deleteEvents?: boolean): void;
+    setVolume(volume: number): void;
+    startClip(idx: number, position?: number | string): void;
+    stopClip(idx: number, position?: number | string): void;
+    addClip(clipParams: ClipParams, idx?: number): void;
+    /**
+     * @param  {Object} ClipParams clip parameters
+     * @return {Function} function that can be used as the callback in Tone.Sequence https://tonejs.github.io/docs/Sequence
+     */
+    getSeqFn(params: ClipParams): SeqFn;
+    private eventCb;
+    private playerCb;
+    /**
+     * Check Tone.js object loaded state and either invoke `resolve` right away, or attach to and wait using Tone onload cb.
+     * It's an ugly hack that reaches into Tone's internal ._buffers or ._buffer to insert itself into .onload() callback.
+     * Tone has different ways to pull the onload callback from within to the API, so this implementation is very brittle.
+     * The sole reason for its existence is to handle async loaded state of Tone instruments that we allow to pass in from outside.
+     * If that option is eliminated, then this hacky function can be killed (or re-implemented via public onload API)
+     * @param toneObject Tone.js object (will work with non-Tone objects that have same loaded/onload properties)
+     * @param resolve onload callback
+     */
+    private checkToneObjLoaded;
+    private recreateToneObjectInContext;
+    private initOutputProducer;
+    private initInstrument;
+    private adjustInstrument;
+    private initEffects;
+    get clips(): any[];
+    get activeClipIdx(): number;
+}

package/dist/lib/clip.d.ts

@@ -0,0 +1,2 @@
+import type { ClipParams, NoteObject } from './types';
+export declare const clip: (params: ClipParams) => NoteObject[];

package/dist/lib/index.d.ts

@@ -0,0 +1,7 @@
+import { scales, chords, scale, chord } from 'harmonics';
+import { clip } from './clip';
+import { getChordDegrees, getChordsByProgression, progression } from './progression';
+import { arp } from './arp';
+import { midi } from './midi';
+export * from './types';
+export { scale, scale as mode, scales, scales as modes, chord, chords, clip, getChordDegrees, getChordsByProgression, progression, arp, midi, };

package/dist/lib/midi.d.ts

@@ -0,0 +1,11 @@
+import type { NoteObject } from './types';
+/**
+ * Take an array of note objects to generate a MIDI file in the same location as this method is called
+ * @param  {NoteObject[]} notes    Notes are in the format: {note: ['c3'], level: 127, length: 64}
+ * @param  {String | null} fileName If a filename is not provided, then `music.mid` is used by default
+ * If `null` is passed for `fileName`, bytes are returned instead of creating a file
+ * If this method is called from a browser then it will return a HTML link that you can append in your page
+ * This link will enable the generated MIDI as a downloadable file.
+ * @param {Number | null} bpm If a value is provided, the generated midi file will be set to this bpm value.
+ */
+export declare const midi: (notes: NoteObject[], fileName?: string | null, bpm?: number | undefined) => string | HTMLAnchorElement | undefined;

package/dist/lib/progression.d.ts

@@ -0,0 +1,25 @@
+import type { ProgressionScale } from './types';
+/**
+ * Get the chords that go with a given scale/mode
+ * This is useful only in case you want to check what chords work with a scale/mode
+ * so that you can come up with chord progressions
+ * @param  {String} mode e.g. major
+ * @return {Array} e.g.['I', 'ii', 'iii', 'IV', 'V', 'vi', 'vii°']
+ */
+export declare const getChordDegrees: (mode: string) => string[];
+/**
+ * Take the specified scale and degrees and return the chord names for them
+ * These can be used as the value for the `notes` param of the `clip` method
+ * @param {String} noteOctaveScale e.g. 'C4 major'
+ * @param  {String} chordDegress e.g. 'I IV V IV'
+ * @return {String} e.g. 'CM FM GM FM'
+ */
+export declare const getChordsByProgression: (noteOctaveScale: string, chordDegress: string) => string;
+/**
+ * Generate a chord progression based on basic music theory
+ * where we follow tonic to optionally predominant and then dominant
+ * and then randomly to predominant and continue this till we reach `count`
+ * @param scaleType e.g. M (for major chord progression), m (for minor chord progression)
+ * @param count e.g. 4
+ */
+export declare const progression: (scaleType: ProgressionScale, count?: number) => any[];

package/dist/lib/session.d.ts

@@ -0,0 +1,14 @@
+import { Channel } from './channel';
+import type { ChannelParams, PlayParams } from './types';
+export declare class Session {
+    sessionChannels: Channel[];
+    constructor(arr: ChannelParams[]);
+    uniqueIdx(channels: Channel[], idx?: string | number): string | number;
+    createChannel(ch: ChannelParams): Channel;
+    get channels(): Channel[];
+    setTransportTempo(valueBpm: number): void;
+    startTransport(): void;
+    stopTransport(deleteEvents?: boolean): void;
+    startRow(idx: number): void;
+    play(params: PlayParams): void;
+}

package/dist/lib/types/arp-params.d.ts

@@ -0,0 +1,6 @@
+interface ArpParams {
+    count: number;
+    order?: string;
+    chords: string | any[];
+}
+export type { ArpParams };