homebridge-plugin-utils 1.35.0 → 2.1.0

package/build/eslint-plugin/rules/split-type-imports.mjs

@@ -0,0 +1,354 @@
+/* Copyright(C) 2017-2026, HJD (https://github.com/hjdhjd). All rights reserved.
+ *
+ * split-type-imports.mjs: Require type imports and re-exports to live in declaration-level `import type` / `export type` statements rather than as
+ * specifier-level qualifiers (`import { type Foo, bar } from "..."`).
+ */
+
+// Test whether a named specifier carries an inline `type` qualifier. ImportSpecifier exposes the qualifier on `importKind`; ExportSpecifier exposes it on
+// `exportKind`. Either being `"type"` indicates the qualifier is present.
+function isInlineTypeSpecifier(specifier) {
+
+  return (specifier.importKind ?? specifier.exportKind) === "type";
+}
+
+// Slide an exclusive end offset forward past a trailing semicolon. The typescript-eslint parser's declaration range[1] usually stops at the source
+// string's closing quote (or the import-attributes clause), leaving the terminating `;` as a separate punctuator token. Sliding forward when the
+// character at the current end is `;` makes the replacement range cover the original semicolon so the rewritten text supplies its own without doubling.
+function includeTrailingSemicolon(sourceCode, end) {
+
+  return (sourceCode.text[end] === ";") ? (end + 1) : end;
+}
+
+// Slide an exclusive end offset back past a trailing semicolon. The mirror of `includeTrailingSemicolon` for the case where range[1] already covers the
+// terminator: when the character just before `end` is `;`, return `end - 1` so the resulting offset stops at the last token of the declaration's body.
+// The two helpers together let downstream code work uniformly against either parser configuration.
+function excludeTrailingSemicolon(sourceCode, end) {
+
+  return (sourceCode.text[end - 1] === ";") ? (end - 1) : end;
+}
+
+// Reconstruct a named specifier's source text without its leading `type` qualifier. For inline-marked specifiers, the first token is the keyword `type`,
+// so we slice from immediately after that keyword's range through the specifier's end and trim. For unmarked specifiers, we take the specifier text
+// verbatim. Range-based slicing carries alias clauses (`as Local`) and any intra-specifier comments along with the name without name-based reconstruction.
+function specifierTextStripped(sourceCode, specifier) {
+
+  if(isInlineTypeSpecifier(specifier)) {
+
+    const firstToken = sourceCode.getFirstToken(specifier);
+
+    return sourceCode.text.slice(firstToken.range[1], specifier.range[1]).trim();
+  }
+
+  return sourceCode.text.slice(specifier.range[0], specifier.range[1]).trim();
+}
+
+// Compute the [start, end] offsets of the declaration's post-source clause. The clause covers everything between the source string's closing quote and
+// the terminating semicolon (or the declaration's end when the parser already excludes the semicolon). For most declarations the slice is empty; for
+// declarations carrying `with { type: "json" }` import attributes (or the legacy `assert { ... }` form) it spans the attribute clause. This is the single
+// source of truth for what counts as "the tail" - both the text-slicing path in `declarationTail` and the comment-membership check in
+// `isCommentPreservable` derive their bounds from this helper so they cannot drift apart.
+function declarationTailRange(sourceCode, node) {
+
+  return [ node.source.range[1], excludeTrailingSemicolon(sourceCode, node.range[1]) ];
+}
+
+// Capture the trailing clause text of a declaration after the source string. Empty for most declarations; preserves `with { type: "json" }` import
+// attributes (and the legacy `assert { ... }` form) when present.
+function declarationTail(sourceCode, node) {
+
+  const [ start, end ] = declarationTailRange(sourceCode, node);
+
+  return sourceCode.text.slice(start, end).trim();
+}
+
+// Compute the leading whitespace of a declaration's line. Used to indent the second emitted declaration so it lines up under the first. We read the line
+// directly rather than emitting a fixed number of spaces so the indent honors tabs or mixed whitespace if either is ever in use.
+function declarationIndent(sourceCode, node) {
+
+  const line = sourceCode.lines[node.loc.start.line - 1];
+
+  return line.slice(0, node.loc.start.column);
+}
+
+// Derive the kind-discriminant strings for a declaration in one place. The rule branches on whether the node is an `ImportDeclaration` or an
+// `ExportNamedDeclaration` to pick the message wording, the declaration head keyword, and the kind keyword used by the value-side renderer; centralizing
+// the discriminant derivations keeps them from drifting and gives every downstream consumer one object to read from instead of separate ternaries to evaluate.
+function declarationFlavor(node) {
+
+  const isImport = node.type === "ImportDeclaration";
+
+  return {
+
+    head: isImport ? "import type" : "export type",
+    kind: isImport ? "import" : "export",
+    kindWord: isImport ? "Imports" : "Re-exports"
+  };
+}
+
+// Classify a declaration's specifiers into the buckets the rule cares about: inline-`type`-marked named specifiers, unmarked named (value) specifiers,
+// and a single default specifier (imports only). Pure - takes the raw specifiers array and returns a structured object, with no dependency on `sourceCode`
+// or `context`. Used by the rule's per-declaration check to drive the decision tree (skip vs split vs collapse) and by the render helpers downstream.
+// Namespace specifiers (`* as ns`) fall through the switch unclassified: per the ECMAScript `ImportClause` grammar they never appear alongside named
+// specifiers, so a declaration containing one yields empty `typeSpecs` and the rule's `typeSpecs.length === 0` short-circuit dismisses it.
+function classifySpecifiers(specifiers) {
+
+  const typeSpecs = [];
+  const valueSpecs = [];
+  let defaultSpec = null;
+
+  for(const specifier of specifiers) {
+
+    switch(specifier.type) {
+
+      case "ImportSpecifier":
+      case "ExportSpecifier": {
+
+        if(isInlineTypeSpecifier(specifier)) {
+
+          typeSpecs.push(specifier);
+        } else {
+
+          valueSpecs.push(specifier);
+        }
+
+        break;
+      }
+
+      case "ImportDefaultSpecifier": {
+
+        defaultSpec = specifier;
+
+        break;
+      }
+    }
+  }
+
+  return { defaultSpec, typeSpecs, valueSpecs };
+}
+
+// Test whether a comment that sits inside the declaration's range falls inside one of the regions the autofix preserves: any specifier's own range
+// (carried along by range-based slicing) and the post-source tail range (carried verbatim into both emitted declarations).
+function isCommentPreservable(sourceCode, comment, node) {
+
+  for(const specifier of node.specifiers) {
+
+    if((specifier.type !== "ImportSpecifier") && (specifier.type !== "ExportSpecifier")) {
+
+      continue;
+    }
+
+    if((comment.range[0] >= specifier.range[0]) && (comment.range[1] <= specifier.range[1])) {
+
+      return true;
+    }
+  }
+
+  const [ tailStart, tailEnd ] = declarationTailRange(sourceCode, node);
+
+  return (comment.range[0] >= tailStart) && (comment.range[1] <= tailEnd);
+}
+
+// Detect whether any comment in or visually adjacent to the declaration lives outside the regions the autofix actually preserves. Unpreservable comments
+// include those between `import` and the brace, between commas in the brace list, between `}` and `from`, between `from` and the source string, and
+// same-line leading or trailing comments that visually attach to the declaration's lines but fall outside the replacement range. The presence of any such
+// comment disqualifies the declaration from autofix, and the rule falls back to report-only so the author can rewrite the declaration deliberately.
+function hasUnpreservableCommentInDeclaration(sourceCode, node) {
+
+  for(const comment of sourceCode.getCommentsInside(node)) {
+
+    if(isCommentPreservable(sourceCode, comment, node)) {
+
+      continue;
+    }
+
+    return true;
+  }
+
+  for(const comment of sourceCode.getCommentsBefore(node)) {
+
+    if(comment.loc.end.line === node.loc.start.line) {
+
+      return true;
+    }
+  }
+
+  for(const comment of sourceCode.getCommentsAfter(node)) {
+
+    if(comment.loc.start.line === node.loc.end.line) {
+
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// Render the type-only declaration line. The flavor's `head` field selects between `import type` / `export type`; the rest is uniform.
+function renderTypeDeclaration({ flavor, sourceText, tailSuffix, typeText }) {
+
+  return flavor.head + " { " + typeText + " } from " + sourceText + tailSuffix + ";";
+}
+
+// Render the value-side declaration line. For re-exports the form is always `export { ... } from "x"` since re-exports cannot carry a default. For
+// imports, the form depends on whether a default specifier survives the split and whether any named value specifiers remain: a default with no named
+// values collapses the brace clause entirely (`import D from "x"`), a default with named values keeps both (`import D, { ... } from "x"`), and no
+// default emits the bare brace form (`import { ... } from "x"`).
+function renderValueDeclaration({ defaultSpec, flavor, sourceText, tailSuffix, valueText }) {
+
+  if(flavor.kind === "export") {
+
+    return "export { " + valueText + " } from " + sourceText + tailSuffix + ";";
+  }
+
+  if((defaultSpec !== null) && !valueText) {
+
+    return "import " + defaultSpec.local.name + " from " + sourceText + tailSuffix + ";";
+  }
+
+  if(defaultSpec !== null) {
+
+    return "import " + defaultSpec.local.name + ", { " + valueText + " } from " + sourceText + tailSuffix + ";";
+  }
+
+  return "import { " + valueText + " } from " + sourceText + tailSuffix + ";";
+}
+
+// Render the canonical replacement text for a declaration that contains inline `type` specifiers. When the declaration's remaining content (after lifting
+// out the inline types) is empty - no value specifiers and no default - the result is a single top-level `import type` / `export type` declaration. When
+// content remains, the result is two declarations: a type-only declaration first, then a regular declaration carrying the values and any default.
+// Invariant at the call site: `typeSpecs.length > 0` (the `checkDeclaration` short-circuit). By the ECMAScript `ImportClause` grammar this implies no
+// namespace specifier sits alongside the named specifiers; by the parser's specifier-kind contract it also implies the declaration is not itself top-level
+// type-only (such a declaration parses with `importKind === "value"` on its specifiers, so `typeSpecs` would have stayed empty).
+function renderSplit({ defaultSpec, flavor, node, sourceCode, typeSpecs, valueSpecs }) {
+
+  const sourceText = sourceCode.getText(node.source);
+  const tail = declarationTail(sourceCode, node);
+  const tailSuffix = tail ? (" " + tail) : "";
+  const typeText = typeSpecs.map((s) => specifierTextStripped(sourceCode, s)).join(", ");
+  const typeDecl = renderTypeDeclaration({ flavor, sourceText, tailSuffix, typeText });
+
+  if((valueSpecs.length === 0) && (defaultSpec === null)) {
+
+    return typeDecl;
+  }
+
+  const indent = declarationIndent(sourceCode, node);
+  const valueText = valueSpecs.map((s) => specifierTextStripped(sourceCode, s)).join(", ");
+  const valueDecl = renderValueDeclaration({ defaultSpec, flavor, sourceText, tailSuffix, valueText });
+
+  return typeDecl + "\n" + indent + valueDecl;
+}
+
+// Require type imports and re-exports to live at the declaration level (`import type` / `export type`) rather than as inline specifier qualifiers
+// (`import { type Foo, bar } from "..."`).
+//
+// Policy rationale (single source of truth - if this comment moves, update the README and the plugin index too):
+//
+// The TypeScript grammar draws a real line between a declaration that exists only at compile time (`import type { ... }` is fully erased) and a
+// declaration that produces a runtime import. The inline `type` qualifier is a per-specifier accommodation introduced in TS 4.5 so that non-tsc
+// transpilers (Babel, esbuild, swc) could elide individual type-only specifiers without whole-program type analysis. It works, but it expresses type-ness
+// at the specifier level - smuggling an erased token into a runtime declaration and asking the reader to classify each specifier in the brace list.
+//
+// Choosing to express type-ness at the declaration level wherever possible aligns the file's shape with the language's own categorization. A reader
+// scanning the top of a file sees two flat tiers: lines that survive to runtime (`import { ... }`) and lines that do not (`import type { ... }`). Brace
+// contents stay single-kind. Refactors that flip a name between type-only and runtime use move a specifier between two stable lines instead of reshaping
+// a mixed declaration. And `^import type` becomes a complete grep for compile-time-only dependencies, which is invisible under the inline form.
+//
+// This rule pairs with `@typescript-eslint/consistent-type-imports` configured with `prefer: "type-imports"` and `fixStyle: "separate-type-imports"`.
+// That upstream rule owns the question "is this type-only specifier marked at all?"; this rule owns "is the marking in the canonical declaration-level
+// form?". The two concerns are crisp and non-overlapping; together they fully express the split-form policy.
+//
+// Cases covered:
+//  * `import { type A, foo } from "x"`                  flagged; autofix splits into `import type { A } from "x";\nimport { foo } from "x";`.
+//  * `import { type A, type B } from "x"`               flagged; autofix collapses to `import type { A, B } from "x";` (no value side).
+//  * `import { type A as Aa, foo } from "x"`            flagged; autofix preserves aliases via range-based slicing.
+//  * `import D, { type A, foo } from "x"`               flagged; autofix splits with the default riding the value declaration.
+//  * `import D, { type A } from "x"`                    flagged; autofix splits and omits the empty value brace (`import D from "x";`).
+//  * `export { type A, foo } from "x"`                  flagged; same split for re-exports.
+//  * Import attributes (`with { type: "json" }`)        carried verbatim into both emitted declarations.
+//  * `import type { A } from "x"`                       canonical; ignored.
+//  * `import { foo } from "x"`                          no type specifier; ignored (upstream owns the unmarked-type case).
+//
+// Comment safety: the autofix is suppressed and the rule falls back to report-only when a comment in the declaration falls outside the two preservable
+// regions (any specifier's own range, and the post-source tail slice). Comments between brace tokens, between `from` and the source string, or attached
+// to the same line as the declaration are unpreservable and disqualify the autofix.
+const ruleSplitTypeImports = {
+
+  create(context) {
+
+    const sourceCode = context.sourceCode;
+
+    function checkDeclaration(node) {
+
+      const { defaultSpec, typeSpecs, valueSpecs } = classifySpecifiers(node.specifiers);
+
+      if(typeSpecs.length === 0) {
+
+        return;
+      }
+
+      const flavor = declarationFlavor(node);
+      const sourceText = sourceCode.getText(node.source);
+      const baseMessage = flavor.kindWord + " from " + sourceText + ": type specifiers must live in a separate `" + flavor.head +
+        "` declaration, not as inline `type` qualifiers.";
+      const loc = { end: typeSpecs.at(-1).loc.end, start: typeSpecs[0].loc.start };
+
+      if(hasUnpreservableCommentInDeclaration(sourceCode, node)) {
+
+        context.report({
+
+          loc,
+          message: baseMessage +
+            " Autofix suppressed because a comment in the declaration cannot be safely preserved by the rewrite; rewrite the declaration manually.",
+          node
+        });
+
+        return;
+      }
+
+      const replacement = renderSplit({ defaultSpec, flavor, node, sourceCode, typeSpecs, valueSpecs });
+      const range = [ node.range[0], includeTrailingSemicolon(sourceCode, node.range[1]) ];
+
+      context.report({
+
+        fix(fixer) {
+
+          return fixer.replaceTextRange(range, replacement);
+        },
+        loc,
+        message: baseMessage,
+        node
+      });
+    }
+
+    return {
+
+      ExportNamedDeclaration(node) {
+
+        if(node.source !== null) {
+
+          checkDeclaration(node);
+        }
+      },
+
+      ImportDeclaration(node) {
+
+        checkDeclaration(node);
+      }
+    };
+  },
+  meta: {
+
+    docs: {
+
+      description: "require type imports and re-exports to live in declaration-level `import type` / `export type` statements rather than as inline " +
+        "specifier-level `type` qualifiers",
+      recommended: false
+    },
+    fixable: "code",
+    schema: [],
+    type: "suggestion"
+  }
+};
+
+export default ruleSplitTypeImports;

package/build/eslint-plugin/rules/split-type-imports.test.mjs

@@ -0,0 +1,268 @@
+/* Copyright(C) 2017-2026, HJD (https://github.com/hjdhjd). All rights reserved.
+ *
+ * split-type-imports.test.mjs: Unit tests for the split-type-imports rule. Covers the single split and collapse cases, default-specifier handling,
+ * re-exports, alias and import-attribute preservation, comment-safety suppression across every unpreservable region, and the negative passthrough cases
+ * that prove canonical declarations and namespace / default-only / unmarked imports are correctly skipped.
+ */
+import { RuleTester } from "../test-setup.mjs";
+import rule from "./split-type-imports.mjs";
+import ts from "typescript-eslint";
+
+// RuleTester wired to the typescript-eslint parser. The rule needs the typescript-eslint AST shape - inline `type` qualifiers on specifiers manifest as
+// `importKind` / `exportKind` fields that espree (the default parser) does not produce.
+const ruleTester = new RuleTester({
+
+  languageOptions: {
+
+    parser: ts.parser
+  }
+});
+
+ruleTester.run("split-type-imports", rule, {
+
+  invalid: [
+
+    // Single inline type with a value specifier. Canonical form lifts the type to its own `import type` declaration and leaves the value declaration
+    // behind. Specifier text round-trips exactly via range-based slicing.
+    {
+
+      code: "import { type A, foo } from \"x\";",
+      errors: [{ message: /Imports from "x": type specifiers must live in a separate `import type` declaration/ }],
+      output: "import type { A } from \"x\";\nimport { foo } from \"x\";"
+    },
+
+    // Multiple inline types with a value specifier. The type declaration carries every inline-marked specifier in source order; the value declaration
+    // retains the remaining value specifier(s) in source order. Member sort is owned by `sort-imports` and is not this rule's concern.
+    {
+
+      code: "import { type A, type B, foo } from \"x\";",
+      errors: 1,
+      output: "import type { A, B } from \"x\";\nimport { foo } from \"x\";"
+    },
+
+    // Multiple types and multiple values. Splits cleanly.
+    {
+
+      code: "import { type A, type B, foo, bar } from \"x\";",
+      errors: 1,
+      output: "import type { A, B } from \"x\";\nimport { foo, bar } from \"x\";"
+    },
+
+    // Collapse case: every named specifier carries the inline qualifier, no values remain. Canonical form is the single top-level type-only declaration;
+    // the rule emits no second declaration.
+    {
+
+      code: "import { type A } from \"x\";",
+      errors: 1,
+      output: "import type { A } from \"x\";"
+    },
+
+    // Collapse case with multiple inline types.
+    {
+
+      code: "import { type A, type B, type C } from \"x\";",
+      errors: 1,
+      output: "import type { A, B, C } from \"x\";"
+    },
+
+    // Default specifier riding alongside inline types and values. The default joins the value declaration (`import D, { ... } from "x"`) since its
+    // runtime semantics are preserved by staying on the value side.
+    {
+
+      code: "import D, { type A, foo } from \"x\";",
+      errors: 1,
+      output: "import type { A } from \"x\";\nimport D, { foo } from \"x\";"
+    },
+
+    // Default specifier with only inline types and no value specifiers. The value declaration collapses its empty brace clause to the bare default form
+    // `import D from "x"`, since an empty `{}` is a syntactic but visually ugly artifact.
+    {
+
+      code: "import D, { type A } from \"x\";",
+      errors: 1,
+      output: "import type { A } from \"x\";\nimport D from \"x\";"
+    },
+
+    // Default specifier with multiple inline types and no values - same collapse of the empty brace clause.
+    {
+
+      code: "import D, { type A, type B } from \"x\";",
+      errors: 1,
+      output: "import type { A, B } from \"x\";\nimport D from \"x\";"
+    },
+
+    // Alias preservation on inline type specifiers via range-based slicing. `type A as Aa` round-trips intact, including whitespace inside the alias.
+    {
+
+      code: "import { type A as Aa, foo } from \"x\";",
+      errors: 1,
+      output: "import type { A as Aa } from \"x\";\nimport { foo } from \"x\";"
+    },
+
+    // Alias preservation on value specifiers too. Range-based slicing carries `foo as bar` through verbatim.
+    {
+
+      code: "import { type A, foo as bar } from \"x\";",
+      errors: 1,
+      output: "import type { A } from \"x\";\nimport { foo as bar } from \"x\";"
+    },
+
+    // Import attributes (the `with { type: "json" }` clause) are carried verbatim into both emitted declarations so the runtime loader honors them on the
+    // value side and the compiler honors them on the type side.
+    {
+
+      code: "import { type A, foo } from \"x\" with { type: \"json\" };",
+      errors: 1,
+      output: "import type { A } from \"x\" with { type: \"json\" };\nimport { foo } from \"x\" with { type: \"json\" };"
+    },
+
+    // Intra-specifier block comments are preserved by range-based slicing. The comment lives inside the specifier's range and rides along when its text
+    // is sliced into the type-declaration output.
+    {
+
+      code: "import { type /* note */ A, foo } from \"x\";",
+      errors: 1,
+      output: "import type { /* note */ A } from \"x\";\nimport { foo } from \"x\";"
+    },
+
+    // Re-export form: inline type plus value specifier. Same split shape with `export type` / `export` heads.
+    {
+
+      code: "export { type A, foo } from \"x\";",
+      errors: [{ message: /Re-exports from "x": type specifiers must live in a separate `export type` declaration/ }],
+      output: "export type { A } from \"x\";\nexport { foo } from \"x\";"
+    },
+
+    // Re-export form: collapse case when every named specifier is type-only.
+    {
+
+      code: "export { type A, type B } from \"x\";",
+      errors: 1,
+      output: "export type { A, B } from \"x\";"
+    },
+
+    // Inline source order preserved: the rule does not sort. Z, Y, X stays Z, Y, X. `sort-imports` handles within-brace alphabetization on a subsequent
+    // autofix pass.
+    {
+
+      code: "import { type Z, type Y, type X, foo } from \"x\";",
+      errors: 1,
+      output: "import type { Z, Y, X } from \"x\";\nimport { foo } from \"x\";"
+    },
+
+    // Inter-specifier block comment: unpreservable. The comment's destination after the split (which side of the split, between which two specifiers) is
+    // genuinely ambiguous, and silently picking one is worse than leaving the rewrite to a human. Report the violation, suppress the autofix.
+    {
+
+      code: "import { type A, /* between */ foo } from \"x\";",
+      errors: [{ message: /Autofix suppressed because a comment in the declaration cannot be safely preserved/ }],
+      output: null
+    },
+
+    // Inter-specifier line comment: same suppression. The helper considers any comment kind, not just block comments.
+    {
+
+      code: "import { type A,\n  // pinned for now\n  foo } from \"x\";",
+      errors: 1,
+      output: null
+    },
+
+    // Comment between the `import` keyword and the default specifier. The autofix replaces the entire declaration and would otherwise drop this comment.
+    {
+
+      code: "import /* default-only */ D, { type A, foo } from \"x\";",
+      errors: 1,
+      output: null
+    },
+
+    // Trailing comment inside the brace list - after the last specifier, before the closing brace. Outside any specifier's range and outside the
+    // post-source tail slice.
+    {
+
+      code: "import { type A, foo /* trailing */ } from \"x\";",
+      errors: 1,
+      output: null
+    },
+
+    // Comment between the closing brace and the `from` keyword - same unpreservable region.
+    {
+
+      code: "import { type A, foo } /* trailing */ from \"x\";",
+      errors: 1,
+      output: null
+    },
+
+    // Comment between `from` and the source string literal - again unpreservable, since `getText(node.source)` only captures the literal itself and the
+    // tail slice starts at the end of that literal.
+    {
+
+      code: "import { type A, foo } from /* path */ \"x\";",
+      errors: 1,
+      output: null
+    },
+
+    // Comment inside the post-source tail slice (around an import-attributes clause) IS preserved by `declarationTail`, so the autofix runs normally
+    // and the comment survives in both emitted declarations.
+    {
+
+      code: "import { type A, foo } from \"x\" /* odd */ with { type: \"json\" };",
+      errors: 1,
+      output: "import type { A } from \"x\" /* odd */ with { type: \"json\" };\nimport { foo } from \"x\" /* odd */ with { type: \"json\" };"
+    },
+
+    // Same-line trailing comment after the declaration's semicolon. The comment survives the rewrite but lands visually attached to the last emitted
+    // declaration, even though the author wrote it for the whole import. Treated as unpreservable.
+    {
+
+      code: "import { type A, foo } from \"x\"; // legacy import",
+      errors: 1,
+      output: null
+    },
+
+    // Same-line leading block comment before the declaration. After a split the comment would label only the first emitted declaration.
+    {
+
+      code: "/* legacy */ import { type A, foo } from \"x\";",
+      errors: 1,
+      output: null
+    },
+
+    // Comments on adjacent lines (not the same line as the declaration) are not visually attached to the declaration's line and do not trigger
+    // suppression - autofix runs as normal and the surrounding comments survive in place because they fall outside the replacement range.
+    {
+
+      code: "// previous-line comment\nimport { type A, foo } from \"x\";\n// following-line comment",
+      errors: 1,
+      output: "// previous-line comment\nimport type { A } from \"x\";\nimport { foo } from \"x\";\n// following-line comment"
+    }
+  ],
+
+  valid: [
+
+    // Already top-level type-only declarations - canonical form. The rule has nothing to do.
+    "import type { A } from \"x\";",
+    "import type { A, B, C } from \"x\";",
+    "import type D from \"x\";",
+    "import type { A, B } from \"x\";\nimport { foo } from \"x\";",
+
+    // Plain value imports of every shape - no inline `type` qualifier means no policy violation. The upstream `consistent-type-imports` rule handles
+    // unmarked types separately; this rule's domain is only the inline-marked case.
+    "import { foo } from \"x\";",
+    "import { foo, bar } from \"x\";",
+    "import D from \"x\";",
+    "import D, { foo } from \"x\";",
+    "import * as ns from \"x\";",
+    "import \"x\";",
+
+    // Re-exports without inline `type` qualifiers.
+    "export { foo } from \"x\";",
+    "export { foo, bar } from \"x\";",
+    "export type { A, B } from \"x\";",
+
+    // Local re-export without a source clause - nothing for this rule to act on.
+    "const foo = 1; export { foo };",
+
+    // Namespace imports are never combined with named specifiers, so even an otherwise-mixed file leaves them untouched.
+    "import * as ns from \"x\";\nimport { foo } from \"y\";"
+  ]
+});

package/build/eslint-plugin/test-setup.mjs

@@ -0,0 +1,21 @@
+/* Copyright(C) 2017-2026, HJD (https://github.com/hjdhjd). All rights reserved.
+ *
+ * test-setup.mjs: Shared RuleTester scaffold for the plugin's per-rule test suites. Wires ESLint's `RuleTester` static class to the `node:test` runner's
+ * `describe` / `it` hooks so each rule's `*.test.mjs` file can construct a tester without repeating the static-assignment dance. The assignments mutate
+ * the `RuleTester` class itself, so they run exactly once on first import regardless of how many test files reach in.
+ *
+ * Mirrors the host package's `src/testing.helpers.ts` convention - shared test infrastructure lives at the top of its module, alongside the entry-point
+ * files (`plugin.mjs`, `config.mjs`, `index.mjs`), with co-located test files in `rules/` importing back up via `../test-setup.mjs`.
+ */
+import { describe, it } from "node:test";
+import { RuleTester } from "eslint";
+
+RuleTester.describe = describe;
+RuleTester.it = it;
+
+// `RuleTester.itOnly` is dispatched when a test case is declared with `{ only: true, ... }`. We map it to `it.only` (not plain `it`) so the test case
+// is actually marked exclusive. Note: node:test additionally requires the `--test-only` CLI flag for `.only` markers to take effect; without it the
+// markers are silently ignored and every test runs as normal. Use `npm run test:focus` (or `node --test --test-only ...`) when debugging with `only: true`.
+RuleTester.itOnly = it.only;
+
+export { RuleTester };