eslint-plugin-ts-type-forge 0.8.15 → 0.8.17

package/src/rule-types.mts

@@ -15,9 +15,9 @@ type SpreadOptionsIfIsArray<
   : T;
 
 /**
- * Extracts the options tuple type of a rule from its TypeScript
- * implementation, so that option types stay in sync with the rule source
- * without converting `meta.schema` (JSON Schema) back into TypeScript types.
+ * Extracts the options tuple type of a rule from its TypeScript implementation,
+ * so that option types stay in sync with the rule source without converting
+ * `meta.schema` (JSON Schema) back into TypeScript types.
  */
 type RuleOptionsOf<Name extends keyof typeof tsTypeForgeRules> =
   (typeof tsTypeForgeRules)[Name] extends TSESLint.RuleModule<
@@ -68,7 +68,7 @@ namespace PreferCanonicalLengthConstrainedTuple {
    *           "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';` when the name is not imported yet; 'global' assumes the ambient globals of `ts-type-forge/global` and never touches imports."
+   *         "description": "How the ts-type-forge type is brought into scope. 'named' (default) makes the autofix import the type from `ts-type-forge` 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."
    *       },
    *       "maxLength": {
    *         "type": "integer",
@@ -117,7 +117,7 @@ namespace PreferCanonicalMutableRecord {
    *           "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';` when the name is not imported yet; 'global' assumes the ambient globals of `ts-type-forge/global` and never touches imports."
+   *         "description": "How the ts-type-forge type is brought into scope. 'named' (default) makes the autofix import the type from `ts-type-forge` 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."
    *       }
    *     },
    *     "additionalProperties": false
@@ -161,7 +161,7 @@ namespace PreferReadonlyOrMutableRecord {
    *           "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';` when the name is not imported yet; 'global' assumes the ambient globals of `ts-type-forge/global` and never touches imports."
+   *         "description": "How the ts-type-forge type is brought into scope. 'named' (default) makes the autofix import the type from `ts-type-forge` 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."
    *       }
    *     },
    *     "additionalProperties": false
@@ -205,7 +205,7 @@ namespace PreferStrictOrRelaxedUtilityType {
    *           "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';` when the name is not imported yet; 'global' assumes the ambient globals of `ts-type-forge/global` and never touches imports."
+   *         "description": "How the ts-type-forge type is brought into scope. 'named' (default) makes the autofix import the type from `ts-type-forge` 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."
    *       }
    *     },
    *     "additionalProperties": false

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,8 +33,9 @@ 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
- * resolve to the wrong declaration, which is exactly what happens inside
+ * 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.
  */
 export const resolveTypeName = (

package/src/rules/import-utils.mts

@@ -1,12 +1,33 @@
-import { AST_NODE_TYPES, type TSESTree } from '@typescript-eslint/utils';
+import {
+  AST_NODE_TYPES,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import { addTypeImports, importedNameOf } from 'eslint-rule-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 `addTypeImports` places them.
+ *
+ * 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[] =>
+  addTypeImports(fixer, sourceCode, TS_TYPE_FORGE_MODULE, names);
+
 /**
  * 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 +41,14 @@ 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 &&
+            importedNameOf(specifier) === name
+          ),
       );
     }
 

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'>;
                   `,
                 },