feat(hook): add beforeMerge, afterMerge, afterOutput hooks

- `afterOutput` will be executed after the file is output to the directory

BREAKING CHANGE: `afterGenerate` will be executed after the build is complete and before the file is
output

Author: NoraH1to

src/Generator.ts

@@ -6,6 +6,8 @@ import { GeneratorSource } from './Source';
 import { Hook, HookHelper } from './Hook';
 import { DirInfo } from './Dir';
 import np from 'normalize-path';
+import { isDir } from './utils';
+import { getConfirm } from './qa';
 
 import type { Ora } from 'ora';
 import type { SourceInfo } from './Source';
@@ -189,13 +191,41 @@ export class Generator<N extends string = string> {
     }
   }
 
-  public async clearTemp() {
-    await fs.rm(this.tempPathname, { recursive: true });
+  private async before() {
+    if (!fs.existsSync(this.target.pathname)) return;
+    let confirm = false;
+    if (isDir(this.target.pathname))
+      if (fs.readdirSync(this.target.pathname).length)
+        confirm = await getConfirm(
+          `The content in folder "${this.target.name}" will be deleted, whether to continue`,
+        );
+      else
+        confirm = await getConfirm(
+          `Existing file "${this.target.name}" will be deleted, whether to continue`,
+        );
+    if (!confirm) process.exit(0);
+    fs.rmSync(this.target.pathname, { recursive: true });
+    fs.ensureDirSync(this.target.pathname);
   }
 
-  private async output() {
-    this.spinner.start('Copy Files');
-    await fs.copy(this.tempPathname, this.target.pathname, { overwrite: true });
+  private async after() {
+    const pkg = this.targetDirInfo.get('/package.json', { type: 'file' });
+    if (pkg?.getJson()) {
+      const pkgJson = pkg.getJson();
+      pkgJson.name = this.target.name;
+      pkg.setContent(JSON.stringify(pkgJson));
+    }
+  }
+
+  private async output(map = this.targetDirInfo.getMap()) {
+    this.spinner.start('Output Files');
+    for (const item of Object.values(map)) {
+      if (item.isDir) this.output(item.getMap());
+      else {
+        fs.ensureFileSync(item.pathname);
+        fs.writeFileSync(item.pathname, (item as FileInfo).getContent());
+      }
+    }
   }
 
   private async installDeps() {
@@ -208,11 +238,20 @@ export class Generator<N extends string = string> {
 
   public async generate() {
     try {
+      await this.before();
+      await this.callHooks('beforeGenerate');
 
       await this.generateBase();
       await this.generateInject();
+      $.verbose = false;
+
+      await this.callHooks('afterGenerate', { targetDir: this.targetDirInfo });
+      await this.after();
+
       await this.output();
 
+      await this.callHooks('afterOutput');
+
       await this.installDeps();
 
       this.spinner.succeed(
@@ -225,8 +264,6 @@ export class Generator<N extends string = string> {
         chalk.redBright(this.spinner.text || 'Something error when generating'),
       );
       console.error(chalk.redBright((e as Error).stack));
-    } finally {
-      await this.clearTemp();
     }
   }
 }

src/Hook.ts

@@ -12,6 +12,7 @@ import VError from 'verror';
 import type { FileInfo } from './File';
 import type { SourceInfo, SOURCE_TYPE } from './Source';
 import type { AsyncOrCommon } from './utils';
+import type { DirInfo } from './Dir';
 
 export type HookHelpers = typeof ex & {
   inquirer: typeof inquirer;
@@ -22,7 +23,22 @@ export type HookHelpers = typeof ex & {
 export interface HookBase<P extends unknown[] = unknown[], R = unknown> {
   (...args: P): AsyncOrCommon<R>;
 }
+
+/**
+ * beforeGenerate -> beforeMerge -> onMerging -> afterMerge -> afterGenerate -> afterOutput
+ */
 export interface Hooks {
+  beforeGenerate?: HookBase;
+  beforeMerge?: HookBase<
+    [
+      options: {
+        srcDir: DirInfo;
+        destDir: DirInfo;
+        src: FileInfo;
+        dest: FileInfo;
+      },
+    ]
+  >;
   onMerging?: HookBase<
     [
       options: {
@@ -32,8 +48,24 @@ export interface Hooks {
     ],
     string
   >;
-  beforeMerge?: HookBase;
-  afterMerge?: HookBase;
+  afterMerge?: HookBase<
+    [
+      options: {
+        srcDir: DirInfo;
+        destDir: DirInfo;
+        src: FileInfo;
+        dest: FileInfo;
+      },
+    ]
+  >;
+  afterGenerate?: HookBase<
+    [
+      options: {
+        targetDir: DirInfo;
+      },
+    ]
+  >;
+  afterOutput?: HookBase;
 }
 
 interface HookConstructorOptions {
@@ -161,7 +193,9 @@ export class HookHelper {
       keys: ['__dir_src__', '__pathname_entry__'],
       onHasNot(_, key) {
         throw new VError(
-          `Base template ${base.name} is missing the "${String(key)}" key in meta`,
+          `Base template ${base.name} is missing the "${String(
+            key,
+          )}" key in meta`,
         );
       },
     });