Implement the european notation (#1067)

* Implement the european notation

Resolves #401
Actually in the code the european notation is referred as "solfege" and it's treated like other ChordType notations, like "symbol" and "numeric"

* Fix eslint issues

* Add ChordsOverWordsFormatter test

Also little refactor and fixed a "Am" to "Lam" in key_config.ts

* eslint: fix errors

* fix whitespaces

* Revert packages updates

---------

Co-authored-by: Martijn Versluis <[email protected]>

Author: SamuMazzi

README.md

@@ -533,7 +533,7 @@ See https://www.chordpro.org/chordpro/directives-key/</p></dd>
 See https://www.chordpro.org/chordpro/directives-env_chorus/</p></dd>
 <dt><a href="#CHORD_STYLE">CHORD_STYLE</a> : <code>string</code></dt>
 <dd><p>Chord type directive. Determines the type of chords used in the rendered chord sheet.
-Possible values are 'symbol', 'numeral' and 'number'</p></dd>
+Possible values are 'solfege', 'symbol', 'numeral' and 'number'</p></dd>
 <dt><a href="#BRIDGE">BRIDGE</a> : <code>string</code></dt>
 <dd><p>Used to mark a paragraph as bridge</p></dd>
 <dt><a href="#CHORUS">CHORUS</a> : <code>string</code></dt>
@@ -1405,6 +1405,9 @@ Inherits from [ChordSheetParser](#ChordSheetParser)</p>
         * [.toChordSymbol([referenceKey])](#Chord+toChordSymbol) ⇒ [<code>Chord</code>](#Chord)
         * [.toChordSymbolString([referenceKey])](#Chord+toChordSymbolString) ⇒ <code>string</code>
         * [.isChordSymbol()](#Chord+isChordSymbol) ⇒ <code>boolean</code>
+        * [.toChordSolfege([referenceKey])](#Chord+toChordSolfege) ⇒ [<code>Chord</code>](#Chord)
+        * [.toChordSolfegeString([referenceKey])](#Chord+toChordSolfegeString) ⇒ <code>string</code>
+        * [.isChordSolfege()](#Chord+isChordSolfege) ⇒ <code>boolean</code>
         * [.toNumeric([referenceKey])](#Chord+toNumeric) ⇒ [<code>Chord</code>](#Chord)
         * [.toNumeral([referenceKey])](#Chord+toNumeral) ⇒ [<code>Chord</code>](#Chord)
         * [.toNumeralString([referenceKey])](#Chord+toNumeralString) ⇒ <code>string</code>
@@ -1460,6 +1463,41 @@ When the chord is already a chord symbol, it will return a string version of the
 ### chord.isChordSymbol() ⇒ <code>boolean</code>
 <p>Determines whether the chord is a chord symbol</p>
 
+**Kind**: instance method of [<code>Chord</code>](#Chord)  
+<a name="Chord+toChordSolfege"></a>
+
+### chord.toChordSolfege([referenceKey]) ⇒ [<code>Chord</code>](#Chord)
+<p>Converts the chord to a chord solfege, using the supplied key as a reference.
+For example, a numeric chord <code>#4</code> with reference key <code>Mi</code> will return the chord symbol <code>La#</code>.
+When the chord is already a chord solfege, it will return a clone of the object.</p>
+
+**Kind**: instance method of [<code>Chord</code>](#Chord)  
+**Returns**: [<code>Chord</code>](#Chord) - <p>the chord solfege</p>  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [referenceKey] | [<code>Key</code>](#Key) \| <code>string</code> \| <code>null</code> | <code></code> | <p>the reference key. The key is required when converting a numeric or numeral.</p> |
+
+<a name="Chord+toChordSolfegeString"></a>
+
+### chord.toChordSolfegeString([referenceKey]) ⇒ <code>string</code>
+<p>Converts the chord to a chord solfege string, using the supplied key as a reference.
+For example, a numeric chord <code>#4</code> with reference key <code>E</code> will return the chord solfege <code>A#</code>.
+When the chord is already a chord solfege, it will return a string version of the chord.</p>
+
+**Kind**: instance method of [<code>Chord</code>](#Chord)  
+**Returns**: <code>string</code> - <p>the chord solfege string</p>  
+**See**: {toChordSolfege}  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| [referenceKey] | [<code>Key</code>](#Key) \| <code>string</code> \| <code>null</code> | <code></code> | <p>the reference key. The key is required when converting a numeric or numeral.</p> |
+
+<a name="Chord+isChordSolfege"></a>
+
+### chord.isChordSolfege() ⇒ <code>boolean</code>
+<p>Determines whether the chord is a chord solfege</p>
+
 **Kind**: instance method of [<code>Chord</code>](#Chord)  
 <a name="Chord+toNumeric"></a>
 
@@ -1545,6 +1583,10 @@ For example, a chord symbol A# with reference key E will return the numeric chor
 ### chord.normalize([key], [options]) ⇒ [<code>Chord</code>](#Chord)
 <p>Normalizes the chord root and bass notes:</p>
 <ul>
+<li>Fab becomes Mi</li>
+<li>Dob becomes Si</li>
+<li>Si# becomes Do</li>
+<li>Mi# becomes Fa</li>
 <li>Fb becomes E</li>
 <li>Cb becomes B</li>
 <li>B# becomes C</li>
@@ -1898,7 +1940,7 @@ See https://www.chordpro.org/chordpro/directives-env_chorus/</p>
 
 ## CHORD\_STYLE : <code>string</code>
 <p>Chord type directive. Determines the type of chords used in the rendered chord sheet.
-Possible values are 'symbol', 'numeral' and 'number'</p>
+Possible values are 'solfege', 'symbol', 'numeral' and 'number'</p>
 
 **Kind**: global constant  
 **See**: https://github.com/bettermusic/ChordSheetJS/issues/352  

bin/generate_scales

@@ -2,11 +2,11 @@
 
 const fs = require('fs');
 
-const { FLAT, MAJOR, MINOR, NO_MODIFIER, NUMERAL, NUMERIC, SHARP, SYMBOL } = require('../src/constants');
+const { FLAT, MAJOR, MINOR, NO_MODIFIER, NUMERAL, NUMERIC, SHARP, SYMBOL, SOLFEGE } = require('../src/constants');
 const { default: SCALES } = require('../data/scales');
 
 const MODIFIERS = { 'NO_MODIFIER': NO_MODIFIER, 'SHARP': SHARP, 'FLAT': FLAT };
-const KEY_TYPES = { 'SYMBOL': SYMBOL, 'NUMERIC': NUMERIC, 'NUMERAL': NUMERAL };
+const KEY_TYPES = { 'SYMBOL': SYMBOL, 'SOLFEGE': SOLFEGE, 'NUMERIC': NUMERIC, 'NUMERAL': NUMERAL };
 const MODES = { 'MAJOR': MAJOR, 'MINOR': MINOR };
 
 const keyToGradeMapping = `
@@ -29,6 +29,7 @@ const keyToGradeMapping = `
     NUMERIC, 
     SHARP, 
     SYMBOL,
+    SOLFEGE
   } from './constants';
 
   export const KEY_TO_GRADE: Record<ChordType, Record<Mode, Record<ModifierMaybe, Record<string, number>>>> = {

data/scales.ts

@@ -8,14 +8,30 @@ import {
   NUMERAL,
   NUMERIC,
   SHARP,
+  SOLFEGE,
   SYMBOL,
 } from '../src/constants';
 
+const AmericanScale = {
+  [NO_MODIFIER]: ['C',  null, 'D',  null, 'E',  'F',  null, 'G',  null, 'A',  null, 'B' ],
+  [SHARP]:       ['B#', 'C#', null, 'D#', null, 'E#', 'F#', null, 'G#', null, 'A#', null],
+  [FLAT]:        [null, 'Db', null, 'Eb', 'Fb', null, 'Gb', null, 'Ab', null, 'Bb', 'Cb'],
+};
+
+const SolfegeScale = {
+  [NO_MODIFIER]: ['Do',  null, 'Re',  null, 'Mi',  'Fa',  null, 'Sol',  null, 'La',  null, 'Si' ],
+  [SHARP]:       ['Si#', 'Do#', null, 'Re#', null, 'Mi#', 'Fa#', null, 'Sol#', null, 'La#', null],
+  [FLAT]:        [null, 'Reb', null, 'Mib', 'Fab', null, 'Solb', null, 'Lab', null, 'Sib', 'Dob'],
+};
+
 const SCALES = {
   [SYMBOL]: {
-    [NO_MODIFIER]: ['C',  null, 'D',  null, 'E',  'F',  null, 'G',  null, 'A',  null, 'B' ],
-    [SHARP]:       ['B#', 'C#', null, 'D#', null, 'E#', 'F#', null, 'G#', null, 'A#', null],
-    [FLAT]:        [null, 'Db', null, 'Eb', 'Fb', null, 'Gb', null, 'Ab', null, 'Bb', 'Cb'],
+    [MINOR]: AmericanScale,
+    [MAJOR]: AmericanScale,
+  },
+  [SOLFEGE]: {
+    [MINOR]: SolfegeScale,
+    [MAJOR]: SolfegeScale,
   },
   [NUMERIC]: {
     [MINOR]: {
@@ -43,8 +59,4 @@ const SCALES = {
   },
 };
 
-const symbolScales = SCALES[SYMBOL];
-SCALES[SYMBOL][MAJOR] = symbolScales;
-SCALES[SYMBOL][MINOR] = symbolScales;
-
 export default SCALES;

src/chord.ts

@@ -8,6 +8,7 @@ import {
   NUMERAL,
   NUMERIC,
   SYMBOL,
+  SOLFEGE,
 } from './constants';
 
 interface ChordProperties {
@@ -110,6 +111,56 @@ class Chord implements ChordProperties {
     return this.is(SYMBOL);
   }
 
+  /**
+   * Converts the chord to a chord solfege, using the supplied key as a reference.
+   * For example, a numeric chord `#4` with reference key `Mi` will return the chord symbol `La#`.
+   * When the chord is already a chord solfege, it will return a clone of the object.
+   * @param {Key|string|null} [referenceKey=null] the reference key. The key is required when converting a
+   * numeric or numeral.
+   * @returns {Chord} the chord solfege
+   */
+  toChordSolfege(referenceKey: Key | string | null = null): Chord {
+    if (this.isChordSolfege()) {
+      return this.clone();
+    }
+
+    const keyObj = Key.wrapOrFail(referenceKey);
+
+    let chordSolfegeChord = new Chord({
+      suffix: this.suffix ? normalizeChordSuffix(this.suffix) : null,
+      root: this.root?.toChordSolfege(keyObj) || null,
+      bass: this.bass?.toChordSolfege(keyObj) || null,
+    });
+
+    if (this.root?.isMinor()) {
+      chordSolfegeChord = chordSolfegeChord.makeMinor();
+    }
+
+    chordSolfegeChord = chordSolfegeChord.normalize(referenceKey);
+    return chordSolfegeChord;
+  }
+
+  /**
+   * Converts the chord to a chord solfege string, using the supplied key as a reference.
+   * For example, a numeric chord `#4` with reference key `E` will return the chord solfege `A#`.
+   * When the chord is already a chord solfege, it will return a string version of the chord.
+   * @param {Key|string|null} [referenceKey=null] the reference key. The key is required when converting a
+   * numeric or numeral.
+   * @returns {string} the chord solfege string
+   * @see {toChordSolfege}
+   */
+  toChordSolfegeString(referenceKey: Key | string | null = null): string {
+    return this.toChordSolfege(referenceKey).toString();
+  }
+
+  /**
+   * Determines whether the chord is a chord solfege
+   * @returns {boolean}
+   */
+  isChordSolfege(): boolean {
+    return this.is(SOLFEGE);
+  }
+
   /**
    * Converts the chord to a numeric chord, using the supplied key as a reference.
    * For example, a chord symbol A# with reference key E will return the numeric chord #4.
@@ -216,6 +267,10 @@ class Chord implements ChordProperties {
 
   /**
    * Normalizes the chord root and bass notes:
+   * - Fab becomes Mi
+   * - Dob becomes Si
+   * - Si# becomes Do
+   * - Mi# becomes Fa
    * - Fb becomes E
    * - Cb becomes B
    * - B# becomes C

src/chord_sheet/tag.ts

@@ -226,13 +226,13 @@ export const CHORUS = 'chorus';
 
 /**
  * Chord type directive. Determines the type of chords used in the rendered chord sheet.
- * Possible values are 'symbol', 'numeral' and 'number'
+ * Possible values are 'solfege', 'symbol', 'numeral' and 'number'
  * @see https://github.com/bettermusic/ChordSheetJS/issues/352
  * @type {string}
  */
 export const CHORD_STYLE = 'chord_style';
 
-export type ChordType = 'symbol' | 'numeral' | 'number' | null;
+export type ChordType = 'symbol' | 'numeral' | 'number' | 'solfege' | null;
 
 const CHORDFONT_SHORT = 'cf';
 const CHORDSIZE_SHORT = 'cs';

src/constants.ts

@@ -52,6 +52,7 @@ export type ParagraphType = 'bridge' | 'chorus' | 'grid' | 'indeterminate' | 'no
 export const SYMBOL = 'symbol';
 export const NUMERIC = 'numeric';
 export const NUMERAL = 'numeral';
+export const SOLFEGE = 'solfege';
 
 export const ROMAN_NUMERALS = ['I', 'II', 'III', 'IV', 'V', 'VI', 'VII'];
 
@@ -62,7 +63,7 @@ export const NO_MODIFIER = 'NM';
 export type NoModifier = 'NM';
 export type ModifierMaybe = Modifier | NoModifier;
 
-export type ChordType = 'symbol' | 'numeric' | 'numeral';
+export type ChordType = 'symbol' | 'solfege' | 'numeric' | 'numeral';
 
 export const MINOR = 'm';
 export const MAJOR = 'M';

src/helpers.ts

@@ -42,6 +42,8 @@ function changeChordType(
   switch (type) {
     case 'symbol':
       return chord.toChordSymbol(referenceKey);
+    case 'solfege':
+      return chord.toChordSolfege(referenceKey);
     case 'numeral':
       return chord.toNumeral(referenceKey);
     case 'number':
@@ -91,7 +93,9 @@ export function renderChord(
  * values are the effective key for that capo.
  */
 export function getCapos(key: Key | string): Record<string, string> {
-  return capos[Key.toString(key)];
+  const keyObj = Key.wrapOrFail(key);
+  const chordType = keyObj.type === 'solfege' ? 'solfege' : 'symbol';
+  return capos[chordType][Key.toString(key)];
 }
 
 /**
@@ -101,5 +105,6 @@ export function getCapos(key: Key | string): Record<string, string> {
  */
 export function getKeys(key: Key | string): string[] {
   const keyObj = Key.wrapOrFail(key);
-  return keyObj.isMinor() ? minorKeys : majorKeys;
+  const chordType = keyObj.type === 'solfege' ? 'solfege' : 'symbol';
+  return keyObj.isMinor() ? minorKeys[chordType] : majorKeys[chordType];
 }

src/index.ts

@@ -58,6 +58,7 @@ export {
   INDETERMINATE,
   NONE,
   NUMERIC,
+  SOLFEGE,
   SYMBOL,
   TAB,
   VERSE,