@mittwald/flow-codemods 1.1.0 → 1.1.1

package/dist/migrations/button-props-interfaces/transform.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Replaces the removed `Button` props interfaces with `ButtonProps`
+ * (alpha.646).
+ *
+ * `RemoteButtonElementProps`, `ResetButtonProps` and `SubmitButtonProps` were
+ * removed; all three are `ButtonProps`. There is no alias for the old names, so
+ * a codebase still using them does not compile.
+ *
+ * This is more than a rename, because the names do not share an entry.
+ * `SubmitButtonProps` and `ResetButtonProps` came from the `react-hook-form`
+ * entry, which does not export `ButtonProps` — renaming them in place would
+ * swap one import error for another. The specifier therefore moves to the
+ * package root of whichever Flow package it came from, joining an existing
+ * import from that root or getting a new one.
+ *
+ * The scope is `@mittwald/flow-react-components` and its subpath entries only.
+ * The remote package re-exports the `flr-universal` surface, so it does carry
+ * some prop types — `ActionProps`, `ModalProps` and the like — but
+ * `ButtonProps` is not among them. There is nothing to move a remote import
+ * onto, so a remote codebase has to pick its own source for the type.
+ * `RemoteButtonElementProps` is left alone for the same reason, and because
+ * `@mittwald/flow-remote-elements` still exports that name today.
+ *
+ * A same-named import from another package is left alone. A name imported under
+ * a local alias (`import { SubmitButtonProps as P }`) keeps its alias — it
+ * becomes `ButtonProps as P`. Namespace usages (`Flow.SubmitButtonProps`) are
+ * rewritten as well.
+ *
+ * All three collapse onto `ButtonProps`, so a file importing more than one of
+ * them — or one of them next to `ButtonProps` itself — ends up with a single
+ * specifier instead of a duplicate declaration, which would not parse.
+ */
+const buttonPropsInterfacesTransform = (fileInfo, { j }) => {
+    const flowPackages = ["@mittwald/flow-react-components"];
+    const removed = new Set(["ResetButtonProps", "SubmitButtonProps"]);
+    const newName = "ButtonProps";
+    /** The Flow package a module specifier belongs to, or `undefined`. */
+    const rootPackageOf = (source) => flowPackages.find((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 = (node) => node.importKind === "type";
+    const root = j(fileInfo.source, { parser: "tsx" });
+    /** Local identifiers that have 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();
+    /** `package:local` pairs that already import `ButtonProps` from a root. */
+    const bound = new Set();
+    /** `package:local` pairs that still need importing, and whether type-only. */
+    const wanted = new Map();
+    const flowImports = root
+        .find(j.ImportDeclaration)
+        .filter((path) => !!rootPackageOf(String(path.node.source.value)));
+    flowImports.forEach((path) => {
+        const source = String(path.node.source.value);
+        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 &&
+                source === rootPackageOf(source)) {
+                bound.add(`${source}:${String(specifier.local?.name ?? newName)}`);
+            }
+        }
+    });
+    flowImports.forEach((path) => {
+        const source = String(path.node.source.value);
+        const pkg = rootPackageOf(source) ?? source;
+        const declarationIsType = isTypeOnly(path.node);
+        const specifiers = path.node.specifiers ?? [];
+        const survivors = [];
+        for (const specifier of specifiers) {
+            if (specifier.type !== "ImportSpecifier" ||
+                specifier.imported.type !== "Identifier" ||
+                !removed.has(specifier.imported.name)) {
+                survivors.push(specifier);
+                continue;
+            }
+            const imported = specifier.imported.name;
+            const local = String(specifier.local?.name ?? imported);
+            const isAlias = local !== imported;
+            const newLocal = isAlias ? local : newName;
+            const key = `${pkg}:${newLocal}`;
+            if (!isAlias) {
+                localRenames.add(local);
+            }
+            if (!bound.has(key)) {
+                const existing = wanted.get(key);
+                const type = declarationIsType || isTypeOnly(specifier);
+                wanted.set(key, {
+                    pkg,
+                    local: newLocal,
+                    // A value import must not lose out to a type-only one.
+                    type: existing ? existing.type && type : type,
+                });
+            }
+        }
+        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 (wanted.size === 0 &&
+        localRenames.size === 0 &&
+        flowNamespaces.size === 0) {
+        return fileInfo.source;
+    }
+    for (const { pkg, local, type } of wanted.values()) {
+        const specifier = j.importSpecifier(j.identifier(newName), j.identifier(local));
+        // Join an import from the package root when the file already has one and
+        // it can carry the specifier; otherwise add a declaration of its own.
+        const host = root
+            .find(j.ImportDeclaration)
+            .filter((path) => String(path.node.source.value) === pkg &&
+            isTypeOnly(path.node) === type)
+            .paths()[0];
+        if (host) {
+            host.node.specifiers = [...(host.node.specifiers ?? []), specifier];
+            continue;
+        }
+        const declaration = j.importDeclaration([specifier], j.literal(pkg));
+        if (type) {
+            declaration.importKind = "type";
+        }
+        const firstImport = root.find(j.ImportDeclaration).paths()[0];
+        if (firstImport) {
+            j(firstImport).insertBefore(declaration);
+        }
+        else {
+            root.get().node.program.body.unshift(declaration);
+        }
+    }
+    /**
+     * `JSXIdentifier` extends `Identifier`, so this one pass covers 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") &&
+                removed.has(path.node.name) &&
+                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;
+        }
+    });
+    return root.toSource();
+};
+exports.default = buttonPropsInterfacesTransform;

package/dist/migrations/color-primary-to-default/transform.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Renames the `color="primary"` prop value to `color="default"` on the five
+ * components changed by the alpha.837 design update: `Breadcrumb`,
+ * `HeaderNavigation`, `Heading`, `IllustratedMessage` and `Link`.
+ *
+ * The scope is deliberately narrow. Only JSX elements that resolve to one of
+ * those components — imported (named or as a namespace) from
+ * `@mittwald/flow-react-components` or
+ * `@mittwald/flow-remote-react-components`, including their subpath entries —
+ * are touched. Components that still accept `color="primary"` (e.g. `Button`)
+ * and same-named elements from other packages (e.g. a router `Link`) are left
+ * untouched.
+ *
+ * Only literal `"primary"` values are rewritten — either as the whole value
+ * (`color="primary"`, `color={"primary"}`) or in a value position inside a
+ * dynamic one (`color={cond ? "secondary" : "primary"}`, `color={override ??
+ * "primary"}`). A value the transform cannot see into (`color={someVariable}`)
+ * is left alone.
+ */
+const colorPrimaryToDefaultTransform = (fileInfo, { j }) => {
+    const flowPackages = [
+        "@mittwald/flow-react-components",
+        "@mittwald/flow-remote-react-components",
+    ];
+    const affectedComponents = new Set([
+        "Breadcrumb",
+        "HeaderNavigation",
+        "Heading",
+        "IllustratedMessage",
+        "Link",
+    ]);
+    const isFlowImport = (source) => flowPackages.some((pkg) => source === pkg || source.startsWith(`${pkg}/`));
+    const isPrimaryLiteral = (node) => {
+        if (!node || typeof node !== "object" || !("type" in node)) {
+            return false;
+        }
+        const { type } = node;
+        return ((type === "StringLiteral" || type === "Literal") &&
+            node.value === "primary");
+    };
+    /**
+     * Rewrites every `"primary"` sitting in a position whose value can reach the
+     * prop: the expression itself, both branches of a ternary, and the operands
+     * of `??`/`||` — plus the right operand of `&&`, since `&&` yields its left
+     * operand only when that operand is falsy and a non-empty string never is. A
+     * `"primary"` anywhere else is not a value that reaches the prop (an object
+     * key, an index into a lookup table) and stays as it is.
+     *
+     * This cannot move into a shared module: the CLI loads this file straight out
+     * of the published package, which ships only
+     * `src/migrations/**\/transform.ts` — see this package's AGENTS.md.
+     */
+    const rewriteValuePositions = (node) => {
+        if (isPrimaryLiteral(node)) {
+            return j.stringLiteral("default");
+        }
+        if (node?.type === "ConditionalExpression") {
+            node.consequent = rewriteValuePositions(node.consequent);
+            node.alternate = rewriteValuePositions(node.alternate);
+            return node;
+        }
+        if (node?.type === "LogicalExpression") {
+            if (node.operator !== "&&") {
+                node.left = rewriteValuePositions(node.left);
+            }
+            node.right = rewriteValuePositions(node.right);
+            return node;
+        }
+        return node;
+    };
+    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;
+        }
+        for (const attribute of path.node.attributes ?? []) {
+            if (attribute.type !== "JSXAttribute" ||
+                attribute.name.type !== "JSXIdentifier" ||
+                attribute.name.name !== "color") {
+                continue;
+            }
+            const value = attribute.value;
+            // color="primary"
+            if (isPrimaryLiteral(value)) {
+                attribute.value = j.stringLiteral("default");
+                continue;
+            }
+            // color={"primary"}, and every value position inside a dynamic value:
+            // color={cond ? "primary" : "x"}, color={fallback ?? "primary"}.
+            if (value?.type === "JSXExpressionContainer" &&
+                value.expression.type !== "JSXEmptyExpression") {
+                value.expression = rewriteValuePositions(value.expression);
+            }
+        }
+    });
+    return root.toSource();
+};
+exports.default = colorPrimaryToDefaultTransform;

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Subpaths this transform must leave alone. Two groups, and they are different
+ * kinds of fact.
+ *
+ * **Subpaths the package still exports.** alpha.28 collapsed 94 subpath exports
+ * onto the package root, and performing that collapse is this transform's whole
+ * job — but it did it with a catch-all `else`, so every subpath introduced
+ * _after_ alpha.28 was collateral. That stayed invisible while selection had a
+ * lower bound; it no longer has one (see `selectEntries`), so the transform now
+ * reaches current code, where flattening `all-layered.css` silently turns a
+ * stylesheet import into a JS one and flattening `mittwald-password-tools-js`
+ * moves `Rule` onto a root that does not export it.
+ *
+ * **Subpaths another entry owns.** `password-tools` is renamed to
+ * `mittwald-password-tools-js` by `password-tools-subpath-renamed`, whose
+ * `since` sorts it _after_ this entry. Flattening it first leaves that
+ * migration nothing to find, and both report success.
+ *
+ * Matched exactly, not by prefix: `react-hook-form/useFoo` still collapses onto
+ * `react-hook-form`, which is what alpha.28 did to it.
+ *
+ * `transform.test.ts` beside this file holds the first group against the
+ * package's real `exports` map, so a new subpath cannot quietly become
+ * collateral again.
+ */
+const keptSubpaths = new Set([
+    // the current export surface
+    "internal",
+    "flr-universal",
+    "nextjs",
+    "react-hook-form",
+    "mittwald-password-tools-js",
+    "all.css",
+    "all-layered.css",
+    "component-index",
+    "doc-properties",
+    // owned by password-tools-subpath-renamed
+    "password-tools",
+]);
+const importsToPackageRootTransform = (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 specifiers = i.node.specifiers ?? [];
+        const importPath = String(i.node.source.value);
+        const importRelativePath = 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`;
+            return;
+        }
+        if (importRelativePath.startsWith("react-hook-form")) {
+            i.node.source.value = `${flowPackage}/react-hook-form`;
+        }
+        else if (importRelativePath.startsWith("nextjs")) {
+            i.node.source.value = `${flowPackage}/nextjs`;
+        }
+        else {
+            i.node.source.value = flowPackage;
+        }
+        specifiers.forEach((s, i) => {
+            if (s.type === "ImportDefaultSpecifier" ||
+                s.type === "ImportSpecifier") {
+                // `name` is typed `string | Identifier` in ast-types; for the
+                // specifiers handled here it is always the plain name.
+                const name = String((s.type === "ImportDefaultSpecifier"
+                    ? s.local?.name
+                    : s.imported?.name) ?? "");
+                specifiers[i] = {
+                    ...s,
+                    type: "ImportSpecifier",
+                    imported: {
+                        type: "Identifier",
+                        name,
+                    },
+                };
+            }
+        });
+    });
+    return root.toSource();
+};
+exports.default = importsToPackageRootTransform;

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"
+}