ts-codemod-lib 1.4.0 → 1.4.1

package/src/cmd/convert-interface-to-type.mts

@@ -8,7 +8,7 @@ import { runTransformerCLI } from './run-transformer-cli.mjs';
 
 const cmdDef = cmd.command({
   name: 'convert-interface-to-type',
-  version: '1.4.0',
+  version: '1.4.1',
   args: {
     baseDir: cmd.positional({
       type: cmd.string,

package/src/cmd/convert-to-readonly.mts

@@ -8,7 +8,7 @@ import { runTransformerCLI } from './run-transformer-cli.mjs';
 
 const cmdDef = cmd.command({
   name: 'convert-to-readonly',
-  version: '1.4.0',
+  version: '1.4.1',
   args: {
     baseDir: cmd.positional({
       type: cmd.string,

package/src/cmd/replace-any-with-unknown.mts

@@ -8,7 +8,7 @@ import { runTransformerCLI } from './run-transformer-cli.mjs';
 
 const cmdDef = cmd.command({
   name: 'replace-any-with-unknown',
-  version: '1.4.0',
+  version: '1.4.1',
   args: {
     baseDir: cmd.positional({
       type: cmd.string,

package/src/cmd/replace-record-with-unknown-record.mts

@@ -8,7 +8,7 @@ import { runTransformerCLI } from './run-transformer-cli.mjs';
 
 const cmdDef = cmd.command({
   name: 'replace-record-with-unknown-record',
-  version: '1.4.0',
+  version: '1.4.1',
   args: {
     baseDir: cmd.positional({
       type: cmd.string,

package/src/cmd/run-transformer-cli.mts

@@ -175,7 +175,7 @@ const getFilesFromGlob = async (
   >
 > => {
   const globResult = await glob(baseDir, {
-    ignore: Array.from(exclude),
+    ignore: exclude,
   });
 
   if (Result.isErr(globResult)) {

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

@@ -1,9 +1,10 @@
-import { ISet } from 'ts-data-forge';
+import { Arr, expectType, ISet, pipe } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
 import {
   hasDisableNextLineComment,
   isAsConstNode,
 } from '../functions/index.mjs';
+import { replaceNodeWithDebugPrint } from '../utils/index.mjs';
 import { type TsMorphTransformer } from './types.mjs';
 
 const TRANSFORMER_NAME = 'append-as-const';
@@ -18,11 +19,25 @@ export const appendAsConstTransformer = (
   const optionsInternal: AppendAsConstTransformerOptionsInternal = {
     applyLevel: options?.applyLevel ?? 'avoidInFunctionArgs',
     ignoredPrefixes: ignorePrefixes,
+
+    debugPrint: options?.debug === true ? console.debug : () => {},
+    replaceNode:
+      options?.debug === true
+        ? replaceNodeWithDebugPrint
+        : (node, newNodeText) => node.replaceWithText(newNodeText),
   };
 
   const transformer: TsMorphTransformer = (sourceAst) => {
     for (const node of sourceAst.getChildren()) {
-      transformNode(node, optionsInternal);
+      transformNode(
+        node,
+        {
+          isUnderConstContext: false,
+          isDirectUnderConstInitializer: false,
+          isUnderSpreadElement: false,
+        },
+        optionsInternal,
+      );
     }
   };
 
@@ -44,186 +59,421 @@ export type AppendAsConstTransformerOptions = DeepReadonly<{
    */
   ignorePrefixes?: string[];
 
-  ignoreConstTypeParameter?: boolean;
+  // TODO
+  // ignoreConstTypeParameter?: boolean;
+
+  debug?: boolean;
 }>;
 
 type AppendAsConstTransformerOptionsInternal = DeepReadonly<{
   applyLevel: 'all' | 'avoidInFunctionArgs';
   ignoredPrefixes: ISet<string>;
+
+  debugPrint: (...args: readonly unknown[]) => void;
+  replaceNode: (node: tsm.Node, newNodeText: string) => void;
+}>;
+
+type AsConstContext = Readonly<{
+  isUnderConstContext: boolean;
+  isDirectUnderConstInitializer: boolean;
+  isUnderSpreadElement: boolean;
 }>;
 
 const transformNode = (
   node: tsm.Node,
+  context: AsConstContext,
   options: AppendAsConstTransformerOptionsInternal,
 ): void => {
   if (hasDisableNextLineComment(node, TRANSFORMER_NAME)) {
-    console.debug('skipped by disable-next-line comment');
+    options.debugPrint('skipped by disable-next-line comment');
+
+    return;
+  }
+
+  options.debugPrint(node.getKindName(), node.getText());
+
+  if (
+    options.applyLevel === 'avoidInFunctionArgs' &&
+    tsm.Node.isCallExpression(node)
+  ) {
+    return;
+  }
+
+  if (
+    node.isKind(tsm.SyntaxKind.LiteralType) ||
+    node.isKind(tsm.SyntaxKind.TypeLiteral) ||
+    node.isKind(tsm.SyntaxKind.TypeReference) ||
+    node.isKind(tsm.SyntaxKind.UnionType) ||
+    node.isKind(tsm.SyntaxKind.TypeAliasDeclaration)
+  ) {
+    return; // skip type annotations
+  }
+
+  if (
+    node.isKind(tsm.SyntaxKind.NoSubstitutionTemplateLiteral) || // `abc`
+    node.isKind(tsm.SyntaxKind.NumericLiteral) || // 123
+    node.isKind(tsm.SyntaxKind.BigIntLiteral) || // 123n
+    node.isKind(tsm.SyntaxKind.StringLiteral) || // 'abc'
+    node.isKind(tsm.SyntaxKind.TrueKeyword) || // true
+    node.isKind(tsm.SyntaxKind.FalseKeyword) // false
+  ) {
+    if (context.isDirectUnderConstInitializer || context.isUnderConstContext) {
+      return;
+    }
+
+    options.replaceNode(node, `${node.getText()} as const`);
+
+    return;
+  }
+
+  if (node.isKind(tsm.SyntaxKind.TemplateExpression)) {
+    options.debugPrint(node.getKindName(), node.getText());
+
+    options.debugPrint(
+      node
+        .getChildren()
+        .map((c) => c.getText())
+        .join(''),
+    );
+
+    options.replaceNode(node, `${node.getText()} as const`);
 
     return;
   }
 
-  // check for ignorePrefix
   if (node.isKind(tsm.SyntaxKind.VariableDeclaration)) {
     const nodeName = node.getName();
 
+    // check for ignorePrefix
     if (options.ignoredPrefixes.some((p) => nodeName.startsWith(p))) {
       // Skip conversion for variable declarations with ignored prefixes
       // Example: const mut_foo: string[] = []; -> remains as is, without appending `as const`
-      console.debug('skipped variable declaration by ignorePrefixes');
+      options.debugPrint('skipped variable declaration by ignorePrefixes');
+
+      return;
+    }
 
+    const initializer = node.getInitializer();
+
+    if (initializer === undefined) {
       return;
     }
 
+    const declarationKindKeywords = node
+      .getVariableStatement()
+      ?.getDeclarationKindKeywords()
+      .map((k) => k.getText());
+
+    if (
+      declarationKindKeywords !== undefined &&
+      Arr.isArrayOfLength(declarationKindKeywords, 1)
+    ) {
+      transformNode(
+        initializer,
+        {
+          isDirectUnderConstInitializer: declarationKindKeywords[0] === 'const',
+          isUnderConstContext: false,
+          isUnderSpreadElement: context.isUnderSpreadElement,
+        },
+        options,
+      );
+
+      return;
+    }
+
+    // const [a, b] = ...;
     // TODO: Support ignoredPrefixes in ArrayBindingPattern
     // if (ts.isArrayBindingPattern(nodeName)) {
     //   // for (const [i, el] of nodeName.elements.entries())
     // }
 
+    // const { x, y } = ...;
     // TODO: Support ignoredPrefixes in ObjectBindingPattern
     // if (ts.isObjectBindingPattern(nodeName)) {
     //   // for (const [i, el] of nodeName.elements.entries())
     // }
   }
 
-  if (
-    options.applyLevel === 'avoidInFunctionArgs' &&
-    tsm.Node.isCallExpression(node)
-  ) {
-    return;
-  }
-
   // `as const` node
   if (isAsConstNode(node)) {
-    const expression = removeParenthesis(node.getExpression());
+    options.debugPrint(node.getKindName(), node.getText());
+
+    if (context.isDirectUnderConstInitializer) {
+      // In const variable declarations, remove `as const` first and then re-append it later if needed
+
+      transformNode(
+        node.getExpression(),
+        {
+          isUnderConstContext: false,
+          isDirectUnderConstInitializer: true,
+          isUnderSpreadElement: context.isUnderSpreadElement,
+        },
+        options,
+      );
+
+      options.replaceNode(
+        node,
+        // The expression may be marked "as const"
+        node.getExpression().getText(),
+      ); // remove `as const`
 
-    if (
-      !tsm.Node.isArrayLiteralExpression(expression) &&
-      !tsm.Node.isObjectLiteralExpression(expression)
-    ) {
-      // `as const` is not needed for primitive types
-      // Example: `0 as const` -> `0`
-      node.replaceWithText(expression.getText());
+      return;
+    }
+
+    if (context.isUnderConstContext) {
+      transformNode(
+        node.getExpression(),
+        {
+          isUnderConstContext: true,
+          isDirectUnderConstInitializer: false,
+          isUnderSpreadElement: context.isUnderSpreadElement,
+        },
+        options,
+      );
+
+      options.replaceNode(
+        node,
+        // The expression may be marked "as const"
+        node.getExpression().getText(),
+      ); // remove `as const`
 
       return;
     }
 
-    // Avoid appending `as const` twice
-    removeAsConstRecursively(node.getExpression());
+    transformNode(
+      node.getExpression(),
+      {
+        isUnderConstContext: true,
+        isDirectUnderConstInitializer: false,
+        isUnderSpreadElement: context.isUnderSpreadElement,
+      },
+      options,
+    );
 
     return;
   }
 
-  if (tsm.Node.isArrayLiteralExpression(node)) {
-    for (const el of node.getElements()) {
-      removeAsConstRecursively(el);
-    }
+  if (tsm.Node.isAsExpression(node)) {
+    return;
+  }
 
-    node.replaceWithText(`${node.getText()} as const`);
+  if (tsm.Node.isSpreadElement(node)) {
+    transformNode(
+      node.getExpression(),
+      {
+        isDirectUnderConstInitializer: false,
+        isUnderConstContext: context.isUnderConstContext,
+        isUnderSpreadElement: true,
+      },
+      options,
+    );
 
     return;
   }
 
-  if (tsm.Node.isObjectLiteralExpression(node)) {
-    for (const el of node.getProperties()) {
-      removeAsConstRecursively(el);
+  if (tsm.Node.isConditionalExpression(node)) {
+    if (context.isUnderSpreadElement) {
+      // When under spread element, keep `as const` in both branches
+      transformNode(
+        node.getWhenTrue(),
+        {
+          isDirectUnderConstInitializer: false,
+          isUnderConstContext: false,
+          isUnderSpreadElement: false,
+        },
+        options,
+      );
+
+      transformNode(
+        node.getWhenFalse(),
+        {
+          isDirectUnderConstInitializer: false,
+          isUnderConstContext: false,
+          isUnderSpreadElement: false,
+        },
+        options,
+      );
     }
 
-    node.replaceWithText(`${node.getText()} as const`);
-
     return;
   }
 
-  for (const child of node.getChildren()) {
-    transformNode(child, options);
-  }
-};
-
-const removeAsConstRecursively = (
-  node: tsm.Node,
-  insideSpreadWithConditional: boolean = false,
-): void => {
-  if (hasDisableNextLineComment(node)) {
-    console.debug('skipped by disable-next-line comment');
+  if (tsm.Node.isParenthesizedExpression(node)) {
+    transformNode(node.getExpression(), context, options);
 
     return;
   }
 
-  if (isAsConstNode(node)) {
-    // If we're inside a spread element with conditional, keep the `as const`
-    if (insideSpreadWithConditional) {
-      return;
-    }
+  if (tsm.Node.isArrayLiteralExpression(node)) {
+    // options.debugPrint(node.getKindName(), node.getText());
 
-    // Extract node.expression to remove `as const` and recursively call the function
-    // to remove `as const` from nested nodes
-    // Example: `[[1,2] as const, [3,4]] as const` -> `[[1,2], [3,4]]`
-    removeAsConstRecursively(node.getExpression(), insideSpreadWithConditional);
+    for (const el of node.getElements()) {
+      transformNode(
+        el,
+        {
+          isUnderConstContext: true, // [...] as const
+          isDirectUnderConstInitializer: false,
+          isUnderSpreadElement: context.isUnderSpreadElement,
+        },
+        options,
+      );
+    }
 
-    node.replaceWithText(node.getExpression().getText());
+    if (!context.isUnderConstContext) {
+      options.replaceNode(node, `${node.getText()} as const`);
+    }
 
     return;
   }
 
-  // If we're inside a spread with conditional and encounter array/object literal without `as const`, add it
-  if (insideSpreadWithConditional) {
-    if (tsm.Node.isArrayLiteralExpression(node)) {
-      // Don't add `as const` to empty arrays
-      if (node.getElements().length === 0) {
-        return;
-      }
-
-      // Add `as const` to the array itself, but don't recursively process elements
-      // Elements will be processed normally by the outer transform
-      node.replaceWithText(`${node.getText()} as const`);
-
-      return;
+  if (tsm.Node.isObjectLiteralExpression(node)) {
+    for (const el of node.getProperties()) {
+      transformNode(
+        el,
+        {
+          isUnderConstContext: true, // {...} as const
+          isDirectUnderConstInitializer: false,
+          isUnderSpreadElement: context.isUnderSpreadElement,
+        },
+        options,
+      );
     }
 
-    if (tsm.Node.isObjectLiteralExpression(node)) {
-      // Don't add `as const` to empty objects
-      if (node.getProperties().length === 0) {
-        return;
-      }
+    if (!context.isUnderConstContext) {
+      options.replaceNode(node, `${node.getText()} as const`);
+    }
 
-      // Add `as const` to the object itself, but don't recursively process properties
-      node.replaceWithText(`${node.getText()} as const`);
+    return;
+  }
 
+  if (node.isKind(tsm.SyntaxKind.ClassDeclaration)) {
+    // Skip conversion for class declarations with ignored prefixes
+    // Example: class mut_Class {...} -> properties remain without readonly
+    if (
+      options.ignoredPrefixes.some(
+        (p) => node.getName()?.startsWith(p) === true,
+      )
+    ) {
       return;
     }
-  }
-
-  // Mark that we're inside a spread element's expression only if it contains conditional
-  // Example: `...(flag ? [1, 2] as const : [])` keeps inner `as const`
-  // Example: `...[1, 2] as const` removes inner `as const`
-  if (tsm.Node.isSpreadElement(node)) {
-    const expression = node.getExpression();
 
-    const hasConditional = containsConditionalExpression(expression);
-
-    removeAsConstRecursively(expression, hasConditional);
+    transformClassDeclarationNode(node, context, options);
 
     return;
   }
 
   for (const child of node.getChildren()) {
-    removeAsConstRecursively(child, insideSpreadWithConditional);
+    transformNode(
+      child,
+      {
+        isDirectUnderConstInitializer: false,
+        isUnderConstContext: context.isUnderConstContext,
+        isUnderSpreadElement: context.isUnderSpreadElement,
+      },
+      options,
+    );
   }
 };
 
-const containsConditionalExpression = (node: tsm.Node): boolean => {
-  if (tsm.Node.isConditionalExpression(node)) {
-    return true;
-  }
+const transformClassDeclarationNode = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: tsm.ClassDeclaration,
+  context: AsConstContext,
+  options: AppendAsConstTransformerOptionsInternal,
+): void => {
+  for (const mb of node.getMembers()) {
+    if (hasDisableNextLineComment(mb)) {
+      options.debugPrint('skipped member by disable-next-line comment');
 
-  // Check children recursively, but stop at AsExpression boundaries
-  if (isAsConstNode(node)) {
-    return false;
-  }
+      continue;
+    }
+
+    if (mb.isKind(tsm.SyntaxKind.PropertyDeclaration)) {
+      if (!checkIfPropertyNameShouldBeIgnored(mb.getNameNode(), options)) {
+        const type = mb.getTypeNode();
+
+        if (type !== undefined) {
+          transformNode(
+            type,
+            {
+              isDirectUnderConstInitializer: false,
+              isUnderConstContext: false,
+              isUnderSpreadElement: context.isUnderSpreadElement,
+            },
+            options,
+          );
+        }
+
+        const initializer = mb.getInitializer();
+
+        if (initializer !== undefined) {
+          transformNode(
+            initializer,
+            {
+              isDirectUnderConstInitializer: false,
+              isUnderConstContext: false,
+              isUnderSpreadElement: context.isUnderSpreadElement,
+            },
+            options,
+          );
+        }
+      }
 
-  return node.getChildren().some(containsConditionalExpression);
+      continue;
+    }
+
+    transformNode(
+      mb,
+      {
+        isDirectUnderConstInitializer: false,
+        isUnderConstContext: false,
+        isUnderSpreadElement: context.isUnderSpreadElement,
+      },
+      options,
+    );
+  }
 };
 
-const removeParenthesis = (node: tsm.Node): tsm.Node =>
-  tsm.Node.isParenthesizedExpression(node)
-    ? removeParenthesis(node.getExpression())
-    : node;
+const checkIfPropertyNameShouldBeIgnored = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  nameNode: tsm.PropertyName,
+  options: AppendAsConstTransformerOptionsInternal,
+): boolean => {
+  expectType<typeof nameNode, tsm.PropertyName>('=');
+
+  expectType<
+    tsm.PropertyName,
+    | tsm.NumericLiteral // skip
+    | tsm.BigIntLiteral // skip
+    | tsm.NoSubstitutionTemplateLiteral // invalid syntax
+    | tsm.Identifier // mut_x: number[]
+    | tsm.StringLiteral // "mut_x": number[]
+    | tsm.PrivateIdentifier // #memberName: number[] (class only)
+    | tsm.ComputedPropertyName // [`mut_x`]: number[]
+  >('=');
+
+  return (
+    (nameNode.isKind(tsm.SyntaxKind.Identifier) &&
+      pipe(nameNode.getText()).map((nm) =>
+        options.ignoredPrefixes.some((p) => nm.startsWith(p)),
+      ).value) ||
+    (nameNode.isKind(tsm.SyntaxKind.StringLiteral) &&
+      pipe(nameNode.getLiteralValue()).map((nm) =>
+        options.ignoredPrefixes.some((p) => nm.startsWith(p)),
+      ).value) ||
+    (nameNode.isKind(tsm.SyntaxKind.PrivateIdentifier) &&
+      pipe(nameNode.getText()).map((nm) =>
+        options.ignoredPrefixes.some((p) => nm.startsWith(`#${p}`)),
+      ).value) ||
+    (nameNode.isKind(tsm.SyntaxKind.ComputedPropertyName) &&
+      pipe(nameNode.getExpression()).map((exp) => {
+        if (exp.isKind(tsm.SyntaxKind.StringLiteral)) {
+          const nm = exp.getLiteralValue();
+
+          return options.ignoredPrefixes.some((p) => nm.startsWith(p));
+        }
+
+        return false;
+      }).value)
+  );
+};