From de9515e91aded87253528cfb84881589b77a3948 Mon Sep 17 00:00:00 2001
From: lisez <mm4324@gmail.com>
Date: Mon, 27 May 2024 11:51:24 +0800
Subject: [PATCH] refactor: refactoring

---
 modules/runners/sequence.ts | 42 ++++++++++++++++++-------------------
 modules/runners/single.ts   | 33 +++++++++++++++++++++++++++++
 2 files changed, 54 insertions(+), 21 deletions(-)
 create mode 100644 modules/runners/single.ts

diff --git a/modules/runners/sequence.ts b/modules/runners/sequence.ts
index 14eb938..ab23969 100644
--- a/modules/runners/sequence.ts
+++ b/modules/runners/sequence.ts
@@ -1,45 +1,45 @@
 import type { EventHandlerSignature } from "modules/types.ts";
 
+import { SingleRunner } from "modules/runners/single.ts";
+
 /**
  * Run handlers in sequence.
  */
-export class SequenceRunner {
+export class SequenceRunner<
+  T extends EventHandlerSignature<any> = EventHandlerSignature<any>,
+> {
   /**
    * Create a new instance of the SequenceRunner.
    * @param handlers The handlers to run.
    */
-  constructor(private handlers: EventHandlerSignature<any>[]) {
+  constructor(private handlers: T[]) {
     this.handlers = handlers;
   }
 
-  /**
-   * Wait for the handler to finish before moving to the next handler.
-   * @param pointer The current handler index.
-   * @param profile The handler profile.
-   * @param args The arguments to pass to the handlers.
-   */
-  private asyncExec(
-    pointer: number,
-    profile: EventHandlerSignature<any>,
-    ...args: any[]
-  ): Promise<void> {
-    return Promise.resolve(profile.handler(...args)).then(() =>
-      this.exec(pointer + 1, ...args)
-    );
-  }
-
   /**
    * Execute the handlers in sequence.
    * @param pointer The current handler index.
    * @param args The arguments to pass to the handlers.
    */
-  exec(pointer: number = 0, ...args: any[]): void | Promise<void> {
+  exec(
+    pointer: number = 0,
+    ...args: Parameters<T["handler"]>
+  ): void | Promise<void> {
     const profile = this.handlers[pointer];
     if (!profile) return;
+
+    const result = new SingleRunner<T>(profile).exec(
+      ...args,
+    );
+
+    /**
+     * Wait for the handler to finish before moving to the next handler.
+     */
     if (profile.options?.async) {
-      return this.asyncExec(pointer, profile, ...args);
+      return Promise.resolve(result).then(() =>
+        this.exec(pointer + 1, ...args)
+      );
     }
-    profile.handler(...args);
     return this.exec(pointer + 1, ...args);
   }
 }
diff --git a/modules/runners/single.ts b/modules/runners/single.ts
new file mode 100644
index 0000000..7ebac0b
--- /dev/null
+++ b/modules/runners/single.ts
@@ -0,0 +1,33 @@
+import { EventHandlerSignature } from "modules/types.ts";
+
+/**
+ * The result of a single runner.
+ */
+export type SingleRunnerResult<T extends (...args: any[]) => any> = ReturnType<
+  T
+>;
+
+/**
+ * Run a handler.
+ */
+export class SingleRunner<
+  T extends EventHandlerSignature<any> = EventHandlerSignature<any>,
+> {
+  /**
+   * Create a new instance of the SingleRunner.
+   * @param profile The handler profile.
+   */
+  constructor(private profile: T) {
+    this.profile = profile;
+  }
+
+  /**
+   * Execute the handler.
+   * @param args The arguments to pass to the handler.
+   */
+  exec(
+    ...args: Parameters<T["handler"]>
+  ): SingleRunnerResult<T["handler"]> {
+    return this.profile.handler(...args);
+  }
+}