@xmobitea/gn-typescript-client 2.6.9 → 2.6.10-tsc

package/dist/runtime/networking/http/NetworkingPeerAxiosRequest.js

@@ -0,0 +1,179 @@
+import axios from "axios";
+import { GNHashtable } from "./../../common/GNData";
+import { Commands } from "./../../constant/Commands";
+import { GNSupport } from "./../../helper/GNSupport";
+import { GNDebug } from "./../../logger/GNDebug";
+import { HttpAppResponse, PostType } from "./HttpPeer";
+import { NetworkingHttpPeerBase } from "./NetworkingHttpPeerBase";
+import { ParameterCode } from "./../../constant/parameterCode/ParameterCode";
+import { GNNetwork } from "./../../GNNetwork";
+import { MessagePackConverterService } from "./../../helper/MessagePackConverterService";
+export class NetworkingPeerAxiosRequest extends NetworkingHttpPeerBase {
+    getRequest(subUri, onHttpAppResponse, timeout, authToken, secretKey, gameId) {
+        this.getRequestAxios(subUri, onHttpAppResponse, timeout, authToken, secretKey, gameId);
+    }
+    postRequest(subUri, param, postType, onHttpAppResponse, timeout, authToken, secretKey, customTags, gameId) {
+        this.postRequestAxios(subUri, param, postType, onHttpAppResponse, timeout, authToken, secretKey, customTags, gameId);
+    }
+    postRequestUpload(subUri, content, filename, mimetype, onHttpAppResponse, timeout) {
+        //GNDebug.logWarning("GN JS client sdk does not support upload file yet.");
+        // let httpAppResponse = new HttpAppResponse();
+        // httpAppResponse.error = "Upload file does not support in GN JS client sdk.";
+        // httpAppResponse.statusCode = -1;
+        // httpAppResponse.text = "[-3]";
+        // if (onHttpAppResponse != null) onHttpAppResponse(httpAppResponse);
+        this.postRequestUploadAxios(subUri, content, filename, mimetype, onHttpAppResponse, timeout);
+    }
+    async getRequestAxios(subUri, onHttpAppResponse, timeout, authToken, secretKey, gameId) {
+        let headers = {};
+        if (authToken)
+            headers[Commands.RequestAuthTokenCmd] = authToken;
+        if (secretKey)
+            headers[Commands.RequestSecretCmd] = secretKey;
+        if (gameId)
+            headers[Commands.RequestGameIdCmd] = gameId;
+        if (!GNSupport.isBrowser())
+            headers[Commands.USER_AGENT] = this.userAgent;
+        let httpAppResponse = new HttpAppResponse();
+        let targetUrl = this.httpUrl + "/" + subUri;
+        if (this.useReverseProxy) {
+            targetUrl = "/" + subUri;
+            headers[Commands.BaseUrl] = this.httpUrl;
+        }
+        try {
+            let result = await axios.get(targetUrl, {
+                headers: headers,
+                timeout: timeout * 1000,
+                responseType: "arraybuffer",
+            });
+            httpAppResponse.statusCode = result.status;
+            let buffers = this.toBuffers(result.data);
+            httpAppResponse.data = buffers[0];
+            httpAppResponse.text = buffers[1];
+        }
+        catch (error) {
+            httpAppResponse.error = error.toString();
+            httpAppResponse.statusCode = -1;
+            httpAppResponse.text = "[-2]";
+            GNDebug.logError(error);
+        }
+        if (onHttpAppResponse != null)
+            onHttpAppResponse(httpAppResponse);
+    }
+    async postRequestAxios(subUri, param, postType, onHttpAppResponse, timeout, authToken, secretKey, customTags, gameId) {
+        let headers = {};
+        if (authToken)
+            headers[Commands.RequestAuthTokenCmd] = authToken;
+        if (secretKey)
+            headers[Commands.RequestSecretCmd] = secretKey;
+        if (gameId)
+            headers[Commands.RequestGameIdCmd] = gameId;
+        if (!GNSupport.isBrowser())
+            headers[Commands.USER_AGENT] = this.userAgent;
+        if (param == null)
+            param = new GNHashtable();
+        if (customTags != null)
+            param.add(ParameterCode.CustomTags, customTags);
+        let body = null;
+        if (postType == PostType.Json) {
+            let content = param.toData();
+            body = content;
+            if (!GNSupport.isBrowser()) {
+                headers[Commands.CONTENT_LENGTH] = JSON.stringify(body).length;
+                headers[Commands.CONTENT_TYPE] = Commands.APPLICATION_JSON;
+            }
+            headers[Commands.ACCEPT] = Commands.APPLICATION_JSON;
+        }
+        else if (postType == PostType.MsgPack) {
+            let content = param.toData();
+            body = Buffer.from(MessagePackConverterService.serialize(content));
+            headers[Commands.CONTENT_TYPE] = Commands.APPLICATION_MSGPACK;
+            headers[Commands.ACCEPT] = Commands.APPLICATION_MSGPACK;
+            if (!GNSupport.isBrowser())
+                headers[Commands.CONTENT_LENGTH] = body.length;
+        }
+        let httpAppResponse = new HttpAppResponse();
+        let targetUrl = this.httpUrl + "/" + subUri;
+        if (this.useReverseProxy) {
+            targetUrl = "/" + subUri;
+            headers[Commands.BaseUrl] = this.httpUrl;
+        }
+        try {
+            if (postType == PostType.Json) {
+                let result = await axios.post(targetUrl, body, {
+                    headers: headers,
+                    timeout: timeout * 1000,
+                    responseType: "text",
+                });
+                httpAppResponse.statusCode = result.status;
+                // let buffers = this.toBuffers(result.data);
+                // httpAppResponse.data = buffers[0];
+                httpAppResponse.text = result.data;
+            }
+            else {
+                let result = await axios.post(targetUrl, body, {
+                    headers: headers,
+                    timeout: timeout * 1000,
+                    responseType: "arraybuffer",
+                });
+                httpAppResponse.statusCode = result.status;
+                let buffers = this.toBuffers(result.data);
+                httpAppResponse.data = buffers[0];
+                httpAppResponse.text = buffers[1];
+            }
+        }
+        catch (error) {
+            httpAppResponse.error = error.toString();
+            httpAppResponse.statusCode = -1;
+            httpAppResponse.text = "[-2]";
+            GNDebug.logError(error);
+        }
+        if (onHttpAppResponse != null)
+            onHttpAppResponse(httpAppResponse);
+    }
+    async postRequestUploadAxios(subUri, content, filename, mimetype, onHttpAppResponse, timeout) {
+        let formData = new FormData();
+        formData.append(Commands.File, new Blob([content], { type: mimetype }), filename);
+        let headers = {};
+        headers[Commands.RequestAuthTokenCmd] = GNNetwork.getAuthenticateStatus().getAuthToken();
+        ;
+        // if (!GNSupport.isBrowser()) {
+        //     headers[Commands.CONTENT_TYPE] = "multipart/form-data";
+        // }
+        let httpAppResponse = new HttpAppResponse();
+        let targetUrl = this.httpUrl + "/" + subUri;
+        if (this.useReverseProxy) {
+            targetUrl = "/" + subUri;
+            headers[Commands.BaseUrl] = this.httpUrl;
+        }
+        try {
+            let result = await axios.post(targetUrl, formData, {
+                headers: headers,
+                timeout: timeout * 1000,
+                responseType: "arraybuffer",
+            });
+            httpAppResponse.statusCode = result.status;
+            let buffers = this.toBuffers(result.data);
+            httpAppResponse.data = buffers[0];
+            httpAppResponse.text = buffers[1];
+        }
+        catch (error) {
+            httpAppResponse.error = error.toString();
+            httpAppResponse.statusCode = -1;
+            httpAppResponse.text = "[-2]";
+            GNDebug.logError(error);
+        }
+        if (onHttpAppResponse != null)
+            onHttpAppResponse(httpAppResponse);
+    }
+    uint8ArrayToString(uint8Array) {
+        return decodeURIComponent(escape(String.fromCharCode(...uint8Array)));
+    }
+    toBuffers(data) {
+        if (GNSupport.isBrowser()) {
+            data = new Uint8Array(data);
+            return [data, this.uint8ArrayToString(data)];
+        }
+        return [data, data.toString()];
+    }
+}

package/dist/runtime/networking/socket/NetworkingPeerSocketIOClient.js

@@ -0,0 +1,130 @@
+import { Commands } from "./../../constant/Commands";
+import { GNDebug } from "./../../logger/GNDebug";
+import { NetworkingSocketPeerBase, SocketPacket } from "./NetworkingSocketPeerBase";
+import { GNNetwork } from "./../../GNNetwork";
+import { OperationHelper } from "./../../entity/OperationHelper";
+import { Manager } from "socket.io-client";
+import { ParameterCode } from "./../../constant/parameterCode/ParameterCode";
+import { MessagePackConverterService } from "./../../helper/MessagePackConverterService";
+import { MessageType } from "./../../config/GNServerSettings";
+export class NetworkingPeerSocketIOClient extends NetworkingSocketPeerBase {
+    sendRequestAuthSocket() {
+        super.sendRequestAuthSocket();
+        if (this.clientId) {
+            this.socketManager.socket("/").emit(Commands.RequestAuthTokenCmd, GNNetwork.getAuthenticateStatus().getAuthToken());
+        }
+        ;
+    }
+    reInitNewSocket() {
+        super.reInitNewSocket();
+        if (this.socketManager == null) {
+            const url = new URL(this.url);
+            this.socketManager = new Manager(url.origin, {
+                path: url.pathname + "/socket.io",
+                reconnection: true,
+                reconnectionDelay: this.reconnectDelay,
+                timeout: this.pingTimeout,
+                autoConnect: false,
+                transports: ["websocket"]
+            });
+            let socket = this.socketManager.socket("/");
+            socket.on("connect", () => {
+                this.onConnect();
+            });
+            socket.on("disconnect", () => {
+                this.onDisconnect();
+            });
+            socket.on("error", (error) => {
+                this.onError(error);
+            });
+            socket.on(Commands.ResponseCmd_MsgPack, (args) => {
+                this.onResponseMsgPack(args);
+            });
+            socket.on(Commands.EventCmd_MsgPack, (args) => {
+                this.onEventMsgPack(args);
+            });
+            socket.on(Commands.ResponseCmd_Json, (args) => {
+                this.onResponseJson(args);
+            });
+            socket.on(Commands.EventCmd_Json, (args) => {
+                this.onEventJson(args);
+            });
+            this.socket = socket;
+        }
+    }
+    onResponseMsgPack(...args) {
+        this.responsePacketLst.push(new SocketPacket(args[0], true));
+    }
+    onEventMsgPack(...args) {
+        this.eventPacketLst.push(new SocketPacket(args[0], true));
+    }
+    onResponseJson(...args) {
+        this.responsePacketLst.push(new SocketPacket(args[0], false));
+    }
+    onEventJson(...args) {
+        this.eventPacketLst.push(new SocketPacket(args[0], false));
+    }
+    onConnect() {
+        GNDebug.log("[GN Socket RECV] HandleOpen " + this.socket.id);
+        this.clientId = this.socket.id;
+        this.onConnectHandler();
+    }
+    onDisconnect() {
+        GNDebug.log("[GN Socket RECV] HandleClose ");
+        this.clientId = "";
+        this.onDisconnectHandler();
+    }
+    onError(error) {
+        GNDebug.logError(error);
+    }
+    init(url, reconnectDelay, pingInterval, pingTimeout) {
+        super.init(url, reconnectDelay, pingInterval, pingTimeout);
+    }
+    emit(requestType, role, operationRequest, authToken, secretKey, customTags, gameId) {
+        super.emit(requestType, role, operationRequest, authToken, secretKey, customTags, gameId);
+        if (this.socketManager == null) {
+            // callback here
+            return;
+        }
+        let socket = this.socketManager.socket("/");
+        if (socket == null) {
+            // callback here
+            return;
+        }
+        if (customTags != null)
+            operationRequest.setParameter(ParameterCode.CustomTags, customTags);
+        let dataSend = OperationHelper.toSocketData(requestType, role, operationRequest);
+        let gnServerSettings = GNNetwork.getGNServerSettings();
+        if (gnServerSettings.getMessageType() == MessageType.Json)
+            socket.emit(Commands.RequestCmd_Json, dataSend);
+        else
+            socket.emit(Commands.RequestCmd_MsgPack, MessagePackConverterService.serialize(dataSend));
+    }
+    close(_onSocketDisconnect) {
+        super.close(_onSocketDisconnect);
+        this.isConnected = false;
+        if (this.socketManager != null) {
+            if (this.socketManager._readyState != "closed") {
+                this.socketManager._close();
+                return;
+            }
+        }
+        if (this.socket != null)
+            this.socket.disconnect();
+        GNDebug.log("[GN Socket] Disconnecting via SocketIO client");
+        this.onDisconnectHandler();
+    }
+    connect(_onSocketConnect) {
+        super.connect(_onSocketConnect);
+        if (this.isConnected) {
+            GNDebug.log("[GN Socket] Reconnecting");
+            return;
+        }
+        this.isConnected = true;
+        GNDebug.log("[GN Socket] Connecting via SocketIO client");
+        if (this.socketManager != null)
+            this.socketManager.open();
+        if (this.socket != null)
+            this.socket.connect();
+    }
+}

package/dist/runtime/networking/socket/NetworkingSocketPeerBase.js

@@ -0,0 +1,165 @@
+import { MessagePackConverterService } from "./../../helper/MessagePackConverterService";
+import { GNHashtable } from "./../../common/GNData";
+import { GNNetwork } from "./../../GNNetwork";
+import { GNDebug } from "./../../logger/GNDebug";
+export class SocketPacket {
+    constructor(obj, isMsgPack) {
+        this.obj = obj;
+        this.isMsgPack = isMsgPack;
+    }
+}
+class Action0List {
+    subscriber(action) {
+        this.handlers.push(action);
+    }
+    unsubscriber(action) {
+        let indexOf = this.handlers.indexOf(action);
+        if (indexOf != -1)
+            this.handlers.splice(indexOf, 1);
+    }
+    invoke() {
+        this.handlers.forEach((a) => {
+            if (a != null)
+                a();
+        });
+    }
+    constructor() {
+        this.handlers = [];
+    }
+}
+export class NetworkingSocketPeerBase {
+    constructor() {
+        this.clientId = "";
+        this._onConnectHandler = new Action0List();
+        this._onDisconnectHandler = new Action0List();
+    }
+    init(url, reconnectDelay, pingInterval, pingTimeout) {
+        this.responsePacketLst = [];
+        this.eventPacketLst = [];
+        this.url = url;
+        this.reconnectDelay = reconnectDelay;
+        this.pingInterval = pingInterval;
+        this.pingTimeout = pingTimeout;
+    }
+    connect(_onSocketConnect) {
+        this._onSocketConnect = _onSocketConnect;
+    }
+    close(_onSocketDisconnect) {
+        this._onSocketDisconnect = _onSocketDisconnect;
+    }
+    sendRequestAuthSocket() {
+    }
+    send(requestType, role, operationRequest, authToken, secretKey, customTags, gameId) {
+        this.emit(requestType, role, operationRequest, authToken, secretKey, customTags, gameId);
+    }
+    emit(requestType, role, operationRequest, authToken, secretKey, customTags, gameId) {
+    }
+    reInitNewSocket() {
+    }
+    setOnConnectHandler(_onConnectHandler) {
+        this._onConnectHandler.subscriber(_onConnectHandler);
+    }
+    setOnDisconnectHandler(_onDisconnectHandler) {
+        this._onDisconnectHandler.subscriber(_onDisconnectHandler);
+    }
+    removeOnConnectHandler(_onConnectHandler) {
+        this._onConnectHandler.unsubscriber(_onConnectHandler);
+    }
+    removeOnDisconnectHandler(_onDisconnectHandler) {
+        this._onDisconnectHandler.unsubscriber(_onDisconnectHandler);
+    }
+    onConnectHandler() {
+        this._onConnectHandler.invoke();
+        let authToken = GNNetwork.getAuthenticateStatus().getAuthToken();
+        if (authToken != null) {
+            this.sendRequestAuthSocket();
+        }
+        if (this._onSocketConnect != null) {
+            this._onSocketConnect();
+            this._onSocketConnect = null;
+        }
+    }
+    onDisconnectHandler() {
+        this._onDisconnectHandler.invoke();
+        if (this._onSocketDisconnect != null) {
+            this._onSocketDisconnect();
+            this._onSocketDisconnect = null;
+        }
+    }
+    setOnEventHandler(_onEventHandler) {
+        this._onEventHandler = _onEventHandler;
+    }
+    onEventHandler(obj) {
+        if (this._onEventHandler != null)
+            this._onEventHandler(obj);
+    }
+    setOnResponseHandler(_onResponseHandler) {
+        this._onResponseHandler = _onResponseHandler;
+    }
+    onResponseHandler(obj) {
+        if (this._onResponseHandler != null)
+            this._onResponseHandler(obj);
+    }
+    service() {
+        if (this.responsePacketLst.length > 0) {
+            for (let i = 0; i < this.responsePacketLst.length; i++) {
+                let responsePacket = this.responsePacketLst[i];
+                if (responsePacket.isMsgPack) {
+                    try {
+                        let iDict = MessagePackConverterService.deserialize(responsePacket.obj);
+                        let gnHashtable = GNHashtable.builder()
+                            .addAll(iDict)
+                            .build();
+                        this.onResponseHandler(gnHashtable);
+                    }
+                    catch (ex) {
+                        GNDebug.logException(ex);
+                    }
+                }
+                else {
+                    try {
+                        let iDict = responsePacket.obj;
+                        let gnHashtable = GNHashtable.builder()
+                            .addAll(iDict)
+                            .build();
+                        this.onResponseHandler(gnHashtable);
+                    }
+                    catch (ex) {
+                        GNDebug.logException(ex);
+                    }
+                }
+            }
+            this.responsePacketLst.length = 0;
+        }
+        if (this.eventPacketLst.length > 0) {
+            for (let i = 0; i < this.eventPacketLst.length; i++) {
+                let eventPacket = this.eventPacketLst[i];
+                if (eventPacket.isMsgPack) {
+                    try {
+                        let iDict = MessagePackConverterService.deserialize(eventPacket.obj);
+                        let gnHashtable = GNHashtable.builder()
+                            .addAll(iDict)
+                            .build();
+                        this.onEventHandler(gnHashtable);
+                    }
+                    catch (ex) {
+                        GNDebug.logException(ex);
+                    }
+                }
+                else {
+                    try {
+                        let iDict = eventPacket.obj;
+                        let gnHashtable = GNHashtable.builder()
+                            .addAll(iDict)
+                            .build();
+                        this.onEventHandler(gnHashtable);
+                    }
+                    catch (ex) {
+                        GNDebug.logException(ex);
+                    }
+                }
+            }
+            this.eventPacketLst.length = 0;
+        }
+    }
+}

package/dist/runtime/networking/socket/SocketPeer.js

@@ -0,0 +1,115 @@
+import { OperationEvent } from "./../../entity/OperationEvent";
+import { GNNetwork } from "./../../GNNetwork";
+import { GNDebug } from "./../../logger/GNDebug";
+import { IServerEventHandler } from "./../handler/IServerEventHandler";
+import { NetworkingPeerSocketIOClient } from "./NetworkingPeerSocketIOClient";
+import { PeerBase } from "./../PeerBase";
+import { ParameterCode } from "./../../constant/parameterCode/ParameterCode";
+import { OperationRequest } from "./../../entity/OperationRequest";
+export class SocketPeer extends PeerBase {
+    getClientId() {
+        return this.networkingSocketPeerBase.clientId;
+    }
+    isConnected() {
+        return this.networkingSocketPeerBase.isWsConnected;
+    }
+    sendRequestAuthSocket() {
+        this.networkingSocketPeerBase.sendRequestAuthSocket();
+    }
+    subscriberServerEventHandler() {
+        this.serverEventHandlersDict = {};
+        let serverEventHandlers = IServerEventHandler.getImplementations();
+        for (let i = 0; i < serverEventHandlers.length; i++) {
+            let serverEventHandler = new serverEventHandlers[i]();
+            if (serverEventHandler != null) {
+                let serverEventHandlers2 = this.serverEventHandlersDict[serverEventHandler.getEventCode()];
+                if (serverEventHandlers2 == null) {
+                    serverEventHandlers2 = [];
+                    this.serverEventHandlersDict[serverEventHandler.getEventCode()] = serverEventHandlers2;
+                }
+                serverEventHandlers2.push(serverEventHandler);
+            }
+        }
+    }
+    subscriberAServerEventHandler(serverEventHandler) {
+        let serverEventHandlers2 = this.serverEventHandlersDict[serverEventHandler.getEventCode()];
+        if (serverEventHandlers2 == null) {
+            serverEventHandlers2 = [];
+            this.serverEventHandlersDict[serverEventHandler.getEventCode()] = serverEventHandlers2;
+        }
+        serverEventHandlers2.push(serverEventHandler);
+    }
+    initGNSocketObject() {
+        let gnServerSettings = GNNetwork.getGNServerSettings();
+        if (gnServerSettings == null)
+            throw new Error("Where is GN Server Settings");
+        this.isUse = gnServerSettings.isUseSocket();
+        this.networkingSocketPeerBase = new NetworkingPeerSocketIOClient();
+        this.networkingSocketPeerBase.init(gnServerSettings.getSocketUrl(), gnServerSettings.getReconnectDelay(), gnServerSettings.getPingInterval(), gnServerSettings.getPingTimeout());
+        this.networkingSocketPeerBase.reInitNewSocket();
+        let thiz = this;
+        this.networkingSocketPeerBase.setOnEventHandler((t1) => {
+            thiz.onEventHandler(t1);
+        });
+        this.networkingSocketPeerBase.setOnResponseHandler((t1) => {
+            thiz.onResponseHandler(t1);
+        });
+        this.subscriberServerEventHandler();
+    }
+    setOnConnectHandler(_onConnectHandler) {
+        this.networkingSocketPeerBase.setOnConnectHandler(_onConnectHandler);
+    }
+    setOnDisconnectHandler(_onDisconnectHandler) {
+        this.networkingSocketPeerBase.setOnDisconnectHandler(_onDisconnectHandler);
+    }
+    removeOnConnectHandler(_onConnectHandler) {
+        this.networkingSocketPeerBase.removeOnConnectHandler(_onConnectHandler);
+    }
+    removeOnDisconnectHandler(_onDisconnectHandler) {
+        this.networkingSocketPeerBase.removeOnDisconnectHandler(_onDisconnectHandler);
+    }
+    connect(_onSocketConnect) {
+        this.networkingSocketPeerBase.connect(_onSocketConnect);
+    }
+    disconnect(_onSocketDisconnect) {
+        this.networkingSocketPeerBase.close(_onSocketDisconnect);
+    }
+    setOnEventHandler(_onEventHandler) {
+        this._onEventHandler = _onEventHandler;
+    }
+    send(operationPending) {
+        let gnServerSettings = GNNetwork.getGNServerSettings();
+        let operationRequest = operationPending.getOperationRequest();
+        if (operationRequest.getTimeout() == OperationRequest.defaultTimeOut)
+            operationRequest.setTimeout(gnServerSettings.getDefaultTimeoutInSeconds());
+        super.send(operationPending);
+        GNDebug.log("[GN Socket SEND] " + operationPending.getOperationRequest().toString());
+        let authToken = operationPending.getAuthToken();
+        let secretKey = operationPending.getSecretKey();
+        let gameId = operationPending.getGameId();
+        let customTags = operationPending.getCustomTags();
+        this.networkingSocketPeerBase.send(operationPending.getRequestType(), operationPending.getRole(), operationPending.getOperationRequest(), authToken, secretKey, customTags, gameId);
+    }
+    onEnqueue(operationPending) {
+        GNDebug.log("[GN Socket ENQUEUE] " + operationPending.getOperationRequest().toString());
+    }
+    onEventHandler(obj) {
+        let eventCode = obj.getString(ParameterCode.EventCode);
+        let operationEvent = new OperationEvent(eventCode, obj.getGNHashtable(ParameterCode.Parameters));
+        GNDebug.log("[GN Socket EVENT] " + operationEvent.toString());
+        if (this._onEventHandler != null)
+            this._onEventHandler(operationEvent);
+        let serverEventHandlers = this.serverEventHandlersDict[eventCode];
+        if (serverEventHandlers == null)
+            return;
+        serverEventHandlers.forEach(serverEventHandler => {
+            if (serverEventHandler != null) {
+                serverEventHandler.handle(operationEvent);
+            }
+        });
+    }
+    service() {
+        super.service();
+        this.networkingSocketPeerBase.service();
+    }
+}

package/dist/runtime/typescript/ServiceUpdate.js

@@ -0,0 +1,12 @@
+export class ServiceUpdate {
+    run() {
+        let thiz = this;
+        setInterval(() => {
+            thiz.update();
+        }, 50);
+    }
+    update() {
+        if (this.peer != null)
+            this.peer.service();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmobitea/gn-typescript-client",
-  "version": "2.6.9",
+  "version": "2.6.10-tsc",
   "description": "GearN Typescript Client SDK by XmobiTea (Pro)",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",