ts-codemod-lib 3.3.1 → 3.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-codemod-lib",
-  "version": "3.3.1",
+  "version": "3.3.3",
   "private": false,
   "keywords": [
     "typescript",
@@ -38,44 +38,44 @@
     "LICENSE"
   ],
   "dependencies": {
-    "ts-data-forge": "^14.6.3",
+    "ts-data-forge": "^14.7.1",
     "ts-morph": "^28.0.0",
     "ts-type-forge": "^9.2.2"
   },
   "devDependencies": {
-    "@types/node": "26.4.1",
-    "@vitest/browser-playwright": "4.1.11",
-    "@vitest/coverage-v8": "4.1.11",
-    "@vitest/ui": "4.1.11",
-    "cspell": "10.1.1",
+    "@types/node": "26.6.1",
+    "@vitest/browser-playwright": "5.0.1",
+    "@vitest/coverage-v8": "5.0.1",
+    "@vitest/ui": "5.0.1",
+    "cspell": "10.3.3",
     "dedent": "1.7.2",
     "esbuild": "0.28.2",
-    "eslint": "10.9.1",
-    "eslint-config-typed": "5.11.2",
-    "eslint-plugin-ts-data-forge": "0.7.0",
-    "eslint-plugin-ts-fortress": "1.2.0",
-    "eslint-plugin-ts-type-forge": "0.8.1",
+    "eslint": "10.10.0",
+    "eslint-config-typed": "5.14.0",
+    "eslint-plugin-ts-data-forge": "0.8.1",
+    "eslint-plugin-ts-fortress": "1.2.3",
+    "eslint-plugin-ts-type-forge": "0.8.4",
     "jiti": "2.7.0",
     "npm-run-all2": "9.0.3",
-    "playwright": "1.62.1",
-    "prettier": "3.9.6",
+    "playwright": "1.63.0",
+    "prettier": "3.9.7",
     "prettier-plugin-organize-imports": "4.3.0",
     "prettier-plugin-packagejson": "3.0.2",
-    "ts-repo-utils": "10.6.0",
-    "tsx": "4.23.12",
+    "ts-repo-utils": "10.7.1",
+    "tsx": "4.23.13",
     "typedoc": "0.28.20",
     "typedoc-github-theme": "0.4.0",
     "typescript": "6.0.3",
     "typescript-native": "npm:typescript@7.0.2",
-    "vite": "8.2.2",
-    "vitest": "4.1.11"
+    "vite": "8.3.0",
+    "vitest": "5.0.1"
   },
   "engines": {
     "node": ">=22.22.2",
     "pnpm": ">=9.0.0"
   },
   "volta": {
-    "node": "26.3.1"
+    "node": "26.9.0"
   },
   "publishConfig": {
     "access": "public",
@@ -83,37 +83,39 @@
   },
   "scripts": {
     "build": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/build.mts",
-    "build:min": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/build.mts --skip-check",
+    "check:cspell": "cspell \"**\" --gitignore --gitignore-root ../../ --no-progress",
+    "check:dist": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/check-dist.mts",
     "check:ext": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/check-ext.mts",
+    "check:lint": "eslint .",
+    "check:test": "pnpm run z:vitest:node run",
+    "check:test:browser": "pnpm run z:vitest --project='Browser' run",
+    "check:test:cov": "pnpm run z:vitest:node run --coverage",
+    "check:types": "node ../../node_modules/typescript-native/bin/tsc --noEmit",
     "check-all": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/check-all.mts",
     "clean": "pnpm run /clean:.*/",
     "clean:logs": "npx rimraf ./*.log",
-    "codemod": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../ts-codemod-cli/src/cmd/ts-codemod.mts --uncommitted --transformer append-as-const --transformer convert-interface-to-type --transformer convert-to-readonly --transformer replace-any-with-unknown --transformer replace-record-with-unknown-record '{src,scripts,samples,test}/**/*.{mts,tsx}' && pnpm run fmt",
-    "codemod:diff": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../ts-codemod-cli/src/cmd/ts-codemod.mts --diff-from origin/main --transformer append-as-const --transformer convert-interface-to-type --transformer convert-to-readonly --transformer replace-any-with-unknown --transformer replace-record-with-unknown-record '{src,scripts,samples,test}/**/*.{mts,tsx}' && pnpm run fmt",
-    "codemod:full": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../ts-codemod-cli/src/cmd/ts-codemod.mts --transformer append-as-const --transformer convert-interface-to-type --transformer convert-to-readonly --transformer replace-any-with-unknown --transformer replace-record-with-unknown-record '{src,scripts,samples,test}/**/*.{mts,tsx}' && pnpm run fmt",
-    "cspell": "cspell \"**\" --gitignore --gitignore-root ../../ --no-progress",
     "doc": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/gen-docs.mts",
-    "doc:embed": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/embed-examples.mts",
     "doc:preview": "vite preview --config ./configs/vite.doc.config.mts",
-    "doc:watch": "typedoc --options ./configs/typedoc.config.mjs --watch",
-    "fmt": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/format-uncommitted.mts --cwd .",
-    "fmt:diff": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/format-diff-from.mts origin/main --cwd .",
-    "fmt:full": "prettier --write .",
-    "gi": "run-s gi:src fmt",
-    "gi:src": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/gen-index-ts.mts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --exclude entry-point.mts",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "prepare-release": "run-s fmt build doc",
+    "fix:codemod": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../ts-codemod-cli/src/cmd/ts-codemod.mts --uncommitted --transformer append-as-const --transformer convert-interface-to-type --transformer convert-to-readonly --transformer replace-any-with-unknown --transformer replace-record-with-unknown-record '{src,scripts,samples,test}/**/*.{mts,tsx}' && pnpm run fix:fmt",
+    "fix:codemod:diff": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../ts-codemod-cli/src/cmd/ts-codemod.mts --diff-from origin/main --transformer append-as-const --transformer convert-interface-to-type --transformer convert-to-readonly --transformer replace-any-with-unknown --transformer replace-record-with-unknown-record '{src,scripts,samples,test}/**/*.{mts,tsx}' && pnpm run fix:fmt",
+    "fix:codemod:full": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../ts-codemod-cli/src/cmd/ts-codemod.mts --transformer append-as-const --transformer convert-interface-to-type --transformer convert-to-readonly --transformer replace-any-with-unknown --transformer replace-record-with-unknown-record '{src,scripts,samples,test}/**/*.{mts,tsx}' && pnpm run fix:fmt",
+    "fix:fmt": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/format-uncommitted.mts --cwd .",
+    "fix:fmt:diff": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/format-diff-from.mts origin/main --cwd .",
+    "fix:fmt:full": "prettier --write .",
+    "fix:lint": "eslint . --fix",
+    "fmt": "pnpm run fix:fmt",
+    "gen": "run-s gen:index gen:readme gen:jsdoc",
+    "gen:index": "run-s gen:index:src fix:fmt",
+    "gen:index:src": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/gen-index-ts.mts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --exclude entry-point.mts",
+    "gen:jsdoc": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/embed-examples-in-jsdoc.mts",
+    "gen:readme": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/embed-examples.mts",
     "run:test": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/test-code/transform-test-code.mts",
-    "test": "pnpm run z:vitest:node run",
-    "test:browser": "pnpm run z:vitest --project='Browser' run",
-    "test:cov": "pnpm run z:vitest:node run --coverage",
+    "test": "pnpm run check:test",
     "test:cov:ui": "vite preview --outDir ./coverage",
     "test:ui": "pnpm run z:vitest:node --ui",
-    "testw": "pnpm run z:vitest:node watch",
-    "tsc": "node ../../node_modules/typescript-native/bin/tsc --noEmit",
-    "tscw": "node ../../node_modules/typescript-native/bin/tsc --noEmit --watch -p ./tsconfig.json",
-    "type-check": "node ../../node_modules/typescript-native/bin/tsc --noEmit",
+    "watch:doc": "typedoc --options ./configs/typedoc.config.mjs --watch",
+    "watch:test": "pnpm run z:vitest:node watch",
+    "watch:types": "node ../../node_modules/typescript-native/bin/tsc --noEmit --watch -p ./tsconfig.json",
     "z:vitest": "vitest --config ./configs/vitest.config.mts",
     "z:vitest:node": "pnpm run z:vitest --project='Node.js'"
   }

package/src/functions/ast-transformers/append-as-const.mts

@@ -362,28 +362,30 @@ const transformNode = (
     return;
   }
 
-  if (tsm.Node.isConditionalExpression(node)) {
-    // For conditional expressions, traverse both branches in a non-const context
-    transformNode(
-      node.getWhenTrue(),
-      {
-        isDirectUnderConstInitializer: context.isDirectUnderConstInitializer,
-        isUnderConstContext: false,
-      },
-      options,
-    );
+  if (!tsm.Node.isConditionalExpression(node)) {
+    return;
+  }
 
-    transformNode(
-      node.getWhenFalse(),
-      {
-        isDirectUnderConstInitializer: context.isDirectUnderConstInitializer,
-        isUnderConstContext: false,
-      },
-      options,
-    );
+  // For conditional expressions, traverse both branches in a non-const context
+  transformNode(
+    node.getWhenTrue(),
+    {
+      isDirectUnderConstInitializer: context.isDirectUnderConstInitializer,
+      isUnderConstContext: false,
+    },
+    options,
+  );
 
-    // return;
-  }
+  transformNode(
+    node.getWhenFalse(),
+    {
+      isDirectUnderConstInitializer: context.isDirectUnderConstInitializer,
+      isUnderConstContext: false,
+    },
+    options,
+  );
+
+  // return;
 };
 
 /**

package/src/functions/ast-transformers/convert-to-readonly.mts

@@ -15,6 +15,7 @@ import {
   type StrictExtract,
 } from 'ts-type-forge';
 import {
+  hasCallOrConstructSignature,
   hasDisableNextLineComment,
   isAtomicTypeNode,
   isConditionalTypeDistributionGuard,
@@ -1032,10 +1033,24 @@ const transformTypeLiteralNode = (
     return;
   }
 
+  // Whether this position is one where the literal is wrapped at all — a
+  // context that already carries `Readonly` or `DeepReadonly` does it, and
+  // inside an indexed access the modifier makes no difference to the result.
+  const wrappingApplies =
+    readonlyContext.type === 'none' && readonlyContext.indexedAccessDepth === 0;
+
+  // A call or construct signature does not survive `Readonly<T>`, so a literal
+  // carrying one is left unwrapped and marked readonly member by member
+  // instead. See `hasCallOrConstructSignature`.
+  const skipWrapping = wrappingApplies && hasCallOrConstructSignature(node);
+
   // Recursive processing
   transformMembers(
     node.getMembers(),
-    'remove',
+    // A wrapper — the one added below, or the one the context already carries —
+    // is what makes the members readonly, so an inner modifier would be
+    // redundant. Without one, each member has to say so itself.
+    skipWrapping ? 'add' : 'remove',
     nextReadonlyContext({
       currentReadonlyContext: readonlyContext,
       nextReadonlyContextType: 'none',
@@ -1044,18 +1059,9 @@ const transformTypeLiteralNode = (
     options,
   );
 
-  switch (readonlyContext.type) {
-    case 'DeepReadonly':
-    case 'Readonly':
-      // Don't wrap with Readonly if already readonly
-      return;
-
-    case 'none': {
-      if (readonlyContext.indexedAccessDepth === 0) {
-        // `{ readonly x: X, readonly y: Y } |-> Readonly<{ x: X, y: Y }>`
-        options.replaceNode(node, `Readonly<${node.getFullText()}>`);
-      }
-    }
+  if (wrappingApplies && !skipWrapping) {
+    // `{ readonly x: X, readonly y: Y } |-> Readonly<{ x: X, y: Y }>`
+    options.replaceNode(node, `Readonly<${node.getFullText()}>`);
   }
 };
 

package/src/functions/ast-transformers/convert-to-readonly.test.mts

@@ -6,7 +6,6 @@ import dedent from 'dedent';
 import * as prettierPluginEstree from 'prettier/plugins/estree';
 import * as prettierPluginTypeScript from 'prettier/plugins/typescript';
 import * as prettier from 'prettier/standalone';
-import { isString } from 'ts-data-forge';
 import {
   convertToReadonlyTransformer,
   type ReadonlyTransformerOptions,
@@ -64,15 +63,8 @@ const normalizeWhitespaceForComparison = (code: string): string => {
   // 1. Protect newlines immediately following line comments
   const protectedCode = code.replaceAll(
     /(\/\/.*?)\r?\n/gu,
-    // The strict standard library types a capture group as `unknown`: an
-    // optional group is `undefined` when it does not participate, so `string`
-    // is not something the signature can promise. This group is not optional,
-    // so the narrowing never actually fails — it just has to be written.
-    (match: string, ...args: readonly unknown[]): string => {
-      const comment = args[0];
-
-      return isString(comment) ? `${comment}${placeholder}` : match;
-    },
+    (match: string, comment: string | undefined): string =>
+      comment === undefined ? match : `${comment}${placeholder}`,
   );
 
   // 2. Collapse multiple whitespace characters (including unprotected newlines) into a single space
@@ -3255,6 +3247,125 @@ describe(convertToReadonlyTransformer, () => {
     ])('$name', testFn);
   });
 
+  describe('Call and construct signatures', () => {
+    // `Readonly<T>` is a mapped type over `keyof T`, and a call or construct
+    // signature is not a property, so wrapping a type literal that carries one
+    // silently drops it — the value stops being callable. See #1881.
+    test.each([
+      {
+        name: 'Overloaded call signatures are not wrapped',
+        source: dedent`
+          const panic: {
+            (message: string, options?: { cause?: unknown }): never;
+            (error: Error): never;
+          } = impl;
+        `,
+        expected: dedent`
+          const panic: {
+            (message: string, options?: Readonly<{ cause?: unknown }>): never;
+            (error: Error): never;
+          } = impl;
+        `,
+      },
+      {
+        name: 'A single call signature is not wrapped',
+        source: dedent`
+          type F = { (arg: number[]): string[] };
+        `,
+        expected: dedent`
+          type F = { (arg: readonly number[]): readonly string[] };
+        `,
+      },
+      {
+        name: 'A construct signature is not wrapped',
+        source: dedent`
+          type C = { new (arg: string[]): { prop: number[] } };
+        `,
+        expected: dedent`
+          type C = { new (arg: readonly string[]): Readonly<{ prop: readonly number[] }> };
+        `,
+      },
+      {
+        name: 'Members alongside a call signature are marked readonly in place',
+        source: dedent`
+          type F = {
+            (arg: number[]): void;
+            prop: string[];
+            [key: string]: unknown;
+          };
+        `,
+        expected: dedent`
+          type F = {
+            (arg: readonly number[]): void;
+            readonly prop: readonly string[];
+            readonly [key: string]: unknown;
+          };
+        `,
+      },
+      {
+        name: 'Members alongside a construct signature are marked readonly in place',
+        source: dedent`
+          type C = {
+            new (arg: string[]): unknown;
+            readonly prop: number[];
+          };
+        `,
+        expected: dedent`
+          type C = {
+            new (arg: readonly string[]): unknown;
+            readonly prop: readonly number[];
+          };
+        `,
+      },
+      {
+        name: 'A callable type literal in a union is left alone',
+        source: dedent`
+          type T = { (): void } | { a: number[] };
+        `,
+        expected: dedent`
+          type T = { (): void } | Readonly<{ a: readonly number[] }>;
+        `,
+      },
+      {
+        name: 'A callable type literal in an intersection is left alone',
+        source: dedent`
+          type T = { (): void } & { a: number[] };
+        `,
+        expected: dedent`
+          type T = { (): void } & Readonly<{ a: readonly number[] }>;
+        `,
+      },
+      {
+        name: 'A nested callable type literal is left alone',
+        source: dedent`
+          type T = { fn: { (): void }; a: number[] };
+        `,
+        expected: dedent`
+          type T = Readonly<{ fn: { (): void }; a: readonly number[] }>;
+        `,
+      },
+    ])('$name', testFn);
+
+    test('a callable type literal reaches a fixed point', () => {
+      const code = dedent`
+        const panic: {
+          (message: string, options?: { cause?: unknown }): never;
+          (error: Error): never;
+        } = impl;
+      `;
+
+      const once = transformSourceCode(code, false, [
+        convertToReadonlyTransformer(),
+      ]);
+
+      const twice = transformSourceCode(once, false, [
+        convertToReadonlyTransformer(),
+      ]);
+
+      expect(twice).toBe(once);
+    });
+  });
+
   describe('Generic Types', () => {
     test.each([
       {

package/src/functions/ast-transformers/enable-no-unchecked-indexed-access.mts

@@ -37,17 +37,40 @@ const TRANSFORMER_NAME = 'enable-no-unchecked-indexed-access';
  * as the `if` of `const v = xs[0]!; if (v === undefined) …` now is.
  *
  * @example
+ *
  * ```ts
- * declare const xs: readonly number[];
- * declare const pair: readonly [number, number];
- * declare const rec: Record<string, number>;
- * declare const known: { a: number };
+ * const before = dedent`
+ *   declare const xs: readonly number[];
+ *   declare const pair: readonly [number, number];
+ *   declare const rec: Record<string, number>;
+ *   declare const known: { a: number };
+ *
+ *   xs[0].toFixed();
+ *   rec['a'].toFixed();
+ *   rec.a.toFixed();
+ *   pair[1].toFixed();
+ *   known.a.toFixed();
+ * `;
+ *
+ * const after = transformSourceCode(before, false, [
+ *   enableNoUncheckedIndexedAccessTransformer(),
+ * ]);
+ *
+ * assert.deepStrictEqual(
+ *   after.trim(),
+ *   dedent`
+ *     declare const xs: readonly number[];
+ *     declare const pair: readonly [number, number];
+ *     declare const rec: Record<string, number>;
+ *     declare const known: { a: number };
  *
- * xs[0].toFixed(); // -> xs[0]!.toFixed();
- * rec['a'].toFixed(); // -> rec['a']!.toFixed();
- * rec.a.toFixed(); // -> rec.a!.toFixed();
- * pair[1].toFixed(); // -> pair[1].toFixed(); (guaranteed to exist)
- * known.a.toFixed(); // -> known.a.toFixed(); (guaranteed to exist)
+ *     xs[0]!.toFixed();
+ *     rec['a']!.toFixed();
+ *     rec.a!.toFixed();
+ *     pair[1].toFixed();
+ *     known.a.toFixed();
+ *   `,
+ * );
  * ```
  */
 export const enableNoUncheckedIndexedAccessTransformer = (

package/src/functions/ast-transformers/enable-no-unchecked-indexed-access.test.mts

@@ -84,7 +84,7 @@ const transformInProject = (
  * off. A case that went through it therefore paid for the whole default
  * library, `lib.esnext.full.d.ts` with the DOM inside it, being parsed and
  * checked from scratch: ~300 ms a case, of which the file under test was a
- * fraction of a millisecond. Sixty of those took `test:cov` past Vitest's
+ * fraction of a millisecond. Sixty of those took `check:test:cov` past Vitest's
  * timeout on CI.
  *
  * Reusing the project is half of the answer and the smaller half — measured,

package/src/functions/ast-transformers/readonly-transformer-helpers/group-union-types.mts

@@ -1,5 +1,6 @@
 import * as tsm from 'ts-morph';
 import {
+  hasCallOrConstructSignature,
   isAtomicTypeNode,
   isReadonlyTupleOrArrayTypeNode,
   isReadonlyTypeReferenceNode,
@@ -121,8 +122,14 @@ export const groupUnionIntersectionTypes = (
       continue;
     }
 
+    // A type literal that declares a call or construct signature is deliberately
+    // not grouped here: this group is joined and wrapped in a single
+    // `Readonly<...>`, which such a literal does not survive. It falls through
+    // to `others`, which leaves it as written. See
+    // `hasCallOrConstructSignature`.
     if (
-      t.isKind(tsm.SyntaxKind.TypeLiteral) ||
+      (t.isKind(tsm.SyntaxKind.TypeLiteral) &&
+        !hasCallOrConstructSignature(t)) ||
       isReadonlyTypeReferenceNode(t)
     ) {
       if (mut_grouped.typeLiterals === undefined) {

package/src/functions/ast-transformers/replace-record-with-unknown-record.mts

@@ -44,9 +44,7 @@ const processDeclarations = (
 
     const typeNode = typeAlias.getTypeNode();
 
-    if (typeNode === undefined) return false;
-
-    return visitTypeNode(typeNode);
+    return typeNode !== undefined && visitTypeNode(typeNode);
   });
 
   const interfaceModifications = container
@@ -103,9 +101,7 @@ const processInterfaceDeclaration = (
     .map((property) => {
       const typeNode = property.getTypeNode();
 
-      if (typeNode === undefined) return false;
-
-      return visitTypeNode(typeNode);
+      return typeNode !== undefined && visitTypeNode(typeNode);
     })
     .includes(true);
 };
@@ -170,13 +166,13 @@ const visitTypeNode = (node: tsm.TypeNode): boolean => {
         if (tsm.Node.isPropertySignature(member)) {
           const typeNode = member.getTypeNode();
 
-          return typeNode === undefined ? false : visitTypeNode(typeNode);
+          return typeNode !== undefined && visitTypeNode(typeNode);
         }
 
         if (tsm.Node.isIndexSignatureDeclaration(member)) {
           const typeNode = member.getReturnTypeNode();
 
-          return typeNode === undefined ? false : visitTypeNode(typeNode);
+          return typeNode !== undefined && visitTypeNode(typeNode);
         }
 
         return false;
@@ -202,19 +198,12 @@ const visitTypeNode = (node: tsm.TypeNode): boolean => {
   }
 
   // Handles `readonly T[]`, `readonly [...]`, `keyof T`
-  if (tsm.Node.isTypeOperatorTypeNode(node)) {
-    return visitTypeNode(node.getTypeNode());
-  }
-
-  if (tsm.Node.isRestTypeNode(node)) {
-    return visitTypeNode(node.getTypeNode());
-  }
-
-  if (tsm.Node.isNamedTupleMember(node)) {
-    return visitTypeNode(node.getTypeNode());
-  }
-
-  return false;
+  return (
+    (tsm.Node.isTypeOperatorTypeNode(node) ||
+      tsm.Node.isRestTypeNode(node) ||
+      tsm.Node.isNamedTupleMember(node)) &&
+    visitTypeNode(node.getTypeNode())
+  );
 };
 
 const isStringUnknownIndexSignature = (
@@ -305,7 +294,9 @@ const ensureUnknownRecordImport = (sourceFile: tsm.SourceFile): void => {
     .getNamedImports()
     .some((ni) => ni.getName() === UNKNOWN_RECORD_NAME);
 
-  if (alreadyImported) return;
+  if (alreadyImported) {
+    return;
+  }
 
   existingImport.addNamedImport({
     name: UNKNOWN_RECORD_NAME,