@mittwald/flow-codemods 1.1.0 → 1.1.2

package/dist/migrations/password-tools-rule/transform.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Replaces `AsyncRule` and `SyncRule` with `Rule` (alpha.802).
+ *
+ * `@mittwald/password-tools-js` merged both classes into a single abstract
+ * `Rule`, and the `mittwald-password-tools-js` entry stopped re-exporting the
+ * old names. A custom rule extends `Rule` and may return its result
+ * synchronously or as a promise — the distinction the two classes encoded is
+ * gone, so both names collapse onto the same one.
+ *
+ * Only names imported from the `mittwald-password-tools-js` entry of
+ * `@mittwald/flow-react-components` are touched, so a same-named import from
+ * another package is left alone. `@mittwald/flow-remote-react-components` has
+ * no such entry. A name imported under a local alias (`import { AsyncRule as
+ * Base }`) keeps its alias — only the imported name changes. Namespace usages
+ * (`Pw.AsyncRule`) are rewritten as well.
+ *
+ * Because both names collapse onto `Rule`, a file importing more than one of
+ * them would end up with a duplicate specifier. Those collapse onto one.
+ */
+const passwordToolsRuleTransform = (fileInfo, { j }) => {
+    const flowPackages = [
+        "@mittwald/flow-react-components/mittwald-password-tools-js",
+    ];
+    const renames = new Map([
+        ["AsyncRule", "Rule"],
+        ["SyncRule", "Rule"],
+    ]);
+    const isFlowImport = (source) => flowPackages.includes(source);
+    // ast-types models `importKind` on the declaration only, while babel also
+    // puts it on the specifier — which is where a per-specifier `type X` lives.
+    const isTypeOnly = (specifier) => specifier.importKind === "type";
+    const makeValueImport = (specifier) => {
+        specifier.importKind = "value";
+    };
+    const root = j(fileInfo.source, { parser: "tsx" });
+    /** Local identifiers that refer to a renamed export, mapped to the new name. */
+    const localRenames = new Map();
+    /**
+     * Whether any import specifier was rewritten. An aliased `Align as Row` adds
+     * nothing to `localRenames` — its local name stays `Row` — so counting those
+     * alone would treat an alias-only file as untouched and discard the rewrite.
+     */
+    let renamedAnImport = false;
+    /** Local names of `import * as Flow` namespace imports from a Flow package. */
+    const flowNamespaces = new Set();
+    const flowImports = root
+        .find(j.ImportDeclaration)
+        .filter((path) => isFlowImport(String(path.node.source.value)));
+    /**
+     * `imported:local` pairs the file already binds without a rename. A rename
+     * that lands on one of these must not add a second specifier for it — the
+     * name is available from the import that already carries it, which is also
+     * the entry that really exports it.
+     */
+    const claimed = new Set();
+    flowImports.forEach((path) => {
+        for (const specifier of path.node.specifiers ?? []) {
+            if (specifier.type === "ImportNamespaceSpecifier" &&
+                specifier.local?.name) {
+                flowNamespaces.add(String(specifier.local.name));
+                continue;
+            }
+            if (specifier.type !== "ImportSpecifier" ||
+                specifier.imported.type !== "Identifier" ||
+                renames.has(specifier.imported.name)) {
+                continue;
+            }
+            claimed.add(`${specifier.imported.name}:${String(specifier.local?.name ?? specifier.imported.name)}`);
+        }
+    });
+    flowImports.forEach((path) => {
+        const specifiers = path.node.specifiers ?? [];
+        const survivors = [];
+        for (const specifier of specifiers) {
+            if (specifier.type !== "ImportSpecifier" ||
+                specifier.imported.type !== "Identifier") {
+                survivors.push(specifier);
+                continue;
+            }
+            const imported = specifier.imported.name;
+            const renamed = renames.get(imported);
+            if (!renamed) {
+                survivors.push(specifier);
+                continue;
+            }
+            const local = String(specifier.local?.name ?? imported);
+            const isAlias = local !== imported;
+            const newLocal = isAlias ? local : renamed;
+            const key = `${renamed}:${newLocal}`;
+            renamedAnImport = true;
+            if (!isAlias) {
+                // An aliased import keeps its local name and needs no further change.
+                localRenames.set(local, renamed);
+            }
+            // Renaming can collide with a name the file already binds — directly, or
+            // because a second old name maps onto the same new one. Either way the
+            // binding already exists, so this specifier goes away instead of
+            // producing a duplicate declaration, which would not parse.
+            const collision = claimed.has(key);
+            claimed.add(key);
+            if (collision) {
+                // A value import must not lose out to a type-only one.
+                if (!isTypeOnly(specifier)) {
+                    for (const kept of survivors) {
+                        if (kept.type === "ImportSpecifier" &&
+                            kept.imported.type === "Identifier" &&
+                            `${kept.imported.name}:${String(kept.local?.name ?? kept.imported.name)}` === key) {
+                            makeValueImport(kept);
+                        }
+                    }
+                }
+                continue;
+            }
+            // Mutate in place so an `import type` / `type X` modifier survives.
+            specifier.imported.name = renamed;
+            if (!isAlias && specifier.local) {
+                specifier.local.name = renamed;
+            }
+            survivors.push(specifier);
+        }
+        if (survivors.length === specifiers.length) {
+            return;
+        }
+        // Every specifier moved to an import that already binds the name. Leaving
+        // the declaration behind would turn it into a side-effect import of an
+        // entry the file no longer uses.
+        if (survivors.length === 0) {
+            j(path).remove();
+            return;
+        }
+        path.node.specifiers = survivors;
+    });
+    if (!renamedAnImport && flowNamespaces.size === 0) {
+        return fileInfo.source;
+    }
+    /**
+     * `JSXIdentifier` extends `Identifier`, so this one pass covers JSX tags,
+     * value references and type references alike. Positions where the name is not
+     * a reference to the import — an object key, a member's property, a JSX
+     * attribute name — are skipped.
+     */
+    root.find(j.Identifier).forEach((path) => {
+        const parent = path.parent.node;
+        const isNamespaceMember = (parent.type === "MemberExpression" ||
+            parent.type === "JSXMemberExpression") &&
+            parent.property === path.node;
+        if (isNamespaceMember) {
+            const object = parent.object;
+            if (object.type === "Identifier" || object.type === "JSXIdentifier") {
+                const renamed = renames.get(path.node.name);
+                if (renamed && flowNamespaces.has(String(object.name))) {
+                    path.node.name = renamed;
+                }
+            }
+            return;
+        }
+        if (parent.type === "ImportSpecifier" ||
+            parent.type === "JSXAttribute" ||
+            ((parent.type === "ObjectProperty" || parent.type === "Property") &&
+                parent.key === path.node &&
+                !parent.computed)) {
+            return;
+        }
+        const renamed = localRenames.get(path.node.name);
+        if (renamed) {
+            path.node.name = renamed;
+        }
+    });
+    return root.toSource();
+};
+exports.default = passwordToolsRuleTransform;

package/dist/migrations/password-tools-subpath-renamed/transform.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const oldPath = "@mittwald/flow-react-components/password-tools";
+const newPath = "@mittwald/flow-react-components/mittwald-password-tools-js";
+/**
+ * Rewrites the module specifier
+ * `@mittwald/flow-react-components/password-tools` to
+ * `@mittwald/flow-react-components/mittwald-password-tools-js` (alpha.1000).
+ *
+ * Every form that names a module is covered: `import`, `import type`, `export …
+ * from`, a side-effect import, `import()` and `require()`. Only that exact
+ * specifier is touched — a deeper path under it never existed, so there is
+ * nothing to prefix-match and no risk of rewriting an unrelated
+ * `password-tools` of someone else's.
+ */
+const passwordToolsSubpathRenamedTransform = (fileInfo, { j }) => {
+    const root = j(fileInfo.source, { parser: "tsx" });
+    let changed = false;
+    const rewrite = (node) => {
+        if (node.value === oldPath) {
+            node.value = newPath;
+            changed = true;
+        }
+    };
+    // import … from "…", export … from "…", import "…"
+    root.find(j.ImportDeclaration).forEach((path) => rewrite(path.node.source));
+    root
+        .find(j.ExportNamedDeclaration)
+        .forEach((path) => path.node.source && rewrite(path.node.source));
+    root
+        .find(j.ExportAllDeclaration)
+        .forEach((path) => rewrite(path.node.source));
+    // import("…") and require("…")
+    root
+        .find(j.CallExpression)
+        .filter((path) => {
+        const callee = path.node.callee;
+        return (callee.type === "Import" ||
+            (callee.type === "Identifier" && callee.name === "require"));
+    })
+        .forEach((path) => {
+        const [argument] = path.node.arguments;
+        if (argument &&
+            (argument.type === "StringLiteral" || argument.type === "Literal")) {
+            rewrite(argument);
+        }
+    });
+    // Returning the source untouched keeps this file out of the "changed" count.
+    return changed ? root.toSource() : fileInfo.source;
+};
+exports.default = passwordToolsSubpathRenamedTransform;

package/dist/migrations.generated.js

@@ -145,7 +145,7 @@ export const migrations = [
         kind: "migration",
         action: "manual",
         remotePackage: true,
-        apply: "Check every `CodeBlock` usage against the current props (see the [CodeBlock documentation](https://flow.mittwald.de/04-components/content/code-block/overview)) and remove or replace props the new implementation does not support.",
+        apply: "Check every `CodeBlock` usage against the current props (see the [CodeBlock documentation](https://flow.mittwald.de/components/content/code-block)) and remove or replace props the new implementation does not support.",
     },
     {
         id: "muted-action-error-to-abort-action-error",

package/dist/run/jscodeshift.d.ts

@@ -36,7 +36,10 @@ export interface CodemodResult {
  * `processedNothing` exists because jscodeshift reports a path with no matching
  * files and a worker that died before touching one the same way: every counter
  * zero, no error. The caller must not render that as "0 files changed", which
- * reads like success.
+ * reads like success. The load check below removes the most common cause of the
+ * second case, so `processedNothing` now means the path far more often than it
+ * used to — but not always: a worker can still die for a reason a successful
+ * load does not predict, so the flag keeps its deliberately vague name.
  */
 export declare const runCodemod: ({ id, path, dry, print, }: CodemodOptions) => Promise<CodemodResult>;
 //# sourceMappingURL=jscodeshift.d.ts.map

package/dist/run/jscodeshift.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jscodeshift.d.ts","sourceRoot":"","sources":["../../src/run/jscodeshift.ts"],"names":[],"mappings":"AAuCA;;;;;GAKG;AACH,eAAO,MAAM,eAAe,OAAQ,MAAM,KAAG,OACd,CAAC;AAEhC,MAAM,WAAW,cAAc;IAC7B,sEAAsE;IACtE,EAAE,EAAE,MAAM,CAAC;IACX,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,yDAAyD;IACzD,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,sEAAsE;IACtE,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAUD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,UAAU,8BAKpB,cAAc,KAAG,OAAO,CAAC,aAAa,CAoCxC,CAAC"}
+{"version":3,"file":"jscodeshift.d.ts","sourceRoot":"","sources":["../../src/run/jscodeshift.ts"],"names":[],"mappings":"AAwDA;;;;;GAKG;AACH,eAAO,MAAM,eAAe,OAAQ,MAAM,KAAG,OACd,CAAC;AAEhC,MAAM,WAAW,cAAc;IAC7B,sEAAsE;IACtE,EAAE,EAAE,MAAM,CAAC;IACX,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,yDAAyD;IACzD,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,sEAAsE;IACtE,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAUD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,UAAU,8BAKpB,cAAc,KAAG,OAAO,CAAC,aAAa,CA6DxC,CAAC"}

package/dist/run/jscodeshift.js

@@ -1,5 +1,5 @@
 import { existsSync } from "node:fs";
-import { fileURLToPath } from "node:url";
+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
 // tsconfig (packages/typescript-config/base.json) lets a deep import of a
@@ -8,30 +8,45 @@ import { unknownCodemodMessage } from "../catalog/entries.js";
 // directive").
 import { run as runJscodeshift } from "jscodeshift/src/Runner.js";
 /**
- * `<packageRoot>/src/migrations` and `<packageRoot>/src/tools`, from either
- * `src/run` or `dist/run`.
- *
- * `dist` mirrors `src`'s directory depth, so one pair of relative paths serves
- * the test run and the published binary. The transforms are not compiled into
- * `dist`: jscodeshift puts a transform through its own babel pipeline, so it
- * wants the `.ts` file.
+ * The package root, from either `src/run` or `dist/run` — both are two levels
+ * down, so one expression serves the test run and the published binary.
  */
-const migrationsDir = fileURLToPath(new URL("../../src/migrations", import.meta.url));
-const toolsDir = fileURLToPath(new URL("../../src/tools", import.meta.url));
+const packageRoot = fileURLToPath(new URL("../../", import.meta.url));
 /**
- * The transform file for `id`: `src/migrations/<id>/transform.ts` when `id`
- * names a migration, otherwise `src/tools/<id>.ts`.
+ * Where a transform for `id` may live, most preferred first.
+ *
+ * The compiled CommonJS in `dist` comes first, and in a published install it is
+ * the only one that works. jscodeshift's worker `require()`s this path; it
+ * installs `@babel/register` beforehand, but babel-register's `only` defaults
+ * to the current working directory, so a transform inside the consumer's
+ * `node_modules` is never claimed by babel. Node's own `.ts` handler takes over
+ * and refuses — `ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`, no opt-out — and
+ * every codemod dies before touching a file. See `tsconfig.transforms.json`.
+ *
+ * The `.ts` sources stay as a fallback for running out of the repo (`tsx`, the
+ * unit tests, `dist` not built yet), where cwd _is_ inside the package and
+ * babel-register does claim them. They are no longer published: `files` ships
+ * `dist` only, so the path that cannot work is absent from the tarball rather
+ * than merely deprioritised.
  *
- * Deliberately independent of the catalogue: `to-remote-package` is a transform
- * with no catalogue entry (it is a port, not a migration — see `notAMigration`
- * in `src/tests/remoteScope.test.ts`), and it still has to be runnable by id.
- * It lives in `src/tools` rather than `src/migrations` for exactly that reason
- * — there is no migration directory to put it beside.
+ * `src/tools` is searched alongside `src/migrations` because
+ * `to-remote-package` is a transform with no catalogue entry (a port, not a
+ * migration — see `notAMigration` in `src/tests/remoteScope.test.ts`) and still
+ * has to be runnable by id.
  */
-const transformPath = (id) => {
-    const migrationPath = `${migrationsDir}/${id}/transform.ts`;
-    return existsSync(migrationPath) ? migrationPath : `${toolsDir}/${id}.ts`;
-};
+const candidatePaths = (id) => [
+    `${packageRoot}dist/migrations/${id}/transform.js`,
+    `${packageRoot}dist/tools/${id}.js`,
+    `${packageRoot}src/migrations/${id}/transform.ts`,
+    `${packageRoot}src/tools/${id}.ts`,
+];
+/** The transform file for `id`, or `undefined` when no candidate exists. */
+const findTransform = (id) => candidatePaths(id).find((candidate) => existsSync(candidate));
+/**
+ * The transform file for `id`, falling back to the last candidate so callers
+ * that only report a path still have one to name.
+ */
+const transformPath = (id) => findTransform(id) ?? `${packageRoot}src/tools/${id}.ts`;
 /**
  * Whether `id` names a transform file on disk.
  *
@@ -53,13 +68,36 @@ export const transformExists = (id) => existsSync(transformPath(id));
  * `processedNothing` exists because jscodeshift reports a path with no matching
  * files and a worker that died before touching one the same way: every counter
  * zero, no error. The caller must not render that as "0 files changed", which
- * reads like success.
+ * reads like success. The load check below removes the most common cause of the
+ * second case, so `processedNothing` now means the path far more often than it
+ * used to — but not always: a worker can still die for a reason a successful
+ * load does not predict, so the flag keeps its deliberately vague name.
  */
 export const runCodemod = async ({ id, path, dry = false, print = false, }) => {
     const transform = transformPath(id);
     if (!existsSync(transform)) {
         throw new Error(unknownCodemodMessage(id));
     }
+    // Load the transform here, in this process, before handing its path to
+    // jscodeshift.
+    //
+    // A worker that cannot load the transform dies before it touches a file, and
+    // the Runner then resolves with every counter at zero — indistinguishable
+    // from a path that matched nothing (see `processedNothing`). The stack trace
+    // goes to the worker's stderr, where the summary line the caller prints
+    // contradicts it by guessing at the path instead. Loading it up front turns
+    // that class of failure into a thrown error naming the real cause, which is
+    // the only way a caller can tell "this migration got no run at all" from
+    // "this migration had nothing to do".
+    //
+    // Safe to do: every shipped transform imports nothing but types, so loading
+    // one has no side effects and costs a file read.
+    try {
+        await import(pathToFileURL(transform).href);
+    }
+    catch (error) {
+        throw new Error(`${id} could not be loaded from ${transform}: ${error instanceof Error ? error.message : error}`, { cause: error });
+    }
     let stats;
     try {
         stats = (await runJscodeshift(transform, [path], {

package/dist/tools/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/tools/to-remote-package.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Ports imports from `@mittwald/flow-react-components` to
+ * `@mittwald/flow-remote-react-components`.
+ *
+ * Not a migration: no version range calls for it, so it has no catalogue entry
+ * (see `notAMigration` in `src/tests/remoteScope.test.ts`) and lives outside
+ * `src/migrations`, in `src/tools` alongside any other transform the CLI runs
+ * by id without a matching entry. It is still resolved and run the same way a
+ * migration's `transform.ts` is — `transformExists`/`runCodemod` in
+ * `src/run/jscodeshift.ts` fall back to this directory when an id names no
+ * migration.
+ */
+const toRemotePackageTransform = (fileInfo, { j }) => {
+    const flowPackage = "@mittwald/flow-react-components";
+    const root = j(fileInfo.source, {
+        parser: "ts",
+    });
+    root
+        .find(j.ImportDeclaration)
+        .filter((i) => String(i.node.source.value).startsWith(flowPackage))
+        .forEach((i) => {
+        const importPath = String(i.node.source.value);
+        i.node.source.value = importPath.replace(flowPackage, "@mittwald/flow-remote-react-components");
+    });
+    return root.toSource();
+};
+exports.default = toRemotePackageTransform;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mittwald/flow-codemods",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "type": "module",
   "description": "Codemods and an upgrade CLI for consumers of Flow, mittwald's design system",
   "homepage": "https://flow.mittwald.de",
@@ -9,15 +9,13 @@
     "flow-codemods": "dist/cli.js"
   },
   "files": [
-    "dist",
-    "src/migrations/**/transform.ts",
-    "src/tools/to-remote-package.ts"
+    "dist"
   ],
   "engines": {
     "node": ">=22.0.0"
   },
   "scripts": {
-    "build": "tsx dev/generateCli.ts && tsc -p tsconfig.build.json",
+    "build": "tsx dev/generateCli.ts && tsc -p tsconfig.build.json && tsx dev/buildTransforms.ts",
     "test:compile": "tsc --noEmit",
     "test:unit": "vitest run"
   },
@@ -38,5 +36,5 @@
     "vitest": "^4.1.11",
     "yaml": "^2.8.1"
   },
-  "gitHead": "3a17e79b1d0dcae9037add47eded28bbec98c038"
+  "gitHead": "82e51fc50883e0579996611df3d56bcc948cc2d8"
 }

package/src/migrations/accent-box-color-to-background-color/transform.ts

@@ -1,218 +0,0 @@
-import type { Transform } from "jscodeshift";
-
-/**
- * Moves the background value of `AccentBox` from `color` to `backgroundColor`
- * (alpha.786).
- *
- * `color` did not go away, it changed meaning: it used to set the background
- * (`"blue" | "green" | "gradient" | "neutral"`) and now sets the content color
- * (`"default" | "dark" | "light" | "dark-static" | "light-static"`). A blanket
- * rename would therefore break every element that already uses the new meaning.
- * The transform decides per value instead: a value from the new content-color
- * union stays on `color`, every other literal moves to `backgroundColor`.
- *
- * The scope is deliberately narrow. Only JSX elements that resolve to
- * `AccentBox` — imported (named or as a namespace) from
- * `@mittwald/flow-react-components` or
- * `@mittwald/flow-remote-react-components`, including their subpath entries —
- * are touched.
- *
- * Two cases are left alone, because both are undecidable without knowing the
- * value:
- *
- * - Values it cannot read (`color={expression}`), and expressions that mix both
- *   meanings (`color={flag ? "blue" : "dark"}`). The same expression means the
- *   background in old code and the content color in new code, and a mix has no
- *   single correct answer. An expression whose every value position is a
- *   literal on the same side of the split _is_ decidable and gets renamed:
- *   `color={flag ? "blue" : "green"}`.
- * - An element that already carries `backgroundColor`. Moving `color` there would
- *   silently overwrite the explicit value.
- *
- * Both keep their `color` prop and need a look by hand.
- */
-const accentBoxColorToBackgroundColorTransform: Transform = (
-  fileInfo,
-  { j },
-) => {
-  const flowPackages = [
-    "@mittwald/flow-react-components",
-    "@mittwald/flow-remote-react-components",
-  ];
-  const affectedComponents = new Set(["AccentBox"]);
-  /** Values `color` still accepts — everything else was a background color. */
-  const contentColors = new Set([
-    "default",
-    "dark",
-    "light",
-    "dark-static",
-    "light-static",
-  ]);
-
-  const isFlowImport = (source: string): boolean =>
-    flowPackages.some((pkg) => source === pkg || source.startsWith(`${pkg}/`));
-
-  /** The value of a string literal, or `undefined` for anything dynamic. */
-  const literalValue = (node: unknown): string | undefined => {
-    if (!node || typeof node !== "object" || !("type" in node)) {
-      return undefined;
-    }
-    const { type } = node as { type: string };
-    if (type !== "StringLiteral" && type !== "Literal") {
-      return undefined;
-    }
-    const { value } = node as { value?: unknown };
-    return typeof value === "string" ? value : undefined;
-  };
-
-  /**
-   * Every literal that could become this attribute's value, or `undefined` when
-   * any of those positions is something we cannot read. The positions are the
-   * expression itself, both ternary branches, and the operands of `??`/`||` —
-   * plus only the right operand of `&&`, since `&&` yields its left operand
-   * only when that operand is falsy and a non-empty string never is.
-   *
-   * A list, not a single value, because this transform decides per attribute,
-   * not per literal: `color={flag ? "blue" : "dark"}` mixes a background with a
-   * content colour, and no single rename is right for both.
-   */
-  const valueLiterals = (node: unknown): string[] | undefined => {
-    const literal = literalValue(node);
-    if (literal !== undefined) {
-      return [literal];
-    }
-    if (!node || typeof node !== "object" || !("type" in node)) {
-      return undefined;
-    }
-    const typed = node as {
-      type: string;
-      operator?: string;
-      consequent?: unknown;
-      alternate?: unknown;
-      left?: unknown;
-      right?: unknown;
-    };
-    if (typed.type === "ConditionalExpression") {
-      const consequent = valueLiterals(typed.consequent);
-      const alternate = valueLiterals(typed.alternate);
-      return consequent && alternate
-        ? [...consequent, ...alternate]
-        : undefined;
-    }
-    if (typed.type === "LogicalExpression") {
-      const right = valueLiterals(typed.right);
-      if (right === undefined) {
-        return undefined;
-      }
-      if (typed.operator === "&&") {
-        return right;
-      }
-      const left = valueLiterals(typed.left);
-      return left ? [...left, ...right] : undefined;
-    }
-    return undefined;
-  };
-
-  const root = j(fileInfo.source, { parser: "tsx" });
-
-  // Local JSX identifier -> canonical component name (resolves `as` aliases).
-  const localToComponent = new Map<string, string>();
-  // Local names of `import * as Flow` namespace imports from a Flow package.
-  const flowNamespaces = new Set<string>();
-
-  root
-    .find(j.ImportDeclaration)
-    .filter((path) => isFlowImport(String(path.node.source.value)))
-    .forEach((path) => {
-      for (const specifier of path.node.specifiers ?? []) {
-        if (
-          specifier.type === "ImportSpecifier" &&
-          specifier.imported.type === "Identifier" &&
-          affectedComponents.has(specifier.imported.name)
-        ) {
-          localToComponent.set(
-            String(specifier.local?.name ?? specifier.imported.name),
-            String(specifier.imported.name),
-          );
-        } else if (
-          specifier.type === "ImportNamespaceSpecifier" &&
-          specifier.local
-        ) {
-          flowNamespaces.add(String(specifier.local.name));
-        }
-      }
-    });
-
-  if (localToComponent.size === 0 && flowNamespaces.size === 0) {
-    return fileInfo.source;
-  }
-
-  root.find(j.JSXOpeningElement).forEach((path) => {
-    const name = path.node.name;
-
-    let isAffected = false;
-    if (name.type === "JSXIdentifier") {
-      isAffected = localToComponent.has(name.name);
-    } else if (
-      name.type === "JSXMemberExpression" &&
-      name.object.type === "JSXIdentifier" &&
-      name.property.type === "JSXIdentifier"
-    ) {
-      isAffected =
-        flowNamespaces.has(name.object.name) &&
-        affectedComponents.has(name.property.name);
-    }
-
-    if (!isAffected) {
-      return;
-    }
-
-    const attributes = path.node.attributes ?? [];
-
-    const isNamed = (attribute: unknown, key: string): boolean =>
-      !!attribute &&
-      typeof attribute === "object" &&
-      (attribute as { type?: string }).type === "JSXAttribute" &&
-      (attribute as { name?: { type?: string; name?: string } }).name?.type ===
-        "JSXIdentifier" &&
-      (attribute as { name?: { name?: string } }).name?.name === key;
-
-    // An explicit `backgroundColor` is the new API already — never overwrite it.
-    if (attributes.some((attribute) => isNamed(attribute, "backgroundColor"))) {
-      return;
-    }
-
-    for (const attribute of attributes) {
-      if (!isNamed(attribute, "color") || attribute.type !== "JSXAttribute") {
-        continue;
-      }
-
-      const value = attribute.value;
-
-      const literals =
-        value?.type === "JSXExpressionContainer"
-          ? valueLiterals(value.expression)
-          : valueLiterals(value);
-
-      if (literals === undefined || literals.length === 0) {
-        continue;
-      }
-
-      // All-or-nothing. Every value has to be a background colour for the
-      // rename to be right; all content colours means the element already uses
-      // the new meaning, and a mix has no single correct answer.
-      const backgrounds = literals.filter(
-        (literal) => !contentColors.has(literal),
-      );
-      if (backgrounds.length !== literals.length) {
-        continue;
-      }
-
-      attribute.name = j.jsxIdentifier("backgroundColor");
-    }
-  });
-
-  return root.toSource();
-};
-
-export default accentBoxColorToBackgroundColorTransform;