@devahn/eslint-plugin-compat
Version:
Lint browser compatibility of API used
306 lines (267 loc) • 29 kB
JavaScript
'use strict';
Object.defineProperty(exports, '__esModule', {
value: true,
});
exports.default = void 0;
var _fs = _interopRequireDefault(require('fs'));
var _findUp = _interopRequireDefault(require('find-up'));
var _lodash = _interopRequireDefault(require('lodash.memoize'));
var _helpers = require('../helpers');
var _providers = require('../providers');
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
/*
* Step 2) Logic that handles AST traversal
* Does not handle looking up the API
* Handles checking what kinds of eslint nodes should be linted
* Tells eslint to lint certain nodes (lintCallExpression, lintMemberExpression, lintNewExpression)
* Gets protochain for the ESLint nodes the plugin is interested in
*/
function getName(node) {
switch (node.type) {
case 'NewExpression': {
return node.callee.name;
}
case 'MemberExpression': {
return node.object.name;
}
case 'ExpressionStatement': {
return node.expression.name;
}
case 'CallExpression': {
return node.callee.name;
}
default:
throw new Error('not found');
}
}
function generateErrorName(rule, context) {
if (isInInstanceMethod(rule, context))
return [rule.protoChain[0], '.prototype.', rule.protoChain[1]].join('');
if (rule.name) return rule.name;
if (rule.property) return `${rule.object}.${rule.property}()`;
return rule.object;
}
const getPolyfillSet = (0, _lodash.default)(
(polyfillArrayJSON) => new Set(JSON.parse(polyfillArrayJSON))
);
function isPolyfilled(context, rule) {
var _context$settings;
if (
!((_context$settings = context.settings) === null ||
_context$settings === void 0
? void 0
: _context$settings.polyfills)
)
return false;
const polyfills = getPolyfillSet(JSON.stringify(context.settings.polyfills));
return (
// v2 allowed users to select polyfills based off their caniuseId. This is
polyfills.has(rule.id) || // no longer supported. Keeping this here to avoid breaking changes.
polyfills.has(rule.protoChainId) || // Check if polyfill is provided (ex. `Promise.all`)
polyfills.has(rule.protoChain[0]) // Check if entire API is polyfilled (ex. `Promise`)
);
}
const items = [
// Babel configs
'babel.config.json',
'babel.config.js',
'.babelrc',
'.babelrc.json',
'.babelrc.js',
];
/**
* Determine if a user has a TS or babel config. This is used to infer if a user is transpiling their code.
* If transpiling code, do not lint ES APIs. We assume that all transpiled code is polyfilled.
* @TODO Use @babel/core to find config. See https://github.com/babel/babel/discussions/11602
* @param dir @
*/
function isUsingTranspiler(context) {
var _context$parserOption;
// If tsconfig config exists in parser options, assume transpilation
if (
((_context$parserOption = context.parserOptions) === null ||
_context$parserOption === void 0
? void 0
: _context$parserOption.tsconfigRootDir) === true
)
return true;
const dir = context.getFilename();
const configPath = _findUp.default.sync(items, {
cwd: dir,
});
if (configPath) return true;
const pkgPath = _findUp.default.sync('package.json', {
cwd: dir,
}); // Check if babel property exists
if (pkgPath) {
const pkg = JSON.parse(_fs.default.readFileSync(pkgPath).toString());
return !!pkg.babel;
}
return false;
}
const isInInstanceMethod = (node, context) => {
const instanceSet = getPolyfillSet(
JSON.stringify(context.settings.instances)
);
const instanceArr = [...instanceSet];
const propertyName = node.protoChainId;
return instanceArr.some((object) => object.includes(propertyName));
};
var _default = {
meta: {
docs: {
description: 'Ensure cross-browser API compatibility',
category: 'Compatibility',
url:
'https://github.com/amilajack/eslint-plugin-compat/blob/master/docs/rules/compat.md',
recommended: true,
},
type: 'problem',
schema: [
{
type: 'string',
},
],
},
create(context) {
var _context$settings2,
_context$settings3,
_context$settings4,
_context$settings5,
_context$settings5$po;
// Determine lowest targets from browserslist config, which reads user's
// package.json config section. Use config from eslintrc for testing purposes
const browserslistConfig =
((_context$settings2 = context.settings) === null ||
_context$settings2 === void 0
? void 0
: _context$settings2.browsers) ||
((_context$settings3 = context.settings) === null ||
_context$settings3 === void 0
? void 0
: _context$settings3.targets) ||
context.options[0];
const lintAllEsApis =
((_context$settings4 = context.settings) === null ||
_context$settings4 === void 0
? void 0
: _context$settings4.lintAllEsApis) === true || // Attempt to infer polyfilling of ES APIs from ts or babel config
(!((_context$settings5 = context.settings) === null ||
_context$settings5 === void 0
? void 0
: (_context$settings5$po = _context$settings5.polyfills) === null ||
_context$settings5$po === void 0
? void 0
: _context$settings5$po.includes('es:all')) &&
!isUsingTranspiler(context));
const browserslistTargets = (0, _helpers.parseBrowsersListVersion)(
(0, _helpers.determineTargetsFromConfig)(
context.getFilename(),
browserslistConfig
)
);
/**
* A small optimization that only lints APIs that are not supported by targeted browsers.
* For example, if the user is targeting chrome 50, which supports the fetch API, it is
* wasteful to lint calls to fetch.
*/
const getRulesForTargets = (0, _lodash.default)((targetsJSON) => {
const result = {
CallExpression: [],
NewExpression: [],
MemberExpression: [],
ExpressionStatement: [],
};
const targets = JSON.parse(targetsJSON);
_providers.nodes
.filter((node) => {
return lintAllEsApis ? true : node.kind !== 'es';
})
.forEach((node) => {
if (!node.getUnsupportedTargets(node, targets).length) return;
result[node.astNodeType].push(node);
});
return result;
}); // Stringify to support memoization; browserslistConfig is always an array of new objects.
const targetedRules = getRulesForTargets(
JSON.stringify(browserslistTargets)
);
const errors = [];
const handleFailingRule = (node, eslintNode) => {
if (isPolyfilled(context, node)) return;
errors.push({
node: eslintNode,
message: [
generateErrorName(node, context),
'is not supported in',
node.getUnsupportedTargets(node, browserslistTargets).join(', '),
].join(' '),
});
};
const filterDuplicateErrors = (errors) => {
return errors.filter(
(error, index, arr) =>
arr.findIndex((e) => e.message === error.message) === index
);
};
const identifiers = new Set();
return {
CallExpression: _helpers.lintCallExpression.bind(
null,
context,
handleFailingRule,
targetedRules.CallExpression
),
NewExpression: _helpers.lintNewExpression.bind(
null,
context,
handleFailingRule,
targetedRules.NewExpression
),
ExpressionStatement: _helpers.lintExpressionStatement.bind(
null,
context,
handleFailingRule,
[...targetedRules.MemberExpression, ...targetedRules.CallExpression]
),
MemberExpression: _helpers.lintMemberExpression.bind(
null,
context,
handleFailingRule,
[
...targetedRules.MemberExpression,
...targetedRules.CallExpression,
...targetedRules.NewExpression,
]
),
// Keep track of all the defined variables. Do not report errors for nodes that are not defined
Identifier(node) {
if (node.parent) {
const { type } = node.parent;
if (
type === 'Property' || // ex. const { Set } = require('immutable');
type === 'FunctionDeclaration' || // ex. function Set() {}
type === 'VariableDeclarator' || // ex. const Set = () => {}
type === 'ClassDeclaration' || // ex. class Set {}
type === 'ImportDefaultSpecifier' || // ex. import Set from 'set';
type === 'ImportSpecifier' || // ex. import {Set} from 'set';
type === 'ImportDeclaration' // ex. import {Set} from 'set';
) {
identifiers.add(node.name);
}
}
},
'Program:exit': () => {
// Get a map of all the variables defined in the root scope (not the global scope)
// const variablesMap = context.getScope().childScopes.map(e => e.set)[0];
// const filteredErrors = filterDuplicateErrors(errors);
// filteredErrors.forEach((node) => context.report(node));
errors.forEach((node) => context.report(node));
},
};
},
};
exports.default = _default;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/compat.ts"],"names":["getName","node","type","callee","name","object","expression","Error","generateErrorName","rule","property","getPolyfillSet","polyfillArrayJSON","Set","JSON","parse","isPolyfilled","context","settings","polyfills","stringify","has","id","protoChainId","protoChain","items","isUsingTranspiler","parserOptions","tsconfigRootDir","dir","getFilename","configPath","findUp","sync","cwd","pkgPath","pkg","fs","readFileSync","toString","babel","meta","docs","description","category","url","recommended","schema","create","browserslistConfig","browsers","targets","options","lintAllEsApis","includes","browserslistTargets","getRulesForTargets","targetsJSON","result","CallExpression","NewExpression","MemberExpression","ExpressionStatement","nodes","filter","kind","forEach","getUnsupportedTargets","length","astNodeType","push","targetedRules","errors","handleFailingRule","eslintNode","message","join","identifiers","lintCallExpression","bind","lintNewExpression","lintExpressionStatement","lintMemberExpression","Identifier","parent","add","error","report"],"mappings":"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","sourcesContent":["/*\n * Step 2) Logic that handles AST traversal\n * Does not handle looking up the API\n * Handles checking what kinds of eslint nodes should be linted\n *   Tells eslint to lint certain nodes  (lintCallExpression, lintMemberExpression, lintNewExpression)\n *   Gets protochain for the ESLint nodes the plugin is interested in\n */\nimport fs from \"fs\";\nimport findUp from \"find-up\";\nimport memoize from \"lodash.memoize\";\nimport {\n  lintCallExpression,\n  lintMemberExpression,\n  lintNewExpression,\n  lintExpressionStatement,\n  parseBrowsersListVersion,\n  determineTargetsFromConfig,\n} from \"../helpers\"; // will be deprecated and introduced to this file\nimport {\n  ESLintNode,\n  AstMetadataApiWithTargetsResolver,\n  BrowserListConfig,\n  HandleFailingRule,\n  Context,\n} from \"../types\";\nimport { nodes } from \"../providers\";\n\ntype ESLint = {\n  [astNodeTypeName: string]: (node: ESLintNode) => void;\n};\n\nfunction getName(node: ESLintNode): string {\n  switch (node.type) {\n    case \"NewExpression\": {\n      return node.callee.name;\n    }\n    case \"MemberExpression\": {\n      return node.object.name;\n    }\n    case \"ExpressionStatement\": {\n      return node.expression.name;\n    }\n    case \"CallExpression\": {\n      return node.callee.name;\n    }\n    default:\n      throw new Error(\"not found\");\n  }\n}\n\nfunction generateErrorName(rule: AstMetadataApiWithTargetsResolver): string {\n  if (rule.name) return rule.name;\n  if (rule.property) return `${rule.object}.${rule.property}()`;\n  return rule.object;\n}\n\nconst getPolyfillSet = memoize(\n  (polyfillArrayJSON: string): Set<String> =>\n    new Set(JSON.parse(polyfillArrayJSON))\n);\n\nfunction isPolyfilled(\n  context: Context,\n  rule: AstMetadataApiWithTargetsResolver\n): boolean {\n  if (!context.settings?.polyfills) return false;\n  const polyfills = getPolyfillSet(JSON.stringify(context.settings.polyfills));\n  return (\n    // v2 allowed users to select polyfills based off their caniuseId. This is\n    polyfills.has(rule.id) || // no longer supported. Keeping this here to avoid breaking changes.\n    polyfills.has(rule.protoChainId) || // Check if polyfill is provided (ex. `Promise.all`)\n    polyfills.has(rule.protoChain[0]) // Check if entire API is polyfilled (ex. `Promise`)\n  );\n}\n\nconst items = [\n  // Babel configs\n  \"babel.config.json\",\n  \"babel.config.js\",\n  \".babelrc\",\n  \".babelrc.json\",\n  \".babelrc.js\",\n  // TS configs\n  \"tsconfig.json\",\n];\n\n/**\n * Determine if a user has a TS or babel config. This is used to infer if a user is transpiling their code.\n * If transpiling code, do not lint ES APIs. We assume that all transpiled code is polyfilled.\n * @TODO Use @babel/core to find config. See https://github.com/babel/babel/discussions/11602\n * @param dir @\n */\nfunction isUsingTranspiler(context: Context): boolean {\n  // If tsconfig config exists in parser options, assume transpilation\n  if (context.parserOptions?.tsconfigRootDir === true) return true;\n  const dir = context.getFilename();\n  const configPath = findUp.sync(items, {\n    cwd: dir,\n  });\n  if (configPath) return true;\n  const pkgPath = findUp.sync(\"package.json\", {\n    cwd: dir,\n  });\n  // Check if babel property exists\n  if (pkgPath) {\n    const pkg = JSON.parse(fs.readFileSync(pkgPath).toString());\n    return !!pkg.babel;\n  }\n  return false;\n}\n\nexport default {\n  meta: {\n    docs: {\n      description: \"Ensure cross-browser API compatibility\",\n      category: \"Compatibility\",\n      url:\n        \"https://github.com/amilajack/eslint-plugin-compat/blob/master/docs/rules/compat.md\",\n      recommended: true,\n    },\n    type: \"problem\",\n    schema: [{ type: \"string\" }],\n  },\n  create(context: Context): ESLint {\n    // Determine lowest targets from browserslist config, which reads user's\n    // package.json config section. Use config from eslintrc for testing purposes\n    const browserslistConfig: BrowserListConfig =\n      context.settings?.browsers ||\n      context.settings?.targets ||\n      context.options[0];\n\n    const lintAllEsApis: boolean =\n      context.settings?.lintAllEsApis === true ||\n      // Attempt to infer polyfilling of ES APIs from ts or babel config\n      (!context.settings?.polyfills?.includes(\"es:all\") &&\n        !isUsingTranspiler(context));\n    const browserslistTargets = parseBrowsersListVersion(\n      determineTargetsFromConfig(context.getFilename(), browserslistConfig)\n    );\n\n    type RulesFilteredByTargets = {\n      CallExpression: AstMetadataApiWithTargetsResolver[];\n      NewExpression: AstMetadataApiWithTargetsResolver[];\n      MemberExpression: AstMetadataApiWithTargetsResolver[];\n      ExpressionStatement: AstMetadataApiWithTargetsResolver[];\n    };\n\n    /**\n     * A small optimization that only lints APIs that are not supported by targeted browsers.\n     * For example, if the user is targeting chrome 50, which supports the fetch API, it is\n     * wasteful to lint calls to fetch.\n     */\n    const getRulesForTargets = memoize(\n      (targetsJSON: string): RulesFilteredByTargets => {\n        const result = {\n          CallExpression: [],\n          NewExpression: [],\n          MemberExpression: [],\n          ExpressionStatement: [],\n        };\n        const targets = JSON.parse(targetsJSON);\n\n        nodes\n          .filter((node) => {\n            return lintAllEsApis ? true : node.kind !== \"es\";\n          })\n          .forEach((node) => {\n            if (!node.getUnsupportedTargets(node, targets).length) return;\n            result[node.astNodeType as keyof RulesFilteredByTargets].push(node);\n          });\n\n        return result;\n      }\n    );\n\n    // Stringify to support memoization; browserslistConfig is always an array of new objects.\n    const targetedRules = getRulesForTargets(\n      JSON.stringify(browserslistTargets)\n    );\n\n    type Error = {\n      message: string;\n      node: ESLintNode;\n    };\n\n    const errors: Error[] = [];\n\n    const handleFailingRule: HandleFailingRule = (\n      node: AstMetadataApiWithTargetsResolver,\n      eslintNode: ESLintNode\n    ) => {\n      if (isPolyfilled(context, node)) return;\n      errors.push({\n        node: eslintNode,\n        message: [\n          generateErrorName(node),\n          \"is not supported in\",\n          node.getUnsupportedTargets(node, browserslistTargets).join(\", \"),\n        ].join(\" \"),\n      });\n    };\n\n    const identifiers = new Set();\n\n    return {\n      CallExpression: lintCallExpression.bind(\n        null,\n        context,\n        handleFailingRule,\n        targetedRules.CallExpression\n      ),\n      NewExpression: lintNewExpression.bind(\n        null,\n        context,\n        handleFailingRule,\n        targetedRules.NewExpression\n      ),\n      ExpressionStatement: lintExpressionStatement.bind(\n        null,\n        context,\n        handleFailingRule,\n        [...targetedRules.MemberExpression, ...targetedRules.CallExpression]\n      ),\n      MemberExpression: lintMemberExpression.bind(\n        null,\n        context,\n        handleFailingRule,\n        [\n          ...targetedRules.MemberExpression,\n          ...targetedRules.CallExpression,\n          ...targetedRules.NewExpression,\n        ]\n      ),\n      // Keep track of all the defined variables. Do not report errors for nodes that are not defined\n      Identifier(node: ESLintNode) {\n        if (node.parent) {\n          const { type } = node.parent;\n          if (\n            type === \"Property\" || // ex. const { Set } = require('immutable');\n            type === \"FunctionDeclaration\" || // ex. function Set() {}\n            type === \"VariableDeclarator\" || // ex. const Set = () => {}\n            type === \"ClassDeclaration\" || // ex. class Set {}\n            type === \"ImportDefaultSpecifier\" || // ex. import Set from 'set';\n            type === \"ImportSpecifier\" || // ex. import {Set} from 'set';\n            type === \"ImportDeclaration\" // ex. import {Set} from 'set';\n          ) {\n            identifiers.add(node.name);\n          }\n        }\n      },\n      \"Program:exit\": () => {\n        // Get a map of all the variables defined in the root scope (not the global scope)\n        // const variablesMap = context.getScope().childScopes.map(e => e.set)[0];\n        errors\n          .filter((error) => !identifiers.has(getName(error.node)))\n          .forEach((node) => context.report(node));\n      },\n    };\n  },\n};\n"]}