StreamFn.events Promise[]

utils/ByteLengthStreamFn.ts

@@ -16,6 +16,15 @@ export function ByteLengthStreamFn(limit: number = Infinity): StreamFn<ByteLengt
 
   const ee = new TypeSafeEventEmitter<ByteLengthStreamEvents>();
 
+  const events = {
+    [resultEvent]: new Promise<ByteLengthStreamEvents[typeof resultEvent]>((resolve) => {
+      ee.once(resultEvent, resolve);
+    }),
+    [limitEvent]: new Promise<ByteLengthStreamEvents[typeof limitEvent]>((resolve) => {
+      ee.on(limitEvent, resolve);
+    }),
+  }
+
   async function* generator (this: unknown, source: Readable) {
     for await (const chunk of source) {
       byteLength += chunk.byteLength;
@@ -32,5 +41,5 @@ export function ByteLengthStreamFn(limit: number = Infinity): StreamFn<ByteLengt
 
   const stream = Duplex.from(generator);
 
-  return { stream, once: ee.once.bind(ee) };
+  return { stream, events };
 }

utils/FileFieldController.ts

@@ -28,14 +28,14 @@ export class FileFieldController {
   }
 
   private byteLength(): { stream: Duplex, byteLength: Promise<number> } {
-    const { stream, once } = ByteLengthStreamFn(this.config.maxFileByteLength);
+    const { stream, events } = ByteLengthStreamFn(this.config.maxFileByteLength);
 
     return {
       stream,
       byteLength: new Promise((resolve, reject) => {
-        once('byteLength', resolve);
+        events.byteLength.then(resolve);
         // TODO: Error
-        once('limit', (payload) => reject(payload))
+        events.limit.then(reject);
       })
     }
   }

utils/StreamFn.ts

@@ -3,5 +3,5 @@ import { EventConfig, TypeSafeEventEmitter } from "./TypeSafeEventEmitter";
 
 export type StreamFn<EC extends EventConfig> = {
   stream: Duplex,
-  once: TypeSafeEventEmitter<EC>['once']
+  events: { [E in keyof EC]: Promise<EC[E]> }
 };

utils/TypeSafeEventEmitter.ts

@@ -13,6 +13,10 @@ export class TypeSafeEventEmitter<EC extends EventConfig> {
     }
   }
 
+  on<E extends keyof EC>(event: E, listener: (payload: EC[E]) => void): void {
+    this.ee.on(event as string, listener);
+  }
+
   once<E extends keyof EC>(event: E, listener: (payload: EC[E]) => void): void {
     this.ee.once(event as string, listener);
   }