twelvetet-fretboard/dist/twelvetet-fretboard.js

(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('twelvetet')) :
	typeof define === 'function' && define.amd ? define(['twelvetet'], factory) :
	(global.TwelveTetFretboard = factory(global.TwelveTet));
}(this, (function (TwelveTet) { 'use strict';

TwelveTet = TwelveTet && TwelveTet.hasOwnProperty('default') ? TwelveTet['default'] : TwelveTet;

var classCallCheck = function (instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
};

var createClass = function () {
  function defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  return function (Constructor, protoProps, staticProps) {
    if (protoProps) defineProperties(Constructor.prototype, protoProps);
    if (staticProps) defineProperties(Constructor, staticProps);
    return Constructor;
  };
}();

/**
 * @class TwelveTetFretboard
 * @param {Array} tuning An array of values representing fretboard tuning.
 * @param {Number} numFrets A positive integer indicating the number of frets.
 * @param {Number} [tuningFrequency] An optional positive number indicating the tuning frequency.
 * @example
 * import Fretboard from 'twelvetet-fretboard'
 *
 * const tuning = ['E2', 'A2', 'D3', 'G3', 'B3', 'E4'] // standard guitar tuning
 * const numFrets = 12
 * const fretboard = new Fretboard(tuning, numFrets)
 *
 * console.log(fretboard.at(0, 0).toString())          // E4
 */

var TwelveTetFretboard = function () {
    function TwelveTetFretboard(tuning, numFrets) {
        var tuningFrequency = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 440;
        classCallCheck(this, TwelveTetFretboard);

        if (!isNonEmptyArray(tuning)) {
            throw new TypeError("Missing or invalid argument, 'tuning'. Non-empty array expected.");
        }

        if (!isPositiveInteger(numFrets)) {
            throw new TypeError("Missing or invalid argument, 'numFrets'. Positive integer expected.");
        }

        if (!isFrequency(tuningFrequency)) {
            throw new TypeError("Missing or invalid argument, 'tuningFrequency'. Positive number expected.");
        }

        var twelvetet = new TwelveTet(tuningFrequency);
        var positions = this._positions = [];
        tuning.slice(0).reverse().forEach(function (value, stringIndex) {
            for (var fretIndex = 0; fretIndex < numFrets; fretIndex++) {
                positions.push({
                    pitch: twelvetet.pitch(value).next(fretIndex),
                    stringIndex: stringIndex,
                    fretIndex: fretIndex
                });
            }
        });
    }

    /**
     * Returns the pitch at `(stringIndex, fretIndex)`
     * @function at
     * @memberof TwelveTetFretboard
     * @instance
     * @param {Number} aStringIndex A zero-based integer indicating the string
     * @param {Number} aFretIndex A zero-based integer indicating the fret
     * @returns {external:Pitch}
     */


    TwelveTetFretboard.prototype.at = function at(aStringIndex, aFretIndex) {
        if (!isNonNegativeInteger(aStringIndex)) {
            throw new TypeError("Missing or invalid argument, 'aStringIndex'. Non-negative integer expected");
        }

        if (!isNonNegativeInteger(aFretIndex)) {
            throw new TypeError("Missing or invalid argument, 'aFretIndex'. Non-negative integer expected.");
        }

        var position = this._positions.find(function (_ref) {
            var stringIndex = _ref.stringIndex,
                fretIndex = _ref.fretIndex;
            return stringIndex === aStringIndex && fretIndex === aFretIndex;
        });

        return position != null ? position.pitch : null;
    };

    /**
     * @property {Array.<Position>} positions An array of all the positions on the fretboard
     * @memberof TwelveTetFretboard
     * @instance
     */


    createClass(TwelveTetFretboard, [{
        key: "positions",
        get: function get$$1() {
            return this._positions.map(function (position) {
                return Object.assign({}, position);
            });
        }
    }]);
    return TwelveTetFretboard;
}();


function isNonEmptyArray(value) {
    return (/^\[object Array\]$/.test(Object.prototype.toString.call(value)) && value.length > 0
    );
}

function isInteger(value) {
    return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;
}

function isNonNegativeInteger(value) {
    return isInteger(value) && value >= 0;
}

function isPositiveInteger(value) {
    return isInteger(value) && value > 0;
}

function isFrequency(value) {
    return typeof value === 'number' && isFinite(value) && value > 0;
}

return TwelveTetFretboard;

})));