ts-codemod-lib 2.2.3 → 2.2.5

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

@@ -8,7 +8,12 @@ import {
   pipe,
 } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
-import { type DeepReadonly, type SafeUintWithSmallInt } from 'ts-type-forge';
+import {
+  type DeepReadonly,
+  type SafeUintWithSmallInt,
+  type StrictExclude,
+  type StrictExtract,
+} from 'ts-type-forge';
 import {
   hasDisableNextLineComment,
   isAtomicTypeNode,
@@ -397,7 +402,7 @@ const transformNode = (
 const transformTypeReferenceNode = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: tsm.TypeReferenceNode,
-  readonlyContext: Exclude<
+  readonlyContext: StrictExclude<
     ReadonlyContext,
     Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
   >,
@@ -409,7 +414,7 @@ const transformTypeReferenceNode = (
 
   // Array<T> / ReadonlyArray<T> to readonly T[]
   if (typeNameStr === 'Array' || typeNameStr === 'ReadonlyArray') {
-    if (!Arr.isArrayOfLength(typeArguments, 1)) {
+    if (!Arr.isFixedLengthArray(1, typeArguments)) {
       throw new Error(
         `Unexpected number of type arguments "${typeArguments.length}" for ${typeNameStr}.`,
       );
@@ -442,7 +447,7 @@ const transformTypeReferenceNode = (
 
   // Set<T> to ReadonlySet<T>
   if (typeNameStr === 'Set') {
-    if (!Arr.isArrayOfLength(typeArguments, 1)) {
+    if (!Arr.isFixedLengthArray(1, typeArguments)) {
       throw new Error(
         `Unexpected number of type arguments "${typeArguments.length}" for Set.`,
       );
@@ -468,7 +473,7 @@ const transformTypeReferenceNode = (
 
   // Map<T> to ReadonlyMap<T>
   if (typeNameStr === 'Map') {
-    if (!Arr.isArrayOfLength(typeArguments, 2)) {
+    if (!Arr.isFixedLengthArray(2, typeArguments)) {
       throw new Error(
         `Unexpected number of type arguments "${typeArguments.length}" for Map.`,
       );
@@ -498,7 +503,7 @@ const transformTypeReferenceNode = (
 
   // remove unnecessary `Readonly` wrapper or convert to readonly operator
   if (typeNameStr === 'Readonly') {
-    if (!Arr.isArrayOfLength(typeArguments, 1)) {
+    if (!Arr.isFixedLengthArray(1, typeArguments)) {
       throw new Error(
         `Unexpected number of type arguments "${typeArguments.length}" for Readonly.`,
       );
@@ -592,7 +597,7 @@ const transformTypeReferenceNode = (
 
   // DeepReadonly
   if (typeNameStr === options.DeepReadonly.typeName) {
-    if (!Arr.isArrayOfLength(typeArguments, 1)) {
+    if (!Arr.isFixedLengthArray(1, typeArguments)) {
       throw new Error(
         `Unexpected number of type arguments "${typeArguments.length}" for Readonly.`,
       );
@@ -813,7 +818,7 @@ const transformRestTypeNode = (
 const transformTypeOperatorNode = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: tsm.TypeOperatorTypeNode,
-  readonlyContext: Exclude<
+  readonlyContext: StrictExclude<
     ReadonlyContext,
     Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
   >,
@@ -852,16 +857,13 @@ const transformTypeOperatorNode = (
 const transformTypeLiteralNode = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: tsm.TypeLiteralNode,
-  readonlyContext: Exclude<
+  readonlyContext: StrictExclude<
     ReadonlyContext,
     Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
   >,
   options: ReadonlyTransformerOptionsInternal,
 ): void => {
-  if (
-    options.ignoreEmptyObjectTypes &&
-    Arr.isArrayOfLength(node.getMembers(), 0)
-  ) {
+  if (options.ignoreEmptyObjectTypes && Arr.isEmpty(node.getMembers())) {
     return;
   }
 
@@ -930,7 +932,7 @@ const transformIndexedAccessTypeNode = (
 const transformMappedTypeNode = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: tsm.MappedTypeNode,
-  readonlyContext: Exclude<
+  readonlyContext: StrictExclude<
     ReadonlyContext,
     Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
   >,
@@ -1112,7 +1114,7 @@ const transformConstructorParameter = (
 const transformIntersectionTypeNode = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: tsm.IntersectionTypeNode,
-  readonlyContext: Exclude<
+  readonlyContext: StrictExclude<
     ReadonlyContext,
     Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
   >,
@@ -1128,7 +1130,7 @@ const transformIntersectionTypeNode = (
 const transformUnionTypeNode = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: tsm.UnionTypeNode,
-  readonlyContext: Exclude<
+  readonlyContext: StrictExclude<
     ReadonlyContext,
     Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
   >,
@@ -1140,7 +1142,7 @@ const transformUnionTypeNode = (
 const transformUnionOrIntersectionTypeNodeImpl = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: tsm.IntersectionTypeNode | tsm.UnionTypeNode,
-  readonlyContext: Exclude<
+  readonlyContext: StrictExclude<
     ReadonlyContext,
     Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
   >,
@@ -1170,8 +1172,7 @@ const transformUnionOrIntersectionTypeNodeImpl = (
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     n: tsm.TypeLiteralNode | ReadonlyTypeReferenceNode,
   ): boolean =>
-    n.isKind(tsm.SyntaxKind.TypeLiteral) &&
-    Arr.isArrayOfLength(n.getMembers(), 0);
+    n.isKind(tsm.SyntaxKind.TypeLiteral) && Arr.isEmpty(n.getMembers());
 
   const nonEmptyTypeLiterals =
     typeLiterals === undefined
@@ -1183,11 +1184,10 @@ const transformUnionOrIntersectionTypeNodeImpl = (
   const emptyTypeLiterals =
     typeLiterals === undefined || !options.ignoreEmptyObjectTypes
       ? undefined
-      : typeLiterals.nodes.filter((n) => isEmptyTypeLiteral(n));
+      : typeLiterals.nodes.filter(isEmptyTypeLiteral);
 
   const typeLiteralsWrappedWithReadonly: readonly [] | readonly [string] =
-    nonEmptyTypeLiterals === undefined ||
-    Arr.isArrayOfLength(nonEmptyTypeLiterals, 0)
+    nonEmptyTypeLiterals === undefined || Arr.isEmpty(nonEmptyTypeLiterals)
       ? ([] as const)
       : ([
           unionToString({
@@ -1282,9 +1282,9 @@ const unionToString = ({
   op: '&' | '|';
   wrapWithReadonly: boolean | string;
 }>): string =>
-  Arr.isArrayOfLength(types, 0)
+  Arr.isEmpty(types)
     ? 'never'
-    : Arr.isArrayOfLength(types, 1)
+    : Arr.isFixedLengthArray(1, types)
       ? wrapWithReadonly === false
         ? wrapWithParentheses(types[0])
         : (`${isString(wrapWithReadonly) ? wrapWithReadonly : 'Readonly'}<${types[0]}>` as const)
@@ -1351,7 +1351,7 @@ const transformMembers = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   members: readonly tsm.TypeElementTypes[],
   readonlyModifier: 'add' | 'remove',
-  readonlyContext: Extract<
+  readonlyContext: StrictExtract<
     ReadonlyContext,
     Readonly<{
       type: 'DeepReadonly' | 'none';
@@ -1392,8 +1392,6 @@ const transformMembers = (
     }
 
     transformNode(mb, readonlyContext, options);
-
-    continue;
   }
 };
 
@@ -1401,7 +1399,7 @@ const transformPropertySignature = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: tsm.PropertySignature,
   readonlyModifier: 'add' | 'remove',
-  readonlyContext: Extract<
+  readonlyContext: StrictExtract<
     ReadonlyContext,
     Readonly<{
       type: 'DeepReadonly' | 'none';
@@ -1411,8 +1409,8 @@ const transformPropertySignature = (
   options: ReadonlyTransformerOptionsInternal,
 ): void => {
   if (
-    readonlyContext.type === 'DeepReadonly' ||
-    readonlyModifier === 'remove'
+    readonlyModifier === 'remove' ||
+    readonlyContext.type === 'DeepReadonly'
   ) {
     node.setIsReadonly(false);
   } else {
@@ -1432,7 +1430,7 @@ const transformIndexSignatureDeclaration = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: tsm.IndexSignatureDeclaration,
   readonlyModifier: 'add' | 'remove',
-  readonlyContext: Extract<
+  readonlyContext: StrictExtract<
     ReadonlyContext,
     Readonly<{
       type: 'DeepReadonly' | 'none';
@@ -1448,8 +1446,8 @@ const transformIndexSignatureDeclaration = (
   }
 
   if (
-    readonlyContext.type === 'DeepReadonly' ||
-    readonlyModifier === 'remove'
+    readonlyModifier === 'remove' ||
+    readonlyContext.type === 'DeepReadonly'
   ) {
     // node.setIsReadonly(false);
     node.toggleModifier('readonly', false);

package/src/functions/ast-transformers/readonly-transformer-helpers/readonly-context.mts

@@ -1,5 +1,5 @@
 import { SafeUint, match } from 'ts-data-forge';
-import { type SafeUintWithSmallInt } from 'ts-type-forge';
+import { type SafeUintWithSmallInt, type StrictExtract } from 'ts-type-forge';
 
 /**
  * Controls whether to make a layer mutable during recursive transformation
@@ -37,7 +37,7 @@ export const nextReadonlyContext = <
         indexedAccessDepthChange: 'decr' | 'incr' | 'keep' | 'infinity';
       }
     | {
-        nextReadonlyContextType: Extract<
+        nextReadonlyContextType: StrictExtract<
           ReadonlyContext['type'],
           'DeepReadonly'
         >;
@@ -47,7 +47,7 @@ export const nextReadonlyContext = <
     currentReadonlyContext: Curr;
   }
 >): Readonly<{
-  type: Extract<ReadonlyContext['type'], 'DeepReadonly'> | Next;
+  type: Next | StrictExtract<ReadonlyContext['type'], 'DeepReadonly'>;
   indexedAccessDepth: SafeUintWithSmallInt;
 }> =>
   curr.type === 'DeepReadonly'

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

@@ -24,9 +24,7 @@ export const replaceRecordWithUnknownRecordTransformer =
       name: TRANSFORMER_NAME,
       transform: (sourceAst) => {
         const containerModifications = Arr.toUnshifted(
-          sourceAst
-            .getModules()
-            .map((namespace) => processDeclarations(namespace)),
+          sourceAst.getModules().map(processDeclarations),
           processDeclarations(sourceAst),
         );
 
@@ -53,7 +51,7 @@ const processDeclarations = (
 
   const interfaceModifications = container
     .getInterfaces()
-    .map((interfaceDecl) => processInterfaceDeclaration(interfaceDecl));
+    .map(processInterfaceDeclaration);
 
   return [...typeAliasModifications, ...interfaceModifications].includes(true);
 };
@@ -81,10 +79,10 @@ const processInterfaceDeclaration = (
   // (type parameters, extends clauses, declare modifier, default export).
   if (
     hasStringUnknownSignature &&
-    Arr.isArrayOfLength(interfaceDecl.getProperties(), 0) &&
-    Arr.isArrayOfLength(indexSignatures, 1) &&
-    Arr.isArrayOfLength(interfaceDecl.getTypeParameters(), 0) &&
-    Arr.isArrayOfLength(interfaceDecl.getExtends(), 0) &&
+    Arr.isEmpty(interfaceDecl.getProperties()) &&
+    Arr.isFixedLengthArray(1, indexSignatures) &&
+    Arr.isEmpty(interfaceDecl.getTypeParameters()) &&
+    Arr.isEmpty(interfaceDecl.getExtends()) &&
     !interfaceDecl.hasDeclareKeyword() &&
     !interfaceDecl.hasDefaultKeyword()
   ) {
@@ -118,7 +116,7 @@ const visitTypeNode = (node: tsm.TypeNode): boolean => {
     if (node.getTypeName().getText() === 'Readonly') {
       const typeArgs = node.getTypeArguments();
 
-      if (Arr.isArrayOfLength(typeArgs, 1)) {
+      if (Arr.isFixedLengthArray(1, typeArgs)) {
         const typeArg = typeArgs[0];
 
         if (tsm.Node.isTypeLiteral(typeArg)) {
@@ -130,8 +128,8 @@ const visitTypeNode = (node: tsm.TypeNode): boolean => {
 
           // Check if it has only one index signature [k: string]: unknown
           if (
-            Arr.isArrayOfLength(members, 1) &&
-            Arr.isArrayOfLength(indexSigs, 1) &&
+            Arr.isFixedLengthArray(1, members) &&
+            Arr.isFixedLengthArray(1, indexSigs) &&
             isStringUnknownIndexSignature(indexSigs[0])
           ) {
             node.replaceWithText('UnknownRecord');
@@ -158,8 +156,8 @@ const visitTypeNode = (node: tsm.TypeNode): boolean => {
 
     // Check if it has only one index signature [k: string]: unknown
     if (
-      Arr.isArrayOfLength(members, 1) &&
-      Arr.isArrayOfLength(indexSigs, 1) &&
+      Arr.isFixedLengthArray(1, members) &&
+      Arr.isFixedLengthArray(1, indexSigs) &&
       isStringUnknownIndexSignature(indexSigs[0])
     ) {
       node.replaceWithText('UnknownRecord');
@@ -188,10 +186,7 @@ const visitTypeNode = (node: tsm.TypeNode): boolean => {
 
   // Recursively visit child type nodes
   if (tsm.Node.isUnionTypeNode(node) || tsm.Node.isIntersectionTypeNode(node)) {
-    return node
-      .getTypeNodes()
-      .map((typeNode) => visitTypeNode(typeNode))
-      .includes(true);
+    return node.getTypeNodes().map(visitTypeNode).includes(true);
   }
 
   if (tsm.Node.isArrayTypeNode(node)) {
@@ -199,10 +194,7 @@ const visitTypeNode = (node: tsm.TypeNode): boolean => {
   }
 
   if (tsm.Node.isTupleTypeNode(node)) {
-    return node
-      .getElements()
-      .map((element) => visitTypeNode(element))
-      .includes(true);
+    return node.getElements().map(visitTypeNode).includes(true);
   }
 
   if (tsm.Node.isParenthesizedTypeNode(node)) {
@@ -244,7 +236,7 @@ const replaceIfRecordUnknown = (node: tsm.TypeReferenceNode): boolean => {
       const typeArgs = node.getTypeArguments();
 
       if (
-        Arr.isArrayOfLength(typeArgs, 2) &&
+        Arr.isFixedLengthArray(2, typeArgs) &&
         typeArgs[0].getText() === 'string' &&
         typeArgs[1].getText() === 'unknown'
       ) {
@@ -254,13 +246,13 @@ const replaceIfRecordUnknown = (node: tsm.TypeReferenceNode): boolean => {
       }
 
       // Recurse into type arguments (e.g. Record<string, Record<string, unknown>>)
-      return typeArgs.map((typeArg) => visitTypeNode(typeArg)).includes(true);
+      return typeArgs.map(visitTypeNode).includes(true);
     }
     case 'Readonly': {
       // Check if it's Readonly<Record<string, unknown>>
       const typeArgs = node.getTypeArguments();
 
-      if (Arr.isArrayOfLength(typeArgs, 1)) {
+      if (Arr.isFixedLengthArray(1, typeArgs)) {
         const innerType = typeArgs[0];
 
         if (tsm.Node.isTypeReference(innerType)) {
@@ -270,7 +262,7 @@ const replaceIfRecordUnknown = (node: tsm.TypeReferenceNode): boolean => {
             const innerTypeArgs = innerType.getTypeArguments();
 
             if (
-              Arr.isArrayOfLength(innerTypeArgs, 2) &&
+              Arr.isFixedLengthArray(2, innerTypeArgs) &&
               innerTypeArgs[0].getText() === 'string' &&
               innerTypeArgs[1].getText() === 'unknown'
             ) {
@@ -290,10 +282,7 @@ const replaceIfRecordUnknown = (node: tsm.TypeReferenceNode): boolean => {
 
     default: {
       // Recurse into type arguments for any other generic type
-      return node
-        .getTypeArguments()
-        .map((typeArg) => visitTypeNode(typeArg))
-        .includes(true);
+      return node.getTypeArguments().map(visitTypeNode).includes(true);
     }
   }
 };

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

@@ -58,12 +58,12 @@ const shouldSkipFile = (
 
   const hasFileIgnoreComment = patterns.some((regex) => regex.test(code));
 
-  if (Arr.isArrayOfLength(ignoredTransformers, 0) && !hasFileIgnoreComment) {
+  if (!hasFileIgnoreComment && Arr.isEmpty(ignoredTransformers)) {
     return false;
   }
 
   // Empty array means ignore all transformers (file-level ignore without specific transformers)
-  if (Arr.isArrayOfLength(ignoredTransformers, 0)) {
+  if (Arr.isEmpty(ignoredTransformers)) {
     return true;
   }
 

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

@@ -43,6 +43,6 @@ export const isAsConstNode = (
   //    and that there are no type arguments (as const doesn't have them)
   return (
     typeNameNode.getText() === 'const' &&
-    Arr.isArrayOfLength(typeNode.getTypeArguments(), 0)
+    Arr.isEmpty(typeNode.getTypeArguments())
   );
 };

package/src/functions/functions/is-readonly-node.mts

@@ -1,6 +1,6 @@
 import { Arr, expectType } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
-import { type DeepReadonly } from 'ts-type-forge';
+import { type DeepReadonly, type StrictOmit } from 'ts-type-forge';
 import { isAtomicTypeNode } from './is-atomic-type-node.mjs';
 
 export const isShallowReadonlyTypeNode = (node: tsm.Node): boolean =>
@@ -17,7 +17,7 @@ export const isReadonlyTupleOrArrayTypeNode = (
     node.getTypeNode().isKind(tsm.SyntaxKind.TupleType));
 
 export type ReadonlyArrayTypeNode = tsm.TypeNode &
-  Omit<tsm.TypeOperatorTypeNode, 'getOperator' | 'getTypeNode'> &
+  StrictOmit<tsm.TypeOperatorTypeNode, 'getOperator' | 'getTypeNode'> &
   Readonly<{
     getOperator: () => tsm.SyntaxKind.ReadonlyKeyword;
     getTypeNode: () => tsm.ArrayTypeNode;
@@ -91,7 +91,7 @@ if (import.meta.vitest !== undefined) {
 }
 
 export type ReadonlyTupleTypeNode = tsm.TypeNode &
-  Omit<tsm.TypeOperatorTypeNode, 'getOperator' | 'getTypeNode'> &
+  StrictOmit<tsm.TypeOperatorTypeNode, 'getOperator' | 'getTypeNode'> &
   Readonly<{
     getOperator: () => tsm.SyntaxKind.ReadonlyKeyword;
     getTypeNode: () => tsm.TupleTypeNode;
@@ -153,9 +153,9 @@ if (import.meta.vitest !== undefined) {
 }
 
 export type ReadonlyTypeReferenceNode = tsm.TypeNode &
-  Omit<tsm.TypeReferenceNode, 'getTypeName' | 'getTypeArguments'> &
+  StrictOmit<tsm.TypeReferenceNode, 'getTypeName' | 'getTypeArguments'> &
   Readonly<{
-    getTypeName: () => Omit<tsm.Identifier, 'getText'> &
+    getTypeName: () => StrictOmit<tsm.Identifier, 'getText'> &
       Readonly<{
         getText: () => 'Readonly';
       }>;
@@ -176,7 +176,7 @@ export const isReadonlyTypeReferenceNode = (
   return (
     typeName.isKind(tsm.SyntaxKind.Identifier) &&
     typeName.getText() === 'Readonly' &&
-    Arr.isArrayOfLength(typeArguments, 1)
+    Arr.isFixedLengthArray(1, typeArguments)
   );
 };
 

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

@@ -23,10 +23,6 @@ export const shouldAvoidParenthesesForReadonly = (node: tsm.Node): boolean => {
   // 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;
+  return parent.isKind(tsm.SyntaxKind.TypePredicate);
 };