fix attaching listeners before connecting

package.json

 {
   "name": "rpclibrary",
-  "version": "1.7.1",
+  "version": "1.8.0",
   "description": "rpclibrary is a websocket on steroids!",
   "main": "./js/Index.js",
   "repository": {

src/Backend.ts

             if(conf.connectionHandler) conf.connectionHandler(socket)
         }
 
-        exporters.forEach(U.fixNames)
+        exporters.forEach(U.fixNames) //TSC for some reason doesn't preserve name properties of methods
 
         let badRPC = exporters.flatMap(ex => ex.exportRPCs()).find(rpc => !rpc.name)
         if(badRPC){
-            console.log(badRPC);
-            
-
             throw new Error(`
             RPC did not provide a name. 
             \nUse 'funtion name(..){ .. }' syntax instead.

src/Frontend.ts

     }
 
     private socket: I.Socket
+    private closeHandlers: T.CloseHandler[] = []
+    private errorHandlers: T.ErrorHandler[] = []
+    private hooks : {[name in string]: T.AnyFunction} = {} 
 
     /**
      * 
      * @param handler The handler to attach
      */
     public hook(name: string, handler: (...args:any[]) => any | Promise<any>){
-        return this.socket.hook(name, handler)
+        if(!this.socket){
+            this.hooks[name] = handler
+        }else{
+            this.socket.hook(name, handler)
+        }
     }
 
     /**
      * @param name The function name 
      */
     public unhook(name: string){
-        return this.socket.unhook(name)
+        if(!this.socket){
+            delete this.hooks[name]
+        }else{
+            this.socket.unhook(name)
+        }
     }
 
     /**
      * @param type 'error' or 'close'
      * @param f The listener to attach
      */
-    public on(type: "error" | "close", f: (e?: any) => void){
-        return this.socket.on(type, f)
+    public on<T extends "error" | "close">(type: T, f: T.HandlerType[T]){
+        if(!this.socket){
+            switch(type){
+                case "error": this.errorHandlers.push(<T.HandlerType['error']> f); break;
+                case "close": this.closeHandlers.push(<T.HandlerType['close']> f); break;
+                default: throw new Error('socket.on only supports ´error´ and ´close´ as first parameter. Got: ´'+type+'´')
+            }
+        }else{
+            this.socket.on(type, f)
+        }
     }
 
     /**
      * Destroys the socket
      */
     public destroy(){
-        return this.socket.destroy()
+        if(!this.socket) return;
+        this.socket.destroy()
     }
 
     /**
      * Closes the socket. It may attempt to reconnect.
      */
     public close(){
-        return this.socket.close()
+        if(!this.socket) return;
+        this.socket.close()
     }
 
     /**
      * @param args other arguments
      */
     public async call (rpcname: string, ...args: any[]) : Promise<any>{
+        if(!this.socket) throw new Error("The socket is not connected! Use socket.connect() first")
         return await this.socket.call.apply(this.socket, [rpcname, ...args])
     }
 
      * @param args other arguments
      */
     public async fire(rpcname: string, ...args: any[]) : Promise<void>{
+        if(!this.socket) throw new Error("The socket is not connected! Use socket.connect() first")
         await this.socket.fire.apply(this.socket, [rpcname, ...args])
     }
     
      */
     public async connect<T extends T.RPCInterface= T.RPCInterface>( sesame?: string ) : Promise<RPCSocket & T>{
         this.socket = await bsock.connect(this.port, this.server, this.conf.tls?this.conf.tls:false)
+        this.errorHandlers.forEach(h => this.socket.on('error', h))
+        this.closeHandlers.forEach(h => this.socket.on('close', h))
+        Object.entries(this.hooks).forEach((kv: [string, T.AnyFunction]) => {
+            this.socket.hook(kv[0], kv[1])
+        })
 
         const info:T.ExtendedRpcInfo[] = await this.info()
         info.forEach(i => {
      * Get a list of available RPCs from the server
      */
     public async info(){
+        if(!this.socket) throw new Error("The socket is not connected! Use socket.connect() first")
         return await this.socket.call('info')
     }
 
             const r = await this.socket.call("${fnName}", ${sesame} ${argParams})
             if(r && r.result === 'Success'){
                 this.socket.hook(r.uuid, callback)
-                this.socket.on('error', e => this.socket.unhook(r.uuid))
             }
             return r
         }`)

src/Interfaces.ts

  */
 export interface Socket extends Destroyable {
     port: number
-    hook: (rpcname: string, handler: T.AnyFunction) => I.Socket
-    unhook: (rpcname:string) => I.Socket
+    hook: (rpcname: string, handler: T.AnyFunction) => void
+    unhook: (rpcname:string) => void
     call: (rpcname:string, ...args: any[]) => Promise<any>
     fire: (rpcname:string, ...args: any[]) => Promise<any>
     on: T.OnFunction    

src/Types.ts

 export type SesameConf = {
     sesame?: string | SesameFunction
 }
+export type HandlerType = {
+    'error' : ErrorHandler
+    'close' : CloseHandler
+}
+
 export type ServerConf = {
     connectionHandler?: ConnectionHandler
     errorHandler?: ErrorHandler
 export type RpcInfo = HookInfo |  CallInfo
 export type ExtendedRpcInfo = RpcInfo & { uniqueName: string } 
 
-export type OnFunction = (type: 'error' | 'close', f: (e?:any)=>void) => I.Socket
+export type OnFunction = <T extends "error" | "close">(type: T, f: HandlerType[T]) => void
 export type HookCloseFunction<T = {}> = (res:SubscriptionResponse<T>, rpc:HookRPC<any, any, T>) => any

test/Test.ts

             done()
         })
     })
+})
+
+
+describe("attaching handlers before connecting", ()=>{
+
+
+    it("fires error if server is unreachable", (done)=>{
+        const sock = new RPCSocket(21004, 'localhost')
+        let errorHandleCount = 0
+
+        sock.on('error', (socket) => {
+            //attached listener fires first
+            if(errorHandleCount != 0){
+                console.log("Error handler didn't fire first");
+            }else{
+                errorHandleCount++
+            }
+        })
+
+        sock.connect().then(_ => {
+            console.log("Unexpected successful connect")
+        }).catch(e => {
+            //catch clause fires second
+            if(errorHandleCount != 1){
+                console.log("catch clause didn't fire second");
+            }else{
+                sock.destroy()
+                done()
+            }
+        })
+    })
 })