@mittwald/flow-codemods 1.2.0-next.6 → 1.2.0-next.61

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/manifest.d.ts

@@ -42,4 +42,3 @@ export declare const applyTarget: <T extends Manifest>(manifest: T, target: stri
  * `imports-to-package-root` needed an explicit leave-alone set to earn this.
  */
 export declare const detectCurrentVersion: (dependencies: FlowDependency[], readInstalledVersion: (name: string) => string | undefined) => string | undefined;
-//# sourceMappingURL=manifest.d.ts.map

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

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
- * Renames the `action` prop to `onAction` on `Action`.
+ * Renames the `action` prop to `onAction` on `Action`, and wraps a bare
+ * function reference passed to it in an inline call.
  *
  * The scope is deliberately narrow. Only JSX elements that resolve to `Action`
  * — imported (named or as a namespace) from `@mittwald/flow-react-components`
@@ -14,6 +15,44 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * 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.
+ *
+ * ## Why the wrap is unconditional
+ *
+ * `onAction` is typed `ActionFn` (`(...args: unknown[]) => unknown`), so a
+ * reference to a function declaring a parameter of any narrower type — the
+ * usual case being `controller.close`, typed `(options?: CloseOverlayOptions)
+ * => void` — does not type-check. Whether a given reference declares such a
+ * parameter needs type information and is not decidable from the source, which
+ * is why this transform used to leave every reference alone and `apply` asked
+ * for a manual pass over all of them.
+ *
+ * Deciding _whether_ to wrap needs the type. _Performing_ the wrap does not:
+ * `() => fn()` calls exactly what `fn` would have been called with by `Action`,
+ * minus the arguments — and `onAction` is documented as taking none. So the
+ * wrap fixes the reference that needed it and is a no-op for the rest, which
+ * makes the decision unnecessary.
+ *
+ * Two cases it can still change, neither decidable from the source:
+ *
+ * - A handler that reads the argument `Action` forwards (the trigger's event,
+ *   e.g. a `PressEvent` from the `Button` inside) and declares it optional or
+ *   as a rest parameter, so that it type-checks both before and after. It stops
+ *   receiving that argument, silently. Nothing in Flow documents `onAction` as
+ *   receiving one.
+ * - A possibly-undefined reference, `onAction={props.onAction}`. `undefined` is a
+ *   valid value for the prop, but calling it is not, so the wrap turns
+ *   something TypeScript accepted into something it rejects — loudly, at the
+ *   call site, which is why this is a compile error to fix rather than a
+ *   regression to find.
+ *
+ * `apply` names both.
+ *
+ * Only a bare reference is wrapped: a plain identifier or a member expression.
+ * An arrow function and a function expression already are the handler. A call
+ * (`makeHandler()`, `close.bind(controller)`) _produces_ the handler, so
+ * wrapping it would call the factory on every trigger and throw its result
+ * away. A conditional, a `??` chain or an optional member expression is not a
+ * reference to one function, so wrapping would be a guess.
  */
 const actionPropToOnActionTransform = (fileInfo, { j }) => {
     const flowPackages = [
@@ -22,6 +61,27 @@ const actionPropToOnActionTransform = (fileInfo, { j }) => {
     ];
     const affectedComponents = new Set(["Action"]);
     const isFlowImport = (source) => flowPackages.some((pkg) => source === pkg || source.startsWith(`${pkg}/`));
+    /**
+     * Whether a member expression is rooted in a plain reference —
+     * `controller.close`, `this.handleSave`, `store.modal.controller.close` —
+     * rather than in something evaluated, as `makeController().close` is.
+     *
+     * An optional link disqualifies the chain. `controller?.close` parses as
+     * `OptionalMemberExpression` and never reaches here at all; walking the chain
+     * catches a mixed one like `(a?.b).c`. Declining is deliberate: `() =>
+     * controller?.close()` short-circuits differently from the value it would
+     * replace, and the spelling says the reference may not be there.
+     */
+    const hasPlainObjectChain = (expression) => {
+        const object = expression.object;
+        if (!object || typeof object !== "object" || !("type" in object)) {
+            return false;
+        }
+        const typed = object;
+        return (typed.type === "ThisExpression" ||
+            typed.type === "Identifier" ||
+            (typed.type === "MemberExpression" && hasPlainObjectChain(typed)));
+    };
     const root = j(fileInfo.source, { parser: "tsx" });
     // Local JSX identifier -> canonical component name (resolves `as` aliases).
     const localToComponent = new Map();
@@ -69,12 +129,38 @@ const actionPropToOnActionTransform = (fileInfo, { j }) => {
         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";
+        else {
+            for (const attribute of attributes) {
+                if (isNamed(attribute, "action") && attribute.type === "JSXAttribute") {
+                    attribute.name.name = "onAction";
+                }
+            }
+        }
+        // Whatever the prop was called before, the surviving `onAction` is the one
+        // that needs the wrap — including one the consumer had already renamed by
+        // hand, which carries the same type error.
+        for (const attribute of path.node.attributes ?? []) {
+            if (attribute.type !== "JSXAttribute" ||
+                !isNamed(attribute, "onAction")) {
+                continue;
+            }
+            const container = attribute.value;
+            if (container?.type !== "JSXExpressionContainer") {
+                continue;
+            }
+            // A bare reference is an identifier or a member expression. Everything
+            // else either is the handler already or is a way of producing one.
+            const expression = container.expression;
+            if (expression.type !== "Identifier" &&
+                expression.type !== "MemberExpression") {
+                continue;
+            }
+            if (expression.type === "MemberExpression" &&
+                !hasPlainObjectChain(expression)) {
+                continue;
             }
+            attribute.value = j.jsxExpressionContainer(j.arrowFunctionExpression([], j.callExpression(expression, [])));
         }
     });
     return root.toSource();

package/dist/migrations/imports-to-package-root/transform.js

@@ -29,6 +29,7 @@ const keptSubpaths = new Set([
     // the current export surface
     "internal",
     "flr-universal",
+    "tunnel",
     "nextjs",
     "react-hook-form",
     "mittwald-password-tools-js",
@@ -39,6 +40,21 @@ const keptSubpaths = new Set([
     // owned by password-tools-subpath-renamed
     "password-tools",
 ]);
+/**
+ * Splits a bundler's asset query or fragment off a specifier. `all.css?url` is
+ * the subpath `all.css`, requested as a URL — not a subpath named
+ * `all.css?url`. Matching the whole string carried the suffix past the
+ * leave-alone set and into the catch-all below, which rewrote `import
+ * flowStyles from "…/all.css?url"` into a named import of a JS export that does
+ * not exist, and `import "…/all-layered.css?inline"` into a side-effect import
+ * of the package root — stylesheet gone, no error anywhere.
+ */
+const splitAssetSuffix = (subpath) => {
+    const suffixAt = subpath.search(/[?#]/);
+    return suffixAt === -1
+        ? [subpath, ""]
+        : [subpath.slice(0, suffixAt), subpath.slice(suffixAt)];
+};
 const importsToPackageRootTransform = (fileInfo, { j }) => {
     const flowPackage = "@mittwald/flow-react-components";
     const root = j(fileInfo.source, {
@@ -50,14 +66,21 @@ const importsToPackageRootTransform = (fileInfo, { j }) => {
         .forEach((i) => {
         const specifiers = i.node.specifiers ?? [];
         const importPath = String(i.node.source.value);
-        const importRelativePath = importPath.slice(flowPackage.length + 1);
+        const [importRelativePath, assetSuffix] = splitAssetSuffix(importPath.slice(flowPackage.length + 1));
         if (keptSubpaths.has(importRelativePath)) {
             return;
         }
         if (importRelativePath === "all.css" ||
             importRelativePath === "globals.css" ||
             importRelativePath === "global.css") {
-            i.node.source.value = `${flowPackage}/all.css`;
+            i.node.source.value = `${flowPackage}/all.css${assetSuffix}`;
+            return;
+        }
+        // Everything below rewrites a *module* import: it moves the specifier
+        // onto a JS entry and turns a default specifier into a named one. An
+        // asset import survives neither, and a suffix reaching this point names a
+        // path this transform cannot resolve to an export — leave it to a human.
+        if (assetSuffix !== "") {
             return;
         }
         if (importRelativePath.startsWith("react-hook-form")) {

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

@@ -23,11 +23,22 @@ const passwordToolsRuleTransform = (fileInfo, { j }) => {
     const flowPackages = [
         "@mittwald/flow-react-components/mittwald-password-tools-js",
     ];
+    /**
+     * The same entry under the name it had when this change shipped. It was
+     * renamed later (alpha.1000, `password-tools-subpath-renamed`), and `since`
+     * puts that rename _after_ this transform — so a consumer coming from before
+     * alpha.802 still spells the import `password-tools` when this runs, and
+     * matching only the current name left `AsyncRule` untouched for the rename to
+     * carry onto an entry that does not export it. Kept out of `flowPackages`
+     * because `remoteScope.test.ts` holds every name in there against the export
+     * map the packages have _today_, where this one is gone.
+     */
+    const renamedFlowPackage = "@mittwald/flow-react-components/password-tools";
     const renames = new Map([
         ["AsyncRule", "Rule"],
         ["SyncRule", "Rule"],
     ]);
-    const isFlowImport = (source) => flowPackages.includes(source);
+    const isFlowImport = (source) => flowPackages.includes(source) || source === renamedFlowPackage;
     // 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";

package/dist/migrations/popover-open-state-props/transform.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Renames the `defaultOpen` prop to `isDefaultOpen` on `Popover`,
+ * `ContextualHelp` and `ContextMenu`.
+ *
+ * The scope is deliberately narrow, and here that is not only about same-named
+ * components from other packages. `defaultOpen` is react-aria's own prop and
+ * Flow passes it straight through on `Select`, `MenuTrigger`, `Tooltip`,
+ * `TooltipTrigger`, `DialogTrigger`, `DatePicker` and `DateRangePicker`, where
+ * it did not change — renaming it there would remove a working prop.
+ *
+ * Only JSX elements that resolve to one of the three — imported (named or as a
+ * namespace) from `@mittwald/flow-react-components` or
+ * `@mittwald/flow-remote-react-components`, including their subpath entries —
+ * are touched.
+ *
+ * An element that already carries `isDefaultOpen` keeps it and only loses the
+ * stale `defaultOpen`, which mirrors the runtime: `isDefaultOpen` wins.
+ *
+ * The other two changes of this migration are not here. `isOpen` and
+ * `onOpenChange` changed behaviour, not spelling: whether a given `isOpen` is
+ * meant to control the popover, and whether an `onOpenChange` handler performed
+ * or suppressed the close, is not decidable from the source. `apply` asks for
+ * those by hand.
+ */
+const popoverOpenStatePropsTransform = (fileInfo, { j }) => {
+    const flowPackages = [
+        "@mittwald/flow-react-components",
+        "@mittwald/flow-remote-react-components",
+    ];
+    const affectedComponents = new Set([
+        "Popover",
+        "ContextualHelp",
+        "ContextMenu",
+    ]);
+    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;
+    }
+    let changed = false;
+    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;
+        if (!attributes.some((attribute) => isNamed(attribute, "defaultOpen"))) {
+            return;
+        }
+        changed = true;
+        if (attributes.some((attribute) => isNamed(attribute, "isDefaultOpen"))) {
+            path.node.attributes = attributes.filter((attribute) => !isNamed(attribute, "defaultOpen"));
+            return;
+        }
+        for (const attribute of attributes) {
+            if (isNamed(attribute, "defaultOpen") &&
+                attribute.type === "JSXAttribute" &&
+                attribute.name.type === "JSXIdentifier") {
+                attribute.name.name = "isDefaultOpen";
+            }
+        }
+    });
+    return changed ? root.toSource() : fileInfo.source;
+};
+exports.default = popoverOpenStatePropsTransform;

package/dist/migrations/renamed-css-export/transform.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const oldPath = "@mittwald/flow-react-components/styles";
+const newPath = "@mittwald/flow-react-components/all.css";
+/**
+ * Rewrites the module specifier `@mittwald/flow-react-components/styles` to
+ * `@mittwald/flow-react-components/all.css` (alpha.292).
+ *
+ * The same shape as `password-tools-subpath-renamed`: one exact specifier, in
+ * every form that names a module — `import`, `import type`, `export … from`, a
+ * side-effect import, `import()` and `require()`. In practice it is nearly
+ * always the side-effect form (`import "…/styles"`), which is why that case is
+ * the one the fixtures lead with.
+ *
+ * Exact match on the path, not a prefix: `./styles` was a single export with
+ * nothing underneath it, so there is no deeper path to rewrite and no risk of
+ * touching an unrelated `styles` of someone else's. A bundler query or fragment
+ * (`?url`, `?inline`) is split off before that comparison and carried over — it
+ * addresses the export, it does not name a different one.
+ *
+ * What this cannot reach is an `@import` in a `.css` or `.scss` file —
+ * jscodeshift only walks the JavaScript and TypeScript extensions. `apply` says
+ * so.
+ */
+const renamedCssExportTransform = (fileInfo, { j }) => {
+    const root = j(fileInfo.source, { parser: "tsx" });
+    let changed = false;
+    // A bundler addresses an asset through a query or fragment on the specifier,
+    // so `…/styles?url` is the old export requested as a URL. The rename applies
+    // to it just the same: match the path, carry the suffix over. Comparing the
+    // whole string leaves it pointing at an export the package no longer has.
+    const rewrite = (node) => {
+        if (typeof node.value !== "string") {
+            return;
+        }
+        const suffixAt = node.value.search(/[?#]/);
+        const [path, suffix] = suffixAt === -1
+            ? [node.value, ""]
+            : [node.value.slice(0, suffixAt), node.value.slice(suffixAt)];
+        if (path !== oldPath) {
+            return;
+        }
+        node.value = `${newPath}${suffix}`;
+        changed = true;
+    };
+    // import … from "…", import "…"
+    root.find(j.ImportDeclaration).forEach((path) => rewrite(path.node.source));
+    // export … from "…", export * from "…"
+    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 = renamedCssExportTransform;