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

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

@@ -0,0 +1,204 @@
+import { defineRule } from "vite-plus/lint/plugins";
+import type { Fix, Fixer, ESTree, Context, SourceCode } from "vite-plus/lint/plugins";
+
+import { getNextStatement } from "./blank-line.js";
+
+function getFunction(node: ESTree.Node): ESTree.Function | null {
+  if (node.type === "FunctionDeclaration" || node.type === "TSDeclareFunction") {
+    return node;
+  }
+
+  if (node.type === "ExportNamedDeclaration" && node.declaration !== null) {
+    const declaration = node.declaration;
+
+    if (declaration.type === "FunctionDeclaration" || declaration.type === "TSDeclareFunction") {
+      return declaration;
+    }
+  }
+
+  return null;
+}
+
+function getKeyName(node: ESTree.MethodDefinition): string | null {
+  if (node.computed) {
+    return null;
+  }
+
+  const key = node.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 getRemoveBlankLinesFix(
+  fixer: Fixer,
+  sourceCode: SourceCode,
+  previous: ESTree.Node,
+  next: ESTree.Node,
+): Fix | null {
+  if (next.loc.start.line <= previous.loc.end.line + 1) {
+    return null;
+  }
+
+  const fromLineEnd = sourceCode.text.indexOf("\n", previous.range[1]);
+
+  if (fromLineEnd === -1) {
+    return null;
+  }
+
+  const nextLineStart = sourceCode.text.lastIndexOf("\n", next.range[0]) + 1;
+  const indent = sourceCode.text.slice(nextLineStart, next.range[0]);
+
+  if (indent.trim() !== "") {
+    return null;
+  }
+
+  return fixer.replaceTextRange([fromLineEnd, next.range[0]], `\n${indent}`);
+}
+
+function hasCommentBetween(
+  sourceCode: SourceCode,
+  previous: ESTree.Node,
+  next: ESTree.Node,
+): boolean {
+  return sourceCode
+    .getAllComments()
+    .some((comment) => comment.range[0] >= previous.range[1] && comment.range[1] <= next.range[0]);
+}
+
+function reportIfSeparated(
+  context: Context,
+  sourceCode: SourceCode,
+  previous: ESTree.Node,
+  next: ESTree.Node,
+): void {
+  if (
+    next.loc.start.line <= previous.loc.end.line + 1 ||
+    hasCommentBetween(sourceCode, previous, next)
+  ) {
+    return;
+  }
+
+  context.report({
+    fix(fixer) {
+      return getRemoveBlankLinesFix(fixer, sourceCode, previous, next);
+    },
+    node: next,
+    messageId: "adjacent",
+  });
+}
+
+/**
+ * オーバーロード署名と実装の間に空行を入れないようにします。
+ */
+const overloadSignaturesAdjacent = defineRule({
+  meta: {
+    docs: {
+      description: "Require overload signatures and their implementation to be adjacent.",
+    },
+    type: "layout",
+    fixable: "whitespace",
+    messages: {
+      adjacent: "Overload signatures must be adjacent to each other and to the implementation.",
+    },
+  },
+  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 ||
+            previous.type !== "MethodDefinition" ||
+            previous.value.body !== null ||
+            next.type !== "MethodDefinition"
+          ) {
+            continue;
+          }
+
+          const previousName = getKeyName(previous);
+          const nextName = getKeyName(next);
+
+          if (previousName === null || previousName !== nextName) {
+            continue;
+          }
+
+          reportIfSeparated(context, sourceCode, previous, next);
+        }
+      },
+      TSDeclareFunction(node): void {
+        if (node.body !== null) {
+          return;
+        }
+
+        const nextStatement = getNextStatement(node);
+
+        if (nextStatement === null) {
+          return;
+        }
+
+        const nextFunction = getFunction(nextStatement);
+
+        if (nextFunction === null || nextFunction.id?.name !== node.id?.name) {
+          return;
+        }
+
+        reportIfSeparated(context, sourceCode, node, nextStatement);
+      },
+      FunctionDeclaration(node): void {
+        if (node.body !== null) {
+          return;
+        }
+
+        const nextStatement = getNextStatement(node);
+
+        if (nextStatement === null) {
+          return;
+        }
+
+        const nextFunction = getFunction(nextStatement);
+
+        if (nextFunction === null || nextFunction.id?.name !== node.id?.name) {
+          return;
+        }
+
+        reportIfSeparated(context, sourceCode, node, nextStatement);
+      },
+      ExportNamedDeclaration(node): void {
+        const currentFunction = getFunction(node);
+
+        if (currentFunction === null || currentFunction.body !== null) {
+          return;
+        }
+
+        const nextStatement = getNextStatement(node);
+
+        if (nextStatement === null) {
+          return;
+        }
+
+        const nextFunction = getFunction(nextStatement);
+
+        if (nextFunction === null || nextFunction.id?.name !== currentFunction.id?.name) {
+          return;
+        }
+
+        reportIfSeparated(context, sourceCode, node, nextStatement);
+      },
+    };
+  },
+});
+
+export default overloadSignaturesAdjacent;

package/src/rules/sort-import-export-specifiers.ts

@@ -0,0 +1,194 @@
+import { defineRule } from "vite-plus/lint/plugins";
+import type { ESTree, SourceCode } from "vite-plus/lint/plugins";
+
+import { compareNames } from "./object-sort-utils.js";
+
+interface SpecifierUnit {
+  group: number;
+  name: string;
+  text: string;
+}
+
+function getSpecifierName(node: ESTree.ModuleExportName): string | null {
+  if (node.type === "Identifier") {
+    return node.name;
+  }
+
+  if (node.type === "Literal") {
+    return node.value;
+  }
+
+  return null;
+}
+
+function getLineIndent(source: string, offset: number): string {
+  const lineStart = source.lastIndexOf("\n", offset) + 1;
+  const match = /^[ \t]*/u.exec(source.slice(lineStart, offset));
+
+  return match?.[0] ?? "";
+}
+
+function hasUnsafeComment(
+  node: ESTree.Node,
+  specifiers: readonly ESTree.Node[],
+  sourceCode: SourceCode,
+): boolean {
+  const comments = sourceCode
+    .getAllComments()
+    .filter((comment) => comment.range[0] >= node.range[0] && comment.range[1] <= node.range[1]);
+
+  return comments.some(
+    (comment) =>
+      !specifiers.some(
+        (specifier) =>
+          comment.range[0] >= specifier.range[0] && comment.range[1] <= specifier.range[1],
+      ),
+  );
+}
+
+function buildReplacement(
+  units: readonly SpecifierUnit[],
+  sourceCode: SourceCode,
+  first: ESTree.Node,
+  last: ESTree.Node,
+): string | null {
+  const sorted = [...units].sort((left, right) => {
+    if (left.group !== right.group) {
+      return left.group - right.group;
+    }
+
+    return compareNames(left.name, right.name);
+  });
+
+  if (sorted.every((unit, index) => unit === units[index])) {
+    return null;
+  }
+
+  const multiline = first.loc.start.line !== last.loc.end.line;
+  const separator = multiline ? `,\n${getLineIndent(sourceCode.text, first.range[0])}` : ", ";
+
+  return sorted.map((unit) => unit.text).join(separator);
+}
+
+/**
+ * import / export の波括弧内の specifier を並べます。
+ *
+ * 「型 → 変数など → default」のグループ順で、各グループ内は名前の長さが短い順、同じ長さなら名前順です。
+ */
+const sortImportExportSpecifiers = defineRule({
+  meta: {
+    docs: {
+      description:
+        "Sort import and export specifiers by group (type, value, default), then by name length and name.",
+    },
+    type: "layout",
+    fixable: "whitespace",
+    messages: {
+      sort: "Import/export specifiers must be sorted by group, name length, then name.",
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    function reportSort(
+      node: ESTree.Node,
+      specifiers: readonly ESTree.Node[],
+      units: readonly SpecifierUnit[],
+    ): void {
+      const first = specifiers[0];
+      const last = specifiers.at(-1);
+
+      if (first === undefined || last === undefined) {
+        return;
+      }
+
+      const replacement = buildReplacement(units, sourceCode, first, last);
+
+      if (replacement === null) {
+        return;
+      }
+
+      context.report({
+        fix(fixer) {
+          return fixer.replaceTextRange([first.range[0], last.range[1]], replacement);
+        },
+        node,
+        messageId: "sort",
+      });
+    }
+
+    return {
+      ImportDeclaration(node): void {
+        const specifiers = node.specifiers.filter(
+          (specifier): specifier is ESTree.ImportSpecifier => specifier.type === "ImportSpecifier",
+        );
+
+        if (specifiers.length < 2 || hasUnsafeComment(node, specifiers, sourceCode)) {
+          return;
+        }
+
+        const units: SpecifierUnit[] = [];
+
+        for (const specifier of specifiers) {
+          const name = getSpecifierName(specifier.imported);
+
+          if (name === null) {
+            return;
+          }
+
+          let group = 1;
+
+          if (node.importKind === "type" || specifier.importKind === "type") {
+            group = 0;
+          } else if (name === "default") {
+            group = 2;
+          }
+
+          units.push({
+            name,
+            text: sourceCode.text.slice(specifier.range[0], specifier.range[1]),
+            group,
+          });
+        }
+
+        reportSort(node, specifiers, units);
+      },
+      ExportNamedDeclaration(node): void {
+        const { specifiers } = node;
+
+        if (specifiers.length < 2 || hasUnsafeComment(node, specifiers, sourceCode)) {
+          return;
+        }
+
+        const units: SpecifierUnit[] = [];
+
+        for (const specifier of specifiers) {
+          const localName = getSpecifierName(specifier.local);
+          const exportedName = getSpecifierName(specifier.exported);
+
+          if (localName === null || exportedName === null) {
+            return;
+          }
+
+          let group = 1;
+
+          if (node.exportKind === "type" || specifier.exportKind === "type") {
+            group = 0;
+          } else if (localName === "default" || exportedName === "default") {
+            group = 2;
+          }
+
+          units.push({
+            name: localName,
+            text: sourceCode.text.slice(specifier.range[0], specifier.range[1]),
+            group,
+          });
+        }
+
+        reportSort(node, specifiers, units);
+      },
+    };
+  },
+});
+
+export default sortImportExportSpecifiers;

package/src/rules/sort-jsx-props.ts

@@ -0,0 +1,149 @@
+import { defineRule } from "vite-plus/lint/plugins";
+import type { ESTree, SourceCode } from "vite-plus/lint/plugins";
+
+import { compareNames } from "./object-sort-utils.js";
+
+interface AttributeUnit {
+  name: string;
+  text: string;
+}
+
+type NamedAttribute = ESTree.JSXAttribute & { name: ESTree.JSXIdentifier };
+
+function isNamedAttribute(attribute: ESTree.JSXAttributeItem): attribute is NamedAttribute {
+  return attribute.type === "JSXAttribute" && attribute.name.type === "JSXIdentifier";
+}
+
+function getAttributeGroup(name: string): number {
+  if (/^on[A-Z].*/u.test(name)) {
+    return 1;
+  }
+
+  if (/^aria-.+/u.test(name)) {
+    return 2;
+  }
+
+  if (/^data-.+/u.test(name)) {
+    return 3;
+  }
+
+  return 0;
+}
+
+function compareAttributes(left: AttributeUnit, right: AttributeUnit): number {
+  const leftGroup = getAttributeGroup(left.name);
+  const rightGroup = getAttributeGroup(right.name);
+
+  if (leftGroup !== rightGroup) {
+    return leftGroup - rightGroup;
+  }
+
+  return compareNames(left.name, right.name);
+}
+
+function getLineIndent(source: string, offset: number): string {
+  const lineStart = source.lastIndexOf("\n", offset) + 1;
+  const match = /^[ \t]*/u.exec(source.slice(lineStart, offset));
+
+  return match?.[0] ?? "";
+}
+
+function hasCommentBetweenAttributes(
+  attributes: readonly NamedAttribute[],
+  sourceCode: SourceCode,
+): boolean {
+  const comments = sourceCode.getAllComments();
+
+  return attributes.some((attribute, index) => {
+    const nextAttribute = attributes[index + 1];
+
+    if (nextAttribute === undefined) {
+      return false;
+    }
+
+    return comments.some(
+      (comment) =>
+        comment.range[0] >= attribute.range[1] && comment.range[1] <= nextAttribute.range[0],
+    );
+  });
+}
+
+/**
+ * JSX の props を「一般 → on* → aria-* → data-*」のグループ順に並べます。
+ * 各グループ内ではプロパティー名の長さが短い順、同じ長さなら名前順です。
+ */
+const sortJsxProps = defineRule({
+  meta: {
+    docs: {
+      description:
+        "Sort JSX props by group (general, on*, aria-*, data-*), then by name length and name.",
+    },
+    type: "layout",
+    fixable: "whitespace",
+    messages: {
+      sort: "JSX props must be sorted by group, name length, then name.",
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    return {
+      JSXOpeningElement(node): void {
+        const attributes = node.attributes.filter(isNamedAttribute);
+
+        if (attributes.length < 2 || attributes.length !== node.attributes.length) {
+          return;
+        }
+
+        const names = new Set<string>();
+
+        for (const attribute of attributes) {
+          if (names.has(attribute.name.name)) {
+            return;
+          }
+
+          names.add(attribute.name.name);
+        }
+
+        if (hasCommentBetweenAttributes(attributes, sourceCode)) {
+          return;
+        }
+
+        const units: AttributeUnit[] = attributes.map((attribute) => ({
+          name: attribute.name.name,
+          text: sourceCode.text.slice(attribute.range[0], attribute.range[1]),
+        }));
+        const sorted = [...units].sort(compareAttributes);
+
+        if (sorted.every((unit, index) => unit === units[index])) {
+          return;
+        }
+
+        const firstAttribute = attributes[0];
+        const lastAttribute = attributes.at(-1);
+
+        if (firstAttribute === undefined || lastAttribute === undefined) {
+          return;
+        }
+
+        const multiline = firstAttribute.loc.start.line !== lastAttribute.loc.end.line;
+        const separator = multiline
+          ? `\n${getLineIndent(sourceCode.text, firstAttribute.range[0])}`
+          : " ";
+
+        context.report({
+          fix(fixer) {
+            return fixer.replaceTextRange(
+              [firstAttribute.range[0], lastAttribute.range[1]],
+              sorted.map((unit) => unit.text).join(separator),
+            );
+          },
+          node,
+          messageId: "sort",
+        });
+      },
+    };
+  },
+});
+
+export default sortJsxProps;

package/src/rules/sort-object-properties.ts

@@ -0,0 +1,62 @@
+import { defineRule } from "vite-plus/lint/plugins";
+
+import { getSortPlan } from "./object-sort-utils.js";
+
+/**
+ * オブジェクトリテラルのプロパティーを、名前の長さが短い順、同じ長さなら名前順に並べます。
+ *
+ * 空行で区切られたグループは意図的なまとまりとみなし、グループ内だけで並べ替えます。
+ * プロパティー直上のコメントはプロパティーと一緒に移動します。
+ */
+const sortObjectProperties = defineRule({
+  meta: {
+    docs: {
+      description:
+        "Sort object properties by name length and name, preserving comment groups separated by blank lines.",
+    },
+    type: "layout",
+    fixable: "whitespace",
+    messages: {
+      sort: "Object properties must be sorted by name length, then by name.",
+    },
+  },
+  create(context) {
+    return {
+      ObjectPattern(node): void {
+        const plan = getSortPlan(node, context.sourceCode, {
+          allowRest: true,
+          forceMultiline: false,
+        });
+
+        if (plan === null || !plan.needsFix) {
+          return;
+        }
+
+        context.report({
+          fix(fixer) {
+            return fixer.replaceText(node, plan.replacement);
+          },
+          node,
+          messageId: "sort",
+        });
+      },
+      ObjectExpression(node): void {
+        const plan = getSortPlan(node, context.sourceCode);
+
+        if (plan === null || !plan.needsFix) {
+          return;
+        }
+
+        context.report({
+          fix(fixer) {
+            return fixer.replaceText(node, plan.replacement);
+          },
+          node,
+          messageId: "sort",
+        });
+      },
+    };
+  },
+});
+
+export default sortObjectProperties;