qiscus-sdk-core 2.16.0 → 2.16.1

package/lib/lib/adapters/mqtt.js

@@ -1,26 +1,51 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = void 0;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _match2 = require("../match");
-var _mitt = _interopRequireDefault(require("mitt"));
-var _connect = _interopRequireDefault(require("mqtt/lib/connect"));
-var _superagent = _interopRequireDefault(require("superagent"));
-var _lodash = _interopRequireDefault(require("lodash.debounce"));
-var _util = require("../util");
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-var MqttAdapter = exports["default"] = /*#__PURE__*/function () {
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const match = require("../match.js");
+const mitt = require("mitt");
+const connect = require("mqtt/lib/connect");
+const request = require("superagent");
+const debounce = require("lodash.debounce");
+const util = require("../util.js");
+class MqttAdapter {
   /**
    * @typedef {Function} GetClientId
    * @return {string}
@@ -38,667 +63,416 @@ var MqttAdapter = exports["default"] = /*#__PURE__*/function () {
    * @param {boolean} login
    * @param {MqttAdapterParams} obj
    */
-  function MqttAdapter(_url, core, login, _ref) {
-    var _this = this;
-    var _ref$shouldConnect = _ref.shouldConnect,
-      shouldConnect = _ref$shouldConnect === void 0 ? true : _ref$shouldConnect,
-      brokerLbUrl = _ref.brokerLbUrl,
-      enableLb = _ref.enableLb,
-      getClientId = _ref.getClientId;
-    (0, _classCallCheck2["default"])(this, MqttAdapter);
-    (0, _defineProperty2["default"])(this, "_getClientId", function () {
-      if (_this.getClientId == null) return "".concat(_this.core.AppId, "_").concat(_this.core.user_id, "_").concat(Date.now());
-      return _this.getClientId();
+  constructor(url, core, login, { shouldConnect = true, brokerLbUrl, enableLb, getClientId }) {
+    __publicField(this, "_getClientId", () => {
+      if (this.getClientId == null)
+        return `${this.core.AppId}_${this.core.user_id}_${Date.now()}`;
+      return this.getClientId();
     });
-    (0, _defineProperty2["default"])(this, "__mqtt_connected_handler", function () {
-      _this.emitter.emit('connected');
+    __publicField(this, "__mqtt_connected_handler", () => {
+      this.emitter.emit("connected");
     });
-    (0, _defineProperty2["default"])(this, "__mqtt_reconnect_handler", function () {
-      _this.emitter.emit('reconnect');
+    __publicField(this, "__mqtt_reconnect_handler", () => {
+      this.emitter.emit("reconnect");
     });
-    (0, _defineProperty2["default"])(this, "__mqtt_closed_handler", function () {
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
-      }
-      _this.emitter.emit('close', args);
+    __publicField(this, "__mqtt_closed_handler", (...args) => {
+      this.emitter.emit("close", args);
     });
-    (0, _defineProperty2["default"])(this, "__mqtt_message_handler", function (t, m) {
-      var message = m.toString();
-      var func = _this.matcher(t);
-      _this.logger('message', t, m);
+    __publicField(this, "__mqtt_message_handler", (t, m) => {
+      const message = m.toString();
+      const func = this.matcher(t);
+      this.logger("message", t, m);
       if (func != null) func(message);
     });
-    (0, _defineProperty2["default"])(this, "__mqtt_error_handler", function (err) {
-      if (err && err.message === 'client disconnecting') return;
-      _this.emitter.emit('error', err.message);
-      _this.logger('error', err.message);
+    __publicField(this, "__mqtt_error_handler", (err) => {
+      if (err && err.message === "client disconnecting") return;
+      this.emitter.emit("error", err.message);
+      this.logger("error", err.message);
     });
-    (0, _defineProperty2["default"])(this, "__mqtt_conneck", function (brokerUrl) {
-      var topics = [];
-      var opts = {
+    __publicField(this, "__mqtt_conneck", (brokerUrl) => {
+      const topics = [];
+      const opts = {
         will: {
-          topic: "u/".concat(_this.core.user_id, "/s"),
+          topic: `u/${this.core.user_id}/s`,
           payload: 0,
           retain: true
         },
-        clientId: _this._getClientId()
+        clientId: this._getClientId()
         // reconnectPeriod: 0,
         // connectTimeout: 1 * 1000,
       };
-      if (brokerUrl == null) brokerUrl = _this.cacheRealtimeURL;
-      if (_this.mqtt != null) {
-        var _topics = Object.keys(_this.mqtt._resubscribeTopics);
-        topics.push.apply(topics, _topics);
-        _this.mqtt.removeAllListeners();
-        _this.mqtt.end(true);
-        delete _this.mqtt;
-        _this.mqtt = null;
+      if (brokerUrl == null) brokerUrl = this.cacheRealtimeURL;
+      if (this.mqtt != null) {
+        const _topics = Object.keys(this.mqtt._resubscribeTopics);
+        topics.push(..._topics);
+        this.mqtt.removeAllListeners();
+        this.mqtt.end(true);
+        delete this.mqtt;
+        this.mqtt = null;
       }
-      var mqtt = (0, _connect["default"])(brokerUrl, opts);
-
-      // #region Mqtt Listener
-      mqtt.addListener('connect', _this.__mqtt_connected_handler);
-      mqtt.addListener('reconnect', _this.__mqtt_reconnect_handler);
-      mqtt.addListener('close', _this.__mqtt_closed_handler);
-      mqtt.addListener('error', _this.__mqtt_error_handler);
-      mqtt.addListener('message', _this.__mqtt_message_handler);
-      // #endregion
-
-      _this.logger("resubscribe to old topics ".concat(topics));
-      topics.forEach(function (topic) {
-        return mqtt.subscribe(topic);
-      });
+      const mqtt = connect(brokerUrl, opts);
+      mqtt.addListener("connect", this.__mqtt_connected_handler);
+      mqtt.addListener("reconnect", this.__mqtt_reconnect_handler);
+      mqtt.addListener("close", this.__mqtt_closed_handler);
+      mqtt.addListener("error", this.__mqtt_error_handler);
+      mqtt.addListener("message", this.__mqtt_message_handler);
+      this.logger(`resubscribe to old topics ${topics}`);
+      topics.forEach((topic) => mqtt.subscribe(topic));
       return mqtt;
     });
-    (0, _defineProperty2["default"])(this, "_on_close_handler", (0, _lodash["default"])(/*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
-      var shouldReconnect, _yield$wrapP, _yield$wrapP2, url, err;
-      return _regenerator["default"].wrap(function (_context) {
-        while (1) switch (_context.prev = _context.next) {
-          case 0:
-            shouldReconnect = _this.enableLb === true &&
-            // appConfig enabling realtime lb
-            _this.core.isLogin === true &&
-            // is logged in
-            _this.shouldConnect === true &&
-            // should reconnect?
-            !_this.willConnectToRealtime; // is there still reconnect process in progress?
-            if (_this.logEnabled) {
-              console.group('@mqtt.closed');
-              console.log("this.enableLb(".concat(_this.enableLb, ")"));
-              console.log("this.core.isLogin(".concat(_this.core.isLogin, ")"));
-              console.log("this.shouldConnect(".concat(_this.shouldConnect, ")"));
-              console.log("this.willConnectToRealtime(".concat(_this.willConnectToRealtime, ")"));
-              console.log("shouldReconnect(".concat(shouldReconnect, ")"));
-              console.groupEnd();
-            }
-            if (shouldReconnect) {
-              _context.next = 1;
-              break;
-            }
-            return _context.abrupt("return");
-          case 1:
-            _this.willConnectToRealtime = true;
-            _context.next = 2;
-            return (0, _util.wrapP)(_this.getMqttNode());
-          case 2:
-            _yield$wrapP = _context.sent;
-            _yield$wrapP2 = (0, _slicedToArray2["default"])(_yield$wrapP, 2);
-            url = _yield$wrapP2[0];
-            err = _yield$wrapP2[1];
-            if (err) {
-              _this.logger("cannot get new brokerURL, using old url instead (".concat(_this.cacheRealtimeURL, ")"));
-              _this.mqtt = _this.__mqtt_conneck(_this.cacheRealtimeURL);
-            } else {
-              _this.cacheRealtimeURL = url;
-              _this.logger('trying to reconnect to', url);
-              _this.mqtt = _this.__mqtt_conneck(url);
-            }
-            _this.willConnectToRealtime = false;
-          case 3:
-          case "end":
-            return _context.stop();
-        }
-      }, _callee);
-    })), 1000));
-    (0, _defineProperty2["default"])(this, "subscribtionBuffer", []);
-    (0, _defineProperty2["default"])(this, "unsubscribtionBuffer", []);
-    (0, _defineProperty2["default"])(this, "publishBuffer", []);
-    this.emitter = (0, _mitt["default"])();
+    __publicField(this, "_on_close_handler", debounce(() => __async(this, null, function* () {
+      const shouldReconnect = this.enableLb === true && // appConfig enabling realtime lb
+      this.core.isLogin === true && // is logged in
+      this.shouldConnect === true && // should reconnect?
+      !this.willConnectToRealtime;
+      if (this.logEnabled) {
+        console.group("@mqtt.closed");
+        console.log(`this.enableLb(${this.enableLb})`);
+        console.log(`this.core.isLogin(${this.core.isLogin})`);
+        console.log(`this.shouldConnect(${this.shouldConnect})`);
+        console.log(`this.willConnectToRealtime(${this.willConnectToRealtime})`);
+        console.log(`shouldReconnect(${shouldReconnect})`);
+        console.groupEnd();
+      }
+      if (!shouldReconnect) return;
+      this.willConnectToRealtime = true;
+      const [url, err] = yield util.wrapP(this.getMqttNode());
+      if (err) {
+        this.logger(
+          `cannot get new brokerURL, using old url instead (${this.cacheRealtimeURL})`
+        );
+        this.mqtt = this.__mqtt_conneck(this.cacheRealtimeURL);
+      } else {
+        this.cacheRealtimeURL = url;
+        this.logger("trying to reconnect to", url);
+        this.mqtt = this.__mqtt_conneck(url);
+      }
+      this.willConnectToRealtime = false;
+    }), 1e3));
+    __publicField(this, "subscribtionBuffer", []);
+    __publicField(this, "unsubscribtionBuffer", []);
+    __publicField(this, "publishBuffer", []);
+    this.emitter = mitt();
     this.core = core;
     this.mqtt = null;
     this.brokerLbUrl = brokerLbUrl;
     this.getClientId = getClientId;
     this.enableLb = enableLb;
     this.shouldConnect = shouldConnect;
-    this.matcher = (0, _match2.match)((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, (0, _match2.when)(this.reNewMessage), function (topic) {
-      return _this.newMessageHandler.bind(_this, topic);
-    }), (0, _match2.when)(this.reNotification), function (topic) {
-      return _this.notificationHandler.bind(_this, topic);
-    }), (0, _match2.when)(this.reTyping), function (topic) {
-      return _this.typingHandler.bind(_this, topic);
-    }), (0, _match2.when)(this.reRoomTyping), function (topic) {
-      return _this.roomTypingHandler.bind(_this, topic);
-    }), (0, _match2.when)(this.reDelivery), function (topic) {
-      return _this.deliveryReceiptHandler.bind(_this, topic);
-    }), (0, _match2.when)(this.reRead), function (topic) {
-      return _this.readReceiptHandler.bind(_this, topic);
-    }), (0, _match2.when)(this.reOnlineStatus), function (topic) {
-      return _this.onlinePresenceHandler.bind(_this, topic);
-    }), (0, _match2.when)(this.reChannelMessage), function (topic) {
-      return _this.channelMessageHandler.bind(_this, topic);
-    }), (0, _match2.when)(this.reMessageUpdated), function (topic) {
-      return _this.messageUpdatedHandler.bind(_this, topic);
-    }), (0, _match2.when)(), function (topic) {
-      return _this.logger('topic not handled', topic);
-    }));
-    var _mqtt = this.__mqtt_conneck(_url);
-    this.mqtt = _mqtt;
-
-    // if appConfig set realtimeEnabled to false,
-    // we intentionally end mqtt connection here.
-    // TODO: Make a better way to not connect
-    //       to broker, but still having mqtt client initiated.
-    if (!shouldConnect) _mqtt.end(true);
+    this.matcher = match.match({
+      [match.when(this.reNewMessage)]: (topic) => this.newMessageHandler.bind(this, topic),
+      [match.when(this.reNotification)]: (topic) => this.notificationHandler.bind(this, topic),
+      [match.when(this.reTyping)]: (topic) => this.typingHandler.bind(this, topic),
+      [match.when(this.reRoomTyping)]: (topic) => this.roomTypingHandler.bind(this, topic),
+      [match.when(this.reDelivery)]: (topic) => this.deliveryReceiptHandler.bind(this, topic),
+      [match.when(this.reRead)]: (topic) => this.readReceiptHandler.bind(this, topic),
+      [match.when(this.reOnlineStatus)]: (topic) => this.onlinePresenceHandler.bind(this, topic),
+      [match.when(this.reChannelMessage)]: (topic) => this.channelMessageHandler.bind(this, topic),
+      [match.when(this.reMessageUpdated)]: (topic) => this.messageUpdatedHandler.bind(this, topic),
+      [match.when()]: (topic) => this.logger("topic not handled", topic)
+    });
+    let mqtt = this.__mqtt_conneck(url);
+    this.mqtt = mqtt;
+    if (!shouldConnect) mqtt.end(true);
     this.willConnectToRealtime = false;
-
-    // handle load balencer
-    this.emitter.on('close', this._on_close_handler);
-    // this.emitter.on('connected', () => {
-    //   this.willConnectToRealtime = false
-    // })
-  }
-  return (0, _createClass2["default"])(MqttAdapter, [{
-    key: "cacheRealtimeURL",
-    get: function get() {
-      return this.core.mqttURL;
-    },
-    set: function set(url) {
-      this.core.mqttURL = url;
-    }
-  }, {
-    key: "connect",
-    value: function connect() {
+    this.emitter.on("close", this._on_close_handler);
+  }
+  get cacheRealtimeURL() {
+    return this.core.mqttURL;
+  }
+  set cacheRealtimeURL(url) {
+    this.core.mqttURL = url;
+  }
+  connect() {
+    this.mqtt = this.__mqtt_conneck();
+  }
+  /**
+   * @return {Promise<boolean>}
+   */
+  openConnection() {
+    return __async(this, null, function* () {
+      this.shouldConnect = true;
       this.mqtt = this.__mqtt_conneck();
-    }
-
-    /**
-     * @return {Promise<boolean>}
-     */
-  }, {
-    key: "openConnection",
-    value: (function () {
-      var _openConnection = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
-        return _regenerator["default"].wrap(function (_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              this.shouldConnect = true;
-              this.mqtt = this.__mqtt_conneck();
-            case 1:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this);
-      }));
-      function openConnection() {
-        return _openConnection.apply(this, arguments);
-      }
-      return openConnection;
-    }()
-    /**
-     * @return {Promise<boolean>}
-     */
-    )
-  }, {
-    key: "closeConnection",
-    value: (function () {
-      var _closeConnection = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
-        var _this2 = this;
-        return _regenerator["default"].wrap(function (_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              this.shouldConnect = false;
-              this.mqtt.end(true, function (err) {
-                if (err) {
-                  _this2.logger('error when close connection', err.message);
-                }
-              });
-              this.mqtt = null;
-            case 1:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3, this);
-      }));
-      function closeConnection() {
-        return _closeConnection.apply(this, arguments);
-      }
-      return closeConnection;
-    }())
-  }, {
-    key: "getMqttNode",
-    value: function () {
-      var _getMqttNode = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4() {
-        var res, url, port;
-        return _regenerator["default"].wrap(function (_context4) {
-          while (1) switch (_context4.prev = _context4.next) {
-            case 0:
-              _context4.next = 1;
-              return _superagent["default"].get(this.brokerLbUrl);
-            case 1:
-              res = _context4.sent;
-              url = res.body.data.url;
-              port = res.body.data.wss_port;
-              return _context4.abrupt("return", "wss://".concat(url, ":").concat(port, "/mqtt"));
-            case 2:
-            case "end":
-              return _context4.stop();
-          }
-        }, _callee4, this);
-      }));
-      function getMqttNode() {
-        return _getMqttNode.apply(this, arguments);
-      }
-      return getMqttNode;
-    }()
-  }, {
-    key: "connected",
-    get: function get() {
-      if (this.mqtt == null) return false;
-      return this.mqtt.connected;
-    }
-  }, {
-    key: "subscribe",
-    value: function subscribe() {
-      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-        args[_key2] = arguments[_key2];
-      }
-      this.subscribtionBuffer.push(args);
-      while (this.mqtt != null && this.subscribtionBuffer.length > 0) {
-        var subs = this.subscribtionBuffer.shift();
-        if (subs != null) {
-          var _this$mqtt;
-          this.logger('subscribe topic', subs);
-          (_this$mqtt = this.mqtt).subscribe.apply(_this$mqtt, (0, _toConsumableArray2["default"])(subs));
-        }
-      }
-    }
-  }, {
-    key: "unsubscribe",
-    value: function unsubscribe() {
-      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
-        args[_key3] = arguments[_key3];
-      }
-      this.unsubscribtionBuffer.push(args);
-      while (this.mqtt != null && this.unsubscribtionBuffer.length > 0) {
-        var subs = this.unsubscribtionBuffer.shift();
-        if (subs != null) {
-          var _this$mqtt2;
-          this.logger('unsubscribe topic', subs);
-          (_this$mqtt2 = this.mqtt).unsubscribe.apply(_this$mqtt2, (0, _toConsumableArray2["default"])(subs));
+    });
+  }
+  /**
+   * @return {Promise<boolean>}
+   */
+  closeConnection() {
+    return __async(this, null, function* () {
+      this.shouldConnect = false;
+      this.mqtt.end(true, (err) => {
+        if (err) {
+          this.logger("error when close connection", err.message);
         }
-      }
-    }
-  }, {
-    key: "publish",
-    value: function publish(topic, payload) {
-      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-      this.publishBuffer.push({
-        topic: topic,
-        payload: payload,
-        options: options
       });
-      while (this.mqtt != null && this.publishBuffer.length > 0) {
-        var data = this.publishBuffer.shift();
-        if (data != null) {
-          this.logger('publish to', data.topic, data.payload, data.options);
-          this.mqtt.publish(data.topic, data.payload.toString(), data.options);
-        }
+      this.mqtt = null;
+    });
+  }
+  getMqttNode() {
+    return __async(this, null, function* () {
+      const res = yield request.get(this.brokerLbUrl);
+      const url = res.body.data.url;
+      const port = res.body.data.wss_port;
+      return `wss://${url}:${port}/mqtt`;
+    });
+  }
+  get connected() {
+    if (this.mqtt == null) return false;
+    return this.mqtt.connected;
+  }
+  subscribe(...args) {
+    this.subscribtionBuffer.push(args);
+    while (this.mqtt != null && this.subscribtionBuffer.length > 0) {
+      const subs = this.subscribtionBuffer.shift();
+      if (subs != null) {
+        this.logger("subscribe topic", subs);
+        this.mqtt.subscribe(...subs);
       }
     }
-  }, {
-    key: "emit",
-    value: function emit() {
-      var _this$emitter;
-      (_this$emitter = this.emitter).emit.apply(_this$emitter, arguments);
-    }
-  }, {
-    key: "on",
-    value: function on() {
-      var _this$emitter2;
-      (_this$emitter2 = this.emitter).on.apply(_this$emitter2, arguments);
-    }
-  }, {
-    key: "off",
-    value: function off() {
-      var _this$emitter3;
-      (_this$emitter3 = this.emitter).off.apply(_this$emitter3, arguments);
-    }
-  }, {
-    key: "logEnabled",
-    get: function get() {
-      return this.core.debugMQTTMode;
-    }
-  }, {
-    key: "logger",
-    get: function get() {
-      if (!this.core.debugMQTTMode) return this.noop;
-      return console.log.bind(console, 'QRealtime ->');
-    }
-
-    // #region regexp
-  }, {
-    key: "reNewMessage",
-    get: function get() {
-      return /^(.+)\/c$/i;
-    }
-  }, {
-    key: "reNotification",
-    get: function get() {
-      return /^(.+)\/n$/i;
-    }
-  }, {
-    key: "reTyping",
-    get: function get() {
-      return /^r\/([\d]+)\/([\d]+)\/(.+)\/t$/i;
-    }
-  }, {
-    key: "reRoomTyping",
-    get: function get() {
-      return /^r\/(.+)\/typing$/i;
-    }
-  }, {
-    key: "reDelivery",
-    get: function get() {
-      return /^r\/([\d]+)\/([\d]+)\/(.+)\/d$/i;
-    }
-  }, {
-    key: "reRead",
-    get: function get() {
-      return /^r\/([\d]+)\/([\d]+)\/(.+)\/r$/i;
-    }
-  }, {
-    key: "reOnlineStatus",
-    get: function get() {
-      return /^u\/(.+)\/s$/i;
-    }
-  }, {
-    key: "reChannelMessage",
-    get: function get() {
-      return /^(.+)\/(.+)\/c$/i;
-    }
-  }, {
-    key: "reMessageUpdated",
-    get: function get() {
-      return /^(.+)\/update$/i;
-    }
-    // #endregion
-  }, {
-    key: "noop",
-    value: function noop() {}
-  }, {
-    key: "newMessageHandler",
-    value: function newMessageHandler(topic, message) {
-      message = JSON.parse(message);
-      this.logger('on:new-message', message);
-      this.emit('new-message', message);
-    }
-  }, {
-    key: "notificationHandler",
-    value: function notificationHandler(topic, message) {
-      var _this3 = this;
-      this.logger('on:notification', message);
-      message = JSON.parse(message);
-      var data = message.payload.data;
-      if ('deleted_messages' in data) {
-        data.deleted_messages.forEach(function (message) {
-          _this3.emit('comment-deleted', {
-            roomId: message.room_id,
-            commentUniqueIds: message.message_unique_ids,
-            isForEveryone: true,
-            isHard: true
-          });
-        });
-      }
-      if ('deleted_rooms' in data) {
-        data.deleted_rooms.forEach(function (room) {
-          _this3.emit('room-cleared', room);
-        });
+  }
+  unsubscribe(...args) {
+    this.unsubscribtionBuffer.push(args);
+    while (this.mqtt != null && this.unsubscribtionBuffer.length > 0) {
+      const subs = this.unsubscribtionBuffer.shift();
+      if (subs != null) {
+        this.logger("unsubscribe topic", subs);
+        this.mqtt.unsubscribe(...subs);
       }
     }
-
-    /**
-     * @param {string} t
-     * @param {string} message
-     */
-  }, {
-    key: "roomTypingHandler",
-    value: function roomTypingHandler(t, message) {
-      var _t$match;
-      this.logger('on:room-typing', t);
-      // topic: r/{roomId}/typing
-
-      var roomId = (_t$match = t.match(this.reRoomTyping)) === null || _t$match === void 0 ? void 0 : _t$match[1];
-
-      /**
-       * {
-       *   "room_id": "12333",
-       *   "status": "typing_on",// or "typing_off"
-       *   "sender_id": "user-987",
-       *   "sender_name": "Botku AI",
-       *   "text": "Analyzing your request..."   // optional, max 50 chars
-       * }
-       * @typedef {Object} RoomTypingPayload
-       * @property {number} room_id
-       * @property {('typing_on'|'typing_off')} status
-       * @property {string} sender_id
-       * @property {string} text
-       */
-
-      /**
-       * @type {RoomTypingPayload}
-       */
-      var parsedMessage = JSON.parse(message);
-      this.emit('room-typing', _objectSpread(_objectSpread({}, parsedMessage), {}, {
-        room_id: roomId
-      }));
-    }
-  }, {
-    key: "typingHandler",
-    value: function typingHandler(t, message) {
-      this.logger('on:typing', t);
-      // r/{roomId}/{roomId}/{userId}/t
-      var topic = t.match(this.reTyping);
-      if (topic[3] === this.core.user_id) return;
-      var userId = topic[3];
-      var roomId = topic[1];
-      this.emit('typing', {
-        message: message,
-        userId: userId,
-        roomId: roomId
-      });
-
-      // TODO: Don't allow side-effect
-      // it should be handled in the UI not core
-      if (this.core.selected == null) return;
-      if (message === '1' && roomId === this.core.selected.id) {
-        var actor = this.core.selected.participants.find(function (it) {
-          return it.email === userId;
-        });
-        if (actor == null) return;
-        var displayName = actor.username;
-        this.core.isTypingStatus = "".concat(displayName, " is typing ...");
-      } else {
-        this.core.isTypingStatus = null;
+  }
+  publish(topic, payload, options = {}) {
+    this.publishBuffer.push({ topic, payload, options });
+    while (this.mqtt != null && this.publishBuffer.length > 0) {
+      const data = this.publishBuffer.shift();
+      if (data != null) {
+        this.logger("publish to", data.topic, data.payload, data.options);
+        this.mqtt.publish(
+          data.topic,
+          data.payload.toString(),
+          data.options
+        );
       }
     }
-  }, {
-    key: "deliveryReceiptHandler",
-    value: function deliveryReceiptHandler(t, message) {
-      this.logger('on:delivered', t, message);
-      // r/{roomId}/{roomId}/{userId}/d
-      var topic = t.match(this.reDelivery);
-      var data = message.split(':');
-      var commentId = Number(data[0]);
-      var commentUniqueId = data[1];
-      var userId = topic[3];
-      this.emit('message-delivered', {
-        commentId: commentId,
-        commentUniqueId: commentUniqueId,
-        userId: userId
-      });
-    }
-  }, {
-    key: "readReceiptHandler",
-    value: function readReceiptHandler(t, message) {
-      this.logger('on:read', t, message);
-      // r/{roomId}/{roomId}/{userId}/r
-      var topic = t.match(this.reRead);
-      var data = message.split(':');
-      var commentId = Number(data[0]);
-      var commentUniqueId = data[1];
-      var userId = topic[3];
-      this.emit('message-read', {
-        commentId: commentId,
-        commentUniqueId: commentUniqueId,
-        userId: userId
-      });
-    }
-  }, {
-    key: "onlinePresenceHandler",
-    value: function onlinePresenceHandler(topic, message) {
-      this.logger('on:online-presence', topic, message);
-      // u/guest-1002/s
-      var topicData = this.reOnlineStatus.exec(topic);
-      var userId = topicData[1];
-      this.emit('presence', {
-        message: message,
-        userId: userId
+  }
+  emit(...args) {
+    this.emitter.emit(...args);
+  }
+  on(...args) {
+    this.emitter.on(...args);
+  }
+  off(...args) {
+    this.emitter.off(...args);
+  }
+  get logEnabled() {
+    return this.core.debugMQTTMode;
+  }
+  get logger() {
+    if (!this.core.debugMQTTMode) return this.noop;
+    return console.log.bind(console, "QRealtime ->");
+  }
+  // #region regexp
+  get reNewMessage() {
+    return /^(.+)\/c$/i;
+  }
+  get reNotification() {
+    return /^(.+)\/n$/i;
+  }
+  get reTyping() {
+    return /^r\/([\d]+)\/([\d]+)\/(.+)\/t$/i;
+  }
+  get reRoomTyping() {
+    return /^r\/(.+)\/typing$/i;
+  }
+  get reDelivery() {
+    return /^r\/([\d]+)\/([\d]+)\/(.+)\/d$/i;
+  }
+  get reRead() {
+    return /^r\/([\d]+)\/([\d]+)\/(.+)\/r$/i;
+  }
+  get reOnlineStatus() {
+    return /^u\/(.+)\/s$/i;
+  }
+  get reChannelMessage() {
+    return /^(.+)\/(.+)\/c$/i;
+  }
+  get reMessageUpdated() {
+    return /^(.+)\/update$/i;
+  }
+  // #endregion
+  noop() {
+  }
+  newMessageHandler(topic, message) {
+    message = JSON.parse(message);
+    this.logger("on:new-message", message);
+    this.emit("new-message", message);
+  }
+  notificationHandler(topic, message) {
+    this.logger("on:notification", message);
+    message = JSON.parse(message);
+    const data = message.payload.data;
+    if ("deleted_messages" in data) {
+      data.deleted_messages.forEach((message2) => {
+        this.emit("comment-deleted", {
+          roomId: message2.room_id,
+          commentUniqueIds: message2.message_unique_ids,
+          isForEveryone: true,
+          isHard: true
+        });
       });
     }
-  }, {
-    key: "channelMessageHandler",
-    value: function channelMessageHandler(topic, message) {
-      this.logger('on:channel-message', topic, message);
-      this.emit('new-message', JSON.parse(message));
-    }
-  }, {
-    key: "messageUpdatedHandler",
-    value: function messageUpdatedHandler(topic, message) {
-      message = JSON.parse(message);
-      this.logger('on:message-updated', topic, message);
-      this.emit('message:updated', message);
-    }
-
-    // #region old-methods
-  }, {
-    key: "subscribeChannel",
-    value: function subscribeChannel(appId, uniqueId) {
-      this.subscribe("".concat(appId, "/").concat(uniqueId, "/c"));
-    }
-  }, {
-    key: "subscribeRoom",
-    value: function subscribeRoom(roomId) {
-      if (this.core.selected == null) return;
-      roomId = roomId || this.core.selected.id;
-      this.subscribe("r/".concat(roomId, "/typing"));
-      this.subscribe("r/".concat(roomId, "/").concat(roomId, "/+/t"));
-      this.subscribe("r/".concat(roomId, "/").concat(roomId, "/+/d"));
-      this.subscribe("r/".concat(roomId, "/").concat(roomId, "/+/r"));
-    }
-  }, {
-    key: "unsubscribeRoom",
-    value: function unsubscribeRoom(roomId) {
-      if (this.core.selected == null) return;
-      roomId = roomId || this.core.selected.id;
-      this.unsubscribe("r/".concat(roomId, "/typing"));
-      this.unsubscribe("r/".concat(roomId, "/").concat(roomId, "/+/t"));
-      this.unsubscribe("r/".concat(roomId, "/").concat(roomId, "/+/d"));
-      this.unsubscribe("r/".concat(roomId, "/").concat(roomId, "/+/r"));
-    }
-  }, {
-    key: "subscribeTyping",
-    get: function get() {
-      return this.subscribeRoom.bind(this);
-    }
-  }, {
-    key: "unsubscribeTyping",
-    get: function get() {
-      return this.unsubscribeRoom.bind(this);
-    }
-  }, {
-    key: "subscribeUserChannel",
-    value: function subscribeUserChannel() {
-      this.subscribe("".concat(this.core.userData.token, "/c"));
-      this.subscribe("".concat(this.core.userData.token, "/n"));
-      this.subscribe("".concat(this.core.userData.token, "/update"));
-    }
-  }, {
-    key: "subscribeUserChannelByToken",
-    value: function subscribeUserChannelByToken(token) {
-      this.subscribe("".concat(token, "/c"));
-      this.subscribe("".concat(token, "/n"));
-      this.subscribe("".concat(token, "/update"));
-    }
-  }, {
-    key: "unsubscribeUserChannel",
-    value: function unsubscribeUserChannel() {
-      this.unsubscribe("".concat(this.core.userData.token, "/c"));
-      this.unsubscribe("".concat(this.core.userData.token, "/n"));
-      this.unsubscribe("".concat(this.core.userData.token, "/update"));
-    }
-  }, {
-    key: "unsusbcribeUserChannelByToken",
-    value: function unsusbcribeUserChannelByToken(token) {
-      this.unsubscribe("".concat(token, "/c"));
-      this.unsubscribe("".concat(token, "/n"));
-      this.unsubscribe("".concat(token, "/update"));
-    }
-  }, {
-    key: "publishPresence",
-    value: function publishPresence(userId) {
-      var isOnline = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-      isOnline ? this.publish("u/".concat(userId, "/s"), 1, {
-        retain: true
-      }) : this.publish("u/".concat(userId, "/s"), 0, {
-        retain: true
+    if ("deleted_rooms" in data) {
+      data.deleted_rooms.forEach((room) => {
+        this.emit("room-cleared", room);
       });
     }
-  }, {
-    key: "disconnect",
-    value: function disconnect() {
-      this.publishPresence(this.core.userData.email, false);
-      this.unsubscribe(Object.keys(this.mqtt._resubscribeTopics));
-    }
-  }, {
-    key: "subscribeUserPresence",
-    value: function subscribeUserPresence(userId) {
-      this.subscribe("u/".concat(userId, "/s"));
-    }
-  }, {
-    key: "unsubscribeUserPresence",
-    value: function unsubscribeUserPresence(userId) {
-      this.unsubscribe("u/".concat(userId, "/s"));
-    }
-  }, {
-    key: "subscribeRoomPresence",
-    get: function get() {
-      return this.subscribeUserPresence.bind(this);
-    }
-  }, {
-    key: "unsubscribeRoomPresence",
-    get: function get() {
-      return this.unsubscribeUserPresence.bind(this);
-    }
-  }, {
-    key: "publishTyping",
-    value: function publishTyping(status) {
-      if (this.core.selected == null) return;
-      var roomId = this.core.selected.id;
-      var userId = this.core.user_id;
-      this.publish("r/".concat(roomId, "/").concat(roomId, "/").concat(userId, "/t"), status);
+  }
+  /**
+   * @param {string} t
+   * @param {string} message
+   */
+  roomTypingHandler(t, message) {
+    var _a;
+    this.logger("on:room-typing", t);
+    let roomId = (_a = t.match(this.reRoomTyping)) == null ? void 0 : _a[1];
+    let parsedMessage = JSON.parse(message);
+    this.emit("room-typing", __spreadProps(__spreadValues({}, parsedMessage), { room_id: roomId }));
+  }
+  typingHandler(t, message) {
+    this.logger("on:typing", t);
+    const topic = t.match(this.reTyping);
+    if (topic[3] === this.core.user_id) return;
+    const userId = topic[3];
+    const roomId = topic[1];
+    this.emit("typing", {
+      message,
+      userId,
+      roomId
+    });
+    if (this.core.selected == null) return;
+    if (message === "1" && roomId === this.core.selected.id) {
+      const actor = this.core.selected.participants.find(
+        (it) => it.email === userId
+      );
+      if (actor == null) return;
+      const displayName = actor.username;
+      this.core.isTypingStatus = `${displayName} is typing ...`;
+    } else {
+      this.core.isTypingStatus = null;
     }
-
-    // #endregion
-  }]);
-}();
-module.exports = exports.default;
+  }
+  deliveryReceiptHandler(t, message) {
+    this.logger("on:delivered", t, message);
+    const topic = t.match(this.reDelivery);
+    const data = message.split(":");
+    const commentId = Number(data[0]);
+    const commentUniqueId = data[1];
+    const userId = topic[3];
+    this.emit("message-delivered", {
+      commentId,
+      commentUniqueId,
+      userId
+    });
+  }
+  readReceiptHandler(t, message) {
+    this.logger("on:read", t, message);
+    const topic = t.match(this.reRead);
+    const data = message.split(":");
+    const commentId = Number(data[0]);
+    const commentUniqueId = data[1];
+    const userId = topic[3];
+    this.emit("message-read", {
+      commentId,
+      commentUniqueId,
+      userId
+    });
+  }
+  onlinePresenceHandler(topic, message) {
+    this.logger("on:online-presence", topic, message);
+    const topicData = this.reOnlineStatus.exec(topic);
+    const userId = topicData[1];
+    this.emit("presence", { message, userId });
+  }
+  channelMessageHandler(topic, message) {
+    this.logger("on:channel-message", topic, message);
+    this.emit("new-message", JSON.parse(message));
+  }
+  messageUpdatedHandler(topic, message) {
+    message = JSON.parse(message);
+    this.logger("on:message-updated", topic, message);
+    this.emit("message:updated", message);
+  }
+  // #region old-methods
+  subscribeChannel(appId, uniqueId) {
+    this.subscribe(`${appId}/${uniqueId}/c`);
+  }
+  subscribeRoom(roomId) {
+    if (this.core.selected == null) return;
+    roomId = roomId || this.core.selected.id;
+    this.subscribe(`r/${roomId}/typing`);
+    this.subscribe(`r/${roomId}/${roomId}/+/t`);
+    this.subscribe(`r/${roomId}/${roomId}/+/d`);
+    this.subscribe(`r/${roomId}/${roomId}/+/r`);
+  }
+  unsubscribeRoom(roomId) {
+    if (this.core.selected == null) return;
+    roomId = roomId || this.core.selected.id;
+    this.unsubscribe(`r/${roomId}/typing`);
+    this.unsubscribe(`r/${roomId}/${roomId}/+/t`);
+    this.unsubscribe(`r/${roomId}/${roomId}/+/d`);
+    this.unsubscribe(`r/${roomId}/${roomId}/+/r`);
+  }
+  get subscribeTyping() {
+    return this.subscribeRoom.bind(this);
+  }
+  get unsubscribeTyping() {
+    return this.unsubscribeRoom.bind(this);
+  }
+  subscribeUserChannel() {
+    this.subscribe(`${this.core.userData.token}/c`);
+    this.subscribe(`${this.core.userData.token}/n`);
+    this.subscribe(`${this.core.userData.token}/update`);
+  }
+  subscribeUserChannelByToken(token) {
+    this.subscribe(`${token}/c`);
+    this.subscribe(`${token}/n`);
+    this.subscribe(`${token}/update`);
+  }
+  unsubscribeUserChannel() {
+    this.unsubscribe(`${this.core.userData.token}/c`);
+    this.unsubscribe(`${this.core.userData.token}/n`);
+    this.unsubscribe(`${this.core.userData.token}/update`);
+  }
+  unsusbcribeUserChannelByToken(token) {
+    this.unsubscribe(`${token}/c`);
+    this.unsubscribe(`${token}/n`);
+    this.unsubscribe(`${token}/update`);
+  }
+  publishPresence(userId, isOnline = true) {
+    isOnline ? this.publish(`u/${userId}/s`, 1, { retain: true }) : this.publish(`u/${userId}/s`, 0, { retain: true });
+  }
+  disconnect() {
+    this.publishPresence(this.core.userData.email, false);
+    this.unsubscribe(Object.keys(this.mqtt._resubscribeTopics));
+  }
+  subscribeUserPresence(userId) {
+    this.subscribe(`u/${userId}/s`);
+  }
+  unsubscribeUserPresence(userId) {
+    this.unsubscribe(`u/${userId}/s`);
+  }
+  get subscribeRoomPresence() {
+    return this.subscribeUserPresence.bind(this);
+  }
+  get unsubscribeRoomPresence() {
+    return this.unsubscribeUserPresence.bind(this);
+  }
+  publishTyping(status) {
+    if (this.core.selected == null) return;
+    const roomId = this.core.selected.id;
+    const userId = this.core.user_id;
+    this.publish(`r/${roomId}/${roomId}/${userId}/t`, status);
+  }
+  // #endregion
+}
+module.exports = MqttAdapter;