ts-codemod-lib 1.0.1

package/src/functions/ast-transformers/index.mts

@@ -0,0 +1,6 @@
+export * from './convert-interface-to-type.mjs';
+export * from './convert-to-readonly-type.mjs';
+export * from './readonly-transformer-helpers/index.mjs';
+export * from './replace-record-with-unknown-record.mjs';
+export * from './transform-source-code.mjs';
+export * from './types.mjs';

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

@@ -0,0 +1,24 @@
+import * as tsm from 'ts-morph';
+import {
+  isPrimitiveTypeNode,
+  isReadonlyTupleOrArrayTypeNode,
+} from '../../functions/index.mjs';
+
+export const compareUnionIntersectionTypes = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  a: tsm.TypeNode,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  b: tsm.TypeNode,
+): number => mapRank(a) - mapRank(b);
+
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+const mapRank = (t: tsm.TypeNode): number =>
+  isPrimitiveTypeNode(t)
+    ? 0
+    : t.isKind(tsm.SyntaxKind.ArrayType) ||
+        t.isKind(tsm.SyntaxKind.TupleType) ||
+        isReadonlyTupleOrArrayTypeNode(t)
+      ? 1
+      : t.isKind(tsm.SyntaxKind.TypeLiteral)
+        ? 2
+        : 3;

package/src/functions/ast-transformers/readonly-transformer-helpers/constants.mts

@@ -0,0 +1,12 @@
+import { ISet } from 'ts-data-forge';
+
+export const invalidDeepReadonlyTypeName = ISet.create([
+  'Readonly',
+  'readonly',
+  'ReadonlyArray',
+  'Array',
+  'Set',
+  'Map',
+  'ReadonlySet',
+  'ReadonlyMap',
+]);

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

@@ -0,0 +1,152 @@
+import * as tsm from 'ts-morph';
+import {
+  isPrimitiveTypeNode,
+  isReadonlyTupleOrArrayTypeNode,
+  isReadonlyTypeReferenceNode,
+  removeParentheses,
+  type PrimitiveTypeNode,
+  type ReadonlyArrayTypeNode,
+  type ReadonlyTupleTypeNode,
+  type ReadonlyTypeReferenceNode,
+} from '../../functions/index.mjs';
+
+export const groupUnionIntersectionTypes = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  types: readonly tsm.TypeNode[],
+): Readonly<{
+  primitives:
+    | Readonly<{
+        firstPosition: number;
+        nodes: readonly PrimitiveTypeNode[];
+      }>
+    | undefined;
+
+  arraysAndTuples:
+    | Readonly<{
+        firstPosition: number;
+        nodes: readonly (
+          | tsm.ArrayTypeNode
+          | tsm.TupleTypeNode
+          | ReadonlyArrayTypeNode
+          | ReadonlyTupleTypeNode
+        )[];
+      }>
+    | undefined;
+
+  typeLiterals:
+    | Readonly<{
+        firstPosition: number;
+        nodes: readonly (tsm.TypeLiteralNode | ReadonlyTypeReferenceNode)[];
+      }>
+    | undefined;
+
+  others:
+    | Readonly<{
+        firstPosition: number;
+        nodes: readonly tsm.TypeNode[];
+      }>
+    | undefined;
+}> => {
+  const mut_grouped: {
+    primitives:
+      | Readonly<{
+          firstPosition: number;
+          nodes: PrimitiveTypeNode[];
+        }>
+      | undefined;
+
+    arraysAndTuples:
+      | Readonly<{
+          firstPosition: number;
+          nodes: (
+            | tsm.ArrayTypeNode
+            | tsm.TupleTypeNode
+            | ReadonlyArrayTypeNode
+            | ReadonlyTupleTypeNode
+          )[];
+        }>
+      | undefined;
+
+    typeLiterals:
+      | Readonly<{
+          firstPosition: number;
+          nodes: (tsm.TypeLiteralNode | ReadonlyTypeReferenceNode)[];
+        }>
+      | undefined;
+
+    others:
+      | Readonly<{
+          firstPosition: number;
+          nodes: tsm.TypeNode[];
+        }>
+      | undefined;
+  } = {
+    primitives: undefined,
+    arraysAndTuples: undefined,
+    typeLiterals: undefined,
+    others: undefined,
+  };
+
+  for (const [i, t_] of types.entries()) {
+    const t = removeParentheses(t_);
+
+    // isReadonlyTypeReferenceNode
+    if (isPrimitiveTypeNode(t)) {
+      if (mut_grouped.primitives === undefined) {
+        mut_grouped.primitives = {
+          firstPosition: i,
+          nodes: [t],
+        } as const;
+      } else {
+        mut_grouped.primitives.nodes.push(t);
+      }
+
+      continue;
+    }
+
+    if (
+      t.isKind(tsm.SyntaxKind.ArrayType) ||
+      t.isKind(tsm.SyntaxKind.TupleType) ||
+      isReadonlyTupleOrArrayTypeNode(t)
+    ) {
+      if (mut_grouped.arraysAndTuples === undefined) {
+        mut_grouped.arraysAndTuples = {
+          firstPosition: i,
+          nodes: [t],
+        } as const;
+      } else {
+        mut_grouped.arraysAndTuples.nodes.push(t);
+      }
+
+      continue;
+    }
+
+    if (
+      t.isKind(tsm.SyntaxKind.TypeLiteral) ||
+      isReadonlyTypeReferenceNode(t)
+    ) {
+      if (mut_grouped.typeLiterals === undefined) {
+        mut_grouped.typeLiterals = {
+          firstPosition: i,
+          nodes: [t],
+        } as const;
+      } else {
+        mut_grouped.typeLiterals.nodes.push(t);
+      }
+
+      continue;
+    }
+
+    // intersections, unions, etc.
+    if (mut_grouped.others === undefined) {
+      mut_grouped.others = {
+        firstPosition: i,
+        nodes: [t],
+      } as const;
+    } else {
+      mut_grouped.others.nodes.push(t);
+    }
+  }
+
+  return mut_grouped;
+};

package/src/functions/ast-transformers/readonly-transformer-helpers/index.mts

@@ -0,0 +1,4 @@
+export * from './compare-union-types.mjs';
+export * from './constants.mjs';
+export * from './group-union-types.mjs';
+export * from './readonly-context.mjs';

package/src/functions/ast-transformers/readonly-transformer-helpers/readonly-context.mts

@@ -0,0 +1,65 @@
+import { SafeUint, match } from 'ts-data-forge';
+
+/**
+ * Controls whether to make a layer mutable during recursive transformation
+ * calls, to standardize by omitting readonly from inner `number[]` in types
+ * like `DeepReadonly<[string, number[]]>`.
+ *
+ * - `"DeepReadonly"`: Indicates that `node` is inside a type utility like
+ *   `DeepReadonly` that recursively applies readonly.
+ * - `"Readonly"`: Indicates that `node` is directly under a `Readonly` type.
+ * - `"readonly"`: Indicates that `node` is directly under a `readonly` operator.
+ * - `"IndexedAccessObjectType"`: Indicates that `node` is directly under an
+ *   IndexedAccessTypeNode.
+ * - `"none"`: All other cases
+ */
+export type ReadonlyContext = Readonly<
+  { indexedAccessDepth: SafeUintWithSmallInt } & (
+    | { type: 'DeepReadonly' }
+    | { type: 'Readonly' }
+    | { type: 'readonly' }
+    | { type: 'none' }
+  )
+>;
+
+export const nextReadonlyContext = <
+  const Curr extends ReadonlyContext,
+  const Next extends ReadonlyContext['type'],
+>({
+  currentReadonlyContext: curr,
+  nextReadonlyContextType: next,
+  indexedAccessDepthChange = 'infinity',
+}: Readonly<
+  {
+    currentReadonlyContext: Curr;
+  } & (
+    | {
+        nextReadonlyContextType: Next;
+        indexedAccessDepthChange: 'decr' | 'incr' | 'keep' | 'infinity';
+      }
+    | {
+        nextReadonlyContextType: Extract<
+          ReadonlyContext['type'],
+          'DeepReadonly'
+        >;
+        indexedAccessDepthChange?: 'infinity';
+      }
+  )
+>): Readonly<{
+  type: Extract<ReadonlyContext['type'], 'DeepReadonly'> | Next;
+  indexedAccessDepth: SafeUintWithSmallInt;
+}> =>
+  curr.type === 'DeepReadonly'
+    ? {
+        type: 'DeepReadonly',
+        indexedAccessDepth: SafeUint.MAX_VALUE,
+      }
+    : {
+        type: next,
+        indexedAccessDepth: match(indexedAccessDepthChange, {
+          decr: SafeUint.sub(curr.indexedAccessDepth, 1),
+          keep: curr.indexedAccessDepth,
+          incr: SafeUint.add(curr.indexedAccessDepth, 1),
+          infinity: SafeUint.MAX_VALUE,
+        }),
+      };

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

@@ -0,0 +1,238 @@
+/* eslint-disable unicorn/consistent-function-scoping -- helper functions are kept inside for clarity */
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types -- ts-morph uses mutable types */
+import { Arr } from 'ts-data-forge';
+import * as tsm from 'ts-morph';
+import { type TsMorphTransformer } from './types.mjs';
+
+/**
+ * Replaces `Readonly<Record<string, unknown>>`, `Record<string, unknown>`,
+ * 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();
+
+      for (const typeAlias of typeAliases) {
+        const typeNode = typeAlias.getTypeNode();
+
+        if (typeNode === undefined) continue;
+
+        visitTypeNode(typeNode);
+      }
+
+      const interfaces = container.getInterfaces();
+
+      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 returnType = sig.getReturnType();
+
+          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 (properties.length === 0 && indexSignatures.length === 1) {
+            // Replace interface with type alias
+            const interfaceName = interfaceDecl.getName();
+
+            interfaceDecl.replaceWithText(
+              `export type ${interfaceName} = UnknownRecord;`,
+            );
+
+            continue;
+          }
+        }
+
+        // Otherwise, check properties for Record types
+        for (const property of interfaceDecl.getProperties()) {
+          const typeNode = property.getTypeNode();
+
+          if (typeNode === undefined) continue;
+
+          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();
+
+          if (typeArgs.length === 1) {
+            const typeArg = typeArgs[0];
+
+            if (tsm.Node.isTypeLiteral(typeArg)) {
+              const members = typeArg.getMembers();
+
+              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');
+
+                return;
+              }
+
+              // Otherwise, recurse into the type literal to visit its properties
+              visitTypeNode(typeArg);
+
+              return;
+            }
+          }
+        }
+
+        replaceIfRecordUnknown(node);
+      }
+
+      // 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),
+        );
+
+        // 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;
+        }
+      }
+
+      // 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);
+            }
+          }
+        }
+      }
+    };
+
+    const isStringUnknownIndexSignature = (
+      sig: tsm.IndexSignatureDeclaration,
+    ): boolean => {
+      const keyType = sig.getKeyTypeNode();
+
+      const returnType = sig.getReturnTypeNode();
+
+      return (
+        keyType.getText() === 'string' && returnType?.getText() === 'unknown'
+      );
+    };
+
+    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');
+          }
+
+          break;
+        }
+        case 'Readonly': {
+          // Check if it's Readonly<Record<string, unknown>>
+          const typeArgs = node.getTypeArguments();
+
+          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;
+        }
+
+        default: {
+          break;
+        }
+      }
+    };
+
+    // Process top-level declarations
+    processDeclarations(sourceAst);
+
+    // Process declarations inside namespaces/modules
+    const namespaces = sourceAst.getModules();
+
+    for (const namespace of namespaces) {
+      processDeclarations(namespace);
+    }
+  };

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

@@ -0,0 +1,38 @@
+import * as tsm from 'ts-morph';
+import { IGNORE_FILE_COMMENT_TEXT } from '../constants/index.mjs';
+import { type TsMorphTransformer } from './types.mjs';
+
+export const transformSourceCode = (
+  code: string,
+  isTsx: boolean,
+  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: {
+      jsx: isTsx ? tsm.ts.JsxEmit.React : undefined,
+      target: tsm.ts.ScriptTarget.ESNext,
+      module: tsm.ts.ModuleKind.ESNext,
+    },
+  });
+
+  const sourceAst = project.createSourceFile(
+    `source.${isTsx ? 'tsx' : 'ts'}`,
+    code,
+  );
+
+  for (const transformer of transformers) {
+    transformer(sourceAst);
+  }
+
+  return sourceAst.getFullText();
+};

package/src/functions/ast-transformers/types.mts

@@ -0,0 +1,6 @@
+import type * as tsm from 'ts-morph';
+
+export type TsMorphTransformer = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  sourceFile: tsm.SourceFile,
+) => void;

package/src/functions/constants/ignore-comment-text.mts

@@ -0,0 +1,3 @@
+export const IGNORE_LINE_COMMENT_TEXT = 'transformer-ignore-next-line';
+
+export const IGNORE_FILE_COMMENT_TEXT = '/* transformer-ignore */';

package/src/functions/constants/index.mts

@@ -0,0 +1 @@
+export * from './ignore-comment-text.mjs';

package/src/functions/functions/has-disable-next-line-comment.mts

@@ -0,0 +1,56 @@
+import * as tsm from 'ts-morph';
+import { IGNORE_LINE_COMMENT_TEXT } from '../constants/index.mjs';
+
+/**
+ * Checks if a given ts-morph Node is immediately preceded by a
+ * '// transformer-ignore-next-line' comment.
+ *
+ * @param node - The ts-morph Node to check.
+ * @returns True if the node is preceded by the ignore comment on the immediately previous line, false otherwise.
+ */
+export const hasDisableNextLineComment = (node: tsm.Node): boolean => {
+  const nodeStartLine = node.getStartLineNumber();
+
+  // Cannot be ignored if it's on the first line
+  if (nodeStartLine <= 1) {
+    return false;
+  }
+
+  const sourceFile = node.getSourceFile(); // Get the SourceFile
+
+  const leadingCommentRanges = node.getLeadingCommentRanges();
+
+  // Iterate backwards through comments as the closest one is most relevant
+  for (let mut_i = leadingCommentRanges.length - 1; mut_i >= 0; mut_i--) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const commentRange = leadingCommentRanges[mut_i]!;
+
+    // Get the end position and convert it to line number
+    const commentEndPos = commentRange.getEnd();
+
+    const commentEndLine = sourceFile.getLineAndColumnAtPos(commentEndPos).line;
+
+    // Check if the comment is on the immediately preceding line
+    if (nodeStartLine === commentEndLine + 1) {
+      // Check if it's a single-line comment containing the specific ignore text
+      if (
+        commentRange.getKind() === tsm.SyntaxKind.SingleLineCommentTrivia &&
+        commentRange.getText().trim().includes(IGNORE_LINE_COMMENT_TEXT)
+      ) {
+        return true;
+      }
+
+      // If we found *any* comment on the preceding line, but it wasn't
+      // the correct ignore comment, then the node is not ignored by
+      // a comment on the *immediately* preceding line. Stop checking further back.
+      return false;
+    }
+
+    // If the comment ends before the preceding line, stop checking further back.
+    if (commentEndLine < nodeStartLine - 1) {
+      break;
+    }
+  }
+
+  return false;
+};

package/src/functions/functions/index.mts

@@ -0,0 +1,8 @@
+export * from './has-disable-next-line-comment.mjs';
+export * from './is-as-const-node.mjs';
+export * from './is-primitive-type-node.mjs';
+export * from './is-readonly-node.mjs';
+export * from './is-spread-parameter-node.mjs';
+export * from './remove-parentheses.mjs';
+export * from './unwrap-readonly.mjs';
+export * from './wrap-with-parentheses.mjs';

package/src/functions/functions/is-as-const-node.mts

@@ -0,0 +1,47 @@
+import * as ts from 'ts-morph';
+
+export const isAsConstNode = (
+  node: ts.Node,
+): node is ts.AsExpression &
+  Readonly<{
+    type: ts.TypeReferenceNode &
+      Readonly<{
+        typeName: ts.Identifier &
+          Readonly<{
+            text: 'const';
+          }>;
+        typeArguments: undefined;
+      }>;
+  }> => {
+  if (!node.isKind(ts.SyntaxKind.AsExpression)) {
+    return false;
+  }
+
+  // 2. Get the 'type' node from the AsExpression
+  const typeNode = node.getTypeNode();
+
+  if (typeNode === undefined) {
+    return false; // Should have a type node for 'as const'
+  }
+
+  // 3. Check if the 'type' node is a TypeReference
+  if (!typeNode.isKind(ts.SyntaxKind.TypeReference)) {
+    return false;
+  }
+
+  // 4. Get the 'typeName' from the TypeReference
+  const typeNameNode = typeNode.getTypeName();
+
+  // 5. Check if the 'typeName' is an Identifier
+  if (!typeNameNode.isKind(ts.SyntaxKind.Identifier)) {
+    // 'as const' uses a simple Identifier 'const', not a QualifiedName
+    return false;
+  }
+
+  // 6. Check if the Identifier's text is 'const'
+  //    and that there are no type arguments (as const doesn't have them)
+  return (
+    typeNameNode.getText() === 'const' &&
+    typeNode.getTypeArguments().length === 0
+  );
+};