@onrails/codemod 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onrails/codemod",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Codemods for migrating onto @onrails/result (neverthrow → compat shim, and beyond)",
   "license": "MIT",
   "author": "Alan R. Soares",

package/src/ast.ts

@@ -21,8 +21,19 @@ export const concatCollectors =
 export const walkSource = (
   src: string,
   visit: (node: ts.Node, sf: ts.SourceFile) => unknown,
+  jsx = false,
 ): void => {
-  const sf = ts.createSourceFile("codemod.ts", src, ts.ScriptTarget.Latest, true);
+  // Parse JSX files in TSX mode — otherwise `<`/`>` are read as comparison
+  // operators and `<T>expr` as a cast, which truncates node boundaries and
+  // corrupts span-based edits. The scriptKind is set explicitly (not just via
+  // the filename) so it can't drift from the extension.
+  const sf = ts.createSourceFile(
+    jsx ? "codemod.tsx" : "codemod.ts",
+    src,
+    ts.ScriptTarget.Latest,
+    true,
+    jsx ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
+  );
   const go = (n: ts.Node) => {
     if (visit(n, sf)) return;
     ts.forEachChild(n, go);

package/src/chains.ts

@@ -213,28 +213,32 @@ export const applyEditStep = (acc: EditAcc, e: Edit): EditAcc => ({
   imports: new Set([...acc.imports, ...e.imports]),
 });
 
-export function rewriteCompatMethodChainsToNative(src: string): string {
+export function rewriteCompatMethodChainsToNative(src: string, jsx = false): string {
   const edits: Edit[] = [];
 
-  walkSource(src, (node, sf) => {
-    if (ts.isCallExpression(node)) {
-      const helper = helperCallToNative(node);
-      if (isSome(helper)) {
-        edits.push(spanEdit(node, sf, helper.value));
-        return true;
+  walkSource(
+    src,
+    (node, sf) => {
+      if (ts.isCallExpression(node)) {
+        const helper = helperCallToNative(node);
+        if (isSome(helper)) {
+          edits.push(spanEdit(node, sf, helper.value));
+          return true;
+        }
       }
-    }
 
-    if (
-      isSupportedChainCall(node) &&
-      !isNestedInSupportedChain(node) &&
-      !ts.isPropertyAccessExpression(node.parent)
-    ) {
-      const chain = collectChain(node);
-      const chained = chainToNative(chain.base, chain.steps);
-      if (isSome(chained)) edits.push(spanEdit(node, sf, chained.value));
-    }
-  });
+      if (
+        isSupportedChainCall(node) &&
+        !isNestedInSupportedChain(node) &&
+        !ts.isPropertyAccessExpression(node.parent)
+      ) {
+        const chain = collectChain(node);
+        const chained = chainToNative(chain.base, chain.steps);
+        if (isSome(chained)) edits.push(spanEdit(node, sf, chained.value));
+      }
+    },
+    jsx,
+  );
 
   if (edits.length === 0) return src;
 

package/src/cli.ts

@@ -3,7 +3,7 @@ import * as Maybe from "@onrails/maybe";
 import { match } from "@onrails/pattern";
 import { err, isErr, ok, type Result, ResultAsync } from "@onrails/result";
 import { Glob } from "bun";
-import { CODE_EXT, SKIP } from "./constants.js";
+import { CODE_EXT, JSX_EXT, SKIP } from "./constants.js";
 import { computeFileChange, toFileChange } from "./file-change.js";
 import { readFileText, writeFileText } from "./io.js";
 import { rewritePkg } from "./pkg.js";
@@ -64,7 +64,7 @@ const rewriteCode = (
 ): ResultAsync<Maybe.Maybe<FileChange>, Error> =>
   readFileText(path).flatMap((src) =>
     Maybe.match(
-      computeFileChange(src, mode),
+      computeFileChange(src, mode, JSX_EXT.test(path)),
       (c) => {
         const change = toFileChange(path, c);
         return c.changed && !dry

package/src/constants.ts

@@ -8,6 +8,7 @@ export const SKIP = new Set([
   "build",
 ]);
 export const CODE_EXT = /\.(ts|tsx|mts|cts)$/;
+export const JSX_EXT = /\.(tsx|jsx)$/;
 export const IMPORT_RE = /(from\s+|import\s*\(\s*)(['"])neverthrow\2/g;
 export const COMPAT_SPEC = "@onrails/result/compat/neverthrow";
 export const NATIVE_SPEC = "@onrails/result";

package/src/file-change.ts

@@ -1,25 +1,25 @@
 import { type Maybe, none, some } from "@onrails/maybe";
-import { flow } from "@onrails/result";
-import { concatCollectors, countOccurrences } from "./ast.js";
+import { countOccurrences } from "./ast.js";
 import { rewriteCompatMethodChainsToNative } from "./chains.js";
 import { COMPAT_SPEC, IMPORT_RE, NATIVE_SPEC } from "./constants.js";
 import { rewriteCompatImportsToNative } from "./imports.js";
 import { tersify } from "./tersify.js";
-import type { ComputedChange, FileChange, Mode, ModeStrategy } from "./types.js";
+import type { ComputedChange, FileChange, Mode, ModeStrategy, Warning } from "./types.js";
 import {
   collectNativeMigrationWarnings,
   collectUnsupportedCompatImportWarnings,
 } from "./warnings.js";
 
-const rewriteCompatToNative = flow(rewriteCompatImportsToNative, rewriteCompatMethodChainsToNative);
+const rewriteCompatToNative = (src: string, jsx: boolean): string =>
+  rewriteCompatMethodChainsToNative(rewriteCompatImportsToNative(src), jsx);
 
 const rewriteNeverthrowToCompat = (src: string): string =>
   src.replace(IMPORT_RE, (_, lead, quote) => `${lead}${quote}${COMPAT_SPEC}${quote}`);
 
-const collectAllNativeWarnings = concatCollectors(
-  collectUnsupportedCompatImportWarnings,
-  collectNativeMigrationWarnings,
-);
+const collectAllNativeWarnings = (next: string, jsx: boolean): readonly Warning[] => [
+  ...collectUnsupportedCompatImportWarnings(next),
+  ...collectNativeMigrationWarnings(next, jsx),
+];
 
 const MODES: Record<Mode, ModeStrategy> = {
   compat: {
@@ -45,13 +45,13 @@ const MODES: Record<Mode, ModeStrategy> = {
   },
 };
 
-export const computeFileChange = (src: string, mode: Mode): Maybe<ComputedChange> => {
+export const computeFileChange = (src: string, mode: Mode, jsx = false): Maybe<ComputedChange> => {
   const strat = MODES[mode];
   const before = strat.countBefore(src);
   if (strat.earlyExit(src, before)) return none();
-  const next = strat.transform(src);
+  const next = strat.transform(src, jsx);
   const changed = next !== src;
-  const warnings = strat.warnings(next);
+  const warnings = strat.warnings(next, jsx);
   return !changed && warnings.length === 0
     ? none()
     : some({ next, before, after: strat.countAfter(next), changed, warnings });

package/src/tersify.ts

@@ -422,29 +422,33 @@ const TRANSFORMS: ReadonlyArray<(node: ts.Node, sf: ts.SourceFile) => Maybe<Edit
   tryTersifyIdentityFilter,
 ];
 
-function tersifyOnce(src: string): string {
+function tersifyOnce(src: string, jsx: boolean): string {
   const edits: Edit[] = [];
   const skippedNodes = new Set<ts.Node>();
 
-  walkSource(src, (node, sf) => {
-    if (skippedNodes.has(node)) {
-      return true;
-    }
+  walkSource(
+    src,
+    (node, sf) => {
+      if (skippedNodes.has(node)) {
+        return true;
+      }
 
-    scanIfReturnSequences(node, sf, skippedNodes, edits);
-    scanIfToSwitchSequences(node, sf, skippedNodes, edits);
+      scanIfReturnSequences(node, sf, skippedNodes, edits);
+      scanIfToSwitchSequences(node, sf, skippedNodes, edits);
 
-    for (const transform of TRANSFORMS) {
-      const editResult = transform(node, sf);
-      if (editResult._tag === "Some") {
-        edits.push(editResult.value);
-        skippedNodes.add(node);
-        return true;
+      for (const transform of TRANSFORMS) {
+        const editResult = transform(node, sf);
+        if (editResult._tag === "Some") {
+          edits.push(editResult.value);
+          skippedNodes.add(node);
+          return true;
+        }
       }
-    }
 
-    return false;
-  });
+      return false;
+    },
+    jsx,
+  );
 
   if (edits.length === 0) return src;
 
@@ -455,11 +459,11 @@ function tersifyOnce(src: string): string {
   return next;
 }
 
-export function tersify(src: string): string {
+export function tersify(src: string, jsx = false): string {
   let current = src;
   let iterations = 0;
   while (iterations < 10) {
-    const next = tersifyOnce(current);
+    const next = tersifyOnce(current, jsx);
     if (next === current) {
       break;
     }

package/src/types.ts

@@ -24,8 +24,8 @@ export type ComputedChange = {
 export type ModeStrategy = {
   countBefore: (src: string) => number;
   earlyExit: (src: string, before: number) => boolean;
-  transform: (src: string) => string;
-  warnings: (next: string) => readonly Warning[];
+  transform: (src: string, jsx: boolean) => string;
+  warnings: (next: string, jsx: boolean) => readonly Warning[];
   countAfter: (next: string) => number;
 };
 

package/src/warnings.ts

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { concatCollectors, walkSource } from "./ast.js";
+import { walkSource } from "./ast.js";
 import { COMPAT_ONLY_PATTERNS, COMPAT_SPEC } from "./constants.js";
 import type { Warning } from "./types.js";
 
@@ -12,7 +12,7 @@ export const collectRegexLineWarnings = (src: string): readonly Warning[] =>
       ),
     );
 
-export const collectAstCompatWarnings = (src: string): readonly Warning[] => {
+export const collectAstCompatWarnings = (src: string, jsx = false): readonly Warning[] => {
   const warnings: Warning[] = [];
   const lines = src.split(/\r?\n/);
   const lineTextAt = (sf: ts.SourceFile, node: ts.Node) => {
@@ -20,32 +20,36 @@ export const collectAstCompatWarnings = (src: string): readonly Warning[] => {
     return { line, text: lines[line - 1]?.trim() ?? node.getText(sf) };
   };
 
-  walkSource(src, (node, sf) => {
-    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
-      const method = node.expression.name.text;
-      if (method === "isOk" || method === "isErr") {
-        warnings.push({ ...lineTextAt(sf, node), label: "compat predicate method" });
+  walkSource(
+    src,
+    (node, sf) => {
+      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+        const method = node.expression.name.text;
+        if (method === "isOk" || method === "isErr") {
+          warnings.push({ ...lineTextAt(sf, node), label: "compat predicate method" });
+        }
       }
-    }
 
-    if (ts.isPropertyAccessExpression(node)) {
-      const property = node.name.text;
-      if (property === "value" || property === "error") {
-        const receiver = node.expression.getText(sf);
-        if (/result$/i.test(receiver) || /^result$/i.test(receiver)) {
-          warnings.push({ ...lineTextAt(sf, node), label: "compat value/error property" });
+      if (ts.isPropertyAccessExpression(node)) {
+        const property = node.name.text;
+        if (property === "value" || property === "error") {
+          const receiver = node.expression.getText(sf);
+          if (/result$/i.test(receiver) || /^result$/i.test(receiver)) {
+            warnings.push({ ...lineTextAt(sf, node), label: "compat value/error property" });
+          }
         }
       }
-    }
-  });
+    },
+    jsx,
+  );
 
   return warnings;
 };
 
-export const collectNativeMigrationWarnings = concatCollectors(
-  collectRegexLineWarnings,
-  collectAstCompatWarnings,
-);
+export const collectNativeMigrationWarnings = (src: string, jsx = false): readonly Warning[] => [
+  ...collectRegexLineWarnings(src),
+  ...collectAstCompatWarnings(src, jsx),
+];
 
 export const collectUnsupportedCompatImportWarnings = (src: string): readonly Warning[] =>
   src.split(/\r?\n/).flatMap((line, i) =>