ts-codemod-lib 3.3.0 → 3.3.2

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

@@ -1 +1 @@
-{"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;;;;"}
+{"version":3,"file":"unwrap-readonly.mjs","sourceRoot":"","sources":["../../../src/functions/functions/unwrap-readonly.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE,MAAM,CAAC,MAAM,yBAAyB,GAAG;AACvC,8EAA8E;AAC9E,IAA+B,EACvB,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC"}

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

@@ -4,11 +4,20 @@
  * 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)
+ *
+ * ```ts
+ * assert.deepStrictEqual(wrapWithParentheses('A'), '(A)');
+ *
+ * // already wrapped, so not '((A))'
+ * assert.deepStrictEqual(wrapWithParentheses('(A)'), '(A)');
+ *
+ * assert.deepStrictEqual(wrapWithParentheses('A | B'), '(A | B)');
+ *
+ * assert.deepStrictEqual(wrapWithParentheses('(A | B)'), '(A | B)');
+ *
+ * // the outer parentheses do not span everything, so a pair is added
+ * assert.deepStrictEqual(wrapWithParentheses('(A) | (B)'), '((A) | (B))');
+ * ```
  */
 export declare const wrapWithParentheses: (nodeStr: string) => string;
 //# sourceMappingURL=wrap-with-parentheses.d.mts.map

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":"AAgDA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,YAAa,MAAM,KAAG,MAQrD,CAAC"}
+{"version":3,"file":"wrap-with-parentheses.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/wrap-with-parentheses.mts"],"names":[],"mappings":"AAsDA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,mBAAmB,YAAa,MAAM,KAAG,MAQrD,CAAC"}

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

@@ -1,36 +1,73 @@
-import { range, asUint32 } from 'ts-data-forge';
-
+import { asUint32, range } from 'ts-data-forge';
 const parenDepthDelta = (char) => {
-  switch (char) {
-    case "(":
-      return 1;
-    case ")":
-      return -1;
-    default:
-      return 0;
-  }
+    switch (char) {
+        case '(':
+            return 1;
+        case ')':
+            return -1;
+
+
+        case undefined:
+        default:
+            return 0;
+    }
 };
+
+
+
+
+
+
+
+
+
+
+
+
+
 const isWrappedWithParentheses = (str) => {
-  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;
+    const trimmed = str.trim();
+    if (!trimmed.startsWith('(') || !trimmed.endsWith(')')) {
+        return false;
     }
-  }
-  return true;
-};
-const wrapWithParentheses = (nodeStr) => {
-  const trimmed = nodeStr.trim();
-  if (isWrappedWithParentheses(trimmed)) {
-    return trimmed;
-  }
-  return `(${trimmed})`;
+
+
+    let mut_depth = 0;
+    for (const mut_i of range(0, asUint32(trimmed.length))) {
+        mut_depth += parenDepthDelta(trimmed.at(mut_i));
+
+        if (mut_depth === 0 && mut_i < trimmed.length - 1) {
+            return false;
+        }
+    }
+    return true;
 };
 
-export { wrapWithParentheses };
-//# sourceMappingURL=wrap-with-parentheses.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const wrapWithParentheses = (nodeStr) => {
+    const trimmed = nodeStr.trim();
+    if (isWrappedWithParentheses(trimmed)) {
+        return trimmed;
+    }
+    return `(${trimmed})`;
+};
+//# sourceMappingURL=wrap-with-parentheses.mjs.map

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":["/**\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;;;;"}
+{"version":3,"file":"wrap-with-parentheses.mjs","sourceRoot":"","sources":["../../../src/functions/functions/wrap-with-parentheses.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAEhD,MAAM,eAAe,GAAG,CAAC,IAAwB,EAAU,EAAE;IAC3D,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,GAAG;YACN,OAAO,CAAC,CAAC;QAEX,KAAK,GAAG;YACN,OAAO,CAAC,CAAC,CAAC;QAEZ,sEAAsE;QACtE,0DAA0D;QAC1D,KAAK,SAAS,CAAC;QACf;YACE,OAAO,CAAC,CAAC;IACb,CAAC;AACH,CAAC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,wBAAwB,GAAG,CAAC,GAAW,EAAW,EAAE;IACxD,MAAM,OAAO,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC;IAE3B,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QACvD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,4DAA4D;IAC5D,6DAA6D;IAC7D,IAAI,SAAS,GAAG,CAAC,CAAC;IAElB,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;QACvD,SAAS,IAAI,eAAe,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;QAEhD,kFAAkF;QAClF,IAAI,SAAS,KAAK,CAAC,IAAI,KAAK,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAClD,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,OAAe,EAAU,EAAE;IAC7D,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAE/B,IAAI,wBAAwB,CAAC,OAAO,CAAC,EAAE,CAAC;QACtC,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,OAAO,IAAI,OAAO,GAAY,CAAC;AACjC,CAAC,CAAC"}

package/dist/functions/index.mjs

@@ -1,24 +1,5 @@
-export { appendAsConstTransformer } from './ast-transformers/append-as-const.mjs';
-export { convertInterfaceToTypeTransformer } from './ast-transformers/convert-interface-to-type.mjs';
-export { convertToReadonlyTransformer } from './ast-transformers/convert-to-readonly.mjs';
-export { enableNoUncheckedIndexedAccessTransformer } from './ast-transformers/enable-no-unchecked-indexed-access.mjs';
-export { compareUnionIntersectionTypes } from './ast-transformers/readonly-transformer-helpers/compare-union-types.mjs';
-export { invalidDeepReadonlyTypeName } from './ast-transformers/readonly-transformer-helpers/constants.mjs';
-export { groupUnionIntersectionTypes } from './ast-transformers/readonly-transformer-helpers/group-union-types.mjs';
-export { nextReadonlyContext } from './ast-transformers/readonly-transformer-helpers/readonly-context.mjs';
-export { replaceAnyWithUnknownTransformer } from './ast-transformers/replace-any-with-unknown.mjs';
-export { replaceRecordWithUnknownRecordTransformer } from './ast-transformers/replace-record-with-unknown-record.mjs';
-export { transformSourceCode } from './ast-transformers/transform-source-code.mjs';
-export { IGNORE_FILE_COMMENT_PREFIXES, IGNORE_LINE_COMMENT_PREFIXES } from './constants/ignore-comment-text.mjs';
-export { hasDisableNextLineComment } from './functions/has-disable-next-line-comment.mjs';
-export { isAsConstNode } from './functions/is-as-const-node.mjs';
-export { isAtomicTypeNode } from './functions/is-atomic-type-node.mjs';
-export { isConditionalTypeDistributionGuard } from './functions/is-conditional-type-distribution-guard.mjs';
-export { isReadonlyArrayTypeNode, isReadonlyTupleOrArrayTypeNode, isReadonlyTupleTypeNode, isReadonlyTypeReferenceNode, isShallowReadonlyTypeNode } from './functions/is-readonly-node.mjs';
-export { isSpreadNamedTupleMemberNode, isSpreadParameterNode } from './functions/is-spread-parameter-node.mjs';
-export { removeParentheses } from './functions/remove-parentheses.mjs';
-export { shouldAvoidParenthesesForReadonly } from './functions/should-avoid-parentheses-for-readonly.mjs';
-export { unwrapReadonlyTypeArgText } from './functions/unwrap-readonly.mjs';
-export { wrapWithParentheses } from './functions/wrap-with-parentheses.mjs';
-export { replaceNodeWithDebugPrint } from './utils/replace-with-debug.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './ast-transformers/index.mjs';
+export * from './constants/index.mjs';
+export * from './functions/index.mjs';
+export * from './utils/index.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/functions/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../src/functions/index.mts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC"}

package/dist/functions/utils/index.mjs

@@ -1,2 +1,2 @@
-export { replaceNodeWithDebugPrint } from './replace-with-debug.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './replace-with-debug.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/functions/utils/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../../src/functions/utils/index.mts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC"}

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

@@ -1,7 +1,5 @@
-const replaceNodeWithDebugPrint = (node, newNodeText) => {
-  console.debug(`${node.getText()} -> ${newNodeText}`);
-  node.replaceWithText(newNodeText);
+export const replaceNodeWithDebugPrint = (node, newNodeText) => {
+    console.debug(`${node.getText()} -> ${newNodeText}`);
+    node.replaceWithText(newNodeText);
 };
-
-export { replaceNodeWithDebugPrint };
-//# sourceMappingURL=replace-with-debug.mjs.map
+//# sourceMappingURL=replace-with-debug.mjs.map

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":["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;;;;"}
+{"version":3,"file":"replace-with-debug.mjs","sourceRoot":"","sources":["../../../src/functions/utils/replace-with-debug.mts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,yBAAyB,GAAG,CACvC,IAAc,EACd,WAAmB,EACb,EAAE;IACR,OAAO,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE,OAAO,WAAW,EAAE,CAAC,CAAC;IAErD,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC;AACpC,CAAC,CAAC"}

package/dist/index.mjs

@@ -1,24 +1,2 @@
-export { appendAsConstTransformer } from './functions/ast-transformers/append-as-const.mjs';
-export { convertInterfaceToTypeTransformer } from './functions/ast-transformers/convert-interface-to-type.mjs';
-export { convertToReadonlyTransformer } from './functions/ast-transformers/convert-to-readonly.mjs';
-export { enableNoUncheckedIndexedAccessTransformer } from './functions/ast-transformers/enable-no-unchecked-indexed-access.mjs';
-export { compareUnionIntersectionTypes } from './functions/ast-transformers/readonly-transformer-helpers/compare-union-types.mjs';
-export { invalidDeepReadonlyTypeName } from './functions/ast-transformers/readonly-transformer-helpers/constants.mjs';
-export { groupUnionIntersectionTypes } from './functions/ast-transformers/readonly-transformer-helpers/group-union-types.mjs';
-export { nextReadonlyContext } from './functions/ast-transformers/readonly-transformer-helpers/readonly-context.mjs';
-export { replaceAnyWithUnknownTransformer } from './functions/ast-transformers/replace-any-with-unknown.mjs';
-export { replaceRecordWithUnknownRecordTransformer } from './functions/ast-transformers/replace-record-with-unknown-record.mjs';
-export { transformSourceCode } from './functions/ast-transformers/transform-source-code.mjs';
-export { IGNORE_FILE_COMMENT_PREFIXES, IGNORE_LINE_COMMENT_PREFIXES } from './functions/constants/ignore-comment-text.mjs';
-export { hasDisableNextLineComment } from './functions/functions/has-disable-next-line-comment.mjs';
-export { isAsConstNode } from './functions/functions/is-as-const-node.mjs';
-export { isAtomicTypeNode } from './functions/functions/is-atomic-type-node.mjs';
-export { isConditionalTypeDistributionGuard } from './functions/functions/is-conditional-type-distribution-guard.mjs';
-export { isReadonlyArrayTypeNode, isReadonlyTupleOrArrayTypeNode, isReadonlyTupleTypeNode, isReadonlyTypeReferenceNode, isShallowReadonlyTypeNode } from './functions/functions/is-readonly-node.mjs';
-export { isSpreadNamedTupleMemberNode, isSpreadParameterNode } from './functions/functions/is-spread-parameter-node.mjs';
-export { removeParentheses } from './functions/functions/remove-parentheses.mjs';
-export { shouldAvoidParenthesesForReadonly } from './functions/functions/should-avoid-parentheses-for-readonly.mjs';
-export { unwrapReadonlyTypeArgText } from './functions/functions/unwrap-readonly.mjs';
-export { wrapWithParentheses } from './functions/functions/wrap-with-parentheses.mjs';
-export { replaceNodeWithDebugPrint } from './functions/utils/replace-with-debug.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './functions/index.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-codemod-lib",
-  "version": "3.3.0",
+  "version": "3.3.2",
   "private": false,
   "keywords": [
     "typescript",
@@ -38,45 +38,44 @@
     "LICENSE"
   ],
   "dependencies": {
-    "ts-data-forge": "^14.4.0",
+    "ts-data-forge": "^14.7.1",
     "ts-morph": "^28.0.0",
     "ts-type-forge": "^9.2.2"
   },
   "devDependencies": {
-    "@types/node": "26.4.0",
-    "@vitest/browser-playwright": "4.1.11",
-    "@vitest/coverage-v8": "4.1.11",
-    "@vitest/ui": "4.1.11",
-    "cspell": "10.0.1",
+    "@types/node": "26.5.0",
+    "@vitest/browser-playwright": "5.0.0",
+    "@vitest/coverage-v8": "5.0.0",
+    "@vitest/ui": "5.0.0",
+    "cspell": "10.2.1",
     "dedent": "1.7.2",
     "esbuild": "0.28.2",
-    "eslint": "10.8.1",
-    "eslint-config-typed": "5.10.0",
-    "eslint-plugin-ts-data-forge": "0.5.0",
-    "eslint-plugin-ts-fortress": "1.0.4",
-    "eslint-plugin-ts-type-forge": "0.7.0",
+    "eslint": "10.9.1",
+    "eslint-config-typed": "5.11.7",
+    "eslint-plugin-ts-data-forge": "0.7.4",
+    "eslint-plugin-ts-fortress": "1.2.2",
+    "eslint-plugin-ts-type-forge": "0.8.3",
     "jiti": "2.7.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.4",
-    "ts-repo-utils": "10.3.2",
-    "tsx": "4.23.12",
+    "ts-repo-utils": "10.6.2",
+    "tsx": "4.23.13",
     "typedoc": "0.28.20",
     "typedoc-github-theme": "0.4.0",
     "typescript": "6.0.3",
     "typescript-native": "npm:typescript@7.0.2",
-    "vite": "8.2.1",
-    "vitest": "4.1.11"
+    "vite": "8.2.2",
+    "vitest": "5.0.0"
   },
   "engines": {
     "node": ">=22.22.2",
     "pnpm": ">=9.0.0"
   },
   "volta": {
-    "node": "26.3.1"
+    "node": "26.8.1"
   },
   "publishConfig": {
     "access": "public",
@@ -95,6 +94,7 @@
     "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:embed:jsdoc": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/embed-examples-in-jsdoc.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 .",

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

@@ -15,6 +15,7 @@ import {
   type StrictExtract,
 } from 'ts-type-forge';
 import {
+  hasCallOrConstructSignature,
   hasDisableNextLineComment,
   isAtomicTypeNode,
   isConditionalTypeDistributionGuard,
@@ -1032,10 +1033,24 @@ const transformTypeLiteralNode = (
     return;
   }
 
+  // Whether this position is one where the literal is wrapped at all — a
+  // context that already carries `Readonly` or `DeepReadonly` does it, and
+  // inside an indexed access the modifier makes no difference to the result.
+  const wrappingApplies =
+    readonlyContext.type === 'none' && readonlyContext.indexedAccessDepth === 0;
+
+  // A call or construct signature does not survive `Readonly<T>`, so a literal
+  // carrying one is left unwrapped and marked readonly member by member
+  // instead. See `hasCallOrConstructSignature`.
+  const skipWrapping = wrappingApplies && hasCallOrConstructSignature(node);
+
   // Recursive processing
   transformMembers(
     node.getMembers(),
-    'remove',
+    // A wrapper — the one added below, or the one the context already carries —
+    // is what makes the members readonly, so an inner modifier would be
+    // redundant. Without one, each member has to say so itself.
+    skipWrapping ? 'add' : 'remove',
     nextReadonlyContext({
       currentReadonlyContext: readonlyContext,
       nextReadonlyContextType: 'none',
@@ -1044,18 +1059,9 @@ const transformTypeLiteralNode = (
     options,
   );
 
-  switch (readonlyContext.type) {
-    case 'DeepReadonly':
-    case 'Readonly':
-      // Don't wrap with Readonly if already readonly
-      return;
-
-    case 'none': {
-      if (readonlyContext.indexedAccessDepth === 0) {
-        // `{ readonly x: X, readonly y: Y } |-> Readonly<{ x: X, y: Y }>`
-        options.replaceNode(node, `Readonly<${node.getFullText()}>`);
-      }
-    }
+  if (wrappingApplies && !skipWrapping) {
+    // `{ readonly x: X, readonly y: Y } |-> Readonly<{ x: X, y: Y }>`
+    options.replaceNode(node, `Readonly<${node.getFullText()}>`);
   }
 };
 

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

@@ -6,6 +6,7 @@ import dedent from 'dedent';
 import * as prettierPluginEstree from 'prettier/plugins/estree';
 import * as prettierPluginTypeScript from 'prettier/plugins/typescript';
 import * as prettier from 'prettier/standalone';
+import { isString } from 'ts-data-forge';
 import {
   convertToReadonlyTransformer,
   type ReadonlyTransformerOptions,
@@ -63,7 +64,15 @@ const normalizeWhitespaceForComparison = (code: string): string => {
   // 1. Protect newlines immediately following line comments
   const protectedCode = code.replaceAll(
     /(\/\/.*?)\r?\n/gu,
-    (_match, comment: string) => `${comment}${placeholder}`,
+    // The strict standard library types a capture group as `unknown`: an
+    // optional group is `undefined` when it does not participate, so `string`
+    // is not something the signature can promise. This group is not optional,
+    // so the narrowing never actually fails — it just has to be written.
+    (match: string, ...args: readonly unknown[]): string => {
+      const comment = args[0];
+
+      return isString(comment) ? `${comment}${placeholder}` : match;
+    },
   );
 
   // 2. Collapse multiple whitespace characters (including unprotected newlines) into a single space
@@ -3246,6 +3255,125 @@ describe(convertToReadonlyTransformer, () => {
     ])('$name', testFn);
   });
 
+  describe('Call and construct signatures', () => {
+    // `Readonly<T>` is a mapped type over `keyof T`, and a call or construct
+    // signature is not a property, so wrapping a type literal that carries one
+    // silently drops it — the value stops being callable. See #1881.
+    test.each([
+      {
+        name: 'Overloaded call signatures are not wrapped',
+        source: dedent`
+          const panic: {
+            (message: string, options?: { cause?: unknown }): never;
+            (error: Error): never;
+          } = impl;
+        `,
+        expected: dedent`
+          const panic: {
+            (message: string, options?: Readonly<{ cause?: unknown }>): never;
+            (error: Error): never;
+          } = impl;
+        `,
+      },
+      {
+        name: 'A single call signature is not wrapped',
+        source: dedent`
+          type F = { (arg: number[]): string[] };
+        `,
+        expected: dedent`
+          type F = { (arg: readonly number[]): readonly string[] };
+        `,
+      },
+      {
+        name: 'A construct signature is not wrapped',
+        source: dedent`
+          type C = { new (arg: string[]): { prop: number[] } };
+        `,
+        expected: dedent`
+          type C = { new (arg: readonly string[]): Readonly<{ prop: readonly number[] }> };
+        `,
+      },
+      {
+        name: 'Members alongside a call signature are marked readonly in place',
+        source: dedent`
+          type F = {
+            (arg: number[]): void;
+            prop: string[];
+            [key: string]: unknown;
+          };
+        `,
+        expected: dedent`
+          type F = {
+            (arg: readonly number[]): void;
+            readonly prop: readonly string[];
+            readonly [key: string]: unknown;
+          };
+        `,
+      },
+      {
+        name: 'Members alongside a construct signature are marked readonly in place',
+        source: dedent`
+          type C = {
+            new (arg: string[]): unknown;
+            readonly prop: number[];
+          };
+        `,
+        expected: dedent`
+          type C = {
+            new (arg: readonly string[]): unknown;
+            readonly prop: readonly number[];
+          };
+        `,
+      },
+      {
+        name: 'A callable type literal in a union is left alone',
+        source: dedent`
+          type T = { (): void } | { a: number[] };
+        `,
+        expected: dedent`
+          type T = { (): void } | Readonly<{ a: readonly number[] }>;
+        `,
+      },
+      {
+        name: 'A callable type literal in an intersection is left alone',
+        source: dedent`
+          type T = { (): void } & { a: number[] };
+        `,
+        expected: dedent`
+          type T = { (): void } & Readonly<{ a: readonly number[] }>;
+        `,
+      },
+      {
+        name: 'A nested callable type literal is left alone',
+        source: dedent`
+          type T = { fn: { (): void }; a: number[] };
+        `,
+        expected: dedent`
+          type T = Readonly<{ fn: { (): void }; a: readonly number[] }>;
+        `,
+      },
+    ])('$name', testFn);
+
+    test('a callable type literal reaches a fixed point', () => {
+      const code = dedent`
+        const panic: {
+          (message: string, options?: { cause?: unknown }): never;
+          (error: Error): never;
+        } = impl;
+      `;
+
+      const once = transformSourceCode(code, false, [
+        convertToReadonlyTransformer(),
+      ]);
+
+      const twice = transformSourceCode(once, false, [
+        convertToReadonlyTransformer(),
+      ]);
+
+      expect(twice).toBe(once);
+    });
+  });
+
   describe('Generic Types', () => {
     test.each([
       {

package/src/functions/ast-transformers/enable-no-unchecked-indexed-access.mts

@@ -37,17 +37,40 @@ const TRANSFORMER_NAME = 'enable-no-unchecked-indexed-access';
  * as the `if` of `const v = xs[0]!; if (v === undefined) …` now is.
  *
  * @example
+ *
  * ```ts
- * declare const xs: readonly number[];
- * declare const pair: readonly [number, number];
- * declare const rec: Record<string, number>;
- * declare const known: { a: number };
+ * const before = dedent`
+ *   declare const xs: readonly number[];
+ *   declare const pair: readonly [number, number];
+ *   declare const rec: Record<string, number>;
+ *   declare const known: { a: number };
+ *
+ *   xs[0].toFixed();
+ *   rec['a'].toFixed();
+ *   rec.a.toFixed();
+ *   pair[1].toFixed();
+ *   known.a.toFixed();
+ * `;
+ *
+ * const after = transformSourceCode(before, false, [
+ *   enableNoUncheckedIndexedAccessTransformer(),
+ * ]);
+ *
+ * assert.deepStrictEqual(
+ *   after.trim(),
+ *   dedent`
+ *     declare const xs: readonly number[];
+ *     declare const pair: readonly [number, number];
+ *     declare const rec: Record<string, number>;
+ *     declare const known: { a: number };
  *
- * xs[0].toFixed(); // -> xs[0]!.toFixed();
- * rec['a'].toFixed(); // -> rec['a']!.toFixed();
- * rec.a.toFixed(); // -> rec.a!.toFixed();
- * pair[1].toFixed(); // -> pair[1].toFixed(); (guaranteed to exist)
- * known.a.toFixed(); // -> known.a.toFixed(); (guaranteed to exist)
+ *     xs[0]!.toFixed();
+ *     rec['a']!.toFixed();
+ *     rec.a!.toFixed();
+ *     pair[1].toFixed();
+ *     known.a.toFixed();
+ *   `,
+ * );
  * ```
  */
 export const enableNoUncheckedIndexedAccessTransformer = (