eslint-plugin-toml 1.1.2 → 1.2.1

package/lib/index.d.mts

@@ -262,6 +262,7 @@ declare class TOMLSourceCode extends TextSourceCodeBase<{
   getCommentsInside(nodeOrToken: TOMLSyntaxElement): AST.Comment[];
   getCommentsBefore(nodeOrToken: TOMLSyntaxElement): AST.Comment[];
   getCommentsAfter(nodeOrToken: TOMLSyntaxElement): AST.Comment[];
+  commentsExistBetween(first: TOMLSyntaxElement, second: TOMLSyntaxElement): boolean;
   isSpaceBetween(first: AST.Token | AST.Comment, second: AST.Token | AST.Comment): boolean;
   /**
    * Compatibility for ESLint's SourceCode API

package/lib/index.mjs

@@ -1175,6 +1175,58 @@ var indent_default = createRule("indent", {
 
 //#endregion
 //#region src/rules/inline-table-curly-spacing.ts
+/**
+* Parses the options for this rule and returns an object containing the spacing option,
+* the emptyObjects option, and two functions to determine if there should be spaces
+* after the opening curly brace and before the closing curly brace, based on the options and the surrounding tokens.
+* @param options The options passed to the rule.
+* @param sourceCode The source code object, used to get nodes by range index.
+* @returns An object containing the spacing option, the emptyObjects option, and two functions to determine if there should be spaces after the opening curly brace and before the closing curly brace.
+*/
+function parseOptions(options, sourceCode) {
+	const spaced = options[0] ?? "always";
+	/**
+	* 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 option The option to exclude.
+	* @returns Whether or not the property is excluded.
+	*/
+	function isOptionSet(option) {
+		return options[1] ? options[1][option] === (spaced === "never") : false;
+	}
+	const arraysInObjectsException = isOptionSet("arraysInObjects");
+	const objectsInObjectsException = isOptionSet("objectsInObjects");
+	const emptyObjects = options[1]?.emptyObjects ?? "ignore";
+	/**
+	* Determines if there should be a space after the opening curly brace,
+	* based on the spacing option and the second token.
+	* @param spaced The spacing option ("always" or "never").
+	* @param second The second token after the opening curly brace.
+	* @returns Whether or not there should be a space after the opening curly brace.
+	*/
+	function isOpeningCurlyBraceMustBeSpaced(spaced, _second) {
+		return spaced === "always";
+	}
+	/**
+	* Determines if there should be a space before the closing curly brace,
+	* based on the spacing option and the penultimate token.
+	* @param spaced The spacing option ("always" or "never").
+	* @param penultimate The penultimate token before the closing curly brace.
+	* @returns Whether or not there should be a space before the closing curly brace.
+	*/
+	function isClosingCurlyBraceMustBeSpaced(spaced, penultimate) {
+		const targetPenultimateType = arraysInObjectsException && isClosingBracketToken(penultimate) ? "TOMLArray" : objectsInObjectsException && isClosingBraceToken(penultimate) ? "TOMLInlineTable" : null;
+		const node = sourceCode.getNodeByRangeIndex(penultimate.range[0]);
+		return targetPenultimateType && node?.type === targetPenultimateType ? spaced === "never" : spaced === "always";
+	}
+	return {
+		spaced,
+		emptyObjects,
+		isOpeningCurlyBraceMustBeSpaced,
+		isClosingCurlyBraceMustBeSpaced
+	};
+}
 var inline_table_curly_spacing_default = createRule("inline-table-curly-spacing", {
 	meta: {
 		docs: {
@@ -1191,7 +1243,15 @@ var inline_table_curly_spacing_default = createRule("inline-table-curly-spacing"
 			type: "object",
 			properties: {
 				arraysInObjects: { type: "boolean" },
-				objectsInObjects: { type: "boolean" }
+				objectsInObjects: { type: "boolean" },
+				emptyObjects: {
+					type: "string",
+					enum: [
+						"ignore",
+						"always",
+						"never"
+					]
+				}
 			},
 			additionalProperties: false
 		}],
@@ -1199,35 +1259,15 @@ var inline_table_curly_spacing_default = createRule("inline-table-curly-spacing"
 			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}}'."
+			unexpectedSpaceAfter: "There should be no space after '{{token}}'.",
+			requiredSpaceInEmptyObject: "A space is required in empty inline table.",
+			unexpectedSpaceInEmptyObject: "There should be no space in empty inline table."
 		}
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
 		if (!sourceCode.parserServices?.isTOML) return {};
-		const spaced = (context.options[0] || "always") === "always";
-		/**
-		* 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 option The option to exclude.
-		* @returns 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"),
-			isOpeningCurlyBraceMustBeSpaced(_second) {
-				return options.spaced;
-			},
-			isClosingCurlyBraceMustBeSpaced(penultimate) {
-				const targetPenultimateType = options.arraysInObjectsException && isClosingBracketToken(penultimate) ? "TOMLArray" : options.objectsInObjectsException && isClosingBraceToken(penultimate) ? "TOMLInlineTable" : null;
-				return targetPenultimateType && sourceCode.getNodeByRangeIndex(penultimate.range[0])?.type === targetPenultimateType ? !options.spaced : options.spaced;
-			}
-		};
+		const options = parseOptions(context.options, sourceCode);
 		/**
 		* Reports that there shouldn't be a space after the first token
 		* @param node The node to report in the event of an error.
@@ -1308,18 +1348,64 @@ var inline_table_curly_spacing_default = createRule("inline-table-curly-spacing"
 		* @param penultimate The penultimate token to check (should be last before closing brace)
 		* @param last The last token to check (should be closing brace)
 		*/
-		function validateBraceSpacing(node, first, second, penultimate, last) {
-			if (isTokenOnSameLine(first, second)) {
-				const firstSpaced = sourceCode.isSpaceBetween(first, second);
-				if (options.isOpeningCurlyBraceMustBeSpaced(second)) {
-					if (!firstSpaced) reportRequiredBeginningSpace(node, first);
-				} else if (firstSpaced && second.type !== "Block") reportNoBeginningSpace(node, first);
+		function validateBraceSpacing(node, spaced, openingToken, second, penultimate, closingToken) {
+			if (isTokenOnSameLine(openingToken, second)) {
+				const firstSpaced = sourceCode.isSpaceBetween(openingToken, second);
+				if (options.isOpeningCurlyBraceMustBeSpaced(spaced, second)) {
+					if (!firstSpaced) reportRequiredBeginningSpace(node, openingToken);
+				} else if (firstSpaced && second.type !== "Block") reportNoBeginningSpace(node, openingToken);
+			}
+			if (isTokenOnSameLine(penultimate, closingToken)) {
+				const lastSpaced = sourceCode.isSpaceBetween(penultimate, closingToken);
+				if (options.isClosingCurlyBraceMustBeSpaced(spaced, penultimate)) {
+					if (!lastSpaced) reportRequiredEndingSpace(node, closingToken);
+				} else if (lastSpaced) reportNoEndingSpace(node, closingToken);
+			}
+		}
+		/**
+		* Checks spacing in empty objects. Depending on the options, reports
+		* if there is an unexpected space or if there is no space when there should be.
+		* @param node The node to check.
+		*/
+		function checkSpaceInEmptyObject(node) {
+			if (options.emptyObjects === "ignore") return;
+			const openingToken = sourceCode.getFirstToken(node);
+			const closingToken = sourceCode.getLastToken(node);
+			const second = sourceCode.getTokenAfter(openingToken, { includeComments: true });
+			if (second !== closingToken && isCommentToken(second)) {
+				const penultimate = sourceCode.getTokenBefore(closingToken, { includeComments: true });
+				validateBraceSpacing(node, options.emptyObjects, openingToken, second, penultimate, closingToken);
+				return;
 			}
-			if (isTokenOnSameLine(penultimate, last)) {
-				const lastSpaced = sourceCode.isSpaceBetween(penultimate, last);
-				if (options.isClosingCurlyBraceMustBeSpaced(penultimate)) {
-					if (!lastSpaced) reportRequiredEndingSpace(node, last);
-				} else if (lastSpaced) reportNoEndingSpace(node, last);
+			if (!isTokenOnSameLine(openingToken, closingToken)) return;
+			const sourceBetween = sourceCode.text.slice(openingToken.range[1], closingToken.range[0]);
+			if (sourceBetween.trim() !== "") return;
+			if (options.emptyObjects === "always") {
+				if (sourceBetween) return;
+				context.report({
+					node,
+					loc: {
+						start: openingToken.loc.end,
+						end: closingToken.loc.start
+					},
+					messageId: "requiredSpaceInEmptyObject",
+					fix(fixer) {
+						return fixer.replaceTextRange([openingToken.range[1], closingToken.range[0]], " ");
+					}
+				});
+			} else if (options.emptyObjects === "never") {
+				if (!sourceBetween) return;
+				context.report({
+					node,
+					loc: {
+						start: openingToken.loc.end,
+						end: closingToken.loc.start
+					},
+					messageId: "unexpectedSpaceInEmptyObject",
+					fix(fixer) {
+						return fixer.removeRange([openingToken.range[1], closingToken.range[0]]);
+					}
+				});
 			}
 		}
 		/**
@@ -1342,10 +1428,15 @@ var inline_table_curly_spacing_default = createRule("inline-table-curly-spacing"
 		* @param node An ObjectExpression or ObjectPattern node to check.
 		*/
 		function checkForObject(node) {
-			if (node.body.length === 0) return;
-			const first = sourceCode.getFirstToken(node);
-			const last = getClosingBraceOfObject(node);
-			validateBraceSpacing(node, first, sourceCode.getTokenAfter(first, { includeComments: true }), sourceCode.getTokenBefore(last, { includeComments: true }), last);
+			if (node.body.length === 0) {
+				checkSpaceInEmptyObject(node);
+				return;
+			}
+			const openingToken = sourceCode.getFirstToken(node);
+			const closingToken = getClosingBraceOfObject(node);
+			const second = sourceCode.getTokenAfter(openingToken, { includeComments: true });
+			const penultimate = sourceCode.getTokenBefore(closingToken, { includeComments: true });
+			validateBraceSpacing(node, options.spaced, openingToken, second, penultimate, closingToken);
 		}
 		return { TOMLInlineTable: checkForObject };
 	}
@@ -3071,7 +3162,7 @@ var standard_default = [...base_default, { rules: {
 //#endregion
 //#region package.json
 var name$1 = "eslint-plugin-toml";
-var version$1 = "1.1.2";
+var version$1 = "1.2.1";
 
 //#endregion
 //#region src/meta.ts
@@ -3305,6 +3396,9 @@ var TOMLSourceCode = class extends TextSourceCodeBase {
 	getCommentsAfter(nodeOrToken) {
 		return this.tokenStore.getCommentsAfter(nodeOrToken);
 	}
+	commentsExistBetween(first, second) {
+		return this.tokenStore.commentsExistBetween(first, second);
+	}
 	isSpaceBetween(first, second) {
 		const [left, right] = first.range[1] <= second.range[0] ? [first, second] : [second, first];
 		return this.tokenStore.isSpaceBetween(left, right);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-toml",
-  "version": "1.1.2",
+  "version": "1.2.1",
   "description": "This ESLint plugin provides linting rules for TOML.",
   "type": "module",
   "exports": {