ts-codemod-lib 2.2.2 → 2.2.4

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

@@ -16,7 +16,7 @@ const isAsConstNode = (node) => {
   if (!typeNameNode.isKind(tsm.SyntaxKind.Identifier)) {
     return false;
   }
-  return typeNameNode.getText() === "const" && Arr.isArrayOfLength(typeNode.getTypeArguments(), 0);
+  return typeNameNode.getText() === "const" && Arr.isEmpty(typeNode.getTypeArguments());
 };
 
 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":["import { Arr } from 'ts-data-forge';\nimport * as ts from 'ts-morph';\n\nexport const isAsConstNode = (\n  node: ts.Node,\n): node is ts.AsExpression &\n  Readonly<{\n    type: ts.TypeReferenceNode &\n      Readonly<{\n        typeName: ts.Identifier &\n          Readonly<{\n            text: 'const';\n          }>;\n        typeArguments: undefined;\n      }>;\n  }> => {\n  if (!node.isKind(ts.SyntaxKind.AsExpression)) {\n    return false;\n  }\n\n  // 2. Get the 'type' node from the AsExpression\n  const typeNode = node.getTypeNode();\n\n  if (typeNode === undefined) {\n    return false; // Should have a type node for 'as const'\n  }\n\n  // 3. Check if the 'type' node is a TypeReference\n  if (!typeNode.isKind(ts.SyntaxKind.TypeReference)) {\n    return false;\n  }\n\n  // 4. Get the 'typeName' from the TypeReference\n  const typeNameNode = typeNode.getTypeName();\n\n  // 5. Check if the 'typeName' is an Identifier\n  if (!typeNameNode.isKind(ts.SyntaxKind.Identifier)) {\n    // 'as const' uses a simple Identifier 'const', not a QualifiedName\n    return false;\n  }\n\n  // 6. Check if the Identifier's text is 'const'\n  //    and that there are no type arguments (as const doesn't have them)\n  return (\n    typeNameNode.getText() === 'const' &&\n    Arr.isArrayOfLength(typeNode.getTypeArguments(), 0)\n  );\n};\n"],"names":["ts"],"mappings":";;;AAGO,MAAM,aAAA,GAAgB,CAC3B,IAAA,KAWM;AACN,EAAA,IAAI,CAAC,IAAA,CAAK,MAAA,CAAOA,GAAA,CAAG,UAAA,CAAW,YAAY,CAAA,EAAG;AAC5C,IAAA,OAAO,KAAA;AAAA,EACT;AAGA,EAAA,MAAM,QAAA,GAAW,KAAK,WAAA,EAAY;AAElC,EAAA,IAAI,aAAa,MAAA,EAAW;AAC1B,IAAA,OAAO,KAAA;AAAA,EACT;AAGA,EAAA,IAAI,CAAC,QAAA,CAAS,MAAA,CAAOA,GAAA,CAAG,UAAA,CAAW,aAAa,CAAA,EAAG;AACjD,IAAA,OAAO,KAAA;AAAA,EACT;AAGA,EAAA,MAAM,YAAA,GAAe,SAAS,WAAA,EAAY;AAG1C,EAAA,IAAI,CAAC,YAAA,CAAa,MAAA,CAAOA,GAAA,CAAG,UAAA,CAAW,UAAU,CAAA,EAAG;AAElD,IAAA,OAAO,KAAA;AAAA,EACT;AAIA,EAAA,OACE,YAAA,CAAa,SAAQ,KAAM,OAAA,IAC3B,IAAI,eAAA,CAAgB,QAAA,CAAS,gBAAA,EAAiB,EAAG,CAAC,CAAA;AAEtD;;;;"}
+{"version":3,"file":"is-as-const-node.mjs","sources":["../../../src/functions/functions/is-as-const-node.mts"],"sourcesContent":["import { Arr } from 'ts-data-forge';\nimport * as ts from 'ts-morph';\n\nexport const isAsConstNode = (\n  node: ts.Node,\n): node is ts.AsExpression &\n  Readonly<{\n    type: ts.TypeReferenceNode &\n      Readonly<{\n        typeName: ts.Identifier &\n          Readonly<{\n            text: 'const';\n          }>;\n        typeArguments: undefined;\n      }>;\n  }> => {\n  if (!node.isKind(ts.SyntaxKind.AsExpression)) {\n    return false;\n  }\n\n  // 2. Get the 'type' node from the AsExpression\n  const typeNode = node.getTypeNode();\n\n  if (typeNode === undefined) {\n    return false; // Should have a type node for 'as const'\n  }\n\n  // 3. Check if the 'type' node is a TypeReference\n  if (!typeNode.isKind(ts.SyntaxKind.TypeReference)) {\n    return false;\n  }\n\n  // 4. Get the 'typeName' from the TypeReference\n  const typeNameNode = typeNode.getTypeName();\n\n  // 5. Check if the 'typeName' is an Identifier\n  if (!typeNameNode.isKind(ts.SyntaxKind.Identifier)) {\n    // 'as const' uses a simple Identifier 'const', not a QualifiedName\n    return false;\n  }\n\n  // 6. Check if the Identifier's text is 'const'\n  //    and that there are no type arguments (as const doesn't have them)\n  return (\n    typeNameNode.getText() === 'const' &&\n    Arr.isEmpty(typeNode.getTypeArguments())\n  );\n};\n"],"names":["ts"],"mappings":";;;AAGO,MAAM,aAAA,GAAgB,CAC3B,IAAA,KAWM;AACN,EAAA,IAAI,CAAC,IAAA,CAAK,MAAA,CAAOA,GAAA,CAAG,UAAA,CAAW,YAAY,CAAA,EAAG;AAC5C,IAAA,OAAO,KAAA;AAAA,EACT;AAGA,EAAA,MAAM,QAAA,GAAW,KAAK,WAAA,EAAY;AAElC,EAAA,IAAI,aAAa,MAAA,EAAW;AAC1B,IAAA,OAAO,KAAA;AAAA,EACT;AAGA,EAAA,IAAI,CAAC,QAAA,CAAS,MAAA,CAAOA,GAAA,CAAG,UAAA,CAAW,aAAa,CAAA,EAAG;AACjD,IAAA,OAAO,KAAA;AAAA,EACT;AAGA,EAAA,MAAM,YAAA,GAAe,SAAS,WAAA,EAAY;AAG1C,EAAA,IAAI,CAAC,YAAA,CAAa,MAAA,CAAOA,GAAA,CAAG,UAAA,CAAW,UAAU,CAAA,EAAG;AAElD,IAAA,OAAO,KAAA;AAAA,EACT;AAIA,EAAA,OACE,YAAA,CAAa,SAAQ,KAAM,OAAA,IAC3B,IAAI,OAAA,CAAQ,QAAA,CAAS,kBAAkB,CAAA;AAE3C;;;;"}

package/dist/functions/functions/is-readonly-node.mjs

@@ -13,7 +13,7 @@ const isReadonlyTypeReferenceNode = (node) => {
   }
   const typeName = node.getTypeName();
   const typeArguments = node.getTypeArguments();
-  return typeName.isKind(tsm.SyntaxKind.Identifier) && typeName.getText() === "Readonly" && Arr.isArrayOfLength(typeArguments, 1);
+  return typeName.isKind(tsm.SyntaxKind.Identifier) && typeName.getText() === "Readonly" && Arr.isFixedLengthArray(1, typeArguments);
 };
 
 export { isReadonlyArrayTypeNode, isReadonlyTupleOrArrayTypeNode, isReadonlyTupleTypeNode, isReadonlyTypeReferenceNode, isShallowReadonlyTypeNode };

package/dist/functions/functions/is-readonly-node.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-readonly-node.mjs","sources":["../../../src/functions/functions/is-readonly-node.mts"],"sourcesContent":["import { Arr, expectType } from 'ts-data-forge';\nimport * as tsm from 'ts-morph';\nimport { type DeepReadonly } from 'ts-type-forge';\nimport { isAtomicTypeNode } from './is-atomic-type-node.mjs';\n\nexport const isShallowReadonlyTypeNode = (node: tsm.Node): boolean =>\n  isReadonlyTupleOrArrayTypeNode(node) ||\n  isReadonlyTypeReferenceNode(node) ||\n  isAtomicTypeNode(node);\n\nexport const isReadonlyTupleOrArrayTypeNode = (\n  node: DeepReadonly<tsm.Node>,\n): node is ReadonlyArrayTypeNode | ReadonlyTupleTypeNode =>\n  node.isKind(tsm.SyntaxKind.TypeOperator) &&\n  node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword &&\n  (node.getTypeNode().isKind(tsm.SyntaxKind.ArrayType) || // Use optional chaining and isKind\n    node.getTypeNode().isKind(tsm.SyntaxKind.TupleType));\n\nexport type ReadonlyArrayTypeNode = tsm.TypeNode &\n  Omit<tsm.TypeOperatorTypeNode, 'getOperator' | 'getTypeNode'> &\n  Readonly<{\n    getOperator: () => tsm.SyntaxKind.ReadonlyKeyword;\n    getTypeNode: () => tsm.ArrayTypeNode;\n  }>;\n\nexport const isReadonlyArrayTypeNode = (\n  node: DeepReadonly<tsm.Node>,\n): node is ReadonlyArrayTypeNode =>\n  node.isKind(tsm.SyntaxKind.TypeOperator) &&\n  node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword &&\n  node.getTypeNode().isKind(tsm.SyntaxKind.ArrayType);\n\n// Helper to get a specific type node from source code\nconst getTypeNodeFromSource = (\n  sourceCode: string,\n  typeName: string,\n): tsm.Node => {\n  const project = new tsm.Project({ useInMemoryFileSystem: true });\n\n  const sourceFile = project.createSourceFile('test.ts', sourceCode);\n\n  const typeAlias = sourceFile.getTypeAliasOrThrow(typeName);\n\n  return typeAlias.getTypeNodeOrThrow();\n};\n\nif (import.meta.vitest !== undefined) {\n  describe('isReadonlyArrayTypeNode', () => {\n    test('should return true for readonly array type', () => {\n      const node = getTypeNodeFromSource(\n        'type Test = readonly number[];',\n        'Test',\n      );\n\n      if (isReadonlyArrayTypeNode(node)) {\n        const _operator = node.getOperator();\n\n        expectType<typeof _operator, tsm.SyntaxKind.ReadonlyKeyword>('=');\n\n        const _typeNode = node.getTypeNode();\n\n        expectType<typeof _typeNode, tsm.ArrayTypeNode>('=');\n      }\n\n      assert.isTrue(node.isKind(tsm.SyntaxKind.TypeOperator));\n\n      if (!isReadonlyArrayTypeNode(node)) {\n        throw new Error('node should be ReadonlyArrayTypeNode');\n      }\n\n      expect(node.getOperator()).toBe(tsm.SyntaxKind.ReadonlyKeyword);\n\n      assert.isTrue(node.getTypeNode().isKind(tsm.SyntaxKind.ArrayType));\n    });\n\n    test('should return false for non-readonly array', () => {\n      const node = getTypeNodeFromSource('type Test = string[];', 'Test');\n\n      assert.isFalse(isReadonlyArrayTypeNode(node));\n    });\n\n    test('should return false for readonly tuple', () => {\n      const node = getTypeNodeFromSource(\n        'type Test = readonly [string];',\n        'Test',\n      );\n\n      assert.isFalse(isReadonlyArrayTypeNode(node));\n    });\n  });\n}\n\nexport type ReadonlyTupleTypeNode = tsm.TypeNode &\n  Omit<tsm.TypeOperatorTypeNode, 'getOperator' | 'getTypeNode'> &\n  Readonly<{\n    getOperator: () => tsm.SyntaxKind.ReadonlyKeyword;\n    getTypeNode: () => tsm.TupleTypeNode;\n  }>;\n\nexport const isReadonlyTupleTypeNode = (\n  node: DeepReadonly<tsm.Node>,\n): node is ReadonlyTupleTypeNode =>\n  node.isKind(tsm.SyntaxKind.TypeOperator) &&\n  node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword &&\n  node.getTypeNode().isKind(tsm.SyntaxKind.TupleType);\n\nif (import.meta.vitest !== undefined) {\n  describe('isReadonlyTupleTypeNode', () => {\n    test('should return true for readonly tuple type', () => {\n      const node = getTypeNodeFromSource(\n        'type Test = readonly [number, string];',\n        'Test',\n      );\n\n      assert.isTrue(isReadonlyTupleTypeNode(node));\n\n      if (isReadonlyTupleTypeNode(node)) {\n        const _operator = node.getOperator();\n\n        expectType<typeof _operator, tsm.SyntaxKind.ReadonlyKeyword>('=');\n\n        const _typeNode = node.getTypeNode();\n\n        expectType<typeof _typeNode, tsm.TupleTypeNode>('=');\n      }\n\n      assert.isTrue(node.isKind(tsm.SyntaxKind.TypeOperator));\n\n      if (!isReadonlyTupleTypeNode(node)) {\n        throw new Error('node should be ReadonlyTupleTypeNode');\n      }\n\n      expect(node.getOperator()).toBe(tsm.SyntaxKind.ReadonlyKeyword);\n\n      assert.isTrue(node.getTypeNode().isKind(tsm.SyntaxKind.TupleType));\n    });\n\n    test('should return false for non-readonly tuple', () => {\n      const node = getTypeNodeFromSource('type Test = [boolean];', 'Test');\n\n      assert.isFalse(isReadonlyTupleTypeNode(node));\n    });\n\n    test('should return false for readonly array', () => {\n      const node = getTypeNodeFromSource(\n        'type Test = readonly number[];',\n        'Test',\n      );\n\n      assert.isFalse(isReadonlyTupleTypeNode(node));\n    });\n  });\n}\n\nexport type ReadonlyTypeReferenceNode = tsm.TypeNode &\n  Omit<tsm.TypeReferenceNode, 'getTypeName' | 'getTypeArguments'> &\n  Readonly<{\n    getTypeName: () => Omit<tsm.Identifier, 'getText'> &\n      Readonly<{\n        getText: () => 'Readonly';\n      }>;\n    getTypeArguments: () => readonly [tsm.TypeNode];\n  }>;\n\nexport const isReadonlyTypeReferenceNode = (\n  node: DeepReadonly<tsm.Node>,\n): node is ReadonlyTypeReferenceNode => {\n  if (!node.isKind(tsm.SyntaxKind.TypeReference)) {\n    return false;\n  }\n\n  const typeName = node.getTypeName();\n\n  const typeArguments = node.getTypeArguments();\n\n  return (\n    typeName.isKind(tsm.SyntaxKind.Identifier) &&\n    typeName.getText() === 'Readonly' &&\n    Arr.isArrayOfLength(typeArguments, 1)\n  );\n};\n\nif (import.meta.vitest !== undefined) {\n  describe('isReadonlyTypeReferenceNode', () => {\n    test('should return true for Readonly<T>', () => {\n      const node = getTypeNodeFromSource(\n        'type Test = Readonly<{ x: number }>;',\n        'Test',\n      );\n\n      assert.isTrue(isReadonlyTypeReferenceNode(node));\n\n      if (isReadonlyTypeReferenceNode(node)) {\n        const _typeNameText = node.getTypeName().getText();\n\n        expectType<typeof _typeNameText, 'Readonly'>('=');\n\n        const _typeArguments = node.getTypeArguments();\n\n        expectType<\n          typeof _typeArguments,\n          readonly [tsm.TypeNode<tsm.ts.TypeNode>]\n        >('=');\n      }\n\n      assert.isTrue(node.isKind(tsm.SyntaxKind.TypeReference));\n\n      if (!isReadonlyTypeReferenceNode(node)) {\n        throw new Error('node should be ReadonlyNode');\n      }\n\n      expect(node.getTypeName().getText()).toBe('Readonly');\n\n      expect(node.getTypeArguments()).toHaveLength(1);\n    });\n\n    test('should return false for other type references', () => {\n      const node = getTypeNodeFromSource(\n        'type Test = Partial<{ y: string }>;',\n        'Test',\n      );\n\n      assert.isFalse(isReadonlyTypeReferenceNode(node));\n    });\n\n    test('should return false for Readonly without type arguments', () => {\n      // Note: This is syntactically incorrect TS, but testing the guard\n      const node = getTypeNodeFromSource('type Test = Readonly;', 'Test');\n\n      assert.isFalse(isReadonlyTypeReferenceNode(node));\n    });\n\n    test('should return false for Readonly with multiple type arguments', () => {\n      // Note: This is syntactically incorrect TS, but testing the guard\n      const project = new tsm.Project({ useInMemoryFileSystem: true });\n\n      // Need to create manually as TS parser might reject Readonly<A, B>\n      const sourceFile = project.createSourceFile(\n        'test.ts',\n        'type Test = Readonly<string, number>;',\n      );\n\n      const node = sourceFile.getTypeAliasOrThrow('Test').getTypeNodeOrThrow();\n\n      assert.isFalse(isReadonlyTypeReferenceNode(node));\n    });\n  });\n}\n"],"names":[],"mappings":";;;;MAKa,yBAAA,GAA4B,CAAC,IAAA,KACxC,8BAAA,CAA+B,IAAI,KACnC,2BAAA,CAA4B,IAAI,CAAA,IAChC,gBAAA,CAAiB,IAAI;MAEV,8BAAA,GAAiC,CAC5C,IAAA,KAEA,IAAA,CAAK,OAAO,GAAA,CAAI,UAAA,CAAW,YAAY,CAAA,IACvC,IAAA,CAAK,aAAY,KAAM,GAAA,CAAI,WAAW,eAAA,KACrC,IAAA,CAAK,aAAY,CAAE,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,SAAS,CAAA;AACjD,IAAA,CAAK,WAAA,EAAY,CAAE,MAAA,CAAO,GAAA,CAAI,WAAW,SAAS,CAAA;MASzC,uBAAA,GAA0B,CACrC,IAAA,KAEA,IAAA,CAAK,OAAO,GAAA,CAAI,UAAA,CAAW,YAAY,CAAA,IACvC,IAAA,CAAK,aAAY,KAAM,GAAA,CAAI,WAAW,eAAA,IACtC,IAAA,CAAK,aAAY,CAAE,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,SAAS;MAqEvC,uBAAA,GAA0B,CACrC,IAAA,KAEA,IAAA,CAAK,OAAO,GAAA,CAAI,UAAA,CAAW,YAAY,CAAA,IACvC,IAAA,CAAK,aAAY,KAAM,GAAA,CAAI,WAAW,eAAA,IACtC,IAAA,CAAK,aAAY,CAAE,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,SAAS;AA4D7C,MAAM,2BAAA,GAA8B,CACzC,IAAA,KACsC;AACtC,EAAA,IAAI,CAAC,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,aAAa,CAAA,EAAG;AAC9C,IAAA,OAAO,KAAA;AAAA,EAAA;AAGT,EAAA,MAAM,QAAA,GAAW,KAAK,WAAA,EAAY;AAElC,EAAA,MAAM,aAAA,GAAgB,KAAK,gBAAA,EAAiB;AAE5C,EAAA,OACE,QAAA,CAAS,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,UAAU,CAAA,IACzC,QAAA,CAAS,OAAA,EAAQ,KAAM,UAAA,IACvB,GAAA,CAAI,eAAA,CAAgB,eAAe,CAAC,CAAA;AAExC;;;;"}
+{"version":3,"file":"is-readonly-node.mjs","sources":["../../../src/functions/functions/is-readonly-node.mts"],"sourcesContent":["import { Arr, expectType } from 'ts-data-forge';\nimport * as tsm from 'ts-morph';\nimport { type DeepReadonly } from 'ts-type-forge';\nimport { isAtomicTypeNode } from './is-atomic-type-node.mjs';\n\nexport const isShallowReadonlyTypeNode = (node: tsm.Node): boolean =>\n  isReadonlyTupleOrArrayTypeNode(node) ||\n  isReadonlyTypeReferenceNode(node) ||\n  isAtomicTypeNode(node);\n\nexport const isReadonlyTupleOrArrayTypeNode = (\n  node: DeepReadonly<tsm.Node>,\n): node is ReadonlyArrayTypeNode | ReadonlyTupleTypeNode =>\n  node.isKind(tsm.SyntaxKind.TypeOperator) &&\n  node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword &&\n  (node.getTypeNode().isKind(tsm.SyntaxKind.ArrayType) || // Use optional chaining and isKind\n    node.getTypeNode().isKind(tsm.SyntaxKind.TupleType));\n\nexport type ReadonlyArrayTypeNode = tsm.TypeNode &\n  Omit<tsm.TypeOperatorTypeNode, 'getOperator' | 'getTypeNode'> &\n  Readonly<{\n    getOperator: () => tsm.SyntaxKind.ReadonlyKeyword;\n    getTypeNode: () => tsm.ArrayTypeNode;\n  }>;\n\nexport const isReadonlyArrayTypeNode = (\n  node: DeepReadonly<tsm.Node>,\n): node is ReadonlyArrayTypeNode =>\n  node.isKind(tsm.SyntaxKind.TypeOperator) &&\n  node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword &&\n  node.getTypeNode().isKind(tsm.SyntaxKind.ArrayType);\n\n// Helper to get a specific type node from source code\nconst getTypeNodeFromSource = (\n  sourceCode: string,\n  typeName: string,\n): tsm.Node => {\n  const project = new tsm.Project({ useInMemoryFileSystem: true });\n\n  const sourceFile = project.createSourceFile('test.ts', sourceCode);\n\n  const typeAlias = sourceFile.getTypeAliasOrThrow(typeName);\n\n  return typeAlias.getTypeNodeOrThrow();\n};\n\nif (import.meta.vitest !== undefined) {\n  describe('isReadonlyArrayTypeNode', () => {\n    test('should return true for readonly array type', () => {\n      const node = getTypeNodeFromSource(\n        'type Test = readonly number[];',\n        'Test',\n      );\n\n      if (isReadonlyArrayTypeNode(node)) {\n        const _operator = node.getOperator();\n\n        expectType<typeof _operator, tsm.SyntaxKind.ReadonlyKeyword>('=');\n\n        const _typeNode = node.getTypeNode();\n\n        expectType<typeof _typeNode, tsm.ArrayTypeNode>('=');\n      }\n\n      assert.isTrue(node.isKind(tsm.SyntaxKind.TypeOperator));\n\n      if (!isReadonlyArrayTypeNode(node)) {\n        throw new Error('node should be ReadonlyArrayTypeNode');\n      }\n\n      expect(node.getOperator()).toBe(tsm.SyntaxKind.ReadonlyKeyword);\n\n      assert.isTrue(node.getTypeNode().isKind(tsm.SyntaxKind.ArrayType));\n    });\n\n    test('should return false for non-readonly array', () => {\n      const node = getTypeNodeFromSource('type Test = string[];', 'Test');\n\n      assert.isFalse(isReadonlyArrayTypeNode(node));\n    });\n\n    test('should return false for readonly tuple', () => {\n      const node = getTypeNodeFromSource(\n        'type Test = readonly [string];',\n        'Test',\n      );\n\n      assert.isFalse(isReadonlyArrayTypeNode(node));\n    });\n  });\n}\n\nexport type ReadonlyTupleTypeNode = tsm.TypeNode &\n  Omit<tsm.TypeOperatorTypeNode, 'getOperator' | 'getTypeNode'> &\n  Readonly<{\n    getOperator: () => tsm.SyntaxKind.ReadonlyKeyword;\n    getTypeNode: () => tsm.TupleTypeNode;\n  }>;\n\nexport const isReadonlyTupleTypeNode = (\n  node: DeepReadonly<tsm.Node>,\n): node is ReadonlyTupleTypeNode =>\n  node.isKind(tsm.SyntaxKind.TypeOperator) &&\n  node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword &&\n  node.getTypeNode().isKind(tsm.SyntaxKind.TupleType);\n\nif (import.meta.vitest !== undefined) {\n  describe('isReadonlyTupleTypeNode', () => {\n    test('should return true for readonly tuple type', () => {\n      const node = getTypeNodeFromSource(\n        'type Test = readonly [number, string];',\n        'Test',\n      );\n\n      assert.isTrue(isReadonlyTupleTypeNode(node));\n\n      if (isReadonlyTupleTypeNode(node)) {\n        const _operator = node.getOperator();\n\n        expectType<typeof _operator, tsm.SyntaxKind.ReadonlyKeyword>('=');\n\n        const _typeNode = node.getTypeNode();\n\n        expectType<typeof _typeNode, tsm.TupleTypeNode>('=');\n      }\n\n      assert.isTrue(node.isKind(tsm.SyntaxKind.TypeOperator));\n\n      if (!isReadonlyTupleTypeNode(node)) {\n        throw new Error('node should be ReadonlyTupleTypeNode');\n      }\n\n      expect(node.getOperator()).toBe(tsm.SyntaxKind.ReadonlyKeyword);\n\n      assert.isTrue(node.getTypeNode().isKind(tsm.SyntaxKind.TupleType));\n    });\n\n    test('should return false for non-readonly tuple', () => {\n      const node = getTypeNodeFromSource('type Test = [boolean];', 'Test');\n\n      assert.isFalse(isReadonlyTupleTypeNode(node));\n    });\n\n    test('should return false for readonly array', () => {\n      const node = getTypeNodeFromSource(\n        'type Test = readonly number[];',\n        'Test',\n      );\n\n      assert.isFalse(isReadonlyTupleTypeNode(node));\n    });\n  });\n}\n\nexport type ReadonlyTypeReferenceNode = tsm.TypeNode &\n  Omit<tsm.TypeReferenceNode, 'getTypeName' | 'getTypeArguments'> &\n  Readonly<{\n    getTypeName: () => Omit<tsm.Identifier, 'getText'> &\n      Readonly<{\n        getText: () => 'Readonly';\n      }>;\n    getTypeArguments: () => readonly [tsm.TypeNode];\n  }>;\n\nexport const isReadonlyTypeReferenceNode = (\n  node: DeepReadonly<tsm.Node>,\n): node is ReadonlyTypeReferenceNode => {\n  if (!node.isKind(tsm.SyntaxKind.TypeReference)) {\n    return false;\n  }\n\n  const typeName = node.getTypeName();\n\n  const typeArguments = node.getTypeArguments();\n\n  return (\n    typeName.isKind(tsm.SyntaxKind.Identifier) &&\n    typeName.getText() === 'Readonly' &&\n    Arr.isFixedLengthArray(1, typeArguments)\n  );\n};\n\nif (import.meta.vitest !== undefined) {\n  describe('isReadonlyTypeReferenceNode', () => {\n    test('should return true for Readonly<T>', () => {\n      const node = getTypeNodeFromSource(\n        'type Test = Readonly<{ x: number }>;',\n        'Test',\n      );\n\n      assert.isTrue(isReadonlyTypeReferenceNode(node));\n\n      if (isReadonlyTypeReferenceNode(node)) {\n        const _typeNameText = node.getTypeName().getText();\n\n        expectType<typeof _typeNameText, 'Readonly'>('=');\n\n        const _typeArguments = node.getTypeArguments();\n\n        expectType<\n          typeof _typeArguments,\n          readonly [tsm.TypeNode<tsm.ts.TypeNode>]\n        >('=');\n      }\n\n      assert.isTrue(node.isKind(tsm.SyntaxKind.TypeReference));\n\n      if (!isReadonlyTypeReferenceNode(node)) {\n        throw new Error('node should be ReadonlyNode');\n      }\n\n      expect(node.getTypeName().getText()).toBe('Readonly');\n\n      expect(node.getTypeArguments()).toHaveLength(1);\n    });\n\n    test('should return false for other type references', () => {\n      const node = getTypeNodeFromSource(\n        'type Test = Partial<{ y: string }>;',\n        'Test',\n      );\n\n      assert.isFalse(isReadonlyTypeReferenceNode(node));\n    });\n\n    test('should return false for Readonly without type arguments', () => {\n      // Note: This is syntactically incorrect TS, but testing the guard\n      const node = getTypeNodeFromSource('type Test = Readonly;', 'Test');\n\n      assert.isFalse(isReadonlyTypeReferenceNode(node));\n    });\n\n    test('should return false for Readonly with multiple type arguments', () => {\n      // Note: This is syntactically incorrect TS, but testing the guard\n      const project = new tsm.Project({ useInMemoryFileSystem: true });\n\n      // Need to create manually as TS parser might reject Readonly<A, B>\n      const sourceFile = project.createSourceFile(\n        'test.ts',\n        'type Test = Readonly<string, number>;',\n      );\n\n      const node = sourceFile.getTypeAliasOrThrow('Test').getTypeNodeOrThrow();\n\n      assert.isFalse(isReadonlyTypeReferenceNode(node));\n    });\n  });\n}\n"],"names":[],"mappings":";;;;MAKa,yBAAA,GAA4B,CAAC,IAAA,KACxC,8BAAA,CAA+B,IAAI,KACnC,2BAAA,CAA4B,IAAI,CAAA,IAChC,gBAAA,CAAiB,IAAI;MAEV,8BAAA,GAAiC,CAC5C,IAAA,KAEA,IAAA,CAAK,OAAO,GAAA,CAAI,UAAA,CAAW,YAAY,CAAA,IACvC,IAAA,CAAK,aAAY,KAAM,GAAA,CAAI,WAAW,eAAA,KACrC,IAAA,CAAK,aAAY,CAAE,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,SAAS,CAAA;AACjD,IAAA,CAAK,WAAA,EAAY,CAAE,MAAA,CAAO,GAAA,CAAI,WAAW,SAAS,CAAA;MASzC,uBAAA,GAA0B,CACrC,IAAA,KAEA,IAAA,CAAK,OAAO,GAAA,CAAI,UAAA,CAAW,YAAY,CAAA,IACvC,IAAA,CAAK,aAAY,KAAM,GAAA,CAAI,WAAW,eAAA,IACtC,IAAA,CAAK,aAAY,CAAE,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,SAAS;MAqEvC,uBAAA,GAA0B,CACrC,IAAA,KAEA,IAAA,CAAK,OAAO,GAAA,CAAI,UAAA,CAAW,YAAY,CAAA,IACvC,IAAA,CAAK,aAAY,KAAM,GAAA,CAAI,WAAW,eAAA,IACtC,IAAA,CAAK,aAAY,CAAE,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,SAAS;AA4D7C,MAAM,2BAAA,GAA8B,CACzC,IAAA,KACsC;AACtC,EAAA,IAAI,CAAC,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,aAAa,CAAA,EAAG;AAC9C,IAAA,OAAO,KAAA;AAAA,EAAA;AAGT,EAAA,MAAM,QAAA,GAAW,KAAK,WAAA,EAAY;AAElC,EAAA,MAAM,aAAA,GAAgB,KAAK,gBAAA,EAAiB;AAE5C,EAAA,OACE,QAAA,CAAS,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,UAAU,CAAA,IACzC,QAAA,CAAS,OAAA,EAAQ,KAAM,UAAA,IACvB,GAAA,CAAI,kBAAA,CAAmB,GAAG,aAAa,CAAA;AAE3C;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-codemod-lib",
-  "version": "2.2.2",
+  "version": "2.2.4",
   "private": false,
   "keywords": [
     "typescript",
@@ -24,6 +24,10 @@
       "import": {
         "types": "./dist/types.d.mts",
         "default": "./dist/entry-point.mjs"
+      },
+      "default": {
+        "types": "./dist/types.d.mts",
+        "default": "./dist/entry-point.mjs"
       }
     }
   },
@@ -43,31 +47,33 @@
     "LICENSE"
   ],
   "scripts": {
+    "agents:gen": "tsx ./scripts/cmd/gen-agents-md.mts",
+    "agents:sync": "tsx ./scripts/cmd/sync-agent-config.mts",
     "build": "tsx ./scripts/cmd/build.mts",
     "build:min": "tsx ./scripts/cmd/build.mts --skip-check",
-    "check:ext": "tsx ./scripts/cmd/check-ext.mts",
     "check-all": "tsx ./scripts/cmd/check-all.mts",
+    "check:ext": "tsx ./scripts/cmd/check-ext.mts",
     "clean": "pnpm run /clean:.*/",
     "clean:logs": "npx rimraf ./*.log",
     "codemod": "run-s codemod:uncommitted:* fmt",
     "codemod:diff": "run-s codemod:diff:* fmt",
-    "codemod:diff:as-const": "tsx ./src/cmd/append-as-const.mts --diff-from origin/main '{src,scripts,samples,test}/**/*.{mts,tsx}'",
     "codemod:diff:any-to-unknown": "tsx ./src/cmd/replace-any-with-unknown.mts --diff-from origin/main '{src,scripts,samples,test}/**/*.{mts,tsx}'",
-    "codemod:diff:unknown-record": "tsx ./src/cmd/replace-record-with-unknown-record.mts --diff-from origin/main '{src,scripts,samples,test}/**/*.{mts,tsx}'",
+    "codemod:diff:as-const": "tsx ./src/cmd/append-as-const.mts --diff-from origin/main '{src,scripts,samples,test}/**/*.{mts,tsx}'",
     "codemod:diff:interface-to-type": "tsx ./src/cmd/convert-interface-to-type.mts --diff-from origin/main '{src,scripts,samples,test}/**/*.{mts,tsx}'",
     "codemod:diff:readonly": "tsx ./src/cmd/convert-to-readonly.mts --diff-from origin/main '{src,scripts,samples,test}/**/*.{mts,tsx}'",
+    "codemod:diff:unknown-record": "tsx ./src/cmd/replace-record-with-unknown-record.mts --diff-from origin/main '{src,scripts,samples,test}/**/*.{mts,tsx}'",
     "codemod:full": "run-s codemod:full:* fmt",
-    "codemod:full:as-const": "tsx ./src/cmd/append-as-const.mts '{src,scripts,samples,test}/**/*.{mts,tsx}'",
     "codemod:full:any-to-unknown": "tsx ./src/cmd/replace-any-with-unknown.mts '{src,scripts,samples,test}/**/*.{mts,tsx}'",
-    "codemod:full:unknown-record": "tsx ./src/cmd/replace-record-with-unknown-record.mts '{src,scripts,samples,test}/**/*.{mts,tsx}'",
+    "codemod:full:as-const": "tsx ./src/cmd/append-as-const.mts '{src,scripts,samples,test}/**/*.{mts,tsx}'",
     "codemod:full:interface-to-type": "tsx ./src/cmd/convert-interface-to-type.mts '{src,scripts,samples,test}/**/*.{mts,tsx}'",
     "codemod:full:readonly": "tsx ./src/cmd/convert-to-readonly.mts '{src,scripts,samples,test}/**/*.{mts,tsx}'",
-    "codemod:uncommitted:as-const": "tsx ./src/cmd/append-as-const.mts --uncommitted '{src,scripts,samples,test}/**/*.{mts,tsx}'",
+    "codemod:full:unknown-record": "tsx ./src/cmd/replace-record-with-unknown-record.mts '{src,scripts,samples,test}/**/*.{mts,tsx}'",
     "codemod:uncommitted:any-to-unknown": "tsx ./src/cmd/replace-any-with-unknown.mts --uncommitted '{src,scripts,samples,test}/**/*.{mts,tsx}'",
-    "codemod:uncommitted:unknown-record": "tsx ./src/cmd/replace-record-with-unknown-record.mts --uncommitted '{src,scripts,samples,test}/**/*.{mts,tsx}'",
+    "codemod:uncommitted:as-const": "tsx ./src/cmd/append-as-const.mts --uncommitted '{src,scripts,samples,test}/**/*.{mts,tsx}'",
     "codemod:uncommitted:interface-to-type": "tsx ./src/cmd/convert-interface-to-type.mts --uncommitted '{src,scripts,samples,test}/**/*.{mts,tsx}'",
     "codemod:uncommitted:readonly": "tsx ./src/cmd/convert-to-readonly.mts --uncommitted '{src,scripts,samples,test}/**/*.{mts,tsx}'",
-    "cspell": "cspell \"**\" --gitignore --gitignore-root ./ --no-progress",
+    "codemod:uncommitted:unknown-record": "tsx ./src/cmd/replace-record-with-unknown-record.mts --uncommitted '{src,scripts,samples,test}/**/*.{mts,tsx}'",
+    "cspell": "cspell \"{**,.changeset/**/*,.github/**/*}\" --gitignore --gitignore-root ./ --no-progress",
     "doc": "tsx ./scripts/cmd/gen-docs.mts",
     "doc:embed": "tsx ./scripts/cmd/embed-examples.mts",
     "doc:preview": "vite preview --config ./configs/vite.doc.config.mts",
@@ -75,19 +81,14 @@
     "fmt": "format-uncommitted",
     "fmt:diff": "format-diff-from origin/main",
     "fmt:full": "prettier --write .",
-    "gh:apply-all": "gh-apply-all",
-    "gh:apply-repository-settings": "gh-apply-repository-settings",
-    "gh:apply-rulesets": "gh-apply-rulesets",
-    "gh:apply-variables": "gh-apply-variables",
-    "gh:backup-all": "gh-backup-all",
-    "gh:backup-repository-settings": "gh-backup-repository-settings",
-    "gh:backup-rulesets": "gh-backup-rulesets",
     "gi": "run-s gi:src fmt",
     "gi:src": "gen-index-ts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --exclude entry-point.mts --exclude cmd",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "md": "markdownlint-cli2",
     "prepare-release": "run-s sync-cli-versions fmt build doc",
+    "repo-settings:apply": "repo-settings apply",
+    "repo-settings:backup": "repo-settings backup",
     "run:cmd": "tsx ./src/cmd/convert-to-readonly.mts ./test/sample1.mts",
     "run:test": "tsx ./scripts/test-code/transform-test-code.mts",
     "sync-cli-versions": "tsx scripts/cmd/sync-cli-versions.mts",
@@ -100,56 +101,58 @@
     "tsc": "node ./node_modules/typescript-native/bin/tsc --noEmit",
     "tscw": "node ./node_modules/typescript-native/bin/tsc --noEmit --watch -p ./tsconfig.json",
     "type-check": "node ./node_modules/typescript-native/bin/tsc --noEmit",
-    "update-packages": "pnpm update --latest '!typescript'",
     "z:vitest": "vitest --config ./configs/vitest.config.mts",
     "z:vitest:node": "pnpm run z:vitest --project='Node.js'"
   },
   "dependencies": {
-    "ts-data-forge": "^7.1.1",
+    "ts-data-forge": "^14.0.0",
     "ts-morph": "^28.0.0",
-    "ts-type-forge": "^4.0.0"
+    "ts-type-forge": "^9.1.1"
   },
   "devDependencies": {
     "@rollup/plugin-replace": "6.0.3",
     "@rollup/plugin-strip": "3.0.4",
-    "@semantic-release/changelog": "6.0.3",
+    "@semantic-release/changelog": "7.0.0",
     "@semantic-release/commit-analyzer": "13.0.1",
     "@semantic-release/exec": "7.1.0",
-    "@semantic-release/git": "10.0.1",
-    "@semantic-release/github": "12.0.8",
+    "@semantic-release/git": "11.0.1",
+    "@semantic-release/github": "12.0.9",
     "@semantic-release/npm": "13.1.5",
     "@semantic-release/release-notes-generator": "14.1.1",
-    "@types/node": "26.1.0",
+    "@types/node": "26.1.2",
     "@vitest/browser-playwright": "4.1.10",
     "@vitest/coverage-v8": "4.1.10",
-    "@vitest/ui": "4.1.9",
+    "@vitest/ui": "4.1.10",
     "cmd-ts": "0.15.0",
     "conventional-changelog-conventionalcommits": "10.2.1",
     "cspell": "10.0.1",
     "dedent": "1.7.2",
     "esbuild": "0.28.1",
-    "eslint": "10.6.0",
-    "eslint-config-typed": "5.4.0",
-    "github-settings-as-code": "1.2.9",
+    "eslint": "10.8.0",
+    "eslint-config-typed": "5.8.2",
+    "eslint-plugin-ts-data-forge": "0.3.0",
+    "eslint-plugin-ts-fortress": "0.4.0",
+    "eslint-plugin-ts-type-forge": "0.4.3",
+    "github-settings-as-code": "2.0.1",
     "jiti": "2.7.0",
-    "markdownlint": "0.41.0",
-    "markdownlint-cli2": "0.23.0",
+    "markdownlint": "0.41.1",
+    "markdownlint-cli2": "0.23.2",
     "npm-run-all2": "9.0.2",
-    "playwright": "1.61.1",
-    "prettier": "3.9.4",
+    "playwright": "1.62.0",
+    "prettier": "3.9.6",
     "prettier-plugin-organize-imports": "4.3.0",
     "prettier-plugin-packagejson": "3.0.2",
-    "rollup": "4.62.2",
+    "rollup": "4.62.3",
     "rollup-plugin-esbuild": "6.2.1",
-    "semantic-release": "25.0.5",
-    "ts-repo-utils": "10.1.2",
-    "tsx": "4.23.0",
-    "typedoc": "0.28.19",
+    "semantic-release": "25.0.8",
+    "ts-repo-utils": "10.1.6",
+    "tsx": "4.23.1",
+    "typedoc": "0.28.20",
     "typedoc-github-theme": "0.4.0",
     "typescript": "6.0.3",
-    "typescript-native": "npm:typescript@7.0.1-rc",
-    "vite": "8.1.2",
-    "vitest": "4.1.9"
+    "typescript-native": "npm:typescript@7.0.2",
+    "vite": "8.1.5",
+    "vitest": "4.1.10"
   },
   "peerDependencies": {
     "cmd-ts": "0.14.3",
@@ -167,12 +170,16 @@
       "optional": true
     }
   },
-  "packageManager": "pnpm@11.10.0+sha512.0b7f8b98060031904c017e3a41eb187a16d40eeb829b95c4f8cb03681761fc4ab53dd219115b9b447f4dce1a05a214764461e7d3703392a9f32f9511ce8c86c8",
+  "packageManager": "pnpm@11.20.0",
   "engines": {
     "node": ">=22.22.2",
     "pnpm": ">=9.0.0"
   },
   "volta": {
     "node": "26.3.1"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
   }
 }

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

@@ -9,7 +9,7 @@ const transformer = appendAsConstTransformer();
 
 const cmdDef = cmd.command({
   name: transformer.name,
-  version: '2.2.2',
+  version: '2.2.4',
   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.2.2',
+  version: '2.2.4',
   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.2.2',
+  version: '2.2.4',
   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.2.2',
+  version: '2.2.4',
   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.2.2',
+  version: '2.2.4',
   args: {
     baseDir: cmd.positional({
       type: cmd.string,

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

@@ -51,7 +51,7 @@ export const runTransformerCLI = async (
 
   const files = filesResult.value;
 
-  if (Arr.isArrayOfLength(files, 0)) {
+  if (Arr.isEmpty(files)) {
     echoIfNotSilent(
       options.diffFrom !== undefined
         ? `No files found in diff from "${options.diffFrom}" matching pattern: ${options.baseDir}`

package/src/functions/ast-transformers/append-as-const.mts

@@ -150,7 +150,7 @@ const transformNode = (
 
     if (
       declarationKindKeywords !== undefined &&
-      Arr.isArrayOfLength(declarationKindKeywords, 1)
+      Arr.isFixedLengthArray(1, declarationKindKeywords)
     ) {
       transformNode(
         initializer,

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

@@ -47,18 +47,18 @@ export const convertInterfaceToTypeTransformer = (): TsMorphTransformer =>
 
         // Build type literal from members
         const mut_typeBody: string = (() => {
-          if (Arr.isArrayOfLength(extendsExpressions, 0)) {
+          if (Arr.isEmpty(extendsExpressions)) {
             // No extends: simple type literal
             return buildTypeLiteral(members);
           }
 
-          if (Arr.isArrayOfLength(members, 0)) {
+          if (Arr.isEmpty(members)) {
             // Only extends, no own members: union of extended types
             const extendedTypes = extendsExpressions.map((ext) =>
               ext.getText(),
             );
 
-            return Arr.isArrayOfLength(extendedTypes, 1)
+            return Arr.isFixedLengthArray(1, extendedTypes)
               ? extendedTypes[0]
               : extendedTypes.join(' & ');
           }
@@ -97,7 +97,7 @@ export const convertInterfaceToTypeTransformer = (): TsMorphTransformer =>
       const buildTypeLiteral = (
         members: readonly tsm.TypeElementTypes[],
       ): string => {
-        if (Arr.isArrayOfLength(members, 0)) {
+        if (Arr.isEmpty(members)) {
           return 'Record<string, never>';
         }
 

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

@@ -409,7 +409,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 +442,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 +468,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 +498,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 +592,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.`,
       );
@@ -858,10 +858,7 @@ const transformTypeLiteralNode = (
   >,
   options: ReadonlyTransformerOptionsInternal,
 ): void => {
-  if (
-    options.ignoreEmptyObjectTypes &&
-    Arr.isArrayOfLength(node.getMembers(), 0)
-  ) {
+  if (options.ignoreEmptyObjectTypes && Arr.isEmpty(node.getMembers())) {
     return;
   }
 
@@ -1170,8 +1167,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 +1179,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 +1277,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)

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 (Arr.isEmpty(ignoredTransformers) && !hasFileIgnoreComment) {
     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

@@ -176,7 +176,7 @@ export const isReadonlyTypeReferenceNode = (
   return (
     typeName.isKind(tsm.SyntaxKind.Identifier) &&
     typeName.getText() === 'Readonly' &&
-    Arr.isArrayOfLength(typeArguments, 1)
+    Arr.isFixedLengthArray(1, typeArguments)
   );
 };