Add: progress message & additional log

package.json

@@ -51,6 +51,7 @@
     "docs": "typedoc src/index.ts"
   },
   "dependencies": {
+    "ora": "^6.1.2",
     "ts-morph": "^15.1.0",
     "yargs": "^17.5.1"
   },

src/EjectEnum.ts

@@ -12,6 +12,7 @@ import {
   SyntaxKind,
   VariableDeclarationKind,
 } from "ts-morph";
+import { initProgressLogger, ProgressLogger } from "./ProgressLogger";
 
 /**
  * Target of the conversion. You can specify one of:
@@ -80,6 +81,18 @@ function addSourceFilesInTarget(project: Project, target: EjectEnumTarget) {
   }
 }
 
+/**
+ * Additional options for the conversion.
+ */
+export type EjectEnumOptions = {
+  /**
+   * If `true`, all outputs are suppressed.
+   *
+   * @defaultValue `false`
+   */
+  silent?: boolean;
+};
+
 /**
  * Ejects enums from all files specified by `target`.
  *
@@ -102,33 +115,56 @@ function addSourceFilesInTarget(project: Project, target: EjectEnumTarget) {
  * ```
  *
  * @param target Target specification of the conversion.
+ * @param options Additional options for the conversion.
  */
-export function ejectEnum(target: EjectEnumTarget) {
+export function ejectEnum(
+  target: EjectEnumTarget,
+  { silent = false }: EjectEnumOptions = {}
+) {
   const project = new Project();
   addSourceFilesInTarget(project, target);
 
+  const progLogger = initProgressLogger(silent);
+  progLogger.start(project.getSourceFiles().length);
+
   for (const srcFile of project.getSourceFiles()) {
-    ejectEnumFromSourceFile(srcFile);
+    ejectEnumFromSourceFile(srcFile, progLogger);
   }
+
+  progLogger.finish();
+
   project.saveSync();
 }
 
 // Ejects enums from single source file.  It is exported for the purpose of testing.
-export function ejectEnumFromSourceFile(srcFile: SourceFile) {
+export function ejectEnumFromSourceFile(
+  srcFile: SourceFile,
+  progLogger?: ProgressLogger
+) {
   const ctx: EjectionContext = {
     rootSrcFile: srcFile,
     probe: new EjectionProbe(),
+    progLogger,
   };
 
   // convert top-level statements
   ejectEnumFromStatementedNode(srcFile, ctx);
   // convert nested statements
   srcFile.forEachDescendant(statementedNodesVisitor(ctx));
 
-  // format file only if at least one ejection happened.
   if (ctx.probe.ejected) {
+    const n = ctx.probe.numEjected;
+    ctx.progLogger?.log(
+      `${path.relative(
+        process.cwd(),
+        ctx.rootSrcFile.getFilePath()
+      )}: ejected ${n} enum${n >= 2 ? "s" : ""}.`
+    );
+
+    // format file only if at least one ejection happened.
     srcFile.formatText();
   }
+  ctx.progLogger?.notifyFinishFile();
 }
 
 function statementedNodesVisitor(ctx: EjectionContext): (node: Node) => void {
@@ -151,20 +187,20 @@ function ejectEnumFromStatementedNode(
   node: StatementedNode,
   ctx: EjectionContext
 ) {
-  node.getEnums().forEach((enumDecl) => {
+  for (const enumDecl of node.getEnums()) {
     if (!isEjectableEnum(enumDecl)) {
-      console.error(
+      ctx.progLogger?.log(
         `${path.relative(
           process.cwd(),
           ctx.rootSrcFile.getFilePath()
         )} > ${enumDecl.getName()}: it has a member whose value can't be known at compile-time. skipped.`
       );
-      return;
+      continue;
     }
 
     convertEnumDeclaration(node, enumDecl, enumDecl.getChildIndex());
-    ctx.probe.setEjected();
-  });
+    ctx.probe.notifyEjected();
+  }
 }
 
 function isEjectableEnum(enumDecl: EnumDeclaration): boolean {
@@ -284,23 +320,28 @@ function getLeadingCommentsAssociatedWithDecl(
 
 // Object to detect an ejection of enum.
 class EjectionProbe {
-  #ejected: boolean;
+  #numEjected: number;
 
   constructor() {
-    this.#ejected = false;
+    this.#numEjected = 0;
   }
 
   get ejected(): boolean {
-    return this.#ejected;
+    return this.#numEjected > 0;
+  }
+
+  get numEjected(): number {
+    return this.#numEjected;
   }
 
-  setEjected() {
-    this.#ejected = true;
+  notifyEjected() {
+    this.#numEjected++;
   }
 }
 
 // Context of the conversion of single source file.
 type EjectionContext = {
   rootSrcFile: SourceFile;
   probe: EjectionProbe;
+  progLogger: ProgressLogger | undefined;
 };

src/ProgressLogger.ts

@@ -0,0 +1,68 @@
+import ora, { Ora } from "ora";
+
+export interface ProgressLogger {
+  start(numFiles: number): void;
+  finish(): void;
+  notifyFinishFile(): void;
+  log(l: string): void;
+}
+
+export const initProgressLogger = (silent: boolean): ProgressLogger =>
+  silent ? noopProgressLogger : new DefaultProgressLogger();
+
+const progressText = (numFinished: number, numFiles: number): string =>
+  `Ejecting... ${numFinished}/${numFiles} (${(
+    (numFinished / numFiles) *
+    100
+  ).toFixed(0)}%)`;
+
+class DefaultProgressLogger implements ProgressLogger {
+  #spinner: Ora;
+
+  #numFiles = 0;
+  #numFinished = 0;
+
+  constructor() {
+    this.#spinner = ora();
+  }
+
+  public start(numFiles: number) {
+    this.#numFiles = numFiles;
+    this.#spinner.text = progressText(0, this.#numFiles);
+
+    this.#spinner.render();
+  }
+
+  public finish() {
+    this.#spinner.succeed("Ejection finished");
+  }
+
+  public notifyFinishFile() {
+    this.#numFinished++;
+    this.#spinner.text = progressText(this.#numFinished, this.#numFiles);
+    this.#spinner.render();
+  }
+
+  public log(l: string) {
+    this.#spinner.clear();
+
+    console.log(l);
+
+    this.#spinner.render();
+  }
+}
+
+const noopProgressLogger: ProgressLogger = {
+  start() {
+    /* no-op */
+  },
+  finish() {
+    /* no-op */
+  },
+  notifyFinishFile() {
+    /* no-op */
+  },
+  log() {
+    /* no-op */
+  },
+};

src/index.ts

@@ -1 +1,2 @@
 export { ejectEnum, EjectEnumTarget } from "./EjectEnum";
+export type { EjectEnumOptions } from "./EjectEnum";

src/main.ts

@@ -1,60 +1,65 @@
+import type { Argv as YargsArgv } from "yargs";
 import { hideBin } from "yargs/helpers";
 import yargs from "yargs/yargs";
+import type { EjectEnumOptions } from "./EjectEnum";
 import { ejectEnum, EjectEnumTarget } from "./EjectEnum";
 
+const argvParser = yargs(hideBin(process.argv))
+  .option("project", {
+    alias: "p",
+    type: "string",
+    array: true,
+    description: "Paths to TS config files",
+    default: [] as string[],
+  })
+  .option("include", {
+    alias: "i",
+    type: "string",
+    array: true,
+    description: "Paths to include in the conversion target",
+    default: [] as string[],
+  })
+  .option("exclude", {
+    alias: "e",
+    type: "string",
+    array: true,
+    description:
+      "Paths to exclude from the conversion target.\nYou CAN'T exclude paths included by TS configs of --project by this option!",
+    default: [] as string[],
+  })
+  .option("silent", {
+    type: "boolean",
+    description: "Suppress outputs",
+    default: false,
+  })
+  .usage(
+    "usage: $0 [--project path/to/tsconfig.json] [--include path/to/include [--exclude path/to/exclude]]"
+  )
+  .help();
+
 // entrypoint of the CLI.
 export function main() {
-  const argvParser = yargs(hideBin(process.argv))
-    .option("project", {
-      alias: "p",
-      type: "string",
-      array: true,
-      description: "Paths to TS config files",
-      default: [] as string[],
-    })
-    .option("include", {
-      alias: "i",
-      type: "string",
-      array: true,
-      description: "Paths to include in the conversion target",
-      default: [] as string[],
-    })
-    .option("exclude", {
-      alias: "e",
-      type: "string",
-      array: true,
-      description:
-        "Paths to exclude from the conversion target.\nYou CAN'T exclude paths included by TS configs of --project by this option!",
-      default: [] as string[],
-    })
-    .usage(
-      "usage: $0 [--project path/to/tsconfig.json] [--include path/to/include [--exclude path/to/exclude]]"
-    )
-    .help();
-
   const argv = argvParser.parseSync();
 
   let target: EjectEnumTarget;
   try {
-    target = optionsFromArgv(argv);
+    target = targetFromArgv(argv);
   } catch (e) {
     console.error(`${e}`);
     argvParser.showHelp();
     process.exit(1);
   }
 
-  ejectEnum(target);
+  ejectEnum(target, optionsFromArgv(argv));
 }
 
-type ParsedArgv = {
-  project: string[];
-  include: string[];
-  exclude: string[];
-};
+type ParsedArgv = typeof argvParser extends YargsArgv<infer T> ? T : never;
+type KeysAboutTarget = "project" | "include" | "exclude";
 
-// gets EjectEnumOptions from parsed command arguments.
 // throws if pre-conditions about the arguments are not satisfied.
-export function optionsFromArgv(argv: ParsedArgv): EjectEnumTarget {
+export function targetFromArgv(
+  argv: Pick<ParsedArgv, KeysAboutTarget>
+): EjectEnumTarget {
   if (argv.project.length === 0 && argv.include.length === 0) {
     throw Error("specify at least one of --project or --include");
   }
@@ -66,3 +71,9 @@ export function optionsFromArgv(argv: ParsedArgv): EjectEnumTarget {
         exclude: argv.exclude,
       });
 }
+
+export function optionsFromArgv(
+  argv: Omit<ParsedArgv, KeysAboutTarget>
+): EjectEnumOptions {
+  return { silent: argv.silent };
+}

test/main.test.ts

@@ -1,15 +1,15 @@
 import { describe, expect, test } from "vitest";
 import { EjectEnumTarget } from "../src/EjectEnum";
-import { optionsFromArgv } from "../src/main";
+import { targetFromArgv } from "../src/main";
 
-describe("optionsFromArgv", () => {
+describe("targetFromArgv", () => {
   test("--project -> EjectTarget.tsConfig", () => {
     const argv = {
       project: ["tsconfig.json", "tsconfig2.json"],
       include: [],
       exclude: [],
     };
-    expect(optionsFromArgv(argv)).toEqual(
+    expect(targetFromArgv(argv)).toEqual(
       EjectEnumTarget.tsConfig(argv.project)
     );
   });
@@ -20,7 +20,7 @@ describe("optionsFromArgv", () => {
       include: ["src/**/*", "test/**/*"],
       exclude: ["src/hoge/*.ts", "src/fuga.ts"],
     };
-    expect(optionsFromArgv(argv)).toEqual(
+    expect(targetFromArgv(argv)).toEqual(
       EjectEnumTarget.paths({
         include: argv.include,
         exclude: argv.exclude,
@@ -34,7 +34,7 @@ describe("optionsFromArgv", () => {
       include: ["src/**/*", "test/**/*"],
       exclude: ["src/hoge/*.ts", "src/fuga.ts"],
     };
-    expect(optionsFromArgv(argv)).toEqual(
+    expect(targetFromArgv(argv)).toEqual(
       EjectEnumTarget.tsConfig(argv.project)
     );
   });
@@ -46,7 +46,7 @@ describe("optionsFromArgv", () => {
       exclude: ["hoge"],
     };
     expect(() => {
-      optionsFromArgv(argv);
+      targetFromArgv(argv);
     }).toThrow();
   });
 });