ts-codemod-lib 2.0.4 → 2.1.0

package/src/functions/functions/should-avoid-parentheses-for-readonly.mts

@@ -0,0 +1,32 @@
+import * as tsm from 'ts-morph';
+
+/**
+ * Determines if parentheses should be avoided when adding 'readonly' prefix to a type.
+ *
+ * Parentheses should be AVOIDED in these specific contexts:
+ * - Type predicates: `x is [T, U]` -> `x is readonly [T, U]` (not `x is (readonly [T, U])`)
+ *   because parentheses around the type in a type predicate cause syntax errors
+ *
+ * For all other contexts, we keep parentheses for safety to avoid precedence issues,
+ * relying on prettier to remove unnecessary ones.
+ *
+ * @param node - The type node to check
+ * @returns true if parentheses should be avoided, false otherwise (keep parentheses)
+ */
+export const shouldAvoidParenthesesForReadonly = (node: tsm.Node): boolean => {
+  const parent = node.getParent();
+
+  if (parent === undefined) {
+    return false;
+  }
+
+  // Check if parent is TypePredicate: x is T
+  // In this case, we MUST avoid parentheses: x is readonly T (not x is (readonly T))
+  // because `x is (readonly T)` is a syntax error
+  if (parent.isKind(tsm.SyntaxKind.TypePredicate)) {
+    return true;
+  }
+
+  // For all other cases, keep parentheses for safety
+  return false;
+};

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

@@ -1,2 +1,75 @@
-export const wrapWithParentheses = (nodeStr: string): `(${string})` =>
-  `(${nodeStr.trim()})` as const;
+/**
+ * Checks if a string is already wrapped with a single pair of balanced parentheses
+ * that encompasses the entire expression.
+ *
+ * @example
+ * isWrappedWithParentheses('(A)') // true
+ * isWrappedWithParentheses('((A))') // true (outer pair wraps everything)
+ * isWrappedWithParentheses('(A) | (B)') // false (outer parens don't wrap everything)
+ * isWrappedWithParentheses('A') // false
+ */
+import { asUint32, range } from 'ts-data-forge';
+
+const isWrappedWithParentheses = (str: string): boolean => {
+  const trimmed = str.trim();
+
+  if (!trimmed.startsWith('(') || !trimmed.endsWith(')')) {
+    return false;
+  }
+
+  // Check if the opening and closing parentheses are balanced
+  // and the opening parenthesis corresponds to the closing one
+  let mut_depth = 0;
+
+  for (const mut_i of range(0, asUint32(trimmed.length))) {
+    const char: string = trimmed.charAt(mut_i);
+
+    switch (char) {
+      case '(': {
+        mut_depth += 1;
+
+        break;
+      }
+
+      case ')': {
+        mut_depth -= 1;
+
+        // If we reach depth 0 before the end, the outer parentheses don't wrap everything
+        if (mut_depth === 0 && mut_i < trimmed.length - 1) {
+          return false;
+        }
+
+        break;
+      }
+
+      default: {
+        // Other characters - no action needed
+        break;
+      }
+    }
+  }
+
+  return true;
+};
+
+/**
+ * Wraps a string with parentheses if not already wrapped.
+ * Avoids adding redundant parentheses when the expression is already
+ * fully wrapped with balanced parentheses.
+ *
+ * @example
+ * wrapWithParentheses('A') // '(A)'
+ * wrapWithParentheses('(A)') // '(A)' (not '((A))')
+ * wrapWithParentheses('A | B') // '(A | B)'
+ * wrapWithParentheses('(A | B)') // '(A | B)' (not '((A | B))')
+ * wrapWithParentheses('(A) | (B)') // '((A) | (B))' (needs outer parens)
+ */
+export const wrapWithParentheses = (nodeStr: string): string => {
+  const trimmed = nodeStr.trim();
+
+  if (isWrappedWithParentheses(trimmed)) {
+    return trimmed;
+  }
+
+  return `(${trimmed})` as const;
+};