@alexlit/lint-kit 183.1.0 → 183.2.0

package/packages/config-eslint/node_modules/eslint/lib/config/flat-config-schema.js

@@ -1,598 +0,0 @@
-/**
- * @fileoverview Flat config schema
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//-----------------------------------------------------------------------------
-// Requirements
-//-----------------------------------------------------------------------------
-
-const { normalizeSeverityToNumber } = require("../shared/severity");
-
-//-----------------------------------------------------------------------------
-// Type Definitions
-//-----------------------------------------------------------------------------
-
-/**
- * @typedef ObjectPropertySchema
- * @property {Function|string} merge The function or name of the function to call
- *      to merge multiple objects with this property.
- * @property {Function|string} validate The function or name of the function to call
- *      to validate the value of this property.
- */
-
-//-----------------------------------------------------------------------------
-// Helpers
-//-----------------------------------------------------------------------------
-
-const ruleSeverities = new Map([
-	[0, 0],
-	["off", 0],
-	[1, 1],
-	["warn", 1],
-	[2, 2],
-	["error", 2],
-]);
-
-/**
- * Check if a value is a non-null object.
- * @param {any} value The value to check.
- * @returns {boolean} `true` if the value is a non-null object.
- */
-function isNonNullObject(value) {
-	return typeof value === "object" && value !== null;
-}
-
-/**
- * Check if a value is a non-null non-array object.
- * @param {any} value The value to check.
- * @returns {boolean} `true` if the value is a non-null non-array object.
- */
-function isNonArrayObject(value) {
-	return isNonNullObject(value) && !Array.isArray(value);
-}
-
-/**
- * Check if a value is undefined.
- * @param {any} value The value to check.
- * @returns {boolean} `true` if the value is undefined.
- */
-function isUndefined(value) {
-	return typeof value === "undefined";
-}
-
-/**
- * Deeply merges two non-array objects.
- * @param {Object} first The base object.
- * @param {Object} second The overrides object.
- * @param {Map<string, Map<string, Object>>} [mergeMap] Maps the combination of first and second arguments to a merged result.
- * @returns {Object} An object with properties from both first and second.
- */
-function deepMerge(first, second, mergeMap = new Map()) {
-	let secondMergeMap = mergeMap.get(first);
-
-	if (secondMergeMap) {
-		const result = secondMergeMap.get(second);
-
-		if (result) {
-			// If this combination of first and second arguments has been already visited, return the previously created result.
-			return result;
-		}
-	} else {
-		secondMergeMap = new Map();
-		mergeMap.set(first, secondMergeMap);
-	}
-
-	/*
-	 * First create a result object where properties from the second object
-	 * overwrite properties from the first. This sets up a baseline to use
-	 * later rather than needing to inspect and change every property
-	 * individually.
-	 */
-	const result = {
-		...first,
-		...second,
-	};
-
-	delete result.__proto__; // eslint-disable-line no-proto -- don't merge own property "__proto__"
-
-	// Store the pending result for this combination of first and second arguments.
-	secondMergeMap.set(second, result);
-
-	for (const key of Object.keys(second)) {
-		// avoid hairy edge case
-		if (
-			key === "__proto__" ||
-			!Object.prototype.propertyIsEnumerable.call(first, key)
-		) {
-			continue;
-		}
-
-		const firstValue = first[key];
-		const secondValue = second[key];
-
-		if (isNonArrayObject(firstValue) && isNonArrayObject(secondValue)) {
-			result[key] = deepMerge(firstValue, secondValue, mergeMap);
-		} else if (isUndefined(secondValue)) {
-			result[key] = firstValue;
-		}
-	}
-
-	return result;
-}
-
-/**
- * Normalizes the rule options config for a given rule by ensuring that
- * it is an array and that the first item is 0, 1, or 2.
- * @param {Array|string|number} ruleOptions The rule options config.
- * @returns {Array} An array of rule options.
- */
-function normalizeRuleOptions(ruleOptions) {
-	const finalOptions = Array.isArray(ruleOptions)
-		? ruleOptions.slice(0)
-		: [ruleOptions];
-
-	finalOptions[0] = ruleSeverities.get(finalOptions[0]);
-	return structuredClone(finalOptions);
-}
-
-/**
- * Determines if an object has any methods.
- * @param {Object} object The object to check.
- * @returns {boolean} `true` if the object has any methods.
- */
-function hasMethod(object) {
-	for (const key of Object.keys(object)) {
-		if (typeof object[key] === "function") {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-//-----------------------------------------------------------------------------
-// Assertions
-//-----------------------------------------------------------------------------
-
-/**
- * The error type when a rule's options are configured with an invalid type.
- */
-class InvalidRuleOptionsError extends Error {
-	/**
-	 * @param {string} ruleId Rule name being configured.
-	 * @param {any} value The invalid value.
-	 */
-	constructor(ruleId, value) {
-		super(
-			`Key "${ruleId}": Expected severity of "off", 0, "warn", 1, "error", or 2.`,
-		);
-		this.messageTemplate = "invalid-rule-options";
-		this.messageData = { ruleId, value };
-	}
-}
-
-/**
- * Validates that a value is a valid rule options entry.
- * @param {string} ruleId Rule name being configured.
- * @param {any} value The value to check.
- * @returns {void}
- * @throws {InvalidRuleOptionsError} If the value isn't a valid rule options.
- */
-function assertIsRuleOptions(ruleId, value) {
-	if (
-		typeof value !== "string" &&
-		typeof value !== "number" &&
-		!Array.isArray(value)
-	) {
-		throw new InvalidRuleOptionsError(ruleId, value);
-	}
-}
-
-/**
- * The error type when a rule's severity is invalid.
- */
-class InvalidRuleSeverityError extends Error {
-	/**
-	 * @param {string} ruleId Rule name being configured.
-	 * @param {any} value The invalid value.
-	 */
-	constructor(ruleId, value) {
-		super(
-			`Key "${ruleId}": Expected severity of "off", 0, "warn", 1, "error", or 2.`,
-		);
-		this.messageTemplate = "invalid-rule-severity";
-		this.messageData = { ruleId, value };
-	}
-}
-
-/**
- * Validates that a value is valid rule severity.
- * @param {string} ruleId Rule name being configured.
- * @param {any} value The value to check.
- * @returns {void}
- * @throws {InvalidRuleSeverityError} If the value isn't a valid rule severity.
- */
-function assertIsRuleSeverity(ruleId, value) {
-	const severity = ruleSeverities.get(value);
-
-	if (typeof severity === "undefined") {
-		throw new InvalidRuleSeverityError(ruleId, value);
-	}
-}
-
-/**
- * Validates that a given string is the form pluginName/objectName.
- * @param {string} value The string to check.
- * @returns {void}
- * @throws {TypeError} If the string isn't in the correct format.
- */
-function assertIsPluginMemberName(value) {
-	if (!/[\w\-@$]+(?:\/[\w\-$]+)+$/iu.test(value)) {
-		throw new TypeError(
-			`Expected string in the form "pluginName/objectName" but found "${value}".`,
-		);
-	}
-}
-
-/**
- * Validates that a value is an object.
- * @param {any} value The value to check.
- * @returns {void}
- * @throws {TypeError} If the value isn't an object.
- */
-function assertIsObject(value) {
-	if (!isNonNullObject(value)) {
-		throw new TypeError("Expected an object.");
-	}
-}
-
-/**
- * The error type when there's an eslintrc-style options in a flat config.
- */
-class IncompatibleKeyError extends Error {
-	/**
-	 * @param {string} key The invalid key.
-	 */
-	constructor(key) {
-		super(
-			"This appears to be in eslintrc format rather than flat config format.",
-		);
-		this.messageTemplate = "eslintrc-incompat";
-		this.messageData = { key };
-	}
-}
-
-/**
- * The error type when there's an eslintrc-style plugins array found.
- */
-class IncompatiblePluginsError extends Error {
-	/**
-	 * Creates a new instance.
-	 * @param {Array<string>} plugins The plugins array.
-	 */
-	constructor(plugins) {
-		super(
-			"This appears to be in eslintrc format (array of strings) rather than flat config format (object).",
-		);
-		this.messageTemplate = "eslintrc-plugins";
-		this.messageData = { plugins };
-	}
-}
-
-//-----------------------------------------------------------------------------
-// Low-Level Schemas
-//-----------------------------------------------------------------------------
-
-/** @type {ObjectPropertySchema} */
-const booleanSchema = {
-	merge: "replace",
-	validate: "boolean",
-};
-
-const ALLOWED_SEVERITIES = new Set(["error", "warn", "off", 2, 1, 0]);
-
-/** @type {ObjectPropertySchema} */
-const disableDirectiveSeveritySchema = {
-	merge(first, second) {
-		const value = second === void 0 ? first : second;
-
-		if (typeof value === "boolean") {
-			return value ? "warn" : "off";
-		}
-
-		return normalizeSeverityToNumber(value);
-	},
-	validate(value) {
-		if (!(ALLOWED_SEVERITIES.has(value) || typeof value === "boolean")) {
-			throw new TypeError(
-				'Expected one of: "error", "warn", "off", 0, 1, 2, or a boolean.',
-			);
-		}
-	},
-};
-
-/** @type {ObjectPropertySchema} */
-const unusedInlineConfigsSeveritySchema = {
-	merge(first, second) {
-		const value = second === void 0 ? first : second;
-
-		return normalizeSeverityToNumber(value);
-	},
-	validate(value) {
-		if (!ALLOWED_SEVERITIES.has(value)) {
-			throw new TypeError(
-				'Expected one of: "error", "warn", "off", 0, 1, or 2.',
-			);
-		}
-	},
-};
-
-/** @type {ObjectPropertySchema} */
-const deepObjectAssignSchema = {
-	merge(first = {}, second = {}) {
-		return deepMerge(first, second);
-	},
-	validate: "object",
-};
-
-//-----------------------------------------------------------------------------
-// High-Level Schemas
-//-----------------------------------------------------------------------------
-
-/** @type {ObjectPropertySchema} */
-const languageOptionsSchema = {
-	merge(first = {}, second = {}) {
-		const result = deepMerge(first, second);
-
-		for (const [key, value] of Object.entries(result)) {
-			/*
-			 * Special case: Because the `parser` property is an object, it should
-			 * not be deep merged. Instead, it should be replaced if it exists in
-			 * the second object. To make this more generic, we just check for
-			 * objects with methods and replace them if they exist in the second
-			 * object.
-			 */
-			if (isNonArrayObject(value)) {
-				if (hasMethod(value)) {
-					result[key] = second[key] ?? first[key];
-					continue;
-				}
-
-				// for other objects, make sure we aren't reusing the same object
-				result[key] = { ...result[key] };
-				continue;
-			}
-		}
-
-		return result;
-	},
-	validate: "object",
-};
-
-/** @type {ObjectPropertySchema} */
-const languageSchema = {
-	merge: "replace",
-	validate: assertIsPluginMemberName,
-};
-
-/** @type {ObjectPropertySchema} */
-const pluginsSchema = {
-	merge(first = {}, second = {}) {
-		const keys = new Set([...Object.keys(first), ...Object.keys(second)]);
-		const result = {};
-
-		// manually validate that plugins are not redefined
-		for (const key of keys) {
-			// avoid hairy edge case
-			if (key === "__proto__") {
-				continue;
-			}
-
-			if (key in first && key in second && first[key] !== second[key]) {
-				throw new TypeError(`Cannot redefine plugin "${key}".`);
-			}
-
-			result[key] = second[key] || first[key];
-		}
-
-		return result;
-	},
-	validate(value) {
-		// first check the value to be sure it's an object
-		if (value === null || typeof value !== "object") {
-			throw new TypeError("Expected an object.");
-		}
-
-		// make sure it's not an array, which would mean eslintrc-style is used
-		if (Array.isArray(value)) {
-			throw new IncompatiblePluginsError(value);
-		}
-
-		// second check the keys to make sure they are objects
-		for (const key of Object.keys(value)) {
-			// avoid hairy edge case
-			if (key === "__proto__") {
-				continue;
-			}
-
-			if (value[key] === null || typeof value[key] !== "object") {
-				throw new TypeError(`Key "${key}": Expected an object.`);
-			}
-		}
-	},
-};
-
-/** @type {ObjectPropertySchema} */
-const processorSchema = {
-	merge: "replace",
-	validate(value) {
-		if (typeof value === "string") {
-			assertIsPluginMemberName(value);
-		} else if (value && typeof value === "object") {
-			if (
-				typeof value.preprocess !== "function" ||
-				typeof value.postprocess !== "function"
-			) {
-				throw new TypeError(
-					"Object must have a preprocess() and a postprocess() method.",
-				);
-			}
-		} else {
-			throw new TypeError("Expected an object or a string.");
-		}
-	},
-};
-
-/** @type {ObjectPropertySchema} */
-const rulesSchema = {
-	merge(first = {}, second = {}) {
-		const result = {
-			...first,
-			...second,
-		};
-
-		for (const ruleId of Object.keys(result)) {
-			try {
-				// avoid hairy edge case
-				if (ruleId === "__proto__") {
-					/* eslint-disable-next-line no-proto -- Though deprecated, may still be present */
-					delete result.__proto__;
-					continue;
-				}
-
-				result[ruleId] = normalizeRuleOptions(result[ruleId]);
-
-				/*
-				 * If either rule config is missing, then the correct
-				 * config is already present and we just need to normalize
-				 * the severity.
-				 */
-				if (!(ruleId in first) || !(ruleId in second)) {
-					continue;
-				}
-
-				const firstRuleOptions = normalizeRuleOptions(first[ruleId]);
-				const secondRuleOptions = normalizeRuleOptions(second[ruleId]);
-
-				/*
-				 * If the second rule config only has a severity (length of 1),
-				 * then use that severity and keep the rest of the options from
-				 * the first rule config.
-				 */
-				if (secondRuleOptions.length === 1) {
-					result[ruleId] = [
-						secondRuleOptions[0],
-						...firstRuleOptions.slice(1),
-					];
-					continue;
-				}
-
-				/*
-				 * In any other situation, then the second rule config takes
-				 * precedence. That means the value at `result[ruleId]` is
-				 * already correct and no further work is necessary.
-				 */
-			} catch (ex) {
-				throw new Error(`Key "${ruleId}": ${ex.message}`, {
-					cause: ex,
-				});
-			}
-		}
-
-		return result;
-	},
-
-	validate(value) {
-		assertIsObject(value);
-
-		/*
-		 * We are not checking the rule schema here because there is no
-		 * guarantee that the rule definition is present at this point. Instead
-		 * we wait and check the rule schema during the finalization step
-		 * of calculating a config.
-		 */
-		for (const ruleId of Object.keys(value)) {
-			// avoid hairy edge case
-			if (ruleId === "__proto__") {
-				continue;
-			}
-
-			const ruleOptions = value[ruleId];
-
-			assertIsRuleOptions(ruleId, ruleOptions);
-
-			if (Array.isArray(ruleOptions)) {
-				assertIsRuleSeverity(ruleId, ruleOptions[0]);
-			} else {
-				assertIsRuleSeverity(ruleId, ruleOptions);
-			}
-		}
-	},
-};
-
-/**
- * Creates a schema that always throws an error. Useful for warning
- * about eslintrc-style keys.
- * @param {string} key The eslintrc key to create a schema for.
- * @returns {ObjectPropertySchema} The schema.
- */
-function createEslintrcErrorSchema(key) {
-	return {
-		merge: "replace",
-		validate() {
-			throw new IncompatibleKeyError(key);
-		},
-	};
-}
-
-const eslintrcKeys = [
-	"env",
-	"extends",
-	"globals",
-	"ignorePatterns",
-	"noInlineConfig",
-	"overrides",
-	"parser",
-	"parserOptions",
-	"reportUnusedDisableDirectives",
-	"root",
-];
-
-//-----------------------------------------------------------------------------
-// Full schema
-//-----------------------------------------------------------------------------
-
-const flatConfigSchema = {
-	// eslintrc-style keys that should always error
-	...Object.fromEntries(
-		eslintrcKeys.map(key => [key, createEslintrcErrorSchema(key)]),
-	),
-
-	// flat config keys
-	settings: deepObjectAssignSchema,
-	linterOptions: {
-		schema: {
-			noInlineConfig: booleanSchema,
-			reportUnusedDisableDirectives: disableDirectiveSeveritySchema,
-			reportUnusedInlineConfigs: unusedInlineConfigsSeveritySchema,
-		},
-	},
-	language: languageSchema,
-	languageOptions: languageOptionsSchema,
-	processor: processorSchema,
-	plugins: pluginsSchema,
-	rules: rulesSchema,
-};
-
-//-----------------------------------------------------------------------------
-// Exports
-//-----------------------------------------------------------------------------
-
-module.exports = {
-	flatConfigSchema,
-	hasMethod,
-	assertIsRuleSeverity,
-};

package/packages/config-eslint/node_modules/eslint/lib/config-api.js

@@ -1,12 +0,0 @@
-/**
- * @fileoverview exports for config helpers
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-const { defineConfig, globalIgnores } = require("@eslint/config-helpers");
-
-module.exports = {
-	defineConfig,
-	globalIgnores,
-};