chore: update

.babelrc

@@ -0,0 +1,11 @@
+{
+  "presets": [
+    "@babel/env",
+    "@babel/typescript"
+  ],
+  "plugins": [
+    "@babel/plugin-transform-runtime",
+    "@babel/proposal-class-properties",
+    "@babel/proposal-object-rest-spread"
+  ]
+}

.editorconfig

@@ -0,0 +1,16 @@
+# http://editorconfig.org
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[Makefile]
+indent_style = tab

.eslintrc.js

@@ -0,0 +1,14 @@
+module.exports = {
+    "parser": "@typescript-eslint/parser",
+    "plugins": ["@typescript-eslint"],
+    "env": {
+        "browser": true,
+        "es6": true
+    },
+    "extends": [
+      "plugin:@typescript-eslint/recommended",
+      "prettier",
+      "prettier/@typescript-eslint"
+    ],
+    "rules": {}
+};

.gitignore

@@ -0,0 +1,5 @@
+node_modules
+dist
+lib
+.cache
+tsconfig.cjs.tsbuildinfo

.prettierrc

@@ -0,0 +1,8 @@
+{
+  "trailingComma": "all",
+  "tabWidth": 2,
+  "indentStyle": "es5",
+  "semi": true,
+  "arrowParens": "always",
+  "singleQuote": true
+}

.vscode/launch.json

@@ -0,0 +1,30 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "node",
+            "name": "vscode-jest-tests",
+            "request": "launch",
+            "args": [
+                "--runInBand"
+            ],
+            "cwd": "${workspaceFolder}",
+            "console": "integratedTerminal",
+            "internalConsoleOptions": "neverOpen",
+            "program": "${workspaceFolder}/node_modules/jest/bin/jest"
+        },
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Launch Program",
+            "program": "${workspaceFolder}/index.js",
+            "preLaunchTask": "tsc: build - tsconfig.json",
+            "outFiles": [
+                "${workspaceFolder}/dist/**/*.js"
+            ]
+        }
+    ]
+}

README.md

@@ -1,3 +1,8 @@
-# ts-sdk
+开发环境
 
-ts-sdk
+运行 npm start可以打开浏览器在console里面看demo运行效果。example目录编写一些使用demo，发布npm包的时候不需要webpack打包
+
+发布npm包
+
+1. 运行 npm build
+2. npm publish

example/main.ts

@@ -0,0 +1,44 @@
+import { Client } from '../src/';
+import { WebsocketError, WebSocketResp } from '../src/types';
+
+const url = 'ws://127.0.0.1:8085';
+const client = Client.getInstance(url, {
+  onOpen(): void {
+    client
+      .ping({})
+      .then(
+        (res: WebSocketResp): void => {
+          console.log('ping sucessful:', res);
+        },
+      )
+      .catch(
+        (reason: WebsocketError): void => {
+          console.log('ping error:', reason.code, reason.msg);
+        },
+      );
+
+    client
+      .request('/v1/healthy', {})
+      .then(
+        (res: WebSocketResp): 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);
+  },
+
+  onError(): void {
+    console.log('close connection');
+  },
+});
+
+client.enableLogger = true;

package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@bilingo.com/ts-linker-sdk",
+  "version": "1.0.4",
+  "description": "linker's ts sdk",
+  "main": "dist/umd/index.js",
+  "types": "dist/types/index.d.ts",
+  "scripts": {
+    "type-check": "tsc --noEmit --project ./tsconfig.cjs.json",
+    "type-check:watch": "npm run type-check -- --watch",
+    "start": "webpack-dev-server --config scripts/webpack/webpack.config.dev.js",
+    "test": "jest --config=scripts/jest/jest.config.js",
+    "build": "npm run clean && npm run build:cjs && npm run build:umd",
+    "build:cjs": "tsc --project ./tsconfig.cjs.json",
+    "build:umd": "cross-env NODE_ENV=production webpack --config scripts/webpack/webpack.config.umd.js",
+    "clean": "rimraf dist"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bilingo-com/ts-sdk"
+  },
+  "author": "adam_fu",
+  "license": "MIT",
+  "dependencies": {
+    "crypto-js": "^3.1.9-1",
+    "eventemitter3": "^4.0.0",
+    "node-int64": "^0.4.0"
+  },
+  "devDependencies": {
+    "cross-env": "^7.0.3",
+    "@babel/cli": "^7.4.4",
+    "@babel/core": "^7.4.4",
+    "@babel/plugin-proposal-class-properties": "^7.4.4",
+    "@babel/plugin-proposal-object-rest-spread": "^7.4.4",
+    "@babel/plugin-transform-runtime": "^7.4.4",
+    "@babel/preset-env": "^7.4.4",
+    "@babel/preset-typescript": "^7.3.3",
+    "@babel/runtime": "^7.4.4",
+    "@types/crypto-js": "^3.1.43",
+    "@types/jest": "^24.0.11",
+    "@types/node-int64": "^0.4.29",
+    "@typescript-eslint/eslint-plugin": "^1.7.0",
+    "@typescript-eslint/parser": "^1.7.0",
+    "babel-core": "^6.26.3",
+    "babel-loader": "^8.0.5",
+    "babel-preset-env": "^1.7.0",
+    "eslint": "^5.16.0",
+    "eslint-config-prettier": "^4.2.0",
+    "eslint-friendly-formatter": "^4.0.1",
+    "eslint-loader": "^2.1.2",
+    "html-webpack-plugin": "^3.2.0",
+    "jest": "^24.5.0",
+    "rimraf": "^2.6.3",
+    "ts-jest": "^24.0.0",
+    "typescript": "3.6",
+    "webpack": "^4.30.0",
+    "webpack-cli": "^3.3.2",
+    "webpack-dev-server": "^3.3.1"
+  },
+  "files": [
+    "dist/"
+  ]
+}

scripts/jest/jest.config.js

@@ -0,0 +1,8 @@
+module.exports = {
+  transform: {
+    '^.+\\.tsx?$': 'ts-jest',
+  },
+  rootDir: '../../',
+  testRegex: '(/test/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$',
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+};

scripts/webpack/webpack.config.dev.js

@@ -0,0 +1,42 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+
+const path = require('path');
+const rootPath = process.cwd();
+const HtmlWebpackPlugin = require('html-webpack-plugin');
+
+module.exports = {
+  mode: 'development',
+  entry: './example/main.ts',
+  devtool: 'inline-source-map',
+  devServer: {
+    compress: true,
+    hot: true,
+  },
+  plugins: [
+    new HtmlWebpackPlugin({
+      title: 'index',
+    }),
+  ],
+  output: {
+    filename: '[name].bundle.js',
+    path: path.resolve(rootPath, 'dist'),
+  },
+  resolve: { extensions: ['.js', '.jsx', '.tsx', '.ts', '.json'] },
+  module: {
+    rules: [
+      {
+        // Include ts, tsx, js, and jsx files.
+        test: /\.(ts|js)x?$/,
+        exclude: /node_modules/,
+        loader: 'babel-loader',
+      },
+      {
+        test: /\.(ts|js)x?$/,
+        loader: 'eslint-loader',
+        options: {
+          formatter: require('eslint-friendly-formatter'),
+        },
+      },
+    ],
+  },
+};

scripts/webpack/webpack.config.umd.js

@@ -0,0 +1,34 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+
+const path = require('path');
+const rootPath = process.cwd();
+
+module.exports = {
+  mode: 'production',
+  entry: './src/index.ts',
+  devtool: false,
+  output: {
+    filename: 'index.js',
+    path: path.resolve(rootPath, 'dist/umd'),
+    library: 'imSdk',
+    libraryTarget: 'umd',
+  },
+  resolve: { extensions: ['.js', '.jsx', '.tsx', '.ts', '.json'] },
+  module: {
+    rules: [
+      {
+        // Include ts, tsx, js, and jsx files.
+        test: /\.(ts|js)x?$/,
+        exclude: /node_modules/,
+        loader: 'babel-loader',
+      },
+      {
+        test: /\.(ts|js)x?$/,
+        loader: 'eslint-loader',
+        options: {
+          formatter: require('eslint-friendly-formatter'),
+        },
+      },
+    ],
+  },
+};

src/index.ts

@@ -0,0 +1,447 @@
+import { Packet } from './packet';
+import { Utils } from './utils';
+import {
+  WebsocketError,
+  WebSocketResp,
+  ReadyStateCallback,
+} from './types/index';
+import EventEmitter from 'eventemitter3';
+
+const clientError = 400;
+
+/**
+ * 初始化链接以及收发数据
+ */
+class Client {
+  private _maxPayload: number;
+  private _enableLogger: boolean;
+  private static instance: Client;
+  private listeners: EventEmitter;
+  private binaryType: BinaryType;
+  private requestHeader: string;
+  private responseHeader: string;
+  private url: string;
+  private reconnectTimes: number;
+  private reconnectLock: boolean;
+  private socket: WebSocket;
+  private readyStateCallback: ReadyStateCallback;
+
+  /**
+   * 构造函数，初始化客户端链接
+   * @param url websocket链接地址
+   * @param readyStateCallback 链接状态回调，可以处理onOpen、onClose、onError
+   */
+  private constructor(url: string, readyStateCallback: ReadyStateCallback, binaryType?: BinaryType) {
+    this.binaryType = binaryType || 'blob';
+    this.listeners = new EventEmitter();
+    this.requestHeader = '';
+    this.requestHeader = '';
+    this._maxPayload = 1024 * 1024;
+    this.url = url;
+    this.reconnectTimes = 0;
+    this.readyStateCallback = readyStateCallback;
+    this._enableLogger = false;
+    this.socket = this.connect();
+  }
+
+  /**
+   * 通过单例模式获取客户端链接
+   * @param url websocket链接地址
+   * @param readyStateCallback 链接状态回调，可以处理onOpen、onClose、onError
+   * @param binaryType "arraybuffer" | "blob"
+   * @param allwaysNew 是否保持新建Client
+   */
+  public static getInstance(url: string, callback: ReadyStateCallback, binaryType?: BinaryType, allwaysNew?: boolean): Client {
+    if (allwaysNew || !Client.instance) {
+      Client.instance = new Client(url, callback, binaryType);
+    }
+
+    return Client.instance;
+  }
+
+  /**
+   * 设置可以处理的数据包上限
+   * @param maxPayload 最多可以处理的数据包大小
+   */
+  public set maxPayload(maxPayload: number) {
+    this._maxPayload = maxPayload;
+  }
+
+  /**
+   * 获取可以处理的数据包大小
+   */
+  public get maxPayload(): number {
+    return this._maxPayload;
+  }
+
+  /**
+   * 设置是否允许显示运行日志
+   */
+  public set enableLogger(enableLogger: boolean) {
+    this._enableLogger = enableLogger;
+  }
+
+  /**
+   * 获取是否显示日志的配置信息
+   */
+  public get enableLogger(): boolean {
+    return this._enableLogger;
+  }
+
+  /**
+   * 发送ping请求，来保持长连接
+   * @param param 请求参数,比如{"hello":"world"}
+   */
+  public async ping(param: object): Promise<WebSocketResp> {
+    return new Promise(
+      (
+        resolve: (data: WebSocketResp) => 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, 'connection refuse'));
+        }
+
+        const heartbeatOperator = 0;
+
+        this.listeners.addListener(
+          heartbeatOperator.toString(),
+          (data: WebSocketResp): 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,
+          );
+        }
+      },
+    );
+  }
+
+  /**
+   * 同步方式向服务端发送请求
+   * @param operator 路由地址
+   * @param param 请求参数，比如{"hello":"world"}
+   * @param callback 请求状态回调处理
+   */
+  public async request(
+    operator: string,
+    param: object,
+  ): Promise<WebSocketResp> {
+    return await this.asyncSend(operator, param);
+  }
+
+  /**
+   * 添加消息监听
+   * @description 添加消息监听器，比如operator是/v1/message/listener，那么从服务端推送到/v1/message/listener的消息会进入到定义的listener里面进行处理
+   * @param operator 消息监听地址
+   * @param listener 定义如何处理从服务端返回的消息
+   */
+  public addMessageListener(
+    operator: string,
+    listener: (data: WebSocketResp) => void,
+  ): void {
+    this.listeners.addListener(Utils.crc32(operator).toString(), listener);
+  }
+
+  /**
+   * 移除消息监听
+   * @param operator 消息监听地址
+   */
+  public removeMessageListener(operator: string): void {
+    this.listeners.removeListener(Utils.crc32(operator).toString());
+  }
+
+  /**
+   * 返回Websocket链接状态
+   * @returns Websocket的链接状态
+   */
+  public get readyState(): number {
+    return this.socket.readyState;
+  }
+
+  /**
+   * 添加请求属性，会携带在数据帧里面发送到服务端
+   * @param key 属性名
+   * @param value 属性值
+   */
+  public setRequestProperty(key: string, value: string): void {
+    let v = this.getRequestProperty(key);
+
+    this.requestHeader = this.requestHeader.replace(key + '=' + v + ';', '');
+    this.requestHeader = this.requestHeader + key + '=' + value + ';';
+  }
+
+  /**
+   * 获取请求属性
+   * @param key 属性名
+   */
+  public getRequestProperty(key: string): string {
+    if (this.requestHeader !== undefined) {
+      let values = this.requestHeader.split(';');
+      for (let index in values) {
+        let kv = values[index].split('=');
+        if (kv[0] === key) {
+          return kv[1];
+        }
+      }
+    }
+
+    return '';
+  }
+
+  /**
+   * 设置响应属性，客户端基本用不到，都是服务端来进行设置
+   * @param key 属性名
+   * @param value 属性值
+   */
+  public setResponseProperty(key: string, value: string): void {
+    let v = this.getResponseProperty(key);
+
+    this.responseHeader = this.responseHeader.replace(key + '=' + v + ';', '');
+    this.responseHeader = this.responseHeader + key + '=' + value + ';';
+  }
+
+  /**
+   * 获取从服务端返回的属性
+   * @param key 获取响应属性
+   */
+  public getResponseProperty(key: string): string {
+    if (this.responseHeader !== undefined) {
+      let values = this.responseHeader.split(';');
+      for (let index in values) {
+        let kv = values[index].split('=');
+        if (kv[0] === key) {
+          return kv[1];
+        }
+      }
+    }
+
+    return '';
+  }
+  /**
+   * 关闭客户端链接
+   */
+  public close(code?: number, reason?: string): void {
+    // 如果是主动关闭
+    this.reconnectLock = true;
+    this.socket.close(code, reason);
+  }
+  /**
+   * 创建websocket链接
+   */
+  private connect(): WebSocket {
+    const readyStateCallback = this.readyStateCallback;
+    let ws = new WebSocket(this.url);
+
+    ws.binaryType = this.binaryType;
+
+    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);
+    };
+
+    ws.onmessage = (ev): void => {
+      const handleData = (data: ArrayBuffer) => {
+        try {
+          let packet = new Packet().unPack(data);
+          let packetLength = packet.headerLength + packet.bodyLength + 20;
+          if (packetLength > this._maxPayload) {
+            throw new Error('the packet is big than ' + this._maxPayload);
+          }
+
+          let operator = Number(packet.operator) + Number(packet.sequence);
+          let listener = operator.toString();
+
+          this.listeners.listeners(listener).forEach((param): void => {
+            if (packet.body === '') {
+              packet.body = '{}';
+            }
+
+            this.responseHeader = packet.header;
+
+            (param as (data: WebSocketResp) => void)(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);
+        }
+      }
+      // 区分不同类型数据的解析（暂时支持Blob和ArrayBuffer)
+      if (ev.data instanceof Blob) {
+        let reader = new FileReader();
+        reader.readAsArrayBuffer(ev.data);
+        reader.onload = (): void => {
+          handleData(reader.result as ArrayBuffer)
+        };
+      } else if(ev.data instanceof ArrayBuffer) {
+        handleData(ev.data);
+      } else {
+        throw new Error('unsupported data format');
+      }
+    };
+
+    return ws;
+  }
+
+  /**`
+   * 断线重连
+   */
+  private reconnect(): void {
+    if (!this.reconnectLock) {
+      this.reconnectLock = true;
+      if (this._enableLogger) {
+        console.info('websocket reconnect in ' + this.reconnectTimes + 's');
+      }
+
+      // 尝试重连
+      setTimeout((): void => {
+        this.reconnectTimes++;
+        this.socket = this.connect();
+        this.reconnectLock = false;
+      }, this.reconnectTimes * 1000);
+    }
+  }
+
+  /**
+   * 向服务端发送数据请求
+   * @param data 向服务端传送的数据
+   */
+  private send(data: ArrayBuffer): void {
+    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);
+    }
+  }
+
+  /**
+   * 异步向服务端发送请求
+   * @param operator 路由地址
+   * @param param 请求参数，比如{"hello":"world"}
+   * @param callback 请求状态回调处理
+   */
+  private asyncSend(operator: string, param: object): Promise<WebSocketResp> {
+    return new Promise(
+      (
+        resolve: (data: WebSocketResp) => 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.addListener(
+          listener.toString(),
+          (data: WebSocketResp): 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 };

src/packet.ts

@@ -0,0 +1,68 @@
+import { Utils } from './utils';
+import Int64 from 'node-int64';
+
+export class Packet {
+  private key: string = 'b8ca9aa66def05ff3f24919274bb4a66';
+  public operator: number;
+  public sequence: number;
+  public headerLength: number;
+  public bodyLength: number;
+  public header: string;
+  public body: string;
+
+  public pack(
+    operator: number,
+    sequence: number,
+    header: string,
+    body: string,
+  ): ArrayBuffer {
+    header = Utils.encrypt(header, this.key, this.key);
+    body = Utils.encrypt(body, this.key, this.key);
+
+    const headerLength = header.length;
+    const bodyLength = body.length;
+
+    const buf = new ArrayBuffer(20 + headerLength + bodyLength);
+    const dataView = new DataView(buf);
+    const nsBuf = new Int64(sequence).toBuffer();
+
+    dataView.setUint32(0, operator);
+    dataView.setUint32(12, headerLength);
+    dataView.setUint32(16, bodyLength);
+
+    let bufView = new Uint8Array(buf);
+    for (var i = 0; i < 8; i++) {
+      bufView[4 + i] = nsBuf[i];
+    }
+    for (let i = 0; i < headerLength; i++) {
+      bufView[20 + i] = header.charCodeAt(i);
+    }
+
+    for (let i = 0; i < bodyLength; i++) {
+      bufView[20 + headerLength + i] = body.charCodeAt(i);
+    }
+
+    return buf;
+  }
+
+  public unPack(data: ArrayBuffer | SharedArrayBuffer): Packet {
+    const dataView = new DataView(data);
+
+    this.operator = dataView.getUint32(0, false);
+    this.sequence = new Int64(
+      new Uint8Array(dataView.buffer.slice(4, 12)),
+    ).toNumber();
+    this.headerLength = dataView.getUint32(12, false);
+    this.bodyLength = dataView.getUint32(16, false);
+
+    const header = Utils.ab2str(
+      dataView.buffer.slice(20, 20 + this.headerLength),
+    );
+    const body = Utils.ab2str(dataView.buffer.slice(20 + this.headerLength));
+
+    this.header = Utils.decrypt(header, this.key, this.key);
+    this.body = Utils.decrypt(body, this.key, this.key);
+
+    return this;
+  }
+}

src/types/callback.ts

@@ -0,0 +1,5 @@
+export interface ReadyStateCallback {
+  onOpen(ev: Event): void;
+  onError(ev: Event): void;
+  onClose(ev: Event): void;
+}

src/types/index.ts

@@ -0,0 +1,32 @@
+export interface WebSocketResp {
+  value: object | string;
+}
+
+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;
+  }
+}
+
+export { ReadyStateCallback } from './callback';

src/utils.ts

@@ -0,0 +1,157 @@
+import { AES, enc, mode, pad } from 'crypto-js';
+
+declare global {
+  interface Window {
+    crcTable: number[];
+  }
+}
+
+class Utils {
+  private static code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split(
+    '',
+  );
+
+  public static crc32(str: string): number {
+    const crcTable =
+      window.crcTable || (window.crcTable = Utils.makeCRCTable());
+    let crc = 0 ^ -1;
+
+    for (let i = 0; i < str.length; i++) {
+      crc = (crc >>> 8) ^ crcTable[(crc ^ str.charCodeAt(i)) & 0xff];
+    }
+
+    return (crc ^ -1) >>> 0;
+  }
+
+  // ArrayBuffer 转为字符串，参数为 ArrayBuffer 对象
+  public static ab2str(buf: ArrayBuffer): string {
+    // 注意，如果是大型二进制数组，为了避免溢出，必须一个一个字符地转
+    if (buf && buf.byteLength < 1024) {
+      return String.fromCharCode.apply(null, new Uint8Array(buf));
+    }
+
+    const bufView = new Uint8Array(buf);
+    const len = bufView.length;
+    const byteStr = new Array(len);
+
+    for (let i = 0; i < len; i++) {
+      byteStr[i] = String.fromCharCode.call(null, bufView[i]);
+    }
+
+    return byteStr.join('');
+  }
+
+  // 字符串转为 ArrayBuffer 对象，参数为字符串
+  public static str2ab(str: string): ArrayBuffer {
+    const buf = new ArrayBuffer(str.length); // 每个字符占用2个字节
+    const bufView = new Uint8Array(buf);
+
+    for (let i = 0, strLen = str.length; i < strLen; i++) {
+      bufView[i] = str.charCodeAt(i);
+    }
+
+    return buf;
+  }
+
+  // 解密服务端传递过来的字符串
+  public static decrypt(data: string, key: string, iv: string): string {
+    const binData = Utils.stringToBin(data);
+    const base64Data = Utils.binToBase64(binData);
+
+    const bytes = AES.decrypt(base64Data, enc.Latin1.parse(key), {
+      iv: enc.Latin1.parse(iv),
+      mode: mode.CBC,
+      padding: pad.Pkcs7,
+    });
+
+    return bytes.toString(enc.Utf8);
+  }
+
+  // 加密字符串以后传递到服务端
+  public static encrypt(data: string, key: string, iv: string): string {
+    const result = AES.encrypt(data, enc.Latin1.parse(key), {
+      iv: enc.Latin1.parse(iv),
+      mode: mode.CBC,
+      padding: pad.Pkcs7,
+    });
+
+    return Utils.binToString(Utils.base64ToBin(result.toString()));
+  }
+
+  // 字节数组转换为base64编码
+  public static binToBase64(bitString: string): string {
+    const tail = bitString.length % 6;
+    const bitStringTemp1 = bitString.substr(0, bitString.length - tail);
+
+    let result = '';
+    let bitStringTemp2 = bitString.substr(bitString.length - tail, tail);
+
+    for (let i = 0; i < bitStringTemp1.length; i += 6) {
+      let 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;
+  }
+
+  // base64编码转换为字节数组
+  public static base64ToBin(str: string): string {
+    let bitString = '';
+    let tail = 0;
+
+    for (let i = 0; i < str.length; i++) {
+      if (str[i] !== '=') {
+        let 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);
+  }
+
+  // 字符串转换为字节数组
+  public static stringToBin(str: string): string {
+    let result = '';
+    for (let i = 0; i < str.length; i++) {
+      let charCode = str.charCodeAt(i).toString(2);
+      result += new Array(9 - charCode.length).join('0') + charCode;
+    }
+
+    return result;
+  }
+
+  // 字节数组转化为字符串
+  public static binToString(bin: string): string {
+    let result = '';
+    for (let i = 0; i < bin.length; i += 8) {
+      result += String.fromCharCode(parseInt(bin.substr(i, 8), 2));
+    }
+
+    return result;
+  }
+
+  private static makeCRCTable(): number[] {
+    let c: number;
+    let crcTable: number[] = [];
+
+    for (let n = 0; n < 256; n++) {
+      c = n;
+      for (let k = 0; k < 8; k++) {
+        c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+      }
+      crcTable[n] = c;
+    }
+
+    return crcTable;
+  }
+}
+
+export { Utils };

test/utils.test.ts

@@ -0,0 +1,24 @@
+import { Utils } from '../src/utils';
+
+test('utils crc32', (): void => {
+  const v = Utils.crc32('/v1/session/init');
+  expect(v).toBe(1897767088);
+});
+
+test('utils str2ab and ab2str', (): void => {
+  expect(Utils.ab2str(Utils.str2ab('test'))).toBe('test');
+});
+
+test('utils encrypt and decrypt', (): void => {
+  const key = 'b8ca9aa66def05ff3f24919274bb4a66';
+  const iv = key;
+  expect(Utils.decrypt(Utils.encrypt('test', key, iv), key, iv)).toBe('test');
+});
+
+test('utils binToBase64 and base64ToBin', (): void => {
+  expect(Utils.binToBase64(Utils.base64ToBin('test'))).toBe('test');
+});
+
+test('utils stringToBin and binToString', (): void => {
+  expect(Utils.binToString(Utils.stringToBin('test'))).toBe('test');
+});

tsconfig.cjs.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "rootDir": "src",
+    "outDir": "dist",
+    "declaration": true,
+    "declarationDir": "dist/types",
+    "sourceMap": false
+  }
+}

tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compileOnSave": true,
+  "compilerOptions": {
+    // Target latest version of ECMAScript.
+    "target": "es5",
+    // Search under node_modules for non-relative imports.
+    "moduleResolution": "node",
+    // Process & infer types from .js files.
+    "allowJs": false,
+    // Import non-ES modules as default imports.
+    "esModuleInterop": true,
+    // Enable strictest settings like strictNullChecks & noImplicitAny.
+    "strictNullChecks": true,
+    "incremental": true,
+    "alwaysStrict": true,
+    "sourceMap": true,
+    "rootDirs": ["src", "example"],
+    "outDir": "lib/"
+  },
+  "include": ["src/**/*"]
+}