framework4js/framework/spanners/WebSocketClient.js

Framework-for-js is a better Javascript's framework

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
/**
 * WebSocket封装
 * 快速使用WS进行开发
 * ws单例和多例模式
 */
var WebSocketClient = /*#__PURE__*/function () {
  function WebSocketClient() {
    (0, _classCallCheck2["default"])(this, WebSocketClient);
    // ws模式
    this.mode = 'single';
    // ws单例名称
    this.wsInstanceName = '';
    // ws多例
    this.wsInstances = new Map();
    // 多例心跳频率
    this.heartRates = new Map();
    // 多例心跳定时器
    this.heartRateTimers = new Map();
    // 多例重启次数
    this.restarts = new Map();
  }

  /**
   * WebSocketClient初始化
   * @param ws 服务器网址（非加密）
   * @param wss 服务器网址（SSL）
   * @param insName {String} 多例名称
   * @param heartRate {Number} 心跳频率 毫秒
   * @param restart {Number} 重启次数
   * @param heartbeat {Function} 心跳执行函数  send {Function} 消息发送函数
   */
  (0, _createClass2["default"])(WebSocketClient, null, [{
    key: "init",
    value: function init(_ref, heartbeat) {
      var ws = _ref.ws,
        wss = _ref.wss,
        insName = _ref.insName,
        _ref$heartRate = _ref.heartRate,
        heartRate = _ref$heartRate === void 0 ? 0 : _ref$heartRate,
        _ref$restart = _ref.restart,
        restart = _ref$restart === void 0 ? 0 : _ref$restart;
      if (!ws && !wss) {
        throw new Error('WebSocketClient未添加ws或wss地址');
      }
      try {
        // 一个项目中ws只能有一个单例，其余必须走多例
        WebSocketClient.getInstance().wsInstanceName = WebSocketClient.getInstance().wsInstanceName || WebSocketClient.randomString(16);
        // 格式化心跳频率 ms
        var heartRateFormat = Number(heartRate).toString() !== 'NaN' ? Number(heartRate) : 0;
        // 创建ws实例
        var wsInstance = new WebSocket(ws || wss);
        // 存入状态
        WebSocketClient.getInstance().wsInstances.set(WebSocketClient.getWsInstanceName(insName), wsInstance);
        // 心跳频率
        WebSocketClient.getInstance().heartRates.set(WebSocketClient.getWsInstanceName(insName), heartRateFormat);
        // 存在心跳执行业务函数
        if (typeof heartbeat === 'function') {
          WebSocketClient.heartbeat(function () {
            var send = function send(msg) {
              WebSocketClient.sendMessage(msg, WebSocketClient.getWsInstanceName(insName));
            };
            heartbeat(send, WebSocketClient.getWsInstanceName(insName));
          }, WebSocketClient.getWsInstanceName(insName));
        }
      } catch (e) {
        console.log(e);
      }
    }

    /**
     * 销毁ws实例
     * @param insName
     */
  }, {
    key: "destroy",
    value: function destroy(insName) {
      var wsInstanceName = WebSocketClient.getWsInstanceName(insName);
      var timers = WebSocketClient.getHeartRateTimer(wsInstanceName);
      // 销毁完毕
      if (!wsInstanceName && !timers) {
        return;
      }
      if (Array.isArray(timers)) {
        timers.map(function (timer) {
          clearInterval(timer);
        });
      }
      try {
        WebSocketClient.getInstance().heartRates["delete"](wsInstanceName);
        WebSocketClient.getInstance().wsInstances["delete"](wsInstanceName);
      } catch (e) {
        console.warn("".concat(wsInstanceName, "\u9500\u6BC1\u5931\u8D25").concat(e));
      }
    }

    /**
     * 返回当前ws实例名称
     * @param insName
     * @return {string|*}
     */
  }, {
    key: "getWsInstanceName",
    value: function getWsInstanceName(insName) {
      return insName || WebSocketClient.getInstance().wsInstanceName;
    }

    /**
     * 返回ws实例
     * @param {String} insName 实例名称
     * @return {WebSocketClient}
     */
  }, {
    key: "getWsInstance",
    value: function getWsInstance(insName) {
      // 多例实例名称
      var wsInstanceName = WebSocketClient.getWsInstanceName(WebSocketClient.getWsInstanceName(insName));
      // 存在实例
      if (WebSocketClient.getInstance().wsInstances.has(wsInstanceName)) {
        return WebSocketClient.getInstance().wsInstances.get(wsInstanceName);
      }
      // WebSocketClient.destroy(wsInstanceName)
      // throw new Error(`${wsInstanceName}实例已销毁，不可获取`)
    }

    /**
     * 获取ws实例连接状态
     * @param {String} insName 实例名称
     * @return {string} CONNECTING OPEN CLOSING CLOSED
     */
  }, {
    key: "getWsState",
    value: function getWsState(insName) {
      var instance = WebSocketClient.getWsInstance(insName);
      if (instance.readyState === WebSocket.CONNECTING) {
        return 'CONNECTING';
      }
      if (instance.readyState === WebSocket.OPEN) {
        return 'OPEN';
      }
      if (instance.readyState === WebSocket.CLOSING) {
        return 'CLOSING';
      }
      if (instance.readyState === WebSocket.CLOSED) {
        return 'CLOSED';
      }
      return 'FAIL';
    }

    /**
     * 监听ws报错
     * @param {Function} callback 监听ws报错的回调函数
     * @param {String} insName insName 实例名称
     */
  }, {
    key: "wsErrorEventListener",
    value: function wsErrorEventListener(callback, insName) {
      try {
        WebSocketClient.getWsInstance(insName).onerror = function (event) {
          if (typeof callback === 'function') {
            callback(event);
          } else {
            console.warn('监听ws报错的回调函数wsError不存在');
          }
        };
      } catch (e) {
        console.warn("".concat(e));
      }
    }

    /**
     * 监听ws关闭
     * @param {Function} callback 监听ws关闭的回调函数
     * @param {String} insName insName 实例名称
     */
  }, {
    key: "wsCloseEventListener",
    value: function wsCloseEventListener(callback, insName) {
      try {
        WebSocketClient.getWsInstance(insName).onclose = function (event) {
          if (typeof callback === 'function') {
            callback(event);
          } else {
            console.warn('监听ws关闭的回调函数wsClose不存在');
          }
        };
      } catch (e) {
        console.warn("".concat(e));
      }
    }

    /**
     * 监听ws打开
     * @param {Function} callback 监听ws打开的回调函数
     * @param {String} insName insName 实例名称
     */
  }, {
    key: "wsOpenEventListener",
    value: function wsOpenEventListener(callback, insName) {
      try {
        WebSocketClient.getWsInstance(insName).onopen = function (event) {
          if (typeof callback === 'function') {
            callback(event);
          } else {
            console.warn('监听ws打开的回调函数wsOpen不存在');
          }
        };
      } catch (e) {
        console.warn("".concat(e));
      }
    }

    /**
     * 消息发送
     * @param {String} msg 消息
     * @param {String} insName insName 实例名称
     * @param {Boolean} isCloseWarn 是否关闭警告
     */
  }, {
    key: "sendMessage",
    value: function sendMessage() {
      var msg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
      var insName = arguments.length > 1 ? arguments[1] : undefined;
      var isCloseWarn = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
      // 当ws状态处于 CONNECTING CLOSING CLOSED 禁止消息发送
      if (!['CONNECTING', 'CLOSING', 'CLOSED'].includes(WebSocketClient.getWsState(insName))) {
        try {
          WebSocketClient.getWsInstance(insName).send(msg);
        } catch (e) {
          console.warn("".concat(e));
        }
      } else if (!isCloseWarn) {
        console.warn('ws当前状态处于CONNECTING、CLOSING、CLOSED禁止消息发送');
      }
    }

    /**
     * 消息接收
     * @param {Function} callback 接收消息的回调函数
     * @param {String} insName insName 实例名称
     */
  }, {
    key: "receiveMessage",
    value: function receiveMessage(callback, insName) {
      try {
        WebSocketClient.getWsInstance(insName).onmessage = function (event) {
          if (typeof callback === 'function') {
            callback(event);
          } else {
            console.warn('接收ws消息的回调函数receiveMessage不存在');
          }
        };
      } catch (e) {
        console.warn("".concat(e));
      }
    }

    /**
     * 处理心跳频率数据
     * @param {String} name 实例名称
     * @return {number|number}
     */
  }, {
    key: "getHeartRate",
    value: function getHeartRate(name) {
      var heartRate = WebSocketClient.getInstance().heartRates.get(name);
      return Number(heartRate).toString() === 'NaN' ? 0 : Number(heartRate);
    }

    /**
     * 获取心跳定时器
     * @param name
     * @return {any|*[]}
     */
  }, {
    key: "getHeartRateTimer",
    value: function getHeartRateTimer(name) {
      return WebSocketClient.getInstance().heartRateTimers.get(name) || [];
    }

    /**
     * 获设置心跳定时器
     * @param name
     * @param val
     * @return {Map<any, any>}
     */
  }, {
    key: "setHeartRateTimer",
    value: function setHeartRateTimer(name, val) {
      return WebSocketClient.getInstance().heartRateTimers.set(name, val);
    }

    /**
     * 心跳函数
     * @param {Function} callback 心跳执行函数
     * @param {String} insName insName 实例名称
     */
  }, {
    key: "heartbeat",
    value: function heartbeat(callback, insName) {
      var wsInstanceName = WebSocketClient.getWsInstanceName(insName);
      var heartRate = WebSocketClient.getHeartRate(wsInstanceName);
      // 心跳频率未设置
      if (!heartRate) {
        return;
      }
      // ws多例回调
      var timer = setInterval(function () {
        callback(WebSocketClient);
      }, heartRate);
      var timers = WebSocketClient.getHeartRateTimer(wsInstanceName);
      // 加入队列
      timers.push(timer);
      WebSocketClient.setHeartRateTimer(wsInstanceName, timers);
    }

    /**
     * Singleton
     * @return {null}
     */
  }, {
    key: "getInstance",
    value: function getInstance() {
      var instance = WebSocketClient.instance;
      if (!instance || !(instance instanceof WebSocketClient)) {
        instance = WebSocketClient.instance = new WebSocketClient();
      }
      return instance;
    }

    /**
     * 生成随机字符串
     * @param len
     * @return {string}
     */
  }, {
    key: "randomString",
    value: function randomString() {
      var len = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 32;
      // 默认去掉了容易混淆的字符oOLl,9gq,Vv,Uu,I1
      var chars = 'ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678';
      var maxNum = chars.length;
      var str = '';
      for (var i = 0; i < len; i++) {
        str += chars.charAt(Math.floor(Math.random() * maxNum));
      }
      return str;
    }
  }]);
  return WebSocketClient;
}();
exports["default"] = WebSocketClient;
(0, _defineProperty2["default"])(WebSocketClient, "instance", null);