add-ts-expect-error 1.0.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2024 Steve Rodriguez
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,93 @@
+# add-ts-expect-error
+
+Adds a `@ts-expect-error` comment above every type error in a TypeScript project,
+with the error message inline.
+
+Useful when you turn on `strict` (or bump TypeScript) and get a few hundred errors
+at once: this gets the project compiling again and leaves each error documented in
+place, so you can work through them one file at a time.
+
+## Install
+
+```sh
+npm i -D add-ts-expect-error
+```
+
+Or run it once without installing:
+
+```sh
+npx add-ts-expect-error
+```
+
+## Usage
+
+Run it from the directory holding your `tsconfig.json`:
+
+```sh
+npx add-ts-expect-error
+```
+
+It reads that `tsconfig.json`, collects the diagnostics for every source file in the
+project, and rewrites the files in place. There are no flags.
+
+**It edits your files.** Commit or stash first.
+
+## What it does to your code
+
+Before:
+
+```ts
+const total: number = getTotal()
+```
+
+After:
+
+```ts
+// @ts-expect-error: FIX: Type 'string' is not assignable to type 'number'.
+const total: number = getTotal()
+```
+
+In JSX it uses the brace form, so the comment does not render as text:
+
+```tsx
+<div>
+  {/* @ts-expect-error: FIX: Type 'string' is not assignable to type 'number'. */}
+  <Widget count="not a number" />
+</div>
+```
+
+Details:
+
+- Comments are indented to match the line they annotate.
+- Only errors are commented. Warnings and suggestions are left alone.
+- When a line has more than one error, the comment reads
+  `Multiple errors, uncomment to see.` Remove the comment to see them all.
+- Lines that already carry the comment are skipped, so a second run does not stack
+  them up.
+
+## What it does not do
+
+- No flags, no config, no file or directory filtering. It processes the whole project.
+- It does not fix anything. Every comment it writes is a `FIX:` you still owe.
+- It does not reformat. Run your formatter afterward if the inserted lines bother it.
+
+## Why this exists
+
+Airbnb's [ts-migrate](https://github.com/airbnb/ts-migrate) has a `reignore` command
+that covers similar ground, as part of a larger JavaScript to TypeScript migration
+framework. This is the narrow version: one command, one job, no migration pipeline
+around it.
+
+## Development
+
+```sh
+npm install
+npm test
+npm run build
+```
+
+Tests are Vitest, including end to end runs against a temporary project on disk.
+
+## License
+
+ISC, Steve Rodriguez.

package/dist/Comment.d.ts

@@ -0,0 +1,23 @@
+import { Diagnostic, SourceFile } from "ts-morph";
+interface ConstructorParams {
+    lineNum: number;
+    lineDiagnostics: Diagnostic[];
+    sourceFile: SourceFile;
+}
+export declare class Comment {
+    private sourceFile;
+    private text?;
+    private lineNum;
+    constructor({ lineNum, lineDiagnostics, sourceFile }: ConstructorParams);
+    private generateTextFrom;
+    private getErrorDiagnostics;
+    private getDiagnosticMessagesFrom;
+    private getErrorMessage;
+    private checkIfInJSX;
+    private getNodeInfo;
+    private getLineNumFor;
+    hasTextAndAlreadyExists(lines: string[]): boolean;
+    getLineNum(): number;
+    getText(): string;
+}
+export {};

package/dist/Comment.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Comment = void 0;
+const ts_morph_1 = require("ts-morph");
+const utils_1 = require("./utils");
+class Comment {
+    constructor({ lineNum, lineDiagnostics, sourceFile }) {
+        this.sourceFile = sourceFile;
+        this.lineNum = lineNum;
+        const errorDiagnostics = this.getErrorDiagnostics(lineDiagnostics);
+        this.text = this.generateTextFrom(errorDiagnostics);
+    }
+    generateTextFrom(lineDiagnostics) {
+        if (lineDiagnostics.length === 0)
+            return;
+        const errorMessage = this.getErrorMessage(lineDiagnostics);
+        const startPosition = lineDiagnostics[0].getStart();
+        if (!startPosition)
+            return;
+        const inJSX = this.checkIfInJSX(startPosition);
+        return inJSX
+            ? `{/* @ts-expect-error: FIX: ${errorMessage} */}`
+            : `// @ts-expect-error: FIX: ${errorMessage}`;
+    }
+    getErrorDiagnostics(lineDiagnostics) {
+        return lineDiagnostics.filter((diagnostic) => diagnostic?.getCategory() === ts_morph_1.DiagnosticCategory.Error);
+    }
+    getDiagnosticMessagesFrom(lineDiagnostics) {
+        return lineDiagnostics.map((diagnostic) => {
+            const messageText = diagnostic.getMessageText();
+            return (0, utils_1.stringifyDiagnosticMessage)(messageText);
+        });
+    }
+    getErrorMessage(lineDiagnostics) {
+        const diagnosticMessages = this.getDiagnosticMessagesFrom(lineDiagnostics);
+        return diagnosticMessages.length > 1
+            ? "Multiple errors, uncomment to see."
+            : diagnosticMessages[0];
+    }
+    checkIfInJSX(startPosition) {
+        const startLineNum = this.getLineNumFor(startPosition);
+        let currentNode = this.sourceFile.getDescendantAtPos(startPosition);
+        let inAttribute = false;
+        while (currentNode) {
+            const { kind, currentLineNum } = this.getNodeInfo(currentNode);
+            if (currentLineNum === startLineNum) {
+                inAttribute || (inAttribute = (0, utils_1.isJsxAttributeOrSpread)(kind));
+            }
+            if (currentLineNum !== startLineNum) {
+                if (kind === ts_morph_1.SyntaxKind.JsxExpression)
+                    return false;
+                if (inAttribute && (0, utils_1.isJsxOpeningOrSelfClosing)(kind))
+                    return false;
+                if ((0, utils_1.isJsxElementOrFragment)(kind))
+                    return true;
+            }
+            currentNode = currentNode.getParent();
+        }
+        return false;
+    }
+    getNodeInfo(node) {
+        const kind = node.getKind();
+        const currentPos = node.getStart();
+        const currentLineNum = this.getLineNumFor(currentPos);
+        return { kind, currentLineNum };
+    }
+    getLineNumFor(position) {
+        return this.sourceFile.getLineAndColumnAtPos(position).line;
+    }
+    hasTextAndAlreadyExists(lines) {
+        if (!this.text)
+            return false;
+        const line = lines[this.lineNum];
+        const beginningOfText = this.text.trim().slice(0, 3);
+        return line?.trim().startsWith(beginningOfText) || false;
+    }
+    getLineNum() {
+        return this.lineNum;
+    }
+    getText() {
+        if (!this.text)
+            throw new Error("Comment text not found.");
+        return this.text;
+    }
+}
+exports.Comment = Comment;

package/dist/FileContent.d.ts

@@ -0,0 +1,16 @@
+import { SourceFile } from "ts-morph";
+export declare class FileContent {
+    private readonly sourceFile;
+    private readonly diagnosticsByLine;
+    private lines;
+    private newLineAddedOffset;
+    constructor(sourceFile: SourceFile);
+    private groupDiagnosticsByLine;
+    private getLines;
+    private getSortedDiagLineNums;
+    /** The leading whitespace of a line, so an inserted comment lines up with the code it annotates. */
+    private indentOf;
+    private insertComment;
+    private createComment;
+    generate(): string | undefined;
+}

package/dist/FileContent.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileContent = void 0;
+const Comment_1 = require("./Comment");
+const utils_1 = require("./utils");
+class FileContent {
+    constructor(sourceFile) {
+        this.sourceFile = sourceFile;
+        this.diagnosticsByLine = this.groupDiagnosticsByLine();
+        this.lines = this.getLines();
+        this.newLineAddedOffset = 0;
+    }
+    groupDiagnosticsByLine() {
+        const diagnostics = this.sourceFile.getPreEmitDiagnostics();
+        return diagnostics.reduce((map, diagnostic) => {
+            const pos = diagnostic.getStart();
+            if (!pos)
+                return map;
+            const { line } = this.sourceFile.getLineAndColumnAtPos(pos);
+            if (!map.has(line))
+                map.set(line, []);
+            map.get(line).push(diagnostic);
+            return map;
+        }, new Map());
+    }
+    getLines() {
+        const path = this.sourceFile.getFilePath();
+        const content = (0, utils_1.readFile)(path);
+        return content.split("\n");
+    }
+    getSortedDiagLineNums() {
+        return Array.from(this.diagnosticsByLine.keys()).sort((a, b) => a - b);
+    }
+    /** The leading whitespace of a line, so an inserted comment lines up with the code it annotates. */
+    indentOf(lineNum) {
+        return this.lines[lineNum]?.match(/^[ \t]*/)?.[0] ?? "";
+    }
+    insertComment(comment) {
+        const lineNum = comment.getLineNum();
+        const text = this.indentOf(lineNum) + comment.getText();
+        this.lines.splice(lineNum, 0, text);
+        this.newLineAddedOffset += 1;
+    }
+    createComment(diagnosticLineNum) {
+        const lineNum = diagnosticLineNum + this.newLineAddedOffset - 1;
+        const lineDiagnostics = this.diagnosticsByLine.get(diagnosticLineNum);
+        const sourceFile = this.sourceFile;
+        return new Comment_1.Comment({ lineNum, lineDiagnostics, sourceFile });
+    }
+    generate() {
+        const sortedDiagnosticLineNums = this.getSortedDiagLineNums();
+        for (const diagnosticLineNum of sortedDiagnosticLineNums) {
+            const comment = this.createComment(diagnosticLineNum);
+            if (comment.hasTextAndAlreadyExists(this.lines))
+                continue;
+            if (!comment.getText())
+                continue;
+            this.insertComment(comment);
+        }
+        return this.lines.join("\n");
+    }
+}
+exports.FileContent = FileContent;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const main_1 = require("./main");
+(0, main_1.main)();

package/dist/main.d.ts

@@ -0,0 +1 @@
+export declare function main(): void;

package/dist/main.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const path_1 = __importDefault(require("path"));
+const ts_morph_1 = require("ts-morph");
+const utils_1 = require("./utils");
+function main() {
+    const currentWorkingDir = process.cwd();
+    const tsConfigFilePath = path_1.default.resolve(currentWorkingDir, "tsconfig.json");
+    const project = new ts_morph_1.Project({ tsConfigFilePath });
+    const sourceFiles = project.getSourceFiles();
+    sourceFiles.forEach(utils_1.processSourceFile);
+    console.log("Added @ts-expect-error comments to all TypeScript errors.");
+}

package/dist/utils/file-util.d.ts

@@ -0,0 +1,2 @@
+export declare function readFile(filePath: string): string;
+export declare function writeFile(filePath: string, content: string): void;

package/dist/utils/file-util.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFile = readFile;
+exports.writeFile = writeFile;
+const fs_1 = __importDefault(require("fs"));
+function readFile(filePath) {
+    try {
+        return fs_1.default.readFileSync(filePath, "utf-8");
+    }
+    catch (error) {
+        console.error(`Error reading file ${filePath}:`, error);
+        throw error;
+    }
+}
+function writeFile(filePath, content) {
+    try {
+        fs_1.default.writeFileSync(filePath, content, "utf-8");
+    }
+    catch (error) {
+        console.error(`Error writing file ${filePath}:`, error);
+        throw error;
+    }
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./jsx-util";
+export * from "./file-util";
+export * from "./stringifyDiagnosticMessage";
+export * from "./processSourceFile";

package/dist/utils/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./jsx-util"), exports);
+__exportStar(require("./file-util"), exports);
+__exportStar(require("./stringifyDiagnosticMessage"), exports);
+__exportStar(require("./processSourceFile"), exports);

package/dist/utils/jsx-util.d.ts

@@ -0,0 +1,4 @@
+import { SyntaxKind } from "ts-morph";
+export declare function isJsxElementOrFragment(kind: SyntaxKind): boolean;
+export declare function isJsxAttributeOrSpread(kind: SyntaxKind): boolean;
+export declare function isJsxOpeningOrSelfClosing(kind: SyntaxKind): boolean;

package/dist/utils/jsx-util.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJsxElementOrFragment = isJsxElementOrFragment;
+exports.isJsxAttributeOrSpread = isJsxAttributeOrSpread;
+exports.isJsxOpeningOrSelfClosing = isJsxOpeningOrSelfClosing;
+const ts_morph_1 = require("ts-morph");
+function isJsxElementOrFragment(kind) {
+    return (kind === ts_morph_1.SyntaxKind.JsxElement ||
+        kind === ts_morph_1.SyntaxKind.JsxSelfClosingElement ||
+        kind === ts_morph_1.SyntaxKind.JsxFragment ||
+        kind === ts_morph_1.SyntaxKind.JsxOpeningElement ||
+        kind === ts_morph_1.SyntaxKind.JsxClosingElement ||
+        kind === ts_morph_1.SyntaxKind.JsxOpeningFragment ||
+        kind === ts_morph_1.SyntaxKind.JsxClosingFragment);
+}
+function isJsxAttributeOrSpread(kind) {
+    return (kind === ts_morph_1.SyntaxKind.JsxAttribute || kind === ts_morph_1.SyntaxKind.JsxSpreadAttribute);
+}
+function isJsxOpeningOrSelfClosing(kind) {
+    return (kind === ts_morph_1.SyntaxKind.JsxOpeningElement ||
+        kind === ts_morph_1.SyntaxKind.JsxSelfClosingElement);
+}

package/dist/utils/processSourceFile.d.ts

@@ -0,0 +1,2 @@
+import { SourceFile } from "ts-morph";
+export declare function processSourceFile(sourceFile: SourceFile): void;

package/dist/utils/processSourceFile.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processSourceFile = processSourceFile;
+const FileContent_1 = require("../FileContent");
+const file_util_1 = require("./file-util");
+function processSourceFile(sourceFile) {
+    const filePath = sourceFile.getFilePath();
+    const newContent = new FileContent_1.FileContent(sourceFile).generate();
+    if (!newContent)
+        return;
+    (0, file_util_1.writeFile)(filePath, newContent);
+}

package/dist/utils/stringifyDiagnosticMessage.d.ts

@@ -0,0 +1,2 @@
+import { DiagnosticMessageChain } from "ts-morph";
+export declare function stringifyDiagnosticMessage(diagnosticMessage: string | DiagnosticMessageChain): string;

package/dist/utils/stringifyDiagnosticMessage.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyDiagnosticMessage = stringifyDiagnosticMessage;
+function stringifyDiagnosticMessage(diagnosticMessage) {
+    if (isDiagnosticMessageChain(diagnosticMessage)) {
+        return stringifyDiagnosticMessageChain(diagnosticMessage);
+    }
+    return diagnosticMessage.toString();
+}
+function isDiagnosticMessageChain(message) {
+    return typeof message === "object" && "getMessageText" in message;
+}
+function stringifyDiagnosticMessageChain(diagnosticMessage) {
+    let messages = [extractMessageText(diagnosticMessage)];
+    let next = diagnosticMessage.getNext();
+    while (next && next.length > 0) {
+        messages.push(extractMessageText(next[0]));
+        next = next[0].getNext();
+    }
+    return messages.join(" ");
+}
+function extractMessageText(diagnosticMessage) {
+    return diagnosticMessage.getMessageText().toString();
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "add-ts-expect-error",
+  "version": "1.0.0",
+  "description": "Adds a @ts-expect-error comment above every type error in a TypeScript project, with the error message inline. JSX aware.",
+  "license": "ISC",
+  "author": "Steve Rodriguez",
+  "homepage": "https://github.com/steve-rodri/add-ts-expect-error#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/steve-rodri/add-ts-expect-error.git"
+  },
+  "bugs": {
+    "url": "https://github.com/steve-rodri/add-ts-expect-error/issues"
+  },
+  "keywords": [
+    "typescript",
+    "ts-expect-error",
+    "ts-ignore",
+    "codemod",
+    "cli",
+    "strict-mode",
+    "migration",
+    "jsx",
+    "tsx",
+    "ts-morph"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "add-ts-expect-error": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build && npm test",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "start": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "ts-morph": "^23.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.2.0",
+    "@vitest/ui": "^2.0.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.5.4",
+    "vitest": "^2.0.5"
+  },
+  "prettier": {
+    "semi": false
+  }
+}