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

package/src/rules/merge-imports.ts

@@ -0,0 +1,301 @@
+import { defineRule } from "vite-plus/lint/plugins";
+import type { ESTree, Comment, SourceCode } from "vite-plus/lint/plugins";
+
+interface NamedSpecifier {
+  local: string;
+  text: string;
+}
+
+function getModuleName(node: ESTree.ImportDeclaration): string {
+  return node.source.value;
+}
+
+function getAttributeKey(attribute: ESTree.ImportAttribute): string {
+  const key = attribute.key.type === "Identifier" ? attribute.key.name : attribute.key.value;
+
+  return `${key}:${attribute.value.value}`;
+}
+
+function getAttributesKey(node: ESTree.ImportDeclaration): string {
+  return node.attributes.map(getAttributeKey).join(",");
+}
+
+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 isMergeableDeclaration(node: ESTree.Node): node is ESTree.ImportDeclaration {
+  return (
+    node.type === "ImportDeclaration" &&
+    node.phase === null &&
+    node.specifiers.length > 0 &&
+    node.specifiers.every((specifier) => specifier.type !== "ImportNamespaceSpecifier")
+  );
+}
+
+function hasUnsafeComment(
+  declarations: readonly ESTree.ImportDeclaration[],
+  comments: readonly Comment[],
+): boolean {
+  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: readonly ESTree.ImportDeclaration[],
+  specifiers: readonly NamedSpecifier[],
+  sourceCode: SourceCode,
+): string {
+  const texts = specifiers.map((specifier) => specifier.text);
+  const multiline = declarations.find((declaration) => {
+    const firstSpecifier = declaration.specifiers.find(
+      (specifier): specifier is ESTree.ImportSpecifier => 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 is ESTree.ImportSpecifier => specifier.type === "ImportSpecifier",
+  );
+  const lastNamed = multiline.specifiers.findLast(
+    (specifier): specifier is ESTree.ImportSpecifier => 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: readonly ESTree.ImportDeclaration[],
+  sourceCode: SourceCode,
+): string | null {
+  const first = declarations[0];
+
+  if (first === undefined) {
+    return null;
+  }
+
+  const defaultSpecifiers = declarations.flatMap((declaration) =>
+    declaration.specifiers
+      .filter(
+        (specifier): specifier is ESTree.ImportDefaultSpecifier =>
+          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: {
+    local: string;
+    typeOnly: boolean;
+  } | null = 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<string, string>();
+  const named: NamedSpecifier[] = [];
+
+  function addNamed(local: string, text: string): boolean {
+    const existing = namedByLocal.get(local);
+
+    if (existing !== undefined) {
+      return existing === text;
+    }
+
+    namedByLocal.set(local, text);
+    named.push({
+      text,
+      local,
+    });
+
+    return true;
+  }
+
+  let defaultClause: string | null = 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: string[] = [];
+
+  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): void {
+        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/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"}