@mittwald/flow-codemods 1.2.0-next.0 → 1.2.0-next.10

package/dist/install.js

@@ -1,38 +1,45 @@
 import { execFileSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-/** Lockfile to manager, in precedence order. */
-const lockfiles = [
-    ["pnpm-lock.yaml", "pnpm"],
-    // Both Bun lockfile names: `bun.lock` (text) is the default only from Bun
-    // 1.2; before that Bun writes the binary `bun.lockb`, which plenty of
-    // projects still have. Missing it would fall through to the npm default and
-    // run `npm install` on a Bun project, leaving a stray package-lock.json.
-    ["bun.lock", "bun"],
-    ["bun.lockb", "bun"],
-    ["yarn.lock", "yarn"],
-    ["package-lock.json", "npm"],
+import { satisfies, validRange } from "semver";
+import { resolveCommand } from "package-manager-detector/commands";
+import { INSTALL_PAGE } from "package-manager-detector/constants";
+import { detect } from "package-manager-detector/detect";
+/** Every strategy the library offers, in the order it applies them. */
+const strategies = [
+    "lockfile",
+    "packageManager-field",
+    "devEngines-field",
+    // Not in the library's default set. `upgrade` always runs on an installed
+    // project — it reads `node_modules` to learn the current Flow version — so the
+    // marker a manager leaves in there is a real signal, and the last one before
+    // the npm fallback.
+    "install-metadata",
 ];
+/** What a project with no signal at all gets. */
+const fallback = { name: "npm", agent: "npm" };
 /**
- * The package manager a project uses, from the lockfiles present.
+ * The package manager for the project at `cwd`.
  *
- * Npm is the fallback: it is the one manager that is always available next to
- * Node, so a project with no lockfile still gets an install rather than an
- * error.
+ * Detection walks **up** from `cwd`, which is the whole point: the previous
+ * implementation looked for lockfiles in `cwd` only, and a workspace package
+ * has none of its own. In a Yarn or pnpm monorepo it therefore fell through to
+ * the npm default and ran `npm install`, which on a workspace manifest dies
+ * with `EUNSUPPORTEDPROTOCOL Unsupported URL Type "workspace:"` — after
+ * `upgrade` had already rewritten `package.json`. It also ignored
+ * `packageManager` entirely.
+ *
+ * Per directory the strategies are applied in order, so a lockfile in `cwd`
+ * still beats a `packageManager` pin in a parent — and when the lockfile
+ * strategy hits, the library reads that same directory's `package.json` and
+ * lets its pin win. That is the precedence we want, and it is the library's,
+ * not ours.
+ *
+ * Npm on `null`, preserving the old fallback: it is the one manager always
+ * present next to Node, so a project with no signal gets an install rather than
+ * an error.
  */
-export const detectPackageManager = (present) => {
-    for (const [lockfile, manager] of lockfiles) {
-        if (present.includes(lockfile)) {
-            return manager;
-        }
-    }
-    return "npm";
-};
-export const detectPackageManagerIn = (cwd) => detectPackageManager(lockfiles
-    .map(([lockfile]) => lockfile)
-    .filter((lockfile) => existsSync(join(cwd, lockfile))));
+export const detectPackageManagerIn = async (cwd) => (await detect({ cwd, strategies: [...strategies] })) ?? fallback;
 /**
- * How to install with a given manager, so that the install actually updates the
+ * How to install with `agent`, so that the install actually updates the
  * lockfile.
  *
  * `upgrade` has just rewritten `package.json`, so the lockfile is deliberately
@@ -40,32 +47,138 @@ export const detectPackageManagerIn = (cwd) => detectPackageManager(lockfiles
  * themselves when they detect CI, where an install then _fails_ instead of
  * updating — and CI is exactly where this runs unattended. pnpm takes a flag;
  * Yarn's flag differs between Classic and Berry, so it gets the environment
- * variable instead, which Classic ignores harmlessly.
+ * variable instead, which Classic ignores harmlessly. Keeping the env var also
+ * keeps this one code path rather than branching on a Berry detection being
+ * right.
+ *
+ * The command itself comes from the library. Its `"install"` is the plain
+ * install for every agent — the frozen variants are a separate command there —
+ * so these quirks stay ours.
+ */
+export const installCommand = (agent) => {
+    const frozenOptOut = agent.startsWith("pnpm") ? ["--no-frozen-lockfile"] : [];
+    const resolved = resolveCommand(agent, "install", frozenOptOut);
+    if (resolved === null) {
+        throw new Error(`${agent} has no install command. Install the dependencies yourself, then re-run this command.`);
+    }
+    return {
+        command: resolved.command,
+        args: resolved.args,
+        env: agent.startsWith("yarn")
+            ? { YARN_ENABLE_IMMUTABLE_INSTALLS: "false" }
+            : {},
+    };
+};
+/**
+ * The pin as a semver range, or `undefined` when there is nothing to check.
+ *
+ * Two values have to be filtered out. `"berry"` is what the library reports for
+ * Yarn 2+ — a specifier, not a version — and for an unparseable
+ * `packageManager` it hands back the raw string. Neither is a range, and
+ * `satisfies` would throw on both.
+ *
+ * A full pin like `8.15.0` is a valid range meaning exactly that version, so
+ * one comparison covers both `pnpm@8` and `pnpm@8.15.0`. That is also why this
+ * is `satisfies` and not a string compare: the library reports the
+ * `\d+(\.\d+){0,2}` match out of the field, so `packageManager: "pnpm@8"`
+ * yields the pin `"8"` while the binary reports `8.15.0` — a string compare
+ * would send a perfectly fine setup through corepack.
  */
-export const installCommand = (manager) => {
-    switch (manager) {
-        case "pnpm":
-            return {
-                command: "pnpm",
-                args: ["install", "--no-frozen-lockfile"],
-                env: {},
-            };
-        case "yarn":
-            return {
-                command: "yarn",
-                args: ["install"],
-                env: { YARN_ENABLE_IMMUTABLE_INSTALLS: "false" },
-            };
-        case "npm":
-        case "bun":
-            return { command: manager, args: ["install"], env: {} };
+export const pinnedRange = (version) => version !== undefined && version !== "berry" && validRange(version) !== null
+    ? version
+    : undefined;
+export const runProbe = (command, args) => {
+    try {
+        return execFileSync(command, args, {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            shell: process.platform === "win32",
+        }).trim();
+    }
+    catch {
+        return undefined;
     }
 };
+/**
+ * What to run for `manager`, honouring a `packageManager` pin.
+ *
+ * The decision tree, and why it checks before reaching for corepack:
+ *
+ * | Situation                                         | Behaviour                 |
+ * | ------------------------------------------------- | ------------------------- |
+ * | No pin, or the `"berry"` specifier                | run directly              |
+ * | Pin, binary present, version satisfies it         | run directly              |
+ * | Pin, mismatch or binary missing, corepack present | run under corepack        |
+ * | Pin, mismatch or missing, no corepack             | throw, before any install |
+ *
+ * Corepack ignores `PATH` and downloads into its own cache, so "always
+ * corepack" would send every project that has a `packageManager` field — most
+ * of them — through a download, offline CI included. pnpm 9.7+ additionally
+ * installs its own pinned version, so for pnpm the direct path is usually
+ * already right.
+ *
+ * `COREPACK_ENABLE_DOWNLOAD_PROMPT=0` is required rather than tidy: corepack
+ * prompts interactively before a first download, and `upgrade` runs unattended
+ * (`-y` is implied with no TTY). Only one `install` is spawned under corepack —
+ * no nested per-task spawns — so the corepack footgun in the repo's root
+ * `AGENTS.md` does not apply.
+ */
+export const planInstall = (manager, probe = runProbe) => {
+    const { command, args, env } = installCommand(manager.agent);
+    const line = [command, ...args].join(" ");
+    const pin = pinnedRange(manager.version);
+    if (pin === undefined) {
+        return { command, args, env, description: `${manager.agent} — ${line}` };
+    }
+    const found = probe(command, ["--version"]);
+    if (found !== undefined && satisfies(found, pin)) {
+        return {
+            command,
+            args,
+            env,
+            description: `${manager.agent} ${found} — ${line}`,
+        };
+    }
+    if (probe("corepack", ["--version"]) === undefined) {
+        throw new Error(`This project pins ${manager.name}@${pin} in "packageManager", but ${found === undefined
+            ? `${command} is not on PATH`
+            : `the ${command} on PATH is ${found}`}, and corepack is not available to bridge the gap.\n\nInstall ${manager.name}@${pin} (${INSTALL_PAGE[manager.agent]}) or enable corepack, then re-run this command. Nothing has been installed.`);
+    }
+    return {
+        command: "corepack",
+        args: [command, ...args],
+        env: { ...env, COREPACK_ENABLE_DOWNLOAD_PROMPT: "0" },
+        description: `${manager.agent} ${pin} via corepack — corepack ${line}`,
+    };
+};
 export const runInstall = (manager, cwd) => {
-    const { command, args, env } = installCommand(manager);
-    execFileSync(command, args, {
+    const plan = planInstall(manager);
+    execFileSync(plan.command, plan.args, {
         cwd,
         stdio: "inherit",
-        env: { ...process.env, ...env },
+        env: { ...process.env, ...plan.env },
+        // Node has refused to spawn `.cmd`/`.bat` without a shell since 2024, which
+        // is why every non-npm manager died with ENOENT on Windows. Every argument
+        // here is our own literal or the library's, so there is no quoting hazard.
+        shell: process.platform === "win32",
     });
+    return plan.description;
+};
+/**
+ * How to tell a reader to invoke this package, for the manager they use.
+ *
+ * `npx …` for npm and Yarn Classic (which has no `dlx`), `pnpm dlx …`, `yarn
+ * dlx …`, `bun x …`. The package name is passed as an argument rather than
+ * baked in, so the library decides the whole prefix.
+ *
+ * Falls back to the `npx` form when the agent has no `execute` command: a
+ * printed hint is worth more than a gap, and npx is the one form every reader
+ * can run.
+ */
+export const resolveInvoke = async (cwd, pkg = "@mittwald/flow-codemods@latest") => {
+    const { agent } = await detectPackageManagerIn(cwd);
+    const resolved = resolveCommand(agent, "execute", [pkg]);
+    return resolved === null
+        ? `npx ${pkg}`
+        : [resolved.command, ...resolved.args].join(" ");
 };

package/dist/migrations/accent-box-color-to-background-color/transform.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 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 = (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) => flowPackages.some((pkg) => source === pkg || source.startsWith(`${pkg}/`));
+    /** The value of a string literal, or `undefined` for anything dynamic. */
+    const literalValue = (node) => {
+        if (!node || typeof node !== "object" || !("type" in node)) {
+            return undefined;
+        }
+        const { type } = node;
+        if (type !== "StringLiteral" && type !== "Literal") {
+            return undefined;
+        }
+        const { value } = node;
+        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) => {
+        const literal = literalValue(node);
+        if (literal !== undefined) {
+            return [literal];
+        }
+        if (!node || typeof node !== "object" || !("type" in node)) {
+            return undefined;
+        }
+        const typed = node;
+        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();
+    // Local names of `import * as Flow` namespace imports from a Flow package.
+    const flowNamespaces = new Set();
+    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, key) => !!attribute &&
+            typeof attribute === "object" &&
+            attribute.type === "JSXAttribute" &&
+            attribute.name?.type ===
+                "JSXIdentifier" &&
+            attribute.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();
+};
+exports.default = accentBoxColorToBackgroundColorTransform;

package/dist/migrations/action-prop-to-on-action/transform.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Renames the `action` prop to `onAction` on `Action`.
+ *
+ * The scope is deliberately narrow. Only JSX elements that resolve to `Action`
+ * — imported (named or as a namespace) from `@mittwald/flow-react-components`
+ * or `@mittwald/flow-remote-react-components`, including their subpath entries
+ * — are touched. `Action` is not one of the generated remote components, but
+ * the remote package re-exports the `flr-universal` surface, which carries it.
+ * Same-named components from other packages are left untouched, and so is the
+ * `action` attribute of a plain `<form>`.
+ *
+ * An element that already carries `onAction` keeps it and only loses the stale
+ * `action` prop, which mirrors what the runtime fallback does: an explicit
+ * `onAction` wins.
+ */
+const actionPropToOnActionTransform = (fileInfo, { j }) => {
+    const flowPackages = [
+        "@mittwald/flow-react-components",
+        "@mittwald/flow-remote-react-components",
+    ];
+    const affectedComponents = new Set(["Action"]);
+    const isFlowImport = (source) => flowPackages.some((pkg) => source === pkg || source.startsWith(`${pkg}/`));
+    const root = j(fileInfo.source, { parser: "tsx" });
+    // Local JSX identifier -> canonical component name (resolves `as` aliases).
+    const localToComponent = new Map();
+    // Local names of `import * as Flow` namespace imports from a Flow package.
+    const flowNamespaces = new Set();
+    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, key) => attribute.type === "JSXAttribute" &&
+            attribute.name.type === "JSXIdentifier" &&
+            attribute.name.name === key;
+        const hasOnAction = attributes.some((attribute) => isNamed(attribute, "onAction"));
+        if (hasOnAction) {
+            path.node.attributes = attributes.filter((attribute) => !isNamed(attribute, "action"));
+            return;
+        }
+        for (const attribute of attributes) {
+            if (isNamed(attribute, "action") && attribute.type === "JSXAttribute") {
+                attribute.name.name = "onAction";
+            }
+        }
+    });
+    return root.toSource();
+};
+exports.default = actionPropToOnActionTransform;

package/dist/migrations/align-to-combine/transform.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Renames the `Align` component to `Combine`, and `AlignProps` to
+ * `CombineProps`.
+ *
+ * Only names imported from `@mittwald/flow-react-components` or
+ * `@mittwald/flow-remote-react-components` (including their subpath entries)
+ * are touched, so a same-named import from another package is left alone. An
+ * `Align` imported under a local alias (`import { Align as Row }`) keeps its
+ * alias — only the imported name changes. Namespace usages (`<Flow.Align />`,
+ * `Flow.AlignProps`) are rewritten as well.
+ */
+const alignToCombineTransform = (fileInfo, { j }) => {
+    const flowPackages = [
+        "@mittwald/flow-react-components",
+        "@mittwald/flow-remote-react-components",
+    ];
+    const renames = new Map([
+        ["Align", "Combine"],
+        ["AlignProps", "CombineProps"],
+    ]);
+    const isFlowImport = (source) => flowPackages.some((pkg) => source === pkg || source.startsWith(`${pkg}/`));
+    // 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 = alignToCombineTransform;