@mittwald/flow-codemods 1.1.0-next.10

package/src/migrations/color-primary-to-default/transform.ts

@@ -0,0 +1,173 @@
+import type { ConditionalExpression, Transform } from "jscodeshift";
+
+/**
+ * An expression that can be a prop's value. Deliberately not
+ * `JSXExpressionContainer["expression"]`: that also admits `JSXEmptyExpression`
+ * (`color={/* a comment *\/}`), which cannot be written back into a ternary
+ * branch. The call site filters it out instead.
+ */
+type ValueNode = ConditionalExpression["consequent"];
+
+/**
+ * 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: Transform = (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: string): boolean =>
+    flowPackages.some((pkg) => source === pkg || source.startsWith(`${pkg}/`));
+
+  const isPrimaryLiteral = (node: unknown): boolean => {
+    if (!node || typeof node !== "object" || !("type" in node)) {
+      return false;
+    }
+    const { type } = node as { type: string };
+    return (
+      (type === "StringLiteral" || type === "Literal") &&
+      (node as { value?: unknown }).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: ValueNode): ValueNode => {
+    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<string, string>();
+  // Local names of `import * as Flow` namespace imports from a Flow package.
+  const flowNamespaces = new Set<string>();
+
+  root
+    .find(j.ImportDeclaration)
+    .filter((path) => isFlowImport(String(path.node.source.value)))
+    .forEach((path) => {
+      for (const specifier of path.node.specifiers ?? []) {
+        if (
+          specifier.type === "ImportSpecifier" &&
+          specifier.imported.type === "Identifier" &&
+          affectedComponents.has(specifier.imported.name)
+        ) {
+          localToComponent.set(
+            String(specifier.local?.name ?? specifier.imported.name),
+            String(specifier.imported.name),
+          );
+        } else if (
+          specifier.type === "ImportNamespaceSpecifier" &&
+          specifier.local
+        ) {
+          flowNamespaces.add(String(specifier.local.name));
+        }
+      }
+    });
+
+  if (localToComponent.size === 0 && flowNamespaces.size === 0) {
+    return fileInfo.source;
+  }
+
+  root.find(j.JSXOpeningElement).forEach((path) => {
+    const name = path.node.name;
+
+    let isAffected = false;
+    if (name.type === "JSXIdentifier") {
+      isAffected = localToComponent.has(name.name);
+    } else if (
+      name.type === "JSXMemberExpression" &&
+      name.object.type === "JSXIdentifier" &&
+      name.property.type === "JSXIdentifier"
+    ) {
+      isAffected =
+        flowNamespaces.has(name.object.name) &&
+        affectedComponents.has(name.property.name);
+    }
+
+    if (!isAffected) {
+      return;
+    }
+
+    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();
+};
+
+export default colorPrimaryToDefaultTransform;

package/src/migrations/imports-to-package-root/transform.ts

@@ -0,0 +1,107 @@
+import type { Transform } from "jscodeshift";
+
+/**
+ * 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: Transform = (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();
+};
+
+export default importsToPackageRootTransform;

package/src/migrations/muted-action-error-to-abort-action-error/transform.ts

@@ -0,0 +1,260 @@
+import type { Transform } from "jscodeshift";
+
+/**
+ * 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: Transform = (
+  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: string): boolean =>
+    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: object): boolean =>
+    (specifier as { importKind?: string }).importKind === "type";
+  const makeValueImport = (specifier: object): void => {
+    (specifier as { importKind?: string }).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<string>();
+  /** Local names whose identifier itself has to be renamed (no alias in play). */
+  const localRenames = new Set<string>();
+  /** Local names of `import * as Flow` namespace imports from a Flow package. */
+  const flowNamespaces = new Set<string>();
+
+  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<string>();
+
+  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: typeof specifiers = [];
+
+    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:
+      | {
+          type: string;
+          name?: unknown;
+          object?: { type: string; name?: unknown } | null;
+          property?: { type: string; name?: unknown } | null;
+        }
+      | null
+      | undefined,
+  ): boolean => {
+    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();
+};
+
+export default mutedActionErrorToAbortActionErrorTransform;