ts-codemod-lib 1.0.1

package/src/functions/functions/is-primitive-type-node.mts

@@ -0,0 +1,301 @@
+import { ISet } from 'ts-data-forge';
+import * as tsm from 'ts-morph';
+
+// Define the set of SyntaxKinds that represent primitive type keywords
+const primitiveKeywordKinds = ISet.create<tsm.SyntaxKind>([
+  tsm.SyntaxKind.StringKeyword,
+  tsm.SyntaxKind.BooleanKeyword,
+  tsm.SyntaxKind.NumberKeyword,
+  tsm.SyntaxKind.BigIntKeyword,
+  tsm.SyntaxKind.SymbolKeyword,
+  tsm.SyntaxKind.UndefinedKeyword,
+  tsm.SyntaxKind.VoidKeyword,
+  tsm.SyntaxKind.AnyKeyword,
+  tsm.SyntaxKind.UnknownKeyword,
+  tsm.SyntaxKind.ObjectKeyword, // Note: 'object' is sometimes considered primitive in TS type system context
+  tsm.SyntaxKind.NeverKeyword,
+]);
+
+export type PrimitiveTypeNode = tsm.Node &
+  Readonly<
+    | tsm.LiteralTypeNode
+    | tsm.TemplateLiteralTypeNode
+    | (tsm.TypeNode & {
+        kind:
+          | tsm.SyntaxKind.StringKeyword
+          | tsm.SyntaxKind.BooleanKeyword
+          | tsm.SyntaxKind.NumberKeyword
+          | tsm.SyntaxKind.BigIntKeyword
+          | tsm.SyntaxKind.SymbolKeyword
+          | tsm.SyntaxKind.UndefinedKeyword
+          | tsm.SyntaxKind.VoidKeyword
+          | tsm.SyntaxKind.AnyKeyword
+          | tsm.SyntaxKind.UnknownKeyword
+          | tsm.SyntaxKind.ObjectKeyword
+          | tsm.SyntaxKind.NeverKeyword;
+      })
+  >;
+
+/**
+ * Checks if a given ts-morph node represents a primitive type node.
+ * This includes keyword types (string, number, etc.), literal types (null, "abc", 123),
+ * and template literal types.
+ *
+ * @param node - The ts-morph node to check.
+ * @returns True if the node represents a primitive type node, false otherwise.
+ *          Acts as a type guard.
+ */
+export const isPrimitiveTypeNode = (
+  node: tsm.Node,
+): node is PrimitiveTypeNode => {
+  // Check for literal types (null, "aaa", 1.23, 456n, true, false)
+  if (node.isKind(tsm.SyntaxKind.LiteralType)) {
+    return true;
+  }
+
+  // Check for template literal types (`abc${expr}def`)
+  if (node.isKind(tsm.SyntaxKind.TemplateLiteralType)) {
+    return true;
+  }
+
+  // Check if it's a TypeNode and its kind is one of the primitive keywords
+  // Node.isTypeNode(node) ensures we only check nodes that represent types
+  // if (ts.Node.isTypeNode(node) && primitiveKeywordKinds.has(node.getKind())) {
+  if (primitiveKeywordKinds.has(node.getKind())) {
+    return true;
+  }
+
+  return false;
+};
+
+if (import.meta.vitest !== undefined) {
+  // Helper to get a specific type node from source code
+  const getTypeNodeFromSource = (
+    sourceCode: string,
+    typeName: string,
+  ): tsm.TypeNode => {
+    const project = new tsm.Project({ useInMemoryFileSystem: true });
+
+    const sourceFile = project.createSourceFile('test.ts', sourceCode);
+
+    const typeAlias = sourceFile.getTypeAliasOrThrow(typeName);
+
+    return typeAlias.getTypeNodeOrThrow();
+  };
+
+  // Helper to get the first node of a specific kind from source code
+  const getFirstNodeOfKind = <T extends tsm.Node>(
+    sourceCode: string,
+    kind: tsm.SyntaxKind,
+  ): T | undefined => {
+    const project = new tsm.Project({ useInMemoryFileSystem: true });
+
+    const sourceFile = project.createSourceFile('test.ts', sourceCode);
+
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    return sourceFile.getFirstDescendantByKind(kind) as T | undefined;
+  };
+
+  describe('isPrimitiveTypeNode', () => {
+    describe('positive cases', () => {
+      test.each([
+        {
+          name: 'string',
+          code: 'type Test = string;',
+          kind: tsm.SyntaxKind.StringKeyword,
+        },
+        {
+          name: 'number',
+          code: 'type Test = number;',
+          kind: tsm.SyntaxKind.NumberKeyword,
+        },
+        {
+          name: 'boolean',
+          code: 'type Test = boolean;',
+          kind: tsm.SyntaxKind.BooleanKeyword,
+        },
+        {
+          name: 'bigint',
+          code: 'type Test = bigint;',
+          kind: tsm.SyntaxKind.BigIntKeyword,
+        },
+        {
+          name: 'symbol',
+          code: 'type Test = symbol;',
+          kind: tsm.SyntaxKind.SymbolKeyword,
+        },
+        {
+          name: 'undefined',
+          code: 'type Test = undefined;',
+          kind: tsm.SyntaxKind.UndefinedKeyword,
+        },
+        {
+          name: 'void',
+          code: 'type Test = void;',
+          kind: tsm.SyntaxKind.VoidKeyword,
+        },
+        {
+          name: 'any',
+          code: 'type Test = any;',
+          kind: tsm.SyntaxKind.AnyKeyword,
+        },
+        {
+          name: 'unknown',
+          code: 'type Test = unknown;',
+          kind: tsm.SyntaxKind.UnknownKeyword,
+        },
+        {
+          name: 'never',
+          code: 'type Test = never;',
+          kind: tsm.SyntaxKind.NeverKeyword,
+        },
+        {
+          name: 'object',
+          code: 'type Test = object;',
+          kind: tsm.SyntaxKind.ObjectKeyword,
+        }, // Included based on original code
+        {
+          name: 'null',
+          code: 'type Test = null;',
+          kind: tsm.SyntaxKind.LiteralType,
+        },
+        {
+          name: 'string literal ("hello")',
+          code: 'type Test = "hello";',
+          kind: tsm.SyntaxKind.LiteralType,
+        },
+        {
+          name: 'number literal (123)',
+          code: 'type Test = 123;',
+          kind: tsm.SyntaxKind.LiteralType,
+        },
+        {
+          name: 'bigint literal (123n)',
+          code: 'type Test = 123n;',
+          kind: tsm.SyntaxKind.LiteralType,
+        },
+        {
+          name: 'boolean literal (true)',
+          code: 'type Test = true;',
+          kind: tsm.SyntaxKind.LiteralType,
+        },
+        {
+          name: 'boolean literal (false)',
+          code: 'type Test = false;',
+          kind: tsm.SyntaxKind.LiteralType,
+        },
+        {
+          name: 'TemplateLiteral',
+          // eslint-disable-next-line no-template-curly-in-string
+          code: 'type Test = `a${string}b`;',
+          kind: tsm.SyntaxKind.TemplateLiteralType,
+        },
+      ])('$name', ({ code, kind }) => {
+        const node = getTypeNodeFromSource(code, 'Test');
+
+        expect(node.getKind()).toBe(kind);
+
+        assert.isTrue(isPrimitiveTypeNode(node));
+      });
+    });
+
+    describe('negative cases', () => {
+      test.each([
+        {
+          name: 'Date TypeReference',
+          code: 'type Test = Date;',
+          kind: tsm.SyntaxKind.TypeReference,
+        },
+        {
+          name: 'Array Type',
+          code: 'type Test = number[];',
+          kind: tsm.SyntaxKind.ArrayType,
+        },
+        {
+          name: 'Tuple Type',
+          code: 'type Test = [string, number];',
+          kind: tsm.SyntaxKind.TupleType,
+        },
+        {
+          name: 'Type Literal',
+          code: 'type Test = { a: number };',
+          kind: tsm.SyntaxKind.TypeLiteral,
+        },
+        {
+          name: 'Readonly Type Operator',
+          code: 'type Test = readonly string[];',
+          kind: tsm.SyntaxKind.TypeOperator,
+        },
+        {
+          name: 'Union Type',
+          code: 'type Test = string | number;',
+          kind: tsm.SyntaxKind.UnionType,
+        },
+        {
+          name: 'Intersection Type',
+          code: 'type Test = A & B;',
+          kind: tsm.SyntaxKind.IntersectionType,
+        },
+        {
+          name: 'Mapped Type',
+          code: 'type Test = { [K in keyof T]: T[K] };',
+          kind: tsm.SyntaxKind.MappedType,
+        }, // Needs T defined
+        {
+          name: 'Parenthesized Type',
+          code: 'type Test = (string);',
+          kind: tsm.SyntaxKind.ParenthesizedType,
+        },
+        {
+          name: 'Conditional Type',
+          code: 'type Test = T extends U ? X : Y;',
+          kind: tsm.SyntaxKind.ConditionalType,
+        }, // Needs T, U, X, Y
+        {
+          name: 'Indexed Access Type',
+          code: 'type Test = T[K];',
+          kind: tsm.SyntaxKind.IndexedAccessType,
+        }, // Needs T, K
+        {
+          name: 'Type Query (typeof)',
+          code: 'type Test = typeof myVar;',
+          kind: tsm.SyntaxKind.TypeQuery,
+        },
+      ])('$name', ({ code, kind }) => {
+        const node = getTypeNodeFromSource(code, 'Test');
+
+        expect(node.getKind()).toBe(kind); // Verify node type
+
+        assert.isFalse(isPrimitiveTypeNode(node));
+      });
+
+      test.each([
+        {
+          name: 'Type Predicate',
+          code: 'function isString(x: any): x is string { return typeof x === "string"; }',
+          kind: tsm.SyntaxKind.TypePredicate,
+        }, // Node is part of function sig
+        {
+          name: 'This Type',
+          code: 'class C { method(): this {} }',
+          kind: tsm.SyntaxKind.ThisType,
+        }, // Node is part of method sig
+        {
+          name: 'Infer Type',
+          code: 'type Test<T> = T extends Promise<infer R> ? R : T;',
+          kind: tsm.SyntaxKind.InferType,
+        }, // Needs context
+      ])('$name (not a type node)', ({ code, kind }) => {
+        const node = getFirstNodeOfKind(code, kind);
+
+        expect(node).toBeDefined();
+
+        if (node === undefined) {
+          throw new Error('Node should be defined');
+        }
+
+        assert.isFalse(isPrimitiveTypeNode(node));
+      });
+    });
+  });
+}

package/src/functions/functions/is-readonly-node.mts

@@ -0,0 +1,247 @@
+import { Arr, expectType } from 'ts-data-forge';
+import * as tsm from 'ts-morph';
+import { isPrimitiveTypeNode } from './is-primitive-type-node.mjs';
+
+export const isShallowReadonlyTypeNode = (node: tsm.Node): boolean =>
+  isReadonlyTupleOrArrayTypeNode(node) ||
+  isReadonlyTypeReferenceNode(node) ||
+  isPrimitiveTypeNode(node);
+
+export const isReadonlyTupleOrArrayTypeNode = (
+  node: tsm.Node,
+): node is ReadonlyArrayTypeNode | ReadonlyTupleTypeNode =>
+  node.isKind(tsm.SyntaxKind.TypeOperator) &&
+  node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword &&
+  (node.getTypeNode().isKind(tsm.SyntaxKind.ArrayType) || // Use optional chaining and isKind
+    node.getTypeNode().isKind(tsm.SyntaxKind.TupleType));
+
+export type ReadonlyArrayTypeNode = tsm.TypeNode &
+  Omit<tsm.TypeOperatorTypeNode, 'getOperator' | 'getTypeNode'> &
+  Readonly<{
+    getOperator: () => tsm.SyntaxKind.ReadonlyKeyword;
+    getTypeNode: () => tsm.ArrayTypeNode;
+  }>;
+
+export const isReadonlyArrayTypeNode = (
+  node: tsm.Node,
+): node is ReadonlyArrayTypeNode =>
+  node.isKind(tsm.SyntaxKind.TypeOperator) &&
+  node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword &&
+  node.getTypeNode().isKind(tsm.SyntaxKind.ArrayType);
+
+// Helper to get a specific type node from source code
+const getTypeNodeFromSource = (
+  sourceCode: string,
+  typeName: string,
+): tsm.Node => {
+  const project = new tsm.Project({ useInMemoryFileSystem: true });
+
+  const sourceFile = project.createSourceFile('test.ts', sourceCode);
+
+  const typeAlias = sourceFile.getTypeAliasOrThrow(typeName);
+
+  return typeAlias.getTypeNodeOrThrow();
+};
+
+if (import.meta.vitest !== undefined) {
+  describe('isReadonlyArrayTypeNode', () => {
+    test('should return true for readonly array type', () => {
+      const node = getTypeNodeFromSource(
+        'type Test = readonly number[];',
+        'Test',
+      );
+
+      if (isReadonlyArrayTypeNode(node)) {
+        const _operator = node.getOperator();
+
+        expectType<typeof _operator, tsm.SyntaxKind.ReadonlyKeyword>('=');
+
+        const _typeNode = node.getTypeNode();
+
+        expectType<typeof _typeNode, tsm.ArrayTypeNode>('=');
+      }
+
+      assert.isTrue(node.isKind(tsm.SyntaxKind.TypeOperator));
+
+      if (!isReadonlyArrayTypeNode(node)) {
+        throw new Error('node should be ReadonlyArrayTypeNode');
+      }
+
+      expect(node.getOperator()).toBe(tsm.SyntaxKind.ReadonlyKeyword);
+
+      assert.isTrue(node.getTypeNode().isKind(tsm.SyntaxKind.ArrayType));
+    });
+
+    test('should return false for non-readonly array', () => {
+      const node = getTypeNodeFromSource('type Test = string[];', 'Test');
+
+      assert.isFalse(isReadonlyArrayTypeNode(node));
+    });
+
+    test('should return false for readonly tuple', () => {
+      const node = getTypeNodeFromSource(
+        'type Test = readonly [string];',
+        'Test',
+      );
+
+      assert.isFalse(isReadonlyArrayTypeNode(node));
+    });
+  });
+}
+
+export type ReadonlyTupleTypeNode = tsm.TypeNode &
+  Omit<tsm.TypeOperatorTypeNode, 'getOperator' | 'getTypeNode'> &
+  Readonly<{
+    getOperator: () => tsm.SyntaxKind.ReadonlyKeyword;
+    getTypeNode: () => tsm.TupleTypeNode;
+  }>;
+
+export const isReadonlyTupleTypeNode = (
+  node: tsm.Node,
+): node is ReadonlyTupleTypeNode =>
+  node.isKind(tsm.SyntaxKind.TypeOperator) &&
+  node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword &&
+  node.getTypeNode().isKind(tsm.SyntaxKind.TupleType);
+
+if (import.meta.vitest !== undefined) {
+  describe('isReadonlyTupleTypeNode', () => {
+    test('should return true for readonly tuple type', () => {
+      const node = getTypeNodeFromSource(
+        'type Test = readonly [number, string];',
+        'Test',
+      );
+
+      assert.isTrue(isReadonlyTupleTypeNode(node));
+
+      if (isReadonlyTupleTypeNode(node)) {
+        const _operator = node.getOperator();
+
+        expectType<typeof _operator, tsm.SyntaxKind.ReadonlyKeyword>('=');
+
+        const _typeNode = node.getTypeNode();
+
+        expectType<typeof _typeNode, tsm.TupleTypeNode>('=');
+      }
+
+      assert.isTrue(node.isKind(tsm.SyntaxKind.TypeOperator));
+
+      if (!isReadonlyTupleTypeNode(node)) {
+        throw new Error('node should be ReadonlyTupleTypeNode');
+      }
+
+      expect(node.getOperator()).toBe(tsm.SyntaxKind.ReadonlyKeyword);
+
+      assert.isTrue(node.getTypeNode().isKind(tsm.SyntaxKind.TupleType));
+    });
+
+    test('should return false for non-readonly tuple', () => {
+      const node = getTypeNodeFromSource('type Test = [boolean];', 'Test');
+
+      assert.isFalse(isReadonlyTupleTypeNode(node));
+    });
+
+    test('should return false for readonly array', () => {
+      const node = getTypeNodeFromSource(
+        'type Test = readonly number[];',
+        'Test',
+      );
+
+      assert.isFalse(isReadonlyTupleTypeNode(node));
+    });
+  });
+}
+
+export type ReadonlyTypeReferenceNode = tsm.TypeNode &
+  Omit<tsm.TypeReferenceNode, 'getTypeName' | 'getTypeArguments'> &
+  Readonly<{
+    getTypeName: () => Omit<tsm.Identifier, 'getText'> &
+      Readonly<{
+        getText: () => 'Readonly';
+      }>;
+    getTypeArguments: () => readonly [tsm.TypeNode];
+  }>;
+
+export const isReadonlyTypeReferenceNode = (
+  node: tsm.Node,
+): node is ReadonlyTypeReferenceNode => {
+  if (!node.isKind(tsm.SyntaxKind.TypeReference)) {
+    return false;
+  }
+
+  const typeName = node.getTypeName();
+
+  const typeArguments = node.getTypeArguments();
+
+  return (
+    typeName.isKind(tsm.SyntaxKind.Identifier) &&
+    typeName.getText() === 'Readonly' &&
+    Arr.isArrayOfLength(typeArguments, 1)
+  );
+};
+
+if (import.meta.vitest !== undefined) {
+  describe('isReadonlyTypeReferenceNode', () => {
+    test('should return true for Readonly<T>', () => {
+      const node = getTypeNodeFromSource(
+        'type Test = Readonly<{ x: number }>;',
+        'Test',
+      );
+
+      assert.isTrue(isReadonlyTypeReferenceNode(node));
+
+      if (isReadonlyTypeReferenceNode(node)) {
+        const _typeNameText = node.getTypeName().getText();
+
+        expectType<typeof _typeNameText, 'Readonly'>('=');
+
+        const _typeArguments = node.getTypeArguments();
+
+        expectType<
+          typeof _typeArguments,
+          readonly [tsm.TypeNode<tsm.ts.TypeNode>]
+        >('=');
+      }
+
+      assert.isTrue(node.isKind(tsm.SyntaxKind.TypeReference));
+
+      if (!isReadonlyTypeReferenceNode(node)) {
+        throw new Error('node should be ReadonlyNode');
+      }
+
+      expect(node.getTypeName().getText()).toBe('Readonly');
+
+      expect(node.getTypeArguments()).toHaveLength(1);
+    });
+
+    test('should return false for other type references', () => {
+      const node = getTypeNodeFromSource(
+        'type Test = Partial<{ y: string }>;',
+        'Test',
+      );
+
+      assert.isFalse(isReadonlyTypeReferenceNode(node));
+    });
+
+    test('should return false for Readonly without type arguments', () => {
+      // Note: This is syntactically incorrect TS, but testing the guard
+      const node = getTypeNodeFromSource('type Test = Readonly;', 'Test');
+
+      assert.isFalse(isReadonlyTypeReferenceNode(node));
+    });
+
+    test('should return false for Readonly with multiple type arguments', () => {
+      // Note: This is syntactically incorrect TS, but testing the guard
+      const project = new tsm.Project({ useInMemoryFileSystem: true });
+
+      // Need to create manually as TS parser might reject Readonly<A, B>
+      const sourceFile = project.createSourceFile(
+        'test.ts',
+        'type Test = Readonly<string, number>;',
+      );
+
+      const node = sourceFile.getTypeAliasOrThrow('Test').getTypeNodeOrThrow();
+
+      assert.isFalse(isReadonlyTypeReferenceNode(node));
+    });
+  });
+}

package/src/functions/functions/is-spread-parameter-node.mts

@@ -0,0 +1,13 @@
+import * as tsm from 'ts-morph';
+
+export const isSpreadParameterNode = (
+  node: tsm.Node,
+): node is tsm.ParameterDeclaration =>
+  node.isKind(tsm.SyntaxKind.Parameter) &&
+  node.getDotDotDotToken() !== undefined;
+
+export const isSpreadNamedTupleMemberNode = (
+  node: tsm.Node,
+): node is tsm.NamedTupleMember =>
+  node.isKind(tsm.SyntaxKind.NamedTupleMember) &&
+  node.getDotDotDotToken() !== undefined;

package/src/functions/functions/remove-parentheses.mts

@@ -0,0 +1,7 @@
+import * as tsm from 'ts-morph';
+
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+export const removeParentheses = (node: tsm.TypeNode): tsm.TypeNode =>
+  node.isKind(tsm.SyntaxKind.ParenthesizedType)
+    ? removeParentheses(node.getTypeNode())
+    : node;

package/src/functions/functions/unwrap-readonly.mts

@@ -0,0 +1,7 @@
+import { type ReadonlyTypeReferenceNode } from './is-readonly-node.mjs';
+import { wrapWithParentheses } from './wrap-with-parentheses.mjs';
+
+export const unwrapReadonlyTypeArgText = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: ReadonlyTypeReferenceNode,
+): string => wrapWithParentheses(node.getTypeArguments()[0].getFullText());

package/src/functions/functions/wrap-with-parentheses.mts

@@ -0,0 +1,2 @@
+export const wrapWithParentheses = (nodeStr: string): string =>
+  `(${nodeStr.trim()})`;

package/src/functions/index.mts

@@ -0,0 +1,4 @@
+export * from './ast-transformers/index.mjs';
+export * from './constants/index.mjs';
+export * from './functions/index.mjs';
+export * from './utils/index.mjs';

package/src/functions/utils/index.mts

@@ -0,0 +1 @@
+export * from './replace-with-debug.mjs';

package/src/functions/utils/replace-with-debug.mts

@@ -0,0 +1,10 @@
+import type * as tsm from 'ts-morph';
+
+export const replaceNodeWithDebugPrint = (
+  node: tsm.Node,
+  newNodeText: string,
+): void => {
+  console.debug(`${node.getText()} -> ${newNodeText}`);
+
+  node.replaceWithText(newNodeText);
+};

package/src/globals.d.mts

@@ -0,0 +1 @@
+/// <reference types="ts-type-forge" />

package/src/index.mts

@@ -0,0 +1 @@
+export * from './functions/index.mjs';