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

package/dist/migrations/muted-action-error-to-abort-action-error/transform.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Renames `MutedActionError` to `AbortActionError`, along with its two static
+ * helpers (alpha.712).
+ *
+ * ```diff
+ * -throw new MutedActionError();
+ * +throw new AbortActionError();
+ * -MutedActionError.isMutedActionError(error);
+ * +AbortActionError.isAbortActionError(error);
+ * -MutedActionError.rethrowIfNotMuted(error);
+ * +AbortActionError.rethrowIfNotAborted(error);
+ * ```
+ *
+ * There is no alias for the old name, so a codebase still using it does not
+ * compile.
+ *
+ * The thrown error's `name` changed too, so a `error.name ===
+ * "MutedActionError"` comparison is rewritten as well — but only in a file that
+ * imports the class, and only where the string is compared with `==`, `===`,
+ * `!=` or `!==`. A check living in a file that never imports the class cannot
+ * be recognised; grep for the string once when you are done.
+ *
+ * Only names imported from `@mittwald/flow-react-components` (including its
+ * subpath entries) are touched. `@mittwald/flow-remote-react-components`
+ * exports no error classes, so it cannot be in scope. A local alias (`import {
+ * MutedActionError as Muted }`) keeps its alias — the static helpers on it are
+ * renamed all the same. Namespace usages (`Flow.MutedActionError`) are
+ * rewritten too.
+ */
+const mutedActionErrorToAbortActionErrorTransform = (fileInfo, { j }) => {
+    const flowPackages = ["@mittwald/flow-react-components"];
+    const oldName = "MutedActionError";
+    const newName = "AbortActionError";
+    const memberRenames = new Map([
+        ["isMutedActionError", "isAbortActionError"],
+        ["rethrowIfNotMuted", "rethrowIfNotAborted"],
+    ]);
+    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 names bound to the class, alias or not — the static helpers hang off
+     * these.
+     */
+    const classLocals = new Set();
+    /** Local names whose identifier itself has to be renamed (no alias in play). */
+    const localRenames = new Set();
+    /** 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)));
+    /**
+     * Local names the file already binds to the new name. Renaming onto one of
+     * them must not add a second specifier, which would not parse.
+     */
+    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" &&
+                specifier.imported.name === newName) {
+                claimed.add(String(specifier.local?.name ?? newName));
+            }
+        }
+    });
+    flowImports.forEach((path) => {
+        const specifiers = path.node.specifiers ?? [];
+        const survivors = [];
+        for (const specifier of specifiers) {
+            if (specifier.type !== "ImportSpecifier" ||
+                specifier.imported.type !== "Identifier" ||
+                specifier.imported.name !== oldName) {
+                survivors.push(specifier);
+                continue;
+            }
+            const local = String(specifier.local?.name ?? oldName);
+            const isAlias = local !== oldName;
+            const newLocal = isAlias ? local : newName;
+            classLocals.add(local);
+            if (!isAlias) {
+                localRenames.add(local);
+            }
+            if (claimed.has(newLocal)) {
+                // The name is already bound by another import — drop this specifier
+                // instead of declaring it twice.
+                if (!isTypeOnly(specifier)) {
+                    for (const kept of survivors) {
+                        if (kept.type === "ImportSpecifier" &&
+                            kept.imported.type === "Identifier" &&
+                            String(kept.local?.name ?? kept.imported.name) === newLocal) {
+                            makeValueImport(kept);
+                        }
+                    }
+                }
+                continue;
+            }
+            claimed.add(newLocal);
+            // Mutate in place so an `import type` / `type X` modifier survives.
+            specifier.imported.name = newName;
+            if (!isAlias && specifier.local) {
+                specifier.local.name = newName;
+            }
+            survivors.push(specifier);
+        }
+        if (survivors.length === specifiers.length) {
+            return;
+        }
+        // Leaving an emptied 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 (classLocals.size === 0 && flowNamespaces.size === 0) {
+        return fileInfo.source;
+    }
+    /** Does this expression denote the class — `Muted` or `Flow.MutedActionError`? */
+    const isClassReference = (node) => {
+        if (!node) {
+            return false;
+        }
+        if (node.type === "Identifier") {
+            return classLocals.has(String(node.name));
+        }
+        return (node.type === "MemberExpression" &&
+            node.object?.type === "Identifier" &&
+            flowNamespaces.has(String(node.object.name)) &&
+            node.property?.type === "Identifier" &&
+            String(node.property.name) === oldName);
+    };
+    // Static helpers first: the check reads the pre-rename object name.
+    root.find(j.MemberExpression).forEach((path) => {
+        const { object, property } = path.node;
+        if (property.type !== "Identifier" || !isClassReference(object)) {
+            return;
+        }
+        const renamed = memberRenames.get(property.name);
+        if (renamed) {
+            property.name = renamed;
+        }
+    });
+    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") &&
+                path.node.name === oldName &&
+                flowNamespaces.has(String(object.name))) {
+                path.node.name = newName;
+            }
+            return;
+        }
+        if (parent.type === "ImportSpecifier" ||
+            parent.type === "JSXAttribute" ||
+            ((parent.type === "ObjectProperty" || parent.type === "Property") &&
+                parent.key === path.node &&
+                !parent.computed)) {
+            return;
+        }
+        if (localRenames.has(path.node.name)) {
+            path.node.name = newName;
+        }
+    });
+    // `error.name === "MutedActionError"` — a comparison is the only place where
+    // the string can be recognised as the error's name rather than free text.
+    const comparisons = new Set(["===", "!==", "==", "!="]);
+    root.find(j.BinaryExpression).forEach((path) => {
+        if (!comparisons.has(path.node.operator)) {
+            return;
+        }
+        for (const side of [path.node.left, path.node.right]) {
+            if ((side.type === "StringLiteral" || side.type === "Literal") &&
+                side.value === oldName) {
+                side.value = newName;
+            }
+        }
+    });
+    return root.toSource();
+};
+exports.default = mutedActionErrorToAbortActionErrorTransform;

package/dist/migrations/package.json

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

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.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"migrations.generated.d.ts","sourceRoot":"","sources":["../src/migrations.generated.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,sEAAsE;AACtE,eAAO,MAAM,UAAU,EAAE,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,EAmPpD,CAAC"}
+{"version":3,"file":"migrations.generated.d.ts","sourceRoot":"","sources":["../src/migrations.generated.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,sEAAsE;AACtE,eAAO,MAAM,UAAU,EAAE,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,EA8PpD,CAAC"}

package/dist/migrations.generated.js

@@ -19,7 +19,7 @@ export const migrations = [
         kind: "deprecation",
         action: "manual",
         remotePackage: true,
-        apply: "Replace `SegmentedControl` with `Tabs` when the selection switches displayed content, or with `RadioGroup` when it sets a value. Pick per usage — this is a structural change, not a rename.",
+        apply: "Replace `SegmentedControl` with `Tabs` when the selection switches displayed content, or with `RadioGroup` when it sets a value. Pick per usage. The two directions cost very different amounts of work. Towards `RadioGroup` it is a prop-compatible rename: `SegmentedControl` → `RadioGroup` and `Segment` → `RadioButton` (always `RadioButton`, not `Radio`; it takes exactly `Segment`'s props), with `value`/`defaultValue`/`onChange` and a `Label` child all carrying over. Only `containerBreakpointSize` has no counterpart, and the joined row is not reproduced. Towards `Tabs` it is structural: the state props are `selectedKey`/`defaultSelectedKey` rather than `value`/`defaultValue`, there is no `Label` slot (the group label moves to the surrounding `Heading`, or to `aria-label` on `Tabs` when it should not be visible, or goes away), and the switched panels move inside the tabs — where they stay mounted, so form fields in them keep their registration.",
     },
     {
         id: "align-to-combine",
@@ -75,6 +75,15 @@ export const migrations = [
         remotePackage: false,
         apply: "Replace the import path `@mittwald/flow-react-components/password-tools` with `@mittwald/flow-react-components/mittwald-password-tools-js`.",
     },
+    {
+        id: "tabs-navigation-usage-to-tab-navigation",
+        since: "0.2.0-alpha.977",
+        title: "Tabs restyled; navigation usage moves to TabNavigation",
+        kind: "migration",
+        action: "manual",
+        remotePackage: true,
+        apply: "Tabs' rendering changed: the tab list now fills the available width with equal-size tabs and a shared, animated indicator that slides between them, replacing the previous fit-content tabs that each carried their own hover/pressed/selected background. Nothing else about `Tabs` changed, and a `Tabs` that switches content within a page needs no code change — the new look applies on upgrade. Where `Tabs` was used to fake real navigation instead — a `TabTitle` given an `href` (`Aria.Tab`'s routing props: `href`, `target`, `routerOptions`, …) so selecting it pushed a real route change — replace it with `TabNavigation`: plain `Link` children instead of `Tab`/`TabTitle`/panels, `aria-current=\"page\"` on the active `Link` instead of `selectedKey`/`defaultSelectedKey`/`onSelectionChange`. `TabNavigation` keeps the visual language the old `Tabs` used to have, because it now owns that use case.",
+    },
     {
         id: "table-column-width-props",
         since: "0.2.0-alpha.956",
@@ -145,7 +154,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",
@@ -190,7 +199,7 @@ export const migrations = [
         kind: "migration",
         action: "codemod",
         remotePackage: true,
-        apply: "Rename the `action` prop on `Action` to `onAction`.",
+        apply: "Rename the `action` prop on `Action` to `onAction`. Not only a rename: the new prop is typed `ActionFn` (`(...args: unknown[]) => unknown`), so a function *reference* that declares a parameter no longer type-checks and needs wrapping — `onAction={() => controller.close()}` rather than `onAction={controller.close}`. Check every site where you passed a reference rather than an inline arrow; the codemod renames the prop but cannot decide this one from the source.",
     },
     {
         id: "button-props-interfaces",

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;