@mittwald/flow-codemods 1.1.0 → 1.1.2

package/src/migrations/button-props-interfaces/transform.ts

@@ -1,229 +0,0 @@
-import type { Transform } from "jscodeshift";
-
-/**
- * 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: Transform = (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: string): string | undefined =>
-    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: object): boolean =>
-    (node as { importKind?: string }).importKind === "type";
-
-  const root = j(fileInfo.source, { parser: "tsx" });
-
-  /** Local identifiers that have 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>();
-  /** `package:local` pairs that already import `ButtonProps` from a root. */
-  const bound = new Set<string>();
-  /** `package:local` pairs that still need importing, and whether type-only. */
-  const wanted = new Map<
-    string,
-    { pkg: string; local: string; type: boolean }
-  >();
-
-  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: typeof specifiers = [];
-
-    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();
-};
-
-export default buttonPropsInterfacesTransform;

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

@@ -1,173 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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;