ts-codemod-lib 1.1.3 → 1.2.0

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

@@ -9,230 +9,238 @@ import { type TsMorphTransformer } from './types.mjs';
  * and index signatures `[k: string]: unknown` with `UnknownRecord`
  */
 export const replaceRecordWithUnknownRecordTransformer =
-  (): TsMorphTransformer => (sourceAst) => {
-    const processDeclarations = (
-      container: tsm.SourceFile | tsm.ModuleDeclaration,
-    ): void => {
-      const typeAliases = container.getTypeAliases();
+  (): TsMorphTransformer => {
+    const transformer: TsMorphTransformer = (sourceAst) => {
+      const processDeclarations = (
+        container: tsm.SourceFile | tsm.ModuleDeclaration,
+      ): void => {
+        const typeAliases = container.getTypeAliases();
 
-      for (const typeAlias of typeAliases) {
-        const typeNode = typeAlias.getTypeNode();
+        for (const typeAlias of typeAliases) {
+          const typeNode = typeAlias.getTypeNode();
 
-        if (typeNode === undefined) continue;
+          if (typeNode === undefined) continue;
 
-        visitTypeNode(typeNode);
-      }
+          visitTypeNode(typeNode);
+        }
 
-      const interfaces = container.getInterfaces();
+        const interfaces = container.getInterfaces();
 
-      for (const interfaceDecl of interfaces) {
-        // Check if interface has index signature [k: string]: unknown
-        const indexSignatures = interfaceDecl.getIndexSignatures();
+        for (const interfaceDecl of interfaces) {
+          // Check if interface has index signature [k: string]: unknown
+          const indexSignatures = interfaceDecl.getIndexSignatures();
 
-        const hasStringUnknownSignature = indexSignatures.some((sig) => {
-          const keyType = sig.getKeyType();
+          const hasStringUnknownSignature = indexSignatures.some((sig) => {
+            const keyType = sig.getKeyType();
 
-          const returnType = sig.getReturnType();
+            const returnType = sig.getReturnType();
 
-          return (
-            keyType.getText() === 'string' && returnType.getText() === 'unknown'
-          );
-        });
+            return (
+              keyType.getText() === 'string' &&
+              returnType.getText() === 'unknown'
+            );
+          });
 
-        // If it has the signature and no other members, replace entire interface with type alias
-        if (hasStringUnknownSignature) {
-          const properties = interfaceDecl.getProperties();
+          // If it has the signature and no other members, replace entire interface with type alias
+          if (hasStringUnknownSignature) {
+            const properties = interfaceDecl.getProperties();
 
-          if (properties.length === 0 && indexSignatures.length === 1) {
-            // Replace interface with type alias
-            const interfaceName = interfaceDecl.getName();
+            if (properties.length === 0 && indexSignatures.length === 1) {
+              // Replace interface with type alias
+              const interfaceName = interfaceDecl.getName();
 
-            interfaceDecl.replaceWithText(
-              `export type ${interfaceName} = UnknownRecord;`,
-            );
+              interfaceDecl.replaceWithText(
+                `export type ${interfaceName} = UnknownRecord;`,
+              );
 
-            continue;
+              continue;
+            }
           }
-        }
 
-        // Otherwise, check properties for Record types
-        for (const property of interfaceDecl.getProperties()) {
-          const typeNode = property.getTypeNode();
+          // Otherwise, check properties for Record types
+          for (const property of interfaceDecl.getProperties()) {
+            const typeNode = property.getTypeNode();
 
-          if (typeNode === undefined) continue;
+            if (typeNode === undefined) continue;
 
-          visitTypeNode(typeNode);
+            visitTypeNode(typeNode);
+          }
         }
-      }
-    };
+      };
 
-    const visitTypeNode = (node: tsm.TypeNode): void => {
-      if (tsm.Node.isTypeReference(node)) {
-        // Check if it's Readonly<{ [k: string]: unknown }>
-        if (node.getTypeName().getText() === 'Readonly') {
-          const typeArgs = node.getTypeArguments();
+      const visitTypeNode = (node: tsm.TypeNode): void => {
+        if (tsm.Node.isTypeReference(node)) {
+          // Check if it's Readonly<{ [k: string]: unknown }>
+          if (node.getTypeName().getText() === 'Readonly') {
+            const typeArgs = node.getTypeArguments();
 
-          if (typeArgs.length === 1) {
-            const typeArg = typeArgs[0];
+            if (typeArgs.length === 1) {
+              const typeArg = typeArgs[0];
 
-            if (tsm.Node.isTypeLiteral(typeArg)) {
-              const members = typeArg.getMembers();
+              if (tsm.Node.isTypeLiteral(typeArg)) {
+                const members = typeArg.getMembers();
 
-              const indexSigs = members.filter((m) =>
-                tsm.Node.isIndexSignatureDeclaration(m),
-              );
+                const indexSigs = members.filter((m) =>
+                  tsm.Node.isIndexSignatureDeclaration(m),
+                );
 
-              // Check if it has only one index signature [k: string]: unknown
-              if (
-                members.length === 1 &&
-                Arr.isArrayOfLength(indexSigs, 1) &&
-                isStringUnknownIndexSignature(indexSigs[0])
-              ) {
-                node.replaceWithText('UnknownRecord');
+                // Check if it has only one index signature [k: string]: unknown
+                if (
+                  members.length === 1 &&
+                  Arr.isArrayOfLength(indexSigs, 1) &&
+                  isStringUnknownIndexSignature(indexSigs[0])
+                ) {
+                  node.replaceWithText('UnknownRecord');
 
-                return;
-              }
+                  return;
+                }
 
-              // Otherwise, recurse into the type literal to visit its properties
-              visitTypeNode(typeArg);
+                // Otherwise, recurse into the type literal to visit its properties
+                visitTypeNode(typeArg);
 
-              return;
+                return;
+              }
             }
           }
-        }
 
-        replaceIfRecordUnknown(node);
-      }
+          replaceIfRecordUnknown(node);
+        }
 
-      // Check for type literal { [k: string]: unknown }
-      if (tsm.Node.isTypeLiteral(node)) {
-        const members = node.getMembers();
+        // Check for type literal { [k: string]: unknown }
+        if (tsm.Node.isTypeLiteral(node)) {
+          const members = node.getMembers();
 
-        const indexSigs = members.filter((m) =>
-          tsm.Node.isIndexSignatureDeclaration(m),
-        );
+          const indexSigs = members.filter((m) =>
+            tsm.Node.isIndexSignatureDeclaration(m),
+          );
 
-        // Check if it has only one index signature [k: string]: unknown
-        if (
-          members.length === 1 &&
-          Arr.isArrayOfLength(indexSigs, 1) &&
-          isStringUnknownIndexSignature(indexSigs[0])
-        ) {
-          node.replaceWithText('UnknownRecord');
+          // Check if it has only one index signature [k: string]: unknown
+          if (
+            members.length === 1 &&
+            Arr.isArrayOfLength(indexSigs, 1) &&
+            isStringUnknownIndexSignature(indexSigs[0])
+          ) {
+            node.replaceWithText('UnknownRecord');
 
-          return;
+            return;
+          }
         }
-      }
 
-      // Recursively visit child type nodes
-      if (tsm.Node.isUnionTypeNode(node)) {
-        for (const typeNode of node.getTypeNodes()) {
-          visitTypeNode(typeNode);
-        }
-      } else if (tsm.Node.isIntersectionTypeNode(node)) {
-        for (const typeNode of node.getTypeNodes()) {
-          visitTypeNode(typeNode);
-        }
-      } else if (tsm.Node.isArrayTypeNode(node)) {
-        visitTypeNode(node.getElementTypeNode());
-      } else if (tsm.Node.isTupleTypeNode(node)) {
-        for (const element of node.getElements()) {
-          visitTypeNode(element);
-        }
-      } else if (tsm.Node.isParenthesizedTypeNode(node)) {
-        visitTypeNode(node.getTypeNode());
-      } else if (tsm.Node.isTypeLiteral(node)) {
-        for (const member of node.getMembers()) {
-          if (tsm.Node.isPropertySignature(member)) {
-            const typeNode = member.getTypeNode();
-
-            if (typeNode !== undefined) {
-              visitTypeNode(typeNode);
-            }
-          } else if (tsm.Node.isIndexSignatureDeclaration(member)) {
-            const typeNode = member.getReturnTypeNode();
+        // Recursively visit child type nodes
+        if (tsm.Node.isUnionTypeNode(node)) {
+          for (const typeNode of node.getTypeNodes()) {
+            visitTypeNode(typeNode);
+          }
+        } else if (tsm.Node.isIntersectionTypeNode(node)) {
+          for (const typeNode of node.getTypeNodes()) {
+            visitTypeNode(typeNode);
+          }
+        } else if (tsm.Node.isArrayTypeNode(node)) {
+          visitTypeNode(node.getElementTypeNode());
+        } else if (tsm.Node.isTupleTypeNode(node)) {
+          for (const element of node.getElements()) {
+            visitTypeNode(element);
+          }
+        } else if (tsm.Node.isParenthesizedTypeNode(node)) {
+          visitTypeNode(node.getTypeNode());
+        } else if (tsm.Node.isTypeLiteral(node)) {
+          for (const member of node.getMembers()) {
+            if (tsm.Node.isPropertySignature(member)) {
+              const typeNode = member.getTypeNode();
+
+              if (typeNode !== undefined) {
+                visitTypeNode(typeNode);
+              }
+            } else if (tsm.Node.isIndexSignatureDeclaration(member)) {
+              const typeNode = member.getReturnTypeNode();
 
-            if (typeNode !== undefined) {
-              visitTypeNode(typeNode);
+              if (typeNode !== undefined) {
+                visitTypeNode(typeNode);
+              }
             }
           }
         }
-      }
-    };
+      };
 
-    const isStringUnknownIndexSignature = (
-      sig: tsm.IndexSignatureDeclaration,
-    ): boolean => {
-      const keyType = sig.getKeyTypeNode();
+      const isStringUnknownIndexSignature = (
+        sig: tsm.IndexSignatureDeclaration,
+      ): boolean => {
+        const keyType = sig.getKeyTypeNode();
 
-      const returnType = sig.getReturnTypeNode();
-
-      return (
-        keyType.getText() === 'string' && returnType?.getText() === 'unknown'
-      );
-    };
+        const returnType = sig.getReturnTypeNode();
 
-    const replaceIfRecordUnknown = (node: tsm.TypeReferenceNode): void => {
-      const typeName = node.getTypeName().getText();
-
-      switch (typeName) {
-        case 'Record': {
-          // Check if it's Record<string, unknown>
-          const typeArgs = node.getTypeArguments();
-
-          if (
-            typeArgs.length === 2 &&
-            typeArgs[0]?.getText() === 'string' &&
-            typeArgs[1]?.getText() === 'unknown'
-          ) {
-            node.replaceWithText('UnknownRecord');
-          }
+        return (
+          keyType.getText() === 'string' && returnType?.getText() === 'unknown'
+        );
+      };
 
-          break;
-        }
-        case 'Readonly': {
-          // Check if it's Readonly<Record<string, unknown>>
-          const typeArgs = node.getTypeArguments();
+      const replaceIfRecordUnknown = (node: tsm.TypeReferenceNode): void => {
+        const typeName = node.getTypeName().getText();
 
-          if (typeArgs.length === 1) {
-            const innerType = typeArgs[0];
+        switch (typeName) {
+          case 'Record': {
+            // Check if it's Record<string, unknown>
+            const typeArgs = node.getTypeArguments();
 
             if (
-              innerType !== undefined &&
-              tsm.Node.isTypeReference(innerType)
+              typeArgs.length === 2 &&
+              typeArgs[0]?.getText() === 'string' &&
+              typeArgs[1]?.getText() === 'unknown'
             ) {
-              const innerTypeName = innerType.getTypeName().getText();
+              node.replaceWithText('UnknownRecord');
+            }
 
-              if (innerTypeName === 'Record') {
-                const innerTypeArgs = innerType.getTypeArguments();
+            break;
+          }
+          case 'Readonly': {
+            // Check if it's Readonly<Record<string, unknown>>
+            const typeArgs = node.getTypeArguments();
 
-                if (
-                  innerTypeArgs.length === 2 &&
-                  innerTypeArgs[0]?.getText() === 'string' &&
-                  innerTypeArgs[1]?.getText() === 'unknown'
-                ) {
-                  node.replaceWithText('UnknownRecord');
+            if (typeArgs.length === 1) {
+              const innerType = typeArgs[0];
+
+              if (
+                innerType !== undefined &&
+                tsm.Node.isTypeReference(innerType)
+              ) {
+                const innerTypeName = innerType.getTypeName().getText();
+
+                if (innerTypeName === 'Record') {
+                  const innerTypeArgs = innerType.getTypeArguments();
+
+                  if (
+                    innerTypeArgs.length === 2 &&
+                    innerTypeArgs[0]?.getText() === 'string' &&
+                    innerTypeArgs[1]?.getText() === 'unknown'
+                  ) {
+                    node.replaceWithText('UnknownRecord');
+                  }
                 }
               }
             }
+
+            break;
           }
 
-          break;
+          default: {
+            break;
+          }
         }
+      };
 
-        default: {
-          break;
-        }
+      // Process top-level declarations
+      processDeclarations(sourceAst);
+
+      // Process declarations inside namespaces/modules
+      const namespaces = sourceAst.getModules();
+
+      for (const namespace of namespaces) {
+        processDeclarations(namespace);
       }
     };
 
-    // Process top-level declarations
-    processDeclarations(sourceAst);
-
-    // Process declarations inside namespaces/modules
-    const namespaces = sourceAst.getModules();
+    // eslint-disable-next-line functional/immutable-data
+    transformer.transformerName = 'replace-record-with-unknown-record';
 
-    for (const namespace of namespaces) {
-      processDeclarations(namespace);
-    }
+    return transformer;
   };

package/src/functions/ast-transformers/transform-source-code.mts

@@ -1,21 +1,59 @@
 import * as tsm from 'ts-morph';
-import { IGNORE_FILE_COMMENT_TEXT } from '../constants/index.mjs';
 import { type TsMorphTransformer } from './types.mjs';
 
+const extractFileIgnoreTransformers = (code: string): readonly string[] => {
+  const match = /\/\*\s*transformer-ignore\s*(.*?)\s*\*\//u.exec(code);
+
+  if (match === null) {
+    return [];
+  }
+
+  const targetTransformers = match[1]?.trim() ?? '';
+
+  // Empty means ignore all transformers
+  if (targetTransformers === '') {
+    return [];
+  }
+
+  // Parse comma-separated transformer names
+  return targetTransformers.split(',').map((name) => name.trim());
+};
+
+const shouldSkipFile = (
+  code: string,
+  transformerName: string | undefined,
+): boolean => {
+  const ignoredTransformers = extractFileIgnoreTransformers(code);
+
+  // If no file-level ignore comment found, don't skip
+  if (
+    ignoredTransformers.length === 0 &&
+    !/\/\*\s*transformer-ignore\s*.*?\s*\*\//u.test(code)
+  ) {
+    return false;
+  }
+
+  // Empty array means ignore all transformers (file-level ignore without specific transformers)
+  if (ignoredTransformers.length === 0) {
+    return true;
+  }
+
+  // If transformer name is not specified, don't skip
+  if (transformerName === undefined) {
+    return false;
+  }
+
+  // Check if the transformer is in the ignore list
+  return ignoredTransformers.includes(transformerName);
+};
+
 export const transformSourceCode = (
   code: string,
   isTsx: boolean,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   transformers: readonly TsMorphTransformer[],
   debug: boolean = false,
 ): string => {
-  if (code.includes(IGNORE_FILE_COMMENT_TEXT)) {
-    if (debug) {
-      console.debug('skipped by ignore-file comment');
-    }
-
-    return code;
-  }
-
   const project = new tsm.Project({
     useInMemoryFileSystem: true,
     compilerOptions: {
@@ -31,6 +69,18 @@ export const transformSourceCode = (
   );
 
   for (const transformer of transformers) {
+    const transformerName = transformer.transformerName;
+
+    if (shouldSkipFile(code, transformerName)) {
+      if (debug) {
+        console.debug(
+          `skipped by ignore-file comment${transformerName !== undefined ? ` for transformer: ${transformerName}` : ''}`,
+        );
+      }
+
+      continue;
+    }
+
     transformer(sourceAst);
   }
 

package/src/functions/ast-transformers/transformer-specific-ignore.test.mts

@@ -0,0 +1,190 @@
+/* eslint-disable tree-shakable/import-star */
+/* eslint-disable import-x/namespace */
+/* eslint-disable vitest/expect-expect */
+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 { appendAsConstTransformer } from './append-as-const.mjs';
+import { convertToReadonlyTypeTransformer } from './convert-to-readonly-type.mjs';
+import { replaceAnyWithUnknownTransformer } from './replace-any-with-unknown.mjs';
+import { transformSourceCode } from './transform-source-code.mjs';
+
+const testFn = async ({
+  source,
+  expected,
+  debug,
+}: Readonly<{
+  source: string;
+  expected: string;
+  debug?: boolean;
+}>): Promise<void> => {
+  if (debug !== true) {
+    // eslint-disable-next-line vitest/no-restricted-vi-methods
+    vi.spyOn(console, 'debug').mockImplementation(() => {});
+
+    // eslint-disable-next-line vitest/no-restricted-vi-methods
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+  }
+
+  const transformed = await formatter(
+    transformSourceCode(source, false, [
+      replaceAnyWithUnknownTransformer(),
+      appendAsConstTransformer(),
+      convertToReadonlyTypeTransformer(),
+    ]),
+  );
+
+  const expectedFormatted = await formatter(expected);
+
+  expect(transformed).toBe(expectedFormatted);
+};
+
+const formatter = (code: string): Promise<string> =>
+  prettier.format(code, {
+    parser: 'typescript',
+    plugins: [prettierPluginTypeScript, prettierPluginEstree],
+  });
+
+describe('Transformer-specific ignore comments (Integration)', () => {
+  test.each([
+    {
+      name: 'Ignore specific transformer on next line',
+      source: dedent`
+        // transformer-ignore-next-line replace-any-with-unknown
+        type A = any; // Should remain any
+        const b = [1, 2, 3]; // Should have as const
+        type C = number[]; // Should be readonly
+      `,
+      expected: dedent`
+        // transformer-ignore-next-line replace-any-with-unknown
+        type A = any; // Should remain any
+        const b = [1, 2, 3] as const; // Should have as const
+        type C = readonly number[]; // Should be readonly
+      `,
+    },
+    {
+      name: 'Ignore specific transformer for entire file',
+      source: dedent`
+        /* transformer-ignore replace-any-with-unknown */
+        type A = any; // Should remain any
+        const b = [1, 2, 3]; // Should have as const
+        type C = number[]; // Should be readonly
+        type D = any; // Should remain any
+      `,
+      expected: dedent`
+        /* transformer-ignore replace-any-with-unknown */
+        type A = any; // Should remain any
+        const b = [1, 2, 3] as const; // Should have as const
+        type C = readonly number[]; // Should be readonly
+        type D = any; // Should remain any
+      `,
+    },
+    {
+      name: 'Ignore multiple specific transformers on next line',
+      source: dedent`
+        type A = any;
+        // transformer-ignore-next-line replace-any-with-unknown, append-as-const
+        type B = any;
+        const c = [1, 2, 3];
+        type D = number[];
+      `,
+      expected: dedent`
+        type A = unknown;
+        // transformer-ignore-next-line replace-any-with-unknown, append-as-const
+        type B = any;
+        const c = [1, 2, 3] as const;
+        type D = readonly number[];
+      `,
+    },
+    {
+      name: 'Ignore multiple specific transformers for entire file',
+      source: dedent`
+        /* transformer-ignore replace-any-with-unknown, convert-to-readonly-type */
+        type A = any; // Should remain any
+        const b = [1, 2, 3]; // Should have as const
+        type C = number[]; // Should remain mutable
+        type D = any; // Should remain any
+      `,
+      expected: dedent`
+        /* transformer-ignore replace-any-with-unknown, convert-to-readonly-type */
+        type A = any; // Should remain any
+        const b = [1, 2, 3] as const; // Should have as const
+        type C = number[]; // Should remain mutable
+        type D = any; // Should remain any
+      `,
+    },
+    {
+      name: 'Different ignore comments for different lines',
+      source: dedent`
+        type A = any;
+        // transformer-ignore-next-line replace-any-with-unknown
+        type B = any;
+        const c = [1, 2, 3];
+        // transformer-ignore-next-line append-as-const
+        const d = [4, 5, 6];
+        type E = number[];
+        // transformer-ignore-next-line convert-to-readonly-type
+        type F = string[];
+      `,
+      expected: dedent`
+        type A = unknown;
+        // transformer-ignore-next-line replace-any-with-unknown
+        type B = any;
+        const c = [1, 2, 3] as const;
+        // transformer-ignore-next-line append-as-const
+        const d = [4, 5, 6];
+        type E = readonly number[];
+        // transformer-ignore-next-line convert-to-readonly-type
+        type F = string[];
+      `,
+    },
+    {
+      name: 'Wrong transformer name should not affect any transformer',
+      source: dedent`
+        // transformer-ignore-next-line non-existent-transformer
+        type A = any; // Should be unknown
+        const b = [1, 2, 3]; // Should have as const
+        type C = number[]; // Should be readonly
+      `,
+      expected: dedent`
+        // transformer-ignore-next-line non-existent-transformer
+        type A = unknown; // Should be unknown
+        const b = [1, 2, 3] as const; // Should have as const
+        type C = readonly number[]; // Should be readonly
+      `,
+    },
+    {
+      name: 'Ignore all transformers on next line (no transformer specified)',
+      source: dedent`
+        type A = any;
+        // transformer-ignore-next-line
+        type B = any;
+        const c = [1, 2, 3];
+        type D = number[];
+      `,
+      expected: dedent`
+        type A = unknown;
+        // transformer-ignore-next-line
+        type B = any;
+        const c = [1, 2, 3] as const;
+        type D = readonly number[];
+      `,
+    },
+    {
+      name: 'Ignore all transformers for entire file (no transformer specified)',
+      source: dedent`
+        /* transformer-ignore */
+        type A = any; // Should remain any
+        const b = [1, 2, 3]; // Should remain without as const
+        type C = number[]; // Should remain mutable
+      `,
+      expected: dedent`
+        /* transformer-ignore */
+        type A = any; // Should remain any
+        const b = [1, 2, 3]; // Should remain without as const
+        type C = number[]; // Should remain mutable
+      `,
+    },
+  ])('$name', testFn);
+});