@tai-kun/vp-lint-plugins 0.0.3 → 0.0.5

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/merge-imports.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 同じモジュールを指す連続した import 宣言を 1 つにまとめます。
+ *
+ * 別名の default import、namespace import、副作用だけの import、属性が異なる import は安全にまとめられないため対象外にします。コメントが specifier の外側にある場合も、コメントを失わないように対象外にします。
+ */
+declare const mergeImports: import("vite-plus/lint/plugins").Rule;
+export default mergeImports;
+//# sourceMappingURL=merge-imports.d.ts.map

package/dist/src/rules/merge-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-imports.d.ts","sourceRoot":"","sources":["../../../src/rules/merge-imports.ts"],"names":[],"mappings":"AAgOA;;;;GAIG;AACH,QAAA,MAAM,YAAY,uCAqEhB,CAAC;eAEY,YAAY"}