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

package/dist/src/rules/merge-imports.js

@@ -0,0 +1,199 @@
+import { defineRule } from "vite-plus/lint/plugins";
+function getModuleName(node) {
+    return node.source.value;
+}
+function getAttributeKey(attribute) {
+    const key = attribute.key.type === "Identifier" ? attribute.key.name : attribute.key.value;
+    return `${key}:${attribute.value.value}`;
+}
+function getAttributesKey(node) {
+    return node.attributes.map(getAttributeKey).join(",");
+}
+function getLineIndent(source, offset) {
+    const lineStart = source.lastIndexOf("\n", offset) + 1;
+    const match = /^[ \t]*/u.exec(source.slice(lineStart, offset));
+    return match?.[0] ?? "";
+}
+function isMergeableDeclaration(node) {
+    return (node.type === "ImportDeclaration" &&
+        node.phase === null &&
+        node.specifiers.length > 0 &&
+        node.specifiers.every((specifier) => specifier.type !== "ImportNamespaceSpecifier"));
+}
+function hasUnsafeComment(declarations, comments) {
+    const first = declarations[0];
+    const last = declarations.at(-1);
+    if (first === undefined || last === undefined) {
+        return true;
+    }
+    const specifierRanges = declarations.flatMap((declaration) => declaration.specifiers.map((specifier) => specifier.range));
+    return comments.some((comment) => comment.range[0] >= first.range[0] &&
+        comment.range[1] <= last.range[1] &&
+        !specifierRanges.some((range) => comment.range[0] >= range[0] && comment.range[1] <= range[1]));
+}
+function buildNamedClause(declarations, specifiers, sourceCode) {
+    const texts = specifiers.map((specifier) => specifier.text);
+    const multiline = declarations.find((declaration) => {
+        const firstSpecifier = declaration.specifiers.find((specifier) => specifier.type === "ImportSpecifier");
+        return (firstSpecifier !== undefined && firstSpecifier.loc.start.line > declaration.loc.start.line);
+    });
+    if (multiline === undefined) {
+        return `{ ${texts.join(", ")} }`;
+    }
+    const firstNamed = multiline.specifiers.find((specifier) => specifier.type === "ImportSpecifier");
+    const lastNamed = multiline.specifiers.findLast((specifier) => specifier.type === "ImportSpecifier");
+    const firstDeclaration = declarations[0];
+    if (firstNamed === undefined || lastNamed === undefined || firstDeclaration === undefined) {
+        return `{ ${texts.join(", ")} }`;
+    }
+    const indent = getLineIndent(sourceCode.text, firstNamed.range[0]);
+    const closingIndent = getLineIndent(sourceCode.text, firstDeclaration.range[0]);
+    const beforeSource = sourceCode.text.slice(lastNamed.range[1], multiline.source.range[0]);
+    const trailingComma = /,\s*\}/u.test(beforeSource);
+    return `{\n${indent}${texts.join(`,\n${indent}`)}${trailingComma ? "," : ""}\n${closingIndent}}`;
+}
+function buildReplacement(declarations, sourceCode) {
+    const first = declarations[0];
+    if (first === undefined) {
+        return null;
+    }
+    const defaultSpecifiers = declarations.flatMap((declaration) => declaration.specifiers
+        .filter((specifier) => specifier.type === "ImportDefaultSpecifier")
+        .map((specifier) => ({
+        local: specifier.local.name,
+        typeOnly: declaration.importKind === "type",
+    })));
+    const hasNamed = declarations.some((declaration) => declaration.specifiers.some((specifier) => specifier.type === "ImportSpecifier"));
+    let defaultSpecifier = null;
+    for (const specifier of defaultSpecifiers) {
+        if (defaultSpecifier === null) {
+            defaultSpecifier = specifier;
+            continue;
+        }
+        // default import は 1 つしか置けないため、別名の default import はまとめられません。
+        if (defaultSpecifier.local !== specifier.local ||
+            defaultSpecifier.typeOnly !== specifier.typeOnly) {
+            return null;
+        }
+    }
+    const allTypeOnly = declarations.every((declaration) => declaration.importKind === "type");
+    // `import type Foo, { Bar }` は書けないため、default と名前付きを併存させる場合は `type default as Foo` を使う通常の import に変換します。
+    const useTypeOnlyDeclaration = allTypeOnly && !(defaultSpecifier !== null && hasNamed);
+    const namedByLocal = new Map();
+    const named = [];
+    function addNamed(local, text) {
+        const existing = namedByLocal.get(local);
+        if (existing !== undefined) {
+            return existing === text;
+        }
+        namedByLocal.set(local, text);
+        named.push({
+            text,
+            local,
+        });
+        return true;
+    }
+    let defaultClause = null;
+    if (defaultSpecifier !== null) {
+        if (useTypeOnlyDeclaration || !defaultSpecifier.typeOnly) {
+            defaultClause = defaultSpecifier.local;
+        }
+        else if (!addNamed(defaultSpecifier.local, `type default as ${defaultSpecifier.local}`)) {
+            return null;
+        }
+    }
+    for (const declaration of declarations) {
+        const forceType = !useTypeOnlyDeclaration && declaration.importKind === "type";
+        for (const specifier of declaration.specifiers) {
+            if (specifier.type !== "ImportSpecifier") {
+                continue;
+            }
+            const original = sourceCode.getText(specifier);
+            const text = forceType && specifier.importKind !== "type" ? `type ${original}` : original;
+            if (!addNamed(specifier.local.name, text)) {
+                return null;
+            }
+        }
+    }
+    if (defaultClause !== null && namedByLocal.has(defaultClause)) {
+        return null;
+    }
+    const bindings = [];
+    if (defaultClause !== null) {
+        bindings.push(defaultClause);
+    }
+    if (named.length > 0) {
+        bindings.push(buildNamedClause(declarations, named, sourceCode));
+    }
+    if (bindings.length === 0) {
+        return null;
+    }
+    const sourceText = sourceCode.getText(first.source);
+    // `with { ... }` や `assert { ... }`、セミコロンの有無を元の宣言から引き継ぎます。
+    const suffix = sourceCode.text.slice(first.source.range[1], first.range[1]);
+    return `import ${useTypeOnlyDeclaration ? "type " : ""}${bindings.join(", ")} from ${sourceText}${suffix}`;
+}
+/**
+ * 同じモジュールを指す連続した import 宣言を 1 つにまとめます。
+ *
+ * 別名の default import、namespace import、副作用だけの import、属性が異なる import は安全にまとめられないため対象外にします。コメントが specifier の外側にある場合も、コメントを失わないように対象外にします。
+ */
+const mergeImports = defineRule({
+    meta: {
+        docs: {
+            description: "Merge consecutive import declarations that import from the same module.",
+        },
+        type: "layout",
+        fixable: "whitespace",
+        messages: {
+            merge: "Import declarations from the same module must be merged.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            Program(node) {
+                const comments = sourceCode.getAllComments();
+                let index = 0;
+                while (index < node.body.length) {
+                    const first = node.body[index];
+                    if (first === undefined || !isMergeableDeclaration(first)) {
+                        index += 1;
+                        continue;
+                    }
+                    const declarations = [first];
+                    let next = index + 1;
+                    while (next < node.body.length) {
+                        const candidate = node.body[next];
+                        if (candidate === undefined ||
+                            !isMergeableDeclaration(candidate) ||
+                            getModuleName(candidate) !== getModuleName(first) ||
+                            getAttributesKey(candidate) !== getAttributesKey(first)) {
+                            break;
+                        }
+                        declarations.push(candidate);
+                        next += 1;
+                    }
+                    if (declarations.length > 1 && !hasUnsafeComment(declarations, comments)) {
+                        const replacement = buildReplacement(declarations, sourceCode);
+                        const last = declarations.at(-1);
+                        if (replacement !== null && last !== undefined) {
+                            context.report({
+                                fix(fixer) {
+                                    return [
+                                        fixer.replaceText(first, replacement),
+                                        fixer.removeRange([first.range[1], last.range[1]]),
+                                    ];
+                                },
+                                node: first,
+                                messageId: "merge",
+                            });
+                        }
+                    }
+                    index = next;
+                }
+            },
+        };
+    },
+});
+export default mergeImports;

package/dist/src/rules/overload-signatures-adjacent.js

@@ -1,5 +1,5 @@
 import { defineRule } from "vite-plus/lint/plugins";
-import { getNextStatement, getRemoveBlankLineFix } from "./blank-line.js";
+import { getNextStatement, getRemoveBlankLineFix } from "./blank-line-utils.js";
 function getFunction(node) {
     if (node.type === "FunctionDeclaration" || node.type === "TSDeclareFunction") {
         return node;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tai-kun/vp-lint-plugins",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "",
   "homepage": "https://tai-kun.github.io/vp-lint-plugins/",
   "license": "MIT",

package/src/index.ts

@@ -1,15 +1,11 @@
-export { default as blankLineAfterControlBlock } from "./rules/blank-line-after-control-block.js";
-export { default as blankLineAfterDeclaration } from "./rules/blank-line-after-declaration.js";
-export { default as blankLineAfterVariableDeclaration } from "./rules/blank-line-after-variable-declaration.js";
-export { default as blankLineBeforeReturn } from "./rules/blank-line-before-return.js";
-export { default as blankLineBetweenClassMembers } from "./rules/blank-line-between-class-members.js";
-export { default as blankLineBetweenSwitchCases } from "./rules/blank-line-between-switch-cases.js";
+export { default as blankLine } from "./rules/blank-line.js";
 export { default as commentJapaneseSpacing } from "./rules/comment-japanese-spacing.js";
 export { default as commentOneSentencePerLine } from "./rules/comment-one-sentence-per-line.js";
 export { default as jsdocParamOrder } from "./rules/jsdoc-param-order.js";
 export { default as jsdocTagLines } from "./rules/jsdoc-tag-lines.js";
 export { default as jsdocTagOrder } from "./rules/jsdoc-tag-order.js";
 export { default as memberOrdering } from "./rules/member-ordering.js";
+export { default as mergeImports } from "./rules/merge-imports.js";
 export { default as objectPropertiesNewline } from "./rules/object-properties-newline.js";
 export { default as overloadSignaturesAdjacent } from "./rules/overload-signatures-adjacent.js";
 export { default as sortImportExportSpecifiers } from "./rules/sort-import-export-specifiers.js";

package/src/plugin.ts

@@ -1,17 +1,13 @@
 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 blankLine from "./rules/blank-line.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 mergeImports from "./rules/merge-imports.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";
@@ -24,6 +20,8 @@ import typeLiteralPropertiesNewline from "./rules/type-literal-properties-newlin
 export default definePlugin({
   meta: { name: "tai-kun" },
   rules: {
+    "blank-line": blankLine,
+    "merge-imports": mergeImports,
     "sort-jsx-props": sortJsxProps,
     "spaced-comment": spacedComment,
     "jsdoc-tag-lines": jsdocTagLines,
@@ -32,17 +30,11 @@ export default definePlugin({
     "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-utils.ts

@@ -0,0 +1,165 @@
+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 isComment(target: ESTree.Node | Comment): target is Comment {
+  const { type } = target as { type: string };
+
+  return type === "Line" || type === "Block" || type === "Shebang";
+}
+
+/**
+ * JSDoc 形式のブロックコメント（`/**` で始まる）かどうかを返します。
+ *
+ * JSDoc 形式のブロックコメントの 1 行上は空行にします。
+ */
+function isDocComment(target: ESTree.Node | Comment): target is Comment {
+  return isComment(target) && target.type === "Block" && target.value.startsWith("*");
+}
+
+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");
+}
+
+/**
+ * 指定したノードと対象の間の空行を削除します。
+ */
+function getRemoveBlankLineFix(
+  fixer: Fixer,
+  sourceCode: SourceCode,
+  node: ESTree.Node,
+  target: ESTree.Node | Comment,
+): Fix | null {
+  if (target.loc.start.line <= node.loc.end.line + 1) {
+    return null;
+  }
+
+  const fromLineEnd = sourceCode.text.indexOf("\n", node.range[1]);
+
+  if (fromLineEnd === -1) {
+    return null;
+  }
+
+  const targetLineStart = sourceCode.text.lastIndexOf("\n", target.range[0]) + 1;
+  const indent = sourceCode.text.slice(targetLineStart, target.range[0]);
+
+  if (indent.trim() !== "") {
+    return null;
+  }
+
+  return fixer.replaceTextRange([fromLineEnd, target.range[0]], `\n${indent}`);
+}
+
+export {
+  isComment,
+  hasBlankLine,
+  isDocComment,
+  getBlankLineFix,
+  getNextStatement,
+  getInsertionTarget,
+  getPreviousStatement,
+  getRemoveBlankLineFix,
+};