source: imaps-frontend/node_modules/@eslint/eslintrc/dist/eslintrc-universal.cjs@ d565449

main
Last change on this file since d565449 was d565449, checked in by stefan toskovski <stefantoska84@…>, 4 weeks ago

Update repo after prototype presentation
  • Property mode set to 100644
File size: 34.1 KB
Line 
1'use strict';
2
3Object.defineProperty(exports, '__esModule', { value: true });
4
5var util = require('util');
6var path = require('path');
7var Ajv = require('ajv');
8var globals = require('globals');
9
10function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
11
12var util__default = /*#__PURE__*/_interopDefaultLegacy(util);
13var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
14var Ajv__default = /*#__PURE__*/_interopDefaultLegacy(Ajv);
15var 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
27const 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 */
46function 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 */
67function 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 */
87function 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 */
96function 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 */
110function 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 */
121function 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
144var 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.
164const 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
176const 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 */
186function 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 */
218const 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
372var 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
395const 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
417const 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 */
483function 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
495const newGlobals2015 = getDiff(globals__default["default"].es2015, globals__default["default"].es5); // 19 variables such as Promise, Map, ...
496const newGlobals2017 = {
497 Atomics: false,
498 SharedArrayBuffer: false
499};
500const newGlobals2020 = {
501 BigInt: false,
502 BigInt64Array: false,
503 BigUint64Array: false,
504 globalThis: false
505};
506
507const 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>} */
518var 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
683const ajv = ajvOrig();
684
685const ruleValidators = new WeakMap();
686const noop = Function.prototype;
687
688//------------------------------------------------------------------------------
689// Private
690//------------------------------------------------------------------------------
691let validateSchema;
692const severityMap = {
693 error: 2,
694 warn: 1,
695 off: 0
696};
697
698const validated = new WeakSet();
699
700//-----------------------------------------------------------------------------
701// Exports
702//-----------------------------------------------------------------------------
703
704class 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
995const 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 */
1004function 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 */
1048function 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 */
1072function getNamespaceFromTerm(term) {
1073 const match = term.match(NAMESPACE_REGEX);
1074
1075 return match ? match[0] : "";
1076}
1077
1078var 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
1094const Legacy = {
1095 environments,
1096
1097 // shared
1098 ConfigOps,
1099 ConfigValidator,
1100 naming
1101};
1102
1103exports.Legacy = Legacy;
1104//# sourceMappingURL=eslintrc-universal.cjs.map
Note: See TracBrowser for help on using the repository browser.