ts-codemod-lib 2.2.3 → 2.2.5

package/dist/functions/ast-transformers/transform-source-code.mjs

@@ -41,10 +41,10 @@ const shouldSkipFile = (code, transformerName) => {
     /\/\*\s*transform-ignore\s*.*?\s*\*\//u
   ];
   const hasFileIgnoreComment = patterns.some((regex) => regex.test(code));
-  if (Arr.isArrayOfLength(ignoredTransformers, 0) && !hasFileIgnoreComment) {
+  if (!hasFileIgnoreComment && Arr.isEmpty(ignoredTransformers)) {
     return false;
   }
-  if (Arr.isArrayOfLength(ignoredTransformers, 0)) {
+  if (Arr.isEmpty(ignoredTransformers)) {
     return true;
   }
   if (transformerName === void 0) {

package/dist/functions/ast-transformers/transform-source-code.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"transform-source-code.mjs","sources":["../../../src/functions/ast-transformers/transform-source-code.mts"],"sourcesContent":["import { Arr } from 'ts-data-forge';\nimport * as tsm from 'ts-morph';\nimport { type TsMorphTransformer } from './types.mjs';\n\nconst extractFileIgnoreTransformers = (code: string): readonly string[] => {\n  // Try to find any of the supported file-level ignore comment prefixes\n  const patterns = [\n    {\n      prefix: 'transformer-ignore',\n      regex: /\\/\\*\\s*transformer-ignore\\s*(.*?)\\s*\\*\\//u,\n    },\n    {\n      prefix: 'ts-codemod-ignore',\n      regex: /\\/\\*\\s*ts-codemod-ignore\\s*(.*?)\\s*\\*\\//u,\n    },\n    {\n      prefix: 'codemod-ignore',\n      regex: /\\/\\*\\s*codemod-ignore\\s*(.*?)\\s*\\*\\//u,\n    },\n    {\n      prefix: 'transform-ignore',\n      regex: /\\/\\*\\s*transform-ignore\\s*(.*?)\\s*\\*\\//u,\n    },\n  ] as const;\n\n  for (const { regex } of patterns) {\n    const match = regex.exec(code);\n\n    if (match !== null) {\n      const targetTransformers = match[1]?.trim() ?? '';\n\n      // Empty means ignore all transformers\n      if (targetTransformers === '') {\n        return [];\n      }\n\n      // Parse comma-separated transformer names\n      return targetTransformers.split(',').map((name) => name.trim());\n    }\n  }\n\n  return [];\n};\n\nconst shouldSkipFile = (\n  code: string,\n  transformerName: string | undefined,\n): boolean => {\n  const ignoredTransformers = extractFileIgnoreTransformers(code);\n\n  // If no file-level ignore comment found, don't skip\n  const patterns = [\n    /\\/\\*\\s*transformer-ignore\\s*.*?\\s*\\*\\//u,\n    /\\/\\*\\s*ts-codemod-ignore\\s*.*?\\s*\\*\\//u,\n    /\\/\\*\\s*codemod-ignore\\s*.*?\\s*\\*\\//u,\n    /\\/\\*\\s*transform-ignore\\s*.*?\\s*\\*\\//u,\n  ] as const;\n\n  const hasFileIgnoreComment = patterns.some((regex) => regex.test(code));\n\n  if (Arr.isArrayOfLength(ignoredTransformers, 0) && !hasFileIgnoreComment) {\n    return false;\n  }\n\n  // Empty array means ignore all transformers (file-level ignore without specific transformers)\n  if (Arr.isArrayOfLength(ignoredTransformers, 0)) {\n    return true;\n  }\n\n  // If transformer name is not specified, don't skip\n  if (transformerName === undefined) {\n    return false;\n  }\n\n  // Check if the transformer is in the ignore list\n  return ignoredTransformers.includes(transformerName);\n};\n\nexport const transformSourceCode = (\n  code: string,\n  isTsx: boolean,\n  transformers: readonly TsMorphTransformer[],\n  debug: boolean = false,\n): string => {\n  const project = new tsm.Project({\n    useInMemoryFileSystem: true,\n    compilerOptions: {\n      jsx: isTsx ? tsm.ts.JsxEmit.React : undefined,\n      target: tsm.ts.ScriptTarget.ESNext,\n      module: tsm.ts.ModuleKind.ESNext,\n    },\n  });\n\n  const sourceAst = project.createSourceFile(\n    `source.${isTsx ? 'tsx' : 'ts'}`,\n    code,\n  );\n\n  for (const transformer of transformers) {\n    const transformerName = transformer.name;\n\n    if (shouldSkipFile(code, transformerName)) {\n      if (debug) {\n        console.debug(\n          `skipped by ignore-file comment for transformer: ${transformerName}`,\n        );\n      }\n\n      continue;\n    }\n\n    transformer.transform(sourceAst);\n  }\n\n  return sourceAst.getFullText();\n};\n"],"names":[],"mappings":";;;AAIA,MAAM,6BAAA,GAAgC,CAAC,IAAA,KAAoC;AAEzE,EAAA,MAAM,QAAA,GAAW;AAAA,IACf;AAAA,MACE,MAAA,EAAQ,oBAAA;AAAA,MACR,KAAA,EAAO;AAAA,KACT;AAAA,IACA;AAAA,MACE,MAAA,EAAQ,mBAAA;AAAA,MACR,KAAA,EAAO;AAAA,KACT;AAAA,IACA;AAAA,MACE,MAAA,EAAQ,gBAAA;AAAA,MACR,KAAA,EAAO;AAAA,KACT;AAAA,IACA;AAAA,MACE,MAAA,EAAQ,kBAAA;AAAA,MACR,KAAA,EAAO;AAAA;AACT,GACF;AAEA,EAAA,KAAA,MAAW,EAAE,KAAA,EAAM,IAAK,QAAA,EAAU;AAChC,IAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,IAAA,CAAK,IAAI,CAAA;AAE7B,IAAA,IAAI,UAAU,IAAA,EAAM;AAClB,MAAA,MAAM,kBAAA,GAAqB,KAAA,CAAM,CAAC,CAAA,EAAG,MAAK,IAAK,EAAA;AAG/C,MAAA,IAAI,uBAAuB,EAAA,EAAI;AAC7B,QAAA,OAAO,EAAC;AAAA,MACV;AAGA,MAAA,OAAO,kBAAA,CAAmB,MAAM,GAAG,CAAA,CAAE,IAAI,CAAC,IAAA,KAAS,IAAA,CAAK,IAAA,EAAM,CAAA;AAAA,IAChE;AAAA,EACF;AAEA,EAAA,OAAO,EAAC;AACV,CAAA;AAEA,MAAM,cAAA,GAAiB,CACrB,IAAA,EACA,eAAA,KACY;AACZ,EAAA,MAAM,mBAAA,GAAsB,8BAA8B,IAAI,CAAA;AAG9D,EAAA,MAAM,QAAA,GAAW;AAAA,IACf,yCAAA;AAAA,IACA,wCAAA;AAAA,IACA,qCAAA;AAAA,IACA;AAAA,GACF;AAEA,EAAA,MAAM,oBAAA,GAAuB,SAAS,IAAA,CAAK,CAAC,UAAU,KAAA,CAAM,IAAA,CAAK,IAAI,CAAC,CAAA;AAEtE,EAAA,IAAI,IAAI,eAAA,CAAgB,mBAAA,EAAqB,CAAC,CAAA,IAAK,CAAC,oBAAA,EAAsB;AACxE,IAAA,OAAO,KAAA;AAAA,EACT;AAGA,EAAA,IAAI,GAAA,CAAI,eAAA,CAAgB,mBAAA,EAAqB,CAAC,CAAA,EAAG;AAC/C,IAAA,OAAO,IAAA;AAAA,EACT;AAGA,EAAA,IAAI,oBAAoB,MAAA,EAAW;AACjC,IAAA,OAAO,KAAA;AAAA,EACT;AAGA,EAAA,OAAO,mBAAA,CAAoB,SAAS,eAAe,CAAA;AACrD,CAAA;AAEO,MAAM,sBAAsB,CACjC,IAAA,EACA,KAAA,EACA,YAAA,EACA,QAAiB,KAAA,KACN;AACX,EAAA,MAAM,OAAA,GAAU,IAAI,GAAA,CAAI,OAAA,CAAQ;AAAA,IAC9B,qBAAA,EAAuB,IAAA;AAAA,IACvB,eAAA,EAAiB;AAAA,MACf,GAAA,EAAK,KAAA,GAAQ,GAAA,CAAI,EAAA,CAAG,QAAQ,KAAA,GAAQ,MAAA;AAAA,MACpC,MAAA,EAAQ,GAAA,CAAI,EAAA,CAAG,YAAA,CAAa,MAAA;AAAA,MAC5B,MAAA,EAAQ,GAAA,CAAI,EAAA,CAAG,UAAA,CAAW;AAAA;AAC5B,GACD,CAAA;AAED,EAAA,MAAM,YAAY,OAAA,CAAQ,gBAAA;AAAA,IACxB,CAAA,OAAA,EAAU,KAAA,GAAQ,KAAA,GAAQ,IAAI,CAAA,CAAA;AAAA,IAC9B;AAAA,GACF;AAEA,EAAA,KAAA,MAAW,eAAe,YAAA,EAAc;AACtC,IAAA,MAAM,kBAAkB,WAAA,CAAY,IAAA;AAEpC,IAAA,IAAI,cAAA,CAAe,IAAA,EAAM,eAAe,CAAA,EAAG;AACzC,MAAA,IAAI,KAAA,EAAO;AACT,QAAA,OAAA,CAAQ,KAAA;AAAA,UACN,mDAAmD,eAAe,CAAA;AAAA,SACpE;AAAA,MACF;AAEA,MAAA;AAAA,IACF;AAEA,IAAA,WAAA,CAAY,UAAU,SAAS,CAAA;AAAA,EACjC;AAEA,EAAA,OAAO,UAAU,WAAA,EAAY;AAC/B;;;;"}
+{"version":3,"file":"transform-source-code.mjs","sources":["../../../src/functions/ast-transformers/transform-source-code.mts"],"sourcesContent":["import { Arr } from 'ts-data-forge';\nimport * as tsm from 'ts-morph';\nimport { type TsMorphTransformer } from './types.mjs';\n\nconst extractFileIgnoreTransformers = (code: string): readonly string[] => {\n  // Try to find any of the supported file-level ignore comment prefixes\n  const patterns = [\n    {\n      prefix: 'transformer-ignore',\n      regex: /\\/\\*\\s*transformer-ignore\\s*(.*?)\\s*\\*\\//u,\n    },\n    {\n      prefix: 'ts-codemod-ignore',\n      regex: /\\/\\*\\s*ts-codemod-ignore\\s*(.*?)\\s*\\*\\//u,\n    },\n    {\n      prefix: 'codemod-ignore',\n      regex: /\\/\\*\\s*codemod-ignore\\s*(.*?)\\s*\\*\\//u,\n    },\n    {\n      prefix: 'transform-ignore',\n      regex: /\\/\\*\\s*transform-ignore\\s*(.*?)\\s*\\*\\//u,\n    },\n  ] as const;\n\n  for (const { regex } of patterns) {\n    const match = regex.exec(code);\n\n    if (match !== null) {\n      const targetTransformers = match[1]?.trim() ?? '';\n\n      // Empty means ignore all transformers\n      if (targetTransformers === '') {\n        return [];\n      }\n\n      // Parse comma-separated transformer names\n      return targetTransformers.split(',').map((name) => name.trim());\n    }\n  }\n\n  return [];\n};\n\nconst shouldSkipFile = (\n  code: string,\n  transformerName: string | undefined,\n): boolean => {\n  const ignoredTransformers = extractFileIgnoreTransformers(code);\n\n  // If no file-level ignore comment found, don't skip\n  const patterns = [\n    /\\/\\*\\s*transformer-ignore\\s*.*?\\s*\\*\\//u,\n    /\\/\\*\\s*ts-codemod-ignore\\s*.*?\\s*\\*\\//u,\n    /\\/\\*\\s*codemod-ignore\\s*.*?\\s*\\*\\//u,\n    /\\/\\*\\s*transform-ignore\\s*.*?\\s*\\*\\//u,\n  ] as const;\n\n  const hasFileIgnoreComment = patterns.some((regex) => regex.test(code));\n\n  if (!hasFileIgnoreComment && Arr.isEmpty(ignoredTransformers)) {\n    return false;\n  }\n\n  // Empty array means ignore all transformers (file-level ignore without specific transformers)\n  if (Arr.isEmpty(ignoredTransformers)) {\n    return true;\n  }\n\n  // If transformer name is not specified, don't skip\n  if (transformerName === undefined) {\n    return false;\n  }\n\n  // Check if the transformer is in the ignore list\n  return ignoredTransformers.includes(transformerName);\n};\n\nexport const transformSourceCode = (\n  code: string,\n  isTsx: boolean,\n  transformers: readonly TsMorphTransformer[],\n  debug: boolean = false,\n): string => {\n  const project = new tsm.Project({\n    useInMemoryFileSystem: true,\n    compilerOptions: {\n      jsx: isTsx ? tsm.ts.JsxEmit.React : undefined,\n      target: tsm.ts.ScriptTarget.ESNext,\n      module: tsm.ts.ModuleKind.ESNext,\n    },\n  });\n\n  const sourceAst = project.createSourceFile(\n    `source.${isTsx ? 'tsx' : 'ts'}`,\n    code,\n  );\n\n  for (const transformer of transformers) {\n    const transformerName = transformer.name;\n\n    if (shouldSkipFile(code, transformerName)) {\n      if (debug) {\n        console.debug(\n          `skipped by ignore-file comment for transformer: ${transformerName}`,\n        );\n      }\n\n      continue;\n    }\n\n    transformer.transform(sourceAst);\n  }\n\n  return sourceAst.getFullText();\n};\n"],"names":[],"mappings":"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"}

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.d.mts

@@ -1,19 +1,19 @@
 import * as tsm from 'ts-morph';
-import { type DeepReadonly } from 'ts-type-forge';
+import { type DeepReadonly, type StrictOmit } from 'ts-type-forge';
 export declare const isShallowReadonlyTypeNode: (node: tsm.Node) => boolean;
 export declare const isReadonlyTupleOrArrayTypeNode: (node: DeepReadonly<tsm.Node>) => node is ReadonlyArrayTypeNode | ReadonlyTupleTypeNode;
-export type ReadonlyArrayTypeNode = tsm.TypeNode & Omit<tsm.TypeOperatorTypeNode, 'getOperator' | 'getTypeNode'> & Readonly<{
+export type ReadonlyArrayTypeNode = tsm.TypeNode & StrictOmit<tsm.TypeOperatorTypeNode, 'getOperator' | 'getTypeNode'> & Readonly<{
     getOperator: () => tsm.SyntaxKind.ReadonlyKeyword;
     getTypeNode: () => tsm.ArrayTypeNode;
 }>;
 export declare const isReadonlyArrayTypeNode: (node: DeepReadonly<tsm.Node>) => node is ReadonlyArrayTypeNode;
-export type ReadonlyTupleTypeNode = tsm.TypeNode & Omit<tsm.TypeOperatorTypeNode, 'getOperator' | 'getTypeNode'> & Readonly<{
+export type ReadonlyTupleTypeNode = tsm.TypeNode & StrictOmit<tsm.TypeOperatorTypeNode, 'getOperator' | 'getTypeNode'> & Readonly<{
     getOperator: () => tsm.SyntaxKind.ReadonlyKeyword;
     getTypeNode: () => tsm.TupleTypeNode;
 }>;
 export declare const isReadonlyTupleTypeNode: (node: DeepReadonly<tsm.Node>) => node is ReadonlyTupleTypeNode;
-export type ReadonlyTypeReferenceNode = tsm.TypeNode & Omit<tsm.TypeReferenceNode, 'getTypeName' | 'getTypeArguments'> & Readonly<{
-    getTypeName: () => Omit<tsm.Identifier, 'getText'> & Readonly<{
+export type ReadonlyTypeReferenceNode = tsm.TypeNode & StrictOmit<tsm.TypeReferenceNode, 'getTypeName' | 'getTypeArguments'> & Readonly<{
+    getTypeName: () => StrictOmit<tsm.Identifier, 'getText'> & Readonly<{
         getText: () => 'Readonly';
     }>;
     getTypeArguments: () => readonly [tsm.TypeNode];

package/dist/functions/functions/is-readonly-node.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"is-readonly-node.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/is-readonly-node.mts"],"names":[],"mappings":"AACA,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAChC,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAGlD,eAAO,MAAM,yBAAyB,SAAU,GAAG,CAAC,IAAI,KAAG,OAGnC,CAAC;AAEzB,eAAO,MAAM,8BAA8B,SACnC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,KAC3B,IAAI,IAAI,qBAAqB,GAAG,qBAIqB,CAAC;AAEzD,MAAM,MAAM,qBAAqB,GAAG,GAAG,CAAC,QAAQ,GAC9C,IAAI,CAAC,GAAG,CAAC,oBAAoB,EAAE,aAAa,GAAG,aAAa,CAAC,GAC7D,QAAQ,CAAC;IACP,WAAW,EAAE,MAAM,GAAG,CAAC,UAAU,CAAC,eAAe,CAAC;IAClD,WAAW,EAAE,MAAM,GAAG,CAAC,aAAa,CAAC;CACtC,CAAC,CAAC;AAEL,eAAO,MAAM,uBAAuB,SAC5B,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,KAC3B,IAAI,IAAI,qBAG0C,CAAC;AA8DtD,MAAM,MAAM,qBAAqB,GAAG,GAAG,CAAC,QAAQ,GAC9C,IAAI,CAAC,GAAG,CAAC,oBAAoB,EAAE,aAAa,GAAG,aAAa,CAAC,GAC7D,QAAQ,CAAC;IACP,WAAW,EAAE,MAAM,GAAG,CAAC,UAAU,CAAC,eAAe,CAAC;IAClD,WAAW,EAAE,MAAM,GAAG,CAAC,aAAa,CAAC;CACtC,CAAC,CAAC;AAEL,eAAO,MAAM,uBAAuB,SAC5B,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,KAC3B,IAAI,IAAI,qBAG0C,CAAC;AAkDtD,MAAM,MAAM,yBAAyB,GAAG,GAAG,CAAC,QAAQ,GAClD,IAAI,CAAC,GAAG,CAAC,iBAAiB,EAAE,aAAa,GAAG,kBAAkB,CAAC,GAC/D,QAAQ,CAAC;IACP,WAAW,EAAE,MAAM,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,SAAS,CAAC,GAChD,QAAQ,CAAC;QACP,OAAO,EAAE,MAAM,UAAU,CAAC;KAC3B,CAAC,CAAC;IACL,gBAAgB,EAAE,MAAM,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;CACjD,CAAC,CAAC;AAEL,eAAO,MAAM,2BAA2B,SAChC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,KAC3B,IAAI,IAAI,yBAcV,CAAC"}
+{"version":3,"file":"is-readonly-node.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/is-readonly-node.mts"],"names":[],"mappings":"AACA,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAChC,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAGnE,eAAO,MAAM,yBAAyB,SAAU,GAAG,CAAC,IAAI,KAAG,OAGnC,CAAC;AAEzB,eAAO,MAAM,8BAA8B,SACnC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,KAC3B,IAAI,IAAI,qBAAqB,GAAG,qBAIqB,CAAC;AAEzD,MAAM,MAAM,qBAAqB,GAAG,GAAG,CAAC,QAAQ,GAC9C,UAAU,CAAC,GAAG,CAAC,oBAAoB,EAAE,aAAa,GAAG,aAAa,CAAC,GACnE,QAAQ,CAAC;IACP,WAAW,EAAE,MAAM,GAAG,CAAC,UAAU,CAAC,eAAe,CAAC;IAClD,WAAW,EAAE,MAAM,GAAG,CAAC,aAAa,CAAC;CACtC,CAAC,CAAC;AAEL,eAAO,MAAM,uBAAuB,SAC5B,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,KAC3B,IAAI,IAAI,qBAG0C,CAAC;AA8DtD,MAAM,MAAM,qBAAqB,GAAG,GAAG,CAAC,QAAQ,GAC9C,UAAU,CAAC,GAAG,CAAC,oBAAoB,EAAE,aAAa,GAAG,aAAa,CAAC,GACnE,QAAQ,CAAC;IACP,WAAW,EAAE,MAAM,GAAG,CAAC,UAAU,CAAC,eAAe,CAAC;IAClD,WAAW,EAAE,MAAM,GAAG,CAAC,aAAa,CAAC;CACtC,CAAC,CAAC;AAEL,eAAO,MAAM,uBAAuB,SAC5B,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,KAC3B,IAAI,IAAI,qBAG0C,CAAC;AAkDtD,MAAM,MAAM,yBAAyB,GAAG,GAAG,CAAC,QAAQ,GAClD,UAAU,CAAC,GAAG,CAAC,iBAAiB,EAAE,aAAa,GAAG,kBAAkB,CAAC,GACrE,QAAQ,CAAC;IACP,WAAW,EAAE,MAAM,UAAU,CAAC,GAAG,CAAC,UAAU,EAAE,SAAS,CAAC,GACtD,QAAQ,CAAC;QACP,OAAO,EAAE,MAAM,UAAU,CAAC;KAC3B,CAAC,CAAC;IACL,gBAAgB,EAAE,MAAM,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;CACjD,CAAC,CAAC;AAEL,eAAO,MAAM,2BAA2B,SAChC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,KAC3B,IAAI,IAAI,yBAcV,CAAC"}

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, type StrictOmit } 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  StrictOmit<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  StrictOmit<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  StrictOmit<tsm.TypeReferenceNode, 'getTypeName' | 'getTypeArguments'> &\n  Readonly<{\n    getTypeName: () => StrictOmit<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/dist/functions/functions/should-avoid-parentheses-for-readonly.d.mts.map

@@ -1 +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,SAAU,GAAG,CAAC,IAAI,KAAG,OAgBlE,CAAC"}
+{"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,SAAU,GAAG,CAAC,IAAI,KAAG,OAYlE,CAAC"}

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

@@ -5,10 +5,7 @@ const shouldAvoidParenthesesForReadonly = (node) => {
   if (parent === void 0) {
     return false;
   }
-  if (parent.isKind(tsm.SyntaxKind.TypePredicate)) {
-    return true;
-  }
-  return false;
+  return parent.isKind(tsm.SyntaxKind.TypePredicate);
 };
 
 export { shouldAvoidParenthesesForReadonly };

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

@@ -1 +1 @@
-{"version":3,"file":"should-avoid-parentheses-for-readonly.mjs","sources":["../../../src/functions/functions/should-avoid-parentheses-for-readonly.mts"],"sourcesContent":["import * as tsm from 'ts-morph';\n\n/**\n * Determines if parentheses should be avoided when adding 'readonly' prefix to a type.\n *\n * Parentheses should be AVOIDED in these specific contexts:\n * - Type predicates: `x is [T, U]` -> `x is readonly [T, U]` (not `x is (readonly [T, U])`)\n *   because parentheses around the type in a type predicate cause syntax errors\n *\n * For all other contexts, we keep parentheses for safety to avoid precedence issues,\n * relying on prettier to remove unnecessary ones.\n *\n * @param node - The type node to check\n * @returns true if parentheses should be avoided, false otherwise (keep parentheses)\n */\nexport const shouldAvoidParenthesesForReadonly = (node: tsm.Node): boolean => {\n  const parent = node.getParent();\n\n  if (parent === undefined) {\n    return false;\n  }\n\n  // Check if parent is TypePredicate: x is T\n  // In this case, we MUST avoid parentheses: x is readonly T (not x is (readonly T))\n  // because `x is (readonly T)` is a syntax error\n  if (parent.isKind(tsm.SyntaxKind.TypePredicate)) {\n    return true;\n  }\n\n  // For all other cases, keep parentheses for safety\n  return false;\n};\n"],"names":[],"mappings":";;AAeO,MAAM,iCAAA,GAAoC,CAAC,IAAA,KAA4B;AAC5E,EAAA,MAAM,MAAA,GAAS,KAAK,SAAA,EAAU;AAE9B,EAAA,IAAI,WAAW,MAAA,EAAW;AACxB,IAAA,OAAO,KAAA;AAAA,EACT;AAKA,EAAA,IAAI,MAAA,CAAO,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,aAAa,CAAA,EAAG;AAC/C,IAAA,OAAO,IAAA;AAAA,EACT;AAGA,EAAA,OAAO,KAAA;AACT;;;;"}
+{"version":3,"file":"should-avoid-parentheses-for-readonly.mjs","sources":["../../../src/functions/functions/should-avoid-parentheses-for-readonly.mts"],"sourcesContent":["import * as tsm from 'ts-morph';\n\n/**\n * Determines if parentheses should be avoided when adding 'readonly' prefix to a type.\n *\n * Parentheses should be AVOIDED in these specific contexts:\n * - Type predicates: `x is [T, U]` -> `x is readonly [T, U]` (not `x is (readonly [T, U])`)\n *   because parentheses around the type in a type predicate cause syntax errors\n *\n * For all other contexts, we keep parentheses for safety to avoid precedence issues,\n * relying on prettier to remove unnecessary ones.\n *\n * @param node - The type node to check\n * @returns true if parentheses should be avoided, false otherwise (keep parentheses)\n */\nexport const shouldAvoidParenthesesForReadonly = (node: tsm.Node): boolean => {\n  const parent = node.getParent();\n\n  if (parent === undefined) {\n    return false;\n  }\n\n  // Check if parent is TypePredicate: x is T\n  // In this case, we MUST avoid parentheses: x is readonly T (not x is (readonly T))\n  // because `x is (readonly T)` is a syntax error\n  // For all other cases, keep parentheses for safety\n  return parent.isKind(tsm.SyntaxKind.TypePredicate);\n};\n"],"names":[],"mappings":";;AAeO,MAAM,iCAAA,GAAoC,CAAC,IAAA,KAA4B;AAC5E,EAAA,MAAM,MAAA,GAAS,KAAK,SAAA,EAAU;AAE9B,EAAA,IAAI,WAAW,MAAA,EAAW;AACxB,IAAA,OAAO,KAAA;AAAA,EACT;AAMA,EAAA,OAAO,MAAA,CAAO,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,aAAa,CAAA;AACnD;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-codemod-lib",
-  "version": "2.2.3",
+  "version": "2.2.5",
   "private": false,
   "keywords": [
     "typescript",
@@ -51,29 +51,29 @@
     "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",
@@ -81,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",
@@ -106,55 +101,57 @@
     "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.1.0",
     "ts-morph": "^28.0.0",
-    "ts-type-forge": "^4.0.0"
+    "ts-type-forge": "^9.1.3"
   },
   "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.2.0",
     "@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.4",
+    "eslint-plugin-ts-data-forge": "0.4.2",
+    "eslint-plugin-ts-fortress": "1.0.0",
+    "eslint-plugin-ts-type-forge": "0.6.1",
+    "github-settings-as-code": "2.1.0",
     "jiti": "2.7.0",
-    "markdownlint": "0.41.0",
-    "markdownlint-cli2": "0.23.0",
-    "npm-run-all2": "9.0.2",
-    "playwright": "1.61.1",
-    "prettier": "3.9.4",
+    "markdownlint": "0.41.1",
+    "markdownlint-cli2": "0.23.2",
+    "npm-run-all2": "9.0.3",
+    "playwright": "1.62.1",
+    "prettier": "3.9.6",
     "prettier-plugin-organize-imports": "4.3.0",
     "prettier-plugin-packagejson": "3.0.2",
-    "rollup": "4.62.2",
+    "rollup": "4.62.4",
     "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.7",
+    "tsx": "4.23.4",
+    "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.3",
+    "typescript-native": "npm:typescript@7.0.2",
+    "vite": "8.2.0",
     "vitest": "4.1.10"
   },
   "peerDependencies": {
@@ -173,7 +170,7 @@
       "optional": true
     }
   },
-  "packageManager": "pnpm@11.10.0+sha512.0b7f8b98060031904c017e3a41eb187a16d40eeb829b95c4f8cb03681761fc4ab53dd219115b9b447f4dce1a05a214764461e7d3703392a9f32f9511ce8c86c8",
+  "packageManager": "pnpm@11.20.0",
   "engines": {
     "node": ">=22.22.2",
     "pnpm": ">=9.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.2.3',
+  version: '2.2.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.2.3',
+  version: '2.2.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.2.3',
+  version: '2.2.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.2.3',
+  version: '2.2.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.2.3',
+  version: '2.2.5',
   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>';
         }