bahlint 28.58.6934

package/lib/rules/object-curly-spacing.js

@@ -0,0 +1,369 @@
+/**
+ * @fileoverview Disallows or enforces spaces inside of object literals.
+ * @author Jamund Ferguson
+ * @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: "object-curly-spacing",
+						url: "https://eslint.style/rules/object-curly-spacing",
+					},
+				},
+			],
+		},
+		type: "layout",
+
+		docs: {
+			description: "Enforce consistent spacing inside braces",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/object-curly-spacing",
+		},
+
+		fixable: "whitespace",
+
+		schema: [
+			{
+				enum: ["always", "never"],
+			},
+			{
+				type: "object",
+				properties: {
+					arraysInObjects: {
+						type: "boolean",
+					},
+					objectsInObjects: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			requireSpaceBefore: "A space is required before '{{token}}'.",
+			requireSpaceAfter: "A space is required after '{{token}}'.",
+			unexpectedSpaceBefore:
+				"There should be no space before '{{token}}'.",
+			unexpectedSpaceAfter: "There should be no space after '{{token}}'.",
+		},
+	},
+
+	create(context) {
+		const spaced = context.options[0] === "always",
+			sourceCode = context.sourceCode;
+
+		/**
+		 * Determines whether an option is set, relative to the spacing option.
+		 * If spaced is "always", then check whether option is set to false.
+		 * If spaced is "never", then check whether option is set to true.
+		 * @param {Object} option The option to exclude.
+		 * @returns {boolean} Whether or not the property is excluded.
+		 */
+		function isOptionSet(option) {
+			return context.options[1]
+				? context.options[1][option] === !spaced
+				: false;
+		}
+
+		const options = {
+			spaced,
+			arraysInObjectsException: isOptionSet("arraysInObjects"),
+			objectsInObjectsException: isOptionSet("objectsInObjects"),
+		};
+
+		//--------------------------------------------------------------------------
+		// Helpers
+		//--------------------------------------------------------------------------
+
+		/**
+		 * Reports that there shouldn't be a space after the first token
+		 * @param {ASTNode} node The node to report in the event of an error.
+		 * @param {Token} token The token to use for the report.
+		 * @returns {void}
+		 */
+		function reportNoBeginningSpace(node, token) {
+			const nextToken = context.sourceCode.getTokenAfter(token, {
+				includeComments: true,
+			});
+
+			context.report({
+				node,
+				loc: { start: token.loc.end, end: nextToken.loc.start },
+				messageId: "unexpectedSpaceAfter",
+				data: {
+					token: token.value,
+				},
+				fix(fixer) {
+					return fixer.removeRange([
+						token.range[1],
+						nextToken.range[0],
+					]);
+				},
+			});
+		}
+
+		/**
+		 * Reports that there shouldn't be a space before the last token
+		 * @param {ASTNode} node The node to report in the event of an error.
+		 * @param {Token} token The token to use for the report.
+		 * @returns {void}
+		 */
+		function reportNoEndingSpace(node, token) {
+			const previousToken = context.sourceCode.getTokenBefore(token, {
+				includeComments: true,
+			});
+
+			context.report({
+				node,
+				loc: { start: previousToken.loc.end, end: token.loc.start },
+				messageId: "unexpectedSpaceBefore",
+				data: {
+					token: token.value,
+				},
+				fix(fixer) {
+					return fixer.removeRange([
+						previousToken.range[1],
+						token.range[0],
+					]);
+				},
+			});
+		}
+
+		/**
+		 * Reports that there should be a space after the first token
+		 * @param {ASTNode} node The node to report in the event of an error.
+		 * @param {Token} token The token to use for the report.
+		 * @returns {void}
+		 */
+		function reportRequiredBeginningSpace(node, token) {
+			context.report({
+				node,
+				loc: token.loc,
+				messageId: "requireSpaceAfter",
+				data: {
+					token: token.value,
+				},
+				fix(fixer) {
+					return fixer.insertTextAfter(token, " ");
+				},
+			});
+		}
+
+		/**
+		 * Reports that there should be a space before the last token
+		 * @param {ASTNode} node The node to report in the event of an error.
+		 * @param {Token} token The token to use for the report.
+		 * @returns {void}
+		 */
+		function reportRequiredEndingSpace(node, token) {
+			context.report({
+				node,
+				loc: token.loc,
+				messageId: "requireSpaceBefore",
+				data: {
+					token: token.value,
+				},
+				fix(fixer) {
+					return fixer.insertTextBefore(token, " ");
+				},
+			});
+		}
+
+		/**
+		 * Determines if spacing in curly braces is valid.
+		 * @param {ASTNode} node The AST node to check.
+		 * @param {Token} first The first token to check (should be the opening brace)
+		 * @param {Token} second The second token to check (should be first after the opening brace)
+		 * @param {Token} penultimate The penultimate token to check (should be last before closing brace)
+		 * @param {Token} last The last token to check (should be closing brace)
+		 * @returns {void}
+		 */
+		function validateBraceSpacing(node, first, second, penultimate, last) {
+			if (astUtils.isTokenOnSameLine(first, second)) {
+				const firstSpaced = sourceCode.isSpaceBetween(first, second);
+
+				if (options.spaced && !firstSpaced) {
+					reportRequiredBeginningSpace(node, first);
+				}
+				if (!options.spaced && firstSpaced && second.type !== "Line") {
+					reportNoBeginningSpace(node, first);
+				}
+			}
+
+			if (astUtils.isTokenOnSameLine(penultimate, last)) {
+				const shouldCheckPenultimate =
+					(options.arraysInObjectsException &&
+						astUtils.isClosingBracketToken(penultimate)) ||
+					(options.objectsInObjectsException &&
+						astUtils.isClosingBraceToken(penultimate));
+				const penultimateType =
+					shouldCheckPenultimate &&
+					sourceCode.getNodeByRangeIndex(penultimate.range[0]).type;
+
+				const closingCurlyBraceMustBeSpaced =
+					(options.arraysInObjectsException &&
+						penultimateType === "ArrayExpression") ||
+					(options.objectsInObjectsException &&
+						(penultimateType === "ObjectExpression" ||
+							penultimateType === "ObjectPattern"))
+						? !options.spaced
+						: options.spaced;
+
+				const lastSpaced = sourceCode.isSpaceBetween(penultimate, last);
+
+				if (closingCurlyBraceMustBeSpaced && !lastSpaced) {
+					reportRequiredEndingSpace(node, last);
+				}
+				if (!closingCurlyBraceMustBeSpaced && lastSpaced) {
+					reportNoEndingSpace(node, last);
+				}
+			}
+		}
+
+		/**
+		 * Gets '}' token of an object node.
+		 *
+		 * Because the last token of object patterns might be a type annotation,
+		 * this traverses tokens preceded by the last property, then returns the
+		 * first '}' token.
+		 * @param {ASTNode} node The node to get. This node is an
+		 *      ObjectExpression or an ObjectPattern. And this node has one or
+		 *      more properties.
+		 * @returns {Token} '}' token.
+		 */
+		function getClosingBraceOfObject(node) {
+			const lastProperty = node.properties.at(-1);
+
+			return sourceCode.getTokenAfter(
+				lastProperty,
+				astUtils.isClosingBraceToken,
+			);
+		}
+
+		/**
+		 * Reports a given object node if spacing in curly braces is invalid.
+		 * @param {ASTNode} node An ObjectExpression or ObjectPattern node to check.
+		 * @returns {void}
+		 */
+		function checkForObject(node) {
+			if (node.properties.length === 0) {
+				return;
+			}
+
+			const first = sourceCode.getFirstToken(node),
+				last = getClosingBraceOfObject(node),
+				second = sourceCode.getTokenAfter(first, {
+					includeComments: true,
+				}),
+				penultimate = sourceCode.getTokenBefore(last, {
+					includeComments: true,
+				});
+
+			validateBraceSpacing(node, first, second, penultimate, last);
+		}
+
+		/**
+		 * Reports a given import node if spacing in curly braces is invalid.
+		 * @param {ASTNode} node An ImportDeclaration node to check.
+		 * @returns {void}
+		 */
+		function checkForImport(node) {
+			if (node.specifiers.length === 0) {
+				return;
+			}
+
+			let firstSpecifier = node.specifiers[0];
+			const lastSpecifier = node.specifiers.at(-1);
+
+			if (lastSpecifier.type !== "ImportSpecifier") {
+				return;
+			}
+			if (firstSpecifier.type !== "ImportSpecifier") {
+				firstSpecifier = node.specifiers[1];
+			}
+
+			const first = sourceCode.getTokenBefore(firstSpecifier),
+				last = sourceCode.getTokenAfter(
+					lastSpecifier,
+					astUtils.isNotCommaToken,
+				),
+				second = sourceCode.getTokenAfter(first, {
+					includeComments: true,
+				}),
+				penultimate = sourceCode.getTokenBefore(last, {
+					includeComments: true,
+				});
+
+			validateBraceSpacing(node, first, second, penultimate, last);
+		}
+
+		/**
+		 * Reports a given export node if spacing in curly braces is invalid.
+		 * @param {ASTNode} node An ExportNamedDeclaration node to check.
+		 * @returns {void}
+		 */
+		function checkForExport(node) {
+			if (node.specifiers.length === 0) {
+				return;
+			}
+
+			const firstSpecifier = node.specifiers[0],
+				lastSpecifier = node.specifiers.at(-1),
+				first = sourceCode.getTokenBefore(firstSpecifier),
+				last = sourceCode.getTokenAfter(
+					lastSpecifier,
+					astUtils.isNotCommaToken,
+				),
+				second = sourceCode.getTokenAfter(first, {
+					includeComments: true,
+				}),
+				penultimate = sourceCode.getTokenBefore(last, {
+					includeComments: true,
+				});
+
+			validateBraceSpacing(node, first, second, penultimate, last);
+		}
+
+		//--------------------------------------------------------------------------
+		// Public
+		//--------------------------------------------------------------------------
+
+		return {
+			// var {x} = y;
+			ObjectPattern: checkForObject,
+
+			// var y = {x: 'y'}
+			ObjectExpression: checkForObject,
+
+			// import {y} from 'x';
+			ImportDeclaration: checkForImport,
+
+			// export {name} from 'yo';
+			ExportNamedDeclaration: checkForExport,
+		};
+	},
+};

package/lib/rules/object-property-newline.js

@@ -0,0 +1,151 @@
+/**
+ * @fileoverview Rule to enforce placing object properties on separate lines.
+ * @author Vitor Balocco
+ * @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: "object-property-newline",
+						url: "https://eslint.style/rules/object-property-newline",
+					},
+				},
+			],
+		},
+		type: "layout",
+
+		docs: {
+			description: "Enforce placing object properties on separate lines",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/object-property-newline",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					allowAllPropertiesOnSameLine: {
+						type: "boolean",
+						default: false,
+					},
+					allowMultiplePropertiesPerLine: {
+						// Deprecated
+						type: "boolean",
+						default: false,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		fixable: "whitespace",
+
+		messages: {
+			propertiesOnNewlineAll:
+				"Object properties must go on a new line if they aren't all on the same line.",
+			propertiesOnNewline: "Object properties must go on a new line.",
+		},
+	},
+
+	create(context) {
+		const allowSameLine =
+			context.options[0] &&
+			(context.options[0].allowAllPropertiesOnSameLine ||
+				context.options[0]
+					.allowMultiplePropertiesPerLine); /* Deprecated */
+		const messageId = allowSameLine
+			? "propertiesOnNewlineAll"
+			: "propertiesOnNewline";
+
+		const sourceCode = context.sourceCode;
+
+		return {
+			ObjectExpression(node) {
+				if (allowSameLine) {
+					if (node.properties.length > 1) {
+						const firstTokenOfFirstProperty =
+							sourceCode.getFirstToken(node.properties[0]);
+						const lastTokenOfLastProperty = sourceCode.getLastToken(
+							node.properties.at(-1),
+						);
+
+						if (
+							firstTokenOfFirstProperty.loc.end.line ===
+							lastTokenOfLastProperty.loc.start.line
+						) {
+							// All keys and values are on the same line
+							return;
+						}
+					}
+				}
+
+				for (let i = 1; i < node.properties.length; i++) {
+					const lastTokenOfPreviousProperty = sourceCode.getLastToken(
+						node.properties[i - 1],
+					);
+					const firstTokenOfCurrentProperty =
+						sourceCode.getFirstToken(node.properties[i]);
+
+					if (
+						lastTokenOfPreviousProperty.loc.end.line ===
+						firstTokenOfCurrentProperty.loc.start.line
+					) {
+						context.report({
+							node,
+							loc: firstTokenOfCurrentProperty.loc,
+							messageId,
+							fix(fixer) {
+								const comma = sourceCode.getTokenBefore(
+									firstTokenOfCurrentProperty,
+								);
+								const rangeAfterComma = [
+									comma.range[1],
+									firstTokenOfCurrentProperty.range[0],
+								];
+
+								// Don't perform a fix if there are any comments between the comma and the next property.
+								if (
+									sourceCode.text
+										.slice(
+											rangeAfterComma[0],
+											rangeAfterComma[1],
+										)
+										.trim()
+								) {
+									return null;
+								}
+
+								return fixer.replaceTextRange(
+									rangeAfterComma,
+									"\n",
+								);
+							},
+						});
+					}
+				}
+			},
+		};
+	},
+};