eslint 9.22.0 → 9.23.0

package/lib/rules/array-bracket-spacing.js

@@ -13,250 +13,289 @@ const astUtils = require("./utils/ast-utils");
 
 /** @type {import('../shared/types').Rule} */
 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: "10.0.0",
-            replacedBy: [
-                {
-                    message: "ESLint Stylistic now maintains deprecated stylistic core rules.",
-                    url: "https://eslint.style/guide/migration",
-                    plugin: {
-                        name: "@stylistic/eslint-plugin-js",
-                        url: "https://eslint.style/packages/js"
-                    },
-                    rule: {
-                        name: "array-bracket-spacing",
-                        url: "https://eslint.style/rules/js/array-bracket-spacing"
-                    }
-                }
-            ]
-        },
-        type: "layout",
+	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: "10.0.0",
+			replacedBy: [
+				{
+					message:
+						"ESLint Stylistic now maintains deprecated stylistic core rules.",
+					url: "https://eslint.style/guide/migration",
+					plugin: {
+						name: "@stylistic/eslint-plugin-js",
+						url: "https://eslint.style/packages/js",
+					},
+					rule: {
+						name: "array-bracket-spacing",
+						url: "https://eslint.style/rules/js/array-bracket-spacing",
+					},
+				},
+			],
+		},
+		type: "layout",
 
-        docs: {
-            description: "Enforce consistent spacing inside array brackets",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/array-bracket-spacing"
-        },
+		docs: {
+			description: "Enforce consistent spacing inside array brackets",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/array-bracket-spacing",
+		},
 
-        fixable: "whitespace",
+		fixable: "whitespace",
 
-        schema: [
-            {
-                enum: ["always", "never"]
-            },
-            {
-                type: "object",
-                properties: {
-                    singleValue: {
-                        type: "boolean"
-                    },
-                    objectsInArrays: {
-                        type: "boolean"
-                    },
-                    arraysInArrays: {
-                        type: "boolean"
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
+		schema: [
+			{
+				enum: ["always", "never"],
+			},
+			{
+				type: "object",
+				properties: {
+					singleValue: {
+						type: "boolean",
+					},
+					objectsInArrays: {
+						type: "boolean",
+					},
+					arraysInArrays: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
 
-        messages: {
-            unexpectedSpaceAfter: "There should be no space after '{{tokenValue}}'.",
-            unexpectedSpaceBefore: "There should be no space before '{{tokenValue}}'.",
-            missingSpaceAfter: "A space is required after '{{tokenValue}}'.",
-            missingSpaceBefore: "A space is required before '{{tokenValue}}'."
-        }
-    },
-    create(context) {
-        const spaced = context.options[0] === "always",
-            sourceCode = context.sourceCode;
+		messages: {
+			unexpectedSpaceAfter:
+				"There should be no space after '{{tokenValue}}'.",
+			unexpectedSpaceBefore:
+				"There should be no space before '{{tokenValue}}'.",
+			missingSpaceAfter: "A space is required after '{{tokenValue}}'.",
+			missingSpaceBefore: "A space is required before '{{tokenValue}}'.",
+		},
+	},
+	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;
-        }
+		/**
+		 * 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,
-            singleElementException: isOptionSet("singleValue"),
-            objectsInArraysException: isOptionSet("objectsInArrays"),
-            arraysInArraysException: isOptionSet("arraysInArrays")
-        };
+		const options = {
+			spaced,
+			singleElementException: isOptionSet("singleValue"),
+			objectsInArraysException: isOptionSet("objectsInArrays"),
+			arraysInArraysException: isOptionSet("arraysInArrays"),
+		};
 
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
+		//--------------------------------------------------------------------------
+		// 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 = sourceCode.getTokenAfter(token);
+		/**
+		 * 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 = sourceCode.getTokenAfter(token);
 
-            context.report({
-                node,
-                loc: { start: token.loc.end, end: nextToken.loc.start },
-                messageId: "unexpectedSpaceAfter",
-                data: {
-                    tokenValue: token.value
-                },
-                fix(fixer) {
-                    return fixer.removeRange([token.range[1], nextToken.range[0]]);
-                }
-            });
-        }
+			context.report({
+				node,
+				loc: { start: token.loc.end, end: nextToken.loc.start },
+				messageId: "unexpectedSpaceAfter",
+				data: {
+					tokenValue: 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 = sourceCode.getTokenBefore(token);
+		/**
+		 * 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 = sourceCode.getTokenBefore(token);
 
-            context.report({
-                node,
-                loc: { start: previousToken.loc.end, end: token.loc.start },
-                messageId: "unexpectedSpaceBefore",
-                data: {
-                    tokenValue: token.value
-                },
-                fix(fixer) {
-                    return fixer.removeRange([previousToken.range[1], token.range[0]]);
-                }
-            });
-        }
+			context.report({
+				node,
+				loc: { start: previousToken.loc.end, end: token.loc.start },
+				messageId: "unexpectedSpaceBefore",
+				data: {
+					tokenValue: 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: "missingSpaceAfter",
-                data: {
-                    tokenValue: token.value
-                },
-                fix(fixer) {
-                    return fixer.insertTextAfter(token, " ");
-                }
-            });
-        }
+		/**
+		 * 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: "missingSpaceAfter",
+				data: {
+					tokenValue: 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: "missingSpaceBefore",
-                data: {
-                    tokenValue: token.value
-                },
-                fix(fixer) {
-                    return fixer.insertTextBefore(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: "missingSpaceBefore",
+				data: {
+					tokenValue: token.value,
+				},
+				fix(fixer) {
+					return fixer.insertTextBefore(token, " ");
+				},
+			});
+		}
 
-        /**
-         * Determines if a node is an object type
-         * @param {ASTNode} node The node to check.
-         * @returns {boolean} Whether or not the node is an object type.
-         */
-        function isObjectType(node) {
-            return node && (node.type === "ObjectExpression" || node.type === "ObjectPattern");
-        }
+		/**
+		 * Determines if a node is an object type
+		 * @param {ASTNode} node The node to check.
+		 * @returns {boolean} Whether or not the node is an object type.
+		 */
+		function isObjectType(node) {
+			return (
+				node &&
+				(node.type === "ObjectExpression" ||
+					node.type === "ObjectPattern")
+			);
+		}
 
-        /**
-         * Determines if a node is an array type
-         * @param {ASTNode} node The node to check.
-         * @returns {boolean} Whether or not the node is an array type.
-         */
-        function isArrayType(node) {
-            return node && (node.type === "ArrayExpression" || node.type === "ArrayPattern");
-        }
+		/**
+		 * Determines if a node is an array type
+		 * @param {ASTNode} node The node to check.
+		 * @returns {boolean} Whether or not the node is an array type.
+		 */
+		function isArrayType(node) {
+			return (
+				node &&
+				(node.type === "ArrayExpression" ||
+					node.type === "ArrayPattern")
+			);
+		}
 
-        /**
-         * Validates the spacing around array brackets
-         * @param {ASTNode} node The node we're checking for spacing
-         * @returns {void}
-         */
-        function validateArraySpacing(node) {
-            if (options.spaced && node.elements.length === 0) {
-                return;
-            }
+		/**
+		 * Validates the spacing around array brackets
+		 * @param {ASTNode} node The node we're checking for spacing
+		 * @returns {void}
+		 */
+		function validateArraySpacing(node) {
+			if (options.spaced && node.elements.length === 0) {
+				return;
+			}
 
-            const first = sourceCode.getFirstToken(node),
-                second = sourceCode.getFirstToken(node, 1),
-                last = node.typeAnnotation
-                    ? sourceCode.getTokenBefore(node.typeAnnotation)
-                    : sourceCode.getLastToken(node),
-                penultimate = sourceCode.getTokenBefore(last),
-                firstElement = node.elements[0],
-                lastElement = node.elements.at(-1);
+			const first = sourceCode.getFirstToken(node),
+				second = sourceCode.getFirstToken(node, 1),
+				last = node.typeAnnotation
+					? sourceCode.getTokenBefore(node.typeAnnotation)
+					: sourceCode.getLastToken(node),
+				penultimate = sourceCode.getTokenBefore(last),
+				firstElement = node.elements[0],
+				lastElement = node.elements.at(-1);
 
-            const openingBracketMustBeSpaced =
-                options.objectsInArraysException && isObjectType(firstElement) ||
-                options.arraysInArraysException && isArrayType(firstElement) ||
-                options.singleElementException && node.elements.length === 1
-                    ? !options.spaced : options.spaced;
+			const openingBracketMustBeSpaced =
+				(options.objectsInArraysException &&
+					isObjectType(firstElement)) ||
+				(options.arraysInArraysException &&
+					isArrayType(firstElement)) ||
+				(options.singleElementException && node.elements.length === 1)
+					? !options.spaced
+					: options.spaced;
 
-            const closingBracketMustBeSpaced =
-                options.objectsInArraysException && isObjectType(lastElement) ||
-                options.arraysInArraysException && isArrayType(lastElement) ||
-                options.singleElementException && node.elements.length === 1
-                    ? !options.spaced : options.spaced;
+			const closingBracketMustBeSpaced =
+				(options.objectsInArraysException &&
+					isObjectType(lastElement)) ||
+				(options.arraysInArraysException && isArrayType(lastElement)) ||
+				(options.singleElementException && node.elements.length === 1)
+					? !options.spaced
+					: options.spaced;
 
-            if (astUtils.isTokenOnSameLine(first, second)) {
-                if (openingBracketMustBeSpaced && !sourceCode.isSpaceBetweenTokens(first, second)) {
-                    reportRequiredBeginningSpace(node, first);
-                }
-                if (!openingBracketMustBeSpaced && sourceCode.isSpaceBetweenTokens(first, second)) {
-                    reportNoBeginningSpace(node, first);
-                }
-            }
+			if (astUtils.isTokenOnSameLine(first, second)) {
+				if (
+					openingBracketMustBeSpaced &&
+					!sourceCode.isSpaceBetweenTokens(first, second)
+				) {
+					reportRequiredBeginningSpace(node, first);
+				}
+				if (
+					!openingBracketMustBeSpaced &&
+					sourceCode.isSpaceBetweenTokens(first, second)
+				) {
+					reportNoBeginningSpace(node, first);
+				}
+			}
 
-            if (first !== penultimate && astUtils.isTokenOnSameLine(penultimate, last)) {
-                if (closingBracketMustBeSpaced && !sourceCode.isSpaceBetweenTokens(penultimate, last)) {
-                    reportRequiredEndingSpace(node, last);
-                }
-                if (!closingBracketMustBeSpaced && sourceCode.isSpaceBetweenTokens(penultimate, last)) {
-                    reportNoEndingSpace(node, last);
-                }
-            }
-        }
+			if (
+				first !== penultimate &&
+				astUtils.isTokenOnSameLine(penultimate, last)
+			) {
+				if (
+					closingBracketMustBeSpaced &&
+					!sourceCode.isSpaceBetweenTokens(penultimate, last)
+				) {
+					reportRequiredEndingSpace(node, last);
+				}
+				if (
+					!closingBracketMustBeSpaced &&
+					sourceCode.isSpaceBetweenTokens(penultimate, last)
+				) {
+					reportNoEndingSpace(node, last);
+				}
+			}
+		}
 
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
+		//--------------------------------------------------------------------------
+		// Public
+		//--------------------------------------------------------------------------
 
-        return {
-            ArrayPattern: validateArraySpacing,
-            ArrayExpression: validateArraySpacing
-        };
-    }
+		return {
+			ArrayPattern: validateArraySpacing,
+			ArrayExpression: validateArraySpacing,
+		};
+	},
 };