feat: update

.gitignore

@@ -7,6 +7,4 @@ node_modules
 # Project specific stuff
 .cache-loader
 @coverage
-*.log
-dist
-build
+*.log

package.json

@@ -6,6 +6,9 @@
     "type": "git",
     "url": "https://git.links123.net/Chevalier/chat-ts-sdk"
   },
+  "main": "./packages/cts-api/dist/cjs/index.js",
+  "module": "./packages/cts-api/dist/cjs/index.js",
+  "types": "./packages/cts-api/dist/types/index.d.ts",
   "license": "MIT",
   "keywords": [
     "react",

packages/cts-adapter/types.d.ts

@@ -1,14 +0,0 @@
-declare module '*.less' {
-  const styles: Record<string, string>;
-  export = styles;
-}
-
-declare module '*.css' {
-  const content: any;
-  export default content;
-}
-
-declare module '*.svg' {
-  const content: string;
-  export default content;
-}

packages/cts-api/dist/cjs/WebSocketClient.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var WebSocketClient = (function () {
+    function WebSocketClient() {
+    }
+    return WebSocketClient;
+}());
+exports.WebSocketClient = WebSocketClient;

packages/cts-api/dist/cjs/client.js

@@ -0,0 +1,283 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var packet_1 = require("./packet");
+var utils_1 = require("./utils");
+var error_1 = require("./error");
+var clientError = 400;
+var Client = (function () {
+    function Client(url, readyStateCallback) {
+        this.listeners = new Map();
+        this.requestHeader = '';
+        this.requestHeader = '';
+        this._maxPayload = 1024 * 1024;
+        this.url = url;
+        this.reconnectTimes = 0;
+        this.readyStateCallback = readyStateCallback;
+        this._enableLogger = false;
+        this.socket = this.connect();
+    }
+    Object.defineProperty(Client.prototype, "maxPayload", {
+        get: function () {
+            return this._maxPayload;
+        },
+        set: function (maxPayload) {
+            this._maxPayload = maxPayload;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Client.prototype, "enableLogger", {
+        get: function () {
+            return this._enableLogger;
+        },
+        set: function (enableLogger) {
+            this._enableLogger = enableLogger;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Client.prototype.ping = function (param) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2, new Promise(function (resolve, reject) {
+                        if (_this.socket.readyState !== _this.socket.OPEN) {
+                            if (_this._enableLogger) {
+                                console.log('[ping]: connection refuse');
+                            }
+                            reject(new error_1.WebsocketError(clientError, 'connection refuse'));
+                        }
+                        var heartbeatOperator = 0;
+                        _this.listeners.set(heartbeatOperator, function (data) {
+                            var code = _this.getResponseProperty('code');
+                            if (code !== '') {
+                                var message = _this.getResponseProperty('message');
+                                reject(new error_1.WebsocketError(Number(code), message));
+                            }
+                            else {
+                                resolve(data);
+                            }
+                        });
+                        var p = new packet_1.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);
+                        }
+                    })];
+            });
+        });
+    };
+    Client.prototype.request = function (operator, param) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.asyncSend(operator, param)];
+                    case 1: return [2, _a.sent()];
+                }
+            });
+        });
+    };
+    Client.prototype.addMessageListener = function (operator, listener) {
+        this.listeners.set(utils_1.Utils.crc32(operator), listener);
+    };
+    Client.prototype.removeMessageListener = function (operator) {
+        delete this.listeners[utils_1.Utils.crc32(operator)];
+    };
+    Object.defineProperty(Client.prototype, "readyState", {
+        get: function () {
+            return this.socket.readyState;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Client.prototype.setRequestProperty = function (key, value) {
+        var v = this.getRequestProperty(key);
+        this.requestHeader = this.requestHeader.replace(key + '=' + v + ';', '');
+        this.requestHeader = this.requestHeader + key + '=' + value + ';';
+    };
+    Client.prototype.getRequestProperty = function (key) {
+        if (this.requestHeader !== undefined) {
+            var values = this.requestHeader.split(';');
+            for (var index in values) {
+                var kv = values[index].split('=');
+                if (kv[0] === key) {
+                    return kv[1];
+                }
+            }
+        }
+        return '';
+    };
+    Client.prototype.setResponseProperty = function (key, value) {
+        var v = this.getResponseProperty(key);
+        this.responseHeader = this.responseHeader.replace(key + '=' + v + ';', '');
+        this.responseHeader = this.responseHeader + key + '=' + value + ';';
+    };
+    Client.prototype.getResponseProperty = function (key) {
+        if (this.responseHeader !== undefined) {
+            var values = this.responseHeader.split(';');
+            for (var index in values) {
+                var kv = values[index].split('=');
+                if (kv[0] === key) {
+                    return kv[1];
+                }
+            }
+        }
+        return '';
+    };
+    Client.prototype.connect = function () {
+        var _this = this;
+        var readyStateCallback = this.readyStateCallback;
+        var ws = new WebSocket(this.url);
+        ws.binaryType = 'blob';
+        ws.onopen = function (ev) {
+            if (_this._enableLogger) {
+                console.info('[websocket] open connection');
+            }
+            _this.reconnectTimes = 0;
+            readyStateCallback.onOpen(ev);
+        };
+        ws.onclose = function (ev) {
+            if (_this._enableLogger) {
+                console.info('[websocket] close connection');
+            }
+            _this.reconnect();
+            readyStateCallback.onClose(ev);
+        };
+        ws.onerror = function (ev) {
+            if (_this._enableLogger) {
+                console.info('[websocket] error');
+            }
+            _this.reconnect();
+            readyStateCallback.onError(ev);
+        };
+        ws.onmessage = function (ev) {
+            if (ev.data instanceof Blob) {
+                var reader_1 = new FileReader();
+                reader_1.readAsArrayBuffer(ev.data);
+                reader_1.onload = function () {
+                    try {
+                        var packet = new packet_1.Packet().unPack(reader_1.result);
+                        var packetLength = packet.headerLength + packet.bodyLength + 20;
+                        if (packetLength > _this._maxPayload) {
+                            throw new Error('the packet is big than ' + _this._maxPayload);
+                        }
+                        var operator = Number(packet.operator) + Number(packet.sequence);
+                        if (_this.listeners.has(operator)) {
+                            if (packet.body === '') {
+                                packet.body = '{}';
+                            }
+                            _this.responseHeader = packet.header;
+                            _this.listeners.get(operator)(JSON.parse(packet.body));
+                        }
+                        if (_this._enableLogger) {
+                            if (operator !== 0 && packet.body !== 'null') {
+                                console.info('receive data packet', packet.body);
+                            }
+                        }
+                    }
+                    catch (e) {
+                        throw new Error(e);
+                    }
+                };
+            }
+            else {
+                throw new Error('unsupported data format');
+            }
+        };
+        return ws;
+    };
+    Client.prototype.reconnect = function () {
+        var _this = this;
+        if (!this.reconnectLock) {
+            this.reconnectLock = true;
+            if (this._enableLogger) {
+                console.info('websocket reconnect in ' + this.reconnectTimes + 's');
+            }
+            setTimeout(function () {
+                _this.reconnectTimes++;
+                _this.socket = _this.connect();
+                _this.reconnectLock = false;
+            }, this.reconnectTimes * 1000);
+        }
+    };
+    Client.prototype.send = function (data) {
+        if (this.socket.readyState !== this.socket.OPEN) {
+            if (this._enableLogger) {
+                console.error('[send] WebSocket is already in CLOSING or CLOSED state.');
+            }
+            return;
+        }
+        try {
+            this.socket.send(data);
+        }
+        catch (e) {
+            throw new Error('send data error' + e);
+        }
+    };
+    Client.prototype.asyncSend = function (operator, param) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            if (_this.socket.readyState !== _this.socket.OPEN) {
+                if (_this._enableLogger) {
+                    console.log('[ping]: connection refuse');
+                }
+                reject(new error_1.WebsocketError(clientError, 'asyncSend: connection refuse'));
+            }
+            var sequence = new Date().getTime();
+            var listener = utils_1.Utils.crc32(operator) + sequence;
+            _this.listeners.set(listener, function (data) {
+                var code = _this.getResponseProperty('code');
+                if (code !== '') {
+                    var message = _this.getResponseProperty('message');
+                    reject(new error_1.WebsocketError(Number(code), message));
+                }
+                else {
+                    resolve(data);
+                }
+                delete _this.listeners[listener];
+            });
+            var p = new packet_1.Packet();
+            _this.send(p.pack(utils_1.Utils.crc32(operator), sequence, _this.requestHeader, JSON.stringify(param)));
+            if (_this._enableLogger) {
+                console.info('[send data packet]', operator, sequence, _this.requestHeader, param);
+            }
+        });
+    };
+    return Client;
+}());
+exports.Client = Client;

packages/cts-api/dist/cjs/config.js

@@ -0,0 +1 @@
+var PING_INTERVAL = 50 * 1000;

packages/cts-api/dist/cjs/error.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var WebsocketError = (function () {
+    function WebsocketError(code, msg) {
+        this._code = code;
+        this._msg = msg;
+    }
+    Object.defineProperty(WebsocketError.prototype, "code", {
+        get: function () {
+            return this._code;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(WebsocketError.prototype, "msg", {
+        get: function () {
+            return this._msg;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return WebsocketError;
+}());
+exports.WebsocketError = WebsocketError;

packages/cts-api/dist/cjs/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var WebSocketClient_1 = require("./WebSocketClient");
+exports.WebSocketClient = WebSocketClient_1.WebSocketClient;
+var error_1 = require("./error");
+exports.WebsocketError = error_1.WebsocketError;
+var client_1 = require("./client");
+exports.Client = client_1.Client;

packages/cts-api/dist/cjs/meta.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getMetaData() {
+    var nAgt = navigator.userAgent;
+    var browserName = navigator.appName;
+    var fullVersion = "" + parseFloat(navigator.appVersion);
+    var majorVersion = parseInt(navigator.appVersion, 10);
+    var nameOffset;
+    var verOffset;
+    var ix;
+    if ((verOffset = nAgt.indexOf('Opera')) !== -1) {
+        browserName = 'Opera';
+        fullVersion = nAgt.substring(verOffset + 6);
+        if ((verOffset = nAgt.indexOf('Version')) !== -1)
+            fullVersion = nAgt.substring(verOffset + 8);
+    }
+    else if ((verOffset = nAgt.indexOf('MSIE')) !== -1) {
+        browserName = 'Microsoft Internet Explorer';
+        fullVersion = nAgt.substring(verOffset + 5);
+    }
+    else if ((verOffset = nAgt.indexOf('Chrome')) !== -1) {
+        browserName = 'Chrome';
+        fullVersion = nAgt.substring(verOffset + 7);
+    }
+    else if ((verOffset = nAgt.indexOf('Safari')) !== -1) {
+        browserName = 'Safari';
+        fullVersion = nAgt.substring(verOffset + 7);
+        if ((verOffset = nAgt.indexOf('Version')) !== -1)
+            fullVersion = nAgt.substring(verOffset + 8);
+    }
+    else if ((verOffset = nAgt.indexOf('Firefox')) !== -1) {
+        browserName = 'Firefox';
+        fullVersion = nAgt.substring(verOffset + 8);
+    }
+    else if ((nameOffset = nAgt.lastIndexOf(' ') + 1) < (verOffset = nAgt.lastIndexOf('/'))) {
+        browserName = nAgt.substring(nameOffset, verOffset);
+        fullVersion = nAgt.substring(verOffset + 1);
+        if (browserName.toLowerCase() === browserName.toUpperCase()) {
+            browserName = navigator.appName;
+        }
+    }
+    if ((ix = fullVersion.indexOf(';')) !== -1)
+        fullVersion = fullVersion.substring(0, ix);
+    if ((ix = fullVersion.indexOf(' ')) !== -1)
+        fullVersion = fullVersion.substring(0, ix);
+    majorVersion = parseInt("" + fullVersion, 10);
+    if (isNaN(majorVersion)) {
+        fullVersion = "" + parseFloat(navigator.appVersion);
+        majorVersion = parseInt(navigator.appVersion, 10);
+    }
+    var OSName = 'Unknown OS';
+    if (navigator.appVersion.indexOf('Win') !== -1)
+        OSName = 'Windows';
+    if (navigator.appVersion.indexOf('Mac') !== -1)
+        OSName = 'MacOS';
+    if (navigator.appVersion.indexOf('X11') !== -1)
+        OSName = 'UNIX';
+    if (navigator.appVersion.indexOf('Linux') !== -1)
+        OSName = 'Linux';
+    var isMobile = false;
+    if (/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|ipad|iris|kindle|Android|Silk|lge |maemo|midp|mmp|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows (ce|phone)|xda|xiino/i.test(navigator.userAgent) ||
+        /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(navigator.userAgent.substr(0, 4))) {
+        isMobile = true;
+    }
+    return {
+        device: isMobile ? 'mobile' : 'pc',
+        os: OSName,
+        os_version: '',
+        app: 'WebLiveClient',
+        app_version: fullVersion,
+        tag: {}
+    };
+}
+exports.getMetaData = getMetaData;

packages/cts-api/dist/cjs/packet.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("./utils");
+var node_int64_1 = require("node-int64");
+var Packet = (function () {
+    function Packet() {
+        this.key = 'b8ca9aa66def05ff3f24919274bb4a66';
+    }
+    Packet.prototype.pack = function (operator, sequence, header, body) {
+        header = utils_1.Utils.encrypt(header, this.key, this.key);
+        body = utils_1.Utils.encrypt(body, this.key, this.key);
+        var headerLength = header.length;
+        var bodyLength = body.length;
+        var buf = new ArrayBuffer(20 + headerLength + bodyLength);
+        var dataView = new DataView(buf);
+        var nsBuf = new node_int64_1.default(sequence).toBuffer();
+        dataView.setUint32(0, operator);
+        dataView.setUint32(12, headerLength);
+        dataView.setUint32(16, bodyLength);
+        var bufView = new Uint8Array(buf);
+        for (var i = 0; i < 8; i++) {
+            bufView[4 + i] = nsBuf[i];
+        }
+        for (var i_1 = 0; i_1 < headerLength; i_1++) {
+            bufView[20 + i_1] = header.charCodeAt(i_1);
+        }
+        for (var i_2 = 0; i_2 < bodyLength; i_2++) {
+            bufView[20 + headerLength + i_2] = body.charCodeAt(i_2);
+        }
+        return buf;
+    };
+    Packet.prototype.unPack = function (data) {
+        var dataView = new DataView(data);
+        this.operator = dataView.getUint32(0, false);
+        this.sequence = new node_int64_1.default(new Uint8Array(dataView.buffer.slice(4, 12))).toNumber();
+        this.headerLength = dataView.getUint32(12, false);
+        this.bodyLength = dataView.getUint32(16, false);
+        var header = utils_1.Utils.ab2str(dataView.buffer.slice(20, 20 + this.headerLength));
+        var body = utils_1.Utils.ab2str(dataView.buffer.slice(20 + this.headerLength));
+        this.header = utils_1.Utils.decrypt(header, this.key, this.key);
+        this.body = utils_1.Utils.decrypt(body, this.key, this.key);
+        return this;
+    };
+    return Packet;
+}());
+exports.Packet = Packet;

packages/cts-api/dist/cjs/types/callback.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

packages/cts-api/dist/cjs/utils.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var crypto_js_1 = require("crypto-js");
+var Utils = (function () {
+    function Utils() {
+    }
+    Utils.crc32 = function (str) {
+        var crcTable = window.crcTable || (window.crcTable = Utils.makeCRCTable());
+        var crc = 0 ^ -1;
+        for (var i = 0; i < str.length; i++) {
+            crc = (crc >>> 8) ^ crcTable[(crc ^ str.charCodeAt(i)) & 0xff];
+        }
+        return (crc ^ -1) >>> 0;
+    };
+    Utils.ab2str = function (buf) {
+        if (buf && buf.byteLength < 1024) {
+            return String.fromCharCode.apply(null, new Uint8Array(buf));
+        }
+        var bufView = new Uint8Array(buf);
+        var len = bufView.length;
+        var byteStr = new Array(len);
+        for (var i = 0; i < len; i++) {
+            byteStr[i] = String.fromCharCode.call(null, bufView[i]);
+        }
+        return byteStr.join('');
+    };
+    Utils.str2ab = function (str) {
+        var buf = new ArrayBuffer(str.length);
+        var bufView = new Uint8Array(buf);
+        for (var i = 0, strLen = str.length; i < strLen; i++) {
+            bufView[i] = str.charCodeAt(i);
+        }
+        return buf;
+    };
+    Utils.decrypt = function (data, key, iv) {
+        var binData = Utils.stringToBin(data);
+        var base64Data = Utils.binToBase64(binData);
+        var bytes = crypto_js_1.AES.decrypt(base64Data, crypto_js_1.enc.Latin1.parse(key), {
+            iv: crypto_js_1.enc.Latin1.parse(iv),
+            mode: crypto_js_1.mode.CBC,
+            padding: crypto_js_1.pad.Pkcs7,
+        });
+        return bytes.toString(crypto_js_1.enc.Utf8);
+    };
+    Utils.encrypt = function (data, key, iv) {
+        var result = crypto_js_1.AES.encrypt(data, crypto_js_1.enc.Latin1.parse(key), {
+            iv: crypto_js_1.enc.Latin1.parse(iv),
+            mode: crypto_js_1.mode.CBC,
+            padding: crypto_js_1.pad.Pkcs7,
+        });
+        return Utils.binToString(Utils.base64ToBin(result.toString()));
+    };
+    Utils.binToBase64 = function (bitString) {
+        var tail = bitString.length % 6;
+        var bitStringTemp1 = bitString.substr(0, bitString.length - tail);
+        var result = '';
+        var bitStringTemp2 = bitString.substr(bitString.length - tail, tail);
+        for (var i = 0; i < bitStringTemp1.length; i += 6) {
+            var index = parseInt(bitStringTemp1.substr(i, 6), 2);
+            result += Utils.code[index];
+        }
+        bitStringTemp2 += new Array(7 - tail).join('0');
+        if (tail) {
+            result += Utils.code[parseInt(bitStringTemp2, 2)];
+            result += new Array((6 - tail) / 2 + 1).join('=');
+        }
+        return result;
+    };
+    Utils.base64ToBin = function (str) {
+        var bitString = '';
+        var tail = 0;
+        for (var i = 0; i < str.length; i++) {
+            if (str[i] !== '=') {
+                var decode = this.code.indexOf(str[i]).toString(2);
+                bitString += new Array(7 - decode.length).join('0') + decode;
+            }
+            else {
+                tail++;
+            }
+        }
+        return bitString.substr(0, bitString.length - tail * 2);
+    };
+    Utils.stringToBin = function (str) {
+        var result = '';
+        for (var i = 0; i < str.length; i++) {
+            var charCode = str.charCodeAt(i).toString(2);
+            result += new Array(9 - charCode.length).join('0') + charCode;
+        }
+        return result;
+    };
+    Utils.binToString = function (bin) {
+        var result = '';
+        for (var i = 0; i < bin.length; i += 8) {
+            result += String.fromCharCode(parseInt(bin.substr(i, 8), 2));
+        }
+        return result;
+    };
+    Utils.makeCRCTable = function () {
+        var c;
+        var crcTable = [];
+        for (var n = 0; n < 256; n++) {
+            c = n;
+            for (var k = 0; k < 8; k++) {
+                c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+            }
+            crcTable[n] = c;
+        }
+        return crcTable;
+    };
+    Utils.code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');
+    return Utils;
+}());
+exports.Utils = Utils;

packages/cts-api/dist/types/WebSocketClient.d.ts

@@ -0,0 +1,2 @@
+export declare class WebSocketClient {
+}

packages/cts-api/dist/types/client.d.ts

@@ -0,0 +1,30 @@
+import { ReadyStateCallback } from './types/callback';
+declare class Client {
+    private _maxPayload;
+    private _enableLogger;
+    private listeners;
+    private requestHeader;
+    private responseHeader;
+    private url;
+    private reconnectTimes;
+    private reconnectLock;
+    private socket;
+    private readyStateCallback;
+    constructor(url: string, readyStateCallback: ReadyStateCallback);
+    maxPayload: number;
+    enableLogger: boolean;
+    ping(param: object): Promise<string>;
+    request(operator: string, param: object): Promise<string>;
+    addMessageListener(operator: string, listener: (data: string) => void): void;
+    removeMessageListener(operator: string): void;
+    readonly readyState: number;
+    setRequestProperty(key: string, value: string): void;
+    getRequestProperty(key: string): string;
+    setResponseProperty(key: string, value: string): void;
+    getResponseProperty(key: string): string;
+    private connect;
+    private reconnect;
+    private send;
+    private asyncSend;
+}
+export { Client };

packages/cts-api/dist/types/config.d.ts

@@ -0,0 +1 @@
+declare const PING_INTERVAL: number;

packages/cts-api/dist/types/error.d.ts

@@ -0,0 +1,7 @@
+export declare class WebsocketError {
+    private _code;
+    private _msg;
+    constructor(code: number, msg: string);
+    readonly code: number;
+    readonly msg: string;
+}

packages/cts-api/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export { WebSocketClient } from './WebSocketClient';
+export { WebsocketError } from './error';
+export { Client } from './client';

packages/cts-api/dist/types/meta.d.ts

@@ -0,0 +1,8 @@
+export declare function getMetaData(): {
+    device: string;
+    os: string;
+    os_version: string;
+    app: string;
+    app_version: string;
+    tag: {};
+};

packages/cts-api/dist/types/packet.d.ts

@@ -0,0 +1,11 @@
+export declare class Packet {
+    private key;
+    operator: number;
+    sequence: number;
+    headerLength: number;
+    bodyLength: number;
+    header: string;
+    body: string;
+    pack(operator: number, sequence: number, header: string, body: string): ArrayBuffer;
+    unPack(data: ArrayBuffer | SharedArrayBuffer): Packet;
+}

packages/cts-api/dist/types/types/callback.d.ts

@@ -0,0 +1,12 @@
+interface ReadyStateCallback {
+    onOpen(ev: Event): void;
+    onError(ev: Event): void;
+    onClose(ev: Event): void;
+}
+interface RequestCallback {
+    onStart(): void;
+    onSuccess(data: string): void;
+    onError(code: number, message: string): void;
+    onEnd(): void;
+}
+export { ReadyStateCallback, RequestCallback };

packages/cts-api/dist/types/utils.d.ts

@@ -0,0 +1,19 @@
+declare global {
+    interface Window {
+        crcTable: number[];
+    }
+}
+declare class Utils {
+    private static code;
+    static crc32(str: string): number;
+    static ab2str(buf: ArrayBuffer): string;
+    static str2ab(str: string): ArrayBuffer;
+    static decrypt(data: string, key: string, iv: string): string;
+    static encrypt(data: string, key: string, iv: string): string;
+    static binToBase64(bitString: string): string;
+    static base64ToBin(str: string): string;
+    static stringToBin(str: string): string;
+    static binToString(bin: string): string;
+    private static makeCRCTable;
+}
+export { Utils };

packages/cts-api/src/WebSocketClient.ts

@@ -1 +1,153 @@
-export class WebSocketClient {}
+import { Client, getClient, WebSocketResp } from './client';
+import { getMetaData } from './meta';
+
+export interface WebSocketClientStatus {
+  created: boolean;
+  connected: boolean;
+  login: boolean;
+}
+
+export type ListenerCallback = (data: WebSocketResp) => void;
+
+const meta = getMetaData();
+
+export class WebSocketClient {
+  client: Client;
+  interval: NodeJS.Timeout;
+
+  wsUrl: string;
+  token: string;
+  sid: string;
+  chatToken: object;
+
+  status: WebSocketClientStatus = {
+    created: false,
+    connected: false,
+    login: false
+  };
+
+  /** 默认构造函数 */
+  constructor(wsUrl: string, token: string, sid: string, chatToken: object) {
+    this.wsUrl = wsUrl;
+    this.token = token;
+    this.chatToken = chatToken;
+    this.sid = sid;
+  }
+
+  async init() {
+    return this.create();
+  }
+
+  getStatus() {
+    return this.status;
+  }
+
+  async create() {
+    const url = this.wsUrl;
+
+    return new Promise((resolve, reject) => {
+      if (!url) {
+        throw new Error('websocket url is required.');
+      }
+      this.client = getClient(url, {
+        onOpen: async () => {
+          try {
+            this.ping();
+            this.interval = setInterval(() => {
+              this.ping();
+            }, PING_INTERVAL);
+          } catch (err) {
+            this.client.reconnect();
+          }
+
+          const data = await this.connect();
+          await this.authentication();
+          resolve(data.value);
+        },
+        onError: err => {
+          resolve(false);
+        },
+        onClose: CloseEvent => {
+          clearInterval(this.interval);
+        }
+      });
+    });
+  }
+
+  on(url: string, callback: (data: WebSocketResp) => void) {
+    if (!url) {
+      throw new Error('url is required.');
+    }
+
+    this.client.addMessageListener(url, callback);
+  }
+
+  off(url: string) {
+    this.client.removeMessageListener(url);
+  }
+
+  async request(url: string, data: object) {
+    let error;
+
+    if (this.client.readyState !== 1) {
+      error = 'websocket connection not ready!';
+      throw new Error(error);
+    }
+
+    try {
+      return this.client.asyncSend(url, data);
+    } catch (e) {
+      console.error(e);
+      throw e;
+    }
+  }
+
+  async connect() {
+    const { sid } = this;
+    if (sid) {
+      this.client.setRequestProperty('sid', sid);
+    }
+
+    const data = await this.request('/v1/session/start', {
+      ...this.chatToken,
+      ...meta
+    });
+
+    if (data && data.value) {
+      const id = data.value as string;
+      this.sid = id;
+      this.client.setRequestProperty('sid', id);
+    }
+    return data || true;
+  }
+
+  ping() {
+    return this.client.ping({});
+  }
+
+  async authentication() {
+    const tk = this.token;
+    const data = this.request('/v1/session/bind/uid/by/token', { token: tk });
+    return data || true;
+  }
+
+  onMessage(callback: ListenerCallback) {
+    this.on('/v1/message/listener', callback);
+  }
+
+  sendMessage(data: object) {
+    return this.request('/v1/send/message', data);
+  }
+
+  markServiced(data: object) {
+    return this.request('/v1/mark/message/serviced', data);
+  }
+
+  /**
+   *
+   * @param {*} data contact_id chat_type start_time limit
+   */
+  getHistoryMessage(data: object) {
+    return this.request('/v1/history/message', data);
+  }
+}

packages/cts-api/src/client.ts

@@ -5,13 +5,17 @@ import { WebsocketError } from './error';
 
 const clientError = 400;
 
+export interface WebSocketResp {
+  value: object | string;
+}
+
 /**
  * 初始化链接以及收发数据
  */
 class Client {
   private _maxPayload: number;
   private _enableLogger: boolean;
-  private listeners: Map<number, (data: string) => void>;
+  private listeners: Map<number, (data: WebSocketResp) => void>;
   private requestHeader: string;
   private responseHeader: string;
   private url: string;
@@ -26,7 +30,7 @@ class Client {
    * @param readyStateCallback 链接状态回调，可以处理onOpen、onClose、onError
    */
   public constructor(url: string, readyStateCallback: ReadyStateCallback) {
-    this.listeners = new Map<number, (data: string) => void>();
+    this.listeners = new Map<number, (data: WebSocketResp) => void>();
     this.requestHeader = '';
     this.requestHeader = '';
     this._maxPayload = 1024 * 1024;
@@ -70,9 +74,9 @@ class Client {
    * 发送ping请求，来保持长连接
    * @param param 请求参数,比如{"hello":"world"}
    */
-  public async ping(param: object): Promise<string> {
+  public async ping(param: object): Promise<WebSocketResp> {
     return new Promise(
-      (resolve: (data: string) => void, reject: (err: WebsocketError) => void): void => {
+      (resolve: (data: WebSocketResp) => void, reject: (err: WebsocketError) => void): void => {
         if (this.socket.readyState !== this.socket.OPEN) {
           if (this._enableLogger) {
             console.log('[ping]: connection refuse');
@@ -85,7 +89,7 @@ class Client {
 
         this.listeners.set(
           heartbeatOperator,
-          (data: string): void => {
+          (data: WebSocketResp): void => {
             const code = this.getResponseProperty('code');
             if (code !== '') {
               const message = this.getResponseProperty('message');
@@ -112,7 +116,7 @@ class Client {
    * @param param 请求参数，比如{"hello":"world"}
    * @param callback 请求状态回调处理
    */
-  public async request(operator: string, param: object): Promise<string> {
+  public async request(operator: string, param: object): Promise<WebSocketResp> {
     return await this.asyncSend(operator, param);
   }
 
@@ -122,7 +126,7 @@ class Client {
    * @param operator 消息监听地址
    * @param listener 定义如何处理从服务端返回的消息
    */
-  public addMessageListener(operator: string, listener: (data: string) => void): void {
+  public addMessageListener(operator: string, listener: (data: WebSocketResp) => void): void {
     this.listeners.set(Utils.crc32(operator), listener);
   }
 
@@ -261,7 +265,9 @@ class Client {
 
               this.responseHeader = packet.header;
 
-              (this.listeners.get(operator) as (data: string) => void)(JSON.parse(packet.body));
+              (this.listeners.get(operator) as (data: WebSocketResp) => void)(
+                JSON.parse(packet.body)
+              );
             }
 
             if (this._enableLogger) {
@@ -284,7 +290,7 @@ class Client {
   /**
    * 断线重连
    */
-  private reconnect(): void {
+  reconnect(): void {
     if (!this.reconnectLock) {
       this.reconnectLock = true;
       if (this._enableLogger) {
@@ -326,9 +332,9 @@ class Client {
    * @param param 请求参数，比如{"hello":"world"}
    * @param callback 请求状态回调处理
    */
-  private asyncSend(operator: string, param: object): Promise<string> {
+  asyncSend(operator: string, param: object): Promise<WebSocketResp> {
     return new Promise(
-      (resolve: (data: string) => void, reject: (err: WebsocketError) => void): void => {
+      (resolve: (data: WebSocketResp) => void, reject: (err: WebsocketError) => void): void => {
         if (this.socket.readyState !== this.socket.OPEN) {
           if (this._enableLogger) {
             console.log('[ping]: connection refuse');
@@ -341,7 +347,7 @@ class Client {
         const listener = Utils.crc32(operator) + sequence;
         this.listeners.set(
           listener,
-          (data: string): void => {
+          (data: WebSocketResp): void => {
             const code = this.getResponseProperty('code');
             if (code !== '') {
               const message = this.getResponseProperty('message');
@@ -367,4 +373,14 @@ class Client {
   }
 }
 
-export { Client };
+let client: Client;
+
+function getClient(url: string, callback: ReadyStateCallback) {
+  if (!client) {
+    client = new Client(url, callback);
+  }
+
+  return client;
+}
+
+export { Client, getClient };