ts-codemod-lib 3.3.0 → 3.3.1

package/dist/functions/ast-transformers/append-as-const.mjs

@@ -1,320 +1,358 @@
-import { ISet, Arr } from 'ts-data-forge';
+import { Arr, ISet } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
-import { hasDisableNextLineComment } from '../functions/has-disable-next-line-comment.mjs';
-import { isAsConstNode } from '../functions/is-as-const-node.mjs';
-import '../functions/is-atomic-type-node.mjs';
-import { replaceNodeWithDebugPrint } from '../utils/replace-with-debug.mjs';
-
-const TRANSFORMER_NAME = "append-as-const";
-const appendAsConstTransformer = (options) => {
-  const ignorePrefixes = ISet.create(
-    options?.ignorePrefixes ?? ["mut_", "#mut_", "_mut_", "draft"]
-  );
-  const optionsInternal = {
-    applyLevel: options?.applyLevel ?? "avoidInFunctionArgs",
-    ignoredPrefixes: ignorePrefixes,
-    removeAsConstForConstTypeParameters: options?.removeAsConstForConstTypeParameters ?? true,
-    debugPrint: options?.debug === true ? console.debug : () => {
-    },
-    replaceNode: options?.debug === true ? replaceNodeWithDebugPrint : (node, newNodeText) => node.replaceWithText(newNodeText)
-  };
-  return {
-    name: TRANSFORMER_NAME,
-    transform: (sourceAst) => {
-      for (const node of sourceAst.getDescendantsOfKind(
-        tsm.SyntaxKind.VariableDeclaration
-      )) {
-        transformNode(
-          node,
-          {
-            isUnderConstContext: false,
-            isDirectUnderConstInitializer: false
-          },
-          optionsInternal
-        );
-      }
-      if (optionsInternal.removeAsConstForConstTypeParameters) {
-        removeAsConstInConstTypeParameterArgs(sourceAst, optionsInternal);
-      }
-    }
-  };
+import { hasDisableNextLineComment, isAsConstNode, } from '../functions/index.mjs';
+import { replaceNodeWithDebugPrint } from '../utils/index.mjs';
+const TRANSFORMER_NAME = 'append-as-const';
+export const appendAsConstTransformer = (options) => {
+    const ignorePrefixes = ISet.create(options?.ignorePrefixes ?? ['mut_', '#mut_', '_mut_', 'draft']);
+    const optionsInternal = {
+        applyLevel: options?.applyLevel ?? 'avoidInFunctionArgs',
+        ignoredPrefixes: ignorePrefixes,
+        removeAsConstForConstTypeParameters: options?.removeAsConstForConstTypeParameters ?? true,
+        debugPrint: options?.debug === true ? console.debug : () => { },
+        replaceNode: options?.debug === true
+            ? replaceNodeWithDebugPrint
+            : (node, newNodeText) => node.replaceWithText(newNodeText),
+    };
+    return {
+        name: TRANSFORMER_NAME,
+        transform: (sourceAst) => {
+            for (const node of sourceAst.getDescendantsOfKind(tsm.SyntaxKind.VariableDeclaration)) {
+                transformNode(node, {
+                    isUnderConstContext: false,
+                    isDirectUnderConstInitializer: false,
+                }, optionsInternal);
+            }
+            if (optionsInternal.removeAsConstForConstTypeParameters) {
+                removeAsConstInConstTypeParameterArgs(sourceAst, optionsInternal);
+            }
+        },
+    };
 };
 const transformNode = (node, context, options) => {
-  if (node.wasForgotten()) {
-    return;
-  }
-  options.debugPrint(node.getKindName(), node.getText(), { context });
-  if (hasDisableNextLineComment(node, TRANSFORMER_NAME)) {
-    options.debugPrint("skipped by disable-next-line comment");
-    return;
-  }
-  if (options.applyLevel === "avoidInFunctionArgs" && tsm.Node.isCallExpression(node)) {
-    return;
-  }
-  if (node.isKind(tsm.SyntaxKind.VariableDeclaration)) {
-    const nodeName = node.getName();
-    if (options.ignoredPrefixes.some((p) => nodeName.startsWith(p))) {
-      options.debugPrint("skipped variable declaration by ignorePrefixes");
-      return;
+    if (node.wasForgotten()) {
+        return;
     }
-    const variableStatement = node.getVariableStatement();
-    if (variableStatement !== void 0 && hasDisableNextLineComment(variableStatement, TRANSFORMER_NAME)) {
-      return;
+    options.debugPrint(node.getKindName(), node.getText(), { context });
+    if (hasDisableNextLineComment(node, TRANSFORMER_NAME)) {
+        options.debugPrint('skipped by disable-next-line comment');
+        return;
     }
-    const initializer = node.getInitializer();
-    if (initializer === void 0) {
-      return;
+    if (options.applyLevel === 'avoidInFunctionArgs' &&
+        tsm.Node.isCallExpression(node)) {
+        return;
     }
-    const declarationKindKeywords = node.getVariableStatement()?.getDeclarationKindKeywords().map((k) => k.getText());
-    if (declarationKindKeywords !== void 0 && Arr.isFixedLengthArray(1, declarationKindKeywords)) {
-      transformNode(
-        initializer,
-        {
-          isDirectUnderConstInitializer: declarationKindKeywords[0] === "const",
-          isUnderConstContext: false
-        },
-        options
-      );
-      return;
-    }
-  }
-  if (tsm.Node.isAsExpression(node) && !isAsConstNode(node)) {
-    return;
-  }
-  if (tsm.Node.isParenthesizedExpression(node)) {
-    transformNode(node.getExpression(), context, options);
-    return;
-  }
-  if (tsm.Node.isSatisfiesExpression(node)) {
-    transformNode(node.getExpression(), context, options);
-    return;
-  }
-  if (tsm.Node.isPropertyAssignment(node)) {
-    const initializer = node.getInitializer();
-    if (initializer !== void 0) {
-      transformNode(initializer, context, options);
-    }
-    return;
-  }
-  if (tsm.Node.isArrowFunction(node)) {
-    const body = node.getBody();
-    transformNode(body, context, options);
-    return;
-  }
-  if (tsm.Node.isSpreadElement(node)) {
-    transformNode(node.getExpression(), context, options);
-    return;
-  }
-  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)) {
-    if (!context.isDirectUnderConstInitializer && !context.isUnderConstContext) {
-      options.replaceNode(node, `${node.getText()} as const`);
+    if (node.isKind(tsm.SyntaxKind.VariableDeclaration)) {
+        const nodeName = node.getName();
+
+        if (options.ignoredPrefixes.some((p) => nodeName.startsWith(p))) {
+
+
+            options.debugPrint('skipped variable declaration by ignorePrefixes');
+            return;
+        }
+        const variableStatement = node.getVariableStatement();
+        if (variableStatement !== undefined &&
+            hasDisableNextLineComment(variableStatement, TRANSFORMER_NAME)) {
+            return;
+        }
+        const initializer = node.getInitializer();
+        if (initializer === undefined) {
+            return;
+        }
+        const declarationKindKeywords = node
+            .getVariableStatement()
+            ?.getDeclarationKindKeywords()
+            .map((k) => k.getText());
+        if (declarationKindKeywords !== undefined &&
+            Arr.isFixedLengthArray(1, declarationKindKeywords)) {
+            transformNode(initializer, {
+                isDirectUnderConstInitializer: declarationKindKeywords[0] === 'const',
+                isUnderConstContext: false,
+            }, options);
+            return;
+        }
+
+
+
+
+
+
+
+
+
+
     }
-    return;
-  }
-  if (node.isKind(tsm.SyntaxKind.TemplateExpression)) {
-    if (!context.isUnderConstContext) {
-      options.replaceNode(node, `${node.getText()} as const`);
+
+    if (tsm.Node.isAsExpression(node) && !isAsConstNode(node)) {
+        return;
     }
-    return;
-  }
-  if (tsm.Node.isArrayLiteralExpression(node)) {
-    for (const el of node.getElements()) {
-      transformNode(
-        el,
-        {
-          isUnderConstContext: true,
-          // [...] as const
-          isDirectUnderConstInitializer: false
-        },
-        options
-      );
+
+    if (tsm.Node.isParenthesizedExpression(node)) {
+        transformNode(node.getExpression(), context, options);
+        return;
     }
-    if (!context.isUnderConstContext) {
-      options.replaceNode(node, `${node.getText()} as const`);
+
+    if (tsm.Node.isSatisfiesExpression(node)) {
+        transformNode(node.getExpression(), context, options);
+        return;
     }
-    return;
-  }
-  if (tsm.Node.isObjectLiteralExpression(node)) {
-    for (const el of node.getProperties()) {
-      transformNode(
-        el,
-        {
-          isUnderConstContext: true,
-          // {...} as const
-          isDirectUnderConstInitializer: false
-        },
-        options
-      );
+
+    if (tsm.Node.isPropertyAssignment(node)) {
+        const initializer = node.getInitializer();
+        if (initializer !== undefined) {
+            transformNode(initializer, context, options);
+        }
+        return;
     }
-    if (!context.isUnderConstContext) {
-      options.replaceNode(node, `${node.getText()} as const`);
+
+    if (tsm.Node.isArrowFunction(node)) {
+        const body = node.getBody();
+        transformNode(body, context, options);
+        return;
     }
-    return;
-  }
-  if (isAsConstNode(node)) {
-    if (context.isDirectUnderConstInitializer) {
-      transformNode(
-        node.getExpression(),
-        {
-          isUnderConstContext: false,
-          isDirectUnderConstInitializer: true
-        },
-        options
-      );
-      options.replaceNode(
-        node,
-        // The expression may be marked "as const"
-        node.getExpression().getText()
-      );
-      return;
+
+    if (tsm.Node.isSpreadElement(node)) {
+        transformNode(node.getExpression(), context, options);
+        return;
     }
-    if (context.isUnderConstContext) {
-      transformNode(
-        node.getExpression(),
-        {
-          isUnderConstContext: true,
-          isDirectUnderConstInitializer: false
-        },
-        options
-      );
-      options.replaceNode(
-        node,
-        // The expression may be marked "as const"
-        node.getExpression().getText()
-      );
-      return;
+    if (node.isKind(tsm.SyntaxKind.NoSubstitutionTemplateLiteral) ||
+        node.isKind(tsm.SyntaxKind.NumericLiteral) ||
+        node.isKind(tsm.SyntaxKind.BigIntLiteral) ||
+        node.isKind(tsm.SyntaxKind.StringLiteral) ||
+        node.isKind(tsm.SyntaxKind.TrueKeyword) ||
+        node.isKind(tsm.SyntaxKind.FalseKeyword)
+    ) {
+        if (!context.isDirectUnderConstInitializer &&
+            !context.isUnderConstContext) {
+            options.replaceNode(node, `${node.getText()} as const`);
+        }
+        return;
     }
-    transformNode(
-      node.getExpression(),
-      {
-        isUnderConstContext: true,
-        isDirectUnderConstInitializer: false
-      },
-      options
-    );
-    return;
-  }
-  if (tsm.Node.isConditionalExpression(node)) {
-    transformNode(
-      node.getWhenTrue(),
-      {
-        isDirectUnderConstInitializer: context.isDirectUnderConstInitializer,
-        isUnderConstContext: false
-      },
-      options
-    );
-    transformNode(
-      node.getWhenFalse(),
-      {
-        isDirectUnderConstInitializer: context.isDirectUnderConstInitializer,
-        isUnderConstContext: false
-      },
-      options
-    );
-  }
-};
-const removeAsConstInConstTypeParameterArgs = (sourceAst, options) => {
-  for (const call of sourceAst.getDescendantsOfKind(tsm.SyntaxKind.CallExpression).toReversed()) {
-    if (call.wasForgotten()) {
-      continue;
+    if (node.isKind(tsm.SyntaxKind.TemplateExpression)) {
+        if (!context.isUnderConstContext) {
+            options.replaceNode(node, `${node.getText()} as const`);
+        }
+        return;
     }
-    const args = call.getArguments();
-    if (!args.some(isAsConstNode)) {
-      continue;
+    if (tsm.Node.isArrayLiteralExpression(node)) {
+        for (const el of node.getElements()) {
+            transformNode(el, {
+                isUnderConstContext: true,
+                isDirectUnderConstInitializer: false,
+            }, options);
+        }
+        if (!context.isUnderConstContext) {
+            options.replaceNode(node, `${node.getText()} as const`);
+        }
+        return;
     }
-    if (hasDisableNextLineComment(call, TRANSFORMER_NAME)) {
-      continue;
+    if (tsm.Node.isObjectLiteralExpression(node)) {
+        for (const el of node.getProperties()) {
+            transformNode(el, {
+                isUnderConstContext: true,
+                isDirectUnderConstInitializer: false,
+            }, options);
+        }
+        if (!context.isUnderConstContext) {
+            options.replaceNode(node, `${node.getText()} as const`);
+        }
+        return;
     }
-    const variableStatement = call.getFirstAncestorByKind(
-      tsm.SyntaxKind.VariableStatement
-    );
-    if (variableStatement !== void 0 && hasDisableNextLineComment(variableStatement, TRANSFORMER_NAME)) {
-      continue;
+
+    if (isAsConstNode(node)) {
+        if (context.isDirectUnderConstInitializer) {
+
+            transformNode(node.getExpression(), {
+                isUnderConstContext: false,
+                isDirectUnderConstInitializer: true,
+            }, options);
+            options.replaceNode(node, 
+
+            node.getExpression().getText());
+            return;
+        }
+        if (context.isUnderConstContext) {
+            transformNode(node.getExpression(), {
+                isUnderConstContext: true,
+                isDirectUnderConstInitializer: false,
+            }, options);
+            options.replaceNode(node, 
+
+            node.getExpression().getText());
+            return;
+        }
+        transformNode(node.getExpression(), {
+            isUnderConstContext: true,
+            isDirectUnderConstInitializer: false,
+        }, options);
+        return;
     }
-    if (!Arr.isEmpty(call.getTypeArguments())) {
-      continue;
+    if (tsm.Node.isConditionalExpression(node)) {
+
+        transformNode(node.getWhenTrue(), {
+            isDirectUnderConstInitializer: context.isDirectUnderConstInitializer,
+            isUnderConstContext: false,
+        }, options);
+        transformNode(node.getWhenFalse(), {
+            isDirectUnderConstInitializer: context.isDirectUnderConstInitializer,
+            isUnderConstContext: false,
+        }, options);
+
     }
-    const callTarget = resolveSingleSignatureCallTarget(call);
-    if (callTarget === void 0) {
-      continue;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const removeAsConstInConstTypeParameterArgs = (
+
+sourceAst, options) => {
+
+
+    for (const call of sourceAst
+        .getDescendantsOfKind(tsm.SyntaxKind.CallExpression)
+        .toReversed()) {
+        if (call.wasForgotten()) {
+            continue;
+        }
+        const args = call.getArguments();
+
+        if (!args.some(isAsConstNode)) {
+            continue;
+        }
+        if (hasDisableNextLineComment(call, TRANSFORMER_NAME)) {
+            continue;
+        }
+        const variableStatement = call.getFirstAncestorByKind(tsm.SyntaxKind.VariableStatement);
+        if (variableStatement !== undefined &&
+            hasDisableNextLineComment(variableStatement, TRANSFORMER_NAME)) {
+            continue;
+        }
+
+
+        if (!Arr.isEmpty(call.getTypeArguments())) {
+            continue;
+        }
+        const callTarget = resolveSingleSignatureCallTarget(call);
+        if (callTarget === undefined) {
+            continue;
+        }
+        removeAsConstArgsOfCall(args, callTarget, options);
     }
-    removeAsConstArgsOfCall(args, callTarget, options);
-  }
 };
-const removeAsConstArgsOfCall = (args, callTarget, options) => {
-  const firstSpreadIndex = args.findIndex(
-    (a) => a.isKind(tsm.SyntaxKind.SpreadElement)
-  );
-  const mappableArgCount = firstSpreadIndex === -1 ? args.length : firstSpreadIndex;
-  for (const [argumentIndex, argument] of args.entries()) {
-    if (argumentIndex >= mappableArgCount) {
-      return;
+const removeAsConstArgsOfCall = (args, 
+
+callTarget, options) => {
+
+
+    const firstSpreadIndex = args.findIndex((a) => a.isKind(tsm.SyntaxKind.SpreadElement));
+    const mappableArgCount = firstSpreadIndex === -1 ? args.length : firstSpreadIndex;
+    for (const [argumentIndex, argument] of args.entries()) {
+        if (argumentIndex >= mappableArgCount) {
+            return;
+        }
+        if (argument.wasForgotten() || !isAsConstNode(argument)) {
+            continue;
+        }
+        if (hasDisableNextLineComment(argument, TRANSFORMER_NAME)) {
+            continue;
+        }
+        const parameter = getMatchedParameter(callTarget.parameters, argumentIndex);
+        if (parameter === undefined ||
+            !isBareConstTypeParameterReference(parameter, callTarget.constTypeParameterNames)) {
+            continue;
+        }
+        options.debugPrint('removing redundant as const in const type parameter argument', argument.getText());
+        options.replaceNode(argument, argument.getExpression().getText());
     }
-    if (argument.wasForgotten() || !isAsConstNode(argument)) {
-      continue;
+};
+
+
+
+
+
+
+
+
+
+const resolveSingleSignatureCallTarget = (
+
+call) => {
+
+
+
+
+    if (!Arr.isFixedLengthArray(1, call.getExpression().getType().getCallSignatures())) {
+        return undefined;
     }
-    if (hasDisableNextLineComment(argument, TRANSFORMER_NAME)) {
-      continue;
+    const declaration = call
+        .getProject()
+        .getTypeChecker()
+        .getResolvedSignature(call)
+        ?.getDeclaration();
+    if (declaration === undefined ||
+        !tsm.Node.isParametered(declaration) ||
+        !tsm.Node.isTypeParametered(declaration)) {
+        return undefined;
     }
-    const parameter = getMatchedParameter(callTarget.parameters, argumentIndex);
-    if (parameter === void 0 || !isBareConstTypeParameterReference(
-      parameter,
-      callTarget.constTypeParameterNames
-    )) {
-      continue;
+
+
+
+    const constTypeParameterNames = ISet.create(declaration
+        .getTypeParameters()
+        .filter((tp) => tp.hasModifier(tsm.SyntaxKind.ConstKeyword))
+        .map((tp) => tp.getName()));
+    if (constTypeParameterNames.size === 0) {
+        return undefined;
     }
-    options.debugPrint(
-      "removing redundant as const in const type parameter argument",
-      argument.getText()
-    );
-    options.replaceNode(argument, argument.getExpression().getText());
-  }
-};
-const resolveSingleSignatureCallTarget = (call) => {
-  if (!Arr.isFixedLengthArray(
-    1,
-    call.getExpression().getType().getCallSignatures()
-  )) {
-    return void 0;
-  }
-  const declaration = call.getProject().getTypeChecker().getResolvedSignature(call)?.getDeclaration();
-  if (declaration === void 0 || !tsm.Node.isParametered(declaration) || !tsm.Node.isTypeParametered(declaration)) {
-    return void 0;
-  }
-  const constTypeParameterNames = ISet.create(
-    declaration.getTypeParameters().filter((tp) => tp.hasModifier(tsm.SyntaxKind.ConstKeyword)).map((tp) => tp.getName())
-  );
-  if (constTypeParameterNames.size === 0) {
-    return void 0;
-  }
-  return {
-    parameters: declaration.getParameters(),
-    constTypeParameterNames
-  };
+    return {
+        parameters: declaration.getParameters(),
+        constTypeParameterNames,
+    };
 };
-const getMatchedParameter = (parameters, argumentIndex) => {
-  if (argumentIndex < parameters.length) {
-    return parameters[argumentIndex];
-  }
-  const lastParameter = parameters.at(-1);
-  return lastParameter?.isRestParameter() === true ? lastParameter : void 0;
-};
-const isBareConstTypeParameterReference = (parameter, constTypeParameterNames) => {
-  const typeNode = parameter.getTypeNode();
-  if (typeNode === void 0) {
-    return false;
-  }
-  if (!typeNode.isKind(tsm.SyntaxKind.TypeReference)) {
-    return false;
-  }
-  const typeName = typeNode.getTypeName();
-  return typeName.isKind(tsm.SyntaxKind.Identifier) && Arr.isEmpty(typeNode.getTypeArguments()) && constTypeParameterNames.has(typeName.getText());
+const getMatchedParameter = (
+
+parameters, argumentIndex) => {
+    if (argumentIndex < parameters.length) {
+        return parameters[argumentIndex];
+    }
+    const lastParameter = parameters.at(-1);
+    return lastParameter?.isRestParameter() === true ? lastParameter : undefined;
 };
 
-export { appendAsConstTransformer };
-//# sourceMappingURL=append-as-const.mjs.map
+
+
+
+
+
+const isBareConstTypeParameterReference = (
+
+parameter, constTypeParameterNames) => {
+    const typeNode = parameter.getTypeNode();
+    if (typeNode === undefined) {
+        return false;
+    }
+    if (!typeNode.isKind(tsm.SyntaxKind.TypeReference)) {
+        return false;
+    }
+    const typeName = typeNode.getTypeName();
+    return (typeName.isKind(tsm.SyntaxKind.Identifier) &&
+        Arr.isEmpty(typeNode.getTypeArguments()) &&
+        constTypeParameterNames.has(typeName.getText()));
+};
+//# sourceMappingURL=append-as-const.mjs.map