Merge pull request #8 from kilmc/expose-more-features

[Release] Expose more features and increase compatibility

.changeset/smart-steaks-buy.md

@@ -0,0 +1,5 @@
+---
+"@kilmc/music-fns": minor
+---
+
+Expose getScaleChords, guessScale, getScale, getEquivalentNote, getInterval, transposeNote

rollup.config.mjs

@@ -12,7 +12,7 @@ export default {
     },
     {
       file: pkg.module,
-      format: 'es',
+      format: 'esm',
     },
   ],
   plugins: [terser(), typescript({ outDir: 'dist' })],

src/chords/getScaleChords.ts

@@ -0,0 +1,14 @@
+import { majorScaleQualities, modes } from '../consts';
+import { offsetArr } from '../helper';
+import type { TMode } from '../types';
+import { getChord } from './getChord';
+import { scaleQualitiesToChordSymbol } from './helpers';
+
+export const getScaleChords = (scale: string[], mode: TMode) => {
+  const scaleQualities = offsetArr(majorScaleQualities, modes.indexOf(mode));
+
+  return scale.map((note, i) => {
+    const quality = scaleQualitiesToChordSymbol(scaleQualities[i]);
+    return getChord(`${note}${quality}`);
+  });
+};

src/consts.ts

@@ -160,6 +160,16 @@ export const majorScaleQualities: TChordQuality[] = [
   'diminished',
 ];
 
+export const majorScaleRomanNumerals = [
+  'I',
+  'ii',
+  'iii',
+  'IV',
+  'V',
+  'vi',
+  'vii',
+];
+
 export const addTypes = ['add2', 'add4', 'add9', 'add11', 'add13'];
 export const susTypes = ['sus2', 'sus4'];
 

src/keys/getKey.ts

@@ -1,14 +1,29 @@
-import { getChords } from '../chords/getChords';
+import { getScaleChords } from '../chords/getScaleChords';
 import { majorScales, modes } from '../consts';
 import { isMajor, offsetArr } from '../helper';
 import { getModeName } from '../modes/getName';
 import { isModeName } from '../modes/helpers';
 import { extractScaleName } from '../scale/extractName';
 import { getMajorFromMode } from '../scale/getMajorFromMode';
-import type { TMode } from '../types';
+import type { IChord, TMode } from '../types';
 import { getRelativeMinorName } from './helpers';
 
-export const getKey = (key: string) => {
+type KeyInfo = {
+  name: string;
+  notes: string[];
+  major: {
+    name: string;
+    notes: string[];
+  };
+  minor: {
+    name: string;
+    notes: string[];
+  };
+  modes(name: TMode): string[];
+  chords: IChord[];
+};
+
+export const getKey = (key: string): KeyInfo | undefined => {
   const [pitch, mode] = extractScaleName(key) || [];
 
   if (mode === undefined || pitch === undefined) {
@@ -38,10 +53,6 @@ export const getKey = (key: string) => {
     modes(name: TMode) {
       return offsetArr(majorScale, modes.indexOf(name));
     },
-    chords: getChords(scale, mode),
+    chords: getScaleChords(scale, mode),
   };
 };
-
-const possibleVersion = {
-  name: 'C major',
-};

src/main.ts

@@ -1,3 +1,18 @@
+// Chords
 export { getChord } from './chords/getChord';
+export { getScaleChords } from './chords/getScaleChords';
+
+// Keys
 export { getKey } from './keys/getKey';
+
+// Scales
+export { guessScale } from './scale/guessScale';
+export { getScale } from './scale/getScale';
+
+// Notes
+export { getEquivalentNote } from './notes/getEquivalentNote';
+export { getInterval } from './notes/getInterval';
+export { transposeNote } from './notes/transpose';
+
+// Consts
 export { majorScales } from './consts';

src/notes/getScaleDegreeOfNote.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it } from 'vitest';
+import { getScaleDegreeOfNote } from './getScaleDegreeOfNote';
+
+describe('getScaleDegreeOfNote', () => {
+  it('converts notes to degrees based on a scale', () => {
+    expect(
+      ['E', 'A', 'C#', 'B'].map((note) =>
+        getScaleDegreeOfNote(note, ['E', 'F#', 'G#', 'A', 'B', 'C#', 'D#'])
+      )
+    ).toStrictEqual(['I', 'IV', 'vi', 'V']);
+  });
+});

src/notes/getScaleDegreeOfNote.ts

@@ -0,0 +1,4 @@
+import { majorScaleRomanNumerals } from '../consts';
+
+export const getScaleDegreeOfNote = (note: string, scale: string[]) =>
+  majorScaleRomanNumerals[scale.indexOf(note)];

src/scale/guessScale.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'vitest';
+import { guessScale } from './guessScale';
+
+describe('guessScale', () => {
+  const testSongs = [
+    {
+      title: 'Dancing Queen',
+      includedNotes: ['D', 'E', 'F#', 'G#', 'A', 'B'],
+      excludedNotes: [],
+      key: 'A major',
+    },
+    {
+      title: "Say It Ain't So",
+      includedNotes: ['D#', 'F', 'G', 'G#', 'A#', 'C', 'D'],
+      excludedNotes: [],
+      key: 'Eb major',
+    },
+    {
+      title: 'Conspiracy',
+      includedNotes: ['C', 'D', 'E', 'F', 'G', 'A#'],
+      excludedNotes: [],
+      key: 'F major',
+    },
+    {
+      title: 'Last Nite',
+      includedNotes: ['C', 'D', 'E', 'F', 'G', 'A', 'B'],
+      excludedNotes: [],
+      key: 'C major',
+    },
+    {
+      title: 'The Dress',
+      includedNotes: ['C', 'C#', 'D#', 'F', 'G', 'G#', 'A#'],
+      excludedNotes: [],
+      key: 'Ab major',
+    },
+    {
+      title: 'Fell in Love Without You',
+      includedNotes: ['C#', 'D#', 'E'],
+      excludedNotes: ['C', 'D', 'F', 'G', 'A'],
+      key: 'B major',
+    },
+  ];
+
+  it.each(testSongs)('$title', ({ includedNotes, excludedNotes, key }) => {
+    expect(
+      guessScale(includedNotes, excludedNotes).map((x) => x.name)
+    ).toStrictEqual([key]);
+  });
+});

src/scale/guessScale.ts

@@ -0,0 +1,58 @@
+import { majorScales } from '../consts';
+import { getEquivalentNote } from '../notes/getEquivalentNote';
+
+// export const determineTonicFromNotes = (arr: string[]) => {
+//   const noteFrequency = Object.entries(
+//     arr.reduce<Record<string, number>>((accum, note) => {
+//       if (accum[note]) {
+//         accum[note] += accum[note];
+//       } else {
+//         accum[note] = 1;
+//       }
+
+//       return accum;
+//     }, {})
+//   ).sort((a, b) => {
+//     return b[1] - a[1];
+//   });
+
+//   return noteFrequency[0];
+// };
+
+const filterScalesFromNotes = (
+  notes: string[],
+  scales: string[][],
+  exclusive = false
+) => {
+  return scales.filter((scale) => {
+    if (exclusive) {
+      return !notes.some(
+        (note) =>
+          scale.includes(note) || scale.includes(getEquivalentNote(note))
+      );
+    } else {
+      return notes.every(
+        (note) =>
+          scale.includes(note) || scale.includes(getEquivalentNote(note))
+      );
+    }
+  });
+};
+
+type KeyGuess = { name?: string; scale: string[] };
+
+export const guessScale = (
+  includedNotes: string[],
+  excludedNotes: string[]
+): KeyGuess[] => {
+  const allMajors = Object.values(majorScales);
+  const possibleScales = filterScalesFromNotes(excludedNotes, allMajors, true);
+  const filteredScales = filterScalesFromNotes(includedNotes, possibleScales);
+
+  return filteredScales.map((scale) => {
+    return {
+      name: `${scale?.at(0)} major`,
+      scale,
+    };
+  });
+};