| [d565449] | 1 | 'use strict';
|
|---|
| 2 |
|
|---|
| 3 | Object.defineProperty(exports, '__esModule', { value: true });
|
|---|
| 4 |
|
|---|
| 5 | var util = require('util');
|
|---|
| 6 | var path = require('path');
|
|---|
| 7 | var Ajv = require('ajv');
|
|---|
| 8 | var globals = require('globals');
|
|---|
| 9 |
|
|---|
| 10 | function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
|
|---|
| 11 |
|
|---|
| 12 | var util__default = /*#__PURE__*/_interopDefaultLegacy(util);
|
|---|
| 13 | var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
|
|---|
| 14 | var Ajv__default = /*#__PURE__*/_interopDefaultLegacy(Ajv);
|
|---|
| 15 | var globals__default = /*#__PURE__*/_interopDefaultLegacy(globals);
|
|---|
| 16 |
|
|---|
| 17 | /**
|
|---|
| 18 | * @fileoverview Config file operations. This file must be usable in the browser,
|
|---|
| 19 | * so no Node-specific code can be here.
|
|---|
| 20 | * @author Nicholas C. Zakas
|
|---|
| 21 | */
|
|---|
| 22 |
|
|---|
| 23 | //------------------------------------------------------------------------------
|
|---|
| 24 | // Private
|
|---|
| 25 | //------------------------------------------------------------------------------
|
|---|
| 26 |
|
|---|
| 27 | const RULE_SEVERITY_STRINGS = ["off", "warn", "error"],
|
|---|
| 28 | RULE_SEVERITY = RULE_SEVERITY_STRINGS.reduce((map, value, index) => {
|
|---|
| 29 | map[value] = index;
|
|---|
| 30 | return map;
|
|---|
| 31 | }, {}),
|
|---|
| 32 | VALID_SEVERITIES = [0, 1, 2, "off", "warn", "error"];
|
|---|
| 33 |
|
|---|
| 34 | //------------------------------------------------------------------------------
|
|---|
| 35 | // Public Interface
|
|---|
| 36 | //------------------------------------------------------------------------------
|
|---|
| 37 |
|
|---|
| 38 | /**
|
|---|
| 39 | * Normalizes the severity value of a rule's configuration to a number
|
|---|
| 40 | * @param {(number|string|[number, ...*]|[string, ...*])} ruleConfig A rule's configuration value, generally
|
|---|
| 41 | * received from the user. A valid config value is either 0, 1, 2, the string "off" (treated the same as 0),
|
|---|
| 42 | * the string "warn" (treated the same as 1), the string "error" (treated the same as 2), or an array
|
|---|
| 43 | * whose first element is one of the above values. Strings are matched case-insensitively.
|
|---|
| 44 | * @returns {(0|1|2)} The numeric severity value if the config value was valid, otherwise 0.
|
|---|
| 45 | */
|
|---|
| 46 | function getRuleSeverity(ruleConfig) {
|
|---|
| 47 | const severityValue = Array.isArray(ruleConfig) ? ruleConfig[0] : ruleConfig;
|
|---|
| 48 |
|
|---|
| 49 | if (severityValue === 0 || severityValue === 1 || severityValue === 2) {
|
|---|
| 50 | return severityValue;
|
|---|
| 51 | }
|
|---|
| 52 |
|
|---|
| 53 | if (typeof severityValue === "string") {
|
|---|
| 54 | return RULE_SEVERITY[severityValue.toLowerCase()] || 0;
|
|---|
| 55 | }
|
|---|
| 56 |
|
|---|
| 57 | return 0;
|
|---|
| 58 | }
|
|---|
| 59 |
|
|---|
| 60 | /**
|
|---|
| 61 | * Converts old-style severity settings (0, 1, 2) into new-style
|
|---|
| 62 | * severity settings (off, warn, error) for all rules. Assumption is that severity
|
|---|
| 63 | * values have already been validated as correct.
|
|---|
| 64 | * @param {Object} config The config object to normalize.
|
|---|
| 65 | * @returns {void}
|
|---|
| 66 | */
|
|---|
| 67 | function normalizeToStrings(config) {
|
|---|
| 68 |
|
|---|
| 69 | if (config.rules) {
|
|---|
| 70 | Object.keys(config.rules).forEach(ruleId => {
|
|---|
| 71 | const ruleConfig = config.rules[ruleId];
|
|---|
| 72 |
|
|---|
| 73 | if (typeof ruleConfig === "number") {
|
|---|
| 74 | config.rules[ruleId] = RULE_SEVERITY_STRINGS[ruleConfig] || RULE_SEVERITY_STRINGS[0];
|
|---|
| 75 | } else if (Array.isArray(ruleConfig) && typeof ruleConfig[0] === "number") {
|
|---|
| 76 | ruleConfig[0] = RULE_SEVERITY_STRINGS[ruleConfig[0]] || RULE_SEVERITY_STRINGS[0];
|
|---|
| 77 | }
|
|---|
| 78 | });
|
|---|
| 79 | }
|
|---|
| 80 | }
|
|---|
| 81 |
|
|---|
| 82 | /**
|
|---|
| 83 | * Determines if the severity for the given rule configuration represents an error.
|
|---|
| 84 | * @param {int|string|Array} ruleConfig The configuration for an individual rule.
|
|---|
| 85 | * @returns {boolean} True if the rule represents an error, false if not.
|
|---|
| 86 | */
|
|---|
| 87 | function isErrorSeverity(ruleConfig) {
|
|---|
| 88 | return getRuleSeverity(ruleConfig) === 2;
|
|---|
| 89 | }
|
|---|
| 90 |
|
|---|
| 91 | /**
|
|---|
| 92 | * Checks whether a given config has valid severity or not.
|
|---|
| 93 | * @param {number|string|Array} ruleConfig The configuration for an individual rule.
|
|---|
| 94 | * @returns {boolean} `true` if the configuration has valid severity.
|
|---|
| 95 | */
|
|---|
| 96 | function isValidSeverity(ruleConfig) {
|
|---|
| 97 | let severity = Array.isArray(ruleConfig) ? ruleConfig[0] : ruleConfig;
|
|---|
| 98 |
|
|---|
| 99 | if (typeof severity === "string") {
|
|---|
| 100 | severity = severity.toLowerCase();
|
|---|
| 101 | }
|
|---|
| 102 | return VALID_SEVERITIES.indexOf(severity) !== -1;
|
|---|
| 103 | }
|
|---|
| 104 |
|
|---|
| 105 | /**
|
|---|
| 106 | * Checks whether every rule of a given config has valid severity or not.
|
|---|
| 107 | * @param {Object} config The configuration for rules.
|
|---|
| 108 | * @returns {boolean} `true` if the configuration has valid severity.
|
|---|
| 109 | */
|
|---|
| 110 | function isEverySeverityValid(config) {
|
|---|
| 111 | return Object.keys(config).every(ruleId => isValidSeverity(config[ruleId]));
|
|---|
| 112 | }
|
|---|
| 113 |
|
|---|
| 114 | /**
|
|---|
| 115 | * Normalizes a value for a global in a config
|
|---|
| 116 | * @param {(boolean|string|null)} configuredValue The value given for a global in configuration or in
|
|---|
| 117 | * a global directive comment
|
|---|
| 118 | * @returns {("readable"|"writeable"|"off")} The value normalized as a string
|
|---|
| 119 | * @throws Error if global value is invalid
|
|---|
| 120 | */
|
|---|
| 121 | function normalizeConfigGlobal(configuredValue) {
|
|---|
| 122 | switch (configuredValue) {
|
|---|
| 123 | case "off":
|
|---|
| 124 | return "off";
|
|---|
| 125 |
|
|---|
| 126 | case true:
|
|---|
| 127 | case "true":
|
|---|
| 128 | case "writeable":
|
|---|
| 129 | case "writable":
|
|---|
| 130 | return "writable";
|
|---|
| 131 |
|
|---|
| 132 | case null:
|
|---|
| 133 | case false:
|
|---|
| 134 | case "false":
|
|---|
| 135 | case "readable":
|
|---|
| 136 | case "readonly":
|
|---|
| 137 | return "readonly";
|
|---|
| 138 |
|
|---|
| 139 | default:
|
|---|
| 140 | throw new Error(`'${configuredValue}' is not a valid configuration for a global (use 'readonly', 'writable', or 'off')`);
|
|---|
| 141 | }
|
|---|
| 142 | }
|
|---|
| 143 |
|
|---|
| 144 | var ConfigOps = {
|
|---|
| 145 | __proto__: null,
|
|---|
| 146 | getRuleSeverity: getRuleSeverity,
|
|---|
| 147 | normalizeToStrings: normalizeToStrings,
|
|---|
| 148 | isErrorSeverity: isErrorSeverity,
|
|---|
| 149 | isValidSeverity: isValidSeverity,
|
|---|
| 150 | isEverySeverityValid: isEverySeverityValid,
|
|---|
| 151 | normalizeConfigGlobal: normalizeConfigGlobal
|
|---|
| 152 | };
|
|---|
| 153 |
|
|---|
| 154 | /**
|
|---|
| 155 | * @fileoverview Provide the function that emits deprecation warnings.
|
|---|
| 156 | * @author Toru Nagashima <http://github.com/mysticatea>
|
|---|
| 157 | */
|
|---|
| 158 |
|
|---|
| 159 | //------------------------------------------------------------------------------
|
|---|
| 160 | // Private
|
|---|
| 161 | //------------------------------------------------------------------------------
|
|---|
| 162 |
|
|---|
| 163 | // Defitions for deprecation warnings.
|
|---|
| 164 | const deprecationWarningMessages = {
|
|---|
| 165 | ESLINT_LEGACY_ECMAFEATURES:
|
|---|
| 166 | "The 'ecmaFeatures' config file property is deprecated and has no effect.",
|
|---|
| 167 | ESLINT_PERSONAL_CONFIG_LOAD:
|
|---|
| 168 | "'~/.eslintrc.*' config files have been deprecated. " +
|
|---|
| 169 | "Please use a config file per project or the '--config' option.",
|
|---|
| 170 | ESLINT_PERSONAL_CONFIG_SUPPRESS:
|
|---|
| 171 | "'~/.eslintrc.*' config files have been deprecated. " +
|
|---|
| 172 | "Please remove it or add 'root:true' to the config files in your " +
|
|---|
| 173 | "projects in order to avoid loading '~/.eslintrc.*' accidentally."
|
|---|
| 174 | };
|
|---|
| 175 |
|
|---|
| 176 | const sourceFileErrorCache = new Set();
|
|---|
| 177 |
|
|---|
| 178 | /**
|
|---|
| 179 | * Emits a deprecation warning containing a given filepath. A new deprecation warning is emitted
|
|---|
| 180 | * for each unique file path, but repeated invocations with the same file path have no effect.
|
|---|
| 181 | * No warnings are emitted if the `--no-deprecation` or `--no-warnings` Node runtime flags are active.
|
|---|
| 182 | * @param {string} source The name of the configuration source to report the warning for.
|
|---|
| 183 | * @param {string} errorCode The warning message to show.
|
|---|
| 184 | * @returns {void}
|
|---|
| 185 | */
|
|---|
| 186 | function emitDeprecationWarning(source, errorCode) {
|
|---|
| 187 | const cacheKey = JSON.stringify({ source, errorCode });
|
|---|
| 188 |
|
|---|
| 189 | if (sourceFileErrorCache.has(cacheKey)) {
|
|---|
| 190 | return;
|
|---|
| 191 | }
|
|---|
| 192 | sourceFileErrorCache.add(cacheKey);
|
|---|
| 193 |
|
|---|
| 194 | const rel = path__default["default"].relative(process.cwd(), source);
|
|---|
| 195 | const message = deprecationWarningMessages[errorCode];
|
|---|
| 196 |
|
|---|
| 197 | process.emitWarning(
|
|---|
| 198 | `${message} (found in "${rel}")`,
|
|---|
| 199 | "DeprecationWarning",
|
|---|
| 200 | errorCode
|
|---|
| 201 | );
|
|---|
| 202 | }
|
|---|
| 203 |
|
|---|
| 204 | /**
|
|---|
| 205 | * @fileoverview The instance of Ajv validator.
|
|---|
| 206 | * @author Evgeny Poberezkin
|
|---|
| 207 | */
|
|---|
| 208 |
|
|---|
| 209 | //-----------------------------------------------------------------------------
|
|---|
| 210 | // Helpers
|
|---|
| 211 | //-----------------------------------------------------------------------------
|
|---|
| 212 |
|
|---|
| 213 | /*
|
|---|
| 214 | * Copied from ajv/lib/refs/json-schema-draft-04.json
|
|---|
| 215 | * The MIT License (MIT)
|
|---|
| 216 | * Copyright (c) 2015-2017 Evgeny Poberezkin
|
|---|
| 217 | */
|
|---|
| 218 | const metaSchema = {
|
|---|
| 219 | id: "http://json-schema.org/draft-04/schema#",
|
|---|
| 220 | $schema: "http://json-schema.org/draft-04/schema#",
|
|---|
| 221 | description: "Core schema meta-schema",
|
|---|
| 222 | definitions: {
|
|---|
| 223 | schemaArray: {
|
|---|
| 224 | type: "array",
|
|---|
| 225 | minItems: 1,
|
|---|
| 226 | items: { $ref: "#" }
|
|---|
| 227 | },
|
|---|
| 228 | positiveInteger: {
|
|---|
| 229 | type: "integer",
|
|---|
| 230 | minimum: 0
|
|---|
| 231 | },
|
|---|
| 232 | positiveIntegerDefault0: {
|
|---|
| 233 | allOf: [{ $ref: "#/definitions/positiveInteger" }, { default: 0 }]
|
|---|
| 234 | },
|
|---|
| 235 | simpleTypes: {
|
|---|
| 236 | enum: ["array", "boolean", "integer", "null", "number", "object", "string"]
|
|---|
| 237 | },
|
|---|
| 238 | stringArray: {
|
|---|
| 239 | type: "array",
|
|---|
| 240 | items: { type: "string" },
|
|---|
| 241 | minItems: 1,
|
|---|
| 242 | uniqueItems: true
|
|---|
| 243 | }
|
|---|
| 244 | },
|
|---|
| 245 | type: "object",
|
|---|
| 246 | properties: {
|
|---|
| 247 | id: {
|
|---|
| 248 | type: "string"
|
|---|
| 249 | },
|
|---|
| 250 | $schema: {
|
|---|
| 251 | type: "string"
|
|---|
| 252 | },
|
|---|
| 253 | title: {
|
|---|
| 254 | type: "string"
|
|---|
| 255 | },
|
|---|
| 256 | description: {
|
|---|
| 257 | type: "string"
|
|---|
| 258 | },
|
|---|
| 259 | default: { },
|
|---|
| 260 | multipleOf: {
|
|---|
| 261 | type: "number",
|
|---|
| 262 | minimum: 0,
|
|---|
| 263 | exclusiveMinimum: true
|
|---|
| 264 | },
|
|---|
| 265 | maximum: {
|
|---|
| 266 | type: "number"
|
|---|
| 267 | },
|
|---|
| 268 | exclusiveMaximum: {
|
|---|
| 269 | type: "boolean",
|
|---|
| 270 | default: false
|
|---|
| 271 | },
|
|---|
| 272 | minimum: {
|
|---|
| 273 | type: "number"
|
|---|
| 274 | },
|
|---|
| 275 | exclusiveMinimum: {
|
|---|
| 276 | type: "boolean",
|
|---|
| 277 | default: false
|
|---|
| 278 | },
|
|---|
| 279 | maxLength: { $ref: "#/definitions/positiveInteger" },
|
|---|
| 280 | minLength: { $ref: "#/definitions/positiveIntegerDefault0" },
|
|---|
| 281 | pattern: {
|
|---|
| 282 | type: "string",
|
|---|
| 283 | format: "regex"
|
|---|
| 284 | },
|
|---|
| 285 | additionalItems: {
|
|---|
| 286 | anyOf: [
|
|---|
| 287 | { type: "boolean" },
|
|---|
| 288 | { $ref: "#" }
|
|---|
| 289 | ],
|
|---|
| 290 | default: { }
|
|---|
| 291 | },
|
|---|
| 292 | items: {
|
|---|
| 293 | anyOf: [
|
|---|
| 294 | { $ref: "#" },
|
|---|
| 295 | { $ref: "#/definitions/schemaArray" }
|
|---|
| 296 | ],
|
|---|
| 297 | default: { }
|
|---|
| 298 | },
|
|---|
| 299 | maxItems: { $ref: "#/definitions/positiveInteger" },
|
|---|
| 300 | minItems: { $ref: "#/definitions/positiveIntegerDefault0" },
|
|---|
| 301 | uniqueItems: {
|
|---|
| 302 | type: "boolean",
|
|---|
| 303 | default: false
|
|---|
| 304 | },
|
|---|
| 305 | maxProperties: { $ref: "#/definitions/positiveInteger" },
|
|---|
| 306 | minProperties: { $ref: "#/definitions/positiveIntegerDefault0" },
|
|---|
| 307 | required: { $ref: "#/definitions/stringArray" },
|
|---|
| 308 | additionalProperties: {
|
|---|
| 309 | anyOf: [
|
|---|
| 310 | { type: "boolean" },
|
|---|
| 311 | { $ref: "#" }
|
|---|
| 312 | ],
|
|---|
| 313 | default: { }
|
|---|
| 314 | },
|
|---|
| 315 | definitions: {
|
|---|
| 316 | type: "object",
|
|---|
| 317 | additionalProperties: { $ref: "#" },
|
|---|
| 318 | default: { }
|
|---|
| 319 | },
|
|---|
| 320 | properties: {
|
|---|
| 321 | type: "object",
|
|---|
| 322 | additionalProperties: { $ref: "#" },
|
|---|
| 323 | default: { }
|
|---|
| 324 | },
|
|---|
| 325 | patternProperties: {
|
|---|
| 326 | type: "object",
|
|---|
| 327 | additionalProperties: { $ref: "#" },
|
|---|
| 328 | default: { }
|
|---|
| 329 | },
|
|---|
| 330 | dependencies: {
|
|---|
| 331 | type: "object",
|
|---|
| 332 | additionalProperties: {
|
|---|
| 333 | anyOf: [
|
|---|
| 334 | { $ref: "#" },
|
|---|
| 335 | { $ref: "#/definitions/stringArray" }
|
|---|
| 336 | ]
|
|---|
| 337 | }
|
|---|
| 338 | },
|
|---|
| 339 | enum: {
|
|---|
| 340 | type: "array",
|
|---|
| 341 | minItems: 1,
|
|---|
| 342 | uniqueItems: true
|
|---|
| 343 | },
|
|---|
| 344 | type: {
|
|---|
| 345 | anyOf: [
|
|---|
| 346 | { $ref: "#/definitions/simpleTypes" },
|
|---|
| 347 | {
|
|---|
| 348 | type: "array",
|
|---|
| 349 | items: { $ref: "#/definitions/simpleTypes" },
|
|---|
| 350 | minItems: 1,
|
|---|
| 351 | uniqueItems: true
|
|---|
| 352 | }
|
|---|
| 353 | ]
|
|---|
| 354 | },
|
|---|
| 355 | format: { type: "string" },
|
|---|
| 356 | allOf: { $ref: "#/definitions/schemaArray" },
|
|---|
| 357 | anyOf: { $ref: "#/definitions/schemaArray" },
|
|---|
| 358 | oneOf: { $ref: "#/definitions/schemaArray" },
|
|---|
| 359 | not: { $ref: "#" }
|
|---|
| 360 | },
|
|---|
| 361 | dependencies: {
|
|---|
| 362 | exclusiveMaximum: ["maximum"],
|
|---|
| 363 | exclusiveMinimum: ["minimum"]
|
|---|
| 364 | },
|
|---|
| 365 | default: { }
|
|---|
| 366 | };
|
|---|
| 367 |
|
|---|
| 368 | //------------------------------------------------------------------------------
|
|---|
| 369 | // Public Interface
|
|---|
| 370 | //------------------------------------------------------------------------------
|
|---|
| 371 |
|
|---|
| 372 | var ajvOrig = (additionalOptions = {}) => {
|
|---|
| 373 | const ajv = new Ajv__default["default"]({
|
|---|
| 374 | meta: false,
|
|---|
| 375 | useDefaults: true,
|
|---|
| 376 | validateSchema: false,
|
|---|
| 377 | missingRefs: "ignore",
|
|---|
| 378 | verbose: true,
|
|---|
| 379 | schemaId: "auto",
|
|---|
| 380 | ...additionalOptions
|
|---|
| 381 | });
|
|---|
| 382 |
|
|---|
| 383 | ajv.addMetaSchema(metaSchema);
|
|---|
| 384 | // eslint-disable-next-line no-underscore-dangle
|
|---|
| 385 | ajv._opts.defaultMeta = metaSchema.id;
|
|---|
| 386 |
|
|---|
| 387 | return ajv;
|
|---|
| 388 | };
|
|---|
| 389 |
|
|---|
| 390 | /**
|
|---|
| 391 | * @fileoverview Defines a schema for configs.
|
|---|
| 392 | * @author Sylvan Mably
|
|---|
| 393 | */
|
|---|
| 394 |
|
|---|
| 395 | const baseConfigProperties = {
|
|---|
| 396 | $schema: { type: "string" },
|
|---|
| 397 | env: { type: "object" },
|
|---|
| 398 | extends: { $ref: "#/definitions/stringOrStrings" },
|
|---|
| 399 | globals: { type: "object" },
|
|---|
| 400 | overrides: {
|
|---|
| 401 | type: "array",
|
|---|
| 402 | items: { $ref: "#/definitions/overrideConfig" },
|
|---|
| 403 | additionalItems: false
|
|---|
| 404 | },
|
|---|
| 405 | parser: { type: ["string", "null"] },
|
|---|
| 406 | parserOptions: { type: "object" },
|
|---|
| 407 | plugins: { type: "array" },
|
|---|
| 408 | processor: { type: "string" },
|
|---|
| 409 | rules: { type: "object" },
|
|---|
| 410 | settings: { type: "object" },
|
|---|
| 411 | noInlineConfig: { type: "boolean" },
|
|---|
| 412 | reportUnusedDisableDirectives: { type: "boolean" },
|
|---|
| 413 |
|
|---|
| 414 | ecmaFeatures: { type: "object" } // deprecated; logs a warning when used
|
|---|
| 415 | };
|
|---|
| 416 |
|
|---|
| 417 | const configSchema = {
|
|---|
| 418 | definitions: {
|
|---|
| 419 | stringOrStrings: {
|
|---|
| 420 | oneOf: [
|
|---|
| 421 | { type: "string" },
|
|---|
| 422 | {
|
|---|
| 423 | type: "array",
|
|---|
| 424 | items: { type: "string" },
|
|---|
| 425 | additionalItems: false
|
|---|
| 426 | }
|
|---|
| 427 | ]
|
|---|
| 428 | },
|
|---|
| 429 | stringOrStringsRequired: {
|
|---|
| 430 | oneOf: [
|
|---|
| 431 | { type: "string" },
|
|---|
| 432 | {
|
|---|
| 433 | type: "array",
|
|---|
| 434 | items: { type: "string" },
|
|---|
| 435 | additionalItems: false,
|
|---|
| 436 | minItems: 1
|
|---|
| 437 | }
|
|---|
| 438 | ]
|
|---|
| 439 | },
|
|---|
| 440 |
|
|---|
| 441 | // Config at top-level.
|
|---|
| 442 | objectConfig: {
|
|---|
| 443 | type: "object",
|
|---|
| 444 | properties: {
|
|---|
| 445 | root: { type: "boolean" },
|
|---|
| 446 | ignorePatterns: { $ref: "#/definitions/stringOrStrings" },
|
|---|
| 447 | ...baseConfigProperties
|
|---|
| 448 | },
|
|---|
| 449 | additionalProperties: false
|
|---|
| 450 | },
|
|---|
| 451 |
|
|---|
| 452 | // Config in `overrides`.
|
|---|
| 453 | overrideConfig: {
|
|---|
| 454 | type: "object",
|
|---|
| 455 | properties: {
|
|---|
| 456 | excludedFiles: { $ref: "#/definitions/stringOrStrings" },
|
|---|
| 457 | files: { $ref: "#/definitions/stringOrStringsRequired" },
|
|---|
| 458 | ...baseConfigProperties
|
|---|
| 459 | },
|
|---|
| 460 | required: ["files"],
|
|---|
| 461 | additionalProperties: false
|
|---|
| 462 | }
|
|---|
| 463 | },
|
|---|
| 464 |
|
|---|
| 465 | $ref: "#/definitions/objectConfig"
|
|---|
| 466 | };
|
|---|
| 467 |
|
|---|
| 468 | /**
|
|---|
| 469 | * @fileoverview Defines environment settings and globals.
|
|---|
| 470 | * @author Elan Shanker
|
|---|
| 471 | */
|
|---|
| 472 |
|
|---|
| 473 | //------------------------------------------------------------------------------
|
|---|
| 474 | // Helpers
|
|---|
| 475 | //------------------------------------------------------------------------------
|
|---|
| 476 |
|
|---|
| 477 | /**
|
|---|
| 478 | * Get the object that has difference.
|
|---|
| 479 | * @param {Record<string,boolean>} current The newer object.
|
|---|
| 480 | * @param {Record<string,boolean>} prev The older object.
|
|---|
| 481 | * @returns {Record<string,boolean>} The difference object.
|
|---|
| 482 | */
|
|---|
| 483 | function getDiff(current, prev) {
|
|---|
| 484 | const retv = {};
|
|---|
| 485 |
|
|---|
| 486 | for (const [key, value] of Object.entries(current)) {
|
|---|
| 487 | if (!Object.hasOwnProperty.call(prev, key)) {
|
|---|
| 488 | retv[key] = value;
|
|---|
| 489 | }
|
|---|
| 490 | }
|
|---|
| 491 |
|
|---|
| 492 | return retv;
|
|---|
| 493 | }
|
|---|
| 494 |
|
|---|
| 495 | const newGlobals2015 = getDiff(globals__default["default"].es2015, globals__default["default"].es5); // 19 variables such as Promise, Map, ...
|
|---|
| 496 | const newGlobals2017 = {
|
|---|
| 497 | Atomics: false,
|
|---|
| 498 | SharedArrayBuffer: false
|
|---|
| 499 | };
|
|---|
| 500 | const newGlobals2020 = {
|
|---|
| 501 | BigInt: false,
|
|---|
| 502 | BigInt64Array: false,
|
|---|
| 503 | BigUint64Array: false,
|
|---|
| 504 | globalThis: false
|
|---|
| 505 | };
|
|---|
| 506 |
|
|---|
| 507 | const newGlobals2021 = {
|
|---|
| 508 | AggregateError: false,
|
|---|
| 509 | FinalizationRegistry: false,
|
|---|
| 510 | WeakRef: false
|
|---|
| 511 | };
|
|---|
| 512 |
|
|---|
| 513 | //------------------------------------------------------------------------------
|
|---|
| 514 | // Public Interface
|
|---|
| 515 | //------------------------------------------------------------------------------
|
|---|
| 516 |
|
|---|
| 517 | /** @type {Map<string, import("../lib/shared/types").Environment>} */
|
|---|
| 518 | var environments = new Map(Object.entries({
|
|---|
| 519 |
|
|---|
| 520 | // Language
|
|---|
| 521 | builtin: {
|
|---|
| 522 | globals: globals__default["default"].es5
|
|---|
| 523 | },
|
|---|
| 524 | es6: {
|
|---|
| 525 | globals: newGlobals2015,
|
|---|
| 526 | parserOptions: {
|
|---|
| 527 | ecmaVersion: 6
|
|---|
| 528 | }
|
|---|
| 529 | },
|
|---|
| 530 | es2015: {
|
|---|
| 531 | globals: newGlobals2015,
|
|---|
| 532 | parserOptions: {
|
|---|
| 533 | ecmaVersion: 6
|
|---|
| 534 | }
|
|---|
| 535 | },
|
|---|
| 536 | es2016: {
|
|---|
| 537 | globals: newGlobals2015,
|
|---|
| 538 | parserOptions: {
|
|---|
| 539 | ecmaVersion: 7
|
|---|
| 540 | }
|
|---|
| 541 | },
|
|---|
| 542 | es2017: {
|
|---|
| 543 | globals: { ...newGlobals2015, ...newGlobals2017 },
|
|---|
| 544 | parserOptions: {
|
|---|
| 545 | ecmaVersion: 8
|
|---|
| 546 | }
|
|---|
| 547 | },
|
|---|
| 548 | es2018: {
|
|---|
| 549 | globals: { ...newGlobals2015, ...newGlobals2017 },
|
|---|
| 550 | parserOptions: {
|
|---|
| 551 | ecmaVersion: 9
|
|---|
| 552 | }
|
|---|
| 553 | },
|
|---|
| 554 | es2019: {
|
|---|
| 555 | globals: { ...newGlobals2015, ...newGlobals2017 },
|
|---|
| 556 | parserOptions: {
|
|---|
| 557 | ecmaVersion: 10
|
|---|
| 558 | }
|
|---|
| 559 | },
|
|---|
| 560 | es2020: {
|
|---|
| 561 | globals: { ...newGlobals2015, ...newGlobals2017, ...newGlobals2020 },
|
|---|
| 562 | parserOptions: {
|
|---|
| 563 | ecmaVersion: 11
|
|---|
| 564 | }
|
|---|
| 565 | },
|
|---|
| 566 | es2021: {
|
|---|
| 567 | globals: { ...newGlobals2015, ...newGlobals2017, ...newGlobals2020, ...newGlobals2021 },
|
|---|
| 568 | parserOptions: {
|
|---|
| 569 | ecmaVersion: 12
|
|---|
| 570 | }
|
|---|
| 571 | },
|
|---|
| 572 | es2022: {
|
|---|
| 573 | globals: { ...newGlobals2015, ...newGlobals2017, ...newGlobals2020, ...newGlobals2021 },
|
|---|
| 574 | parserOptions: {
|
|---|
| 575 | ecmaVersion: 13
|
|---|
| 576 | }
|
|---|
| 577 | },
|
|---|
| 578 | es2023: {
|
|---|
| 579 | globals: { ...newGlobals2015, ...newGlobals2017, ...newGlobals2020, ...newGlobals2021 },
|
|---|
| 580 | parserOptions: {
|
|---|
| 581 | ecmaVersion: 14
|
|---|
| 582 | }
|
|---|
| 583 | },
|
|---|
| 584 | es2024: {
|
|---|
| 585 | globals: { ...newGlobals2015, ...newGlobals2017, ...newGlobals2020, ...newGlobals2021 },
|
|---|
| 586 | parserOptions: {
|
|---|
| 587 | ecmaVersion: 15
|
|---|
| 588 | }
|
|---|
| 589 | },
|
|---|
| 590 |
|
|---|
| 591 | // Platforms
|
|---|
| 592 | browser: {
|
|---|
| 593 | globals: globals__default["default"].browser
|
|---|
| 594 | },
|
|---|
| 595 | node: {
|
|---|
| 596 | globals: globals__default["default"].node,
|
|---|
| 597 | parserOptions: {
|
|---|
| 598 | ecmaFeatures: {
|
|---|
| 599 | globalReturn: true
|
|---|
| 600 | }
|
|---|
| 601 | }
|
|---|
| 602 | },
|
|---|
| 603 | "shared-node-browser": {
|
|---|
| 604 | globals: globals__default["default"]["shared-node-browser"]
|
|---|
| 605 | },
|
|---|
| 606 | worker: {
|
|---|
| 607 | globals: globals__default["default"].worker
|
|---|
| 608 | },
|
|---|
| 609 | serviceworker: {
|
|---|
| 610 | globals: globals__default["default"].serviceworker
|
|---|
| 611 | },
|
|---|
| 612 |
|
|---|
| 613 | // Frameworks
|
|---|
| 614 | commonjs: {
|
|---|
| 615 | globals: globals__default["default"].commonjs,
|
|---|
| 616 | parserOptions: {
|
|---|
| 617 | ecmaFeatures: {
|
|---|
| 618 | globalReturn: true
|
|---|
| 619 | }
|
|---|
| 620 | }
|
|---|
| 621 | },
|
|---|
| 622 | amd: {
|
|---|
| 623 | globals: globals__default["default"].amd
|
|---|
| 624 | },
|
|---|
| 625 | mocha: {
|
|---|
| 626 | globals: globals__default["default"].mocha
|
|---|
| 627 | },
|
|---|
| 628 | jasmine: {
|
|---|
| 629 | globals: globals__default["default"].jasmine
|
|---|
| 630 | },
|
|---|
| 631 | jest: {
|
|---|
| 632 | globals: globals__default["default"].jest
|
|---|
| 633 | },
|
|---|
| 634 | phantomjs: {
|
|---|
| 635 | globals: globals__default["default"].phantomjs
|
|---|
| 636 | },
|
|---|
| 637 | jquery: {
|
|---|
| 638 | globals: globals__default["default"].jquery
|
|---|
| 639 | },
|
|---|
| 640 | qunit: {
|
|---|
| 641 | globals: globals__default["default"].qunit
|
|---|
| 642 | },
|
|---|
| 643 | prototypejs: {
|
|---|
| 644 | globals: globals__default["default"].prototypejs
|
|---|
| 645 | },
|
|---|
| 646 | shelljs: {
|
|---|
| 647 | globals: globals__default["default"].shelljs
|
|---|
| 648 | },
|
|---|
| 649 | meteor: {
|
|---|
| 650 | globals: globals__default["default"].meteor
|
|---|
| 651 | },
|
|---|
| 652 | mongo: {
|
|---|
| 653 | globals: globals__default["default"].mongo
|
|---|
| 654 | },
|
|---|
| 655 | protractor: {
|
|---|
| 656 | globals: globals__default["default"].protractor
|
|---|
| 657 | },
|
|---|
| 658 | applescript: {
|
|---|
| 659 | globals: globals__default["default"].applescript
|
|---|
| 660 | },
|
|---|
| 661 | nashorn: {
|
|---|
| 662 | globals: globals__default["default"].nashorn
|
|---|
| 663 | },
|
|---|
| 664 | atomtest: {
|
|---|
| 665 | globals: globals__default["default"].atomtest
|
|---|
| 666 | },
|
|---|
| 667 | embertest: {
|
|---|
| 668 | globals: globals__default["default"].embertest
|
|---|
| 669 | },
|
|---|
| 670 | webextensions: {
|
|---|
| 671 | globals: globals__default["default"].webextensions
|
|---|
| 672 | },
|
|---|
| 673 | greasemonkey: {
|
|---|
| 674 | globals: globals__default["default"].greasemonkey
|
|---|
| 675 | }
|
|---|
| 676 | }));
|
|---|
| 677 |
|
|---|
| 678 | /**
|
|---|
| 679 | * @fileoverview Validates configs.
|
|---|
| 680 | * @author Brandon Mills
|
|---|
| 681 | */
|
|---|
| 682 |
|
|---|
| 683 | const ajv = ajvOrig();
|
|---|
| 684 |
|
|---|
| 685 | const ruleValidators = new WeakMap();
|
|---|
| 686 | const noop = Function.prototype;
|
|---|
| 687 |
|
|---|
| 688 | //------------------------------------------------------------------------------
|
|---|
| 689 | // Private
|
|---|
| 690 | //------------------------------------------------------------------------------
|
|---|
| 691 | let validateSchema;
|
|---|
| 692 | const severityMap = {
|
|---|
| 693 | error: 2,
|
|---|
| 694 | warn: 1,
|
|---|
| 695 | off: 0
|
|---|
| 696 | };
|
|---|
| 697 |
|
|---|
| 698 | const validated = new WeakSet();
|
|---|
| 699 |
|
|---|
| 700 | //-----------------------------------------------------------------------------
|
|---|
| 701 | // Exports
|
|---|
| 702 | //-----------------------------------------------------------------------------
|
|---|
| 703 |
|
|---|
| 704 | class ConfigValidator {
|
|---|
| 705 | constructor({ builtInRules = new Map() } = {}) {
|
|---|
| 706 | this.builtInRules = builtInRules;
|
|---|
| 707 | }
|
|---|
| 708 |
|
|---|
| 709 | /**
|
|---|
| 710 | * Gets a complete options schema for a rule.
|
|---|
| 711 | * @param {{create: Function, schema: (Array|null)}} rule A new-style rule object
|
|---|
| 712 | * @returns {Object} JSON Schema for the rule's options.
|
|---|
| 713 | */
|
|---|
| 714 | getRuleOptionsSchema(rule) {
|
|---|
| 715 | if (!rule) {
|
|---|
| 716 | return null;
|
|---|
| 717 | }
|
|---|
| 718 |
|
|---|
| 719 | const schema = rule.schema || rule.meta && rule.meta.schema;
|
|---|
| 720 |
|
|---|
| 721 | // Given a tuple of schemas, insert warning level at the beginning
|
|---|
| 722 | if (Array.isArray(schema)) {
|
|---|
| 723 | if (schema.length) {
|
|---|
| 724 | return {
|
|---|
| 725 | type: "array",
|
|---|
| 726 | items: schema,
|
|---|
| 727 | minItems: 0,
|
|---|
| 728 | maxItems: schema.length
|
|---|
| 729 | };
|
|---|
| 730 | }
|
|---|
| 731 | return {
|
|---|
| 732 | type: "array",
|
|---|
| 733 | minItems: 0,
|
|---|
| 734 | maxItems: 0
|
|---|
| 735 | };
|
|---|
| 736 |
|
|---|
| 737 | }
|
|---|
| 738 |
|
|---|
| 739 | // Given a full schema, leave it alone
|
|---|
| 740 | return schema || null;
|
|---|
| 741 | }
|
|---|
| 742 |
|
|---|
| 743 | /**
|
|---|
| 744 | * Validates a rule's severity and returns the severity value. Throws an error if the severity is invalid.
|
|---|
| 745 | * @param {options} options The given options for the rule.
|
|---|
| 746 | * @returns {number|string} The rule's severity value
|
|---|
| 747 | */
|
|---|
| 748 | validateRuleSeverity(options) {
|
|---|
| 749 | const severity = Array.isArray(options) ? options[0] : options;
|
|---|
| 750 | const normSeverity = typeof severity === "string" ? severityMap[severity.toLowerCase()] : severity;
|
|---|
| 751 |
|
|---|
| 752 | if (normSeverity === 0 || normSeverity === 1 || normSeverity === 2) {
|
|---|
| 753 | return normSeverity;
|
|---|
| 754 | }
|
|---|
| 755 |
|
|---|
| 756 | throw new Error(`\tSeverity should be one of the following: 0 = off, 1 = warn, 2 = error (you passed '${util__default["default"].inspect(severity).replace(/'/gu, "\"").replace(/\n/gu, "")}').\n`);
|
|---|
| 757 |
|
|---|
| 758 | }
|
|---|
| 759 |
|
|---|
| 760 | /**
|
|---|
| 761 | * Validates the non-severity options passed to a rule, based on its schema.
|
|---|
| 762 | * @param {{create: Function}} rule The rule to validate
|
|---|
| 763 | * @param {Array} localOptions The options for the rule, excluding severity
|
|---|
| 764 | * @returns {void}
|
|---|
| 765 | */
|
|---|
| 766 | validateRuleSchema(rule, localOptions) {
|
|---|
| 767 | if (!ruleValidators.has(rule)) {
|
|---|
| 768 | const schema = this.getRuleOptionsSchema(rule);
|
|---|
| 769 |
|
|---|
| 770 | if (schema) {
|
|---|
| 771 | ruleValidators.set(rule, ajv.compile(schema));
|
|---|
| 772 | }
|
|---|
| 773 | }
|
|---|
| 774 |
|
|---|
| 775 | const validateRule = ruleValidators.get(rule);
|
|---|
| 776 |
|
|---|
| 777 | if (validateRule) {
|
|---|
| 778 | validateRule(localOptions);
|
|---|
| 779 | if (validateRule.errors) {
|
|---|
| 780 | throw new Error(validateRule.errors.map(
|
|---|
| 781 | error => `\tValue ${JSON.stringify(error.data)} ${error.message}.\n`
|
|---|
| 782 | ).join(""));
|
|---|
| 783 | }
|
|---|
| 784 | }
|
|---|
| 785 | }
|
|---|
| 786 |
|
|---|
| 787 | /**
|
|---|
| 788 | * Validates a rule's options against its schema.
|
|---|
| 789 | * @param {{create: Function}|null} rule The rule that the config is being validated for
|
|---|
| 790 | * @param {string} ruleId The rule's unique name.
|
|---|
| 791 | * @param {Array|number} options The given options for the rule.
|
|---|
| 792 | * @param {string|null} source The name of the configuration source to report in any errors. If null or undefined,
|
|---|
| 793 | * no source is prepended to the message.
|
|---|
| 794 | * @returns {void}
|
|---|
| 795 | */
|
|---|
| 796 | validateRuleOptions(rule, ruleId, options, source = null) {
|
|---|
| 797 | try {
|
|---|
| 798 | const severity = this.validateRuleSeverity(options);
|
|---|
| 799 |
|
|---|
| 800 | if (severity !== 0) {
|
|---|
| 801 | this.validateRuleSchema(rule, Array.isArray(options) ? options.slice(1) : []);
|
|---|
| 802 | }
|
|---|
| 803 | } catch (err) {
|
|---|
| 804 | const enhancedMessage = `Configuration for rule "${ruleId}" is invalid:\n${err.message}`;
|
|---|
| 805 |
|
|---|
| 806 | if (typeof source === "string") {
|
|---|
| 807 | throw new Error(`${source}:\n\t${enhancedMessage}`);
|
|---|
| 808 | } else {
|
|---|
| 809 | throw new Error(enhancedMessage);
|
|---|
| 810 | }
|
|---|
| 811 | }
|
|---|
| 812 | }
|
|---|
| 813 |
|
|---|
| 814 | /**
|
|---|
| 815 | * Validates an environment object
|
|---|
| 816 | * @param {Object} environment The environment config object to validate.
|
|---|
| 817 | * @param {string} source The name of the configuration source to report in any errors.
|
|---|
| 818 | * @param {function(envId:string): Object} [getAdditionalEnv] A map from strings to loaded environments.
|
|---|
| 819 | * @returns {void}
|
|---|
| 820 | */
|
|---|
| 821 | validateEnvironment(
|
|---|
| 822 | environment,
|
|---|
| 823 | source,
|
|---|
| 824 | getAdditionalEnv = noop
|
|---|
| 825 | ) {
|
|---|
| 826 |
|
|---|
| 827 | // not having an environment is ok
|
|---|
| 828 | if (!environment) {
|
|---|
| 829 | return;
|
|---|
| 830 | }
|
|---|
| 831 |
|
|---|
| 832 | Object.keys(environment).forEach(id => {
|
|---|
| 833 | const env = getAdditionalEnv(id) || environments.get(id) || null;
|
|---|
| 834 |
|
|---|
| 835 | if (!env) {
|
|---|
| 836 | const message = `${source}:\n\tEnvironment key "${id}" is unknown\n`;
|
|---|
| 837 |
|
|---|
| 838 | throw new Error(message);
|
|---|
| 839 | }
|
|---|
| 840 | });
|
|---|
| 841 | }
|
|---|
| 842 |
|
|---|
| 843 | /**
|
|---|
| 844 | * Validates a rules config object
|
|---|
| 845 | * @param {Object} rulesConfig The rules config object to validate.
|
|---|
| 846 | * @param {string} source The name of the configuration source to report in any errors.
|
|---|
| 847 | * @param {function(ruleId:string): Object} getAdditionalRule A map from strings to loaded rules
|
|---|
| 848 | * @returns {void}
|
|---|
| 849 | */
|
|---|
| 850 | validateRules(
|
|---|
| 851 | rulesConfig,
|
|---|
| 852 | source,
|
|---|
| 853 | getAdditionalRule = noop
|
|---|
| 854 | ) {
|
|---|
| 855 | if (!rulesConfig) {
|
|---|
| 856 | return;
|
|---|
| 857 | }
|
|---|
| 858 |
|
|---|
| 859 | Object.keys(rulesConfig).forEach(id => {
|
|---|
| 860 | const rule = getAdditionalRule(id) || this.builtInRules.get(id) || null;
|
|---|
| 861 |
|
|---|
| 862 | this.validateRuleOptions(rule, id, rulesConfig[id], source);
|
|---|
| 863 | });
|
|---|
| 864 | }
|
|---|
| 865 |
|
|---|
| 866 | /**
|
|---|
| 867 | * Validates a `globals` section of a config file
|
|---|
| 868 | * @param {Object} globalsConfig The `globals` section
|
|---|
| 869 | * @param {string|null} source The name of the configuration source to report in the event of an error.
|
|---|
| 870 | * @returns {void}
|
|---|
| 871 | */
|
|---|
| 872 | validateGlobals(globalsConfig, source = null) {
|
|---|
| 873 | if (!globalsConfig) {
|
|---|
| 874 | return;
|
|---|
| 875 | }
|
|---|
| 876 |
|
|---|
| 877 | Object.entries(globalsConfig)
|
|---|
| 878 | .forEach(([configuredGlobal, configuredValue]) => {
|
|---|
| 879 | try {
|
|---|
| 880 | normalizeConfigGlobal(configuredValue);
|
|---|
| 881 | } catch (err) {
|
|---|
| 882 | throw new Error(`ESLint configuration of global '${configuredGlobal}' in ${source} is invalid:\n${err.message}`);
|
|---|
| 883 | }
|
|---|
| 884 | });
|
|---|
| 885 | }
|
|---|
| 886 |
|
|---|
| 887 | /**
|
|---|
| 888 | * Validate `processor` configuration.
|
|---|
| 889 | * @param {string|undefined} processorName The processor name.
|
|---|
| 890 | * @param {string} source The name of config file.
|
|---|
| 891 | * @param {function(id:string): Processor} getProcessor The getter of defined processors.
|
|---|
| 892 | * @returns {void}
|
|---|
| 893 | */
|
|---|
| 894 | validateProcessor(processorName, source, getProcessor) {
|
|---|
| 895 | if (processorName && !getProcessor(processorName)) {
|
|---|
| 896 | throw new Error(`ESLint configuration of processor in '${source}' is invalid: '${processorName}' was not found.`);
|
|---|
| 897 | }
|
|---|
| 898 | }
|
|---|
| 899 |
|
|---|
| 900 | /**
|
|---|
| 901 | * Formats an array of schema validation errors.
|
|---|
| 902 | * @param {Array} errors An array of error messages to format.
|
|---|
| 903 | * @returns {string} Formatted error message
|
|---|
| 904 | */
|
|---|
| 905 | formatErrors(errors) {
|
|---|
| 906 | return errors.map(error => {
|
|---|
| 907 | if (error.keyword === "additionalProperties") {
|
|---|
| 908 | const formattedPropertyPath = error.dataPath.length ? `${error.dataPath.slice(1)}.${error.params.additionalProperty}` : error.params.additionalProperty;
|
|---|
| 909 |
|
|---|
| 910 | return `Unexpected top-level property "${formattedPropertyPath}"`;
|
|---|
| 911 | }
|
|---|
| 912 | if (error.keyword === "type") {
|
|---|
| 913 | const formattedField = error.dataPath.slice(1);
|
|---|
| 914 | const formattedExpectedType = Array.isArray(error.schema) ? error.schema.join("/") : error.schema;
|
|---|
| 915 | const formattedValue = JSON.stringify(error.data);
|
|---|
| 916 |
|
|---|
| 917 | return `Property "${formattedField}" is the wrong type (expected ${formattedExpectedType} but got \`${formattedValue}\`)`;
|
|---|
| 918 | }
|
|---|
| 919 |
|
|---|
| 920 | const field = error.dataPath[0] === "." ? error.dataPath.slice(1) : error.dataPath;
|
|---|
| 921 |
|
|---|
| 922 | return `"${field}" ${error.message}. Value: ${JSON.stringify(error.data)}`;
|
|---|
| 923 | }).map(message => `\t- ${message}.\n`).join("");
|
|---|
| 924 | }
|
|---|
| 925 |
|
|---|
| 926 | /**
|
|---|
| 927 | * Validates the top level properties of the config object.
|
|---|
| 928 | * @param {Object} config The config object to validate.
|
|---|
| 929 | * @param {string} source The name of the configuration source to report in any errors.
|
|---|
| 930 | * @returns {void}
|
|---|
| 931 | */
|
|---|
| 932 | validateConfigSchema(config, source = null) {
|
|---|
| 933 | validateSchema = validateSchema || ajv.compile(configSchema);
|
|---|
| 934 |
|
|---|
| 935 | if (!validateSchema(config)) {
|
|---|
| 936 | throw new Error(`ESLint configuration in ${source} is invalid:\n${this.formatErrors(validateSchema.errors)}`);
|
|---|
| 937 | }
|
|---|
| 938 |
|
|---|
| 939 | if (Object.hasOwnProperty.call(config, "ecmaFeatures")) {
|
|---|
| 940 | emitDeprecationWarning(source, "ESLINT_LEGACY_ECMAFEATURES");
|
|---|
| 941 | }
|
|---|
| 942 | }
|
|---|
| 943 |
|
|---|
| 944 | /**
|
|---|
| 945 | * Validates an entire config object.
|
|---|
| 946 | * @param {Object} config The config object to validate.
|
|---|
| 947 | * @param {string} source The name of the configuration source to report in any errors.
|
|---|
| 948 | * @param {function(ruleId:string): Object} [getAdditionalRule] A map from strings to loaded rules.
|
|---|
| 949 | * @param {function(envId:string): Object} [getAdditionalEnv] A map from strings to loaded envs.
|
|---|
| 950 | * @returns {void}
|
|---|
| 951 | */
|
|---|
| 952 | validate(config, source, getAdditionalRule, getAdditionalEnv) {
|
|---|
| 953 | this.validateConfigSchema(config, source);
|
|---|
| 954 | this.validateRules(config.rules, source, getAdditionalRule);
|
|---|
| 955 | this.validateEnvironment(config.env, source, getAdditionalEnv);
|
|---|
| 956 | this.validateGlobals(config.globals, source);
|
|---|
| 957 |
|
|---|
| 958 | for (const override of config.overrides || []) {
|
|---|
| 959 | this.validateRules(override.rules, source, getAdditionalRule);
|
|---|
| 960 | this.validateEnvironment(override.env, source, getAdditionalEnv);
|
|---|
| 961 | this.validateGlobals(config.globals, source);
|
|---|
| 962 | }
|
|---|
| 963 | }
|
|---|
| 964 |
|
|---|
| 965 | /**
|
|---|
| 966 | * Validate config array object.
|
|---|
| 967 | * @param {ConfigArray} configArray The config array to validate.
|
|---|
| 968 | * @returns {void}
|
|---|
| 969 | */
|
|---|
| 970 | validateConfigArray(configArray) {
|
|---|
| 971 | const getPluginEnv = Map.prototype.get.bind(configArray.pluginEnvironments);
|
|---|
| 972 | const getPluginProcessor = Map.prototype.get.bind(configArray.pluginProcessors);
|
|---|
| 973 | const getPluginRule = Map.prototype.get.bind(configArray.pluginRules);
|
|---|
| 974 |
|
|---|
| 975 | // Validate.
|
|---|
| 976 | for (const element of configArray) {
|
|---|
| 977 | if (validated.has(element)) {
|
|---|
| 978 | continue;
|
|---|
| 979 | }
|
|---|
| 980 | validated.add(element);
|
|---|
| 981 |
|
|---|
| 982 | this.validateEnvironment(element.env, element.name, getPluginEnv);
|
|---|
| 983 | this.validateGlobals(element.globals, element.name);
|
|---|
| 984 | this.validateProcessor(element.processor, element.name, getPluginProcessor);
|
|---|
| 985 | this.validateRules(element.rules, element.name, getPluginRule);
|
|---|
| 986 | }
|
|---|
| 987 | }
|
|---|
| 988 |
|
|---|
| 989 | }
|
|---|
| 990 |
|
|---|
| 991 | /**
|
|---|
| 992 | * @fileoverview Common helpers for naming of plugins, formatters and configs
|
|---|
| 993 | */
|
|---|
| 994 |
|
|---|
| 995 | const NAMESPACE_REGEX = /^@.*\//iu;
|
|---|
| 996 |
|
|---|
| 997 | /**
|
|---|
| 998 | * Brings package name to correct format based on prefix
|
|---|
| 999 | * @param {string} name The name of the package.
|
|---|
| 1000 | * @param {string} prefix Can be either "eslint-plugin", "eslint-config" or "eslint-formatter"
|
|---|
| 1001 | * @returns {string} Normalized name of the package
|
|---|
| 1002 | * @private
|
|---|
| 1003 | */
|
|---|
| 1004 | function normalizePackageName(name, prefix) {
|
|---|
| 1005 | let normalizedName = name;
|
|---|
| 1006 |
|
|---|
| 1007 | /**
|
|---|
| 1008 | * On Windows, name can come in with Windows slashes instead of Unix slashes.
|
|---|
| 1009 | * Normalize to Unix first to avoid errors later on.
|
|---|
| 1010 | * https://github.com/eslint/eslint/issues/5644
|
|---|
| 1011 | */
|
|---|
| 1012 | if (normalizedName.includes("\\")) {
|
|---|
| 1013 | normalizedName = normalizedName.replace(/\\/gu, "/");
|
|---|
| 1014 | }
|
|---|
| 1015 |
|
|---|
| 1016 | if (normalizedName.charAt(0) === "@") {
|
|---|
| 1017 |
|
|---|
| 1018 | /**
|
|---|
| 1019 | * it's a scoped package
|
|---|
| 1020 | * package name is the prefix, or just a username
|
|---|
| 1021 | */
|
|---|
| 1022 | const scopedPackageShortcutRegex = new RegExp(`^(@[^/]+)(?:/(?:${prefix})?)?$`, "u"),
|
|---|
| 1023 | scopedPackageNameRegex = new RegExp(`^${prefix}(-|$)`, "u");
|
|---|
| 1024 |
|
|---|
| 1025 | if (scopedPackageShortcutRegex.test(normalizedName)) {
|
|---|
| 1026 | normalizedName = normalizedName.replace(scopedPackageShortcutRegex, `$1/${prefix}`);
|
|---|
| 1027 | } else if (!scopedPackageNameRegex.test(normalizedName.split("/")[1])) {
|
|---|
| 1028 |
|
|---|
| 1029 | /**
|
|---|
| 1030 | * for scoped packages, insert the prefix after the first / unless
|
|---|
| 1031 | * the path is already @scope/eslint or @scope/eslint-xxx-yyy
|
|---|
| 1032 | */
|
|---|
| 1033 | normalizedName = normalizedName.replace(/^@([^/]+)\/(.*)$/u, `@$1/${prefix}-$2`);
|
|---|
| 1034 | }
|
|---|
| 1035 | } else if (!normalizedName.startsWith(`${prefix}-`)) {
|
|---|
| 1036 | normalizedName = `${prefix}-${normalizedName}`;
|
|---|
| 1037 | }
|
|---|
| 1038 |
|
|---|
| 1039 | return normalizedName;
|
|---|
| 1040 | }
|
|---|
| 1041 |
|
|---|
| 1042 | /**
|
|---|
| 1043 | * Removes the prefix from a fullname.
|
|---|
| 1044 | * @param {string} fullname The term which may have the prefix.
|
|---|
| 1045 | * @param {string} prefix The prefix to remove.
|
|---|
| 1046 | * @returns {string} The term without prefix.
|
|---|
| 1047 | */
|
|---|
| 1048 | function getShorthandName(fullname, prefix) {
|
|---|
| 1049 | if (fullname[0] === "@") {
|
|---|
| 1050 | let matchResult = new RegExp(`^(@[^/]+)/${prefix}$`, "u").exec(fullname);
|
|---|
| 1051 |
|
|---|
| 1052 | if (matchResult) {
|
|---|
| 1053 | return matchResult[1];
|
|---|
| 1054 | }
|
|---|
| 1055 |
|
|---|
| 1056 | matchResult = new RegExp(`^(@[^/]+)/${prefix}-(.+)$`, "u").exec(fullname);
|
|---|
| 1057 | if (matchResult) {
|
|---|
| 1058 | return `${matchResult[1]}/${matchResult[2]}`;
|
|---|
| 1059 | }
|
|---|
| 1060 | } else if (fullname.startsWith(`${prefix}-`)) {
|
|---|
| 1061 | return fullname.slice(prefix.length + 1);
|
|---|
| 1062 | }
|
|---|
| 1063 |
|
|---|
| 1064 | return fullname;
|
|---|
| 1065 | }
|
|---|
| 1066 |
|
|---|
| 1067 | /**
|
|---|
| 1068 | * Gets the scope (namespace) of a term.
|
|---|
| 1069 | * @param {string} term The term which may have the namespace.
|
|---|
| 1070 | * @returns {string} The namespace of the term if it has one.
|
|---|
| 1071 | */
|
|---|
| 1072 | function getNamespaceFromTerm(term) {
|
|---|
| 1073 | const match = term.match(NAMESPACE_REGEX);
|
|---|
| 1074 |
|
|---|
| 1075 | return match ? match[0] : "";
|
|---|
| 1076 | }
|
|---|
| 1077 |
|
|---|
| 1078 | var naming = {
|
|---|
| 1079 | __proto__: null,
|
|---|
| 1080 | normalizePackageName: normalizePackageName,
|
|---|
| 1081 | getShorthandName: getShorthandName,
|
|---|
| 1082 | getNamespaceFromTerm: getNamespaceFromTerm
|
|---|
| 1083 | };
|
|---|
| 1084 |
|
|---|
| 1085 | /**
|
|---|
| 1086 | * @fileoverview Package exports for @eslint/eslintrc
|
|---|
| 1087 | * @author Nicholas C. Zakas
|
|---|
| 1088 | */
|
|---|
| 1089 |
|
|---|
| 1090 | //-----------------------------------------------------------------------------
|
|---|
| 1091 | // Exports
|
|---|
| 1092 | //-----------------------------------------------------------------------------
|
|---|
| 1093 |
|
|---|
| 1094 | const Legacy = {
|
|---|
| 1095 | environments,
|
|---|
| 1096 |
|
|---|
| 1097 | // shared
|
|---|
| 1098 | ConfigOps,
|
|---|
| 1099 | ConfigValidator,
|
|---|
| 1100 | naming
|
|---|
| 1101 | };
|
|---|
| 1102 |
|
|---|
| 1103 | exports.Legacy = Legacy;
|
|---|
| 1104 | //# sourceMappingURL=eslintrc-universal.cjs.map
|
|---|
