ts-codemod-lib 3.4.4 → 3.5.0

package/dist/functions/utils/replace-node-with-text.d.mts

@@ -0,0 +1,21 @@
+import type * as tsm from 'ts-morph';
+/**
+ * `node.replaceWithText(newNodeText)`, sparing a one-line text the indentation
+ * lookup.
+ *
+ * `replaceWithText` writes the text through a writer whose indentation it
+ * looks up first, for the lines after the first one, and the lookup reparses
+ * the whole file in the language service: on top of the reparse every
+ * replacement makes anyway, once per replacement, so it is quadratic in the
+ * size of the file. A text with no `\n` has no line after the first, the
+ * indentation is never applied, and a plain writer from the same project
+ * writes the same text — so the lookup is skipped. A multi-line text takes
+ * the original path.
+ *
+ * The writer is passed as `replaceWithText`'s second argument, which its
+ * declaration leaves out and ts-morph passes itself when it sets an
+ * expression. Were it ever dropped, the method would look the indentation up
+ * as before: slower, never different.
+ */
+export declare const replaceNodeWithText: (node: tsm.Node, newNodeText: string) => tsm.Node;
+//# sourceMappingURL=replace-node-with-text.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"replace-node-with-text.d.mts","sourceRoot":"","sources":["../../../src/functions/utils/replace-node-with-text.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,GAAG,MAAM,UAAU,CAAC;AAErC;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB,SACxB,GAAG,CAAC,IAAI,eACD,MAAM,KAClB,GAAG,CAAC,IAOA,CAAC"}

package/dist/functions/utils/replace-node-with-text.mjs

@@ -0,0 +1,22 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const replaceNodeWithText = (node, newNodeText) => newNodeText.includes('\n')
+    ? node.replaceWithText(newNodeText)
+    : node.replaceWithText.call(node, newNodeText, node.getProject().createWriter());
+//# sourceMappingURL=replace-node-with-text.mjs.map

package/dist/functions/utils/replace-node-with-text.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"replace-node-with-text.mjs","sourceRoot":"","sources":["../../../src/functions/utils/replace-node-with-text.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CACjC,IAAc,EACd,WAAmB,EACT,EAAE,CACZ,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC;IACxB,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC;IACnC,CAAC,CAAE,IAAI,CAAC,eAA6C,CAAC,IAAI,CACtD,IAAI,EACJ,WAAW,EACX,IAAI,CAAC,UAAU,EAAE,CAAC,YAAY,EAAE,CACjC,CAAC"}

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,SAC9B,GAAG,CAAC,IAAI,eACD,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;AAGrC,eAAO,MAAM,yBAAyB,SAC9B,GAAG,CAAC,IAAI,eACD,MAAM,KAClB,IAIF,CAAC"}

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

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

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"replace-with-debug.mjs","sourceRoot":"","sources":["../../../src/functions/utils/replace-with-debug.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAEnE,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,mBAAmB,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;AACzC,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-codemod-lib",
-  "version": "3.4.4",
+  "version": "3.5.0",
   "private": false,
   "keywords": [
     "typescript",
@@ -38,7 +38,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "ts-data-forge": "^14.7.1",
+    "ts-data-forge": "^14.8.0",
     "ts-morph": "^28.0.0",
     "ts-type-forge": "^9.2.2"
   },
@@ -51,10 +51,10 @@
     "dedent": "1.7.2",
     "esbuild": "0.28.2",
     "eslint": "10.12.0",
-    "eslint-config-typed": "5.18.0",
-    "eslint-plugin-ts-data-forge": "0.8.6",
-    "eslint-plugin-ts-fortress": "1.3.3",
-    "eslint-plugin-ts-type-forge": "0.8.8",
+    "eslint-config-typed": "5.19.0",
+    "eslint-plugin-ts-data-forge": "0.9.0",
+    "eslint-plugin-ts-fortress": "1.3.4",
+    "eslint-plugin-ts-type-forge": "0.8.9",
     "jiti": "2.7.0",
     "npm-run-all2": "9.0.3",
     "playwright": "1.64.0",
@@ -75,7 +75,7 @@
     "pnpm": ">=9.0.0"
   },
   "volta": {
-    "node": "26.11.1"
+    "node": "26.12.0"
   },
   "publishConfig": {
     "access": "public",
@@ -86,11 +86,11 @@
     "check:cspell": "cspell \"**\" --gitignore --gitignore-root ../../ --no-progress",
     "check:dist": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/check-dist.mts",
     "check:ext": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/check-ext.mts",
-    "check:lint": "oxlint . && eslint .",
-    "check:test": "pnpm run z:vitest:node run",
-    "check:test:browser": "pnpm run z:vitest --project='Browser' run",
-    "check:test:cov": "pnpm run z:vitest:node run --coverage",
-    "check:types": "node ../../node_modules/typescript-native/bin/tsc --noEmit",
+    "check:lint": "node ../../tools/scripts/cmd/assert-deps-built.mts && oxlint . && eslint .",
+    "check:test": "node ../../tools/scripts/cmd/assert-deps-built.mts && pnpm run z:vitest:node run",
+    "check:test:browser": "node ../../tools/scripts/cmd/assert-deps-built.mts && pnpm run z:vitest --project='Browser' run",
+    "check:test:cov": "node ../../tools/scripts/cmd/assert-deps-built.mts && pnpm run z:vitest:node run --coverage",
+    "check:types": "node ../../tools/scripts/cmd/assert-deps-built.mts && node ../../node_modules/typescript-native/bin/tsc --noEmit",
     "check-all": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/check-all.mts",
     "clean": "pnpm run /clean:.*/",
     "clean:logs": "npx rimraf ./*.log",
@@ -102,7 +102,7 @@
     "fix:fmt": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/format-uncommitted.mts --cwd .",
     "fix:fmt:diff": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/format-diff-from.mts origin/main --cwd .",
     "fix:fmt:full": "prettier --write .",
-    "fix:lint": "oxlint . --fix && eslint . --fix",
+    "fix:lint": "node ../../tools/scripts/cmd/assert-deps-built.mts && oxlint . --fix && eslint . --fix",
     "fmt": "pnpm run fix:fmt",
     "gen": "run-s gen:index gen:readme gen:jsdoc",
     "gen:index": "run-s gen:index:src fix:fmt",

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

@@ -5,7 +5,10 @@ import {
   hasDisableNextLineComment,
   isAsConstNode,
 } from '../functions/index.mjs';
-import { replaceNodeWithDebugPrint } from '../utils/index.mjs';
+import {
+  replaceNodeWithDebugPrint,
+  replaceNodeWithText,
+} from '../utils/index.mjs';
 import type { TsMorphTransformer } from './types.mjs';
 
 const TRANSFORMER_NAME = 'append-as-const';
@@ -27,7 +30,7 @@ export const appendAsConstTransformer = (
     replaceNode:
       options?.debug === true
         ? replaceNodeWithDebugPrint
-        : (node, newNodeText) => node.replaceWithText(newNodeText),
+        : (node, newNodeText) => replaceNodeWithText(node, newNodeText),
   } as const;
 
   return {
@@ -319,7 +322,7 @@ const transformNode = (
 
     options.debugPrint(`${node.getText()} -> ${asConstText}`);
 
-    transformNode(node.replaceWithText(asConstText), context, options);
+    transformNode(replaceNodeWithText(node, asConstText), context, options);
 
     return;
   }

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

@@ -3,6 +3,7 @@
 import { Arr } from 'ts-data-forge';
 import type * as tsm from 'ts-morph';
 import { hasDisableNextLineComment } from '../functions/index.mjs';
+import { replaceNodeWithText } from '../utils/index.mjs';
 import type { TsMorphTransformer } from './types.mjs';
 
 const TRANSFORMER_NAME = 'convert-interface-to-type';
@@ -91,7 +92,7 @@ export const convertInterfaceToTypeTransformer = (): TsMorphTransformer =>
         const typeAliasText =
           `${jsDocText}${exportKeyword}type ${interfaceName}${typeParamsStr} = ${mut_typeBody};` as const;
 
-        interfaceDecl.replaceWithText(typeAliasText);
+        replaceNodeWithText(interfaceDecl, typeAliasText);
       };
 
       const buildTypeLiteral = (

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

@@ -29,7 +29,10 @@ import {
   wrapWithParentheses,
   type ReadonlyTypeReferenceNode,
 } from '../functions/index.mjs';
-import { replaceNodeWithDebugPrint } from '../utils/index.mjs';
+import {
+  replaceNodeWithDebugPrint,
+  replaceNodeWithText,
+} from '../utils/index.mjs';
 import {
   groupUnionIntersectionTypes,
   invalidDeepReadonlyTypeName,
@@ -72,7 +75,7 @@ export const convertToReadonlyTransformer = (
     replaceNode:
       options?.debug === true
         ? replaceNodeWithDebugPrint
-        : (node, newNodeText) => node.replaceWithText(newNodeText),
+        : (node, newNodeText) => replaceNodeWithText(node, newNodeText),
   } as const;
 
   return {

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

@@ -7,9 +7,7 @@ import * as prettierPluginEstree from 'prettier/plugins/estree';
 import * as prettierPluginTypeScript from 'prettier/plugins/typescript';
 import * as prettier from 'prettier/standalone';
 import { expectType } from 'ts-data-forge';
-// Aliased: an import named `DeepReadonly` makes `vitest/prefer-describe-function-title`
-// rewrite `describe('DeepReadonly', ...)` into a reference to this type.
-import type { DeepReadonly as TsTypeForgeDeepReadonly } from 'ts-type-forge';
+import type { DeepReadonly } from 'ts-type-forge';
 import {
   convertToReadonlyTransformer,
   type ReadonlyTransformerOptions,
@@ -3090,34 +3088,25 @@ describe(convertToReadonlyTransformer, () => {
       type B = Readonly<{ b: string[] }>;
 
       // `|` commutes with DeepReadonly, so merging a union is safe.
-      expectType<
-        TsTypeForgeDeepReadonly<A | B>,
-        TsTypeForgeDeepReadonly<A> | TsTypeForgeDeepReadonly<B>
-      >('=');
+      expectType<DeepReadonly<A | B>, DeepReadonly<A> | DeepReadonly<B>>('=');
 
-      expectType<
-        TsTypeForgeDeepReadonly<F | X>,
-        TsTypeForgeDeepReadonly<F> | TsTypeForgeDeepReadonly<X>
-      >('=');
+      expectType<DeepReadonly<F | X>, DeepReadonly<F> | DeepReadonly<X>>('=');
 
       expectType<
-        TsTypeForgeDeepReadonly<readonly string[] | X>,
-        TsTypeForgeDeepReadonly<readonly string[]> | TsTypeForgeDeepReadonly<X>
+        DeepReadonly<readonly string[] | X>,
+        DeepReadonly<readonly string[]> | DeepReadonly<X>
       >('=');
 
       // `&` does not: an intersection is tested as a whole and matches every
       // branch any one member matches. `F & X` hits the function branch and
       // comes back unchanged, leaving `x` mutable.
-      expectType<TsTypeForgeDeepReadonly<F & X>, F & X>('=');
+      expectType<DeepReadonly<F & X>, F & X>('=');
 
-      expectType<
-        TsTypeForgeDeepReadonly<F & X>,
-        TsTypeForgeDeepReadonly<F> & TsTypeForgeDeepReadonly<X>
-      >('!=');
+      expectType<DeepReadonly<F & X>, DeepReadonly<F> & DeepReadonly<X>>('!=');
 
       expectType<
-        TsTypeForgeDeepReadonly<readonly string[] & X>,
-        TsTypeForgeDeepReadonly<readonly string[]> & TsTypeForgeDeepReadonly<X>
+        DeepReadonly<readonly string[] & X>,
+        DeepReadonly<readonly string[]> & DeepReadonly<X>
       >('!=');
 
       // `Readonly` over type literals does commute with `&`, which is what

package/src/functions/ast-transformers/replace-any-with-unknown.mts

@@ -4,6 +4,7 @@ import {
   isSpreadNamedTupleMemberNode,
   isSpreadParameterNode,
 } from '../functions/index.mjs';
+import { replaceNodeWithText } from '../utils/index.mjs';
 import type { TsMorphTransformer } from './types.mjs';
 
 const TRANSFORMER_NAME = 'replace-any-with-unknown';
@@ -37,12 +38,12 @@ const transformNode = (node: tsm.Node): void => {
         // `[name: E0, ...args: any)]` -> `[name: E0, ...args: unknown[]]`
         isSpreadNamedTupleMemberNode(parent))
     ) {
-      anyKeywordNode.replaceWithText('readonly unknown[]');
+      replaceNodeWithText(anyKeywordNode, 'readonly unknown[]');
 
       return;
     }
 
-    anyKeywordNode.replaceWithText('unknown');
+    replaceNodeWithText(anyKeywordNode, 'unknown');
 
     return;
   }

package/src/functions/ast-transformers/replace-record-with-unknown-record.mts

@@ -2,6 +2,7 @@
 import { Arr } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
 import { hasDisableNextLineComment } from '../functions/index.mjs';
+import { replaceNodeWithText } from '../utils/index.mjs';
 import type { TsMorphTransformer } from './types.mjs';
 
 const TRANSFORMER_NAME = 'replace-record-with-unknown-record';
@@ -88,7 +89,8 @@ const processInterfaceDeclaration = (
 
     const interfaceName = interfaceDecl.getName();
 
-    interfaceDecl.replaceWithText(
+    replaceNodeWithText(
+      interfaceDecl,
       `${exportPrefix}type ${interfaceName} = UnknownRecord;`,
     );
 
@@ -128,7 +130,7 @@ const visitTypeNode = (node: tsm.TypeNode): boolean => {
             Arr.isFixedLengthArray(1, indexSigs) &&
             isStringUnknownIndexSignature(indexSigs[0])
           ) {
-            node.replaceWithText('UnknownRecord');
+            replaceNodeWithText(node, 'UnknownRecord');
 
             return true;
           }
@@ -156,7 +158,7 @@ const visitTypeNode = (node: tsm.TypeNode): boolean => {
       Arr.isFixedLengthArray(1, indexSigs) &&
       isStringUnknownIndexSignature(indexSigs[0])
     ) {
-      node.replaceWithText('UnknownRecord');
+      replaceNodeWithText(node, 'UnknownRecord');
 
       return true;
     }
@@ -229,7 +231,7 @@ const replaceIfRecordUnknown = (node: tsm.TypeReferenceNode): boolean => {
         typeArgs[0].getText() === 'string' &&
         typeArgs[1].getText() === 'unknown'
       ) {
-        node.replaceWithText('UnknownRecord');
+        replaceNodeWithText(node, 'UnknownRecord');
 
         return true;
       }
@@ -255,7 +257,7 @@ const replaceIfRecordUnknown = (node: tsm.TypeReferenceNode): boolean => {
               innerTypeArgs[0].getText() === 'string' &&
               innerTypeArgs[1].getText() === 'unknown'
             ) {
-              node.replaceWithText('UnknownRecord');
+              replaceNodeWithText(node, 'UnknownRecord');
 
               return true;
             }

package/src/functions/functions/has-disable-next-line-comment.mts

@@ -1,3 +1,4 @@
+import { Arr } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
 import { IGNORE_LINE_COMMENT_PREFIXES } from '../constants/index.mjs';
 
@@ -19,16 +20,22 @@ export const hasDisableNextLineComment = (
   node: tsm.Node,
   transformerName?: string,
 ): boolean => {
-  const nodeStartLine = node.getStartLineNumber();
+  // Most nodes have no leading comment, and then nothing below can match.
+  // Asking first spares them the line numbers, the costly part.
+  const leadingCommentRanges = node.getLeadingCommentRanges();
 
-  // Cannot be ignored if it's on the first line
-  if (nodeStartLine <= 1) {
+  if (Arr.isEmpty(leadingCommentRanges)) {
     return false;
   }
 
-  const sourceFile = node.getSourceFile(); // Get the SourceFile
+  const lineNumberAt = lineNumberLookup(node.getSourceFile().compilerNode);
 
-  const leadingCommentRanges = node.getLeadingCommentRanges();
+  const nodeStartLine = lineNumberAt(node.getStart());
+
+  // Cannot be ignored if it's on the first line
+  if (nodeStartLine <= 1) {
+    return false;
+  }
 
   // Iterate backwards through comments as the closest one is most relevant
   for (let mut_i = leadingCommentRanges.length - 1; mut_i >= 0; mut_i--) {
@@ -38,7 +45,7 @@ export const hasDisableNextLineComment = (
     // Get the end position and convert it to line number
     const commentEndPos = commentRange.getEnd();
 
-    const commentEndLine = sourceFile.getLineAndColumnAtPos(commentEndPos).line;
+    const commentEndLine = lineNumberAt(commentEndPos);
 
     // Check if the comment is on the immediately preceding line
     if (nodeStartLine === commentEndLine + 1) {
@@ -91,3 +98,69 @@ export const hasDisableNextLineComment = (
 
   return false;
 };
+
+/**
+ * The 1-based line number of a position in `sourceFile`, counted the way
+ * ts-morph's `getStartLineNumber` and `getLineAndColumnAtPos` count it: one
+ * plus the number of `\n` before the position (a lone `\r` starts no line,
+ * unlike in the compiler's own line map).
+ *
+ * ts-morph scans the text from its start on every call, which made this
+ * check, asked of every node a transformer visits, quadratic in the size of
+ * the file. The newline positions are collected once per compiler source file
+ * instead. ts-morph replaces that object whenever the file is edited, so an
+ * entry never outlives the text it was collected from.
+ */
+const lineNumberLookup = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  sourceFile: tsm.ts.SourceFile,
+): ((pos: number) => number) => {
+  const cached = newlinePositionsCache.get(sourceFile);
+
+  const newlinePositions = cached ?? newlinePositionsOf(sourceFile.text);
+
+  if (cached === undefined) {
+    newlinePositionsCache.set(sourceFile, newlinePositions);
+  }
+
+  return (pos) => countLessThan(newlinePositions, pos) + 1;
+};
+
+const newlinePositionsCache = new WeakMap<
+  tsm.ts.SourceFile,
+  readonly number[]
+>();
+
+const newlinePositionsOf = (text: string): readonly number[] => {
+  const mut_positions: number[] = [];
+
+  for (
+    let mut_index = text.indexOf('\n');
+    mut_index !== -1;
+    mut_index = text.indexOf('\n', mut_index + 1)
+  ) {
+    mut_positions.push(mut_index);
+  }
+
+  return mut_positions;
+};
+
+/** The number of elements of the ascending `sorted` that are below `value`. */
+const countLessThan = (sorted: readonly number[], value: number): number => {
+  let mut_low = 0;
+
+  let mut_high = sorted.length;
+
+  while (mut_low < mut_high) {
+    const mid = Math.floor((mut_low + mut_high) / 2);
+
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    if (sorted[mid]! < value) {
+      mut_low = mid + 1;
+    } else {
+      mut_high = mid;
+    }
+  }
+
+  return mut_low;
+};

package/src/functions/functions/has-disable-next-line-comment.test.mts

@@ -0,0 +1,96 @@
+import * as tsm from 'ts-morph';
+import { hasDisableNextLineComment } from './has-disable-next-line-comment.mjs';
+
+/** The first type alias in `source`, the node every case asks about. */
+const typeAliasOf = (source: string): tsm.TypeAliasDeclaration => {
+  const project = new tsm.Project({ useInMemoryFileSystem: true });
+
+  return project
+    .createSourceFile('source.ts', source)
+    .getFirstDescendantByKindOrThrow(tsm.SyntaxKind.TypeAliasDeclaration);
+};
+
+describe(hasDisableNextLineComment, () => {
+  test.each([
+    {
+      name: 'a comment on the line above (LF)',
+      source: '// transformer-ignore-next-line\ntype A = number[];\n',
+      expected: true,
+    },
+    {
+      name: 'a comment on the line above (CRLF)',
+      source: '// transformer-ignore-next-line\r\ntype A = number[];\r\n',
+      expected: true,
+    },
+    {
+      name: 'a comment two lines above',
+      source: '// transformer-ignore-next-line\n\ntype A = number[];\n',
+      expected: false,
+    },
+    {
+      name: 'a comment two lines above (CRLF)',
+      source: '// transformer-ignore-next-line\r\n\r\ntype A = number[];\r\n',
+      expected: false,
+    },
+    {
+      name: 'a later comment on the line above shadows an earlier ignore comment',
+      source:
+        '// transformer-ignore-next-line\n// something else\ntype A = number[];\n',
+      expected: false,
+    },
+    {
+      name: 'the node on the first line',
+      source: 'type A = number[];\n',
+      expected: false,
+    },
+    {
+      name: 'the node on the first line after a block comment',
+      source: '/* transformer-ignore-next-line */ type A = number[];\n',
+      expected: false,
+    },
+    {
+      name: 'a lone CR, which does not count as a line break',
+      source: '// transformer-ignore-next-line\rtype A = number[];\n',
+      expected: false,
+    },
+    {
+      name: 'a lone CR before the comment, deep in the file',
+      source:
+        'const x = 1;\r\nconst y = 2;\r// transformer-ignore-next-line\ntype A = number[];\n',
+      expected: true,
+    },
+    {
+      name: 'a node far below many lines',
+      source: `${'const x = 1;\n'.repeat(500)}// transformer-ignore-next-line\ntype A = number[];\n`,
+      expected: true,
+    },
+  ])('$name', ({ source, expected }) => {
+    expect(hasDisableNextLineComment(typeAliasOf(source))).toBe(expected);
+  });
+
+  test('matches the transformer name list', () => {
+    const node = typeAliasOf(
+      '// transformer-ignore-next-line append-as-const, convert-to-readonly\ntype A = number[];\n',
+    );
+
+    assert.isTrue(hasDisableNextLineComment(node, 'convert-to-readonly'));
+
+    assert.isFalse(hasDisableNextLineComment(node, 'replace-any-with-unknown'));
+  });
+
+  test('reads the current text after the file has been edited', () => {
+    const node = typeAliasOf('type A = number[];\n');
+
+    assert.isFalse(hasDisableNextLineComment(node));
+
+    const sourceFile = node.getSourceFile();
+
+    sourceFile.insertText(0, '// transformer-ignore-next-line\n');
+
+    const edited = sourceFile.getFirstDescendantByKindOrThrow(
+      tsm.SyntaxKind.TypeAliasDeclaration,
+    );
+
+    assert.isTrue(hasDisableNextLineComment(edited));
+  });
+});

package/src/functions/utils/index.mts

@@ -1 +1,2 @@
+export * from './replace-node-with-text.mjs';
 export * from './replace-with-debug.mjs';

package/src/functions/utils/replace-node-with-text.mts

@@ -0,0 +1,37 @@
+import type * as tsm from 'ts-morph';
+
+/**
+ * `node.replaceWithText(newNodeText)`, sparing a one-line text the indentation
+ * lookup.
+ *
+ * `replaceWithText` writes the text through a writer whose indentation it
+ * looks up first, for the lines after the first one, and the lookup reparses
+ * the whole file in the language service: on top of the reparse every
+ * replacement makes anyway, once per replacement, so it is quadratic in the
+ * size of the file. A text with no `\n` has no line after the first, the
+ * indentation is never applied, and a plain writer from the same project
+ * writes the same text — so the lookup is skipped. A multi-line text takes
+ * the original path.
+ *
+ * The writer is passed as `replaceWithText`'s second argument, which its
+ * declaration leaves out and ts-morph passes itself when it sets an
+ * expression. Were it ever dropped, the method would look the indentation up
+ * as before: slower, never different.
+ */
+export const replaceNodeWithText = (
+  node: tsm.Node,
+  newNodeText: string,
+): tsm.Node =>
+  newNodeText.includes('\n')
+    ? node.replaceWithText(newNodeText)
+    : (node.replaceWithText as ReplaceWithTextWithWriter).call(
+        node,
+        newNodeText,
+        node.getProject().createWriter(),
+      );
+
+type ReplaceWithTextWithWriter = (
+  this: tsm.Node,
+  textOrWriterFunction: string,
+  writer: tsm.CodeBlockWriter,
+) => tsm.Node;