@musodojo/music-theory-data 14.0.0

package/src/data/labels/note-labels.ts

@@ -0,0 +1,451 @@
+export type NoteInteger = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
+
+const _noteLetters = [
+  "C",
+  "D",
+  "E",
+  "F",
+  "G",
+  "A",
+  "B",
+] as const;
+
+export type NoteLetter = typeof _noteLetters[number];
+
+export const noteLetters: readonly NoteLetter[] = _noteLetters;
+
+const _noteAccidentalToIntegerMap = {
+  "𝄫": -2,
+  "♭": -1,
+  "♮": 0,
+  "♯": 1,
+  "𝄪": 2,
+} as const;
+
+export type NoteAccidental = keyof typeof _noteAccidentalToIntegerMap;
+
+export const noteAccidentalToIntegerMap: ReadonlyMap<NoteAccidental, number> =
+  new Map(
+    Object.entries(_noteAccidentalToIntegerMap) as [NoteAccidental, number][],
+  );
+
+const _enharmonicNoteNameGroups = [
+  ["C", "C♮", "B♯", "D𝄫"],
+  ["D♭", "C♯", "B𝄪"],
+  ["D", "D♮", "E𝄫", "C𝄪"],
+  ["E♭", "D♯", "F𝄫"],
+  ["E", "E♮", "F♭", "D𝄪"],
+  ["F", "F♮", "E♯", "G𝄫"],
+  ["G♭", "F♯", "E𝄪"],
+  ["G", "G♮", "A𝄫", "F𝄪"],
+  ["A♭", "G♯"],
+  ["A", "A♮", "B𝄫", "G𝄪"],
+  ["B♭", "A♯", "C𝄫"],
+  ["B", "B♮", "C♭", "A𝄪"],
+] as const;
+
+export type NoteName = typeof _enharmonicNoteNameGroups[number][number];
+
+export const enharmonicNoteNameGroups: readonly (readonly NoteName[])[] =
+  _enharmonicNoteNameGroups;
+
+export const noteNames: readonly NoteName[] = enharmonicNoteNameGroups.flat();
+
+export const noteNamesSet: ReadonlySet<NoteName> = new Set(noteNames);
+
+export const noteNameToIntegerMap: ReadonlyMap<NoteName, NoteInteger> = (() => {
+  const map = new Map<NoteName, NoteInteger>();
+  _enharmonicNoteNameGroups.forEach((group, index) => {
+    group.forEach((note) => {
+      map.set(note, index as NoteInteger);
+    });
+  });
+  return map;
+})();
+
+const _enharmonicRootNoteGroups = [
+  ["C", "B♯"],
+  ["D♭", "C♯"],
+  ["D"],
+  ["E♭", "D♯"],
+  ["E", "F♭"],
+  ["F", "E♯"],
+  ["G♭", "F♯"],
+  ["G"],
+  ["A♭", "G♯"],
+  ["A"],
+  ["B♭", "A♯"],
+  ["B", "C♭"],
+] as const;
+
+export type RootNote = typeof _enharmonicRootNoteGroups[number][number];
+
+export const enharmonicRootNoteGroups: readonly (readonly RootNote[])[] =
+  _enharmonicRootNoteGroups;
+
+export const rootNotes: readonly RootNote[] = enharmonicRootNoteGroups.flat();
+
+export const rootNotesSet: ReadonlySet<RootNote> = new Set(rootNotes);
+
+export const rootNoteToIntegerMap: ReadonlyMap<RootNote, NoteInteger> = (() => {
+  const map = new Map<RootNote, NoteInteger>();
+  enharmonicRootNoteGroups.forEach((group, index) => {
+    group.forEach((note) => {
+      map.set(note, index as NoteInteger);
+    });
+  });
+  return map;
+})();
+
+export type SimpleIntervalNumber =
+  | "1"
+  | "2"
+  | "3"
+  | "4"
+  | "5"
+  | "6"
+  | "7"
+  | "8";
+
+const _simpleIntervalToIntegerMap = {
+  "𝄫1": -2,
+  "♭1": -1,
+  "♮1": 0,
+  "1": 0,
+  "♯1": 1,
+  "𝄪1": 2,
+
+  "𝄫2": 0,
+  "♭2": 1,
+  "♮2": 2,
+  "2": 2,
+  "♯2": 3,
+  "𝄪2": 4,
+
+  "𝄫3": 2,
+  "♭3": 3,
+  "♮3": 4,
+  "3": 4,
+  "♯3": 5,
+  "𝄪3": 6,
+
+  "𝄫4": 3,
+  "♭4": 4,
+  "♮4": 5,
+  "4": 5,
+  "♯4": 6,
+  "𝄪4": 7,
+
+  "𝄫5": 5,
+  "♭5": 6,
+  "♮5": 7,
+  "5": 7,
+  "♯5": 8,
+  "𝄪5": 9,
+
+  "𝄫6": 7,
+  "♭6": 8,
+  "♮6": 9,
+  "6": 9,
+  "♯6": 10,
+  "𝄪6": 11,
+
+  "𝄫7": 9,
+  "♭7": 10,
+  "♮7": 11,
+  "7": 11,
+  "♯7": 12,
+  "𝄪7": 13,
+
+  "𝄫8": 10,
+  "♭8": 11,
+  "♮8": 12,
+  "8": 12,
+  "♯8": 13,
+  "𝄪8": 14,
+} as const;
+
+export type SimpleInterval = keyof typeof _simpleIntervalToIntegerMap;
+
+export type CompoundIntervalNumber =
+  | "9"
+  | "10"
+  | "11"
+  | "12"
+  | "13"
+  | "14"
+  | "15";
+
+const _compoundIntervalToIntegerMap = {
+  "𝄫9": 12,
+  "♭9": 13,
+  "♮9": 14,
+  "9": 14,
+  "♯9": 15,
+  "𝄪9": 16,
+
+  "𝄫10": 14,
+  "♭10": 15,
+  "♮10": 16,
+  "10": 16,
+  "♯10": 17,
+  "𝄪10": 18,
+
+  "𝄫11": 15,
+  "♭11": 16,
+  "♮11": 17,
+  "11": 17,
+  "♯11": 18,
+  "𝄪11": 19,
+
+  "𝄫12": 17,
+  "♭12": 18,
+  "♮12": 19,
+  "12": 19,
+  "♯12": 20,
+  "𝄪12": 21,
+
+  "𝄫13": 19,
+  "♭13": 20,
+  "♮13": 21,
+  "13": 21,
+  "♯13": 22,
+  "𝄪13": 23,
+
+  "𝄫14": 21,
+  "♭14": 22,
+  "♮14": 23,
+  "14": 23,
+  "♯14": 24,
+  "𝄪14": 25,
+
+  "𝄫15": 22,
+  "♭15": 23,
+  "♮15": 24,
+  "15": 24,
+  "♯15": 25,
+  "𝄪15": 26,
+} as const;
+
+export type CompoundInterval = keyof typeof _compoundIntervalToIntegerMap;
+
+export type IntervalNumber = SimpleIntervalNumber | CompoundIntervalNumber;
+
+const _intervalToIntegerMap = {
+  ..._simpleIntervalToIntegerMap,
+  ..._compoundIntervalToIntegerMap,
+} as const;
+
+export type Interval = keyof typeof _intervalToIntegerMap;
+
+export const intervalToIntegerMap: ReadonlyMap<Interval, number> = new Map(
+  Object.entries(_intervalToIntegerMap) as [Interval, number][],
+);
+
+const _simpleToExtensionIntervalMap = {
+  "2": "9",
+  "♮2": "♮9",
+  "♭2": "♭9",
+  "♯2": "♯9",
+  "4": "11",
+  "♮4": "♮11",
+  "♭4": "♭11",
+  "♯4": "♯11",
+  "6": "13",
+  "♮6": "♮13",
+  "♭6": "♭13",
+  "♯6": "♯13",
+} as const;
+
+export const simpleToExtensionIntervalMap: ReadonlyMap<
+  SimpleInterval,
+  CompoundInterval
+> = new Map(
+  Object.entries(_simpleToExtensionIntervalMap) as [
+    SimpleInterval,
+    CompoundInterval,
+  ][],
+);
+
+const _extensionToSimpleIntervalMap = {
+  "9": "2",
+  "♮9": "♮2",
+  "♭9": "♭2",
+  "♯9": "♯2",
+  "11": "4",
+  "♮11": "♮4",
+  "♭11": "♭4",
+  "♯11": "♯4",
+  "13": "6",
+  "♮13": "♮6",
+  "♭13": "♭6",
+  "♯13": "♯6",
+} as const;
+
+export const extensionToSimpleIntervalMap: ReadonlyMap<
+  CompoundInterval,
+  SimpleInterval
+> = new Map(
+  Object.entries(_extensionToSimpleIntervalMap) as [
+    CompoundInterval,
+    SimpleInterval,
+  ][],
+);
+
+const _simpleToCompoundIntervalMap = {
+  "2": "9",
+  "♮2": "♮9",
+  "♭2": "♭9",
+  "♯2": "♯9",
+  "3": "10",
+  "♮3": "♮10",
+  "♭3": "♭10",
+  "♯3": "♯10",
+  "4": "11",
+  "♮4": "♮11",
+  "♭4": "♭11",
+  "♯4": "♯11",
+  "5": "12",
+  "♮5": "♮12",
+  "♭5": "♭12",
+  "♯5": "♯12",
+  "6": "13",
+  "♮6": "♮13",
+  "♭6": "♭13",
+  "♯6": "♯13",
+  "7": "14",
+  "♮7": "♮14",
+  "♭7": "♭14",
+  "♯7": "♯14",
+} as const;
+
+export const simpleToCompoundIntervalMap: ReadonlyMap<
+  SimpleInterval,
+  CompoundInterval
+> = new Map(
+  Object.entries(_simpleToCompoundIntervalMap) as [
+    SimpleInterval,
+    CompoundInterval,
+  ][],
+);
+
+const _compoundToSimpleIntervalMap = {
+  "9": "2",
+  "♮9": "♮2",
+  "♭9": "♭2",
+  "♯9": "♯2",
+  "10": "3",
+  "♮10": "♮3",
+  "♭10": "♭3",
+  "♯10": "♯3",
+  "11": "4",
+  "♮11": "♮4",
+  "♭11": "♭4",
+  "♯11": "♯4",
+  "12": "5",
+  "♮12": "♮5",
+  "♭12": "♭5",
+  "♯12": "♯5",
+  "13": "6",
+  "♮13": "♮6",
+  "♭13": "♭6",
+  "♯13": "♯6",
+  "14": "7",
+  "♮14": "♮7",
+  "♭14": "♭7",
+  "♯14": "♯7",
+} as const;
+
+export const compoundToSimpleIntervalMap: ReadonlyMap<
+  CompoundInterval,
+  SimpleInterval
+> = new Map(
+  Object.entries(_compoundToSimpleIntervalMap) as [
+    CompoundInterval,
+    SimpleInterval,
+  ][],
+);
+
+export type IntervalQualityType = "d" | "m" | "P" | "M" | "A";
+
+const _intervalQualityToIntegerMap = {
+  "d1": -1,
+  "P1": 0,
+  "A1": 1,
+
+  "d2": 0,
+  "m2": 1,
+  "M2": 2,
+  "A2": 3,
+
+  "d3": 2,
+  "m3": 3,
+  "M3": 4,
+  "A3": 5,
+
+  "d4": 4,
+  "P4": 5,
+  "A4": 6,
+
+  "d5": 6,
+  "P5": 7,
+  "A5": 8,
+
+  "d6": 7,
+  "m6": 8,
+  "M6": 9,
+  "A6": 10,
+
+  "d7": 9,
+  "m7": 10,
+  "M7": 11,
+  "A7": 12,
+
+  "d8": 11,
+  "P8": 12,
+  "A8": 13,
+
+  "d9": 12,
+  "m9": 13,
+  "M9": 14,
+  "A9": 15,
+
+  "d10": 14,
+  "m10": 15,
+  "M10": 16,
+  "A10": 17,
+
+  "d11": 16,
+  "P11": 17,
+  "A11": 19,
+
+  "d12": 18,
+  "P12": 19,
+  "A12": 20,
+
+  "d13": 19,
+  "m13": 20,
+  "M13": 21,
+  "A13": 22,
+
+  "d14": 21,
+  "m14": 22,
+  "M14": 23,
+  "A14": 24,
+
+  "d15": 23,
+  "P15": 24,
+  "A15": 25,
+} as const;
+
+export type IntervalQuality = keyof typeof _intervalQualityToIntegerMap;
+
+export const intervalQualityToIntegerMap: ReadonlyMap<
+  IntervalQuality,
+  number
+> = new Map(
+  Object.entries(_intervalQualityToIntegerMap) as [
+    IntervalQuality,
+    number,
+  ][],
+);

package/src/data/mod.ts

@@ -0,0 +1,4 @@
+export * from "./chords/mod.ts";
+export * from "./colors/mod.ts";
+export * from "./labels/mod.ts";
+export * from "./note-collections/mod.ts";

package/src/data/note-collections/diatonic-modes.ts

@@ -0,0 +1,267 @@
+import type { NoteCollection } from "../../types/note-collections.d.ts";
+
+const ionian: NoteCollection = {
+  primaryName: "Major",
+  names: [
+    "Major",
+    "Ionian",
+    "Major Scale",
+    "Ionian Mode",
+    "Diatonic Major",
+  ],
+  intervals: ["1", "2", "3", "4", "5", "6", "7", "8"],
+  integers: [0, 2, 4, 5, 7, 9, 11],
+  rotation: 0,
+  type: [
+    "major",
+    "ionian",
+    "mode",
+    "scale",
+    "church mode",
+    "diatonic mode",
+    "heptatonic",
+    "first diatonic mode",
+    "do mode",
+  ],
+  characteristics: [
+    "bright",
+    "happy",
+    "stable",
+    "uplifting",
+    "consonant",
+    "western",
+    "foundational",
+    "simple",
+    "pop music",
+    "major tonality",
+    "commonly used western scale",
+  ],
+  pattern: ["whole", "whole", "half", "whole", "whole", "whole", "half"],
+  patternShort: ["W", "W", "H", "W", "W", "W", "H"],
+} as const;
+
+const dorian: NoteCollection = {
+  primaryName: "Dorian",
+  names: [
+    "Dorian",
+    "Minor ♮6",
+    "Dorian Mode",
+  ],
+  intervals: ["1", "2", "♭3", "4", "5", "6", "♭7", "8"],
+  integers: [0, 2, 3, 5, 7, 9, 10],
+  rotation: 1,
+  type: [
+    "minor",
+    "dorian",
+    "mode",
+    "scale",
+    "church mode",
+    "diatonic mode",
+    "heptatonic",
+    "second diatonic mode",
+    "re mode",
+  ],
+  characteristics: [
+    "soulful",
+    "funky",
+    "jazzy",
+    "hopeful",
+    "celtic",
+    "folk",
+    "minor tonality",
+    "versatile",
+    "used in folk, jazz, and rock",
+    "medieval",
+    "minor feel with a hopeful twist",
+  ],
+  pattern: ["whole", "half", "whole", "whole", "whole", "half", "whole"],
+  patternShort: ["W", "H", "W", "W", "W", "H", "W"],
+} as const;
+
+const phrygian: NoteCollection = {
+  primaryName: "Phrygian",
+  names: [
+    "Phrygian",
+    "Minor ♭2",
+    "Phrygian Mode",
+  ],
+  intervals: ["1", "♭2", "♭3", "4", "5", "♭6", "♭7", "8"],
+  integers: [0, 1, 3, 5, 7, 8, 10],
+  rotation: 2,
+  type: [
+    "minor",
+    "phrygian",
+    "mode",
+    "scale",
+    "church mode",
+    "diatonic mode",
+    "heptatonic",
+    "third diatonic mode",
+    "mi mode",
+  ],
+  characteristics: [
+    "exotic",
+    "spanish",
+    "flamenco",
+    "tense",
+    "dark",
+    "dramatic",
+    "minor tonality",
+    "darker emotional tones",
+    "often used in metal and flamenco",
+  ],
+  pattern: ["half", "whole", "whole", "whole", "half", "whole", "whole"],
+  patternShort: ["H", "W", "W", "W", "H", "W", "W"],
+} as const;
+
+const lydian: NoteCollection = {
+  primaryName: "Lydian",
+  names: ["Lydian", "Major ♯4", "Lydian Mode"],
+  intervals: ["1", "2", "3", "♯4", "5", "6", "7", "8"],
+  integers: [0, 2, 4, 6, 7, 9, 11],
+  rotation: 3,
+  type: [
+    "major",
+    "lydian",
+    "mode",
+    "scale",
+    "church mode",
+    "diatonic mode",
+    "heptatonic",
+    "fourth diatonic mode",
+    "fa mode",
+  ],
+  characteristics: [
+    "dreamy",
+    "floating",
+    "ethereal",
+    "cinematic",
+    "bright",
+    "bright major tonality",
+    "used in film scores and jazz",
+  ],
+  pattern: ["whole", "whole", "whole", "half", "whole", "whole", "half"],
+  patternShort: ["W", "W", "W", "H", "W", "W", "H"],
+} as const;
+
+const mixolydian: NoteCollection = {
+  primaryName: "Mixolydian",
+  names: [
+    "Mixolydian",
+    "Major ♭7",
+    "Dominant Scale",
+    "Mixolydian Mode",
+  ],
+  intervals: ["1", "2", "3", "4", "5", "6", "♭7", "8"],
+  integers: [0, 2, 4, 5, 7, 9, 10],
+  rotation: 4,
+  type: [
+    "major",
+    "dominant",
+    "mixolydian",
+    "mode",
+    "scale",
+    "church mode",
+    "diatonic mode",
+    "heptatonic",
+    "fifth diatonic mode",
+    "sol mode",
+  ],
+  characteristics: [
+    "bluesy",
+    "dominant",
+    "funky",
+    "rock",
+    "energetic",
+    "major tonality",
+    "strong blues and rock feel",
+  ],
+  pattern: ["whole", "whole", "half", "whole", "whole", "half", "whole"],
+  patternShort: ["W", "W", "H", "W", "W", "H", "W"],
+} as const;
+
+const aeolian: NoteCollection = {
+  primaryName: "Minor",
+  names: [
+    "Minor",
+    "Aeolian",
+    "Natural Minor Scale",
+    "Aeolian Mode",
+    "Descending Melodic Minor Scale",
+  ],
+  intervals: ["1", "2", "♭3", "4", "5", "♭6", "♭7", "8"],
+  integers: [0, 2, 3, 5, 7, 8, 10],
+  rotation: 5,
+  type: [
+    "minor",
+    "aeolian",
+    "natural",
+    "mode",
+    "scale",
+    "church mode",
+    "diatonic mode",
+    "heptatonic",
+    "sixth diatonic mode",
+    "la mode",
+  ],
+  characteristics: [
+    "melancholic",
+    "sad",
+    "somber",
+    "introspective",
+    "dark",
+    "minor tonality",
+    "the relative minor of the major scale",
+  ],
+  pattern: ["whole", "half", "whole", "whole", "half", "whole", "whole"],
+  patternShort: ["W", "H", "W", "W", "H", "W", "W"],
+} as const;
+
+const locrian: NoteCollection = {
+  primaryName: "Locrian",
+  names: [
+    "Locrian",
+    "Minor ♭2 ♭5",
+    "Locrian Mode",
+  ],
+  intervals: ["1", "♭2", "♭3", "4", "♭5", "♭6", "♭7", "8"],
+  integers: [0, 1, 3, 5, 6, 8, 10],
+  rotation: 6,
+  type: [
+    "diminished",
+    "locrian",
+    "mode",
+    "scale",
+    "church mode",
+    "diatonic mode",
+    "heptatonic",
+    "seventh diatonic mode",
+    "ti mode",
+  ],
+  characteristics: [
+    "unsettling",
+    "tense",
+    "dark",
+    "unstable",
+    "dissonant",
+    "highly dissonant",
+    "rarely used as a tonal center",
+  ],
+  pattern: ["half", "whole", "whole", "half", "whole", "whole", "whole"],
+  patternShort: ["H", "W", "W", "H", "W", "W", "W"],
+} as const;
+
+const _diatonicModes = {
+  ionian,
+  dorian,
+  phrygian,
+  lydian,
+  mixolydian,
+  aeolian,
+  locrian,
+} as const;
+
+export type DiatonicModeKey = keyof typeof _diatonicModes;
+
+export const diatonicModes: Record<DiatonicModeKey, NoteCollection> =
+  _diatonicModes;