ts-codemod-lib 2.2.4 → 3.0.0

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.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.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;;;;"}
+{"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.4",
+  "version": "3.0.0",
   "private": false,
   "keywords": [
     "typescript",
@@ -11,13 +11,11 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/noshiro-pf/ts-codemod-lib.git"
+    "url": "git+https://github.com/noshiro-pf/mono.git",
+    "directory": "libs/ts-codemod-lib"
   },
   "license": "Apache-2.0",
   "author": "noshiro-pf <noshiro.pf@gmail.com>",
-  "sideEffects": [
-    "./dist/cmd/*.mjs"
-  ],
   "type": "module",
   "exports": {
     ".": {
@@ -33,144 +31,49 @@
   },
   "module": "./dist/entry-point.mjs",
   "types": "./dist/types.d.mts",
-  "bin": {
-    "append-as-const": "./dist/cmd/append-as-const.mjs",
-    "convert-interface-to-type": "./dist/cmd/convert-interface-to-type.mjs",
-    "convert-to-readonly": "./dist/cmd/convert-to-readonly.mjs",
-    "replace-any-with-unknown": "./dist/cmd/replace-any-with-unknown.mjs",
-    "replace-record-with-unknown-record": "./dist/cmd/replace-record-with-unknown-record.mjs"
-  },
   "files": [
     "src",
     "dist",
     "README.md",
     "LICENSE"
   ],
-  "scripts": {
-    "agents:gen": "tsx ./scripts/cmd/gen-agents-md.mts",
-    "agents:sync": "tsx ./scripts/cmd/sync-agent-config.mts",
-    "build": "tsx ./scripts/cmd/build.mts",
-    "build:min": "tsx ./scripts/cmd/build.mts --skip-check",
-    "check-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:any-to-unknown": "tsx ./src/cmd/replace-any-with-unknown.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:any-to-unknown": "tsx ./src/cmd/replace-any-with-unknown.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: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: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}'",
-    "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",
-    "doc:watch": "typedoc --options ./configs/typedoc.config.mjs --watch",
-    "fmt": "format-uncommitted",
-    "fmt:diff": "format-diff-from origin/main",
-    "fmt:full": "prettier --write .",
-    "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",
-    "test": "pnpm run z:vitest:node run",
-    "test:browser": "pnpm run z:vitest --project='Browser' run",
-    "test:cov": "pnpm run z:vitest:node run --coverage",
-    "test:cov:ui": "vite preview --outDir ./coverage",
-    "test:ui": "pnpm run z:vitest:node --ui",
-    "testw": "pnpm run z:vitest:node watch",
-    "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",
-    "z:vitest": "vitest --config ./configs/vitest.config.mts",
-    "z:vitest:node": "pnpm run z:vitest --project='Node.js'"
-  },
   "dependencies": {
-    "ts-data-forge": "^14.0.0",
     "ts-morph": "^28.0.0",
-    "ts-type-forge": "^9.1.1"
+    "ts-data-forge": "^14.2.1",
+    "ts-type-forge": "^9.2.1"
   },
   "devDependencies": {
     "@rollup/plugin-replace": "6.0.3",
     "@rollup/plugin-strip": "3.0.4",
-    "@semantic-release/changelog": "7.0.0",
-    "@semantic-release/commit-analyzer": "13.0.1",
-    "@semantic-release/exec": "7.1.0",
-    "@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.2",
+    "@types/node": "26.2.0",
     "@vitest/browser-playwright": "4.1.10",
     "@vitest/coverage-v8": "4.1.10",
     "@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.8.0",
-    "eslint-config-typed": "5.8.2",
-    "eslint-plugin-ts-data-forge": "0.3.0",
-    "eslint-plugin-ts-fortress": "0.4.0",
-    "eslint-plugin-ts-type-forge": "0.4.3",
-    "github-settings-as-code": "2.0.1",
     "jiti": "2.7.0",
-    "markdownlint": "0.41.1",
-    "markdownlint-cli2": "0.23.2",
-    "npm-run-all2": "9.0.2",
-    "playwright": "1.62.0",
+    "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.3",
+    "rollup": "4.62.4",
     "rollup-plugin-esbuild": "6.2.1",
-    "semantic-release": "25.0.8",
-    "ts-repo-utils": "10.1.6",
-    "tsx": "4.23.1",
+    "tsx": "4.23.4",
     "typedoc": "0.28.20",
     "typedoc-github-theme": "0.4.0",
     "typescript": "6.0.3",
     "typescript-native": "npm:typescript@7.0.2",
-    "vite": "8.1.5",
-    "vitest": "4.1.10"
-  },
-  "peerDependencies": {
-    "cmd-ts": "0.14.3",
-    "dedent": "1.7.2",
-    "ts-repo-utils": "8.1.0"
-  },
-  "peerDependenciesMeta": {
-    "cmd-ts": {
-      "optional": true
-    },
-    "dedent": {
-      "optional": true
-    },
-    "ts-repo-utils": {
-      "optional": true
-    }
+    "vite": "8.2.0",
+    "vitest": "4.1.10",
+    "eslint-config-typed": "5.8.5",
+    "eslint-plugin-ts-data-forge": "0.4.4",
+    "eslint-plugin-ts-fortress": "1.0.1",
+    "eslint-plugin-ts-type-forge": "0.6.3",
+    "ts-repo-utils": "10.2.0"
   },
-  "packageManager": "pnpm@11.20.0",
   "engines": {
     "node": ">=22.22.2",
     "pnpm": ">=9.0.0"
@@ -181,5 +84,56 @@
   "publishConfig": {
     "access": "public",
     "provenance": true
+  },
+  "scripts": {
+    "build": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/build.mts",
+    "build:min": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/build.mts --skip-check",
+    "check-all": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/check-all.mts",
+    "check:ext": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./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:any-to-unknown": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../ts-codemod-cli/src/cmd/replace-any-with-unknown.mts --diff-from origin/main '{src,scripts,samples,test}/**/*.{mts,tsx}'",
+    "codemod:diff:as-const": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../ts-codemod-cli/src/cmd/append-as-const.mts --diff-from origin/main '{src,scripts,samples,test}/**/*.{mts,tsx}'",
+    "codemod:diff:interface-to-type": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../ts-codemod-cli/src/cmd/convert-interface-to-type.mts --diff-from origin/main '{src,scripts,samples,test}/**/*.{mts,tsx}'",
+    "codemod:diff:readonly": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../ts-codemod-cli/src/cmd/convert-to-readonly.mts --diff-from origin/main '{src,scripts,samples,test}/**/*.{mts,tsx}'",
+    "codemod:diff:unknown-record": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../ts-codemod-cli/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:any-to-unknown": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../ts-codemod-cli/src/cmd/replace-any-with-unknown.mts '{src,scripts,samples,test}/**/*.{mts,tsx}'",
+    "codemod:full:as-const": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../ts-codemod-cli/src/cmd/append-as-const.mts '{src,scripts,samples,test}/**/*.{mts,tsx}'",
+    "codemod:full:interface-to-type": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../ts-codemod-cli/src/cmd/convert-interface-to-type.mts '{src,scripts,samples,test}/**/*.{mts,tsx}'",
+    "codemod:full:readonly": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../ts-codemod-cli/src/cmd/convert-to-readonly.mts '{src,scripts,samples,test}/**/*.{mts,tsx}'",
+    "codemod:full:unknown-record": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../ts-codemod-cli/src/cmd/replace-record-with-unknown-record.mts '{src,scripts,samples,test}/**/*.{mts,tsx}'",
+    "codemod:uncommitted:any-to-unknown": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../ts-codemod-cli/src/cmd/replace-any-with-unknown.mts --uncommitted '{src,scripts,samples,test}/**/*.{mts,tsx}'",
+    "codemod:uncommitted:as-const": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../ts-codemod-cli/src/cmd/append-as-const.mts --uncommitted '{src,scripts,samples,test}/**/*.{mts,tsx}'",
+    "codemod:uncommitted:interface-to-type": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../ts-codemod-cli/src/cmd/convert-interface-to-type.mts --uncommitted '{src,scripts,samples,test}/**/*.{mts,tsx}'",
+    "codemod:uncommitted:readonly": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../ts-codemod-cli/src/cmd/convert-to-readonly.mts --uncommitted '{src,scripts,samples,test}/**/*.{mts,tsx}'",
+    "codemod:uncommitted:unknown-record": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../ts-codemod-cli/src/cmd/replace-record-with-unknown-record.mts --uncommitted '{src,scripts,samples,test}/**/*.{mts,tsx}'",
+    "cspell": "cspell \"**\" --gitignore --gitignore-root ../../ --no-progress",
+    "doc": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/gen-docs.mts",
+    "doc:embed": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/embed-examples.mts",
+    "doc:preview": "vite preview --config ./configs/vite.doc.config.mts",
+    "doc:watch": "typedoc --options ./configs/typedoc.config.mjs --watch",
+    "fmt": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/format-uncommitted.mts --cwd .",
+    "fmt:diff": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/format-diff-from.mts origin/main --cwd .",
+    "fmt:full": "prettier --write .",
+    "gi": "run-s gi:src fmt",
+    "gi:src": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/gen-index-ts.mts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --exclude entry-point.mts",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "prepare-release": "run-s fmt build doc",
+    "run:test": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/test-code/transform-test-code.mts",
+    "test": "pnpm run z:vitest:node run",
+    "test:browser": "pnpm run z:vitest --project='Browser' run",
+    "test:cov": "pnpm run z:vitest:node run --coverage",
+    "test:cov:ui": "vite preview --outDir ./coverage",
+    "test:ui": "pnpm run z:vitest:node --ui",
+    "testw": "pnpm run z:vitest:node watch",
+    "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",
+    "z:vitest": "vitest --config ./configs/vitest.config.mts",
+    "z:vitest:node": "pnpm run z:vitest --project='Node.js'"
   }
-}
+}

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

@@ -8,7 +8,12 @@ import {
   pipe,
 } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
-import { type DeepReadonly, type SafeUintWithSmallInt } from 'ts-type-forge';
+import {
+  type DeepReadonly,
+  type SafeUintWithSmallInt,
+  type StrictExclude,
+  type StrictExtract,
+} from 'ts-type-forge';
 import {
   hasDisableNextLineComment,
   isAtomicTypeNode,
@@ -397,7 +402,7 @@ const transformNode = (
 const transformTypeReferenceNode = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: tsm.TypeReferenceNode,
-  readonlyContext: Exclude<
+  readonlyContext: StrictExclude<
     ReadonlyContext,
     Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
   >,
@@ -813,7 +818,7 @@ const transformRestTypeNode = (
 const transformTypeOperatorNode = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: tsm.TypeOperatorTypeNode,
-  readonlyContext: Exclude<
+  readonlyContext: StrictExclude<
     ReadonlyContext,
     Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
   >,
@@ -852,7 +857,7 @@ const transformTypeOperatorNode = (
 const transformTypeLiteralNode = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: tsm.TypeLiteralNode,
-  readonlyContext: Exclude<
+  readonlyContext: StrictExclude<
     ReadonlyContext,
     Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
   >,
@@ -927,7 +932,7 @@ const transformIndexedAccessTypeNode = (
 const transformMappedTypeNode = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: tsm.MappedTypeNode,
-  readonlyContext: Exclude<
+  readonlyContext: StrictExclude<
     ReadonlyContext,
     Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
   >,
@@ -1109,7 +1114,7 @@ const transformConstructorParameter = (
 const transformIntersectionTypeNode = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: tsm.IntersectionTypeNode,
-  readonlyContext: Exclude<
+  readonlyContext: StrictExclude<
     ReadonlyContext,
     Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
   >,
@@ -1125,7 +1130,7 @@ const transformIntersectionTypeNode = (
 const transformUnionTypeNode = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: tsm.UnionTypeNode,
-  readonlyContext: Exclude<
+  readonlyContext: StrictExclude<
     ReadonlyContext,
     Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
   >,
@@ -1137,7 +1142,7 @@ const transformUnionTypeNode = (
 const transformUnionOrIntersectionTypeNodeImpl = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: tsm.IntersectionTypeNode | tsm.UnionTypeNode,
-  readonlyContext: Exclude<
+  readonlyContext: StrictExclude<
     ReadonlyContext,
     Readonly<{ type: 'readonly'; indexedAccessDepth: SafeUintWithSmallInt }>
   >,
@@ -1346,7 +1351,7 @@ const transformMembers = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   members: readonly tsm.TypeElementTypes[],
   readonlyModifier: 'add' | 'remove',
-  readonlyContext: Extract<
+  readonlyContext: StrictExtract<
     ReadonlyContext,
     Readonly<{
       type: 'DeepReadonly' | 'none';
@@ -1387,8 +1392,6 @@ const transformMembers = (
     }
 
     transformNode(mb, readonlyContext, options);
-
-    continue;
   }
 };
 
@@ -1396,7 +1399,7 @@ const transformPropertySignature = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: tsm.PropertySignature,
   readonlyModifier: 'add' | 'remove',
-  readonlyContext: Extract<
+  readonlyContext: StrictExtract<
     ReadonlyContext,
     Readonly<{
       type: 'DeepReadonly' | 'none';
@@ -1406,8 +1409,8 @@ const transformPropertySignature = (
   options: ReadonlyTransformerOptionsInternal,
 ): void => {
   if (
-    readonlyContext.type === 'DeepReadonly' ||
-    readonlyModifier === 'remove'
+    readonlyModifier === 'remove' ||
+    readonlyContext.type === 'DeepReadonly'
   ) {
     node.setIsReadonly(false);
   } else {
@@ -1427,7 +1430,7 @@ const transformIndexSignatureDeclaration = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: tsm.IndexSignatureDeclaration,
   readonlyModifier: 'add' | 'remove',
-  readonlyContext: Extract<
+  readonlyContext: StrictExtract<
     ReadonlyContext,
     Readonly<{
       type: 'DeepReadonly' | 'none';
@@ -1443,8 +1446,8 @@ const transformIndexSignatureDeclaration = (
   }
 
   if (
-    readonlyContext.type === 'DeepReadonly' ||
-    readonlyModifier === 'remove'
+    readonlyModifier === 'remove' ||
+    readonlyContext.type === 'DeepReadonly'
   ) {
     // node.setIsReadonly(false);
     node.toggleModifier('readonly', false);

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

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

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

@@ -58,7 +58,7 @@ const shouldSkipFile = (
 
   const hasFileIgnoreComment = patterns.some((regex) => regex.test(code));
 
-  if (Arr.isEmpty(ignoredTransformers) && !hasFileIgnoreComment) {
+  if (!hasFileIgnoreComment && Arr.isEmpty(ignoredTransformers)) {
     return false;
   }
 

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

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

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

@@ -23,10 +23,6 @@ export const shouldAvoidParenthesesForReadonly = (node: tsm.Node): boolean => {
   // Check if parent is TypePredicate: x is T
   // In this case, we MUST avoid parentheses: x is readonly T (not x is (readonly T))
   // because `x is (readonly T)` is a syntax error
-  if (parent.isKind(tsm.SyntaxKind.TypePredicate)) {
-    return true;
-  }
-
   // For all other cases, keep parentheses for safety
-  return false;
+  return parent.isKind(tsm.SyntaxKind.TypePredicate);
 };

package/dist/cmd/append-as-const.d.mts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=append-as-const.d.mts.map

package/dist/cmd/append-as-const.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"append-as-const.d.mts","sourceRoot":"","sources":["../../src/cmd/append-as-const.mts"],"names":[],"mappings":""}