fix: wrong report for object option in jsonc/object-curly-spacing

.changeset/tidy-flowers-push.md

@@ -0,0 +1,5 @@
+---
+"eslint-plugin-jsonc": patch
+---
+
+fix: wrong report for object option in `jsonc/object-curly-spacing`

.eslintrc.js

@@ -22,7 +22,6 @@ module.exports = {
     "@typescript-eslint/no-non-null-assertion": "off",
     "@typescript-eslint/no-explicit-any": "off",
     "no-shadow": "off",
-    complexity: "off",
     "one-var": "off",
     "no-invalid-this": "off",
     // Repo rule

lib/rules/array-bracket-spacing.ts

@@ -78,6 +78,28 @@ export default createRule("array-bracket-spacing", {
       singleElementException: isOptionSet("singleValue"),
       objectsInArraysException: isOptionSet("objectsInArrays"),
       arraysInArraysException: isOptionSet("arraysInArrays"),
+      isOpeningBracketMustBeSpaced(node: AST.JSONArrayExpression) {
+        if (options.singleElementException && node.elements.length === 1) {
+          return !options.spaced;
+        }
+        const firstElement = node.elements[0];
+        return firstElement &&
+          ((options.objectsInArraysException && isObjectType(firstElement)) ||
+            (options.arraysInArraysException && isArrayType(firstElement)))
+          ? !options.spaced
+          : options.spaced;
+      },
+      isClosingBracketMustBeSpaced(node: AST.JSONArrayExpression) {
+        if (options.singleElementException && node.elements.length === 1) {
+          return !options.spaced;
+        }
+        const lastElement = node.elements[node.elements.length - 1];
+        return lastElement &&
+          ((options.objectsInArraysException && isObjectType(lastElement)) ||
+            (options.arraysInArraysException && isArrayType(lastElement)))
+          ? !options.spaced
+          : options.spaced;
+      },
     };
 
     /**
@@ -189,57 +211,25 @@ export default createRule("array-bracket-spacing", {
       const second = sourceCode.getFirstToken(node as any, 1)!;
       const last = sourceCode.getLastToken(node as any)!;
       const penultimate = sourceCode.getTokenBefore(last)!;
-      const firstElement = node.elements[0];
-      const lastElement = node.elements[node.elements.length - 1];
-
-      const openingBracketMustBeSpaced =
-        (firstElement &&
-          options.objectsInArraysException &&
-          isObjectType(firstElement)) ||
-        (firstElement &&
-          options.arraysInArraysException &&
-          isArrayType(firstElement)) ||
-        (options.singleElementException && node.elements.length === 1)
-          ? !options.spaced
-          : options.spaced;
-
-      const closingBracketMustBeSpaced =
-        (lastElement &&
-          options.objectsInArraysException &&
-          isObjectType(lastElement)) ||
-        (lastElement &&
-          options.arraysInArraysException &&
-          isArrayType(lastElement)) ||
-        (options.singleElementException && node.elements.length === 1)
-          ? !options.spaced
-          : options.spaced;
 
       if (isTokenOnSameLine(first, second)) {
-        if (
-          openingBracketMustBeSpaced &&
-          !sourceCode.isSpaceBetweenTokens(first, second)
-        )
-          reportRequiredBeginningSpace(node, first);
-
-        if (
-          !openingBracketMustBeSpaced &&
-          sourceCode.isSpaceBetweenTokens(first, second)
-        )
-          reportNoBeginningSpace(node, first);
+        if (options.isOpeningBracketMustBeSpaced(node)) {
+          if (!sourceCode.isSpaceBetween(first, second))
+            reportRequiredBeginningSpace(node, first);
+        } else {
+          if (sourceCode.isSpaceBetween(first, second))
+            reportNoBeginningSpace(node, first);
+        }
       }
 
       if (first !== penultimate && isTokenOnSameLine(penultimate, last)) {
-        if (
-          closingBracketMustBeSpaced &&
-          !sourceCode.isSpaceBetweenTokens(penultimate, last)
-        )
-          reportRequiredEndingSpace(node, last);
-
-        if (
-          !closingBracketMustBeSpaced &&
-          sourceCode.isSpaceBetweenTokens(penultimate, last)
-        )
-          reportNoEndingSpace(node, last);
+        if (options.isClosingBracketMustBeSpaced(node)) {
+          if (!sourceCode.isSpaceBetween(penultimate, last))
+            reportRequiredEndingSpace(node, last);
+        } else {
+          if (sourceCode.isSpaceBetween(penultimate, last))
+            reportNoEndingSpace(node, last);
+        }
       }
     }
 

lib/rules/object-curly-spacing.ts

@@ -74,6 +74,25 @@ export default createRule("object-curly-spacing", {
       spaced,
       arraysInObjectsException: isOptionSet("arraysInObjects"),
       objectsInObjectsException: isOptionSet("objectsInObjects"),
+      isOpeningCurlyBraceMustBeSpaced(_second: Token | Comment) {
+        return options.spaced;
+      },
+      isClosingCurlyBraceMustBeSpaced(penultimate: Token | Comment) {
+        const targetPenultimateType =
+          options.arraysInObjectsException && isClosingBracketToken(penultimate)
+            ? "JSONArrayExpression"
+            : options.objectsInObjectsException &&
+                isClosingBraceToken(penultimate)
+              ? "JSONObjectExpression"
+              : null;
+        const node = sourceCode.getNodeByRangeIndex(
+          penultimate.range![0],
+        ) as AST.JSONNode | null;
+
+        return targetPenultimateType && node?.type === targetPenultimateType
+          ? !options.spaced
+          : options.spaced;
+      },
     };
 
     /**
@@ -185,47 +204,25 @@ export default createRule("object-curly-spacing", {
       last: Token,
     ) {
       if (isTokenOnSameLine(first, second)) {
-        const firstSpaced = sourceCode.isSpaceBetweenTokens(
-          first,
-          second as Token,
-        );
-
-        if (options.spaced && !firstSpaced)
-          reportRequiredBeginningSpace(node, first);
+        const firstSpaced = sourceCode.isSpaceBetween(first, second as any);
 
-        if (!options.spaced && firstSpaced && second.type !== "Line")
-          reportNoBeginningSpace(node, first);
+        if (options.isOpeningCurlyBraceMustBeSpaced(second)) {
+          if (!firstSpaced) reportRequiredBeginningSpace(node, first);
+        } else {
+          if (firstSpaced && second.type !== "Line") {
+            reportNoBeginningSpace(node, first);
+          }
+        }
       }
 
       if (isTokenOnSameLine(penultimate, last)) {
-        const shouldCheckPenultimate =
-          (options.arraysInObjectsException &&
-            isClosingBracketToken(penultimate)) ||
-          (options.objectsInObjectsException &&
-            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.isSpaceBetweenTokens(
-          penultimate as Token,
-          last,
-        );
-
-        if (closingCurlyBraceMustBeSpaced && !lastSpaced)
-          reportRequiredEndingSpace(node, last);
+        const lastSpaced = sourceCode.isSpaceBetween(penultimate as any, last);
 
-        if (!closingCurlyBraceMustBeSpaced && lastSpaced)
-          reportNoEndingSpace(node, last);
+        if (options.isClosingCurlyBraceMustBeSpaced(penultimate)) {
+          if (!lastSpaced) reportRequiredEndingSpace(node, last);
+        } else {
+          if (lastSpaced) reportNoEndingSpace(node, last);
+        }
       }
     }