mirror of
https://github.com/react/react-native-devtools-frontend.git
synced 2026-10-09 21:28:43 +08:00
Tim van der Lippe
c8f6ffd7c3
Also update the PRESUBMIT linter configuration to make sure it actually runs the linter when updating ESLint. Otherwise, it would not properly do the full linter check. R=jacktfranklin@chromium.org DISABLE_THIRD_PARTY_CHECK=Update ESLint Bug: 1068145 Change-Id: Ibf2de156366dc64c90ee1aced5537d2038e7a268 Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/2137384 Commit-Queue: Tim van der Lippe <tvanderlippe@chromium.org> Reviewed-by: Jack Franklin <jacktfranklin@chromium.org>
1040 lines
36 KiB
JavaScript
1040 lines
36 KiB
JavaScript
/**
|
|
* @fileoverview The factory of `ConfigArray` objects.
|
|
*
|
|
* This class provides methods to create `ConfigArray` instance.
|
|
*
|
|
* - `create(configData, options)`
|
|
* Create a `ConfigArray` instance from a config data. This is to handle CLI
|
|
* options except `--config`.
|
|
* - `loadFile(filePath, options)`
|
|
* Create a `ConfigArray` instance from a config file. This is to handle
|
|
* `--config` option. If the file was not found, throws the following error:
|
|
* - If the filename was `*.js`, a `MODULE_NOT_FOUND` error.
|
|
* - If the filename was `package.json`, an IO error or an
|
|
* `ESLINT_CONFIG_FIELD_NOT_FOUND` error.
|
|
* - Otherwise, an IO error such as `ENOENT`.
|
|
* - `loadInDirectory(directoryPath, options)`
|
|
* Create a `ConfigArray` instance from a config file which is on a given
|
|
* directory. This tries to load `.eslintrc.*` or `package.json`. If not
|
|
* found, returns an empty `ConfigArray`.
|
|
* - `loadESLintIgnore(filePath)`
|
|
* Create a `ConfigArray` instance from a config file that is `.eslintignore`
|
|
* format. This is to handle `--ignore-path` option.
|
|
* - `loadDefaultESLintIgnore()`
|
|
* Create a `ConfigArray` instance from `.eslintignore` or `package.json` in
|
|
* the current working directory.
|
|
*
|
|
* `ConfigArrayFactory` class has the responsibility that loads configuration
|
|
* files, including loading `extends`, `parser`, and `plugins`. The created
|
|
* `ConfigArray` instance has the loaded `extends`, `parser`, and `plugins`.
|
|
*
|
|
* But this class doesn't handle cascading. `CascadingConfigArrayFactory` class
|
|
* handles cascading and hierarchy.
|
|
*
|
|
* @author Toru Nagashima <https://github.com/mysticatea>
|
|
*/
|
|
"use strict";
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Requirements
|
|
//------------------------------------------------------------------------------
|
|
|
|
const fs = require("fs");
|
|
const path = require("path");
|
|
const importFresh = require("import-fresh");
|
|
const stripComments = require("strip-json-comments");
|
|
const { validateConfigSchema } = require("../shared/config-validator");
|
|
const naming = require("../shared/naming");
|
|
const ModuleResolver = require("../shared/relative-module-resolver");
|
|
const {
|
|
ConfigArray,
|
|
ConfigDependency,
|
|
IgnorePattern,
|
|
OverrideTester
|
|
} = require("./config-array");
|
|
const debug = require("debug")("eslint:config-array-factory");
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Helpers
|
|
//------------------------------------------------------------------------------
|
|
|
|
const eslintRecommendedPath = path.resolve(__dirname, "../../conf/eslint-recommended.js");
|
|
const eslintAllPath = path.resolve(__dirname, "../../conf/eslint-all.js");
|
|
const configFilenames = [
|
|
".eslintrc.js",
|
|
".eslintrc.cjs",
|
|
".eslintrc.yaml",
|
|
".eslintrc.yml",
|
|
".eslintrc.json",
|
|
".eslintrc",
|
|
"package.json"
|
|
];
|
|
|
|
// Define types for VSCode IntelliSense.
|
|
/** @typedef {import("../shared/types").ConfigData} ConfigData */
|
|
/** @typedef {import("../shared/types").OverrideConfigData} OverrideConfigData */
|
|
/** @typedef {import("../shared/types").Parser} Parser */
|
|
/** @typedef {import("../shared/types").Plugin} Plugin */
|
|
/** @typedef {import("./config-array/config-dependency").DependentParser} DependentParser */
|
|
/** @typedef {import("./config-array/config-dependency").DependentPlugin} DependentPlugin */
|
|
/** @typedef {ConfigArray[0]} ConfigArrayElement */
|
|
|
|
/**
|
|
* @typedef {Object} ConfigArrayFactoryOptions
|
|
* @property {Map<string,Plugin>} [additionalPluginPool] The map for additional plugins.
|
|
* @property {string} [cwd] The path to the current working directory.
|
|
* @property {string} [resolvePluginsRelativeTo] A path to the directory that plugins should be resolved from. Defaults to `cwd`.
|
|
*/
|
|
|
|
/**
|
|
* @typedef {Object} ConfigArrayFactoryInternalSlots
|
|
* @property {Map<string,Plugin>} additionalPluginPool The map for additional plugins.
|
|
* @property {string} cwd The path to the current working directory.
|
|
* @property {string} resolvePluginsRelativeTo An absolute path the the directory that plugins should be resolved from.
|
|
*/
|
|
|
|
/** @type {WeakMap<ConfigArrayFactory, ConfigArrayFactoryInternalSlots>} */
|
|
const internalSlotsMap = new WeakMap();
|
|
|
|
/**
|
|
* Check if a given string is a file path.
|
|
* @param {string} nameOrPath A module name or file path.
|
|
* @returns {boolean} `true` if the `nameOrPath` is a file path.
|
|
*/
|
|
function isFilePath(nameOrPath) {
|
|
return (
|
|
/^\.{1,2}[/\\]/u.test(nameOrPath) ||
|
|
path.isAbsolute(nameOrPath)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Convenience wrapper for synchronously reading file contents.
|
|
* @param {string} filePath The filename to read.
|
|
* @returns {string} The file contents, with the BOM removed.
|
|
* @private
|
|
*/
|
|
function readFile(filePath) {
|
|
return fs.readFileSync(filePath, "utf8").replace(/^\ufeff/u, "");
|
|
}
|
|
|
|
/**
|
|
* Loads a YAML configuration from a file.
|
|
* @param {string} filePath The filename to load.
|
|
* @returns {ConfigData} The configuration object from the file.
|
|
* @throws {Error} If the file cannot be read.
|
|
* @private
|
|
*/
|
|
function loadYAMLConfigFile(filePath) {
|
|
debug(`Loading YAML config file: ${filePath}`);
|
|
|
|
// lazy load YAML to improve performance when not used
|
|
const yaml = require("js-yaml");
|
|
|
|
try {
|
|
|
|
// empty YAML file can be null, so always use
|
|
return yaml.safeLoad(readFile(filePath)) || {};
|
|
} catch (e) {
|
|
debug(`Error reading YAML file: ${filePath}`);
|
|
e.message = `Cannot read config file: ${filePath}\nError: ${e.message}`;
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Loads a JSON configuration from a file.
|
|
* @param {string} filePath The filename to load.
|
|
* @returns {ConfigData} The configuration object from the file.
|
|
* @throws {Error} If the file cannot be read.
|
|
* @private
|
|
*/
|
|
function loadJSONConfigFile(filePath) {
|
|
debug(`Loading JSON config file: ${filePath}`);
|
|
|
|
try {
|
|
return JSON.parse(stripComments(readFile(filePath)));
|
|
} catch (e) {
|
|
debug(`Error reading JSON file: ${filePath}`);
|
|
e.message = `Cannot read config file: ${filePath}\nError: ${e.message}`;
|
|
e.messageTemplate = "failed-to-read-json";
|
|
e.messageData = {
|
|
path: filePath,
|
|
message: e.message
|
|
};
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Loads a legacy (.eslintrc) configuration from a file.
|
|
* @param {string} filePath The filename to load.
|
|
* @returns {ConfigData} The configuration object from the file.
|
|
* @throws {Error} If the file cannot be read.
|
|
* @private
|
|
*/
|
|
function loadLegacyConfigFile(filePath) {
|
|
debug(`Loading legacy config file: ${filePath}`);
|
|
|
|
// lazy load YAML to improve performance when not used
|
|
const yaml = require("js-yaml");
|
|
|
|
try {
|
|
return yaml.safeLoad(stripComments(readFile(filePath))) || /* istanbul ignore next */ {};
|
|
} catch (e) {
|
|
debug("Error reading YAML file: %s\n%o", filePath, e);
|
|
e.message = `Cannot read config file: ${filePath}\nError: ${e.message}`;
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Loads a JavaScript configuration from a file.
|
|
* @param {string} filePath The filename to load.
|
|
* @returns {ConfigData} The configuration object from the file.
|
|
* @throws {Error} If the file cannot be read.
|
|
* @private
|
|
*/
|
|
function loadJSConfigFile(filePath) {
|
|
debug(`Loading JS config file: ${filePath}`);
|
|
try {
|
|
return importFresh(filePath);
|
|
} catch (e) {
|
|
debug(`Error reading JavaScript file: ${filePath}`);
|
|
e.message = `Cannot read config file: ${filePath}\nError: ${e.message}`;
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Loads a configuration from a package.json file.
|
|
* @param {string} filePath The filename to load.
|
|
* @returns {ConfigData} The configuration object from the file.
|
|
* @throws {Error} If the file cannot be read.
|
|
* @private
|
|
*/
|
|
function loadPackageJSONConfigFile(filePath) {
|
|
debug(`Loading package.json config file: ${filePath}`);
|
|
try {
|
|
const packageData = loadJSONConfigFile(filePath);
|
|
|
|
if (!Object.hasOwnProperty.call(packageData, "eslintConfig")) {
|
|
throw Object.assign(
|
|
new Error("package.json file doesn't have 'eslintConfig' field."),
|
|
{ code: "ESLINT_CONFIG_FIELD_NOT_FOUND" }
|
|
);
|
|
}
|
|
|
|
return packageData.eslintConfig;
|
|
} catch (e) {
|
|
debug(`Error reading package.json file: ${filePath}`);
|
|
e.message = `Cannot read config file: ${filePath}\nError: ${e.message}`;
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Loads a `.eslintignore` from a file.
|
|
* @param {string} filePath The filename to load.
|
|
* @returns {string[]} The ignore patterns from the file.
|
|
* @private
|
|
*/
|
|
function loadESLintIgnoreFile(filePath) {
|
|
debug(`Loading .eslintignore file: ${filePath}`);
|
|
|
|
try {
|
|
return readFile(filePath)
|
|
.split(/\r?\n/gu)
|
|
.filter(line => line.trim() !== "" && !line.startsWith("#"));
|
|
} catch (e) {
|
|
debug(`Error reading .eslintignore file: ${filePath}`);
|
|
e.message = `Cannot read .eslintignore file: ${filePath}\nError: ${e.message}`;
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates an error to notify about a missing config to extend from.
|
|
* @param {string} configName The name of the missing config.
|
|
* @param {string} importerName The name of the config that imported the missing config
|
|
* @returns {Error} The error object to throw
|
|
* @private
|
|
*/
|
|
function configMissingError(configName, importerName) {
|
|
return Object.assign(
|
|
new Error(`Failed to load config "${configName}" to extend from.`),
|
|
{
|
|
messageTemplate: "extend-config-missing",
|
|
messageData: { configName, importerName }
|
|
}
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Loads a configuration file regardless of the source. Inspects the file path
|
|
* to determine the correctly way to load the config file.
|
|
* @param {string} filePath The path to the configuration.
|
|
* @returns {ConfigData|null} The configuration information.
|
|
* @private
|
|
*/
|
|
function loadConfigFile(filePath) {
|
|
switch (path.extname(filePath)) {
|
|
case ".js":
|
|
case ".cjs":
|
|
return loadJSConfigFile(filePath);
|
|
|
|
case ".json":
|
|
if (path.basename(filePath) === "package.json") {
|
|
return loadPackageJSONConfigFile(filePath);
|
|
}
|
|
return loadJSONConfigFile(filePath);
|
|
|
|
case ".yaml":
|
|
case ".yml":
|
|
return loadYAMLConfigFile(filePath);
|
|
|
|
default:
|
|
return loadLegacyConfigFile(filePath);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Write debug log.
|
|
* @param {string} request The requested module name.
|
|
* @param {string} relativeTo The file path to resolve the request relative to.
|
|
* @param {string} filePath The resolved file path.
|
|
* @returns {void}
|
|
*/
|
|
function writeDebugLogForLoading(request, relativeTo, filePath) {
|
|
/* istanbul ignore next */
|
|
if (debug.enabled) {
|
|
let nameAndVersion = null;
|
|
|
|
try {
|
|
const packageJsonPath = ModuleResolver.resolve(
|
|
`${request}/package.json`,
|
|
relativeTo
|
|
);
|
|
const { version = "unknown" } = require(packageJsonPath);
|
|
|
|
nameAndVersion = `${request}@${version}`;
|
|
} catch (error) {
|
|
debug("package.json was not found:", error.message);
|
|
nameAndVersion = request;
|
|
}
|
|
|
|
debug("Loaded: %s (%s)", nameAndVersion, filePath);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Concatenate two config data.
|
|
* @param {IterableIterator<ConfigArrayElement>|null} elements The config elements.
|
|
* @param {ConfigArray|null} parentConfigArray The parent config array.
|
|
* @returns {ConfigArray} The concatenated config array.
|
|
*/
|
|
function createConfigArray(elements, parentConfigArray) {
|
|
if (!elements) {
|
|
return parentConfigArray || new ConfigArray();
|
|
}
|
|
const configArray = new ConfigArray(...elements);
|
|
|
|
if (parentConfigArray && !configArray.isRoot()) {
|
|
configArray.unshift(...parentConfigArray);
|
|
}
|
|
return configArray;
|
|
}
|
|
|
|
/**
|
|
* Normalize a given plugin.
|
|
* - Ensure the object to have four properties: configs, environments, processors, and rules.
|
|
* - Ensure the object to not have other properties.
|
|
* @param {Plugin} plugin The plugin to normalize.
|
|
* @returns {Plugin} The normalized plugin.
|
|
*/
|
|
function normalizePlugin(plugin) {
|
|
return {
|
|
configs: plugin.configs || {},
|
|
environments: plugin.environments || {},
|
|
processors: plugin.processors || {},
|
|
rules: plugin.rules || {}
|
|
};
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Public Interface
|
|
//------------------------------------------------------------------------------
|
|
|
|
/**
|
|
* The factory of `ConfigArray` objects.
|
|
*/
|
|
class ConfigArrayFactory {
|
|
|
|
/**
|
|
* Initialize this instance.
|
|
* @param {ConfigArrayFactoryOptions} [options] The map for additional plugins.
|
|
*/
|
|
constructor({
|
|
additionalPluginPool = new Map(),
|
|
cwd = process.cwd(),
|
|
resolvePluginsRelativeTo = cwd
|
|
} = {}) {
|
|
internalSlotsMap.set(this, { additionalPluginPool, cwd, resolvePluginsRelativeTo: path.resolve(cwd, resolvePluginsRelativeTo) });
|
|
}
|
|
|
|
/**
|
|
* Create `ConfigArray` instance from a config data.
|
|
* @param {ConfigData|null} configData The config data to create.
|
|
* @param {Object} [options] The options.
|
|
* @param {string} [options.filePath] The path to this config data.
|
|
* @param {string} [options.name] The config name.
|
|
* @param {ConfigArray} [options.parent] The parent config array.
|
|
* @returns {ConfigArray} Loaded config.
|
|
*/
|
|
create(configData, { filePath, name, parent } = {}) {
|
|
return createConfigArray(
|
|
configData
|
|
? this._normalizeConfigData(configData, filePath, name)
|
|
: null,
|
|
parent
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Load a config file.
|
|
* @param {string} filePath The path to a config file.
|
|
* @param {Object} [options] The options.
|
|
* @param {string} [options.name] The config name.
|
|
* @param {ConfigArray} [options.parent] The parent config array.
|
|
* @returns {ConfigArray} Loaded config.
|
|
*/
|
|
loadFile(filePath, { name, parent } = {}) {
|
|
const { cwd } = internalSlotsMap.get(this);
|
|
const absolutePath = path.resolve(cwd, filePath);
|
|
|
|
return createConfigArray(
|
|
this._loadConfigData(absolutePath, name),
|
|
parent
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Load the config file on a given directory if exists.
|
|
* @param {string} directoryPath The path to a directory.
|
|
* @param {Object} [options] The options.
|
|
* @param {string} [options.name] The config name.
|
|
* @param {ConfigArray} [options.parent] The parent config array.
|
|
* @returns {ConfigArray} Loaded config. An empty `ConfigArray` if any config doesn't exist.
|
|
*/
|
|
loadInDirectory(directoryPath, { name, parent } = {}) {
|
|
const { cwd } = internalSlotsMap.get(this);
|
|
const absolutePath = path.resolve(cwd, directoryPath);
|
|
|
|
return createConfigArray(
|
|
this._loadConfigDataInDirectory(absolutePath, name),
|
|
parent
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Load `.eslintignore` file.
|
|
* @param {string} filePath The path to a `.eslintignore` file to load.
|
|
* @returns {ConfigArray} Loaded config. An empty `ConfigArray` if any config doesn't exist.
|
|
*/
|
|
loadESLintIgnore(filePath) {
|
|
const { cwd } = internalSlotsMap.get(this);
|
|
const absolutePath = path.resolve(cwd, filePath);
|
|
const name = path.relative(cwd, absolutePath);
|
|
const ignorePatterns = loadESLintIgnoreFile(absolutePath);
|
|
|
|
return createConfigArray(
|
|
this._normalizeESLintIgnoreData(ignorePatterns, absolutePath, name)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Load `.eslintignore` file in the current working directory.
|
|
* @returns {ConfigArray} Loaded config. An empty `ConfigArray` if any config doesn't exist.
|
|
*/
|
|
loadDefaultESLintIgnore() {
|
|
const { cwd } = internalSlotsMap.get(this);
|
|
const eslintIgnorePath = path.resolve(cwd, ".eslintignore");
|
|
const packageJsonPath = path.resolve(cwd, "package.json");
|
|
|
|
if (fs.existsSync(eslintIgnorePath)) {
|
|
return this.loadESLintIgnore(eslintIgnorePath);
|
|
}
|
|
if (fs.existsSync(packageJsonPath)) {
|
|
const data = loadJSONConfigFile(packageJsonPath);
|
|
|
|
if (Object.hasOwnProperty.call(data, "eslintIgnore")) {
|
|
if (!Array.isArray(data.eslintIgnore)) {
|
|
throw new Error("Package.json eslintIgnore property requires an array of paths");
|
|
}
|
|
return createConfigArray(
|
|
this._normalizeESLintIgnoreData(
|
|
data.eslintIgnore,
|
|
packageJsonPath,
|
|
"eslintIgnore in package.json"
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
return new ConfigArray();
|
|
}
|
|
|
|
/**
|
|
* Load a given config file.
|
|
* @param {string} filePath The path to a config file.
|
|
* @param {string} name The config name.
|
|
* @returns {IterableIterator<ConfigArrayElement>} Loaded config.
|
|
* @private
|
|
*/
|
|
_loadConfigData(filePath, name) {
|
|
return this._normalizeConfigData(
|
|
loadConfigFile(filePath),
|
|
filePath,
|
|
name
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Load the config file in a given directory if exists.
|
|
* @param {string} directoryPath The path to a directory.
|
|
* @param {string} name The config name.
|
|
* @returns {IterableIterator<ConfigArrayElement> | null} Loaded config. `null` if any config doesn't exist.
|
|
* @private
|
|
*/
|
|
_loadConfigDataInDirectory(directoryPath, name) {
|
|
for (const filename of configFilenames) {
|
|
const filePath = path.join(directoryPath, filename);
|
|
|
|
if (fs.existsSync(filePath)) {
|
|
let configData;
|
|
|
|
try {
|
|
configData = loadConfigFile(filePath);
|
|
} catch (error) {
|
|
if (!error || error.code !== "ESLINT_CONFIG_FIELD_NOT_FOUND") {
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
if (configData) {
|
|
debug(`Config file found: ${filePath}`);
|
|
return this._normalizeConfigData(configData, filePath, name);
|
|
}
|
|
}
|
|
}
|
|
|
|
debug(`Config file not found on ${directoryPath}`);
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Normalize a given `.eslintignore` data to config array elements.
|
|
* @param {string[]} ignorePatterns The patterns to ignore files.
|
|
* @param {string|undefined} filePath The file path of this config.
|
|
* @param {string|undefined} name The name of this config.
|
|
* @returns {IterableIterator<ConfigArrayElement>} The normalized config.
|
|
* @private
|
|
*/
|
|
*_normalizeESLintIgnoreData(ignorePatterns, filePath, name) {
|
|
const elements = this._normalizeObjectConfigData(
|
|
{ ignorePatterns },
|
|
filePath,
|
|
name
|
|
);
|
|
|
|
// Set `ignorePattern.loose` flag for backward compatibility.
|
|
for (const element of elements) {
|
|
if (element.ignorePattern) {
|
|
element.ignorePattern.loose = true;
|
|
}
|
|
yield element;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Normalize a given config to an array.
|
|
* @param {ConfigData} configData The config data to normalize.
|
|
* @param {string|undefined} providedFilePath The file path of this config.
|
|
* @param {string|undefined} providedName The name of this config.
|
|
* @returns {IterableIterator<ConfigArrayElement>} The normalized config.
|
|
* @private
|
|
*/
|
|
_normalizeConfigData(configData, providedFilePath, providedName) {
|
|
const { cwd } = internalSlotsMap.get(this);
|
|
const filePath = providedFilePath
|
|
? path.resolve(cwd, providedFilePath)
|
|
: "";
|
|
const name = providedName || (filePath && path.relative(cwd, filePath));
|
|
|
|
validateConfigSchema(configData, name || filePath);
|
|
|
|
return this._normalizeObjectConfigData(configData, filePath, name);
|
|
}
|
|
|
|
/**
|
|
* Normalize a given config to an array.
|
|
* @param {ConfigData|OverrideConfigData} configData The config data to normalize.
|
|
* @param {string} filePath The file path of this config.
|
|
* @param {string} name The name of this config.
|
|
* @returns {IterableIterator<ConfigArrayElement>} The normalized config.
|
|
* @private
|
|
*/
|
|
*_normalizeObjectConfigData(configData, filePath, name) {
|
|
const { cwd } = internalSlotsMap.get(this);
|
|
const { files, excludedFiles, ...configBody } = configData;
|
|
const basePath = filePath ? path.dirname(filePath) : cwd;
|
|
const criteria = OverrideTester.create(files, excludedFiles, basePath);
|
|
const elements =
|
|
this._normalizeObjectConfigDataBody(configBody, filePath, name);
|
|
|
|
// Apply the criteria to every element.
|
|
for (const element of elements) {
|
|
|
|
// Adopt the base path of the entry file (the outermost base path).
|
|
if (element.criteria) {
|
|
element.criteria.basePath = basePath;
|
|
}
|
|
if (element.ignorePattern) {
|
|
element.ignorePattern.basePath = basePath;
|
|
}
|
|
|
|
/*
|
|
* Merge the criteria; this is for only file extension processors in
|
|
* `overrides` section for now.
|
|
*/
|
|
element.criteria = OverrideTester.and(criteria, element.criteria);
|
|
|
|
/*
|
|
* Remove `root` property to ignore `root` settings which came from
|
|
* `extends` in `overrides`.
|
|
*/
|
|
if (element.criteria) {
|
|
element.root = void 0;
|
|
}
|
|
|
|
yield element;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Normalize a given config to an array.
|
|
* @param {ConfigData} configData The config data to normalize.
|
|
* @param {string} filePath The file path of this config.
|
|
* @param {string} name The name of this config.
|
|
* @returns {IterableIterator<ConfigArrayElement>} The normalized config.
|
|
* @private
|
|
*/
|
|
*_normalizeObjectConfigDataBody(
|
|
{
|
|
env,
|
|
extends: extend,
|
|
globals,
|
|
ignorePatterns,
|
|
noInlineConfig,
|
|
parser: parserName,
|
|
parserOptions,
|
|
plugins: pluginList,
|
|
processor,
|
|
reportUnusedDisableDirectives,
|
|
root,
|
|
rules,
|
|
settings,
|
|
overrides: overrideList = []
|
|
},
|
|
filePath,
|
|
name
|
|
) {
|
|
const extendList = Array.isArray(extend) ? extend : [extend];
|
|
const ignorePattern = ignorePatterns && new IgnorePattern(
|
|
Array.isArray(ignorePatterns) ? ignorePatterns : [ignorePatterns],
|
|
filePath ? path.dirname(filePath) : internalSlotsMap.get(this).cwd
|
|
);
|
|
|
|
// Flatten `extends`.
|
|
for (const extendName of extendList.filter(Boolean)) {
|
|
yield* this._loadExtends(extendName, filePath, name);
|
|
}
|
|
|
|
// Load parser & plugins.
|
|
const parser =
|
|
parserName && this._loadParser(parserName, filePath, name);
|
|
const plugins =
|
|
pluginList && this._loadPlugins(pluginList, filePath, name);
|
|
|
|
// Yield pseudo config data for file extension processors.
|
|
if (plugins) {
|
|
yield* this._takeFileExtensionProcessors(plugins, filePath, name);
|
|
}
|
|
|
|
// Yield the config data except `extends` and `overrides`.
|
|
yield {
|
|
|
|
// Debug information.
|
|
name,
|
|
filePath,
|
|
|
|
// Config data.
|
|
criteria: null,
|
|
env,
|
|
globals,
|
|
ignorePattern,
|
|
noInlineConfig,
|
|
parser,
|
|
parserOptions,
|
|
plugins,
|
|
processor,
|
|
reportUnusedDisableDirectives,
|
|
root,
|
|
rules,
|
|
settings
|
|
};
|
|
|
|
// Flatten `overries`.
|
|
for (let i = 0; i < overrideList.length; ++i) {
|
|
yield* this._normalizeObjectConfigData(
|
|
overrideList[i],
|
|
filePath,
|
|
`${name}#overrides[${i}]`
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load configs of an element in `extends`.
|
|
* @param {string} extendName The name of a base config.
|
|
* @param {string} importerPath The file path which has the `extends` property.
|
|
* @param {string} importerName The name of the config which has the `extends` property.
|
|
* @returns {IterableIterator<ConfigArrayElement>} The normalized config.
|
|
* @private
|
|
*/
|
|
_loadExtends(extendName, importerPath, importerName) {
|
|
debug("Loading {extends:%j} relative to %s", extendName, importerPath);
|
|
try {
|
|
if (extendName.startsWith("eslint:")) {
|
|
return this._loadExtendedBuiltInConfig(
|
|
extendName,
|
|
importerName
|
|
);
|
|
}
|
|
if (extendName.startsWith("plugin:")) {
|
|
return this._loadExtendedPluginConfig(
|
|
extendName,
|
|
importerPath,
|
|
importerName
|
|
);
|
|
}
|
|
return this._loadExtendedShareableConfig(
|
|
extendName,
|
|
importerPath,
|
|
importerName
|
|
);
|
|
} catch (error) {
|
|
error.message += `\nReferenced from: ${importerPath || importerName}`;
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load configs of an element in `extends`.
|
|
* @param {string} extendName The name of a base config.
|
|
* @param {string} importerName The name of the config which has the `extends` property.
|
|
* @returns {IterableIterator<ConfigArrayElement>} The normalized config.
|
|
* @private
|
|
*/
|
|
_loadExtendedBuiltInConfig(extendName, importerName) {
|
|
const name = `${importerName} » ${extendName}`;
|
|
|
|
if (extendName === "eslint:recommended") {
|
|
return this._loadConfigData(eslintRecommendedPath, name);
|
|
}
|
|
if (extendName === "eslint:all") {
|
|
return this._loadConfigData(eslintAllPath, name);
|
|
}
|
|
|
|
throw configMissingError(extendName, importerName);
|
|
}
|
|
|
|
/**
|
|
* Load configs of an element in `extends`.
|
|
* @param {string} extendName The name of a base config.
|
|
* @param {string} importerPath The file path which has the `extends` property.
|
|
* @param {string} importerName The name of the config which has the `extends` property.
|
|
* @returns {IterableIterator<ConfigArrayElement>} The normalized config.
|
|
* @private
|
|
*/
|
|
_loadExtendedPluginConfig(extendName, importerPath, importerName) {
|
|
const slashIndex = extendName.lastIndexOf("/");
|
|
const pluginName = extendName.slice("plugin:".length, slashIndex);
|
|
const configName = extendName.slice(slashIndex + 1);
|
|
|
|
if (isFilePath(pluginName)) {
|
|
throw new Error("'extends' cannot use a file path for plugins.");
|
|
}
|
|
|
|
const plugin = this._loadPlugin(pluginName, importerPath, importerName);
|
|
const configData =
|
|
plugin.definition &&
|
|
plugin.definition.configs[configName];
|
|
|
|
if (configData) {
|
|
return this._normalizeConfigData(
|
|
configData,
|
|
plugin.filePath,
|
|
`${importerName} » plugin:${plugin.id}/${configName}`
|
|
);
|
|
}
|
|
|
|
throw plugin.error || configMissingError(extendName, importerPath);
|
|
}
|
|
|
|
/**
|
|
* Load configs of an element in `extends`.
|
|
* @param {string} extendName The name of a base config.
|
|
* @param {string} importerPath The file path which has the `extends` property.
|
|
* @param {string} importerName The name of the config which has the `extends` property.
|
|
* @returns {IterableIterator<ConfigArrayElement>} The normalized config.
|
|
* @private
|
|
*/
|
|
_loadExtendedShareableConfig(extendName, importerPath, importerName) {
|
|
const { cwd } = internalSlotsMap.get(this);
|
|
const relativeTo = importerPath || path.join(cwd, "__placeholder__.js");
|
|
let request;
|
|
|
|
if (isFilePath(extendName)) {
|
|
request = extendName;
|
|
} else if (extendName.startsWith(".")) {
|
|
request = `./${extendName}`; // For backward compatibility. A ton of tests depended on this behavior.
|
|
} else {
|
|
request = naming.normalizePackageName(
|
|
extendName,
|
|
"eslint-config"
|
|
);
|
|
}
|
|
|
|
let filePath;
|
|
|
|
try {
|
|
filePath = ModuleResolver.resolve(request, relativeTo);
|
|
} catch (error) {
|
|
/* istanbul ignore else */
|
|
if (error && error.code === "MODULE_NOT_FOUND") {
|
|
throw configMissingError(extendName, importerPath);
|
|
}
|
|
throw error;
|
|
}
|
|
|
|
writeDebugLogForLoading(request, relativeTo, filePath);
|
|
return this._loadConfigData(filePath, `${importerName} » ${request}`);
|
|
}
|
|
|
|
/**
|
|
* Load given plugins.
|
|
* @param {string[]} names The plugin names to load.
|
|
* @param {string} importerPath The path to a config file that imports it. This is just a debug info.
|
|
* @param {string} importerName The name of a config file that imports it. This is just a debug info.
|
|
* @returns {Record<string,DependentPlugin>} The loaded parser.
|
|
* @private
|
|
*/
|
|
_loadPlugins(names, importerPath, importerName) {
|
|
return names.reduce((map, name) => {
|
|
if (isFilePath(name)) {
|
|
throw new Error("Plugins array cannot includes file paths.");
|
|
}
|
|
const plugin = this._loadPlugin(name, importerPath, importerName);
|
|
|
|
map[plugin.id] = plugin;
|
|
|
|
return map;
|
|
}, {});
|
|
}
|
|
|
|
/**
|
|
* Load a given parser.
|
|
* @param {string} nameOrPath The package name or the path to a parser file.
|
|
* @param {string} importerPath The path to a config file that imports it.
|
|
* @param {string} importerName The name of a config file that imports it. This is just a debug info.
|
|
* @returns {DependentParser} The loaded parser.
|
|
*/
|
|
_loadParser(nameOrPath, importerPath, importerName) {
|
|
debug("Loading parser %j from %s", nameOrPath, importerPath);
|
|
|
|
const { cwd } = internalSlotsMap.get(this);
|
|
const relativeTo = importerPath || path.join(cwd, "__placeholder__.js");
|
|
|
|
try {
|
|
const filePath = ModuleResolver.resolve(nameOrPath, relativeTo);
|
|
|
|
writeDebugLogForLoading(nameOrPath, relativeTo, filePath);
|
|
|
|
return new ConfigDependency({
|
|
definition: require(filePath),
|
|
filePath,
|
|
id: nameOrPath,
|
|
importerName,
|
|
importerPath
|
|
});
|
|
} catch (error) {
|
|
|
|
// If the parser name is "espree", load the espree of ESLint.
|
|
if (nameOrPath === "espree") {
|
|
debug("Fallback espree.");
|
|
return new ConfigDependency({
|
|
definition: require("espree"),
|
|
filePath: require.resolve("espree"),
|
|
id: nameOrPath,
|
|
importerName,
|
|
importerPath
|
|
});
|
|
}
|
|
|
|
debug("Failed to load parser '%s' declared in '%s'.", nameOrPath, importerName);
|
|
error.message = `Failed to load parser '${nameOrPath}' declared in '${importerName}': ${error.message}`;
|
|
|
|
return new ConfigDependency({
|
|
error,
|
|
id: nameOrPath,
|
|
importerName,
|
|
importerPath
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load a given plugin.
|
|
* @param {string} name The plugin name to load.
|
|
* @param {string} importerPath The path to a config file that imports it. This is just a debug info.
|
|
* @param {string} importerName The name of a config file that imports it. This is just a debug info.
|
|
* @returns {DependentPlugin} The loaded plugin.
|
|
* @private
|
|
*/
|
|
_loadPlugin(name, importerPath, importerName) {
|
|
debug("Loading plugin %j from %s", name, importerPath);
|
|
|
|
const { additionalPluginPool, resolvePluginsRelativeTo } = internalSlotsMap.get(this);
|
|
const request = naming.normalizePackageName(name, "eslint-plugin");
|
|
const id = naming.getShorthandName(request, "eslint-plugin");
|
|
const relativeTo = path.join(resolvePluginsRelativeTo, "__placeholder__.js");
|
|
|
|
if (name.match(/\s+/u)) {
|
|
const error = Object.assign(
|
|
new Error(`Whitespace found in plugin name '${name}'`),
|
|
{
|
|
messageTemplate: "whitespace-found",
|
|
messageData: { pluginName: request }
|
|
}
|
|
);
|
|
|
|
return new ConfigDependency({
|
|
error,
|
|
id,
|
|
importerName,
|
|
importerPath
|
|
});
|
|
}
|
|
|
|
// Check for additional pool.
|
|
const plugin =
|
|
additionalPluginPool.get(request) ||
|
|
additionalPluginPool.get(id);
|
|
|
|
if (plugin) {
|
|
return new ConfigDependency({
|
|
definition: normalizePlugin(plugin),
|
|
filePath: importerPath,
|
|
id,
|
|
importerName,
|
|
importerPath
|
|
});
|
|
}
|
|
|
|
let filePath;
|
|
let error;
|
|
|
|
try {
|
|
filePath = ModuleResolver.resolve(request, relativeTo);
|
|
} catch (resolveError) {
|
|
error = resolveError;
|
|
/* istanbul ignore else */
|
|
if (error && error.code === "MODULE_NOT_FOUND") {
|
|
error.messageTemplate = "plugin-missing";
|
|
error.messageData = {
|
|
pluginName: request,
|
|
resolvePluginsRelativeTo,
|
|
importerName
|
|
};
|
|
}
|
|
}
|
|
|
|
if (filePath) {
|
|
try {
|
|
writeDebugLogForLoading(request, relativeTo, filePath);
|
|
|
|
const startTime = Date.now();
|
|
const pluginDefinition = require(filePath);
|
|
|
|
debug(`Plugin ${filePath} loaded in: ${Date.now() - startTime}ms`);
|
|
|
|
return new ConfigDependency({
|
|
definition: normalizePlugin(pluginDefinition),
|
|
filePath,
|
|
id,
|
|
importerName,
|
|
importerPath
|
|
});
|
|
} catch (loadError) {
|
|
error = loadError;
|
|
}
|
|
}
|
|
|
|
debug("Failed to load plugin '%s' declared in '%s'.", name, importerName);
|
|
error.message = `Failed to load plugin '${name}' declared in '${importerName}': ${error.message}`;
|
|
return new ConfigDependency({
|
|
error,
|
|
id,
|
|
importerName,
|
|
importerPath
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Take file expression processors as config array elements.
|
|
* @param {Record<string,DependentPlugin>} plugins The plugin definitions.
|
|
* @param {string} filePath The file path of this config.
|
|
* @param {string} name The name of this config.
|
|
* @returns {IterableIterator<ConfigArrayElement>} The config array elements of file expression processors.
|
|
* @private
|
|
*/
|
|
*_takeFileExtensionProcessors(plugins, filePath, name) {
|
|
for (const pluginId of Object.keys(plugins)) {
|
|
const processors =
|
|
plugins[pluginId] &&
|
|
plugins[pluginId].definition &&
|
|
plugins[pluginId].definition.processors;
|
|
|
|
if (!processors) {
|
|
continue;
|
|
}
|
|
|
|
for (const processorId of Object.keys(processors)) {
|
|
if (processorId.startsWith(".")) {
|
|
yield* this._normalizeObjectConfigData(
|
|
{
|
|
files: [`*${processorId}`],
|
|
processor: `${pluginId}/${processorId}`
|
|
},
|
|
filePath,
|
|
`${name}#processors["${pluginId}/${processorId}"]`
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = { ConfigArrayFactory };
|