@atlaskit/eslint-plugin-no-lookahead-lookbehind-regexp/dist/esm/helpers/caniuse.js

Fork of https://github.com/JonasBa/eslint-plugin-no-lookahead-lookbehind-regexp

import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
import _typeof from "@babel/runtime/helpers/typeof";
import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
import browserslist from 'browserslist';
// @ts-expect-error
import * as lite from 'caniuse-lite';
// Collect all browser targets that may be defined as browserlistrc, eslint, package.json etc.
export function collectBrowserTargets(configPath, config) {
  var _browserslistConfig$d;
  var browserslistConfig = browserslist.findConfig(configPath);
  var hasConfig = browserslistConfig && (browserslistConfig === null || browserslistConfig === void 0 || (_browserslistConfig$d = browserslistConfig.defaults) === null || _browserslistConfig$d === void 0 ? void 0 : _browserslistConfig$d.length) > 0 || false;
  var targets = new Set();
  function addTarget(target) {
    targets.add(target);
  }
  function transformTarget(t) {
    var _t$split = t.split(' '),
      _t$split2 = _slicedToArray(_t$split, 2),
      browser = _t$split2[0],
      version = _t$split2[1];
    return {
      target: t,
      browser: browser,
      version: version
    };
  }

  // Get eslint targets
  if (Array.isArray(config) || typeof config === 'string') {
    browserslist(config, {
      path: configPath
    }).forEach(addTarget);
    // If config is an object, resolve targets from production and development
  } else if (_typeof(config) === 'object' && config !== null) {
    browserslist([].concat(_toConsumableArray(config.production || []), _toConsumableArray(config.development || [])), {
      path: configPath
    }).forEach(addTarget);
  }

  // If user had eslint config and also has browserslist config, then merge the two
  if (targets.size > 0 && hasConfig) {
    browserslist(undefined, {
      path: configPath
    }).forEach(addTarget);
    return {
      targets: Array.from(targets).map(transformTarget),
      hasConfig: hasConfig
    };
  }

  // If they only use an eslint config, then return what we have
  if (targets.size > 0 && !hasConfig) {
    return {
      targets: Array.from(targets).map(transformTarget),
      hasConfig: hasConfig
    };
  }

  // ** Warning
  // If they don't use a browserslist config, then return an empty targets array and disable the use of the regexp lookahead and lookbehind entirely.
  if (!hasConfig) {
    return {
      targets: [],
      hasConfig: hasConfig
    };
  }
  browserslist(undefined, {
    path: configPath
  }).forEach(addTarget);
  // If we couldnt find anything, return empty targets and indicate that no config was found
  return {
    targets: Array.from(targets).map(transformTarget),
    hasConfig: hasConfig
  };
}

// Returns a list of browser targets that do not support a feature.
// In case feature stats are not found in the database, we will assume that the feature is supported,
// this can result in false positives when querying for versions that may not have been released yet (typo or user mistake)
// Since the equivalent can happen in case of specifying some super old version, the proper way to possibly handle
// this would be to throw an error, but since I dont know how often that happens or if it may cause false positives later on
// if caniuse db changes... I'm leaning towards throwing an error here, but it's not the plugin's responsability to validate browserslist config - opinions are welcome.
// TODO: check if browserslist throws an error lower in the stack if config is invalid, this would likely be the best solution
export function collectUnsupportedTargets(id, targets) {
  var data = lite.feature(lite.features[id]);
  if (!data) {
    return [];
  }
  var stats = data.stats;
  var unsupportedTargets = [];
  var _iterator = _createForOfIteratorHelper(targets),
    _step;
  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var target = _step.value;
      // If we have no match for the target, we can assume it is supported
      if (!stats[target.browser] || !stats[target.browser][target.version]) {
        continue;
      }
      if (stats[target.browser][target.version] === 'n') {
        unsupportedTargets.push(target);
      }
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }
  return unsupportedTargets;
}
var HumanReadableBrowserTargets = {
  chrome: 'Chrome',
  firefox: 'Firefox',
  safari: 'Safari',
  ios_saf: 'iOS Safari',
  ie: 'Internet Explorer',
  ie_mob: 'Internet Explorer Mobile',
  edge: 'Edge',
  baidu: 'Baidu',
  electron: 'Electron',
  blackberry_browser: 'Blackberry Browser',
  edge_mobile: 'Edge Mobile',
  and_uc: 'Android UC Browser',
  and_chrome: 'Android Chrome',
  and_firefox: 'Android Firefox',
  and_webview: 'Android Webview',
  and_samsung: 'Samsung Browser',
  and_opera: 'Opera Android',
  opera: 'Opera',
  opera_mini: 'Opera Mini',
  opera_mobile: 'Opera Mobile',
  node: 'Node.js',
  kaios: 'KaiOS'
};
export function resolveCaniUseBrowserTarget(target) {
  return HumanReadableBrowserTargets[target] || target;
}
export function formatLinterMessage(violators, targets, config) {
  // If browser has no targets and we still want to report an error, it means that the feature is banned from use.
  if (!targets.length || config.browserslist === false) {
    if (violators.length === 1) {
      return "Disallowed ".concat(violators[0].negative ? 'negative ' : '').concat(violators[0].type, " match group at position ").concat(violators[0].position);
    }
    return "Disallowed lookahead and/or lookbehind match groups at positions ".concat(violators.map(function (violator) {
      return violator.position;
    }).join(', '));
  }
  var groupedTargets = {};
  var _iterator2 = _createForOfIteratorHelper(targets),
    _step2;
  try {
    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
      var target = _step2.value;
      if (!groupedTargets[target.browser]) {
        groupedTargets[target.browser] = [];
      }
      groupedTargets[target.browser].push(target.version);
    }
  } catch (err) {
    _iterator2.e(err);
  } finally {
    _iterator2.f();
  }
  if (violators.length === 1) {
    return "".concat(Object.keys(groupedTargets).map(function (g) {
      return "".concat(resolveCaniUseBrowserTarget(g), " ").concat(groupedTargets[g].join(', '));
    }).join(', '), ": unsupported ").concat(violators[0].negative ? 'negative ' : '').concat(violators[0].type, " match group at position ").concat(violators[0].position);
  }
  return "".concat(Object.keys(groupedTargets).map(function (g) {
    return "".concat(resolveCaniUseBrowserTarget(g), " ").concat(groupedTargets[g].join(', '));
  }), ": unsupported lookahead and/or lookbehind match groups at positions ").concat(violators.map(function (violator) {
    return violator.position;
  }).join(', '));
}