@alexlit/lint-kit 183.0.0 → 183.2.0

package/packages/config-eslint/node_modules/eslint/lib/rules/no-multi-assign.js

@@ -1,66 +0,0 @@
-/**
- * @fileoverview Rule to check use of chained assignment expressions
- * @author Stewart Rand
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: [
-			{
-				ignoreNonDeclaration: false,
-			},
-		],
-
-		docs: {
-			description: "Disallow use of chained assignment expressions",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-multi-assign",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					ignoreNonDeclaration: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			unexpectedChain: "Unexpected chained assignment.",
-		},
-	},
-
-	create(context) {
-		const [{ ignoreNonDeclaration }] = context.options;
-		const selectors = [
-			"VariableDeclarator > AssignmentExpression.init",
-			"PropertyDefinition > AssignmentExpression.value",
-		];
-
-		if (!ignoreNonDeclaration) {
-			selectors.push("AssignmentExpression > AssignmentExpression.right");
-		}
-
-		return {
-			[selectors](node) {
-				context.report({
-					node,
-					messageId: "unexpectedChain",
-				});
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-multi-spaces.js

@@ -1,179 +0,0 @@
-/**
- * @fileoverview Disallow use of multiple spaces.
- * @author Nicholas C. Zakas
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		deprecated: {
-			message: "Formatting rules are being moved out of ESLint core.",
-			url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
-			deprecatedSince: "8.53.0",
-			availableUntil: "11.0.0",
-			replacedBy: [
-				{
-					message:
-						"ESLint Stylistic now maintains deprecated stylistic core rules.",
-					url: "https://eslint.style/guide/migration",
-					plugin: {
-						name: "@stylistic/eslint-plugin",
-						url: "https://eslint.style",
-					},
-					rule: {
-						name: "no-multi-spaces",
-						url: "https://eslint.style/rules/no-multi-spaces",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description: "Disallow multiple spaces",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-multi-spaces",
-		},
-
-		fixable: "whitespace",
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					exceptions: {
-						type: "object",
-						patternProperties: {
-							"^([A-Z][a-z]*)+$": {
-								type: "boolean",
-							},
-						},
-						additionalProperties: false,
-					},
-					ignoreEOLComments: {
-						type: "boolean",
-						default: false,
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			multipleSpaces: "Multiple spaces found before '{{displayValue}}'.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-		const options = context.options[0] || {};
-		const ignoreEOLComments = options.ignoreEOLComments;
-		const exceptions = Object.assign(
-			{ Property: true },
-			options.exceptions,
-		);
-		const hasExceptions = Object.keys(exceptions).some(
-			key => exceptions[key],
-		);
-
-		/**
-		 * Formats value of given comment token for error message by truncating its length.
-		 * @param {Token} token comment token
-		 * @returns {string} formatted value
-		 * @private
-		 */
-		function formatReportedCommentValue(token) {
-			const valueLines = token.value.split("\n");
-			const value = valueLines[0];
-			const formattedValue = `${value.slice(0, 12)}...`;
-
-			return valueLines.length === 1 && value.length <= 12
-				? value
-				: formattedValue;
-		}
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			Program() {
-				sourceCode.tokensAndComments.forEach(
-					(leftToken, leftIndex, tokensAndComments) => {
-						if (leftIndex === tokensAndComments.length - 1) {
-							return;
-						}
-						const rightToken = tokensAndComments[leftIndex + 1];
-
-						// Ignore tokens that don't have 2 spaces between them or are on different lines
-						if (
-							!sourceCode.text
-								.slice(leftToken.range[1], rightToken.range[0])
-								.includes("  ") ||
-							leftToken.loc.end.line < rightToken.loc.start.line
-						) {
-							return;
-						}
-
-						// Ignore comments that are the last token on their line if `ignoreEOLComments` is active.
-						if (
-							ignoreEOLComments &&
-							astUtils.isCommentToken(rightToken) &&
-							(leftIndex === tokensAndComments.length - 2 ||
-								rightToken.loc.end.line <
-									tokensAndComments[leftIndex + 2].loc.start
-										.line)
-						) {
-							return;
-						}
-
-						// Ignore tokens that are in a node in the "exceptions" object
-						if (hasExceptions) {
-							const parentNode = sourceCode.getNodeByRangeIndex(
-								rightToken.range[0] - 1,
-							);
-
-							if (parentNode && exceptions[parentNode.type]) {
-								return;
-							}
-						}
-
-						let displayValue;
-
-						if (rightToken.type === "Block") {
-							displayValue = `/*${formatReportedCommentValue(rightToken)}*/`;
-						} else if (rightToken.type === "Line") {
-							displayValue = `//${formatReportedCommentValue(rightToken)}`;
-						} else {
-							displayValue = rightToken.value;
-						}
-
-						context.report({
-							node: rightToken,
-							loc: {
-								start: leftToken.loc.end,
-								end: rightToken.loc.start,
-							},
-							messageId: "multipleSpaces",
-							data: { displayValue },
-							fix: fixer =>
-								fixer.replaceTextRange(
-									[leftToken.range[1], rightToken.range[0]],
-									" ",
-								),
-						});
-					},
-				);
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-multi-str.js

@@ -1,67 +0,0 @@
-/**
- * @fileoverview Rule to flag when using multiline strings
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow multiline strings",
-			recommended: false,
-			frozen: true,
-			url: "https://eslint.org/docs/latest/rules/no-multi-str",
-		},
-
-		schema: [],
-
-		messages: {
-			multilineString:
-				"Multiline support is limited to browsers supporting ES5 only.",
-		},
-	},
-
-	create(context) {
-		/**
-		 * Determines if a given node is part of JSX syntax.
-		 * @param {ASTNode} node The node to check.
-		 * @returns {boolean} True if the node is a JSX node, false if not.
-		 * @private
-		 */
-		function isJSXElement(node) {
-			return node.type.indexOf("JSX") === 0;
-		}
-
-		//--------------------------------------------------------------------------
-		// Public API
-		//--------------------------------------------------------------------------
-
-		return {
-			Literal(node) {
-				if (
-					astUtils.LINEBREAK_MATCHER.test(node.raw) &&
-					!isJSXElement(node.parent)
-				) {
-					context.report({
-						node,
-						messageId: "multilineString",
-					});
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-multiple-empty-lines.js

@@ -1,210 +0,0 @@
-/**
- * @fileoverview Disallows multiple blank lines.
- * implementation adapted from the no-trailing-spaces rule.
- * @author Greg Cochard
- * @deprecated in ESLint v8.53.0
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		deprecated: {
-			message: "Formatting rules are being moved out of ESLint core.",
-			url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
-			deprecatedSince: "8.53.0",
-			availableUntil: "11.0.0",
-			replacedBy: [
-				{
-					message:
-						"ESLint Stylistic now maintains deprecated stylistic core rules.",
-					url: "https://eslint.style/guide/migration",
-					plugin: {
-						name: "@stylistic/eslint-plugin",
-						url: "https://eslint.style",
-					},
-					rule: {
-						name: "no-multiple-empty-lines",
-						url: "https://eslint.style/rules/no-multiple-empty-lines",
-					},
-				},
-			],
-		},
-		type: "layout",
-
-		docs: {
-			description: "Disallow multiple empty lines",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-multiple-empty-lines",
-		},
-
-		fixable: "whitespace",
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					max: {
-						type: "integer",
-						minimum: 0,
-					},
-					maxEOF: {
-						type: "integer",
-						minimum: 0,
-					},
-					maxBOF: {
-						type: "integer",
-						minimum: 0,
-					},
-				},
-				required: ["max"],
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			blankBeginningOfFile:
-				"Too many blank lines at the beginning of file. Max of {{max}} allowed.",
-			blankEndOfFile:
-				"Too many blank lines at the end of file. Max of {{max}} allowed.",
-			consecutiveBlank:
-				"More than {{max}} blank {{pluralizedLines}} not allowed.",
-		},
-	},
-
-	create(context) {
-		// Use options.max or 2 as default
-		let max = 2,
-			maxEOF = max,
-			maxBOF = max;
-
-		if (context.options.length) {
-			max = context.options[0].max;
-			maxEOF =
-				typeof context.options[0].maxEOF !== "undefined"
-					? context.options[0].maxEOF
-					: max;
-			maxBOF =
-				typeof context.options[0].maxBOF !== "undefined"
-					? context.options[0].maxBOF
-					: max;
-		}
-
-		const sourceCode = context.sourceCode;
-
-		// Swallow the final newline, as some editors add it automatically and we don't want it to cause an issue
-		const allLines =
-			sourceCode.lines.at(-1) === ""
-				? sourceCode.lines.slice(0, -1)
-				: sourceCode.lines;
-		const templateLiteralLines = new Set();
-
-		//--------------------------------------------------------------------------
-		// Public
-		//--------------------------------------------------------------------------
-
-		return {
-			TemplateLiteral(node) {
-				node.quasis.forEach(literalPart => {
-					// Empty lines have a semantic meaning if they're inside template literals. Don't count these as empty lines.
-					for (
-						let ignoredLine = literalPart.loc.start.line;
-						ignoredLine < literalPart.loc.end.line;
-						ignoredLine++
-					) {
-						templateLiteralLines.add(ignoredLine);
-					}
-				});
-			},
-			"Program:exit"(node) {
-				return (
-					allLines
-
-						// Given a list of lines, first get a list of line numbers that are non-empty.
-						.reduce((nonEmptyLineNumbers, line, index) => {
-							if (
-								line.trim() ||
-								templateLiteralLines.has(index + 1)
-							) {
-								nonEmptyLineNumbers.push(index + 1);
-							}
-							return nonEmptyLineNumbers;
-						}, [])
-
-						// Add a value at the end to allow trailing empty lines to be checked.
-						.concat(allLines.length + 1)
-
-						// Given two line numbers of non-empty lines, report the lines between if the difference is too large.
-						.reduce((lastLineNumber, lineNumber) => {
-							let messageId, maxAllowed;
-
-							if (lastLineNumber === 0) {
-								messageId = "blankBeginningOfFile";
-								maxAllowed = maxBOF;
-							} else if (lineNumber === allLines.length + 1) {
-								messageId = "blankEndOfFile";
-								maxAllowed = maxEOF;
-							} else {
-								messageId = "consecutiveBlank";
-								maxAllowed = max;
-							}
-
-							if (lineNumber - lastLineNumber - 1 > maxAllowed) {
-								context.report({
-									node,
-									loc: {
-										start: {
-											line:
-												lastLineNumber + maxAllowed + 1,
-											column: 0,
-										},
-										end: { line: lineNumber, column: 0 },
-									},
-									messageId,
-									data: {
-										max: maxAllowed,
-										pluralizedLines:
-											maxAllowed === 1 ? "line" : "lines",
-									},
-									fix(fixer) {
-										const rangeStart =
-											sourceCode.getIndexFromLoc({
-												line: lastLineNumber + 1,
-												column: 0,
-											});
-
-										/*
-										 * The end of the removal range is usually the start index of the next line.
-										 * However, at the end of the file there is no next line, so the end of the
-										 * range is just the length of the text.
-										 */
-										const lineNumberAfterRemovedLines =
-											lineNumber - maxAllowed;
-										const rangeEnd =
-											lineNumberAfterRemovedLines <=
-											allLines.length
-												? sourceCode.getIndexFromLoc({
-														line: lineNumberAfterRemovedLines,
-														column: 0,
-													})
-												: sourceCode.text.length;
-
-										return fixer.removeRange([
-											rangeStart,
-											rangeEnd,
-										]);
-									},
-								});
-							}
-
-							return lineNumber;
-						}, 0)
-				);
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-native-reassign.js

@@ -1,114 +0,0 @@
-/**
- * @fileoverview Rule to disallow assignments to native objects or read-only global variables
- * @author Ilya Volodin
- * @deprecated in ESLint v3.3.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Disallow assignments to native objects or read-only global variables",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-native-reassign",
-		},
-
-		deprecated: {
-			message: "Renamed rule.",
-			url: "https://eslint.org/blog/2016/08/eslint-v3.3.0-released/#deprecated-rules",
-			deprecatedSince: "3.3.0",
-			availableUntil: "11.0.0",
-			replacedBy: [
-				{
-					rule: {
-						name: "no-global-assign",
-						url: "https://eslint.org/docs/rules/no-global-assign",
-					},
-				},
-			],
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					exceptions: {
-						type: "array",
-						items: { type: "string" },
-						uniqueItems: true,
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			nativeReassign:
-				"Read-only global '{{name}}' should not be modified.",
-		},
-	},
-
-	create(context) {
-		const config = context.options[0];
-		const exceptions = (config && config.exceptions) || [];
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Reports write references.
-		 * @param {Reference} reference A reference to check.
-		 * @param {number} index The index of the reference in the references.
-		 * @param {Reference[]} references The array that the reference belongs to.
-		 * @returns {void}
-		 */
-		function checkReference(reference, index, references) {
-			const identifier = reference.identifier;
-
-			if (
-				reference.init === false &&
-				reference.isWrite() &&
-				/*
-				 * Destructuring assignments can have multiple default value,
-				 * so possibly there are multiple writeable references for the same identifier.
-				 */
-				(index === 0 || references[index - 1].identifier !== identifier)
-			) {
-				context.report({
-					node: identifier,
-					messageId: "nativeReassign",
-					data: identifier,
-				});
-			}
-		}
-
-		/**
-		 * Reports write references if a given variable is read-only builtin.
-		 * @param {Variable} variable A variable to check.
-		 * @returns {void}
-		 */
-		function checkVariable(variable) {
-			if (
-				variable.writeable === false &&
-				!exceptions.includes(variable.name)
-			) {
-				variable.references.forEach(checkReference);
-			}
-		}
-
-		return {
-			Program(node) {
-				const globalScope = sourceCode.getScope(node);
-
-				globalScope.variables.forEach(checkVariable);
-			},
-		};
-	},
-};