cli.ts

import { Command } from "@commander-js/extra-typings";
import * as fs from "fs/promises";
import * as oldFs from "fs";
import * as path from "path";
import { toTypescript } from ".";

const packageContents = oldFs.readFileSync(path.join(__dirname, "../package.json"), {
    encoding: "utf-8",
});
const json = JSON.parse(packageContents);

export const program = new Command()
  .version(json["version"])
  .argument("<path>")
  .option("--outdir <dir>")
  .action(async (path, opts) => {
    await compile(path, opts);
  });

type Opts = ReturnType<typeof program.opts>;

async function compile(target: string, opts: Opts) {
  const realpath = await fs.realpath(target);
  const dirinfo = await fs.stat(realpath);
  if(dirinfo.isDirectory()) {
    return compileDir(target, {
      outpath: opts.outdir || "",
    });
  }
  if(dirinfo.isFile()) {
    return compileFile(target, {
      outpath: opts.outdir ? path.join(opts.outdir, path.basename(target)) : target,
    });
  }

  throw `${realpath} is neither a file nor a directory`;
}

type CompileOpts = {
  outpath: string,
};

export async function compileFile(filepath: string, opts: CompileOpts) {
  const contents = await fs.readFile(filepath, { encoding: 'utf-8' });
  const ts = toTypescript(filepath, contents);

  await fs.mkdir(path.dirname(opts.outpath), {
    recursive: true,
  });

  await fs.writeFile(opts.outpath + ".ts", ts);
}

export async function compileDir(dirpath: string, opts: CompileOpts) {
  const files = await fs.opendir(dirpath);
  let file;
  while(file = await files.read()) {
    console.log(`Compiling ${file.name}...`);

    const outpath = path.join(opts.outpath, file.name);
    if(file.isDirectory()) {
      await compileDir(path.join(dirpath, file.name), {
        outpath,
      });
    }
    else {
      await compileFile(path.join(dirpath, file.name), {
        outpath,
      });
    }
  }
}