chordsheetjs 5.3.0 → 6.0.0

package/lib/chord.js

@@ -12,6 +12,8 @@ var _utilities = require("./utilities");
 
 var _key = _interopRequireDefault(require("./key"));
 
+var _suffixNormalizeMapping = _interopRequireDefault(require("./normalize_mappings/suffix-normalize-mapping"));
+
 var _constants = require("./constants");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
@@ -36,12 +38,6 @@ function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollect
 
 function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
 
-function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
-
-function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
-
-function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
-
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
 
 function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
@@ -60,23 +56,12 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function"
 
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
-var MAJOR_SCALE = [null, 'M', 'm', 'm', 'M', 'M', 'm', 'dim'];
-
 function normalizeSuffix(suffix) {
-  if (suffix === 'M') {
-    return '';
+  if (_suffixNormalizeMapping["default"][suffix] === '[blank]') {
+    return null;
   }
 
-  return suffix;
-}
-
-function chordSuffix(noteNumber, suffix) {
-  if ((0, _utilities.isEmptyString)(suffix)) {
-    var defaultSuffix = MAJOR_SCALE[noteNumber];
-    return normalizeSuffix(defaultSuffix);
-  }
-
-  return normalizeSuffix(suffix);
+  return _suffixNormalizeMapping["default"][suffix] || suffix;
 }
 
 var chordRegex = /*#__PURE__*/_wrapRegExp(/^([A-G])(#|b)?((?:(?![\t-\r \/\xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF])[\s\S])*)(\/([A-G])(#|b)?)?$/i, {
@@ -143,15 +128,24 @@ var Chord = /*#__PURE__*/function () {
       set: void 0
     });
 
+    this.suffix = (0, _utilities.presence)(suffix);
     this.root = root || new _key["default"]({
       note: base,
-      modifier: modifier
+      modifier: modifier,
+      minor: suffix === 'm'
     });
-    this.suffix = (0, _utilities.presence)(suffix);
-    this.bass = bass || (bassBase ? new _key["default"]({
-      note: bassBase,
-      modifier: bassModifier
-    }) : null);
+
+    if (bass) {
+      this.bass = bass;
+    } else if (bassBase) {
+      this.bass = new _key["default"]({
+        note: bassBase,
+        modifier: bassModifier,
+        minor: suffix === 'm'
+      });
+    } else {
+      this.bass = null;
+    }
   }
 
   _createClass(Chord, [{
@@ -183,10 +177,11 @@ var Chord = /*#__PURE__*/function () {
 
       var keyObj = _key["default"].wrap(key);
 
+      var rootKey = this.root.toChordSymbol(keyObj).normalizeEnharmonics(keyObj);
       var chordSymbolChord = new Chord({
-        suffix: chordSuffix(_classPrivateFieldGet(this, _rootNote), this.suffix),
-        root: this.root.toChordSymbol(keyObj),
-        bass: (_this$bass = this.bass) === null || _this$bass === void 0 ? void 0 : _this$bass.toChordSymbol(keyObj)
+        suffix: normalizeSuffix(this.suffix),
+        root: rootKey,
+        bass: (_this$bass = this.bass) === null || _this$bass === void 0 ? void 0 : _this$bass.toChordSymbol(keyObj).normalizeEnharmonics(rootKey)
       });
 
       if (this.root.isMinor()) {
@@ -247,7 +242,7 @@ var Chord = /*#__PURE__*/function () {
       var keyObj = _key["default"].wrap(key);
 
       return new Chord({
-        suffix: chordSuffix(_classPrivateFieldGet(this, _rootNote), this.suffix),
+        suffix: normalizeSuffix(this.suffix),
         root: this.root.toNumeric(keyObj),
         bass: (_this$bass3 = this.bass) === null || _this$bass3 === void 0 ? void 0 : _this$bass3.toNumeric(keyObj)
       });
@@ -282,7 +277,7 @@ var Chord = /*#__PURE__*/function () {
       var keyObj = _key["default"].wrap(key);
 
       return new Chord({
-        suffix: chordSuffix(_classPrivateFieldGet(this, _rootNote), this.suffix),
+        suffix: normalizeSuffix(this.suffix),
         root: this.root.toNumeral(keyObj),
         bass: (_this$bass5 = this.bass) === null || _this$bass5 === void 0 ? void 0 : _this$bass5.toNumeral(keyObj)
       });
@@ -350,7 +345,7 @@ var Chord = /*#__PURE__*/function () {
       return chordString;
     }
     /**
-     * Normalizes the chord:
+     * Normalizes the chord root and bass notes:
      * - Fb becomes E
      * - Cb becomes B
      * - B# becomes C
@@ -360,14 +355,26 @@ var Chord = /*#__PURE__*/function () {
      * - 7# becomes 1
      * - 3# becomes 4
      *
-     * If the chord is already normalized, this will return a copy.
+     * Besides that it normalizes the suffix. For example, `sus2` becomes `2`, `sus4` becomes `sus`.
+     * All suffix normalizations can be found in `src/normalize_mappings/suffix-mapping.txt`.
+     *
      * @returns {Chord} the normalized chord
      */
 
   }, {
     key: "normalize",
-    value: function normalize() {
-      return _classPrivateMethodGet(this, _process, _process2).call(this, 'normalize');
+    value: function normalize(key) {
+      if (!(0, _utilities.presence)(key)) {
+        return _classPrivateMethodGet(this, _process, _process2).call(this, 'normalize').set({
+          suffix: (0, _utilities.presence)(normalizeSuffix(this.suffix))
+        });
+      }
+
+      return this.set({
+        root: this.root.normalizeEnharmonics(key),
+        suffix: (0, _utilities.presence)(normalizeSuffix(this.suffix)),
+        bass: this.bass ? this.bass.normalizeEnharmonics(this.root.toString()) : null
+      });
     }
     /**
      * Switches to the specified modifier

package/lib/key.js

@@ -11,6 +11,8 @@ var _note = _interopRequireDefault(require("./note"));
 
 var _constants = require("./constants");
 
+var _enharmonicNormalize = _interopRequireDefault(require("./normalize_mappings/enharmonic-normalize"));
+
 var _MODIFIER_TRANSPOSITI;
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
@@ -43,14 +45,16 @@ var FLAT = 'b';
 var SHARP = '#';
 var MODIFIER_TRANSPOSITION = (_MODIFIER_TRANSPOSITI = {}, _defineProperty(_MODIFIER_TRANSPOSITI, SHARP, 1), _defineProperty(_MODIFIER_TRANSPOSITI, FLAT, -1), _MODIFIER_TRANSPOSITI);
 
-var symbolKeyRegex = /*#__PURE__*/_wrapRegExp(/^([A-G])(#|b)?$/i, {
+var symbolKeyRegex = /*#__PURE__*/_wrapRegExp(/^([A-G])(#|b)?(m)?$/i, {
   note: 1,
-  modifier: 2
+  modifier: 2,
+  minor: 3
 });
 
-var numericKeyRegex = /*#__PURE__*/_wrapRegExp(/^(#|b)?([1-7])$/, {
+var numericKeyRegex = /*#__PURE__*/_wrapRegExp(/^(#|b)?([1-7])(m)?$/, {
   modifier: 1,
-  note: 2
+  note: 2,
+  minor: 3
 });
 
 var numeralKeyRegex = /*#__PURE__*/_wrapRegExp(/^(#|b)?(I{1,3}|IV|VI{0,2}|i{1,3}|iv|vi{0,2})$/, {
@@ -66,7 +70,9 @@ var Key = /*#__PURE__*/function () {
   function Key(_ref) {
     var note = _ref.note,
         _ref$modifier = _ref.modifier,
-        modifier = _ref$modifier === void 0 ? null : _ref$modifier;
+        modifier = _ref$modifier === void 0 ? null : _ref$modifier,
+        _ref$minor = _ref.minor,
+        minor = _ref$minor === void 0 ? false : _ref$minor;
 
     _classCallCheck(this, Key);
 
@@ -74,6 +80,7 @@ var Key = /*#__PURE__*/function () {
 
     this.note = note instanceof _note["default"] ? note : _note["default"].parse(note);
     this.modifier = modifier || null;
+    this.minor = !!minor || false;
   }
 
   _createClass(Key, [{
@@ -100,6 +107,21 @@ var Key = /*#__PURE__*/function () {
     value: function clone() {
       return _classPrivateMethodGet(this, _set, _set2).call(this, {});
     }
+  }, {
+    key: "toChordSymbol",
+    value: function toChordSymbol(key) {
+      if (this.is(_constants.SYMBOL)) {
+        return this.clone();
+      }
+
+      var transposeDistance = this.note.getTransposeDistance(key.minor) + (MODIFIER_TRANSPOSITION[this.modifier] || 0);
+      return key.transpose(transposeDistance).normalize().useModifier(key.modifier);
+    }
+  }, {
+    key: "toChordSymbolString",
+    value: function toChordSymbolString(key) {
+      return this.toChordSymbol(key).toString();
+    }
   }, {
     key: "is",
     value: function is(type) {
@@ -127,21 +149,6 @@ var Key = /*#__PURE__*/function () {
           modifier = _ref2.modifier;
       return this.note.equals(note) && this.modifier === modifier;
     }
-  }, {
-    key: "toChordSymbol",
-    value: function toChordSymbol(key) {
-      if (this.is(_constants.SYMBOL)) {
-        return this.clone();
-      }
-
-      var transposeDistance = this.note.getTransposeDistance() + (MODIFIER_TRANSPOSITION[this.modifier] || 0);
-      return key.transpose(transposeDistance).normalize().useModifier(key.modifier);
-    }
-  }, {
-    key: "toChordSymbolString",
-    value: function toChordSymbolString(key) {
-      return this.toChordSymbol(key).toString();
-    }
   }, {
     key: "toNumeric",
     value: function toNumeric(key) {
@@ -159,11 +166,11 @@ var Key = /*#__PURE__*/function () {
         note: 1
       });
       var symbolKey = key.clone();
-      var reference = this.clone().normalize().useModifier(key.modifier);
+      var reference = this.clone().normalize().useModifier(key.modifier).normalizeEnharmonics(key);
 
       while (!symbolKey.equals(reference)) {
         numericKey = numericKey.transposeUp().useModifier(key.modifier);
-        symbolKey = symbolKey.transposeUp().normalize().useModifier(key.modifier);
+        symbolKey = symbolKey.transposeUp().normalize().useModifier(key.modifier).normalizeEnharmonics(key);
       }
 
       return numericKey;
@@ -190,11 +197,11 @@ var Key = /*#__PURE__*/function () {
         note: 'I'
       });
       var symbolKey = key.clone();
-      var reference = this.clone().normalize().useModifier(key.modifier);
+      var reference = this.clone().normalize().useModifier(key.modifier).normalizeEnharmonics(key);
 
       while (!symbolKey.equals(reference)) {
         numeralKey = numeralKey.transposeUp().useModifier(key.modifier);
-        symbolKey = symbolKey.transposeUp().normalize().useModifier(key.modifier);
+        symbolKey = symbolKey.transposeUp().normalize().useModifier(key.modifier).normalizeEnharmonics(key);
       }
 
       return numeralKey;
@@ -318,6 +325,21 @@ var Key = /*#__PURE__*/function () {
         });
       }
 
+      return this.clone();
+    }
+  }, {
+    key: "normalizeEnharmonics",
+    value: function normalizeEnharmonics(key) {
+      if (key) {
+        var rootKeyString = key.minor ? "".concat(key, "m") : key.toString();
+        var enharmonics = _enharmonicNormalize["default"][rootKeyString];
+        var thisKeyString = this.toString();
+
+        if (enharmonics && enharmonics[thisKeyString]) {
+          return Key.parse(enharmonics[thisKeyString]);
+        }
+      }
+
       return this.clone();
     }
   }], [{
@@ -355,7 +377,8 @@ var Key = /*#__PURE__*/function () {
 function _set2(attributes) {
   return new this.constructor(_objectSpread({
     note: this.note.clone(),
-    modifier: this.modifier
+    modifier: this.modifier,
+    minor: !!this.minor
   }, attributes));
 }
 

package/lib/normalize_mappings/enharmonic-normalize.js

@@ -0,0 +1,124 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  'Ab': {
+    'B': 'Cb'
+  },
+  'Cb': {
+    'B': 'Cb',
+    'A#': 'Bb',
+    'E': 'Fb'
+  },
+  'C': {
+    'C#': 'Db',
+    'D#': 'Eb',
+    'F#': 'Gb',
+    'G#': 'Ab',
+    'A#': 'Bb'
+  },
+  'C#': {
+    'D#': 'Eb',
+    'A#': 'Bb'
+  },
+  'Db': {
+    'B': 'Cb'
+  },
+  'D': {
+    'D#': 'Eb',
+    'A#': 'Bb'
+  },
+  'E': {
+    'Ab': 'G#',
+    'A#': 'Bb',
+    'D#': 'Eb'
+  },
+  'F': {
+    'A#': 'Bb',
+    'F#': 'Gb',
+    'C#': 'Db',
+    'D#': 'Eb',
+    'G#': 'Ab'
+  },
+  'F#': {
+    'A#': 'Bb',
+    'D#': 'Eb'
+  },
+  'Gb': {
+    'A#': 'Bb',
+    'D#': 'Eb',
+    'G#': 'Ab',
+    'B': 'Cb',
+    'E': 'Fb'
+  },
+  'G': {
+    'A#': 'Bb',
+    'D#': 'Eb',
+    'G#': 'Ab'
+  },
+  'G#': {
+    'A#': 'Bb',
+    'D#': 'Eb'
+  },
+  'Am': {
+    'Gb': 'G',
+    'G#': 'Ab',
+    'F#': 'Gb',
+    'C#': 'Db',
+    'D#': 'Eb',
+    'A#': 'Bb'
+  },
+  'Bbm': {
+    'Cb': 'B'
+  },
+  'Bm': {
+    'A#': 'Bb',
+    'D#': 'Eb'
+  },
+  'C#m': {
+    'A#': 'Bb',
+    'D#': 'Eb'
+  },
+  'Cm': {
+    'G#': 'Ab',
+    'A#': 'Bb',
+    'D#': 'Eb',
+    'F#': 'Gb',
+    'C#': 'Db'
+  },
+  'Dm': {
+    'A#': 'Bb',
+    'D#': 'Eb'
+  },
+  'Em': {
+    'A#': 'Bb',
+    'D#': 'Eb'
+  },
+  'F#m': {
+    'A#': 'Bb',
+    'D#': 'Eb',
+    'Gb': 'F#',
+    'Ab': 'G#',
+    'Db': 'C#'
+  },
+  'Fm': {
+    'G#': 'Ab',
+    'A#': 'Bb',
+    'D#': 'Eb',
+    'F#': 'Gb',
+    'C#': 'Db'
+  },
+  'Gm': {
+    'G#': 'Ab',
+    'A#': 'Bb',
+    'D#': 'Eb'
+  },
+  'G#m': {
+    'A#': 'Bb',
+    'D#': 'Eb'
+  }
+};
+exports["default"] = _default;

package/lib/normalize_mappings/generate-suffix-normalize-mapping.js

@@ -0,0 +1,36 @@
+"use strict";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var fs = require('fs');
+
+console.warn('\x1b[34m', '👷 Building suffix normalize mapping from suffix-mapping.txt');
+fs.readFile('src/normalize_mappings/suffix-mapping.txt', function (err, data) {
+  if (err) throw err;
+  var suffixs = [];
+  data.toString().split('\n').map(function (line) {
+    var items = line.split(',');
+    var cleanStringsArray = [];
+    items.forEach(function (item) {
+      cleanStringsArray.push(item.trim());
+    });
+    suffixs.push(cleanStringsArray);
+    return suffixs;
+  });
+  var flatObject = {};
+  suffixs.forEach(function (line) {
+    line.forEach(function (item) {
+      flatObject = _objectSpread(_defineProperty({}, item, line[0]), flatObject);
+    });
+  });
+  var suffixMappingJson = JSON.stringify(flatObject, null, 2);
+  var suffixMappingJs = "export default ".concat(suffixMappingJson, ";\n");
+  fs.writeFile('src/normalize_mappings/suffix-normalize-mapping.js', suffixMappingJs, 'utf-8', function (error) {
+    if (error) throw error;
+    console.warn('\x1b[32m', '✨ Sucessfully built suffix-normalize-mapping.js');
+  });
+});