@mittwald/flow-codemods 1.1.0 → 1.1.2

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

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

package/src/migrations/password-tools-rule/transform.ts

@@ -1,219 +0,0 @@
-import type { Transform } from "jscodeshift";
-
-/**
- * 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: Transform = (fileInfo, { j }) => {
-  const flowPackages = [
-    "@mittwald/flow-react-components/mittwald-password-tools-js",
-  ];
-  const renames = new Map([
-    ["AsyncRule", "Rule"],
-    ["SyncRule", "Rule"],
-  ]);
-
-  const isFlowImport = (source: string): boolean =>
-    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: 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 identifiers that refer to a renamed export, mapped to the new name. */
-  const localRenames = new Map<string, string>();
-  /**
-   * 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<string>();
-
-  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<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" ||
-        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: typeof specifiers = [];
-
-    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();
-};
-
-export default passwordToolsRuleTransform;

package/src/migrations/password-tools-subpath-renamed/transform.ts

@@ -1,61 +0,0 @@
-import type { Transform } from "jscodeshift";
-
-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: Transform = (fileInfo, { j }) => {
-  const root = j(fileInfo.source, { parser: "tsx" });
-  let changed = false;
-
-  const rewrite = (node: { value?: unknown }): void => {
-    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;
-};
-
-export default passwordToolsSubpathRenamedTransform;

package/src/tools/to-remote-package.ts

@@ -1,37 +0,0 @@
-import type { Transform } from "jscodeshift";
-
-/**
- * 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: 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 importPath = String(i.node.source.value);
-
-      i.node.source.value = importPath.replace(
-        flowPackage,
-        "@mittwald/flow-remote-react-components",
-      );
-    });
-
-  return root.toSource();
-};
-
-export default toRemotePackageTransform;