ts-codemod-lib 2.2.1 → 2.2.2

package/dist/functions/functions/is-conditional-type-distribution-guard.mjs

@@ -1,39 +1,15 @@
 import * as tsm from 'ts-morph';
 
-/**
- * Determines whether a type node is an operand (check or extends type) of a
- * conditional type whose check type is wrapped to suppress union distribution,
- * i.e. the `X` and `Y` in `X extends Y ? ... : ...` where `X` is itself a tuple
- * or array.
- *
- * Wrapping a naked type parameter so that it is no longer naked is a well-known
- * type-implementation idiom used to suppress union distribution. Both
- * `[A] extends [B] ? ...` (tuple wrapping) and `A[] extends B[] ? ...` (array
- * wrapping) rely on this. Adding a `readonly` modifier to those operands neither
- * makes the type more immutable in any meaningful way nor preserves the idiom's
- * intent, so such operands must be left untouched.
- *
- * A naked check type such as `T extends string[] ? ...` still distributes, so it
- * is not a guard; arrays/tuples in its extends position are converted as usual.
- *
- * @param node - The type node to check
- * @returns true if the node is the check or extends type of a distribution-guarded
- *   conditional type
- */
 const isConditionalTypeDistributionGuard = (node) => {
-    const parent = node.getParent();
-    if (parent?.isKind(tsm.SyntaxKind.ConditionalType) !== true) {
-        return false;
-    }
-    const checkType = parent.getCheckType();
-    // The guard is only in effect when the check type itself is wrapped in a tuple
-    // or array; otherwise (e.g. a naked `T`) the conditional still distributes.
-    if (!checkType.isKind(tsm.SyntaxKind.TupleType) &&
-        !checkType.isKind(tsm.SyntaxKind.ArrayType)) {
-        return false;
-    }
-    return (checkType.compilerNode === node.compilerNode ||
-        parent.getExtendsType().compilerNode === node.compilerNode);
+  const parent = node.getParent();
+  if (parent?.isKind(tsm.SyntaxKind.ConditionalType) !== true) {
+    return false;
+  }
+  const checkType = parent.getCheckType();
+  if (!checkType.isKind(tsm.SyntaxKind.TupleType) && !checkType.isKind(tsm.SyntaxKind.ArrayType)) {
+    return false;
+  }
+  return checkType.compilerNode === node.compilerNode || parent.getExtendsType().compilerNode === node.compilerNode;
 };
 
 export { isConditionalTypeDistributionGuard };

package/dist/functions/functions/is-conditional-type-distribution-guard.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-conditional-type-distribution-guard.mjs","sources":["../../../src/functions/functions/is-conditional-type-distribution-guard.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,kCAAkC,GAAG,CAAC,IAAc,KAAa;AAC5E,IAAA,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE;AAE/B,IAAA,IAAI,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,eAAe,CAAC,KAAK,IAAI,EAAE;AAC3D,QAAA,OAAO,KAAK;IACd;AAEA,IAAA,MAAM,SAAS,GAAG,MAAM,CAAC,YAAY,EAAE;;;IAIvC,IACE,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC;QAC3C,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,EAC3C;AACA,QAAA,OAAO,KAAK;IACd;AAEA,IAAA,QACE,SAAS,CAAC,YAAY,KAAK,IAAI,CAAC,YAAY;QAC5C,MAAM,CAAC,cAAc,EAAE,CAAC,YAAY,KAAK,IAAI,CAAC,YAAY;AAE9D;;;;"}
+{"version":3,"file":"is-conditional-type-distribution-guard.mjs","sources":["../../../src/functions/functions/is-conditional-type-distribution-guard.mts"],"sourcesContent":["import * as tsm from 'ts-morph';\n\n/**\n * Determines whether a type node is an operand (check or extends type) of a\n * conditional type whose check type is wrapped to suppress union distribution,\n * i.e. the `X` and `Y` in `X extends Y ? ... : ...` where `X` is itself a tuple\n * or array.\n *\n * Wrapping a naked type parameter so that it is no longer naked is a well-known\n * type-implementation idiom used to suppress union distribution. Both\n * `[A] extends [B] ? ...` (tuple wrapping) and `A[] extends B[] ? ...` (array\n * wrapping) rely on this. Adding a `readonly` modifier to those operands neither\n * makes the type more immutable in any meaningful way nor preserves the idiom's\n * intent, so such operands must be left untouched.\n *\n * A naked check type such as `T extends string[] ? ...` still distributes, so it\n * is not a guard; arrays/tuples in its extends position are converted as usual.\n *\n * @param node - The type node to check\n * @returns true if the node is the check or extends type of a distribution-guarded\n *   conditional type\n */\nexport const isConditionalTypeDistributionGuard = (node: tsm.Node): boolean => {\n  const parent = node.getParent();\n\n  if (parent?.isKind(tsm.SyntaxKind.ConditionalType) !== true) {\n    return false;\n  }\n\n  const checkType = parent.getCheckType();\n\n  // The guard is only in effect when the check type itself is wrapped in a tuple\n  // or array; otherwise (e.g. a naked `T`) the conditional still distributes.\n  if (\n    !checkType.isKind(tsm.SyntaxKind.TupleType) &&\n    !checkType.isKind(tsm.SyntaxKind.ArrayType)\n  ) {\n    return false;\n  }\n\n  return (\n    checkType.compilerNode === node.compilerNode ||\n    parent.getExtendsType().compilerNode === node.compilerNode\n  );\n};\n"],"names":[],"mappings":";;AAsBO,MAAM,kCAAA,GAAqC,CAAC,IAAA,KAA4B;AAC7E,EAAA,MAAM,MAAA,GAAS,KAAK,SAAA,EAAU;AAE9B,EAAA,IAAI,QAAQ,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,eAAe,MAAM,IAAA,EAAM;AAC3D,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,MAAM,SAAA,GAAY,OAAO,YAAA,EAAa;AAItC,EAAA,IACE,CAAC,SAAA,CAAU,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,SAAS,CAAA,IAC1C,CAAC,SAAA,CAAU,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,SAAS,CAAA,EAC1C;AACA,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,OACE,SAAA,CAAU,iBAAiB,IAAA,CAAK,YAAA,IAChC,OAAO,cAAA,EAAe,CAAE,iBAAiB,IAAA,CAAK,YAAA;AAElD;;;;"}

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,GAAI,MAAM,GAAG,CAAC,IAAI,KAAG,OAGnC,CAAC;AAEzB,eAAO,MAAM,8BAA8B,GACzC,MAAM,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,GAClC,MAAM,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,GAClC,MAAM,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,GACtC,MAAM,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,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"}

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

@@ -2,28 +2,18 @@ import { Arr } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
 import { isAtomicTypeNode } from './is-atomic-type-node.mjs';
 
-const isShallowReadonlyTypeNode = (node) => isReadonlyTupleOrArrayTypeNode(node) ||
-    isReadonlyTypeReferenceNode(node) ||
-    isAtomicTypeNode(node);
-const isReadonlyTupleOrArrayTypeNode = (node) => node.isKind(tsm.SyntaxKind.TypeOperator) &&
-    node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword &&
-    (node.getTypeNode().isKind(tsm.SyntaxKind.ArrayType) || // Use optional chaining and isKind
-        node.getTypeNode().isKind(tsm.SyntaxKind.TupleType));
-const isReadonlyArrayTypeNode = (node) => node.isKind(tsm.SyntaxKind.TypeOperator) &&
-    node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword &&
-    node.getTypeNode().isKind(tsm.SyntaxKind.ArrayType);
-const isReadonlyTupleTypeNode = (node) => node.isKind(tsm.SyntaxKind.TypeOperator) &&
-    node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword &&
-    node.getTypeNode().isKind(tsm.SyntaxKind.TupleType);
+const isShallowReadonlyTypeNode = (node) => isReadonlyTupleOrArrayTypeNode(node) || isReadonlyTypeReferenceNode(node) || isAtomicTypeNode(node);
+const isReadonlyTupleOrArrayTypeNode = (node) => node.isKind(tsm.SyntaxKind.TypeOperator) && node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword && (node.getTypeNode().isKind(tsm.SyntaxKind.ArrayType) || // Use optional chaining and isKind
+node.getTypeNode().isKind(tsm.SyntaxKind.TupleType));
+const isReadonlyArrayTypeNode = (node) => node.isKind(tsm.SyntaxKind.TypeOperator) && node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword && node.getTypeNode().isKind(tsm.SyntaxKind.ArrayType);
+const isReadonlyTupleTypeNode = (node) => node.isKind(tsm.SyntaxKind.TypeOperator) && node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword && node.getTypeNode().isKind(tsm.SyntaxKind.TupleType);
 const isReadonlyTypeReferenceNode = (node) => {
-    if (!node.isKind(tsm.SyntaxKind.TypeReference)) {
-        return false;
-    }
-    const typeName = node.getTypeName();
-    const typeArguments = node.getTypeArguments();
-    return (typeName.isKind(tsm.SyntaxKind.Identifier) &&
-        typeName.getText() === 'Readonly' &&
-        Arr.isArrayOfLength(typeArguments, 1));
+  if (!node.isKind(tsm.SyntaxKind.TypeReference)) {
+    return false;
+  }
+  const typeName = node.getTypeName();
+  const typeArguments = node.getTypeArguments();
+  return typeName.isKind(tsm.SyntaxKind.Identifier) && typeName.getText() === "Readonly" && Arr.isArrayOfLength(typeArguments, 1);
 };
 
 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":[null],"names":[],"mappings":";;;;AAKO,MAAM,yBAAyB,GAAG,CAAC,IAAc,KACtD,8BAA8B,CAAC,IAAI,CAAC;IACpC,2BAA2B,CAAC,IAAI,CAAC;IACjC,gBAAgB,CAAC,IAAI;AAEhB,MAAM,8BAA8B,GAAG,CAC5C,IAA4B,KAE5B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,YAAY,CAAC;IACxC,IAAI,CAAC,WAAW,EAAE,KAAK,GAAG,CAAC,UAAU,CAAC,eAAe;AACrD,KAAC,IAAI,CAAC,WAAW,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC;AAClD,QAAA,IAAI,CAAC,WAAW,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC;AAShD,MAAM,uBAAuB,GAAG,CACrC,IAA4B,KAE5B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,YAAY,CAAC;IACxC,IAAI,CAAC,WAAW,EAAE,KAAK,GAAG,CAAC,UAAU,CAAC,eAAe;AACrD,IAAA,IAAI,CAAC,WAAW,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS;AAqE7C,MAAM,uBAAuB,GAAG,CACrC,IAA4B,KAE5B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,YAAY,CAAC;IACxC,IAAI,CAAC,WAAW,EAAE,KAAK,GAAG,CAAC,UAAU,CAAC,eAAe;AACrD,IAAA,IAAI,CAAC,WAAW,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS;AA4D7C,MAAM,2BAA2B,GAAG,CACzC,IAA4B,KACS;AACrC,IAAA,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE;AAC9C,QAAA,OAAO,KAAK;;AAGd,IAAA,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,EAAE;AAEnC,IAAA,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,EAAE;IAE7C,QACE,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,UAAU,CAAC;AAC1C,QAAA,QAAQ,CAAC,OAAO,EAAE,KAAK,UAAU;QACjC,GAAG,CAAC,eAAe,CAAC,aAAa,EAAE,CAAC,CAAC;AAEzC;;;;"}
+{"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;;;;"}

package/dist/functions/functions/is-spread-parameter-node.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"is-spread-parameter-node.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/is-spread-parameter-node.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAEhC,eAAO,MAAM,qBAAqB,GAChC,MAAM,GAAG,CAAC,IAAI,KACb,IAAI,IAAI,GAAG,CAAC,oBAEyB,CAAC;AAEzC,eAAO,MAAM,4BAA4B,GACvC,MAAM,GAAG,CAAC,IAAI,KACb,IAAI,IAAI,GAAG,CAAC,gBAEyB,CAAC"}
+{"version":3,"file":"is-spread-parameter-node.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/is-spread-parameter-node.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAEhC,eAAO,MAAM,qBAAqB,SAC1B,GAAG,CAAC,IAAI,KACb,IAAI,IAAI,GAAG,CAAC,oBAEyB,CAAC;AAEzC,eAAO,MAAM,4BAA4B,SACjC,GAAG,CAAC,IAAI,KACb,IAAI,IAAI,GAAG,CAAC,gBAEyB,CAAC"}

package/dist/functions/functions/is-spread-parameter-node.mjs

@@ -1,9 +1,7 @@
 import * as tsm from 'ts-morph';
 
-const isSpreadParameterNode = (node) => node.isKind(tsm.SyntaxKind.Parameter) &&
-    node.getDotDotDotToken() !== undefined;
-const isSpreadNamedTupleMemberNode = (node) => node.isKind(tsm.SyntaxKind.NamedTupleMember) &&
-    node.getDotDotDotToken() !== undefined;
+const isSpreadParameterNode = (node) => node.isKind(tsm.SyntaxKind.Parameter) && node.getDotDotDotToken() !== void 0;
+const isSpreadNamedTupleMemberNode = (node) => node.isKind(tsm.SyntaxKind.NamedTupleMember) && node.getDotDotDotToken() !== void 0;
 
 export { isSpreadNamedTupleMemberNode, isSpreadParameterNode };
 //# sourceMappingURL=is-spread-parameter-node.mjs.map

package/dist/functions/functions/is-spread-parameter-node.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-spread-parameter-node.mjs","sources":["../../../src/functions/functions/is-spread-parameter-node.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAEO,MAAM,qBAAqB,GAAG,CACnC,IAAc,KAEd,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC;AACrC,IAAA,IAAI,CAAC,iBAAiB,EAAE,KAAK;AAExB,MAAM,4BAA4B,GAAG,CAC1C,IAAc,KAEd,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,gBAAgB,CAAC;AAC5C,IAAA,IAAI,CAAC,iBAAiB,EAAE,KAAK;;;;"}
+{"version":3,"file":"is-spread-parameter-node.mjs","sources":["../../../src/functions/functions/is-spread-parameter-node.mts"],"sourcesContent":["import * as tsm from 'ts-morph';\n\nexport const isSpreadParameterNode = (\n  node: tsm.Node,\n): node is tsm.ParameterDeclaration =>\n  node.isKind(tsm.SyntaxKind.Parameter) &&\n  node.getDotDotDotToken() !== undefined;\n\nexport const isSpreadNamedTupleMemberNode = (\n  node: tsm.Node,\n): node is tsm.NamedTupleMember =>\n  node.isKind(tsm.SyntaxKind.NamedTupleMember) &&\n  node.getDotDotDotToken() !== undefined;\n"],"names":[],"mappings":";;AAEO,MAAM,qBAAA,GAAwB,CACnC,IAAA,KAEA,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,SAAS,CAAA,IACpC,IAAA,CAAK,iBAAA,EAAkB,KAAM;AAExB,MAAM,4BAAA,GAA+B,CAC1C,IAAA,KAEA,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,gBAAgB,CAAA,IAC3C,IAAA,CAAK,iBAAA,EAAkB,KAAM;;;;"}

package/dist/functions/functions/remove-parentheses.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"remove-parentheses.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/remove-parentheses.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAGhC,eAAO,MAAM,iBAAiB,GAAI,MAAM,GAAG,CAAC,QAAQ,KAAG,GAAG,CAAC,QAGjD,CAAC"}
+{"version":3,"file":"remove-parentheses.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/remove-parentheses.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAGhC,eAAO,MAAM,iBAAiB,SAAU,GAAG,CAAC,QAAQ,KAAG,GAAG,CAAC,QAGjD,CAAC"}

package/dist/functions/functions/remove-parentheses.mjs

@@ -1,9 +1,6 @@
 import * as tsm from 'ts-morph';
 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-const removeParentheses = (node) => node.isKind(tsm.SyntaxKind.ParenthesizedType)
-    ? removeParentheses(node.getTypeNode())
-    : node;
+const removeParentheses = (node) => node.isKind(tsm.SyntaxKind.ParenthesizedType) ? removeParentheses(node.getTypeNode()) : node;
 
 export { removeParentheses };
 //# sourceMappingURL=remove-parentheses.mjs.map

package/dist/functions/functions/remove-parentheses.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"remove-parentheses.mjs","sources":["../../../src/functions/functions/remove-parentheses.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;AACO,MAAM,iBAAiB,GAAG,CAAC,IAAkB,KAClD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,iBAAiB;AAC1C,MAAE,iBAAiB,CAAC,IAAI,CAAC,WAAW,EAAE;MACpC;;;;"}
+{"version":3,"file":"remove-parentheses.mjs","sources":["../../../src/functions/functions/remove-parentheses.mts"],"sourcesContent":["import * as tsm from 'ts-morph';\n\n// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\nexport const removeParentheses = (node: tsm.TypeNode): tsm.TypeNode =>\n  node.isKind(tsm.SyntaxKind.ParenthesizedType)\n    ? removeParentheses(node.getTypeNode())\n    : node;\n"],"names":[],"mappings":";;AAGO,MAAM,iBAAA,GAAoB,CAAC,IAAA,KAChC,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,iBAAiB,CAAA,GACxC,iBAAA,CAAkB,IAAA,CAAK,WAAA,EAAa,CAAA,GACpC;;;;"}

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,GAAI,MAAM,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,OAgBlE,CAAC"}

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

@@ -1,31 +1,14 @@
 import * as tsm from 'ts-morph';
 
-/**
- * Determines if parentheses should be avoided when adding 'readonly' prefix to a type.
- *
- * Parentheses should be AVOIDED in these specific contexts:
- * - Type predicates: `x is [T, U]` -> `x is readonly [T, U]` (not `x is (readonly [T, U])`)
- *   because parentheses around the type in a type predicate cause syntax errors
- *
- * For all other contexts, we keep parentheses for safety to avoid precedence issues,
- * relying on prettier to remove unnecessary ones.
- *
- * @param node - The type node to check
- * @returns true if parentheses should be avoided, false otherwise (keep parentheses)
- */
 const shouldAvoidParenthesesForReadonly = (node) => {
-    const parent = node.getParent();
-    if (parent === undefined) {
-        return false;
-    }
-    // Check if parent is TypePredicate: x is T
-    // In this case, we MUST avoid parentheses: x is readonly T (not x is (readonly T))
-    // because `x is (readonly T)` is a syntax error
-    if (parent.isKind(tsm.SyntaxKind.TypePredicate)) {
-        return true;
-    }
-    // For all other cases, keep parentheses for safety
+  const parent = node.getParent();
+  if (parent === void 0) {
     return false;
+  }
+  if (parent.isKind(tsm.SyntaxKind.TypePredicate)) {
+    return true;
+  }
+  return false;
 };
 
 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":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;AAYG;AACI,MAAM,iCAAiC,GAAG,CAAC,IAAc,KAAa;AAC3E,IAAA,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE;AAE/B,IAAA,IAAI,MAAM,KAAK,SAAS,EAAE;AACxB,QAAA,OAAO,KAAK;IACd;;;;IAKA,IAAI,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE;AAC/C,QAAA,OAAO,IAAI;IACb;;AAGA,IAAA,OAAO,KAAK;AACd;;;;"}
+{"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;;;;"}

package/dist/functions/functions/unwrap-readonly.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"unwrap-readonly.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/unwrap-readonly.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAGxE,eAAO,MAAM,yBAAyB,GAEpC,MAAM,yBAAyB,KAC9B,MAAuE,CAAC"}
+{"version":3,"file":"unwrap-readonly.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/unwrap-readonly.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAGxE,eAAO,MAAM,yBAAyB,SAE9B,yBAAyB,KAC9B,MAAuE,CAAC"}

package/dist/functions/functions/unwrap-readonly.mjs

@@ -1,8 +1,6 @@
 import { wrapWithParentheses } from './wrap-with-parentheses.mjs';
 
-const unwrapReadonlyTypeArgText = (
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node) => wrapWithParentheses(node.getTypeArguments()[0].getFullText());
+const unwrapReadonlyTypeArgText = (node) => wrapWithParentheses(node.getTypeArguments()[0].getFullText());
 
 export { unwrapReadonlyTypeArgText };
 //# sourceMappingURL=unwrap-readonly.mjs.map

package/dist/functions/functions/unwrap-readonly.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"unwrap-readonly.mjs","sources":["../../../src/functions/functions/unwrap-readonly.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAGO,MAAM,yBAAyB,GAAG;AACvC;AACA,IAA+B,KACpB,mBAAmB,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE;;;;"}
+{"version":3,"file":"unwrap-readonly.mjs","sources":["../../../src/functions/functions/unwrap-readonly.mts"],"sourcesContent":["import { type ReadonlyTypeReferenceNode } from './is-readonly-node.mjs';\nimport { wrapWithParentheses } from './wrap-with-parentheses.mjs';\n\nexport const unwrapReadonlyTypeArgText = (\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  node: ReadonlyTypeReferenceNode,\n): string => wrapWithParentheses(node.getTypeArguments()[0].getFullText());\n"],"names":[],"mappings":";;AAGO,MAAM,yBAAA,GAA4B,CAEvC,IAAA,KACW,mBAAA,CAAoB,IAAA,CAAK,kBAAiB,CAAE,CAAC,CAAA,CAAE,WAAA,EAAa;;;;"}

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

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

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

@@ -1,60 +1,35 @@
 import { range, asUint32 } from 'ts-data-forge';
 
-/**
- * Checks if a string is already wrapped with a single pair of balanced parentheses
- * that encompasses the entire expression.
- *
- * @example
- * isWrappedWithParentheses('(A)') // true
- * isWrappedWithParentheses('((A))') // true (outer pair wraps everything)
- * isWrappedWithParentheses('(A) | (B)') // false (outer parens don't wrap everything)
- * isWrappedWithParentheses('A') // false
- */
+const parenDepthDelta = (char) => {
+  switch (char) {
+    case "(":
+      return 1;
+    case ")":
+      return -1;
+    default:
+      return 0;
+  }
+};
 const isWrappedWithParentheses = (str) => {
-    const trimmed = str.trim();
-    if (!trimmed.startsWith('(') || !trimmed.endsWith(')')) {
-        return false;
-    }
-    // Check if the opening and closing parentheses are balanced
-    // and the opening parenthesis corresponds to the closing one
-    let mut_depth = 0;
-    for (const mut_i of range(0, asUint32(trimmed.length))) {
-        const char = trimmed.charAt(mut_i);
-        switch (char) {
-            case '(': {
-                mut_depth += 1;
-                break;
-            }
-            case ')': {
-                mut_depth -= 1;
-                // If we reach depth 0 before the end, the outer parentheses don't wrap everything
-                if (mut_depth === 0 && mut_i < trimmed.length - 1) {
-                    return false;
-                }
-                break;
-            }
-        }
+  const trimmed = str.trim();
+  if (!trimmed.startsWith("(") || !trimmed.endsWith(")")) {
+    return false;
+  }
+  let mut_depth = 0;
+  for (const mut_i of range(0, asUint32(trimmed.length))) {
+    mut_depth += parenDepthDelta(trimmed.charAt(mut_i));
+    if (mut_depth === 0 && mut_i < trimmed.length - 1) {
+      return false;
     }
-    return true;
+  }
+  return true;
 };
-/**
- * Wraps a string with parentheses if not already wrapped.
- * Avoids adding redundant parentheses when the expression is already
- * fully wrapped with balanced parentheses.
- *
- * @example
- * wrapWithParentheses('A') // '(A)'
- * wrapWithParentheses('(A)') // '(A)' (not '((A))')
- * wrapWithParentheses('A | B') // '(A | B)'
- * wrapWithParentheses('(A | B)') // '(A | B)' (not '((A | B))')
- * wrapWithParentheses('(A) | (B)') // '((A) | (B))' (needs outer parens)
- */
 const wrapWithParentheses = (nodeStr) => {
-    const trimmed = nodeStr.trim();
-    if (isWrappedWithParentheses(trimmed)) {
-        return trimmed;
-    }
-    return `(${trimmed})`;
+  const trimmed = nodeStr.trim();
+  if (isWrappedWithParentheses(trimmed)) {
+    return trimmed;
+  }
+  return `(${trimmed})`;
 };
 
 export { wrapWithParentheses };

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

@@ -1 +1 @@
-{"version":3,"file":"wrap-with-parentheses.mjs","sources":["../../../src/functions/functions/wrap-with-parentheses.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAAA;;;;;;;;;AASG;AAGH,MAAM,wBAAwB,GAAG,CAAC,GAAW,KAAa;AACxD,IAAA,MAAM,OAAO,GAAG,GAAG,CAAC,IAAI,EAAE;AAE1B,IAAA,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;AACtD,QAAA,OAAO,KAAK;IACd;;;IAIA,IAAI,SAAS,GAAG,CAAC;AAEjB,IAAA,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE;QACtD,MAAM,IAAI,GAAW,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC;QAE1C,QAAQ,IAAI;YACV,KAAK,GAAG,EAAE;gBACR,SAAS,IAAI,CAAC;gBAEd;YACF;YAEA,KAAK,GAAG,EAAE;gBACR,SAAS,IAAI,CAAC;;AAGd,gBAAA,IAAI,SAAS,KAAK,CAAC,IAAI,KAAK,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;AACjD,oBAAA,OAAO,KAAK;gBACd;gBAEA;YACF;;IAOJ;AAEA,IAAA,OAAO,IAAI;AACb,CAAC;AAED;;;;;;;;;;;AAWG;AACI,MAAM,mBAAmB,GAAG,CAAC,OAAe,KAAY;AAC7D,IAAA,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,EAAE;AAE9B,IAAA,IAAI,wBAAwB,CAAC,OAAO,CAAC,EAAE;AACrC,QAAA,OAAO,OAAO;IAChB;IAEA,OAAO,CAAA,CAAA,EAAI,OAAO,CAAA,CAAA,CAAY;AAChC;;;;"}
+{"version":3,"file":"wrap-with-parentheses.mjs","sources":["../../../src/functions/functions/wrap-with-parentheses.mts"],"sourcesContent":["/**\n * Checks if a string is already wrapped with a single pair of balanced parentheses\n * that encompasses the entire expression.\n *\n * @example\n * isWrappedWithParentheses('(A)') // true\n * isWrappedWithParentheses('((A))') // true (outer pair wraps everything)\n * isWrappedWithParentheses('(A) | (B)') // false (outer parens don't wrap everything)\n * isWrappedWithParentheses('A') // false\n */\nimport { asUint32, range } from 'ts-data-forge';\n\nconst parenDepthDelta = (char: string): number => {\n  switch (char) {\n    case '(':\n      return 1;\n\n    case ')':\n      return -1;\n\n    default:\n      return 0;\n  }\n};\n\nconst isWrappedWithParentheses = (str: string): boolean => {\n  const trimmed = str.trim();\n\n  if (!trimmed.startsWith('(') || !trimmed.endsWith(')')) {\n    return false;\n  }\n\n  // Check if the opening and closing parentheses are balanced\n  // and the opening parenthesis corresponds to the closing one\n  let mut_depth = 0;\n\n  for (const mut_i of range(0, asUint32(trimmed.length))) {\n    mut_depth += parenDepthDelta(trimmed.charAt(mut_i));\n\n    // If we reach depth 0 before the end, the outer parentheses don't wrap everything\n    if (mut_depth === 0 && mut_i < trimmed.length - 1) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\n * Wraps a string with parentheses if not already wrapped.\n * Avoids adding redundant parentheses when the expression is already\n * fully wrapped with balanced parentheses.\n *\n * @example\n * wrapWithParentheses('A') // '(A)'\n * wrapWithParentheses('(A)') // '(A)' (not '((A))')\n * wrapWithParentheses('A | B') // '(A | B)'\n * wrapWithParentheses('(A | B)') // '(A | B)' (not '((A | B))')\n * wrapWithParentheses('(A) | (B)') // '((A) | (B))' (needs outer parens)\n */\nexport const wrapWithParentheses = (nodeStr: string): string => {\n  const trimmed = nodeStr.trim();\n\n  if (isWrappedWithParentheses(trimmed)) {\n    return trimmed;\n  }\n\n  return `(${trimmed})` as const;\n};\n"],"names":[],"mappings":";;AAYA,MAAM,eAAA,GAAkB,CAAC,IAAA,KAAyB;AAChD,EAAA,QAAQ,IAAA;AAAM,IACZ,KAAK,GAAA;AACH,MAAA,OAAO,CAAA;AAAA,IAET,KAAK,GAAA;AACH,MAAA,OAAO,EAAA;AAAA,IAET;AACE,MAAA,OAAO,CAAA;AAAA;AAEb,CAAA;AAEA,MAAM,wBAAA,GAA2B,CAAC,GAAA,KAAyB;AACzD,EAAA,MAAM,OAAA,GAAU,IAAI,IAAA,EAAK;AAEzB,EAAA,IAAI,CAAC,QAAQ,UAAA,CAAW,GAAG,KAAK,CAAC,OAAA,CAAQ,QAAA,CAAS,GAAG,CAAA,EAAG;AACtD,IAAA,OAAO,KAAA;AAAA,EACT;AAIA,EAAA,IAAI,SAAA,GAAY,CAAA;AAEhB,EAAA,KAAA,MAAW,SAAS,KAAA,CAAM,CAAA,EAAG,SAAS,OAAA,CAAQ,MAAM,CAAC,CAAA,EAAG;AACtD,IAAA,SAAA,IAAa,eAAA,CAAgB,OAAA,CAAQ,MAAA,CAAO,KAAK,CAAC,CAAA;AAGlD,IAAA,IAAI,SAAA,KAAc,CAAA,IAAK,KAAA,GAAQ,OAAA,CAAQ,SAAS,CAAA,EAAG;AACjD,MAAA,OAAO,KAAA;AAAA,IACT;AAAA,EACF;AAEA,EAAA,OAAO,IAAA;AACT,CAAA;AAcO,MAAM,mBAAA,GAAsB,CAAC,OAAA,KAA4B;AAC9D,EAAA,MAAM,OAAA,GAAU,QAAQ,IAAA,EAAK;AAE7B,EAAA,IAAI,wBAAA,CAAyB,OAAO,CAAA,EAAG;AACrC,IAAA,OAAO,OAAA;AAAA,EACT;AAEA,EAAA,OAAO,IAAI,OAAO,CAAA,CAAA,CAAA;AACpB;;;;"}

package/dist/functions/utils/replace-with-debug.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"replace-with-debug.d.mts","sourceRoot":"","sources":["../../../src/functions/utils/replace-with-debug.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,GAAG,MAAM,UAAU,CAAC;AAErC,eAAO,MAAM,yBAAyB,GACpC,MAAM,GAAG,CAAC,IAAI,EACd,aAAa,MAAM,KAClB,IAIF,CAAC"}
+{"version":3,"file":"replace-with-debug.d.mts","sourceRoot":"","sources":["../../../src/functions/utils/replace-with-debug.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,GAAG,MAAM,UAAU,CAAC;AAErC,eAAO,MAAM,yBAAyB,SAC9B,GAAG,CAAC,IAAI,eACD,MAAM,KAClB,IAIF,CAAC"}

package/dist/functions/utils/replace-with-debug.mjs

@@ -1,6 +1,6 @@
 const replaceNodeWithDebugPrint = (node, newNodeText) => {
-    console.debug(`${node.getText()} -> ${newNodeText}`);
-    node.replaceWithText(newNodeText);
+  console.debug(`${node.getText()} -> ${newNodeText}`);
+  node.replaceWithText(newNodeText);
 };
 
 export { replaceNodeWithDebugPrint };

package/dist/functions/utils/replace-with-debug.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"replace-with-debug.mjs","sources":["../../../src/functions/utils/replace-with-debug.mts"],"sourcesContent":[null],"names":[],"mappings":"MAEa,yBAAyB,GAAG,CACvC,IAAc,EACd,WAAmB,KACX;AACR,IAAA,OAAO,CAAC,KAAK,CAAC,CAAA,EAAG,IAAI,CAAC,OAAO,EAAE,CAAA,IAAA,EAAO,WAAW,CAAA,CAAE,CAAC;AAEpD,IAAA,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC;AACnC;;;;"}
+{"version":3,"file":"replace-with-debug.mjs","sources":["../../../src/functions/utils/replace-with-debug.mts"],"sourcesContent":["import type * as tsm from 'ts-morph';\n\nexport const replaceNodeWithDebugPrint = (\n  node: tsm.Node,\n  newNodeText: string,\n): void => {\n  console.debug(`${node.getText()} -> ${newNodeText}`);\n\n  node.replaceWithText(newNodeText);\n};\n"],"names":[],"mappings":"AAEO,MAAM,yBAAA,GAA4B,CACvC,IAAA,EACA,WAAA,KACS;AACT,EAAA,OAAA,CAAQ,MAAM,CAAA,EAAG,IAAA,CAAK,SAAS,CAAA,IAAA,EAAO,WAAW,CAAA,CAAE,CAAA;AAEnD,EAAA,IAAA,CAAK,gBAAgB,WAAW,CAAA;AAClC;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-codemod-lib",
-  "version": "2.2.1",
+  "version": "2.2.2",
   "private": false,
   "keywords": [
     "typescript",
@@ -97,22 +97,21 @@
     "test:cov:ui": "vite preview --outDir ./coverage",
     "test:ui": "pnpm run z:vitest:node --ui",
     "testw": "pnpm run z:vitest:node watch",
-    "tsc": "tsc --noEmit",
-    "tscw": "tsc --noEmit --watch -p ./tsconfig.json",
-    "type-check": "tsc --noEmit",
-    "update-packages": "pnpm update --latest",
+    "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": "^6.9.6",
+    "ts-data-forge": "^7.1.1",
     "ts-morph": "^28.0.0",
-    "ts-type-forge": "^3.0.1"
+    "ts-type-forge": "^4.0.0"
   },
   "devDependencies": {
     "@rollup/plugin-replace": "6.0.3",
     "@rollup/plugin-strip": "3.0.4",
-    "@rollup/plugin-typescript": "12.3.0",
     "@semantic-release/changelog": "6.0.3",
     "@semantic-release/commit-analyzer": "13.0.1",
     "@semantic-release/exec": "7.1.0",
@@ -120,35 +119,37 @@
     "@semantic-release/github": "12.0.8",
     "@semantic-release/npm": "13.1.5",
     "@semantic-release/release-notes-generator": "14.1.1",
-    "@types/node": "25.9.2",
-    "@vitest/browser-playwright": "4.1.5",
-    "@vitest/coverage-v8": "4.1.5",
-    "@vitest/ui": "4.1.5",
+    "@types/node": "26.1.0",
+    "@vitest/browser-playwright": "4.1.10",
+    "@vitest/coverage-v8": "4.1.10",
+    "@vitest/ui": "4.1.9",
     "cmd-ts": "0.15.0",
-    "conventional-changelog-conventionalcommits": "9.3.1",
+    "conventional-changelog-conventionalcommits": "10.2.1",
     "cspell": "10.0.1",
     "dedent": "1.7.2",
-    "eslint": "9.39.4",
-    "eslint-config-typed": "4.9.11",
+    "esbuild": "0.28.1",
+    "eslint": "10.6.0",
+    "eslint-config-typed": "5.4.0",
     "github-settings-as-code": "1.2.9",
     "jiti": "2.7.0",
-    "markdownlint": "0.40.0",
-    "markdownlint-cli2": "0.22.1",
-    "npm-run-all2": "8.0.4",
-    "playwright": "1.60.0",
-    "prettier": "3.8.3",
+    "markdownlint": "0.41.0",
+    "markdownlint-cli2": "0.23.0",
+    "npm-run-all2": "9.0.2",
+    "playwright": "1.61.1",
+    "prettier": "3.9.4",
     "prettier-plugin-organize-imports": "4.3.0",
     "prettier-plugin-packagejson": "3.0.2",
-    "rollup": "4.61.1",
+    "rollup": "4.62.2",
+    "rollup-plugin-esbuild": "6.2.1",
     "semantic-release": "25.0.5",
     "ts-repo-utils": "10.1.2",
-    "tslib": "2.8.1",
-    "tsx": "4.22.3",
+    "tsx": "4.23.0",
     "typedoc": "0.28.19",
     "typedoc-github-theme": "0.4.0",
-    "typescript": "5.9.3",
-    "vite": "8.0.16",
-    "vitest": "4.1.5"
+    "typescript": "6.0.3",
+    "typescript-native": "npm:typescript@7.0.1-rc",
+    "vite": "8.1.2",
+    "vitest": "4.1.9"
   },
   "peerDependencies": {
     "cmd-ts": "0.14.3",
@@ -166,12 +167,12 @@
       "optional": true
     }
   },
-  "packageManager": "pnpm@10.33.4",
+  "packageManager": "pnpm@11.10.0+sha512.0b7f8b98060031904c017e3a41eb187a16d40eeb829b95c4f8cb03681761fc4ab53dd219115b9b447f4dce1a05a214764461e7d3703392a9f32f9511ce8c86c8",
   "engines": {
-    "node": ">=22.18.0",
+    "node": ">=22.22.2",
     "pnpm": ">=9.0.0"
   },
   "volta": {
-    "node": "25.9.0"
+    "node": "26.3.1"
   }
 }

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import * as cmd from 'cmd-ts';
-import { Result } from 'ts-data-forge';
+import { Arr, Result } from 'ts-data-forge';
 import { appendAsConstTransformer } from '../functions/index.mjs';
 import { runTransformerCLI } from './run-transformer-cli.mjs';
 
@@ -9,7 +9,7 @@ const transformer = appendAsConstTransformer();
 
 const cmdDef = cmd.command({
   name: transformer.name,
-  version: '2.2.1',
+  version: '2.2.2',
   args: {
     baseDir: cmd.positional({
       type: cmd.string,
@@ -64,4 +64,4 @@ const cmdDef = cmd.command({
   },
 });
 
-await cmd.run(cmdDef, process.argv.slice(2));
+await cmd.run(cmdDef, Arr.skip(process.argv, 2));

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import * as cmd from 'cmd-ts';
-import { Result } from 'ts-data-forge';
+import { Arr, Result } from 'ts-data-forge';
 import { convertInterfaceToTypeTransformer } from '../functions/index.mjs';
 import { runTransformerCLI } from './run-transformer-cli.mjs';
 
@@ -9,7 +9,7 @@ const transformer = convertInterfaceToTypeTransformer();
 
 const cmdDef = cmd.command({
   name: transformer.name,
-  version: '2.2.1',
+  version: '2.2.2',
   args: {
     baseDir: cmd.positional({
       type: cmd.string,
@@ -64,4 +64,4 @@ const cmdDef = cmd.command({
   },
 });
 
-await cmd.run(cmdDef, process.argv.slice(2));
+await cmd.run(cmdDef, Arr.skip(process.argv, 2));

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import * as cmd from 'cmd-ts';
-import { Result } from 'ts-data-forge';
+import { Arr, Result } from 'ts-data-forge';
 import { convertToReadonlyTransformer } from '../functions/index.mjs';
 import { runTransformerCLI } from './run-transformer-cli.mjs';
 
@@ -9,7 +9,7 @@ const transformer = convertToReadonlyTransformer();
 
 const cmdDef = cmd.command({
   name: transformer.name,
-  version: '2.2.1',
+  version: '2.2.2',
   args: {
     baseDir: cmd.positional({
       type: cmd.string,
@@ -64,4 +64,4 @@ const cmdDef = cmd.command({
   },
 });
 
-await cmd.run(cmdDef, process.argv.slice(2));
+await cmd.run(cmdDef, Arr.skip(process.argv, 2));