bahlint 28.58.6934

package/lib/rules/comma-dangle.js

@@ -0,0 +1,424 @@
+/**
+ * @fileoverview Rule to forbid or enforce dangling commas.
+ * @author Ian Christian Myers
+ * @deprecated in ESLint v8.53.0
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const DEFAULT_OPTIONS = Object.freeze({
+	arrays: "never",
+	objects: "never",
+	imports: "never",
+	exports: "never",
+	functions: "never",
+});
+
+/**
+ * Checks whether or not a trailing comma is allowed in a given node.
+ * If the `lastItem` is `RestElement` or `RestProperty`, it disallows trailing commas.
+ * @param {ASTNode} lastItem The node of the last element in the given node.
+ * @returns {boolean} `true` if a trailing comma is allowed.
+ */
+function isTrailingCommaAllowed(lastItem) {
+	return !(
+		lastItem.type === "RestElement" ||
+		lastItem.type === "RestProperty" ||
+		lastItem.type === "ExperimentalRestProperty"
+	);
+}
+
+/**
+ * Normalize option value.
+ * @param {string|Object|undefined} optionValue The 1st option value to normalize.
+ * @param {number} ecmaVersion The normalized ECMAScript version.
+ * @returns {Object} The normalized option value.
+ */
+function normalizeOptions(optionValue, ecmaVersion) {
+	if (typeof optionValue === "string") {
+		return {
+			arrays: optionValue,
+			objects: optionValue,
+			imports: optionValue,
+			exports: optionValue,
+			functions: ecmaVersion < 2017 ? "ignore" : optionValue,
+		};
+	}
+	if (typeof optionValue === "object" && optionValue !== null) {
+		return {
+			arrays: optionValue.arrays || DEFAULT_OPTIONS.arrays,
+			objects: optionValue.objects || DEFAULT_OPTIONS.objects,
+			imports: optionValue.imports || DEFAULT_OPTIONS.imports,
+			exports: optionValue.exports || DEFAULT_OPTIONS.exports,
+			functions: optionValue.functions || DEFAULT_OPTIONS.functions,
+		};
+	}
+
+	return DEFAULT_OPTIONS;
+}
+
+//------------------------------------------------------------------------------
+// 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: "comma-dangle",
+						url: "https://eslint.style/rules/comma-dangle",
+					},
+				},
+			],
+		},
+		type: "layout",
+
+		docs: {
+			description: "Require or disallow trailing commas",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/comma-dangle",
+		},
+
+		fixable: "code",
+
+		schema: {
+			definitions: {
+				value: {
+					enum: [
+						"always-multiline",
+						"always",
+						"never",
+						"only-multiline",
+					],
+				},
+				valueWithIgnore: {
+					enum: [
+						"always-multiline",
+						"always",
+						"ignore",
+						"never",
+						"only-multiline",
+					],
+				},
+			},
+			type: "array",
+			items: [
+				{
+					oneOf: [
+						{
+							$ref: "#/definitions/value",
+						},
+						{
+							type: "object",
+							properties: {
+								arrays: {
+									$ref: "#/definitions/valueWithIgnore",
+								},
+								objects: {
+									$ref: "#/definitions/valueWithIgnore",
+								},
+								imports: {
+									$ref: "#/definitions/valueWithIgnore",
+								},
+								exports: {
+									$ref: "#/definitions/valueWithIgnore",
+								},
+								functions: {
+									$ref: "#/definitions/valueWithIgnore",
+								},
+							},
+							additionalProperties: false,
+						},
+					],
+				},
+			],
+			additionalItems: false,
+		},
+
+		messages: {
+			unexpected: "Unexpected trailing comma.",
+			missing: "Missing trailing comma.",
+		},
+	},
+
+	create(context) {
+		const options = normalizeOptions(
+			context.options[0],
+			context.languageOptions.ecmaVersion,
+		);
+
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Gets the last item of the given node.
+		 * @param {ASTNode} node The node to get.
+		 * @returns {ASTNode|null} The last node or null.
+		 */
+		function getLastItem(node) {
+			/**
+			 * Returns the last element of an array
+			 * @param {any[]} array The input array
+			 * @returns {any} The last element
+			 */
+			function last(array) {
+				return array.at(-1);
+			}
+
+			switch (node.type) {
+				case "ObjectExpression":
+				case "ObjectPattern":
+					return last(node.properties);
+				case "ArrayExpression":
+				case "ArrayPattern":
+					return last(node.elements);
+				case "ImportDeclaration":
+				case "ExportNamedDeclaration":
+					return last(node.specifiers);
+				case "FunctionDeclaration":
+				case "FunctionExpression":
+				case "ArrowFunctionExpression":
+					return last(node.params);
+				case "CallExpression":
+				case "NewExpression":
+					return last(node.arguments);
+				default:
+					return null;
+			}
+		}
+
+		/**
+		 * Gets the trailing comma token of the given node.
+		 * If the trailing comma does not exist, this returns the token which is
+		 * the insertion point of the trailing comma token.
+		 * @param {ASTNode} node The node to get.
+		 * @param {ASTNode} lastItem The last item of the node.
+		 * @returns {Token} The trailing comma token or the insertion point.
+		 */
+		function getTrailingToken(node, lastItem) {
+			switch (node.type) {
+				case "ObjectExpression":
+				case "ArrayExpression":
+				case "CallExpression":
+				case "NewExpression":
+					return sourceCode.getLastToken(node, 1);
+				default: {
+					const nextToken = sourceCode.getTokenAfter(lastItem);
+
+					if (astUtils.isCommaToken(nextToken)) {
+						return nextToken;
+					}
+					return sourceCode.getLastToken(lastItem);
+				}
+			}
+		}
+
+		/**
+		 * Checks whether or not a given node is multiline.
+		 * This rule handles a given node as multiline when the closing parenthesis
+		 * and the last element are not on the same line.
+		 * @param {ASTNode} node A node to check.
+		 * @returns {boolean} `true` if the node is multiline.
+		 */
+		function isMultiline(node) {
+			const lastItem = getLastItem(node);
+
+			if (!lastItem) {
+				return false;
+			}
+
+			const penultimateToken = getTrailingToken(node, lastItem);
+			const lastToken = sourceCode.getTokenAfter(penultimateToken);
+
+			return lastToken.loc.end.line !== penultimateToken.loc.end.line;
+		}
+
+		/**
+		 * Reports a trailing comma if it exists.
+		 * @param {ASTNode} node A node to check. Its type is one of
+		 *   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,
+		 *   ImportDeclaration, and ExportNamedDeclaration.
+		 * @returns {void}
+		 */
+		function forbidTrailingComma(node) {
+			const lastItem = getLastItem(node);
+
+			if (
+				!lastItem ||
+				(node.type === "ImportDeclaration" &&
+					lastItem.type !== "ImportSpecifier")
+			) {
+				return;
+			}
+
+			const trailingToken = getTrailingToken(node, lastItem);
+
+			if (astUtils.isCommaToken(trailingToken)) {
+				context.report({
+					node: lastItem,
+					loc: trailingToken.loc,
+					messageId: "unexpected",
+					*fix(fixer) {
+						yield fixer.remove(trailingToken);
+
+						/*
+						 * Extend the range of the fix to include surrounding tokens to ensure
+						 * that the element after which the comma is removed stays _last_.
+						 * This intentionally makes conflicts in fix ranges with rules that may be
+						 * adding or removing elements in the same autofix pass.
+						 * https://github.com/eslint/eslint/issues/15660
+						 */
+						yield fixer.insertTextBefore(
+							sourceCode.getTokenBefore(trailingToken),
+							"",
+						);
+						yield fixer.insertTextAfter(
+							sourceCode.getTokenAfter(trailingToken),
+							"",
+						);
+					},
+				});
+			}
+		}
+
+		/**
+		 * Reports the last element of a given node if it does not have a trailing
+		 * comma.
+		 *
+		 * If a given node is `ArrayPattern` which has `RestElement`, the trailing
+		 * comma is disallowed, so report if it exists.
+		 * @param {ASTNode} node A node to check. Its type is one of
+		 *   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,
+		 *   ImportDeclaration, and ExportNamedDeclaration.
+		 * @returns {void}
+		 */
+		function forceTrailingComma(node) {
+			const lastItem = getLastItem(node);
+
+			if (
+				!lastItem ||
+				(node.type === "ImportDeclaration" &&
+					lastItem.type !== "ImportSpecifier")
+			) {
+				return;
+			}
+			if (!isTrailingCommaAllowed(lastItem)) {
+				forbidTrailingComma(node);
+				return;
+			}
+
+			const trailingToken = getTrailingToken(node, lastItem);
+
+			if (trailingToken.value !== ",") {
+				context.report({
+					node: lastItem,
+					loc: {
+						start: trailingToken.loc.end,
+						end: astUtils.getNextLocation(
+							sourceCode,
+							trailingToken.loc.end,
+						),
+					},
+					messageId: "missing",
+					*fix(fixer) {
+						yield fixer.insertTextAfter(trailingToken, ",");
+
+						/*
+						 * Extend the range of the fix to include surrounding tokens to ensure
+						 * that the element after which the comma is inserted stays _last_.
+						 * This intentionally makes conflicts in fix ranges with rules that may be
+						 * adding or removing elements in the same autofix pass.
+						 * https://github.com/eslint/eslint/issues/15660
+						 */
+						yield fixer.insertTextBefore(trailingToken, "");
+						yield fixer.insertTextAfter(
+							sourceCode.getTokenAfter(trailingToken),
+							"",
+						);
+					},
+				});
+			}
+		}
+
+		/**
+		 * If a given node is multiline, reports the last element of a given node
+		 * when it does not have a trailing comma.
+		 * Otherwise, reports a trailing comma if it exists.
+		 * @param {ASTNode} node A node to check. Its type is one of
+		 *   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,
+		 *   ImportDeclaration, and ExportNamedDeclaration.
+		 * @returns {void}
+		 */
+		function forceTrailingCommaIfMultiline(node) {
+			if (isMultiline(node)) {
+				forceTrailingComma(node);
+			} else {
+				forbidTrailingComma(node);
+			}
+		}
+
+		/**
+		 * Only if a given node is not multiline, reports the last element of a given node
+		 * when it does not have a trailing comma.
+		 * Otherwise, reports a trailing comma if it exists.
+		 * @param {ASTNode} node A node to check. Its type is one of
+		 *   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,
+		 *   ImportDeclaration, and ExportNamedDeclaration.
+		 * @returns {void}
+		 */
+		function allowTrailingCommaIfMultiline(node) {
+			if (!isMultiline(node)) {
+				forbidTrailingComma(node);
+			}
+		}
+
+		const predicate = {
+			always: forceTrailingComma,
+			"always-multiline": forceTrailingCommaIfMultiline,
+			"only-multiline": allowTrailingCommaIfMultiline,
+			never: forbidTrailingComma,
+			ignore() {},
+		};
+
+		return {
+			ObjectExpression: predicate[options.objects],
+			ObjectPattern: predicate[options.objects],
+
+			ArrayExpression: predicate[options.arrays],
+			ArrayPattern: predicate[options.arrays],
+
+			ImportDeclaration: predicate[options.imports],
+
+			ExportNamedDeclaration: predicate[options.exports],
+
+			FunctionDeclaration: predicate[options.functions],
+			FunctionExpression: predicate[options.functions],
+			ArrowFunctionExpression: predicate[options.functions],
+			CallExpression: predicate[options.functions],
+			NewExpression: predicate[options.functions],
+		};
+	},
+};

package/lib/rules/comma-spacing.js

@@ -0,0 +1,205 @@
+/**
+ * @fileoverview Comma spacing - validates spacing before and after comma
+ * @author Vignesh Anand aka vegetableman.
+ * @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: "comma-spacing",
+						url: "https://eslint.style/rules/comma-spacing",
+					},
+				},
+			],
+		},
+		type: "layout",
+
+		docs: {
+			description: "Enforce consistent spacing before and after commas",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/comma-spacing",
+		},
+
+		fixable: "whitespace",
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					before: {
+						type: "boolean",
+						default: false,
+					},
+					after: {
+						type: "boolean",
+						default: true,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			missing: "A space is required {{loc}} ','.",
+			unexpected: "There should be no space {{loc}} ','.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const tokensAndComments = sourceCode.tokensAndComments;
+
+		const options = {
+			before: context.options[0] ? context.options[0].before : false,
+			after: context.options[0] ? context.options[0].after : true,
+		};
+
+		//--------------------------------------------------------------------------
+		// Helpers
+		//--------------------------------------------------------------------------
+
+		// list of comma tokens to ignore for the check of leading whitespace
+		const commaTokensToIgnore = [];
+
+		/**
+		 * Reports a spacing error with an appropriate message.
+		 * @param {ASTNode} node The binary expression node to report.
+		 * @param {string} loc Is the error "before" or "after" the comma?
+		 * @param {ASTNode} otherNode The node at the left or right of `node`
+		 * @returns {void}
+		 * @private
+		 */
+		function report(node, loc, otherNode) {
+			context.report({
+				node,
+				fix(fixer) {
+					if (options[loc]) {
+						if (loc === "before") {
+							return fixer.insertTextBefore(node, " ");
+						}
+						return fixer.insertTextAfter(node, " ");
+					}
+					let start, end;
+					const newText = "";
+
+					if (loc === "before") {
+						start = otherNode.range[1];
+						end = node.range[0];
+					} else {
+						start = node.range[1];
+						end = otherNode.range[0];
+					}
+
+					return fixer.replaceTextRange([start, end], newText);
+				},
+				messageId: options[loc] ? "missing" : "unexpected",
+				data: {
+					loc,
+				},
+			});
+		}
+
+		/**
+		 * Adds null elements of the given ArrayExpression or ArrayPattern node to the ignore list.
+		 * @param {ASTNode} node An ArrayExpression or ArrayPattern node.
+		 * @returns {void}
+		 */
+		function addNullElementsToIgnoreList(node) {
+			let previousToken = sourceCode.getFirstToken(node);
+
+			node.elements.forEach(element => {
+				let token;
+
+				if (element === null) {
+					token = sourceCode.getTokenAfter(previousToken);
+
+					if (astUtils.isCommaToken(token)) {
+						commaTokensToIgnore.push(token);
+					}
+				} else {
+					token = sourceCode.getTokenAfter(element);
+				}
+
+				previousToken = token;
+			});
+		}
+
+		//--------------------------------------------------------------------------
+		// Public
+		//--------------------------------------------------------------------------
+
+		return {
+			"Program:exit"() {
+				tokensAndComments.forEach((token, i) => {
+					if (!astUtils.isCommaToken(token)) {
+						return;
+					}
+
+					const previousToken = tokensAndComments[i - 1];
+					const nextToken = tokensAndComments[i + 1];
+
+					if (
+						previousToken &&
+						!astUtils.isCommaToken(previousToken) && // ignore spacing between two commas
+						/*
+						 * `commaTokensToIgnore` are ending commas of `null` elements (array holes/elisions).
+						 * In addition to spacing between two commas, this can also ignore:
+						 *
+						 *   - Spacing after `[` (controlled by array-bracket-spacing)
+						 *       Example: [ , ]
+						 *                 ^
+						 *   - Spacing after a comment (for backwards compatibility, this was possibly unintentional)
+						 *       Example: [a, /* * / ,]
+						 *                          ^
+						 */
+						!commaTokensToIgnore.includes(token) &&
+						astUtils.isTokenOnSameLine(previousToken, token) &&
+						options.before !==
+							sourceCode.isSpaceBetween(previousToken, token)
+					) {
+						report(token, "before", previousToken);
+					}
+
+					if (
+						nextToken &&
+						!astUtils.isCommaToken(nextToken) && // ignore spacing between two commas
+						!astUtils.isClosingParenToken(nextToken) && // controlled by space-in-parens
+						!astUtils.isClosingBracketToken(nextToken) && // controlled by array-bracket-spacing
+						!astUtils.isClosingBraceToken(nextToken) && // controlled by object-curly-spacing
+						!(!options.after && nextToken.type === "Line") && // special case, allow space before line comment
+						astUtils.isTokenOnSameLine(token, nextToken) &&
+						options.after !==
+							sourceCode.isSpaceBetween(token, nextToken)
+					) {
+						report(token, "after", nextToken);
+					}
+				});
+			},
+			ArrayExpression: addNullElementsToIgnoreList,
+			ArrayPattern: addNullElementsToIgnoreList,
+		};
+	},
+};