@tai-kun/vp-lint-plugins 0.0.4 → 0.0.6

package/dist/src/rules/blank-line.js

@@ -1,86 +1,446 @@
-/**
- * 文の配列を持つ親から、その文が属する配列を取得します。
- */
-function getStatementBody(node) {
-    const { parent } = node;
-    if (parent === null) {
-        return null;
+import { defineRule } from "vite-plus/lint/plugins";
+import { isComment, hasBlankLine, isDocComment, getBlankLineFix, getInsertionTarget, getRemoveBlankLineFix, } from "./_blank-line-utils.js";
+const CONTROL_STATEMENT_TYPES = new Set([
+    "DoWhileStatement",
+    "ForInStatement",
+    "ForOfStatement",
+    "ForStatement",
+    "IfStatement",
+    "SwitchStatement",
+    "TryStatement",
+    "WhileStatement",
+]);
+const DECLARATION_TYPES = new Set([
+    "ClassDeclaration",
+    "FunctionDeclaration",
+    "TSDeclareFunction",
+    "TSEnumDeclaration",
+    "TSInterfaceDeclaration",
+    "TSModuleDeclaration",
+    "TSTypeAliasDeclaration",
+]);
+const SKIP_RETURN_PREVIOUS_TYPES = new Set([
+    // 制御ブロックの後は afterControlBlock が担当するため、ここでは判定しません。
+    "DoWhileStatement",
+    "ForInStatement",
+    "ForOfStatement",
+    "ForStatement",
+    "IfStatement",
+    "SwitchStatement",
+    "TryStatement",
+    "WhileStatement",
+    // 宣言の後は afterDeclaration が担当するため、ここでは判定しません。
+    "ClassDeclaration",
+    "ExportAllDeclaration",
+    "ExportDefaultDeclaration",
+    "ExportNamedDeclaration",
+    "FunctionDeclaration",
+    "ImportDeclaration",
+    "TSDeclareFunction",
+    "TSEnumDeclaration",
+    "TSInterfaceDeclaration",
+    "TSModuleDeclaration",
+    "TSTypeAliasDeclaration",
+    // 途中で終わる文や空文の後は対象外にします。
+    "BlockStatement",
+    "BreakStatement",
+    "ContinueStatement",
+    "DebuggerStatement",
+    "EmptyStatement",
+    "LabeledStatement",
+    "ReturnStatement",
+    "ThrowStatement",
+    "WithStatement",
+]);
+const DEFAULT_OPTIONS = {
+    beforeReturn: true,
+    afterDeclaration: true,
+    afterControlBlock: true,
+    betweenSwitchCases: true,
+    betweenTypeMembers: true,
+    betweenClassMembers: true,
+    afterVariableDeclaration: true,
+};
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getFlag(option, key) {
+    const value = option[key];
+    return value === undefined ? DEFAULT_OPTIONS[key] : value === true;
+}
+function getOptions(options) {
+    const option = options[0];
+    if (!isObject(option)) {
+        return { ...DEFAULT_OPTIONS };
     }
-    if (parent.type === "Program" ||
-        parent.type === "BlockStatement" ||
-        parent.type === "StaticBlock" ||
-        parent.type === "TSModuleBlock") {
-        return parent.body;
+    return {
+        beforeReturn: getFlag(option, "beforeReturn"),
+        afterDeclaration: getFlag(option, "afterDeclaration"),
+        afterControlBlock: getFlag(option, "afterControlBlock"),
+        betweenSwitchCases: getFlag(option, "betweenSwitchCases"),
+        betweenTypeMembers: getFlag(option, "betweenTypeMembers"),
+        betweenClassMembers: getFlag(option, "betweenClassMembers"),
+        afterVariableDeclaration: getFlag(option, "afterVariableDeclaration"),
+    };
+}
+function isControlStatement(node) {
+    return CONTROL_STATEMENT_TYPES.has(node.type);
+}
+function getDeclaration(node) {
+    if (DECLARATION_TYPES.has(node.type)) {
+        return node;
     }
-    if (parent.type === "SwitchCase") {
-        return parent.consequent;
+    if ((node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") &&
+        node.declaration !== null &&
+        DECLARATION_TYPES.has(node.declaration.type)) {
+        return node.declaration;
     }
     return null;
 }
-function getNextStatement(node) {
-    const body = getStatementBody(node);
-    if (body === null) {
-        return null;
+function isOverload(declaration) {
+    return ((declaration.type === "FunctionDeclaration" || declaration.type === "TSDeclareFunction") &&
+        declaration.body === null);
+}
+function getVariableDeclaration(node) {
+    if (node.type === "VariableDeclaration") {
+        return node;
     }
-    const index = body.indexOf(node);
-    if (index === -1 || index === body.length - 1) {
-        return null;
+    if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration") {
+        return node.declaration;
     }
-    return body[index + 1] ?? null;
+    return null;
 }
-function getPreviousStatement(node) {
-    const body = getStatementBody(node);
-    if (body === null) {
-        return null;
+function isRelatedExpression(statement, variables) {
+    if (statement.type !== "ExpressionStatement") {
+        return false;
     }
-    const index = body.indexOf(node);
-    if (index <= 0) {
-        return null;
+    for (const variable of variables) {
+        for (const reference of variable.references) {
+            if (reference.identifier.range[0] >= statement.range[0] &&
+                reference.identifier.range[1] <= statement.range[1]) {
+                return true;
+            }
+        }
     }
-    return body[index - 1] ?? null;
+    return false;
 }
-/**
- * 空行の挿入位置を返します。
- *
- * 次の文に付くコメントがある場合は、そのコメントの前を挿入位置にします。
- * 同じ行の末尾コメントは対象外です。
- */
-function getInsertionTarget(node, nextStatement, sourceCode) {
-    return (sourceCode
-        .getAllComments()
-        .find((comment) => comment.range[0] >= node.range[1] &&
-        comment.range[1] <= nextStatement.range[0] &&
-        comment.loc.start.line > node.loc.end.line) ?? nextStatement);
+function isDirective(node) {
+    return node.type === "ExpressionStatement" && typeof node.directive === "string";
 }
-function hasBlankLine(node, target) {
-    return target.loc.start.line > node.loc.end.line + 1;
-}
-function getBlankLineFix(fixer, sourceCode, node, target) {
-    if (target.loc.start.line === node.loc.end.line) {
-        return fixer.insertTextAfterRange([node.range[1], node.range[1]], "\n\n");
+function getKeyName(member) {
+    if (member.type === "TSIndexSignature" || member.type === "StaticBlock") {
+        return null;
     }
-    const lineEnd = sourceCode.text.indexOf("\n", node.range[1]);
-    if (lineEnd === -1) {
+    if (member.computed) {
         return null;
     }
-    return fixer.insertTextBeforeRange([lineEnd, lineEnd + 1], "\n");
+    const key = member.key;
+    if (key.type === "Identifier") {
+        return key.name;
+    }
+    if (key.type === "Literal" && (typeof key.value === "string" || typeof key.value === "number")) {
+        return String(key.value);
+    }
+    return null;
 }
-/**
- * 指定したノードと対象の間の空行を削除します。
- */
-function getRemoveBlankLineFix(fixer, sourceCode, node, target) {
-    if (target.loc.start.line <= node.loc.end.line + 1) {
-        return null;
+function isOverloadMember(member) {
+    return member.type === "MethodDefinition" && member.value.body === null;
+}
+function isGetterSetterPair(previous, next) {
+    if (previous.type !== "MethodDefinition" || next.type !== "MethodDefinition") {
+        return false;
     }
-    const fromLineEnd = sourceCode.text.indexOf("\n", node.range[1]);
-    if (fromLineEnd === -1) {
-        return null;
+    if (!((previous.kind === "get" && next.kind === "set") ||
+        (previous.kind === "set" && next.kind === "get"))) {
+        return false;
     }
-    const targetLineStart = sourceCode.text.lastIndexOf("\n", target.range[0]) + 1;
-    const indent = sourceCode.text.slice(targetLineStart, target.range[0]);
-    if (indent.trim() !== "") {
-        return null;
+    const previousName = getKeyName(previous);
+    const nextName = getKeyName(next);
+    return previousName !== null && previousName === nextName;
+}
+function getMemberStart(member) {
+    if (member.type === "TSIndexSignature" || member.type === "StaticBlock") {
+        return member;
     }
-    return fixer.replaceTextRange([fromLineEnd, target.range[0]], `\n${indent}`);
+    return member.decorators[0] ?? member;
 }
-export { hasBlankLine, getBlankLineFix, getNextStatement, getInsertionTarget, getPreviousStatement, getRemoveBlankLineFix, };
+/**
+ * 宣言・制御ブロック・変数宣言グループ・return・クラスや型のメンバー・switch の case における空行を、1 つのルールでまとめて扱います。
+ *
+ * 文の境界ごとに該当する項目を 1 つだけ判定するため、複数の診断が同じ箇所で矛盾しません。
+ * 行コメントや通常のブロックコメントを挟む場合、前後の空行は任意とします。
+ */
+const blankLine = defineRule({
+    meta: {
+        docs: {
+            description: "Require blank lines between statements, class members, and switch cases, and above JSDoc-style block comments.",
+        },
+        type: "layout",
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    beforeReturn: { type: "boolean" },
+                    afterDeclaration: { type: "boolean" },
+                    afterControlBlock: { type: "boolean" },
+                    betweenSwitchCases: { type: "boolean" },
+                    betweenTypeMembers: { type: "boolean" },
+                    betweenClassMembers: { type: "boolean" },
+                    afterVariableDeclaration: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        fixable: "whitespace",
+        messages: {
+            blankLine: "Expected a blank line here.",
+            unexpectedBlankLine: "Expected no blank line between a variable declaration and its related statement.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        const options = getOptions(context.options);
+        function requireBlankLine(previous, next, reportNode) {
+            const target = getInsertionTarget(previous, next, sourceCode);
+            // JSDoc 形式のブロックコメントの 1 行上は空行にします。
+            // それ以外のコメントを挟む場合、前後の空行は任意とします。
+            if (isComment(target) && !isDocComment(target)) {
+                return;
+            }
+            if (hasBlankLine(previous, target)) {
+                return;
+            }
+            context.report({
+                fix(fixer) {
+                    return getBlankLineFix(fixer, sourceCode, previous, target);
+                },
+                node: reportNode,
+                messageId: "blankLine",
+            });
+        }
+        /**
+         * 変数宣言グループを収集します。
+         *
+         * 連続する変数宣言と、宣言した変数を使う式文を同じグループとして扱います。
+         * グループ開始でない場合は null を返します。
+         */
+        function collectVariableGroup(body, start) {
+            const first = body[start];
+            if (first === undefined) {
+                return null;
+            }
+            const firstDeclaration = getVariableDeclaration(first);
+            if (firstDeclaration === null) {
+                return null;
+            }
+            const variables = new Set(sourceCode.getDeclaredVariables(firstDeclaration));
+            const statements = [first];
+            let index = start + 1;
+            while (index < body.length) {
+                const next = body[index];
+                if (next === undefined) {
+                    break;
+                }
+                const nextDeclaration = getVariableDeclaration(next);
+                const lastStatement = statements.at(-1);
+                if (nextDeclaration !== null &&
+                    lastStatement !== undefined &&
+                    getVariableDeclaration(lastStatement) !== null) {
+                    for (const variable of sourceCode.getDeclaredVariables(nextDeclaration)) {
+                        variables.add(variable);
+                    }
+                    statements.push(next);
+                    index += 1;
+                    continue;
+                }
+                if (next.type === "ExpressionStatement" && isRelatedExpression(next, variables)) {
+                    statements.push(next);
+                    index += 1;
+                    continue;
+                }
+                break;
+            }
+            return {
+                variables,
+                statements,
+            };
+        }
+        function checkVariableGroupBoundary(last, next) {
+            if (next === undefined || next.type === "EmptyStatement") {
+                return;
+            }
+            if (next.type === "ReturnStatement") {
+                if (options.beforeReturn) {
+                    requireBlankLine(last, next, next);
+                }
+                return;
+            }
+            if (options.afterVariableDeclaration) {
+                requireBlankLine(last, next, next);
+            }
+        }
+        function checkStatementBody(body) {
+            let index = 0;
+            while (index < body.length) {
+                const group = options.afterVariableDeclaration || options.beforeReturn
+                    ? collectVariableGroup(body, index)
+                    : null;
+                if (group !== null) {
+                    if (options.afterVariableDeclaration) {
+                        for (let offset = 0; offset < group.statements.length - 1; offset += 1) {
+                            const previous = group.statements[offset];
+                            const next = group.statements[offset + 1];
+                            if (previous === undefined || next === undefined) {
+                                continue;
+                            }
+                            const target = getInsertionTarget(previous, next, sourceCode);
+                            // JSDoc 形式のブロックコメントの 1 行上は空行にします。
+                            if (isDocComment(target)) {
+                                requireBlankLine(previous, next, next);
+                                continue;
+                            }
+                            // 変数同士の境界は空行の有無を問いません。
+                            if (next.type !== "ExpressionStatement") {
+                                continue;
+                            }
+                            if (isComment(target) || !hasBlankLine(previous, target)) {
+                                continue;
+                            }
+                            context.report({
+                                fix(fixer) {
+                                    return getRemoveBlankLineFix(fixer, sourceCode, previous, target);
+                                },
+                                node: next,
+                                messageId: "unexpectedBlankLine",
+                            });
+                        }
+                    }
+                    const last = group.statements.at(-1);
+                    const next = body[index + group.statements.length];
+                    if (last === undefined) {
+                        index += group.statements.length;
+                        continue;
+                    }
+                    checkVariableGroupBoundary(last, next);
+                    index += group.statements.length;
+                    continue;
+                }
+                const previous = body[index];
+                const next = body[index + 1];
+                if (previous === undefined || next === undefined || next.type === "EmptyStatement") {
+                    index += 1;
+                    continue;
+                }
+                if (isControlStatement(previous)) {
+                    if (options.afterControlBlock) {
+                        requireBlankLine(previous, next, previous);
+                    }
+                    index += 1;
+                    continue;
+                }
+                const declaration = getDeclaration(previous);
+                if (declaration !== null) {
+                    if (!isOverload(declaration) && options.afterDeclaration) {
+                        requireBlankLine(previous, next, previous);
+                    }
+                    index += 1;
+                    continue;
+                }
+                if (next.type === "ReturnStatement") {
+                    if (options.beforeReturn &&
+                        !SKIP_RETURN_PREVIOUS_TYPES.has(previous.type) &&
+                        !isDirective(previous)) {
+                        requireBlankLine(previous, next, next);
+                    }
+                    index += 1;
+                    continue;
+                }
+                index += 1;
+            }
+        }
+        /**
+         * 型や interface のメンバー境界を確認します。
+         *
+         * メンバー間の空行は要求せず、JSDoc 形式のブロックコメントの 1 行上だけ空行を要求します。
+         */
+        function checkTypeMembers(members) {
+            for (let index = 1; index < members.length; index += 1) {
+                const previous = members[index - 1];
+                const next = members[index];
+                if (previous === undefined || next === undefined) {
+                    continue;
+                }
+                const target = getInsertionTarget(previous, next, sourceCode);
+                if (!isDocComment(target) || hasBlankLine(previous, target)) {
+                    continue;
+                }
+                context.report({
+                    fix(fixer) {
+                        return getBlankLineFix(fixer, sourceCode, previous, target);
+                    },
+                    node: next,
+                    messageId: "blankLine",
+                });
+            }
+        }
+        return {
+            Program(node) {
+                checkStatementBody(node.body);
+            },
+            ClassBody(node) {
+                if (!options.betweenClassMembers) {
+                    return;
+                }
+                for (let index = 1; index < node.body.length; index += 1) {
+                    const previous = node.body[index - 1];
+                    const next = node.body[index];
+                    if (previous === undefined || next === undefined) {
+                        continue;
+                    }
+                    if (isOverloadMember(previous) || isGetterSetterPair(previous, next)) {
+                        continue;
+                    }
+                    requireBlankLine(previous, getMemberStart(next), next);
+                }
+            },
+            SwitchCase(node) {
+                checkStatementBody(node.consequent);
+            },
+            StaticBlock(node) {
+                checkStatementBody(node.body);
+            },
+            TSModuleBlock(node) {
+                checkStatementBody(node.body);
+            },
+            TSTypeLiteral(node) {
+                if (!options.betweenTypeMembers) {
+                    return;
+                }
+                checkTypeMembers(node.members);
+            },
+            BlockStatement(node) {
+                checkStatementBody(node.body);
+            },
+            SwitchStatement(node) {
+                if (!options.betweenSwitchCases) {
+                    return;
+                }
+                for (let index = 1; index < node.cases.length; index += 1) {
+                    const previous = node.cases[index - 1];
+                    const next = node.cases[index];
+                    if (previous === undefined || next === undefined || previous.consequent.length === 0) {
+                        continue;
+                    }
+                    requireBlankLine(previous, next, next);
+                }
+            },
+            TSInterfaceBody(node) {
+                if (!options.betweenTypeMembers) {
+                    return;
+                }
+                checkTypeMembers(node.body);
+            },
+        };
+    },
+});
+export default blankLine;

package/dist/src/rules/comment-japanese-spacing.js

@@ -1,5 +1,5 @@
 import { defineRule } from "vite-plus/lint/plugins";
-import { isBlank, isFence, isCodeLike, isDirective, getLineGroupInfos, getCommentLineInfos, } from "./comment-utils.js";
+import { isBlank, isFence, isCodeLike, isDirective, getLineGroupInfos, getCommentLineInfos, } from "./_comment-utils.js";
 const JAPANESE = /^[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\u30FC\uFF66-\uFF9F]$/u;
 const ASCII_BOUNDARY = /^[A-Za-z0-9+#@%/&=$~^|:\\`]$/u;
 const EXCLUDED_PUNCTUATION = new Set(["、", "。", "（", "）", "「", "」"]);

package/dist/src/rules/comment-one-sentence-per-line.d.ts

@@ -1,7 +1,7 @@
 /**
  * コメントを 1 行 1 文にします。
  *
- * 複数行のコメントで、文の途中（「、」など）で改行している箇所を検出し、次の行と結合します。文末は「。」「．」「.」「!」「?」などを判定します。
+ * 複数行のコメントで、文の途中（「、」など）で改行している箇所を検出し、次の行と結合します。文末は「。」「．」「.」「!」「?」「:」「：」などを判定します。
  * `requireEndPunctuation` を有効にすると、文末の句読点がない散文行も報告します。
  */
 declare const commentOneSentencePerLine: import("vite-plus/lint/plugins").Rule;

package/dist/src/rules/comment-one-sentence-per-line.js

@@ -1,5 +1,5 @@
 import { defineRule } from "vite-plus/lint/plugins";
-import { isTag, isBlank, isFence, isCodeLike, isDirective, isLabelLine, isSentenceEnd, isListOrHeading, getLineGroupInfos, getCommentLineInfos, isSkippableProseLine, } from "./comment-utils.js";
+import { isTag, isBlank, isFence, isCodeLike, isDirective, isLabelLine, isSentenceEnd, isListOrHeading, getLineGroupInfos, getCommentLineInfos, isSkippableProseLine, } from "./_comment-utils.js";
 function needsSpace(left, right) {
     const leftIsAscii = /[A-Za-z0-9`)]$/u.test(left);
     const leftIsWord = /[\p{L}\p{N}]$/u.test(left);
@@ -102,7 +102,7 @@ function collectDiagnostics(infos, requireEndPunctuation) {
 /**
  * コメントを 1 行 1 文にします。
  *
- * 複数行のコメントで、文の途中（「、」など）で改行している箇所を検出し、次の行と結合します。文末は「。」「．」「.」「!」「?」などを判定します。
+ * 複数行のコメントで、文の途中（「、」など）で改行している箇所を検出し、次の行と結合します。文末は「。」「．」「.」「!」「?」「:」「：」などを判定します。
  * `requireEndPunctuation` を有効にすると、文末の句読点がない散文行も報告します。
  */
 const commentOneSentencePerLine = defineRule({

package/dist/src/rules/jsdoc-param-order.js

@@ -1,5 +1,5 @@
 import { defineRule } from "vite-plus/lint/plugins";
-import { getNodeJSDoc, getParamName, getJSDocLines, hasExampleOrFence } from "./jsdoc-utils.js";
+import { getNodeJSDoc, getParamName, getJSDocLines, hasExampleOrFence } from "./_jsdoc-utils.js";
 function getParamNameFromPattern(param) {
     if (param.type === "Identifier") {
         return param.name;

package/dist/src/rules/jsdoc-tag-lines.js

@@ -1,5 +1,5 @@
 import { defineRule } from "vite-plus/lint/plugins";
-import { getJSDocLines, hasExampleOrFence } from "./jsdoc-utils.js";
+import { getJSDocLines, hasExampleOrFence } from "./_jsdoc-utils.js";
 function getBlankPrefix(line) {
     return line.prefix.trimEnd();
 }

package/dist/src/rules/jsdoc-tag-order.js

@@ -1,5 +1,5 @@
 import { defineRule } from "vite-plus/lint/plugins";
-import { getJSDocLines, hasExampleOrFence } from "./jsdoc-utils.js";
+import { getJSDocLines, hasExampleOrFence } from "./_jsdoc-utils.js";
 const TAG_ORDER = {
     see: 70,
     beta: 65,

package/dist/src/rules/object-properties-newline.d.ts

@@ -1,8 +1,9 @@
 /**
- * プロパティーが 2 つ以上あるオブジェクトリテラルを複数行にします。
+ * プロパティーが 2 つ以上あるオブジェクトリテラルと JSON オブジェクトを複数行にします。
  *
  * Oxfmt の `objectWrap` には「プロパティー数で改行を強制する」オプションがないため、改行を挿入する最小限の fix を提供します。
  * `objectWrap: "preserve"` と組み合わせることで、後続の Oxfmt がプロパティーごとの改行とインデントを整えます。
+ * JSON (`JSONObjectExpression`) も同じ fix で複数行化します。
  */
 declare const objectPropertiesNewline: import("vite-plus/lint/plugins").Rule;
 export default objectPropertiesNewline;

package/dist/src/rules/object-properties-newline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"object-properties-newline.d.ts","sourceRoot":"","sources":["../../../src/rules/object-properties-newline.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,QAAA,MAAM,uBAAuB,uCAyC3B,CAAC;eAEY,uBAAuB"}
+{"version":3,"file":"object-properties-newline.d.ts","sourceRoot":"","sources":["../../../src/rules/object-properties-newline.ts"],"names":[],"mappings":"AA2EA;;;;;;GAMG;AACH,QAAA,MAAM,uBAAuB,uCAoD3B,CAAC;eAEY,uBAAuB"}

package/dist/src/rules/object-properties-newline.js

@@ -1,15 +1,35 @@
 import { defineRule } from "vite-plus/lint/plugins";
-import { getSortPlan } from "./object-sort-utils.js";
+import { getSortPlan } from "./_object-sort-utils.js";
 /**
- * プロパティーが 2 つ以上あるオブジェクトリテラルを複数行にします。
+ * 複数行にすべき 1 行オブジェクトかどうかを判定します。
+ *
+ * プロパティーが 2 つ以上あり、最初のプロパティーが `{` と同じ行にある場合に `true` を返します。
+ *
+ * @param node 判定対象のオブジェクトです。
+ *
+ * @returns 複数行にすべき場合に `true` です。
+ */
+function needsMultiline(node) {
+    if (node.properties.length < 2) {
+        return false;
+    }
+    const firstProperty = node.properties[0];
+    if (firstProperty === undefined) {
+        return false;
+    }
+    return firstProperty.loc.start.line === node.loc.start.line;
+}
+/**
+ * プロパティーが 2 つ以上あるオブジェクトリテラルと JSON オブジェクトを複数行にします。
  *
  * Oxfmt の `objectWrap` には「プロパティー数で改行を強制する」オプションがないため、改行を挿入する最小限の fix を提供します。
  * `objectWrap: "preserve"` と組み合わせることで、後続の Oxfmt がプロパティーごとの改行とインデントを整えます。
+ * JSON (`JSONObjectExpression`) も同じ fix で複数行化します。
  */
 const objectPropertiesNewline = defineRule({
     meta: {
         docs: {
-            description: "Enforce multiline object literals when they have two or more properties.",
+            description: "Enforce multiline objects when they have two or more properties.",
         },
         type: "layout",
         fixable: "whitespace",
@@ -20,16 +40,12 @@ const objectPropertiesNewline = defineRule({
     create(context) {
         return {
             ObjectExpression(node) {
-                if (node.properties.length < 2) {
-                    return;
-                }
                 // 並び替え可能なオブジェクトは sort-object-properties が複数行化も担当します。
                 if (getSortPlan(node, context.sourceCode) !== null) {
                     return;
                 }
                 // Oxfmt は `{` の直後に改行があるかどうかで複数行を維持するため、最初のプロパティーが `{` と同じ行にある場合だけを対象にします。
-                const firstProperty = node.properties[0];
-                if (firstProperty === undefined || firstProperty.loc.start.line !== node.loc.start.line) {
+                if (!needsMultiline(node)) {
                     return;
                 }
                 context.report({
@@ -41,6 +57,21 @@ const objectPropertiesNewline = defineRule({
                     messageId: "multiline",
                 });
             },
+            JSONObjectExpression(node) {
+                const target = node;
+                if (!needsMultiline(target)) {
+                    return;
+                }
+                context.report({
+                    fix(fixer) {
+                        // JSON も `objectWrap: "preserve"` で整形されるため、JS と同じく `{` の直後に改行を 1 つ挿入するだけで十分です。
+                        return fixer.insertTextAfterRange([target.range[0], target.range[0] + 1], "\n");
+                    },
+                    // `JSONObjectExpression` は `VisitorObject` の既定の型に含まれないため、報告時は `node` をそのまま渡します。
+                    node: node,
+                    messageId: "multiline",
+                });
+            },
         };
     },
 });