Rename js files with @flow header to ts/tsx

index.ts

import { Stats } from "fs";
import { readdir, lstat, readFile, rename } from "fs/promises";
import path from "path";
import { transformAsync } from "@babel/core";

const isDry = !!process.argv.find((a) => a.includes("--dry"));
const jsExtRegex = /\.(js)$/;

async function* walkPath(
  basePath: string
): AsyncIterableIterator<{ path: string; stat: Promise<Stats> }> {
  try {
    for (const currentPath of await readdir(path.normalize(basePath))) {
      const fullPath = path.resolve(basePath, currentPath);
      const stat = lstat(fullPath);
      yield { path: fullPath, stat };
    }
  } catch {
    // Ignore
  }
}

interface PathWalkerOptions {
  yieldDir?: boolean;
  yieldFile?: boolean;
  depth?: number;
}

export async function* pathWalker(
  basePath: string,
  options: PathWalkerOptions = {}
): AsyncGenerator<string> {
  const { yieldDir = false, yieldFile = true, depth = Infinity } = options;
  try {
    for await (const { path, stat } of walkPath(basePath)) {
      const s = await stat;
      if (s.isDirectory()) {
        if (depth > 1) {
          yield* pathWalker(path, { ...options, depth: depth - 1 });
        }
        if (yieldDir) {
          yield path;
        }
      } else if (s.isFile() && yieldFile) {
        yield path;
      }
    }
  } catch {
    // Ignore
  }
}

async function main() {
  for (const sourceDir of ["./src", "./scripts"]) {
    for await (const filePath of pathWalker(
      path.resolve(process.cwd(), sourceDir)
    )) {
      const isJsFile = jsExtRegex.test(filePath);
      if (isJsFile) {
        const content = await readFile(filePath, "utf8");
        const isFlow = content.includes("// @flow");
        if (isFlow) {
          // strip flow types from content string using babel
          const result = await transformAsync(content, {
            filename: filePath,
            plugins: [
              "@babel/plugin-transform-flow-strip-types",
              [
                "@babel/plugin-transform-react-jsx",
                {
                  runtime: "automatic",
                },
              ],
            ],
          });

          if (filePath.includes("Camera.js")) {
            console.log("isFlow", isFlow);
          }
          const code = result?.code || "";
          const isJSX =
            code.includes("react/jsx-runtime") ||
            code.includes("React.Fragment") ||
            code.includes("React.createElement");
          const ext = isJSX ? "tsx" : "ts";
          const newFilePath = filePath.replace(/\.js$/, `.${ext}`);
          console.log(`${filePath} -> ${newFilePath}`);
          if (!isDry) {
            await rename(filePath, newFilePath);
          }
        }
      }
    }
  }
}

main();