ts-codemod-lib 2.0.4 → 2.1.0

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()}` as const;
+
       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()}` as const;
+
       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()}` as const;
+
       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()}` as const;
+
         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()}` as const;
+
         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(() => {

package/src/functions/ast-transformers/replace-record-with-unknown-record.mts

@@ -68,7 +68,10 @@ const processDeclarations = (
     if (hasStringUnknownSignature) {
       const properties = interfaceDecl.getProperties();
 
-      if (properties.length === 0 && indexSignatures.length === 1) {
+      if (
+        Arr.isArrayOfLength(properties, 0) &&
+        Arr.isArrayOfLength(indexSignatures, 1)
+      ) {
         // Replace interface with type alias
         const interfaceName = interfaceDecl.getName();
 
@@ -97,7 +100,7 @@ const visitTypeNode = (node: tsm.TypeNode): void => {
     if (node.getTypeName().getText() === 'Readonly') {
       const typeArgs = node.getTypeArguments();
 
-      if (typeArgs.length === 1) {
+      if (Arr.isArrayOfLength(typeArgs, 1)) {
         const typeArg = typeArgs[0];
 
         if (tsm.Node.isTypeLiteral(typeArg)) {
@@ -109,7 +112,7 @@ const visitTypeNode = (node: tsm.TypeNode): void => {
 
           // Check if it has only one index signature [k: string]: unknown
           if (
-            members.length === 1 &&
+            Arr.isArrayOfLength(members, 1) &&
             Arr.isArrayOfLength(indexSigs, 1) &&
             isStringUnknownIndexSignature(indexSigs[0])
           ) {
@@ -139,7 +142,7 @@ const visitTypeNode = (node: tsm.TypeNode): void => {
 
     // Check if it has only one index signature [k: string]: unknown
     if (
-      members.length === 1 &&
+      Arr.isArrayOfLength(members, 1) &&
       Arr.isArrayOfLength(indexSigs, 1) &&
       isStringUnknownIndexSignature(indexSigs[0])
     ) {
@@ -204,9 +207,9 @@ const replaceIfRecordUnknown = (node: tsm.TypeReferenceNode): void => {
       const typeArgs = node.getTypeArguments();
 
       if (
-        typeArgs.length === 2 &&
-        typeArgs[0]?.getText() === 'string' &&
-        typeArgs[1]?.getText() === 'unknown'
+        Arr.isArrayOfLength(typeArgs, 2) &&
+        typeArgs[0].getText() === 'string' &&
+        typeArgs[1].getText() === 'unknown'
       ) {
         node.replaceWithText('UnknownRecord');
       }
@@ -217,19 +220,19 @@ const replaceIfRecordUnknown = (node: tsm.TypeReferenceNode): void => {
       // Check if it's Readonly<Record<string, unknown>>
       const typeArgs = node.getTypeArguments();
 
-      if (typeArgs.length === 1) {
+      if (Arr.isArrayOfLength(typeArgs, 1)) {
         const innerType = typeArgs[0];
 
-        if (innerType !== undefined && tsm.Node.isTypeReference(innerType)) {
+        if (tsm.Node.isTypeReference(innerType)) {
           const innerTypeName = innerType.getTypeName().getText();
 
           if (innerTypeName === 'Record') {
             const innerTypeArgs = innerType.getTypeArguments();
 
             if (
-              innerTypeArgs.length === 2 &&
-              innerTypeArgs[0]?.getText() === 'string' &&
-              innerTypeArgs[1]?.getText() === 'unknown'
+              Arr.isArrayOfLength(innerTypeArgs, 2) &&
+              innerTypeArgs[0].getText() === 'string' &&
+              innerTypeArgs[1].getText() === 'unknown'
             ) {
               node.replaceWithText('UnknownRecord');
             }

package/src/functions/ast-transformers/transform-source-code.mts

@@ -1,22 +1,45 @@
+import { Arr } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
 import { type TsMorphTransformer } from './types.mjs';
 
 const extractFileIgnoreTransformers = (code: string): readonly string[] => {
-  const match = /\/\*\s*transformer-ignore\s*(.*?)\s*\*\//u.exec(code);
+  // Try to find any of the supported file-level ignore comment prefixes
+  const patterns = [
+    {
+      prefix: 'transformer-ignore',
+      regex: /\/\*\s*transformer-ignore\s*(.*?)\s*\*\//u,
+    },
+    {
+      prefix: 'ts-codemod-ignore',
+      regex: /\/\*\s*ts-codemod-ignore\s*(.*?)\s*\*\//u,
+    },
+    {
+      prefix: 'codemod-ignore',
+      regex: /\/\*\s*codemod-ignore\s*(.*?)\s*\*\//u,
+    },
+    {
+      prefix: 'transform-ignore',
+      regex: /\/\*\s*transform-ignore\s*(.*?)\s*\*\//u,
+    },
+  ] as const;
 
-  if (match === null) {
-    return [];
-  }
+  for (const { regex } of patterns) {
+    const match = regex.exec(code);
 
-  const targetTransformers = match[1]?.trim() ?? '';
+    if (match !== null) {
+      const targetTransformers = match[1]?.trim() ?? '';
 
-  // Empty means ignore all transformers
-  if (targetTransformers === '') {
-    return [];
+      // Empty means ignore all transformers
+      if (targetTransformers === '') {
+        return [];
+      }
+
+      // Parse comma-separated transformer names
+      return targetTransformers.split(',').map((name) => name.trim());
+    }
   }
 
-  // Parse comma-separated transformer names
-  return targetTransformers.split(',').map((name) => name.trim());
+  return [];
 };
 
 const shouldSkipFile = (
@@ -26,15 +49,21 @@ const shouldSkipFile = (
   const ignoredTransformers = extractFileIgnoreTransformers(code);
 
   // If no file-level ignore comment found, don't skip
-  if (
-    ignoredTransformers.length === 0 &&
-    !/\/\*\s*transformer-ignore\s*.*?\s*\*\//u.test(code)
-  ) {
+  const patterns = [
+    /\/\*\s*transformer-ignore\s*.*?\s*\*\//u,
+    /\/\*\s*ts-codemod-ignore\s*.*?\s*\*\//u,
+    /\/\*\s*codemod-ignore\s*.*?\s*\*\//u,
+    /\/\*\s*transform-ignore\s*.*?\s*\*\//u,
+  ] as const;
+
+  const hasFileIgnoreComment = patterns.some((regex) => regex.test(code));
+
+  if (Arr.isArrayOfLength(ignoredTransformers, 0) && !hasFileIgnoreComment) {
     return false;
   }
 
   // Empty array means ignore all transformers (file-level ignore without specific transformers)
-  if (ignoredTransformers.length === 0) {
+  if (Arr.isArrayOfLength(ignoredTransformers, 0)) {
     return true;
   }
 

package/src/functions/ast-transformers/transformer-specific-ignore.test.mts

@@ -62,6 +62,45 @@ describe('Transformer-specific ignore comments (Integration)', () => {
         type C = readonly number[]; // Should be readonly
       `,
     },
+    {
+      name: 'ts-codemod-ignore-next-line pattern',
+      source: dedent`
+        // ts-codemod-ignore-next-line replace-any-with-unknown
+        type A = any; // Should remain any
+        const b = [1, 2, 3]; // Should have as const
+      `,
+      expected: dedent`
+        // ts-codemod-ignore-next-line replace-any-with-unknown
+        type A = any; // Should remain any
+        const b = [1, 2, 3] as const; // Should have as const
+      `,
+    },
+    {
+      name: 'codemod-ignore-next-line pattern',
+      source: dedent`
+        // codemod-ignore-next-line replace-any-with-unknown
+        type A = any; // Should remain any
+        type B = number[];
+      `,
+      expected: dedent`
+        // codemod-ignore-next-line replace-any-with-unknown
+        type A = any; // Should remain any
+        type B = readonly number[];
+      `,
+    },
+    {
+      name: 'transform-ignore-next-line pattern',
+      source: dedent`
+        // transform-ignore-next-line append-as-const
+        const b = [1, 2, 3]; // Should remain without as const
+        type A = any;
+      `,
+      expected: dedent`
+        // transform-ignore-next-line append-as-const
+        const b = [1, 2, 3]; // Should remain without as const
+        type A = unknown;
+      `,
+    },
     {
       name: 'Ignore specific transformer for entire file',
       source: dedent`
@@ -79,6 +118,51 @@ describe('Transformer-specific ignore comments (Integration)', () => {
         type D = any; // Should remain any
       `,
     },
+    {
+      name: 'ts-codemod-ignore for entire file',
+      source: dedent`
+        /* ts-codemod-ignore replace-any-with-unknown */
+        type A = any; // Should remain any
+        const b = [1, 2, 3]; // Should have as const
+        type D = any; // Should remain any
+      `,
+      expected: dedent`
+        /* ts-codemod-ignore replace-any-with-unknown */
+        type A = any; // Should remain any
+        const b = [1, 2, 3] as const; // Should have as const
+        type D = any; // Should remain any
+      `,
+    },
+    {
+      name: 'codemod-ignore for entire file',
+      source: dedent`
+        /* codemod-ignore convert-to-readonly */
+        type A = any;
+        const b = [1, 2, 3];
+        type C = number[]; // Should remain mutable
+      `,
+      expected: dedent`
+        /* codemod-ignore convert-to-readonly */
+        type A = unknown;
+        const b = [1, 2, 3] as const;
+        type C = number[]; // Should remain mutable
+      `,
+    },
+    {
+      name: 'transform-ignore for entire file',
+      source: dedent`
+        /* transform-ignore append-as-const */
+        type A = any;
+        const b = [1, 2, 3]; // Should remain without as const
+        type C = number[];
+      `,
+      expected: dedent`
+        /* transform-ignore append-as-const */
+        type A = unknown;
+        const b = [1, 2, 3]; // Should remain without as const
+        type C = readonly number[];
+      `,
+    },
     {
       name: 'Ignore multiple specific transformers on next line',
       source: dedent`
@@ -185,5 +269,50 @@ describe('Transformer-specific ignore comments (Integration)', () => {
         type C = number[]; // Should remain mutable
       `,
     },
+    {
+      name: 'ts-codemod-ignore for entire file',
+      source: dedent`
+        /* ts-codemod-ignore replace-any-with-unknown */
+        type A = any; // Should remain any
+        const b = [1, 2, 3]; // Should have as const
+        type D = any; // Should remain any
+      `,
+      expected: dedent`
+        /* ts-codemod-ignore replace-any-with-unknown */
+        type A = any; // Should remain any
+        const b = [1, 2, 3] as const; // Should have as const
+        type D = any; // Should remain any
+      `,
+    },
+    {
+      name: 'codemod-ignore for entire file',
+      source: dedent`
+        /* codemod-ignore convert-to-readonly */
+        type A = any;
+        const b = [1, 2, 3];
+        type C = number[]; // Should remain mutable
+      `,
+      expected: dedent`
+        /* codemod-ignore convert-to-readonly */
+        type A = unknown;
+        const b = [1, 2, 3] as const;
+        type C = number[]; // Should remain mutable
+      `,
+    },
+    {
+      name: 'transform-ignore for entire file',
+      source: dedent`
+        /* transform-ignore append-as-const */
+        type A = any;
+        const b = [1, 2, 3]; // Should remain without as const
+        type C = number[];
+      `,
+      expected: dedent`
+        /* transform-ignore append-as-const */
+        type A = unknown;
+        const b = [1, 2, 3]; // Should remain without as const
+        type C = readonly number[];
+      `,
+    },
   ])('$name', testFn);
 });

package/src/functions/constants/ignore-comment-text.mts

@@ -1,3 +1,13 @@
-export const IGNORE_LINE_COMMENT_PREFIX = 'transformer-ignore-next-line';
+export const IGNORE_LINE_COMMENT_PREFIXES = [
+  'transformer-ignore-next-line',
+  'ts-codemod-ignore-next-line',
+  'codemod-ignore-next-line',
+  'transform-ignore-next-line',
+] as const;
 
-export const IGNORE_FILE_COMMENT_PREFIX = 'transformer-ignore';
+export const IGNORE_FILE_COMMENT_PREFIXES = [
+  'transformer-ignore',
+  'ts-codemod-ignore',
+  'codemod-ignore',
+  'transform-ignore',
+] as const;

package/src/functions/functions/has-disable-next-line-comment.mts

@@ -1,9 +1,9 @@
 import * as tsm from 'ts-morph';
-import { IGNORE_LINE_COMMENT_PREFIX } from '../constants/index.mjs';
+import { IGNORE_LINE_COMMENT_PREFIXES } from '../constants/index.mjs';
 
 /**
- * Checks if a given ts-morph Node is immediately preceded by a
- * '// transformer-ignore-next-line' comment, optionally filtered by transformer name(s).
+ * Checks if a given ts-morph Node is immediately preceded by an ignore-next-line comment,
+ * optionally filtered by transformer name(s).
  *
  * @param node - The ts-morph Node to check.
  * @param transformerName - Optional transformer name to check for specific ignore directive.
@@ -12,6 +12,7 @@ import { IGNORE_LINE_COMMENT_PREFIX } from '../constants/index.mjs';
  *                          - `// transformer-ignore-next-line` (ignores all transformers)
  *                          - `// transformer-ignore-next-line append-as-const` (specific transformer)
  *                          - `// transformer-ignore-next-line append-as-const, replace-any-with-unknown` (multiple transformers)
+ *                          - Also accepts `ts-codemod-ignore-next-line`, `codemod-ignore-next-line`, `transform-ignore-next-line`
  * @returns True if the node is preceded by the ignore comment on the immediately previous line, false otherwise.
  */
 export const hasDisableNextLineComment = (
@@ -45,11 +46,16 @@ export const hasDisableNextLineComment = (
       if (commentRange.getKind() === tsm.SyntaxKind.SingleLineCommentTrivia) {
         const commentText = commentRange.getText().trim();
 
-        if (commentText.includes(IGNORE_LINE_COMMENT_PREFIX)) {
+        // Check if the comment contains any of the supported ignore prefixes
+        const matchedPrefix = IGNORE_LINE_COMMENT_PREFIXES.find((prefix) =>
+          commentText.includes(prefix),
+        );
+
+        if (matchedPrefix !== undefined) {
           // Extract the part after the prefix
           const afterPrefix = commentText
-            .slice(commentText.indexOf(IGNORE_LINE_COMMENT_PREFIX))
-            .replace(IGNORE_LINE_COMMENT_PREFIX, '')
+            .slice(commentText.indexOf(matchedPrefix))
+            .replace(matchedPrefix, '')
             .trim();
 
           // If no transformer name specified, check if comment applies to all transformers

package/src/functions/functions/index.mts

@@ -4,5 +4,6 @@ export * from './is-atomic-type-node.mjs';
 export * from './is-readonly-node.mjs';
 export * from './is-spread-parameter-node.mjs';
 export * from './remove-parentheses.mjs';
+export * from './should-avoid-parentheses-for-readonly.mjs';
 export * from './unwrap-readonly.mjs';
 export * from './wrap-with-parentheses.mjs';

package/src/functions/functions/is-as-const-node.mts

@@ -1,3 +1,4 @@
+import { Arr } from 'ts-data-forge';
 import * as ts from 'ts-morph';
 
 export const isAsConstNode = (
@@ -42,6 +43,6 @@ export const isAsConstNode = (
   //    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)
   );
 };