ts-codemod-lib 2.0.4 → 2.0.5

package/dist/functions/functions/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/index.mts"],"names":[],"mappings":"AAAA,cAAc,qCAAqC,CAAC;AACpD,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/index.mts"],"names":[],"mappings":"AAAA,cAAc,qCAAqC,CAAC;AACpD,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,0BAA0B,CAAC;AACzC,cAAc,6CAA6C,CAAC;AAC5D,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC"}

package/dist/functions/functions/index.mjs

@@ -4,6 +4,7 @@ export { isAtomicTypeNode } from './is-atomic-type-node.mjs';
 export { isReadonlyArrayTypeNode, isReadonlyTupleOrArrayTypeNode, isReadonlyTupleTypeNode, isReadonlyTypeReferenceNode, isShallowReadonlyTypeNode } from './is-readonly-node.mjs';
 export { isSpreadNamedTupleMemberNode, isSpreadParameterNode } from './is-spread-parameter-node.mjs';
 export { removeParentheses } from './remove-parentheses.mjs';
+export { shouldAvoidParenthesesForReadonly } from './should-avoid-parentheses-for-readonly.mjs';
 export { unwrapReadonlyTypeArgText } from './unwrap-readonly.mjs';
 export { wrapWithParentheses } from './wrap-with-parentheses.mjs';
 //# sourceMappingURL=index.mjs.map

package/dist/functions/functions/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}

package/dist/functions/functions/is-as-const-node.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"is-as-const-node.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/is-as-const-node.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,UAAU,CAAC;AAE/B,eAAO,MAAM,aAAa,GACxB,MAAM,EAAE,CAAC,IAAI,KACZ,IAAI,IAAI,EAAE,CAAC,YAAY,GACxB,QAAQ,CAAC;IACP,IAAI,EAAE,EAAE,CAAC,iBAAiB,GACxB,QAAQ,CAAC;QACP,QAAQ,EAAE,EAAE,CAAC,UAAU,GACrB,QAAQ,CAAC;YACP,IAAI,EAAE,OAAO,CAAC;SACf,CAAC,CAAC;QACL,aAAa,EAAE,SAAS,CAAC;KAC1B,CAAC,CAAC;CACN,CAgCF,CAAC"}
+{"version":3,"file":"is-as-const-node.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/is-as-const-node.mts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,UAAU,CAAC;AAE/B,eAAO,MAAM,aAAa,GACxB,MAAM,EAAE,CAAC,IAAI,KACZ,IAAI,IAAI,EAAE,CAAC,YAAY,GACxB,QAAQ,CAAC;IACP,IAAI,EAAE,EAAE,CAAC,iBAAiB,GACxB,QAAQ,CAAC;QACP,QAAQ,EAAE,EAAE,CAAC,UAAU,GACrB,QAAQ,CAAC;YACP,IAAI,EAAE,OAAO,CAAC;SACf,CAAC,CAAC;QACL,aAAa,EAAE,SAAS,CAAC;KAC1B,CAAC,CAAC;CACN,CAgCF,CAAC"}

package/dist/functions/functions/is-as-const-node.mjs

@@ -1,3 +1,4 @@
+import { Arr } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
 
 const isAsConstNode = (node) => {
@@ -23,7 +24,7 @@ const isAsConstNode = (node) => {
     // 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);
+        Arr.isArrayOfLength(typeNode.getTypeArguments(), 0));
 };
 
 export { isAsConstNode };

package/dist/functions/functions/is-as-const-node.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-as-const-node.mjs","sources":["../../../src/functions/functions/is-as-const-node.mts"],"sourcesContent":[null],"names":["ts"],"mappings":";;AAEO,MAAM,aAAa,GAAG,CAC3B,IAAa,KAWR;AACL,IAAA,IAAI,CAAC,IAAI,CAAC,MAAM,CAACA,GAAE,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE;AAC5C,QAAA,OAAO,KAAK;IACd;;AAGA,IAAA,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,EAAE;AAEnC,IAAA,IAAI,QAAQ,KAAK,SAAS,EAAE;QAC1B,OAAO,KAAK,CAAC;IACf;;AAGA,IAAA,IAAI,CAAC,QAAQ,CAAC,MAAM,CAACA,GAAE,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE;AACjD,QAAA,OAAO,KAAK;IACd;;AAGA,IAAA,MAAM,YAAY,GAAG,QAAQ,CAAC,WAAW,EAAE;;AAG3C,IAAA,IAAI,CAAC,YAAY,CAAC,MAAM,CAACA,GAAE,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE;;AAElD,QAAA,OAAO,KAAK;IACd;;;AAIA,IAAA,QACE,YAAY,CAAC,OAAO,EAAE,KAAK,OAAO;QAClC,QAAQ,CAAC,gBAAgB,EAAE,CAAC,MAAM,KAAK,CAAC;AAE5C;;;;"}
+{"version":3,"file":"is-as-const-node.mjs","sources":["../../../src/functions/functions/is-as-const-node.mts"],"sourcesContent":[null],"names":["ts"],"mappings":";;;AAGO,MAAM,aAAa,GAAG,CAC3B,IAAa,KAWR;AACL,IAAA,IAAI,CAAC,IAAI,CAAC,MAAM,CAACA,GAAE,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE;AAC5C,QAAA,OAAO,KAAK;IACd;;AAGA,IAAA,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,EAAE;AAEnC,IAAA,IAAI,QAAQ,KAAK,SAAS,EAAE;QAC1B,OAAO,KAAK,CAAC;IACf;;AAGA,IAAA,IAAI,CAAC,QAAQ,CAAC,MAAM,CAACA,GAAE,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE;AACjD,QAAA,OAAO,KAAK;IACd;;AAGA,IAAA,MAAM,YAAY,GAAG,QAAQ,CAAC,WAAW,EAAE;;AAG3C,IAAA,IAAI,CAAC,YAAY,CAAC,MAAM,CAACA,GAAE,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE;;AAElD,QAAA,OAAO,KAAK;IACd;;;AAIA,IAAA,QACE,YAAY,CAAC,OAAO,EAAE,KAAK,OAAO;QAClC,GAAG,CAAC,eAAe,CAAC,QAAQ,CAAC,gBAAgB,EAAE,EAAE,CAAC,CAAC;AAEvD;;;;"}

package/dist/functions/functions/should-avoid-parentheses-for-readonly.d.mts

@@ -0,0 +1,16 @@
+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 declare const shouldAvoidParenthesesForReadonly: (node: tsm.Node) => boolean;
+//# sourceMappingURL=should-avoid-parentheses-for-readonly.d.mts.map

package/dist/functions/functions/should-avoid-parentheses-for-readonly.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"should-avoid-parentheses-for-readonly.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/should-avoid-parentheses-for-readonly.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAEhC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iCAAiC,GAAI,MAAM,GAAG,CAAC,IAAI,KAAG,OAgBlE,CAAC"}

package/dist/functions/functions/should-avoid-parentheses-for-readonly.mjs

@@ -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)
+ */
+const shouldAvoidParenthesesForReadonly = (node) => {
+    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;
+};
+
+export { shouldAvoidParenthesesForReadonly };
+//# sourceMappingURL=should-avoid-parentheses-for-readonly.mjs.map

package/dist/functions/functions/should-avoid-parentheses-for-readonly.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"should-avoid-parentheses-for-readonly.mjs","sources":["../../../src/functions/functions/should-avoid-parentheses-for-readonly.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;AAYG;AACI,MAAM,iCAAiC,GAAG,CAAC,IAAc,KAAa;AAC3E,IAAA,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE;AAE/B,IAAA,IAAI,MAAM,KAAK,SAAS,EAAE;AACxB,QAAA,OAAO,KAAK;IACd;;;;IAKA,IAAI,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE;AAC/C,QAAA,OAAO,IAAI;IACb;;AAGA,IAAA,OAAO,KAAK;AACd;;;;"}

package/dist/functions/functions/wrap-with-parentheses.d.mts

@@ -1,2 +1,14 @@
-export declare const wrapWithParentheses: (nodeStr: string) => `(${string})`;
+/**
+ * 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 declare const wrapWithParentheses: (nodeStr: string) => string;
 //# sourceMappingURL=wrap-with-parentheses.d.mts.map

package/dist/functions/functions/wrap-with-parentheses.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"wrap-with-parentheses.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/wrap-with-parentheses.mts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,GAAI,SAAS,MAAM,KAAG,IAAI,MAAM,GAChC,CAAC"}
+{"version":3,"file":"wrap-with-parentheses.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/wrap-with-parentheses.mts"],"names":[],"mappings":"AAsDA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAS,MAAM,KAAG,MAQrD,CAAC"}

package/dist/functions/functions/wrap-with-parentheses.mjs

@@ -1,4 +1,61 @@
-const wrapWithParentheses = (nodeStr) => `(${nodeStr.trim()})`;
+import { range, asUint32 } from 'ts-data-forge';
+
+/**
+ * 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
+ */
+const isWrappedWithParentheses = (str) => {
+    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 = 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;
+            }
+        }
+    }
+    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)
+ */
+const wrapWithParentheses = (nodeStr) => {
+    const trimmed = nodeStr.trim();
+    if (isWrappedWithParentheses(trimmed)) {
+        return trimmed;
+    }
+    return `(${trimmed})`;
+};
 
 export { wrapWithParentheses };
 //# sourceMappingURL=wrap-with-parentheses.mjs.map

package/dist/functions/functions/wrap-with-parentheses.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"wrap-with-parentheses.mjs","sources":["../../../src/functions/functions/wrap-with-parentheses.mts"],"sourcesContent":[null],"names":[],"mappings":"AAAO,MAAM,mBAAmB,GAAG,CAAC,OAAe,KACjD,IAAI,OAAO,CAAC,IAAI,EAAE;;;;"}
+{"version":3,"file":"wrap-with-parentheses.mjs","sources":["../../../src/functions/functions/wrap-with-parentheses.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAAA;;;;;;;;;AASG;AAGH,MAAM,wBAAwB,GAAG,CAAC,GAAW,KAAa;AACxD,IAAA,MAAM,OAAO,GAAG,GAAG,CAAC,IAAI,EAAE;AAE1B,IAAA,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;AACtD,QAAA,OAAO,KAAK;IACd;;;IAIA,IAAI,SAAS,GAAG,CAAC;AAEjB,IAAA,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE;QACtD,MAAM,IAAI,GAAW,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC;QAE1C,QAAQ,IAAI;YACV,KAAK,GAAG,EAAE;gBACR,SAAS,IAAI,CAAC;gBAEd;YACF;YAEA,KAAK,GAAG,EAAE;gBACR,SAAS,IAAI,CAAC;;AAGd,gBAAA,IAAI,SAAS,KAAK,CAAC,IAAI,KAAK,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;AACjD,oBAAA,OAAO,KAAK;gBACd;gBAEA;YACF;;IAOJ;AAEA,IAAA,OAAO,IAAI;AACb,CAAC;AAED;;;;;;;;;;;AAWG;AACI,MAAM,mBAAmB,GAAG,CAAC,OAAe,KAAY;AAC7D,IAAA,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,EAAE;AAE9B,IAAA,IAAI,wBAAwB,CAAC,OAAO,CAAC,EAAE;AACrC,QAAA,OAAO,OAAO;IAChB;IAEA,OAAO,CAAA,CAAA,EAAI,OAAO,CAAA,CAAA,CAAY;AAChC;;;;"}

package/dist/functions/index.mjs

@@ -15,6 +15,7 @@ export { isAtomicTypeNode } from './functions/is-atomic-type-node.mjs';
 export { isReadonlyArrayTypeNode, isReadonlyTupleOrArrayTypeNode, isReadonlyTupleTypeNode, isReadonlyTypeReferenceNode, isShallowReadonlyTypeNode } from './functions/is-readonly-node.mjs';
 export { isSpreadNamedTupleMemberNode, isSpreadParameterNode } from './functions/is-spread-parameter-node.mjs';
 export { removeParentheses } from './functions/remove-parentheses.mjs';
+export { shouldAvoidParenthesesForReadonly } from './functions/should-avoid-parentheses-for-readonly.mjs';
 export { unwrapReadonlyTypeArgText } from './functions/unwrap-readonly.mjs';
 export { wrapWithParentheses } from './functions/wrap-with-parentheses.mjs';
 export { replaceNodeWithDebugPrint } from './utils/replace-with-debug.mjs';

package/dist/functions/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;"}

package/dist/index.mjs

@@ -15,6 +15,7 @@ export { isAtomicTypeNode } from './functions/functions/is-atomic-type-node.mjs'
 export { isReadonlyArrayTypeNode, isReadonlyTupleOrArrayTypeNode, isReadonlyTupleTypeNode, isReadonlyTypeReferenceNode, isShallowReadonlyTypeNode } from './functions/functions/is-readonly-node.mjs';
 export { isSpreadNamedTupleMemberNode, isSpreadParameterNode } from './functions/functions/is-spread-parameter-node.mjs';
 export { removeParentheses } from './functions/functions/remove-parentheses.mjs';
+export { shouldAvoidParenthesesForReadonly } from './functions/functions/should-avoid-parentheses-for-readonly.mjs';
 export { unwrapReadonlyTypeArgText } from './functions/functions/unwrap-readonly.mjs';
 export { wrapWithParentheses } from './functions/functions/wrap-with-parentheses.mjs';
 export { replaceNodeWithDebugPrint } from './functions/utils/replace-with-debug.mjs';

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-codemod-lib",
-  "version": "2.0.4",
+  "version": "2.0.5",
   "private": false,
   "keywords": [
     "typescript",
@@ -99,7 +99,7 @@
     "z:vitest:node": "pnpm run z:vitest --project='Node.js'"
   },
   "dependencies": {
-    "ts-data-forge": "6.4.0",
+    "ts-data-forge": "6.5.0",
     "ts-morph": "27.0.2"
   },
   "devDependencies": {
@@ -113,17 +113,17 @@
     "@semantic-release/github": "12.0.3",
     "@semantic-release/npm": "13.1.3",
     "@semantic-release/release-notes-generator": "14.1.0",
-    "@types/node": "25.2.0",
+    "@types/node": "25.2.3",
     "@vitest/browser-playwright": "4.0.18",
     "@vitest/coverage-v8": "4.0.18",
     "@vitest/ui": "4.0.18",
     "cmd-ts": "0.14.3",
     "conventional-changelog-conventionalcommits": "9.1.0",
-    "cspell": "9.6.3",
+    "cspell": "9.6.4",
     "dedent": "1.7.1",
     "eslint": "9.39.2",
-    "eslint-config-typed": "4.6.1",
-    "github-settings-as-code": "1.1.2",
+    "eslint-config-typed": "4.6.2",
+    "github-settings-as-code": "1.1.4",
     "jiti": "2.6.1",
     "markdownlint": "0.40.0",
     "markdownlint-cli2": "0.20.0",
@@ -134,7 +134,7 @@
     "prettier-plugin-packagejson": "3.0.0",
     "rollup": "4.57.1",
     "semantic-release": "25.0.3",
-    "ts-repo-utils": "8.1.0",
+    "ts-repo-utils": "8.2.0",
     "ts-type-forge": "2.3.1",
     "tslib": "2.8.1",
     "tsx": "4.21.0",
@@ -160,7 +160,7 @@
       "optional": true
     }
   },
-  "packageManager": "pnpm@10.29.2",
+  "packageManager": "pnpm@10.29.3",
   "engines": {
     "node": ">=20.11.0",
     "pnpm": ">=8.0.0"

package/src/cmd/append-as-const.mts

@@ -9,7 +9,7 @@ const transformer = appendAsConstTransformer();
 
 const cmdDef = cmd.command({
   name: transformer.name,
-  version: '2.0.4',
+  version: '2.0.5',
   args: {
     baseDir: cmd.positional({
       type: cmd.string,

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

@@ -9,7 +9,7 @@ const transformer = convertInterfaceToTypeTransformer();
 
 const cmdDef = cmd.command({
   name: transformer.name,
-  version: '2.0.4',
+  version: '2.0.5',
   args: {
     baseDir: cmd.positional({
       type: cmd.string,

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

@@ -9,7 +9,7 @@ const transformer = convertToReadonlyTransformer();
 
 const cmdDef = cmd.command({
   name: transformer.name,
-  version: '2.0.4',
+  version: '2.0.5',
   args: {
     baseDir: cmd.positional({
       type: cmd.string,

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

@@ -9,7 +9,7 @@ const transformer = replaceAnyWithUnknownTransformer();
 
 const cmdDef = cmd.command({
   name: transformer.name,
-  version: '2.0.4',
+  version: '2.0.5',
   args: {
     baseDir: cmd.positional({
       type: cmd.string,

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

@@ -9,7 +9,7 @@ const transformer = replaceRecordWithUnknownRecordTransformer();
 
 const cmdDef = cmd.command({
   name: transformer.name,
-  version: '2.0.4',
+  version: '2.0.5',
   args: {
     baseDir: cmd.positional({
       type: cmd.string,

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

@@ -44,7 +44,7 @@ export const runTransformerCLI = async (
 
   const files = filesResult.value;
 
-  if (files.length === 0) {
+  if (Arr.isArrayOfLength(files, 0)) {
     echoIfNotSilent(
       options.uncommitted
         ? 'No uncommitted files found'
@@ -71,7 +71,7 @@ export const runTransformerCLI = async (
       📊 Total:       ${files.length}
   `);
 
-  if (errorFiles.length > 0) {
+  if (Arr.isNonEmpty(errorFiles)) {
     echoIfNotSilent('\nFiles with errors:');
 
     for (const fileName of errorFiles) {
@@ -81,7 +81,7 @@ export const runTransformerCLI = async (
 
   echoIfNotSilent(hr);
 
-  if (errorFiles.length > 0) {
+  if (Arr.isNonEmpty(errorFiles)) {
     return Result.err(undefined);
   }
 

package/src/functions/ast-transformers/convert-interface-to-type.mts

@@ -41,19 +41,18 @@ export const convertInterfaceToTypeTransformer = (): TsMorphTransformer =>
         const members = interfaceDecl.getMembers();
 
         // Build type parameters string
-        const typeParamsStr =
-          typeParameters.length > 0
-            ? `<${typeParameters.map((tp) => tp.getText()).join(', ')}>`
-            : '';
+        const typeParamsStr = Arr.isNonEmpty(typeParameters)
+          ? `<${typeParameters.map((tp) => tp.getText()).join(', ')}>`
+          : '';
 
         // Build type literal from members
         const mut_typeBody: string = (() => {
-          if (extendsExpressions.length === 0) {
+          if (Arr.isArrayOfLength(extendsExpressions, 0)) {
             // No extends: simple type literal
             return buildTypeLiteral(members);
           }
 
-          if (members.length === 0) {
+          if (Arr.isArrayOfLength(members, 0)) {
             // Only extends, no own members: union of extended types
             const extendedTypes = extendsExpressions.map((ext) =>
               ext.getText(),
@@ -98,7 +97,7 @@ export const convertInterfaceToTypeTransformer = (): TsMorphTransformer =>
       const buildTypeLiteral = (
         members: readonly tsm.TypeElementTypes[],
       ): string => {
-        if (members.length === 0) {
+        if (Arr.isArrayOfLength(members, 0)) {
           return 'Record<string, never>';
         }
 

package/src/functions/ast-transformers/convert-to-readonly.mts

@@ -15,10 +15,11 @@ import {
   isReadonlyTupleOrArrayTypeNode,
   isReadonlyTupleTypeNode,
   isReadonlyTypeReferenceNode,
-  type ReadonlyTypeReferenceNode,
   removeParentheses,
+  shouldAvoidParenthesesForReadonly,
   unwrapReadonlyTypeArgText,
   wrapWithParentheses,
+  type ReadonlyTypeReferenceNode,
 } from '../functions/index.mjs';
 import { replaceNodeWithDebugPrint } from '../utils/index.mjs';
 import {
@@ -552,9 +553,13 @@ const transformTypeReferenceNode = (
       T.isKind(tsm.SyntaxKind.ArrayType) ||
       T.isKind(tsm.SyntaxKind.TupleType)
     ) {
+      const readonlyText = `readonly ${T.getFullText()}`;
+
       options.replaceNode(
         node,
-        wrapWithParentheses(`readonly ${T.getFullText()}`),
+        shouldAvoidParenthesesForReadonly(node)
+          ? readonlyText
+          : wrapWithParentheses(readonlyText),
       );
 
       return;
@@ -626,9 +631,13 @@ const transformTypeReferenceNode = (
       T.isKind(tsm.SyntaxKind.ArrayType) &&
       isAtomicTypeNode(T.getElementTypeNode())
     ) {
+      const readonlyText = `readonly ${T.getFullText()}`;
+
       options.replaceNode(
         node,
-        wrapWithParentheses(`readonly ${T.getFullText()}`),
+        shouldAvoidParenthesesForReadonly(node)
+          ? readonlyText
+          : wrapWithParentheses(readonlyText),
       );
 
       return;
@@ -640,9 +649,13 @@ const transformTypeReferenceNode = (
       T.isKind(tsm.SyntaxKind.TupleType) &&
       T.getElements().every(isAtomicTypeNode)
     ) {
+      const readonlyText = `readonly ${T.getFullText()}`;
+
       options.replaceNode(
         node,
-        wrapWithParentheses(`readonly ${T.getFullText()}`),
+        shouldAvoidParenthesesForReadonly(node)
+          ? readonlyText
+          : wrapWithParentheses(readonlyText),
       );
 
       return;
@@ -692,9 +705,13 @@ const transformArrayTypeNode = (
     case 'Readonly':
     case 'none':
       if (readonlyContext.indexedAccessDepth === 0) {
+        const readonlyText = `readonly ${node.getFullText()}`;
+
         options.replaceNode(
           node,
-          wrapWithParentheses(`readonly ${node.getFullText()}`),
+          shouldAvoidParenthesesForReadonly(node)
+            ? readonlyText
+            : wrapWithParentheses(readonlyText),
         );
       }
   }
@@ -735,9 +752,13 @@ const transformTupleTypeNode = (
     case 'Readonly':
     case 'none':
       if (readonlyContext.indexedAccessDepth === 0) {
+        const readonlyText = `readonly ${node.getFullText()}`;
+
         options.replaceNode(
           node,
-          wrapWithParentheses(`readonly ${node.getFullText()}`),
+          shouldAvoidParenthesesForReadonly(node)
+            ? readonlyText
+            : wrapWithParentheses(readonlyText),
         );
       }
   }
@@ -825,7 +846,10 @@ const transformTypeLiteralNode = (
   >,
   options: ReadonlyTransformerOptionsInternal,
 ): void => {
-  if (options.ignoreEmptyObjectTypes && node.getMembers().length === 0) {
+  if (
+    options.ignoreEmptyObjectTypes &&
+    Arr.isArrayOfLength(node.getMembers(), 0)
+  ) {
     return;
   }
 
@@ -1130,7 +1154,8 @@ const transformUnionOrIntersectionTypeNodeImpl = (
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     n: tsm.TypeLiteralNode | ReadonlyTypeReferenceNode,
   ): boolean =>
-    n.isKind(tsm.SyntaxKind.TypeLiteral) && n.getMembers().length === 0;
+    n.isKind(tsm.SyntaxKind.TypeLiteral) &&
+    Arr.isArrayOfLength(n.getMembers(), 0);
 
   const nonEmptyTypeLiterals =
     typeLiterals === undefined
@@ -1145,7 +1170,8 @@ const transformUnionOrIntersectionTypeNodeImpl = (
       : typeLiterals.nodes.filter((n) => isEmptyTypeLiteral(n));
 
   const typeLiteralsWrappedWithReadonly: readonly [] | readonly [string] =
-    nonEmptyTypeLiterals === undefined || nonEmptyTypeLiterals.length === 0
+    nonEmptyTypeLiterals === undefined ||
+    Arr.isArrayOfLength(nonEmptyTypeLiterals, 0)
       ? ([] as const)
       : ([
           unionToString({
@@ -1172,13 +1198,13 @@ const transformUnionOrIntersectionTypeNodeImpl = (
       arraysAndTuples,
       (a) => [a.nodes.map((n) => n.getFullText()), a.firstPosition] as const,
     ),
-    nonEmptyTypeLiterals !== undefined && nonEmptyTypeLiterals.length > 0
+    nonEmptyTypeLiterals !== undefined && Arr.isNonEmpty(nonEmptyTypeLiterals)
       ? mapNullable(
           typeLiterals,
           (a) => [typeLiteralsWrappedWithReadonly, a.firstPosition] as const,
         )
       : undefined,
-    emptyTypeLiterals !== undefined && emptyTypeLiterals.length > 0
+    emptyTypeLiterals !== undefined && Arr.isNonEmpty(emptyTypeLiterals)
       ? mapNullable(
           typeLiterals,
           (a) =>
@@ -1187,7 +1213,7 @@ const transformUnionOrIntersectionTypeNodeImpl = (
               // Use a position after non-empty type literals if they exist
               a.firstPosition +
                 (nonEmptyTypeLiterals !== undefined &&
-                nonEmptyTypeLiterals.length > 0
+                Arr.isNonEmpty(nonEmptyTypeLiterals)
                   ? 0.5
                   : 0),
             ] as const,
@@ -1226,7 +1252,7 @@ const unionToString = ({
   op: '&' | '|';
   wrapWithReadonly: boolean | string;
 }>): string =>
-  types.length === 0
+  Arr.isArrayOfLength(types, 0)
     ? 'never'
     : Arr.isArrayOfLength(types, 1)
       ? wrapWithReadonly === false

package/src/functions/ast-transformers/convert-to-readonly.test.mts

@@ -3816,6 +3816,85 @@ describe(convertToReadonlyTransformer, () => {
     ])('$name', testFn);
   });
 
+  describe('shouldAvoidParenthesesForReadonly', () => {
+    test.each([
+      {
+        name: 'Type predicate with array - avoid parentheses',
+        source: dedent`
+          function isStringArray(x: unknown): x is string[] {
+            return Array.isArray(x);
+          }
+        `,
+        expected: dedent`
+          function isStringArray(x: unknown): x is readonly string[] {
+            return Array.isArray(x);
+          }
+        `,
+      },
+      {
+        name: 'Type predicate with tuple - avoid parentheses',
+        source: dedent`
+          function isTuple(x: unknown): x is [string, number] {
+            return Array.isArray(x) && x.length === 2;
+          }
+        `,
+        expected: dedent`
+          function isTuple(x: unknown): x is readonly [string, number] {
+            return Array.isArray(x) && x.length === 2;
+          }
+        `,
+      },
+      {
+        name: 'Type predicate with Readonly<T[]> - avoid parentheses',
+        source: dedent`
+          function isArray(x: unknown): x is Readonly<string[]> {
+            return Array.isArray(x);
+          }
+        `,
+        expected: dedent`
+          function isArray(x: unknown): x is readonly string[] {
+            return Array.isArray(x);
+          }
+        `,
+      },
+      {
+        name: 'Type predicate with Readonly<[T, U]> - avoid parentheses',
+        source: dedent`
+          function isTuple(x: unknown): x is Readonly<[string, number]> {
+            return Array.isArray(x);
+          }
+        `,
+        expected: dedent`
+          function isTuple(x: unknown): x is readonly [string, number] {
+            return Array.isArray(x);
+          }
+        `,
+      },
+      {
+        name: 'Non-type predicate context - keep parentheses (handled by formatter)',
+        source: dedent`
+          type T = Readonly<string[]>;
+        `,
+        expected: dedent`
+          type T = readonly string[];
+        `,
+      },
+      {
+        name: 'Function return type - keep parentheses (handled by formatter)',
+        source: dedent`
+          function foo(): Readonly<number[]> {
+            return [];
+          }
+        `,
+        expected: dedent`
+          function foo(): readonly number[] {
+            return [];
+          }
+        `,
+      },
+    ])('$name', testFn);
+  });
+
   describe('Error Cases', () => {
     test('Invalid DeepReadonlyTypeName', () => {
       expect(() => {