"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) {
  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", // TS configs
"tsconfig.json"];
/**
 * 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;
}

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), "is not supported in", node.getUnsupportedTargets(node, browserslistTargets).join(", ")].join(" ")
      });
    };

    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];
        errors.filter(error => !identifiers.has(getName(error.node))).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"]}