fix bug in subscribe with param

package.json

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

src/Frontend.ts

         const info:T.ExtendedRpcInfo[] = await this.info()
         info.forEach(i => {
             let f: any
+            
             switch (i.type) {
                 case 'Call':
                     f = this.callGenerator(i.uniqueName, i.argNames, sesame)    
      * @param fnArgs A string-list of parameters
      */
     private frontEndHookGenerator(fnName: string, fnArgs:string[], sesame?:string): T.HookFunction{
-        fnArgs.pop()
+        
+        if(sesame)
+            fnArgs.shift()
+
         let headerArgs = fnArgs.join(",")
         const argParams = fnArgs.map(stripAfterEquals).join(",")
-        sesame = appendComma(sesame)
-        headerArgs = appendComma(headerArgs) 
+        sesame = appendComma(sesame, true)
+        headerArgs = fnArgs.length>0?headerArgs+",":headerArgs 
 
         return eval( `
         async (${headerArgs} callback) => {
+
             const r = await this.socket.call("${fnName}", ${sesame} ${argParams})
             if(r && r.result === 'Success'){
                 this.socket.hook(r.uuid, callback)

src/Utils.ts

     const args = sesameFn?(['sesame', ...argsArr].join(','))
                          :callArgs
 
-    callArgs = appendComma(callArgs)
+    callArgs = appendComma(callArgs, false)
 
     //note rpc.hook is the associated RPC, not a socket.hook
     return eval(`
  */
 const extractArgs = (f:Function):string[] => {
     let fn:string
-    return (fn = String(f)).substr(0, fn.indexOf(")")).substr(fn.indexOf("(")+1).split(",")
+    fn = (fn = String(f)).substr(0, fn.indexOf(")")).substr(fn.indexOf("(")+1)
+    return fn!==""?fn.split(',') : []
 }
 
 /**
 }
 
 
-export function appendComma(s?:string):string{
-    return s?`'${s}',`:"" 
+export function appendComma(s?:string, turnToString = true):string{
+    if(turnToString)   
+        return s?`'${s}',`:"" 
+        return s?`${s},`:"" 
 }
 
 

test/Test.ts

 describe('It should do unhook', () => {
     let candy = "OK"
     let cb: Function
+    let cb2: Function
     let client: RPCSocket
     let server: RPCServer<{topic: string}> 
 
                     }
                 }
             }, 
+            {
+                name: 'subscribeWithParam',
+                hook: async(param, callback):Promise<SubscriptionResponse<{topic:string}>> => {
+                    
+                    if(param != "OK"){
+                        console.log("param was"+ param);
+                        return {
+                            result: "Success",
+                            uuid: "no",
+                            topic: "test"
+                        }
+                    }
+                    cb2 = <Function> callback
+                    return {
+                        result: "Success",
+                        uuid: "OK",
+                        topic: "test"
+                    }
+                }
+            },
             function checkCandy():string { cb(candy); return candy },
             function stealCandy():string { candy = "_OK"; cb(candy); cb = () => {}; return candy }
         ]
         server.destroy()
     })
 
+    it('Subscribe with param', (done) => {
+        client['test'].subscribeWithParam("OK", c => {}).then( async (res: SubscriptionResponse) => {
+            if(res.uuid === "OK"){
+                done()
+            }else
+                done(new Error("Results did not match "+res.uuid))
+        })
+    })
+
     it('Unhook+unsubscribe should stop callbacks', (done) => {
         client['test'].subscribe(c => {}).then( async (res: SubscriptionResponse) => {
             const r1 = await client['test'].checkCandy()
     })
 })
 
+type myExporterIfc = {
+    MyExporter: {
+        myRPC: ()=>Promise<string>
+    }
+}
+
 
 describe("Class binding", ()=>{
 
-    class MyExporter implements RPCExporter{
-        name = "MyExporter";
+    class MyExporter implements RPCExporter<myExporterIfc>{
+        name = "MyExporter" as "MyExporter";
         exportRPCs = () => [
             this.myRPC
         ]
 
-        myRPC = () => "Hello World"
+        myRPC = async () => "Hello World"
 
     }
+    let serv: RPCServer,
+        sock: RPCSocket,
+        exporter: MyExporter
+        
+    before((done)=>{
+        exporter = new MyExporter()
+        serv = new RPCServer(21004, [exporter])
+        sock = new RPCSocket(21004, 'localhost')
+        sock.connect<myExporterIfc>().then(_ => done())
+    })
+    after(() => {
+        sock.destroy()
+        serv.destroy()
+    })
 
     it("binds correctly", (done)=>{
-        const exporter = new MyExporter()
-        const serv = new RPCServer(21004, [exporter])
-        const sock = new RPCSocket(21004, 'localhost')
-        sock.connect().then(sock => {
-            if(sock.MyExporter && sock.MyExporter.myRPC){
-                done()
-            }
-        })
-        .catch(done)
-        .finally(() => {
-            sock.destroy()
-            serv.destroy()
+        sock['MyExporter'].myRPC().then(() => {
+            done()
         })
     })
 })