Type sub event handler (#156)

* RelayEvent allow Promises

* type Sub EventHandler

* Update relay.ts

pool.ts

@@ -107,19 +107,17 @@ export class SimplePool {
         subs.forEach(sub => sub.unsub())
       },
       on(type, cb) {
-        switch (type) {
-          case 'event':
+        if (type === 'event') {
           eventListeners.add(cb)
-            break
-          case 'eose':
-            eoseListeners.add(cb)
-            break
+        } else if (type === 'eose') {
+          eoseListeners.add(cb as () => void | Promise<void>)
         }
       },
       off(type, cb) {
         if (type === 'event') {
           eventListeners.delete(cb)
-        } else if (type === 'eose') eoseListeners.delete(cb)
+        } else if (type === 'eose')
+          eoseListeners.delete(cb as () => void | Promise<void>)
       }
     }
 

relay.ts

@@ -5,12 +5,15 @@ import {Filter, matchFilters} from './filter'
 import {getHex64, getSubscriptionId} from './fakejson'
 
 type RelayEvent = {
-	connect: () => void
-	disconnect: () => void
-	error: () => void
-	notice: (msg: string) => void
+  connect: () => void | Promise<void>
+  disconnect: () => void | Promise<void>
+  error: () => void | Promise<void>
+  notice: (msg: string) => void | Promise<void>
+}
+type SubEvent = {
+  event: (event: Event) => void | Promise<void>
+  eose: () => void | Promise<void>
 }
-
 export type Relay = {
   url: string
   status: number
@@ -20,8 +23,14 @@ export type Relay = {
   list: (filters: Filter[], opts?: SubscriptionOptions) => Promise<Event[]>
   get: (filter: Filter, opts?: SubscriptionOptions) => Promise<Event | null>
   publish: (event: Event) => Pub
-  off: <T extends keyof RelayEvent, U extends RelayEvent[T]>(event: T, listener: U) => void
-  on: <T extends keyof RelayEvent, U extends RelayEvent[T]>(event: T, listener: U) => void
+  off: <T extends keyof RelayEvent, U extends RelayEvent[T]>(
+    event: T,
+    listener: U
+  ) => void
+  on: <T extends keyof RelayEvent, U extends RelayEvent[T]>(
+    event: T,
+    listener: U
+  ) => void 
 }
 export type Pub = {
   on: (type: 'ok' | 'failed', cb: any) => void
@@ -30,8 +39,14 @@ export type Pub = {
 export type Sub = {
   sub: (filters: Filter[], opts: SubscriptionOptions) => Sub
   unsub: () => void
-  on: (type: 'event' | 'eose', cb: any) => void
-  off: (type: 'event' | 'eose', cb: any) => void
+  on: <T extends keyof SubEvent, U extends SubEvent[T]>(
+    event: T,
+    listener: U
+  ) => void
+  off: <T extends keyof SubEvent, U extends SubEvent[T]>(
+    event: T,
+    listener: U
+  ) => void
 }
 
 export type SubscriptionOptions = {
@@ -51,17 +66,14 @@ export function relayInit(
 
   var ws: WebSocket
   var openSubs: {[id: string]: {filters: Filter[]} & SubscriptionOptions} = {}
-  var listeners: { [TK in keyof RelayEvent]: RelayEvent[TK][]} = {
+  var listeners: {[TK in keyof RelayEvent]: RelayEvent[TK][]} = {
     connect: [],
     disconnect: [],
     error: [],
     notice: []
   }
   var subListeners: {
-    [subid: string]: {
-      event: Array<(event: Event) => void>
-      eose: Array<() => void>
-    }
+    [subid: string]: {[TK in keyof SubEvent]: SubEvent[TK][]}
   } = {}
   var pubListeners: {
     [eventid: string]: {
@@ -225,14 +237,20 @@ export function relayInit(
         delete subListeners[subid]
         trySend(['CLOSE', subid])
       },
-      on: (type: 'event' | 'eose', cb: any): void => {
+      on: <T extends keyof SubEvent, U extends SubEvent[T]>(
+        type: T,
+        cb: U
+      ): void => {
         subListeners[subid] = subListeners[subid] || {
           event: [],
           eose: []
         }
         subListeners[subid][type].push(cb)
       },
-      off: (type: 'event' | 'eose', cb: any): void => {
+      off: <T extends keyof SubEvent, U extends SubEvent[T]>(
+        type: T,
+        cb: U
+      ): void => {
         let listeners = subListeners[subid]
         let idx = listeners[type].indexOf(cb)
         if (idx >= 0) listeners[type].splice(idx, 1)
@@ -243,14 +261,20 @@ export function relayInit(
   return {
     url,
     sub,
-	on: <T extends keyof RelayEvent, U extends RelayEvent[T]>(type: T, cb: U): void => {
+    on: <T extends keyof RelayEvent, U extends RelayEvent[T]>(
+      type: T,
+      cb: U
+    ): void => {
       listeners[type].push(cb)
       if (type === 'connect' && ws?.readyState === 1) {
         // i would love to know why we need this
-			(cb as ()=> void)()
+        ;(cb as () => void)()
       }
     },
-	off: <T extends keyof RelayEvent, U extends RelayEvent[T]>(type: T, cb: U): void => {
+    off: <T extends keyof RelayEvent, U extends RelayEvent[T]>(
+      type: T,
+      cb: U
+    ): void => {
       let index = listeners[type].indexOf(cb)
       if (index !== -1) listeners[type].splice(index, 1)
     },