chore: update ts-sdk

packages/cts-core/example/index.ts

 import { Client } from '../src/client';
+import { WebsocketError } from './error';
 
 const url = 'ws://127.0.0.1:8081';
-const client = new Client(
-  url,
-  new (class {
-    public onOpen(): void {
-      client.ping(
-        {},
-        new (class {
-          public onStart(): void {
-            console.log('start ping');
-          }
-
-          public onSuccess(data: string): void {
-            console.log('ping successful:', data);
-          }
-
-          public onError(code: number, message: string): void {
-            console.log('ping error:', message);
-          }
-
-          public onEnd(): void {
-            console.log('end ping');
-          }
-        })()
+const client = new Client(url, {
+  onOpen(): void {
+    client
+      .ping({})
+      .then(
+        (res: string): void => {
+          console.log('ping sucessful:', res);
+        },
+      )
+      .catch(
+        (reason: WebsocketError): void => {
+          console.log('ping error:', reason.code, reason.msg);
+        },
       );
 
-      client.syncSend(
-        '/v1/healthy',
-        {},
-        new (class {
-          public onStart(): void {
-            console.log('start request');
-          }
-
-          public onSuccess(data: string): void {
-            console.log('request successful:', data);
-          }
-
-          public onError(code: number, message: string): void {
-            console.log('request error:', message);
-          }
-
-          public onEnd(): void {
-            console.log('end request');
-          }
-        })()
+    client
+      .request('/v1/healthy', {})
+      .then(
+        (res: string): void => {
+          console.log('request successful:', res);
+        },
+      )
+      .catch(
+        (reason: WebsocketError): void => {
+          console.log('request error:', reason.code, reason.msg);
+        },
       );
-    }
+  },
+
+  onClose(ev: Event): void {
+    console.log('connection error', ev);
+    console.log(ev);
+  },
 
-    public onClose(ev: Event): void {
-      console.log('connection error', ev);
-      console.log(ev);
-    }
+  onError(): void {
+    console.log('close connection');
+  },
+});
 
-    public onError(): void {
-      console.log('close connection');
-    }
-  })()
-);
+client.enableLogger = true;

packages/cts-core/src/client.ts

 import { Packet } from './packet';
 import { Utils } from './utils';
-import { ReadyStateCallback, RequestCallback } from './types/callback';
+import { ReadyStateCallback } from './types/callback';
+import { WebsocketError } from './error';
+
+const clientError = 400;
 
 /**
  * 初始化链接以及收发数据
  */
 class Client {
   private _maxPayload: number;
+  private _enableLogger: boolean;
   private listeners: Map<number, (data: string) => void>;
   private requestHeader: string;
   private responseHeader: string;
     this.url = url;
     this.reconnectTimes = 0;
     this.readyStateCallback = readyStateCallback;
+    this._enableLogger = false;
     this.socket = this.connect();
   }
 
   /**
-   * 发送ping请求，来保持长连接
-   * @param param 请求参数,比如{"hello":"world"}
-   * @param requestCallback 请求状态回调
+   * 设置可以处理的数据包上限
+   * @param maxPayload 最多可以处理的数据包大小
    */
-  public ping(param: object, requestCallback: RequestCallback): void {
-    if (this.socket.readyState !== this.socket.OPEN) {
-      throw new Error('asyncSend: connection refuse');
-    }
-
-    const heartbeatOperator = 0;
-
-    this.listeners.set(
-      heartbeatOperator,
-      (data: string): void => {
-        const code = this.getResponseProperty('code');
-        if (code !== '') {
-          const message = this.getResponseProperty('message');
-          requestCallback.onError(Number(code), message);
-        } else {
-          requestCallback.onSuccess(data);
-        }
+  public set maxPayload(maxPayload: number) {
+    this._maxPayload = maxPayload;
+  }
 
-        requestCallback.onEnd();
-      },
-    );
+  /**
+   * 获取可以处理的数据包大小
+   */
+  public get maxPayload(): number {
+    return this._maxPayload;
+  }
 
-    const p = new Packet();
-    this.send(
-      p.pack(heartbeatOperator, 0, this.requestHeader, JSON.stringify(param)),
-    );
+  /**
+   * 设置是否允许显示运行日志
+   */
+  public set enableLogger(enableLogger: boolean) {
+    this._enableLogger = enableLogger;
   }
 
   /**
-   * 异步向服务端发送请求
-   * @param operator 路由地址
-   * @param param 请求参数，比如{"hello":"world"}
-   * @param callback 请求状态回调处理
+   * 获取是否显示日志的配置信息
    */
-  public asyncSend(
-    operator: string,
-    param: object,
-    callback: RequestCallback,
-  ): void {
-    console.info('websocket send data', operator, this.requestHeader, param);
+  public get enableLogger(): boolean {
+    return this._enableLogger;
+  }
 
-    if (this.socket.readyState !== this.socket.OPEN) {
-      throw new Error('asyncSend: connection refuse');
-    }
+  /**
+   * 发送ping请求，来保持长连接
+   * @param param 请求参数,比如{"hello":"world"}
+   */
+  public async ping(param: object): Promise<string> {
+    return new Promise(
+      (
+        resolve: (data: string) => void,
+        reject: (err: WebsocketError) => void,
+      ): void => {
+        if (this.socket.readyState !== this.socket.OPEN) {
+          if (this._enableLogger) {
+            console.log('[ping]: connection refuse');
+          }
 
-    callback.onStart();
-
-    const sequence = new Date().getTime();
-    const listener = Utils.crc32(operator) + sequence;
-    this.listeners.set(
-      listener,
-      (data: string): void => {
-        const code = this.getResponseProperty('code');
-        if (code !== '') {
-          const message = this.getResponseProperty('message');
-          callback.onError(Number(code), message);
-        } else {
-          callback.onSuccess(data);
+          reject(new WebsocketError(clientError, 'connection refuse'));
         }
 
-        callback.onEnd();
-
-        delete this.listeners[listener];
+        const heartbeatOperator = 0;
+
+        this.listeners.set(
+          heartbeatOperator,
+          (data: string): void => {
+            const code = this.getResponseProperty('code');
+            if (code !== '') {
+              const message = this.getResponseProperty('message');
+              reject(new WebsocketError(Number(code), message));
+            } else {
+              resolve(data);
+            }
+          },
+        );
+
+        const p = new Packet();
+        this.send(
+          p.pack(
+            heartbeatOperator,
+            0,
+            this.requestHeader,
+            JSON.stringify(param),
+          ),
+        );
+
+        if (this._enableLogger) {
+          console.info(
+            '[send data packet]',
+            heartbeatOperator,
+            0,
+            this.requestHeader,
+            param,
+          );
+        }
       },
     );
-
-    const p = new Packet();
-    this.send(
-      p.pack(
-        Utils.crc32(operator),
-        sequence,
-        this.requestHeader,
-        JSON.stringify(param),
-      ),
-    );
   }
 
   /**
    * @param param 请求参数，比如{"hello":"world"}
    * @param callback 请求状态回调处理
    */
-  public async syncSend(
-    operator: string,
-    param: object,
-    callback: RequestCallback,
-  ): Promise<void> {
-    await this.asyncSend(operator, param, callback);
+  public async request(operator: string, param: object): Promise<string> {
+    return await this.asyncSend(operator, param);
   }
 
   /**
     return this.socket.readyState;
   }
 
-  /**
-   * 设置可以处理的数据包上限
-   * @param maxPayload 最多可以处理的数据包大小
-   */
-  public set maxPayload(maxPayload: number) {
-    this._maxPayload = maxPayload;
-  }
-
-  /**
-   * 获取可以处理的数据包大小
-   */
-  public get maxPayload(): number {
-    return this._maxPayload;
-  }
-
   /**
    * 添加请求属性，会携带在数据帧里面发送到服务端
    * @param key 属性名
     ws.binaryType = 'blob';
 
     ws.onopen = (ev): void => {
+      if (this._enableLogger) {
+        console.info('[websocket] open connection');
+      }
+
       this.reconnectTimes = 0;
 
       readyStateCallback.onOpen(ev);
     };
 
     ws.onclose = (ev): void => {
+      if (this._enableLogger) {
+        console.info('[websocket] close connection');
+      }
+
       this.reconnect();
 
       readyStateCallback.onClose(ev);
     };
 
     ws.onerror = (ev): void => {
+      if (this._enableLogger) {
+        console.info('[websocket] error');
+      }
+
       this.reconnect();
 
       readyStateCallback.onError(ev);
               );
             }
 
-            if (operator !== 0 && packet.body !== 'null') {
-              console.info('receive data', packet.body);
+            if (this._enableLogger) {
+              if (operator !== 0 && packet.body !== 'null') {
+                console.info('receive data packet', packet.body);
+              }
             }
           } catch (e) {
             throw new Error(e);
   private reconnect(): void {
     if (!this.reconnectLock) {
       this.reconnectLock = true;
-      console.info('websocket reconnect in ' + this.reconnectTimes + 's');
+      if (this._enableLogger) {
+        console.info('websocket reconnect in ' + this.reconnectTimes + 's');
+      }
+
       // 尝试重连
       setTimeout((): void => {
         this.reconnectTimes++;
    */
   private send(data: ArrayBuffer): void {
     if (this.socket.readyState !== this.socket.OPEN) {
-      console.error('WebSocket is already in CLOSING or CLOSED state.');
+      if (this._enableLogger) {
+        console.error(
+          '[send] WebSocket is already in CLOSING or CLOSED state.',
+        );
+      }
+
       return;
     }
+
     try {
       this.socket.send(data);
     } catch (e) {
-      console.log('send data error', e);
+      throw new Error('send data error' + e);
     }
   }
+
+  /**
+   * 异步向服务端发送请求
+   * @param operator 路由地址
+   * @param param 请求参数，比如{"hello":"world"}
+   * @param callback 请求状态回调处理
+   */
+  private asyncSend(operator: string, param: object): Promise<string> {
+    return new Promise(
+      (
+        resolve: (data: string) => void,
+        reject: (err: WebsocketError) => void,
+      ): void => {
+        if (this.socket.readyState !== this.socket.OPEN) {
+          if (this._enableLogger) {
+            console.log('[ping]: connection refuse');
+          }
+
+          reject(
+            new WebsocketError(clientError, 'asyncSend: connection refuse'),
+          );
+        }
+
+        const sequence = new Date().getTime();
+        const listener = Utils.crc32(operator) + sequence;
+        this.listeners.set(
+          listener,
+          (data: string): void => {
+            const code = this.getResponseProperty('code');
+            if (code !== '') {
+              const message = this.getResponseProperty('message');
+              reject(new WebsocketError(Number(code), message));
+            } else {
+              resolve(data);
+            }
+
+            delete this.listeners[listener];
+          },
+        );
+
+        const p = new Packet();
+        this.send(
+          p.pack(
+            Utils.crc32(operator),
+            sequence,
+            this.requestHeader,
+            JSON.stringify(param),
+          ),
+        );
+
+        if (this._enableLogger) {
+          console.info(
+            '[send data packet]',
+            operator,
+            sequence,
+            this.requestHeader,
+            param,
+          );
+        }
+      },
+    );
+  }
 }
 
 export { Client };

packages/cts-core/src/error.ts

+export class WebsocketError {
+  private _code: number;
+  private _msg: string;
+
+  /**
+   * 构造函数
+   */
+  public constructor(code: number, msg: string) {
+    this._code = code;
+    this._msg = msg;
+  }
+
+  /**
+   * 返回错误码
+   */
+  public get code(): number {
+    return this._code;
+  }
+
+  /**
+   * 返回具体的错误信息
+   */
+  public get msg(): string {
+    return this._msg;
+  }
+}