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

package/src/rules/overload-signatures-adjacent.ts

@@ -1,7 +1,7 @@
 import { defineRule } from "vite-plus/lint/plugins";
 import type { ESTree, Context, SourceCode } from "vite-plus/lint/plugins";
 
-import { getNextStatement, getRemoveBlankLineFix } from "./blank-line.js";
+import { getNextStatement, getRemoveBlankLineFix } from "./blank-line-utils.js";
 
 function getFunction(node: ESTree.Node): ESTree.Function | null {
   if (node.type === "FunctionDeclaration" || node.type === "TSDeclareFunction") {

package/dist/src/rules/blank-line-after-control-block.d.ts

@@ -1,7 +0,0 @@
-/**
- * 制御ブロックの直後に次の処理がある場合、空行を 1 行以上確保します。
- * 余分な空行は Oxfmt が 1 行に畳みます。
- */
-declare const blankLineAfterControlBlock: import("vite-plus/lint/plugins").Rule;
-export default blankLineAfterControlBlock;
-//# sourceMappingURL=blank-line-after-control-block.d.ts.map

package/dist/src/rules/blank-line-after-control-block.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"blank-line-after-control-block.d.ts","sourceRoot":"","sources":["../../../src/rules/blank-line-after-control-block.ts"],"names":[],"mappings":"AA+BA;;;GAGG;AACH,QAAA,MAAM,0BAA0B,uCA4C9B,CAAC;eAEY,0BAA0B"}

package/dist/src/rules/blank-line-after-control-block.js

@@ -1,54 +0,0 @@
-import { defineRule } from "vite-plus/lint/plugins";
-import { hasBlankLine, getBlankLineFix, getNextStatement, getInsertionTarget, } from "./blank-line.js";
-const CONTROL_STATEMENT_TYPES = new Set([
-    "DoWhileStatement",
-    "ForInStatement",
-    "ForOfStatement",
-    "ForStatement",
-    "IfStatement",
-    "SwitchStatement",
-    "TryStatement",
-    "WhileStatement",
-]);
-/**
- * 制御ブロックの直後に次の処理がある場合、空行を 1 行以上確保します。
- * 余分な空行は Oxfmt が 1 行に畳みます。
- */
-const blankLineAfterControlBlock = defineRule({
-    meta: {
-        docs: {
-            description: "Require a blank line after a control block when another statement follows.",
-        },
-        type: "layout",
-        fixable: "whitespace",
-        messages: {
-            blankLine: "Expected a blank line after a control block when another statement follows.",
-        },
-    },
-    create(context) {
-        const sourceCode = context.sourceCode;
-        function checkNode(node) {
-            const nextStatement = getNextStatement(node);
-            if (nextStatement === null || nextStatement.type === "EmptyStatement") {
-                return;
-            }
-            const target = getInsertionTarget(node, nextStatement, sourceCode);
-            if (hasBlankLine(node, target)) {
-                return;
-            }
-            context.report({
-                fix(fixer) {
-                    return getBlankLineFix(fixer, sourceCode, node, target);
-                },
-                node,
-                messageId: "blankLine",
-            });
-        }
-        const visitors = {};
-        for (const type of CONTROL_STATEMENT_TYPES) {
-            visitors[type] = checkNode;
-        }
-        return visitors;
-    },
-});
-export default blankLineAfterControlBlock;

package/dist/src/rules/blank-line-after-declaration.d.ts

@@ -1,7 +0,0 @@
-/**
- * 関数・クラス・型などの宣言の後に次の文がある場合、空行を 1 行以上確保します。
- * 余分な空行は Oxfmt が 1 行に畳みます。
- */
-declare const blankLineAfterDeclaration: import("vite-plus/lint/plugins").Rule;
-export default blankLineAfterDeclaration;
-//# sourceMappingURL=blank-line-after-declaration.d.ts.map

package/dist/src/rules/blank-line-after-declaration.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"blank-line-after-declaration.d.ts","sourceRoot":"","sources":["../../../src/rules/blank-line-after-declaration.ts"],"names":[],"mappings":"AA2CA;;;GAGG;AACH,QAAA,MAAM,yBAAyB,uCAwD7B,CAAC;eAEY,yBAAyB"}

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

@@ -1,79 +0,0 @@
-import { defineRule } from "vite-plus/lint/plugins";
-import { hasBlankLine, getBlankLineFix, getNextStatement, getInsertionTarget, } from "./blank-line.js";
-const DECLARATION_TYPES = new Set([
-    "ClassDeclaration",
-    "FunctionDeclaration",
-    "TSDeclareFunction",
-    "TSEnumDeclaration",
-    "TSInterfaceDeclaration",
-    "TSModuleDeclaration",
-    "TSTypeAliasDeclaration",
-]);
-function getDeclaration(node) {
-    if (DECLARATION_TYPES.has(node.type)) {
-        return node;
-    }
-    if ((node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") &&
-        node.declaration !== null &&
-        DECLARATION_TYPES.has(node.declaration.type)) {
-        return node.declaration;
-    }
-    return null;
-}
-function isOverload(declaration) {
-    return ((declaration.type === "FunctionDeclaration" || declaration.type === "TSDeclareFunction") &&
-        declaration.body === null);
-}
-/**
- * 関数・クラス・型などの宣言の後に次の文がある場合、空行を 1 行以上確保します。
- * 余分な空行は Oxfmt が 1 行に畳みます。
- */
-const blankLineAfterDeclaration = defineRule({
-    meta: {
-        docs: {
-            description: "Require a blank line after a declaration when another statement follows.",
-        },
-        type: "layout",
-        fixable: "whitespace",
-        messages: {
-            blankLine: "Expected a blank line after a declaration when another statement follows.",
-        },
-    },
-    create(context) {
-        const sourceCode = context.sourceCode;
-        function checkNode(node) {
-            const declaration = getDeclaration(node);
-            if (declaration === null || isOverload(declaration)) {
-                return;
-            }
-            const nextStatement = getNextStatement(node);
-            if (nextStatement === null || nextStatement.type === "EmptyStatement") {
-                return;
-            }
-            const target = getInsertionTarget(node, nextStatement, sourceCode);
-            if (hasBlankLine(node, target)) {
-                return;
-            }
-            context.report({
-                fix(fixer) {
-                    return getBlankLineFix(fixer, sourceCode, node, target);
-                },
-                node,
-                messageId: "blankLine",
-            });
-        }
-        const visitors = {
-            ClassDeclaration: checkNode,
-            TSDeclareFunction: checkNode,
-            TSEnumDeclaration: checkNode,
-            FunctionDeclaration: checkNode,
-            TSModuleDeclaration: checkNode,
-            ExportNamedDeclaration: checkNode,
-            TSInterfaceDeclaration: checkNode,
-            TSTypeAliasDeclaration: checkNode,
-            ExportDefaultDeclaration: checkNode,
-        };
-        return visitors;
-    },
-});
-export default blankLineAfterDeclaration;

package/dist/src/rules/blank-line-after-variable-declaration.d.ts

@@ -1,9 +0,0 @@
-/**
- * 連続する変数宣言の後に別の種類の文が続く場合、空行を 1 行以上確保します。
- *
- * 宣言した変数を使う式文は同じ宣言グループとして扱い、グループ内の空行は削除します。
- * return の直前は blank-line-before-return が担当するため対象外にします。
- */
-declare const blankLineAfterVariableDeclaration: import("vite-plus/lint/plugins").Rule;
-export default blankLineAfterVariableDeclaration;
-//# sourceMappingURL=blank-line-after-variable-declaration.d.ts.map

package/dist/src/rules/blank-line-after-variable-declaration.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"blank-line-after-variable-declaration.d.ts","sourceRoot":"","sources":["../../../src/rules/blank-line-after-variable-declaration.ts"],"names":[],"mappings":"AA8CA;;;;;GAKG;AACH,QAAA,MAAM,iCAAiC,uCA8GrC,CAAC;eAEY,iCAAiC"}

package/dist/src/rules/blank-line-after-variable-declaration.js

@@ -1,118 +0,0 @@
-import { defineRule } from "vite-plus/lint/plugins";
-import { hasBlankLine, getBlankLineFix, getNextStatement, getInsertionTarget, getPreviousStatement, getRemoveBlankLineFix, } from "./blank-line.js";
-function getVariableDeclaration(node) {
-    if (node.type === "VariableDeclaration") {
-        return node;
-    }
-    if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration") {
-        return node.declaration;
-    }
-    return null;
-}
-function isRelatedExpression(statement, variables) {
-    if (statement.type !== "ExpressionStatement") {
-        return false;
-    }
-    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 false;
-}
-/**
- * 連続する変数宣言の後に別の種類の文が続く場合、空行を 1 行以上確保します。
- *
- * 宣言した変数を使う式文は同じ宣言グループとして扱い、グループ内の空行は削除します。
- * return の直前は blank-line-before-return が担当するため対象外にします。
- */
-const blankLineAfterVariableDeclaration = defineRule({
-    meta: {
-        docs: {
-            description: "Require a blank line after a variable declaration group and remove blank lines before related statements.",
-        },
-        type: "layout",
-        fixable: "whitespace",
-        messages: {
-            blankLine: "Expected a blank line after a variable declaration group when another statement follows.",
-            unexpectedBlankLine: "Expected no blank line between a variable declaration and its related statement.",
-        },
-    },
-    create(context) {
-        const sourceCode = context.sourceCode;
-        function checkStatement(node) {
-            const variableDeclaration = getVariableDeclaration(node);
-            if (variableDeclaration === null) {
-                return;
-            }
-            if (node.type === "VariableDeclaration" && node.parent.type === "ExportNamedDeclaration") {
-                return;
-            }
-            const previousStatement = getPreviousStatement(node);
-            if (previousStatement !== null && getVariableDeclaration(previousStatement) !== null) {
-                return;
-            }
-            const variables = new Set(sourceCode.getDeclaredVariables(variableDeclaration));
-            let last = node;
-            let nextStatement = getNextStatement(last);
-            while (nextStatement !== null) {
-                const nextVariableDeclaration = getVariableDeclaration(nextStatement);
-                if (nextVariableDeclaration !== null && getVariableDeclaration(last) !== null) {
-                    for (const variable of sourceCode.getDeclaredVariables(nextVariableDeclaration)) {
-                        variables.add(variable);
-                    }
-                    last = nextStatement;
-                    nextStatement = getNextStatement(last);
-                    continue;
-                }
-                if (nextStatement.type === "ExpressionStatement" &&
-                    isRelatedExpression(nextStatement, variables)) {
-                    const target = getInsertionTarget(last, nextStatement, sourceCode);
-                    if (hasBlankLine(last, target)) {
-                        context.report({
-                            fix(fixer) {
-                                return getRemoveBlankLineFix(fixer, sourceCode, last, target);
-                            },
-                            node: nextStatement,
-                            messageId: "unexpectedBlankLine",
-                        });
-                    }
-                    last = nextStatement;
-                    nextStatement = getNextStatement(last);
-                    continue;
-                }
-                break;
-            }
-            if (nextStatement === null ||
-                nextStatement.type === "EmptyStatement" ||
-                nextStatement.type === "ReturnStatement") {
-                return;
-            }
-            const target = getInsertionTarget(last, nextStatement, sourceCode);
-            if (hasBlankLine(last, target)) {
-                return;
-            }
-            context.report({
-                fix(fixer) {
-                    return getBlankLineFix(fixer, sourceCode, last, target);
-                },
-                node: nextStatement,
-                messageId: "blankLine",
-            });
-        }
-        return {
-            VariableDeclaration(node) {
-                checkStatement(node);
-            },
-            ExportNamedDeclaration(node) {
-                if (node.declaration?.type === "VariableDeclaration") {
-                    checkStatement(node);
-                }
-            },
-        };
-    },
-});
-export default blankLineAfterVariableDeclaration;

package/dist/src/rules/blank-line-before-return.d.ts

@@ -1,7 +0,0 @@
-/**
- * return の直前に処理がある場合、空行を 1 行以上確保します。
- * 余分な空行は Oxfmt が 1 行に畳みます。
- */
-declare const blankLineBeforeReturn: import("vite-plus/lint/plugins").Rule;
-export default blankLineBeforeReturn;
-//# sourceMappingURL=blank-line-before-return.d.ts.map

package/dist/src/rules/blank-line-before-return.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"blank-line-before-return.d.ts","sourceRoot":"","sources":["../../../src/rules/blank-line-before-return.ts"],"names":[],"mappings":"AA2CA;;;GAGG;AACH,QAAA,MAAM,qBAAqB,uCAmDzB,CAAC;eAEY,qBAAqB"}

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

@@ -1,81 +0,0 @@
-import { defineRule } from "vite-plus/lint/plugins";
-import { hasBlankLine, getBlankLineFix, getInsertionTarget, getPreviousStatement, } from "./blank-line.js";
-const SKIP_PREVIOUS_TYPES = new Set([
-    // 制御ブロックは blank-line-after-control-block が担当します。
-    "DoWhileStatement",
-    "ForInStatement",
-    "ForOfStatement",
-    "ForStatement",
-    "IfStatement",
-    "SwitchStatement",
-    "TryStatement",
-    "WhileStatement",
-    // 宣言は blank-line-after-declaration が担当します。
-    "ClassDeclaration",
-    "ExportAllDeclaration",
-    "ExportDefaultDeclaration",
-    "ExportNamedDeclaration",
-    "FunctionDeclaration",
-    "ImportDeclaration",
-    "TSDeclareFunction",
-    "TSEnumDeclaration",
-    "TSInterfaceDeclaration",
-    "TSModuleDeclaration",
-    "TSTypeAliasDeclaration",
-    // 途中で終わる文や空文の後は対象外にします。
-    "BlockStatement",
-    "BreakStatement",
-    "ContinueStatement",
-    "DebuggerStatement",
-    "EmptyStatement",
-    "LabeledStatement",
-    "ReturnStatement",
-    "ThrowStatement",
-    "WithStatement",
-]);
-/**
- * return の直前に処理がある場合、空行を 1 行以上確保します。
- * 余分な空行は Oxfmt が 1 行に畳みます。
- */
-const blankLineBeforeReturn = defineRule({
-    meta: {
-        docs: {
-            description: "Require a blank line before a return statement when another statement precedes it.",
-        },
-        type: "layout",
-        fixable: "whitespace",
-        messages: {
-            blankLine: "Expected a blank line before a return statement when another statement precedes it.",
-        },
-    },
-    create(context) {
-        const sourceCode = context.sourceCode;
-        return {
-            ReturnStatement(node) {
-                const previousStatement = getPreviousStatement(node);
-                if (previousStatement === null) {
-                    return;
-                }
-                if (SKIP_PREVIOUS_TYPES.has(previousStatement.type)) {
-                    return;
-                }
-                if (previousStatement.type === "ExpressionStatement" &&
-                    typeof previousStatement.directive === "string") {
-                    return;
-                }
-                const target = getInsertionTarget(previousStatement, node, sourceCode);
-                if (hasBlankLine(previousStatement, target)) {
-                    return;
-                }
-                context.report({
-                    fix(fixer) {
-                        return getBlankLineFix(fixer, sourceCode, previousStatement, target);
-                    },
-                    node,
-                    messageId: "blankLine",
-                });
-            },
-        };
-    },
-});
-export default blankLineBeforeReturn;

package/dist/src/rules/blank-line-between-class-members.d.ts

@@ -1,8 +0,0 @@
-/**
- * クラスメンバーの間に空行を 1 行以上確保します。
- *
- * オーバーロード署名と getter/setter のペアは連続させます。
- */
-declare const blankLineBetweenClassMembers: import("vite-plus/lint/plugins").Rule;
-export default blankLineBetweenClassMembers;
-//# sourceMappingURL=blank-line-between-class-members.d.ts.map

package/dist/src/rules/blank-line-between-class-members.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"blank-line-between-class-members.d.ts","sourceRoot":"","sources":["../../../src/rules/blank-line-between-class-members.ts"],"names":[],"mappings":"AA2DA;;;;GAIG;AACH,QAAA,MAAM,4BAA4B,uCA6ChC,CAAC;eAEY,4BAA4B"}

package/dist/src/rules/blank-line-between-class-members.js

@@ -1,85 +0,0 @@
-import { defineRule } from "vite-plus/lint/plugins";
-import { hasBlankLine, getBlankLineFix, getInsertionTarget } from "./blank-line.js";
-function getKeyName(member) {
-    if (member.type === "TSIndexSignature" || member.type === "StaticBlock") {
-        return null;
-    }
-    if (member.computed) {
-        return null;
-    }
-    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 isOverload(member) {
-    return member.type === "MethodDefinition" && member.value.body === null;
-}
-function isGetterSetterPair(previous, next) {
-    if (previous.type !== "MethodDefinition" || next.type !== "MethodDefinition") {
-        return false;
-    }
-    if (!((previous.kind === "get" && next.kind === "set") ||
-        (previous.kind === "set" && next.kind === "get"))) {
-        return false;
-    }
-    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 member.decorators[0] ?? member;
-}
-/**
- * クラスメンバーの間に空行を 1 行以上確保します。
- *
- * オーバーロード署名と getter/setter のペアは連続させます。
- */
-const blankLineBetweenClassMembers = defineRule({
-    meta: {
-        docs: {
-            description: "Require a blank line between class members.",
-        },
-        type: "layout",
-        fixable: "whitespace",
-        messages: {
-            blankLine: "Expected a blank line between class members.",
-        },
-    },
-    create(context) {
-        const sourceCode = context.sourceCode;
-        return {
-            ClassBody(node) {
-                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 (isOverload(previous) || isGetterSetterPair(previous, next)) {
-                        continue;
-                    }
-                    const target = getInsertionTarget(previous, getMemberStart(next), sourceCode);
-                    if (hasBlankLine(previous, target)) {
-                        continue;
-                    }
-                    context.report({
-                        fix(fixer) {
-                            return getBlankLineFix(fixer, sourceCode, previous, target);
-                        },
-                        node: next,
-                        messageId: "blankLine",
-                    });
-                }
-            },
-        };
-    },
-});
-export default blankLineBetweenClassMembers;

package/dist/src/rules/blank-line-between-switch-cases.d.ts

@@ -1,8 +0,0 @@
-/**
- * 空でない switch の case の間に空行を 1 行以上確保します。
- *
- * 連続する case はフォールスルーとみなし、対象外にします。
- */
-declare const blankLineBetweenSwitchCases: import("vite-plus/lint/plugins").Rule;
-export default blankLineBetweenSwitchCases;
-//# sourceMappingURL=blank-line-between-switch-cases.d.ts.map

package/dist/src/rules/blank-line-between-switch-cases.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"blank-line-between-switch-cases.d.ts","sourceRoot":"","sources":["../../../src/rules/blank-line-between-switch-cases.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,QAAA,MAAM,2BAA2B,uCAyC/B,CAAC;eAEY,2BAA2B"}

package/dist/src/rules/blank-line-between-switch-cases.js

@@ -1,45 +0,0 @@
-import { defineRule } from "vite-plus/lint/plugins";
-import { hasBlankLine, getBlankLineFix, getInsertionTarget } from "./blank-line.js";
-/**
- * 空でない switch の case の間に空行を 1 行以上確保します。
- *
- * 連続する case はフォールスルーとみなし、対象外にします。
- */
-const blankLineBetweenSwitchCases = defineRule({
-    meta: {
-        docs: {
-            description: "Require a blank line between non-empty switch cases.",
-        },
-        type: "layout",
-        fixable: "whitespace",
-        messages: {
-            blankLine: "Expected a blank line between switch cases.",
-        },
-    },
-    create(context) {
-        const sourceCode = context.sourceCode;
-        return {
-            SwitchStatement(node) {
-                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;
-                    }
-                    const target = getInsertionTarget(previous, next, sourceCode);
-                    if (hasBlankLine(previous, target)) {
-                        continue;
-                    }
-                    context.report({
-                        fix(fixer) {
-                            return getBlankLineFix(fixer, sourceCode, previous, target);
-                        },
-                        node: next,
-                        messageId: "blankLine",
-                    });
-                }
-            },
-        };
-    },
-});
-export default blankLineBetweenSwitchCases;

package/src/rules/blank-line-after-control-block.ts

@@ -1,82 +0,0 @@
-import { defineRule } from "vite-plus/lint/plugins";
-import type { ESTree, Visitor } from "vite-plus/lint/plugins";
-
-import {
-  hasBlankLine,
-  getBlankLineFix,
-  getNextStatement,
-  getInsertionTarget,
-} from "./blank-line.js";
-
-type ControlStatement =
-  | ESTree.DoWhileStatement
-  | ESTree.ForInStatement
-  | ESTree.ForOfStatement
-  | ESTree.ForStatement
-  | ESTree.IfStatement
-  | ESTree.SwitchStatement
-  | ESTree.TryStatement
-  | ESTree.WhileStatement;
-
-const CONTROL_STATEMENT_TYPES: ReadonlySet<ControlStatement["type"]> = new Set([
-  "DoWhileStatement",
-  "ForInStatement",
-  "ForOfStatement",
-  "ForStatement",
-  "IfStatement",
-  "SwitchStatement",
-  "TryStatement",
-  "WhileStatement",
-]);
-
-/**
- * 制御ブロックの直後に次の処理がある場合、空行を 1 行以上確保します。
- * 余分な空行は Oxfmt が 1 行に畳みます。
- */
-const blankLineAfterControlBlock = defineRule({
-  meta: {
-    docs: {
-      description: "Require a blank line after a control block when another statement follows.",
-    },
-    type: "layout",
-    fixable: "whitespace",
-    messages: {
-      blankLine: "Expected a blank line after a control block when another statement follows.",
-    },
-  },
-  create(context) {
-    const sourceCode = context.sourceCode;
-
-    function checkNode(node: ESTree.Node): void {
-      const nextStatement = getNextStatement(node);
-
-      if (nextStatement === null || nextStatement.type === "EmptyStatement") {
-        return;
-      }
-
-      const target = getInsertionTarget(node, nextStatement, sourceCode);
-
-      if (hasBlankLine(node, target)) {
-        return;
-      }
-
-      context.report({
-        fix(fixer) {
-          return getBlankLineFix(fixer, sourceCode, node, target);
-        },
-        node,
-        messageId: "blankLine",
-      });
-    }
-
-    const visitors: Visitor = {};
-
-    for (const type of CONTROL_STATEMENT_TYPES) {
-      visitors[type] = checkNode;
-    }
-
-    return visitors;
-  },
-});
-
-export default blankLineAfterControlBlock;