@mittwald/flow-codemods 1.2.17 → 1.2.18

package/README.md

@@ -131,5 +131,6 @@ npx @mittwald/flow-codemods@latest to-remote-package src
 
 `0` on success, `1` on a refusal — dirty tree, unresolvable revision, failed
 install, an unknown id, or an id whose migration has no codemod — and `1` when a
-codemod reports an error, is declined for every file it looked at, or found
-nothing under `path` to process.
+codemod reports an error, found nothing under `path` to process, or declined
+every file it looked at. "Every" means every: a decline among files the
+transform did read is a per-file fact, not a failed run.

package/dist/cli/codemod.js

@@ -78,14 +78,19 @@ export const runSingleCodemod = async (parsed, { cwd, log, run = runCodemod }) =
     }
     // The same trap as `processedNothing`, one field over: a transform that
     // declines a file by returning nothing counts as `skipped`, not `unmodified`.
-    // If every file was skipped and none changed, "0 file(s) changed" would read
+    // If every file was declined and none changed, "0 file(s) changed" would read
     // as a clean no-op run when in fact the transform bailed on everything.
-    if (result.changed === 0 && result.skipped > 0) {
+    //
+    // "All" means all: `unmodified > 0` says the transform read those files and
+    // handed them back, so a decline among them is a per-file fact, not a failed
+    // run.
+    if (result.changed === 0 && result.unmodified === 0 && result.skipped > 0) {
         log(`${id}: the transform declined all ${result.skipped} file(s) it looked at, and changed none.`);
         return 1;
     }
     const skipped = result.skipped > 0 ? `, ${result.skipped} skipped` : "";
-    const summary = `${id}: ${result.changed} file(s) changed, ${result.unmodified} unchanged${skipped}.`;
+    const empty = result.empty > 0 ? `, ${result.empty} empty` : "";
+    const summary = `${id}: ${result.changed} file(s) changed, ${result.unmodified} unchanged${skipped}${empty}.`;
     // Only a catalogued id has a migration guide entry to point at — a transform
     // like `to-remote-package` with no catalogue entry has no anchor in
     // `MIGRATION.md` to link, so pointing there would be a dead link.

package/dist/cli/upgrade.js

@@ -168,9 +168,9 @@ export const runUpgrade = async (parsed, deps) => {
         if (result.changed > 0) {
             changedCount += 1;
         }
-        // Same three-way distinction as the single-codemod command: "0 changed" on
-        // its own would read as success where nothing was looked at, or where the
-        // transform declined everything it saw.
+        // Same three-way distinction as the single-codemod command, and the same
+        // reading of "declined all": `unmodified > 0` proves the transform read
+        // files and handed them back, so it did not bail on the tree.
         if (result.errors > 0) {
             hadFailure = true;
             log(`  ${entry.id}: ${result.errors} file(s) failed to transform`);
@@ -179,7 +179,9 @@ export const runUpgrade = async (parsed, deps) => {
             hadFailure = true;
             log(`  ${entry.id}: no files under ${path} were processed`);
         }
-        else if (result.changed === 0 && result.skipped > 0) {
+        else if (result.changed === 0 &&
+            result.unmodified === 0 &&
+            result.skipped > 0) {
             hadFailure = true;
             log(`  ${entry.id}: declined all ${result.skipped} file(s) it looked at`);
         }

package/dist/run/jscodeshift.d.ts

@@ -16,8 +16,15 @@ export interface CodemodOptions {
 export interface CodemodResult {
     changed: number;
     unmodified: number;
-    /** Files the transform declined by returning nothing. */
+    /**
+     * Files the transform declined by returning nothing — empty ones excluded.
+     *
+     * Both come back from jscodeshift as `skip`. A caller may report this field
+     * as "the transform bailed on these"; it must not report `empty` that way.
+     */
     skipped: number;
+    /** Files with no content, which no transform can do anything with. */
+    empty: number;
     errors: number;
     /** True when jscodeshift accounted for no file at all — see below. */
     processedNothing: boolean;

package/dist/run/jscodeshift.js

@@ -1,4 +1,5 @@
-import { existsSync } from "node:fs";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { extname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { unknownCodemodMessage } from "../catalog/entries.js";
 // jscodeshift ships no types for its Runner — `allowJs` in this repo's shared
@@ -54,6 +55,61 @@ const transformPath = (id) => findTransform(id) ?? `${packageRoot}src/tools/${id
  * module's own `existsSync` check below.
  */
 export const transformExists = (id) => existsSync(transformPath(id));
+/**
+ * The extensions the walk takes, and the directories it stays out of.
+ *
+ * Both are handed to jscodeshift below — without them its walk takes every file
+ * under the path, and since `upgrade` runs codemods after the install,
+ * `node_modules` is freshly populated underneath; non-JS files then fail to
+ * parse, which shows up as `errors > 0` and hides the real change count.
+ *
+ * `emptySourceFiles` reads the same two constants so that its walk and
+ * jscodeshift's agree by construction.
+ */
+const extensions = ["js", "jsx", "ts", "tsx", "cjs", "mjs", "cts", "mts"];
+const ignoredDirectories = ["node_modules", "dist", ".git"];
+const sourceExtensions = new Set(extensions.map((extension) => `.${extension}`));
+const ignoredDirectorySet = new Set(ignoredDirectories);
+/**
+ * How many source files under `path` hold nothing at all.
+ *
+ * Jscodeshift's worker tests a transform's result for truthiness
+ * (`updateStatus(out ? 'nochange' : 'skip', file)`), and on an empty file both
+ * `root.toSource()` and `fileInfo.source` are `""` — so an empty file lands in
+ * `skip`, indistinguishable there from a transform that declined it.
+ *
+ * Counted with a walk of our own rather than filtered out of jscodeshift's
+ * input: this number only ever explains a count. If the two walks disagree, the
+ * worst outcome is a slightly wrong explanation, never a file that should have
+ * been transformed and was not.
+ */
+const emptySourceFiles = (path) => {
+    let found = 0;
+    const visit = (candidate) => {
+        let stats;
+        try {
+            stats = statSync(candidate);
+        }
+        catch {
+            // A broken symlink or a file removed mid-walk. jscodeshift skips these
+            // too ("Skipping path … which does not exist").
+            return;
+        }
+        if (stats.isDirectory()) {
+            for (const child of readdirSync(candidate)) {
+                if (!ignoredDirectorySet.has(child)) {
+                    visit(join(candidate, child));
+                }
+            }
+            return;
+        }
+        if (stats.size === 0 && sourceExtensions.has(extname(candidate))) {
+            found += 1;
+        }
+    };
+    visit(path);
+    return found;
+};
 /**
  * Runs one codemod over a path.
  *
@@ -105,21 +161,22 @@ export const runCodemod = async ({ id, path, dry = false, print = false, }) => {
             silent: true,
             dry,
             print,
-            // Without these the walk takes every file under the path. `upgrade` runs
-            // codemods after the install, so `node_modules` is freshly populated
-            // underneath — and non-JS files fail to parse, which shows up as
-            // `errors > 0` and hides the real change count.
-            extensions: "js,jsx,ts,tsx,cjs,mjs,cts,mts",
-            ignorePattern: ["**/node_modules/**", "**/dist/**", "**/.git/**"],
+            extensions: extensions.join(","),
+            ignorePattern: ignoredDirectories.map((name) => `**/${name}/**`),
         }));
     }
     catch (error) {
         throw new Error(`Running ${id} failed: ${error instanceof Error ? error.message : error}`, { cause: error });
     }
+    // Clamped rather than subtracted outright: the two walks are independent, so
+    // a file that appeared or emptied between them must not push `skipped` below
+    // zero.
+    const empty = Math.min(emptySourceFiles(path), stats.skip);
     return {
         changed: stats.ok,
         unmodified: stats.nochange,
-        skipped: stats.skip,
+        skipped: stats.skip - empty,
+        empty,
         errors: stats.error,
         processedNothing: stats.ok + stats.nochange + stats.skip + stats.error === 0,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mittwald/flow-codemods",
-  "version": "1.2.17",
+  "version": "1.2.18",
   "type": "module",
   "description": "Codemods and an upgrade CLI for consumers of Flow, mittwald's design system",
   "homepage": "https://flow.mittwald.de",
@@ -38,5 +38,5 @@
     "vitest": "^4.1.11",
     "yaml": "^2.8.1"
   },
-  "gitHead": "069b32e72bac3917e27c54e9df65046f6c91ddeb"
+  "gitHead": "f5f05b9f490f10b0f4b1298efc7c8bf8fa8be555"
 }