@tai-kun/vp-lint-plugins 0.0.0 → 0.0.1

package/src/plugin.ts

@@ -0,0 +1,48 @@
+import { definePlugin } from "vite-plus/lint/plugins";
+
+import blankLineAfterControlBlock from "./rules/blank-line-after-control-block.js";
+import blankLineAfterDeclaration from "./rules/blank-line-after-declaration.js";
+import blankLineAfterVariableDeclaration from "./rules/blank-line-after-variable-declaration.js";
+import blankLineBeforeReturn from "./rules/blank-line-before-return.js";
+import blankLineBetweenClassMembers from "./rules/blank-line-between-class-members.js";
+import blankLineBetweenSwitchCases from "./rules/blank-line-between-switch-cases.js";
+import commentJapaneseSpacing from "./rules/comment-japanese-spacing.js";
+import commentOneSentencePerLine from "./rules/comment-one-sentence-per-line.js";
+import jsdocParamOrder from "./rules/jsdoc-param-order.js";
+import jsdocTagLines from "./rules/jsdoc-tag-lines.js";
+import jsdocTagOrder from "./rules/jsdoc-tag-order.js";
+import memberOrdering from "./rules/member-ordering.js";
+import objectPropertiesNewline from "./rules/object-properties-newline.js";
+import overloadSignaturesAdjacent from "./rules/overload-signatures-adjacent.js";
+import sortImportExportSpecifiers from "./rules/sort-import-export-specifiers.js";
+import sortJsxProps from "./rules/sort-jsx-props.js";
+import sortObjectProperties from "./rules/sort-object-properties.js";
+import sortTypeMembers from "./rules/sort-type-members.js";
+import spacedComment from "./rules/spaced-comment.js";
+import typeLiteralPropertiesNewline from "./rules/type-literal-properties-newline.js";
+
+export default definePlugin({
+  meta: { name: "tai-kun" },
+  rules: {
+    "sort-jsx-props": sortJsxProps,
+    "spaced-comment": spacedComment,
+    "jsdoc-tag-lines": jsdocTagLines,
+    "jsdoc-tag-order": jsdocTagOrder,
+    "member-ordering": memberOrdering,
+    "jsdoc-param-order": jsdocParamOrder,
+    "sort-type-members": sortTypeMembers,
+    "sort-object-properties": sortObjectProperties,
+    "blank-line-before-return": blankLineBeforeReturn,
+    "comment-japanese-spacing": commentJapaneseSpacing,
+    "object-properties-newline": objectPropertiesNewline,
+    "blank-line-after-declaration": blankLineAfterDeclaration,
+    "overload-signatures-adjacent": overloadSignaturesAdjacent,
+    "comment-one-sentence-per-line": commentOneSentencePerLine,
+    "sort-import-export-specifiers": sortImportExportSpecifiers,
+    "blank-line-after-control-block": blankLineAfterControlBlock,
+    "blank-line-between-switch-cases": blankLineBetweenSwitchCases,
+    "type-literal-properties-newline": typeLiteralPropertiesNewline,
+    "blank-line-between-class-members": blankLineBetweenClassMembers,
+    "blank-line-after-variable-declaration": blankLineAfterVariableDeclaration,
+  },
+});

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

@@ -0,0 +1,82 @@
+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;

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

@@ -0,0 +1,106 @@
+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";
+
+const DECLARATION_TYPES: ReadonlySet<string> = new Set([
+  "ClassDeclaration",
+  "FunctionDeclaration",
+  "TSDeclareFunction",
+  "TSEnumDeclaration",
+  "TSInterfaceDeclaration",
+  "TSModuleDeclaration",
+  "TSTypeAliasDeclaration",
+]);
+
+function getDeclaration(node: ESTree.Node): ESTree.Node | null {
+  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: ESTree.Node): boolean {
+  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: ESTree.Node): void {
+      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: Visitor = {
+      ClassDeclaration: checkNode,
+      TSDeclareFunction: checkNode,
+      TSEnumDeclaration: checkNode,
+      FunctionDeclaration: checkNode,
+      TSModuleDeclaration: checkNode,
+      ExportNamedDeclaration: checkNode,
+      TSInterfaceDeclaration: checkNode,
+      TSTypeAliasDeclaration: checkNode,
+      ExportDefaultDeclaration: checkNode,
+    };
+
+    return visitors;
+  },
+});
+
+export default blankLineAfterDeclaration;

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

@@ -0,0 +1,84 @@
+import { defineRule } from "vite-plus/lint/plugins";
+import type { ESTree } from "vite-plus/lint/plugins";
+
+import {
+  hasBlankLine,
+  getBlankLineFix,
+  getNextStatement,
+  getInsertionTarget,
+} from "./blank-line.js";
+
+function isVariableDeclarationStatement(node: ESTree.Node): boolean {
+  if (node.type === "VariableDeclaration") {
+    return true;
+  }
+
+  return node.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration";
+}
+
+/**
+ * 連続する変数宣言の後に別の種類の文が続く場合、空行を 1 行以上確保します。
+ *
+ * return の直前は blank-line-before-return が担当するため対象外にします。
+ */
+const blankLineAfterVariableDeclaration = defineRule({
+  meta: {
+    docs: {
+      description:
+        "Require a blank line after a variable declaration group when another statement follows.",
+    },
+    type: "layout",
+    fixable: "whitespace",
+    messages: {
+      blankLine:
+        "Expected a blank line after a variable declaration group when another statement follows.",
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    function checkStatement(node: ESTree.Node): void {
+      if (node.type === "VariableDeclaration" && node.parent.type === "ExportNamedDeclaration") {
+        return;
+      }
+
+      const nextStatement = getNextStatement(node);
+
+      if (
+        nextStatement === null ||
+        nextStatement.type === "EmptyStatement" ||
+        nextStatement.type === "ReturnStatement" ||
+        isVariableDeclarationStatement(nextStatement)
+      ) {
+        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",
+      });
+    }
+
+    return {
+      VariableDeclaration(node): void {
+        checkStatement(node);
+      },
+      ExportNamedDeclaration(node): void {
+        if (node.declaration?.type === "VariableDeclaration") {
+          checkStatement(node);
+        }
+      },
+    };
+  },
+});
+
+export default blankLineAfterVariableDeclaration;

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

@@ -0,0 +1,101 @@
+import { defineRule } from "vite-plus/lint/plugins";
+
+import {
+  hasBlankLine,
+  getBlankLineFix,
+  getInsertionTarget,
+  getPreviousStatement,
+} from "./blank-line.js";
+
+const SKIP_PREVIOUS_TYPES: ReadonlySet<string> = 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): void {
+        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/src/rules/blank-line-between-class-members.ts

@@ -0,0 +1,112 @@
+import { defineRule } from "vite-plus/lint/plugins";
+import type { ESTree } from "vite-plus/lint/plugins";
+
+import { hasBlankLine, getBlankLineFix, getInsertionTarget } from "./blank-line.js";
+
+function getKeyName(member: ESTree.ClassElement): string | null {
+  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: ESTree.ClassElement): boolean {
+  return member.type === "MethodDefinition" && member.value.body === null;
+}
+
+function isGetterSetterPair(previous: ESTree.ClassElement, next: ESTree.ClassElement): boolean {
+  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: ESTree.ClassElement): ESTree.ClassElement | ESTree.Decorator {
+  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): void {
+        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/src/rules/blank-line-between-switch-cases.ts

@@ -0,0 +1,53 @@
+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): void {
+        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.ts

@@ -0,0 +1,113 @@
+import type { Fix, Fixer, ESTree, Comment, SourceCode } from "vite-plus/lint/plugins";
+
+/**
+ * 文の配列を持つ親から、その文が属する配列を取得します。
+ */
+function getStatementBody(node: ESTree.Node): readonly ESTree.Node[] | null {
+  const { parent } = node;
+
+  if (parent === null) {
+    return null;
+  }
+
+  if (
+    parent.type === "Program" ||
+    parent.type === "BlockStatement" ||
+    parent.type === "StaticBlock" ||
+    parent.type === "TSModuleBlock"
+  ) {
+    return parent.body;
+  }
+
+  if (parent.type === "SwitchCase") {
+    return parent.consequent;
+  }
+
+  return null;
+}
+
+function getNextStatement(node: ESTree.Node): ESTree.Node | null {
+  const body = getStatementBody(node);
+
+  if (body === null) {
+    return null;
+  }
+
+  const index = body.indexOf(node);
+
+  if (index === -1 || index === body.length - 1) {
+    return null;
+  }
+
+  return body[index + 1] ?? null;
+}
+
+function getPreviousStatement(node: ESTree.Node): ESTree.Node | null {
+  const body = getStatementBody(node);
+
+  if (body === null) {
+    return null;
+  }
+
+  const index = body.indexOf(node);
+
+  if (index <= 0) {
+    return null;
+  }
+
+  return body[index - 1] ?? null;
+}
+
+/**
+ * 空行の挿入位置を返します。
+ *
+ * 次の文に付くコメントがある場合は、そのコメントの前を挿入位置にします。
+ * 同じ行の末尾コメントは対象外です。
+ */
+function getInsertionTarget(
+  node: ESTree.Node,
+  nextStatement: ESTree.Node,
+  sourceCode: SourceCode,
+): ESTree.Node | Comment {
+  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 hasBlankLine(node: ESTree.Node, target: ESTree.Node | Comment): boolean {
+  return target.loc.start.line > node.loc.end.line + 1;
+}
+
+function getBlankLineFix(
+  fixer: Fixer,
+  sourceCode: SourceCode,
+  node: ESTree.Node,
+  target: ESTree.Node | Comment,
+): Fix | null {
+  if (target.loc.start.line === node.loc.end.line) {
+    return fixer.insertTextAfterRange([node.range[1], node.range[1]], "\n\n");
+  }
+
+  const lineEnd = sourceCode.text.indexOf("\n", node.range[1]);
+
+  if (lineEnd === -1) {
+    return null;
+  }
+
+  return fixer.insertTextBeforeRange([lineEnd, lineEnd + 1], "\n");
+}
+
+export {
+  hasBlankLine,
+  getBlankLineFix,
+  getNextStatement,
+  getInsertionTarget,
+  getPreviousStatement,
+};