es-feature-detection/lib/browserVersions.js

'use strict';

var es5 = require('../caniuse/es5');
var es6 = require('../caniuse/es6');

function parseId(entryId) {
  // Parse browser name and version
  var m = /^([^0-9_]+)([0-9_]+)?$/.exec(entryId);
  // If it is not compliant we move on
  if (!m) {
    return null;
  }

  var browser = m[1];
  var vers = String(m[2] || -1);

  // Some version indicator are structured like 413 for version 4.13, so we try to parse that here
  if (['safari', 'konq', 'ios'].indexOf(browser) > -1 && vers.length > 1) {
    var dec = vers.substr(1).replace('_', '');
    vers = vers[0] + '.' + ('0' + dec).substr(-2);
  }

  // Some have a '_' instead of the '.' in the version numeber. We correct that here.
  if (browser === 'opera' || browser === 'firefox') {
    vers = vers.replace('_', '.');
  }

  return { browser: browser, version: Number(vers) };
}

// Map browsers from the DB
function mapBrowsers(browsers) {
  return Object.keys(browsers).reduce(function (map, name) {
    var current = browsers[name];

    // Skip non client and unstable browsers
    if (current.platformtype && current.platformtype !== 'mobile' || current.unstable) {
      return map;
    }

    var parsed = parseId(name);

    if (!parsed) {
      return map;
    }

    var list = map.get(parsed.browser) || new Set();
    var all = allBrowsers.get(parsed.browser) || new Set();

    // We combine the parsed version with the name, to have the correct DB name reference
    var vers = { version: parsed.version, id: name };

    // Update browser in the global
    all.add(vers);
    allBrowsers.set(parsed.browser, all);

    // Update the current browser (and return it)
    list.add(vers);
    return map.set(parsed.browser, list);
  }, new Map());
}

// Sort the browser version decending (newest first)
function sortVersions(map) {
  var _iteratorNormalCompletion = true;
  var _didIteratorError = false;
  var _iteratorError = undefined;

  try {
    for (var _iterator = map.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
      var entry = _step.value;

      map.set(entry[0], Array.from(entry[1]).sort(function (a, b) {
        return b.version - a.version;
      }));
    }
  } catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion && _iterator.return) {
        _iterator.return();
      }
    } finally {
      if (_didIteratorError) {
        throw _iteratorError;
      }
    }
  }

  return map;
}

// Determine the available browsers from the DB
var allBrowsers = new Map();
var es5browsers = sortVersions(mapBrowsers(es5.browsers));
var es6browsers = sortVersions(mapBrowsers(es6.browsers));
allBrowsers = sortVersions(allBrowsers);

module.exports.parseId = parseId;

module.exports.getVersions = function getVersions(versions) {
  if (!Array.isArray(versions)) {
    versions = [versions];
  }

  // Loop through each browser version phrase
  var parsed = versions.reduce(function (map, versionExp) {
    var m = void 0;

    // Phrase like 'last 2 versions' or 'latest version'
    if (m = /(?:last|latest)( \d+)? versions?/.exec(versionExp)) {
      var i = Math.max(0, Number(m[1] || 0) - 1);

      // Loop through all the browsers
      var _iteratorNormalCompletion2 = true;
      var _didIteratorError2 = false;
      var _iteratorError2 = undefined;

      try {
        for (var _iterator2 = allBrowsers.entries()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
          var entry = _step2.value;

          var browser = entry[0];
          var list = entry[1];

          // Grab the version from the defined index
          var vers = list[i];
          // Or the last if it doesn't have a version list that long
          if (!vers) {
            vers = list[list.length - 1];
          }

          // We go for lowest version, so only update entry if the found version
          // is lower than the currently stored one
          var curr = map.get(browser);
          if (!curr || curr.version > vers.version) {
            map.set(browser, vers);
          }
        }

        // Exact browser like 'ie 8' or 'FireFox 30'
      } catch (err) {
        _didIteratorError2 = true;
        _iteratorError2 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion2 && _iterator2.return) {
            _iterator2.return();
          }
        } finally {
          if (_didIteratorError2) {
            throw _iteratorError2;
          }
        }
      }
    } else if (m = /(\w+)\s+([0-9.]+)/.exec(versionExp)) {
      var _browser = m[1];
      var target = Number(m[2]);
      var _list = allBrowsers.get(_browser);

      // Just stop here if there were no browser stored with that name
      if (!_list) {
        return map;
      }

      var _vers = void 0;

      // Search for a matching version
      // - should be the same or the first that is lower
      _list.some(function (item) {
        if (item.version <= target) {
          _vers = item;
          return true;
        }
      });

      // Take the lowest version if the defined version was too low
      if (!_vers) {
        _vers = _list[_list.length - 1];
      }

      // We go for lowest version, so only update entry if the found version
      // is lower than the currently stored one
      var _curr = map.get(_browser);
      if (!_curr || _curr.version > _vers.version) {
        map.set(_browser, _vers);
      }
    }

    // Return the findings
    return map;
  }, new Map());

  return {
    all: allBrowsers,
    es5: es5browsers,
    es6: es6browsers,
    parsed: parsed
  };
};