eslint-plugin-ts-type-forge 0.8.14 → 0.8.16

package/src/rules/ast-utils.mts

@@ -143,6 +143,114 @@ const isInConditionalTypeExtendsClause = (node: TSESTree.Node): boolean => {
   );
 };
 
+/** The `type X = …` declaration `node` sits in, if any. */
+const enclosingTypeAlias = (
+  node: TSESTree.Node,
+): TSESTree.TSTypeAliasDeclaration | undefined =>
+  node.type === AST_NODE_TYPES.TSTypeAliasDeclaration
+    ? node
+    : node.type === AST_NODE_TYPES.Program
+      ? undefined
+      : enclosingTypeAlias(node.parent);
+
+const isNode = (value: unknown): value is TSESTree.Node =>
+  isNonNullObject(value) &&
+  typeof (value as Readonly<{ type?: unknown }>).type === 'string';
+
+/**
+ * Visits `node` and its descendants.
+ *
+ * Children are found through the parser's visitor keys, so only the properties
+ * that actually hold one are read. Reading every own property instead works
+ * too, and is the fallback for a parser that declares no keys for a node type,
+ * but it allocates an entry pair per property and walks `loc` / `range` as
+ * well — on the generated rule-type files that alone was most of the cost.
+ */
+const walk = (
+  node: TSESTree.Node,
+  sourceCode: TSESLint.SourceCode,
+  visit: (visited: TSESTree.Node) => void,
+): void => {
+  visit(node);
+
+  if (!isRecord(node)) {
+    return;
+  }
+
+  const keys =
+    sourceCode.visitorKeys[node.type] ??
+    Object.keys(node).filter((key) => key !== 'parent');
+
+  for (const key of keys) {
+    const value: unknown = hasKey(node, key) ? node[key] : undefined;
+
+    if (Arr.isArray(value)) {
+      for (const element of value) {
+        if (isNode(element)) {
+          walk(element, sourceCode, visit);
+        }
+      }
+    } else if (isNode(value)) {
+      walk(value, sourceCode, visit);
+    }
+  }
+};
+
+/** The names every `X` / `X<…>` reference in the subtree points at. */
+const referencedTypeNames = (
+  node: TSESTree.Node,
+  sourceCode: TSESLint.SourceCode,
+): ReadonlySet<string> => {
+  const mut_names = new Set<string>();
+
+  walk(node, sourceCode, (visited) => {
+    if (
+      visited.type === AST_NODE_TYPES.TSTypeReference &&
+      visited.typeName.type === AST_NODE_TYPES.Identifier
+    ) {
+      mut_names.add(visited.typeName.name);
+    }
+  });
+
+  return mut_names;
+};
+
+/**
+ * Which other type names each `type X = …` in the file refers to, keyed by `X`.
+ *
+ * Built once per file and cached on the `Program` node: the search below runs
+ * per candidate tuple, and rebuilding this for each of them made the rule cost
+ * `O(tuples × file size)` — a full second on the largest generated files here.
+ */
+const aliasReferenceGraph = (
+  program: TSESTree.Program,
+  sourceCode: TSESLint.SourceCode,
+): ReadonlyMap<string, ReadonlySet<string>> => {
+  const cached = aliasReferenceGraphCache.get(program);
+
+  if (cached !== undefined) {
+    return cached;
+  }
+
+  const mut_graph = new Map<string, ReadonlySet<string>>();
+
+  walk(program, sourceCode, (visited) => {
+    if (visited.type === AST_NODE_TYPES.TSTypeAliasDeclaration) {
+      mut_graph.set(
+        visited.id.name,
+        referencedTypeNames(visited.typeAnnotation, sourceCode),
+      );
+    }
+  });
+
+  aliasReferenceGraphCache.set(program, mut_graph);
+
+  return mut_graph;
+};
+
+const programOf = (node: TSESTree.Node): TSESTree.Program =>
+  node.type === AST_NODE_TYPES.Program ? node : programOf(node.parent);
+
 /**
  * Whether the tuple spells out an alias that its own element type leads back
  * to.
@@ -225,119 +333,11 @@ const definesRecursiveTypeAlias = (
   }
 };
 
-/** The `type X = …` declaration `node` sits in, if any. */
-const enclosingTypeAlias = (
-  node: TSESTree.Node,
-): TSESTree.TSTypeAliasDeclaration | undefined =>
-  node.type === AST_NODE_TYPES.TSTypeAliasDeclaration
-    ? node
-    : node.type === AST_NODE_TYPES.Program
-      ? undefined
-      : enclosingTypeAlias(node.parent);
-
-/**
- * Which other type names each `type X = …` in the file refers to, keyed by `X`.
- *
- * Built once per file and cached on the `Program` node: the search below runs
- * per candidate tuple, and rebuilding this for each of them made the rule cost
- * `O(tuples × file size)` — a full second on the largest generated files here.
- */
-const aliasReferenceGraph = (
-  program: TSESTree.Program,
-  sourceCode: TSESLint.SourceCode,
-): ReadonlyMap<string, ReadonlySet<string>> => {
-  const cached = aliasReferenceGraphCache.get(program);
-
-  if (cached !== undefined) {
-    return cached;
-  }
-
-  const mut_graph = new Map<string, ReadonlySet<string>>();
-
-  walk(program, sourceCode, (visited) => {
-    if (visited.type === AST_NODE_TYPES.TSTypeAliasDeclaration) {
-      mut_graph.set(
-        visited.id.name,
-        referencedTypeNames(visited.typeAnnotation, sourceCode),
-      );
-    }
-  });
-
-  aliasReferenceGraphCache.set(program, mut_graph);
-
-  return mut_graph;
-};
-
 const aliasReferenceGraphCache = new WeakMap<
   TSESTree.Program,
   ReadonlyMap<string, ReadonlySet<string>>
 >();
 
-const programOf = (node: TSESTree.Node): TSESTree.Program =>
-  node.type === AST_NODE_TYPES.Program ? node : programOf(node.parent);
-
-/** The names every `X` / `X<…>` reference in the subtree points at. */
-const referencedTypeNames = (
-  node: TSESTree.Node,
-  sourceCode: TSESLint.SourceCode,
-): ReadonlySet<string> => {
-  const mut_names = new Set<string>();
-
-  walk(node, sourceCode, (visited) => {
-    if (
-      visited.type === AST_NODE_TYPES.TSTypeReference &&
-      visited.typeName.type === AST_NODE_TYPES.Identifier
-    ) {
-      mut_names.add(visited.typeName.name);
-    }
-  });
-
-  return mut_names;
-};
-
-/**
- * Visits `node` and its descendants.
- *
- * Children are found through the parser's visitor keys, so only the properties
- * that actually hold one are read. Reading every own property instead works
- * too, and is the fallback for a parser that declares no keys for a node type,
- * but it allocates an entry pair per property and walks `loc` / `range` as
- * well — on the generated rule-type files that alone was most of the cost.
- */
-const walk = (
-  node: TSESTree.Node,
-  sourceCode: TSESLint.SourceCode,
-  visit: (visited: TSESTree.Node) => void,
-): void => {
-  visit(node);
-
-  if (!isRecord(node)) {
-    return;
-  }
-
-  const keys =
-    sourceCode.visitorKeys[node.type] ??
-    Object.keys(node).filter((key) => key !== 'parent');
-
-  for (const key of keys) {
-    const value: unknown = hasKey(node, key) ? node[key] : undefined;
-
-    if (Arr.isArray(value)) {
-      for (const element of value) {
-        if (isNode(element)) {
-          walk(element, sourceCode, visit);
-        }
-      }
-    } else if (isNode(value)) {
-      walk(value, sourceCode, visit);
-    }
-  }
-};
-
-const isNode = (value: unknown): value is TSESTree.Node =>
-  isNonNullObject(value) &&
-  typeof (value as Readonly<{ type?: unknown }>).type === 'string';
-
 /** Unwraps `V[]` and `readonly V[]` to `V`. */
 const getArrayElementType = (
   node: TSESTree.TypeNode,

package/src/rules/import-style.mts

@@ -20,9 +20,9 @@ export const IMPORT_STYLE_SCHEMA_PROPERTY: JsonSchema = {
   enum: ['global', 'named'],
   description: [
     'How the ts-type-forge type is brought into scope.',
-    "'named' (default) makes the autofix add the corresponding",
-    `\`import { type … } from '${TS_TYPE_FORGE_MODULE}';\``,
-    "when the name is not imported yet; 'global' assumes the",
+    "'named' (default) makes the autofix import the type from",
+    `\`${TS_TYPE_FORGE_MODULE}\` when the name is not imported yet,`,
+    "adding it to an existing import of the module where there is one; 'global' assumes the",
     'ambient globals of `ts-type-forge/global` and never touches',
     'imports.',
   ].join(' '),
@@ -33,7 +33,8 @@ export const IMPORT_STYLE_SCHEMA_PROPERTY: JsonSchema = {
  * whether the fix has to add an import for it.
  *
  * Returns `undefined` when the name is already bound to something else (a local
- * alias, or an import from another module) — rewriting to it would then silently
+ * alias, an import from another module, or another ts-type-forge export
+ * imported under the name) — rewriting to it would then silently
  * resolve to the wrong declaration, which is exactly what happens inside
  * ts-type-forge's own sources.
  */

package/src/rules/import-utils.mts

@@ -1,12 +1,91 @@
-import { AST_NODE_TYPES, type TSESTree } from '@typescript-eslint/utils';
+import {
+  AST_NODE_TYPES,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import { buildNamedImportFix, getImportDeclarations } from 'eslint-rule-forge';
+import { Arr } from 'ts-data-forge';
 import { TS_TYPE_FORGE_MODULE } from './constants.mjs';
 
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 
+/**
+ * The edits that import the ts-type-forge types `names` the file does not
+ * import yet, as types: added to an existing `import type { … }` from the
+ * module (`, X`), else to a named import from it (`, type X`), else after a
+ * lone default import (`, { type X }`), and only failing all of those as a
+ * new `import { type X } from 'ts-type-forge'` after the directive prologue.
+ * Empty braces count as a host. Adding to an existing declaration keeps
+ * `import-x/no-duplicates` satisfied.
+ *
+ * Fixes that add an import overlap, so `--fix` applies one per pass, and the
+ * rest in later passes, by when the file imports their names (see
+ * `resolveTypeName`).
+ */
+export const buildTypeImportFix = (
+  fixer: TSESLint.RuleFixer,
+  sourceCode: Readonly<TSESLint.SourceCode>,
+  names: readonly string[],
+): readonly TSESLint.RuleFix[] => {
+  if (!Arr.isNonEmpty(names)) {
+    return [];
+  }
+
+  const declarations = getImportDeclarations(
+    sourceCode.ast,
+    TS_TYPE_FORGE_MODULE,
+  );
+
+  const typeOnlyFix = declarations
+    .filter((declaration) => declaration.importKind === 'type')
+    .map((declaration) => addToBraces(fixer, sourceCode, declaration, names))
+    .find((fix) => fix !== undefined);
+
+  if (typeOnlyFix !== undefined) {
+    return [typeOnlyFix];
+  }
+
+  const typeSpecifiers = names.map((name) => `type ${name}`);
+
+  const valueDeclarations = declarations.filter(
+    (declaration) => declaration.importKind !== 'type',
+  );
+
+  const valueFix = valueDeclarations
+    .map((declaration) =>
+      addToBraces(fixer, sourceCode, declaration, typeSpecifiers),
+    )
+    .find((fix) => fix !== undefined);
+
+  if (valueFix !== undefined) {
+    return [valueFix];
+  }
+
+  const defaultHost = valueDeclarations.find(
+    (declaration) =>
+      Arr.isFixedLengthArray(1, declaration.specifiers) &&
+      declaration.specifiers[0].type === AST_NODE_TYPES.ImportDefaultSpecifier,
+  )?.specifiers[0];
+
+  if (defaultHost !== undefined) {
+    return [
+      fixer.insertTextAfter(defaultHost, `, { ${typeSpecifiers.join(', ')} }`),
+    ];
+  }
+
+  return buildNamedImportFix(
+    fixer,
+    sourceCode.ast,
+    TS_TYPE_FORGE_MODULE,
+    typeSpecifiers,
+  );
+};
+
 /**
  * Whether the file already binds `name` to something that is not the
  * ts-type-forge export of the same name — a local type alias / interface /
- * class / enum, or an import from another module. Autofixes that introduce
+ * class / enum, an import from another module, or another ts-type-forge
+ * export imported under that name. Autofixes that introduce
  * `name` must bail out in that case, because the rewritten type would resolve
  * to the wrong declaration. (ts-type-forge's own sources, which declare
  * `NonEmptyArray` themselves, are the motivating example.)
@@ -20,9 +99,16 @@ export const hasConflictingDeclaration = (
 ): boolean =>
   program.body.some((node) => {
     if (node.type === AST_NODE_TYPES.ImportDeclaration) {
-      return (
-        node.source.value !== TS_TYPE_FORGE_MODULE &&
-        node.specifiers.some((specifier) => specifier.local.name === name)
+      return node.specifiers.some(
+        (specifier) =>
+          specifier.local.name === name &&
+          !(
+            node.source.value === TS_TYPE_FORGE_MODULE &&
+            specifier.type === AST_NODE_TYPES.ImportSpecifier &&
+            (specifier.imported.type === AST_NODE_TYPES.Identifier
+              ? specifier.imported.name
+              : specifier.imported.value) === name
+          ),
       );
     }
 
@@ -35,6 +121,39 @@ export const hasConflictingDeclaration = (
     );
   });
 
+/**
+ * Adds `specifiers` to the `{ … }` of `declaration`: after its last named
+ * specifier, or inside empty braces (`import d, {} from …`). `undefined` when
+ * the declaration has no braces (a default or namespace import alone).
+ */
+const addToBraces = (
+  fixer: TSESLint.RuleFixer,
+  sourceCode: Readonly<TSESLint.SourceCode>,
+  declaration: TSESTree.ImportDeclaration,
+  specifiers: readonly string[],
+): TSESLint.RuleFix | undefined => {
+  const lastNamed = declaration.specifiers
+    .filter(
+      (specifier): specifier is TSESTree.ImportSpecifier =>
+        specifier.type === AST_NODE_TYPES.ImportSpecifier,
+    )
+    .at(-1);
+
+  if (lastNamed !== undefined) {
+    return fixer.insertTextAfter(lastNamed, `, ${specifiers.join(', ')}`);
+  }
+
+  // Before the source, or the brace found is that of `with { … }`.
+  const openingBrace = sourceCode.getFirstToken(declaration, {
+    filter: (token) =>
+      token.value === '{' && token.range[1] <= declaration.source.range[0],
+  });
+
+  return openingBrace === null
+    ? undefined
+    : fixer.insertTextAfter(openingBrace, ` ${specifiers.join(', ')} `);
+};
+
 const declaresName = (
   node: TSESTree.Node | null | undefined,
   name: string,

package/src/rules/prefer-canonical-length-constrained-tuple.test.mts

@@ -255,13 +255,20 @@ describe('prefer-canonical-length-constrained-tuple', () => {
             type B = readonly [number, number, number];
             type C = [number, number, ...number[]];
           `,
-          output: dedent`
-            import { type FixedLengthTuple } from 'ts-type-forge';
-            import { type MutableMinLengthTuple } from 'ts-type-forge';
-            type A = FixedLengthTuple<2, string>;
-            type B = FixedLengthTuple<3, number>;
-            type C = MutableMinLengthTuple<2, number>;
-          `,
+          output: [
+            dedent`
+              import { type FixedLengthTuple, type MutableMinLengthTuple } from 'ts-type-forge';
+              type A = FixedLengthTuple<2, string>;
+              type B = readonly [number, number, number];
+              type C = [number, number, ...number[]];
+            `,
+            dedent`
+              import { type FixedLengthTuple, type MutableMinLengthTuple } from 'ts-type-forge';
+              type A = FixedLengthTuple<2, string>;
+              type B = FixedLengthTuple<3, number>;
+              type C = MutableMinLengthTuple<2, number>;
+            `,
+          ],
           errors: [
             { messageId: 'useCanonicalTuple' },
             { messageId: 'useCanonicalTuple' },
@@ -290,13 +297,43 @@ describe('prefer-canonical-length-constrained-tuple', () => {
           errors: [{ messageId: 'useCanonicalTuple' }],
         },
         {
-          name: 'rewrites parameter and return type positions',
-          code: 'declare const f: (xs: readonly [number, number]) => [string, string];',
-          output: dedent`
+          name: 'gives a report that needs no import no import edit',
+          code: dedent`
             import { type FixedLengthTuple } from 'ts-type-forge';
-            import { type MutableFixedLengthTuple } from 'ts-type-forge';
-            declare const f: (xs: FixedLengthTuple<2, number>) => MutableFixedLengthTuple<2, string>;
+            type A = readonly [number, number];
+            type C = [number, number, ...number[]];
           `,
+          // C's import edit spans A, so A follows in the next pass.
+          output: [
+            dedent`
+              import { type FixedLengthTuple, type MutableMinLengthTuple } from 'ts-type-forge';
+              type A = readonly [number, number];
+              type C = MutableMinLengthTuple<2, number>;
+            `,
+            dedent`
+              import { type FixedLengthTuple, type MutableMinLengthTuple } from 'ts-type-forge';
+              type A = FixedLengthTuple<2, number>;
+              type C = MutableMinLengthTuple<2, number>;
+            `,
+          ],
+          errors: [
+            { messageId: 'useCanonicalTuple' },
+            { messageId: 'useCanonicalTuple' },
+          ],
+        },
+        {
+          name: 'rewrites parameter and return type positions',
+          code: 'declare const f: (xs: readonly [number, number]) => [string, string];',
+          output: [
+            dedent`
+              import { type FixedLengthTuple, type MutableFixedLengthTuple } from 'ts-type-forge';
+              declare const f: (xs: FixedLengthTuple<2, number>) => [string, string];
+            `,
+            dedent`
+              import { type FixedLengthTuple, type MutableFixedLengthTuple } from 'ts-type-forge';
+              declare const f: (xs: FixedLengthTuple<2, number>) => MutableFixedLengthTuple<2, string>;
+            `,
+          ],
           errors: [
             { messageId: 'useCanonicalTuple' },
             { messageId: 'useCanonicalTuple' },

package/src/rules/prefer-canonical-mutable-record.test.mts

@@ -50,6 +50,13 @@ describe('prefer-canonical-mutable-record', () => {
           type A = Mutable<Record<string, number>>;
         `,
       },
+      {
+        name: 'stays silent when another ts-type-forge export is imported as `MutableRecord`',
+        code: dedent`
+          import { type DeepReadonly as MutableRecord } from 'ts-type-forge';
+          type A = Mutable<Record<string, number>>;
+        `,
+      },
       {
         name: 'stays silent when `MutableRecord` is bound to another module',
         code: dedent`
@@ -107,16 +114,124 @@ describe('prefer-canonical-mutable-record', () => {
           type A = Mutable<Record<string, number>>;
           type B = Mutable<ReadonlyRecord<string, boolean>>;
         `,
-        output: dedent`
-          import { type MutableRecord } from 'ts-type-forge';
-          type A = MutableRecord<string, number>;
-          type B = MutableRecord<string, boolean>;
-        `,
+        output: [
+          dedent`
+            import { type MutableRecord } from 'ts-type-forge';
+            type A = MutableRecord<string, number>;
+            type B = Mutable<ReadonlyRecord<string, boolean>>;
+          `,
+          dedent`
+            import { type MutableRecord } from 'ts-type-forge';
+            type A = MutableRecord<string, number>;
+            type B = MutableRecord<string, boolean>;
+          `,
+        ],
         errors: [
           { messageId: 'useMutableRecord' },
           { messageId: 'useMutableRecord' },
         ],
       },
+      {
+        name: 'adds the name to an existing `import type` from ts-type-forge',
+        code: dedent`
+          import type { Mutable } from 'ts-type-forge';
+          type A = Mutable<Record<string, number>>;
+        `,
+        output: dedent`
+          import type { Mutable, MutableRecord } from 'ts-type-forge';
+          type A = MutableRecord<string, number>;
+        `,
+        errors: [{ messageId: 'useMutableRecord' }],
+      },
+      {
+        name: 'adds the name to an existing `import { … }` from ts-type-forge',
+        code: dedent`
+          import { type Mutable, type DeepReadonly } from 'ts-type-forge';
+          type A = Mutable<Record<string, number>>;
+        `,
+        output: dedent`
+          import { type Mutable, type DeepReadonly, type MutableRecord } from 'ts-type-forge';
+          type A = MutableRecord<string, number>;
+        `,
+        errors: [{ messageId: 'useMutableRecord' }],
+      },
+      {
+        name: 'adds named braces after a lone default import',
+        code: dedent`
+          import forge from 'ts-type-forge';
+          type A = Mutable<Record<string, number>>;
+        `,
+        output: dedent`
+          import forge, { type MutableRecord } from 'ts-type-forge';
+          type A = MutableRecord<string, number>;
+        `,
+        errors: [{ messageId: 'useMutableRecord' }],
+      },
+      {
+        name: 'fills the empty braces of `import d, {}`',
+        code: dedent`
+          import forge, {} from 'ts-type-forge';
+          type A = Mutable<Record<string, number>>;
+        `,
+        output: dedent`
+          import forge, { type MutableRecord } from 'ts-type-forge';
+          type A = MutableRecord<string, number>;
+        `,
+        errors: [{ messageId: 'useMutableRecord' }],
+      },
+      {
+        name: 'fills the empty braces of `import type {}`',
+        code: dedent`
+          import type {} from 'ts-type-forge';
+          type A = Mutable<Record<string, number>>;
+        `,
+        output: dedent`
+          import type { MutableRecord } from 'ts-type-forge';
+          type A = MutableRecord<string, number>;
+        `,
+        errors: [{ messageId: 'useMutableRecord' }],
+      },
+      {
+        name: 'does not take the brace of import attributes for the specifiers',
+        code: dedent`
+          import type forge from 'ts-type-forge' with { 'resolution-mode': 'import' };
+          type A = Mutable<Record<string, number>>;
+        `,
+        output: dedent`
+          import { type MutableRecord } from 'ts-type-forge';
+          import type forge from 'ts-type-forge' with { 'resolution-mode': 'import' };
+          type A = MutableRecord<string, number>;
+        `,
+        errors: [{ messageId: 'useMutableRecord' }],
+      },
+      {
+        name: 'adds a new declaration beside a type-only default import',
+        code: dedent`
+          import type forge from 'ts-type-forge';
+          type A = Mutable<Record<string, number>>;
+        `,
+        output: dedent`
+          import { type MutableRecord } from 'ts-type-forge';
+          import type forge from 'ts-type-forge';
+          type A = MutableRecord<string, number>;
+        `,
+        errors: [{ messageId: 'useMutableRecord' }],
+      },
+      {
+        name: 'adds a new declaration beside a namespace import, after the directives',
+        code: dedent`
+          'use strict';
+          import * as forge from 'ts-type-forge';
+          type A = Mutable<Record<string, number>>;
+        `,
+        output: dedent`
+          'use strict';
+          import { type MutableRecord } from 'ts-type-forge';
+          import * as forge from 'ts-type-forge';
+          type A = MutableRecord<string, number>;
+        `,
+        errors: [{ messageId: 'useMutableRecord' }],
+      },
       {
         name: 'follows ts-type-forge import aliases on both sides',
         code: dedent`

package/src/rules/prefer-readonly-or-mutable-record.test.mts

@@ -120,8 +120,35 @@ describe('prefer-readonly-or-mutable-record', () => {
                   messageId: 'replaceWith',
                   data: { name: 'Record', replacement: 'MutableRecord' },
                   output: dedent`
-                    import { type MutableRecord } from 'ts-type-forge';
-                    import { type ReadonlyRecord as RRecord } from 'ts-type-forge';
+                    import { type ReadonlyRecord as RRecord, type MutableRecord } from 'ts-type-forge';
+                    type A = MutableRecord<string, number>;
+                  `,
+                },
+              ],
+            },
+          ],
+        },
+        {
+          name: 'adds the suggested name to an existing `import type`',
+          code: dedent`
+            import type { DeepReadonly } from 'ts-type-forge';
+            type A = Record<string, number>;
+          `,
+          errors: [
+            {
+              messageId: 'useReadonlyOrMutableRecord',
+              suggestions: [
+                {
+                  messageId: 'replaceWith',
+                  output: dedent`
+                    import type { DeepReadonly, ReadonlyRecord } from 'ts-type-forge';
+                    type A = ReadonlyRecord<string, number>;
+                  `,
+                },
+                {
+                  messageId: 'replaceWith',
+                  output: dedent`
+                    import type { DeepReadonly, MutableRecord } from 'ts-type-forge';
                     type A = MutableRecord<string, number>;
                   `,
                 },

package/src/rules/prefer-strict-or-relaxed-utility-type.test.mts

@@ -197,8 +197,7 @@ describe('prefer-strict-or-relaxed-utility-type', () => {
                   messageId: 'replaceWith',
                   data: { name: 'Pick', replacement: 'RelaxedPick' },
                   output: dedent`
-                    import { type RelaxedPick } from 'ts-type-forge';
-                    import { type StrictPick as SPick } from 'ts-type-forge';
+                    import { type StrictPick as SPick, type RelaxedPick } from 'ts-type-forge';
                     type A = RelaxedPick<{ a: 1 }, 'a'>;
                   `,
                 },