@hellotext/hellotext 2.5.7 → 2.5.8

package/lib/channels/webchat_channel.cjs

@@ -6,189 +6,144 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 var _application_channel = _interopRequireDefault(require("./application_channel"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-let WebchatChannel = /*#__PURE__*/function (_ApplicationChannel) {
-  _inherits(WebchatChannel, _ApplicationChannel);
-  var _super = _createSuper(WebchatChannel);
-  function WebchatChannel(id, session, conversation) {
-    var _this;
-    _classCallCheck(this, WebchatChannel);
-    _this = _super.call(this);
-    _this.id = id;
-    _this.session = session;
-    _this.conversation = conversation;
+class WebchatChannel extends _application_channel.default {
+  constructor(id, session, conversation) {
+    super();
+    this.id = id;
+    this.session = session;
+    this.conversation = conversation;
     // Keep our own subscription intent instead of trusting the socket state.
     // The shared WebSocket can reconnect independently, but an explicit
     // unsubscribe means this channel should not silently join again.
-    _this.subscribed = false;
-    _this.awaitingReconnectConfirmation = false;
-    _this.reconnectCallbacks = new Set();
+    this.subscribed = false;
+    this.awaitingReconnectConfirmation = false;
+    this.reconnectCallbacks = new Set();
 
     // ActionCable confirms subscriptions at the socket level. This channel
     // listens for those confirmations so the controller can wait until Rails has
     // accepted this exact WebchatChannel subscription before fetching missed
     // messages from the REST catch-up endpoint.
-    _this.onSubscriptionConfirmed(identifier => _this.handleSubscriptionConfirmed(identifier));
-    _this.subscribe();
-    return _this;
+    this.onSubscriptionConfirmed(identifier => this.handleSubscriptionConfirmed(identifier));
+    this.subscribe();
   }
-  _createClass(WebchatChannel, [{
-    key: "subscribe",
-    value: function subscribe() {
-      this.subscribed = true;
-      const params = {
-        channel: 'WebchatChannel',
-        id: this.id,
-        session: this.session,
-        conversation: this.conversation
-      };
-      this.send({
-        command: 'subscribe',
-        identifier: params
-      });
-    }
-  }, {
-    key: "unsubscribe",
-    value: function unsubscribe() {
-      this.subscribed = false;
-      const params = {
-        channel: 'WebchatChannel',
-        id: this.id,
-        session: this.session,
-        conversation: this.conversation
-      };
-      this.send({
-        command: 'unsubscribe',
-        identifier: params
-      });
-    }
-  }, {
-    key: "resubscribe",
-    value: function resubscribe() {
-      if (this.subscribed === false) return;
+  subscribe() {
+    this.subscribed = true;
+    const params = {
+      channel: 'WebchatChannel',
+      id: this.id,
+      session: this.session,
+      conversation: this.conversation
+    };
+    this.send({
+      command: 'subscribe',
+      identifier: params
+    });
+  }
+  unsubscribe() {
+    this.subscribed = false;
+    const params = {
+      channel: 'WebchatChannel',
+      id: this.id,
+      session: this.session,
+      conversation: this.conversation
+    };
+    this.send({
+      command: 'unsubscribe',
+      identifier: params
+    });
+  }
+  resubscribe() {
+    if (this.subscribed === false) return;
 
-      // Reconnect recovery has two phases: send the subscription command first,
-      // then wait for ActionCable to confirm it. Catch-up work should run after
-      // that confirmation so broadcasts and REST backfill are pointed at the same
-      // live conversation subscription.
-      this.awaitingReconnectConfirmation = true;
-      this.subscribe();
-    }
-  }, {
-    key: "onReconnect",
-    value: function onReconnect(callback) {
-      this.reconnectCallbacks.add(callback);
-    }
-  }, {
-    key: "handleSubscriptionConfirmed",
-    value: function handleSubscriptionConfirmed(identifier) {
-      if (!this.awaitingReconnectConfirmation || !this.matchesIdentifier(identifier)) return;
+    // Reconnect recovery has two phases: send the subscription command first,
+    // then wait for ActionCable to confirm it. Catch-up work should run after
+    // that confirmation so broadcasts and REST backfill are pointed at the same
+    // live conversation subscription.
+    this.awaitingReconnectConfirmation = true;
+    this.subscribe();
+  }
+  onReconnect(callback) {
+    this.reconnectCallbacks.add(callback);
+  }
+  handleSubscriptionConfirmed(identifier) {
+    if (!this.awaitingReconnectConfirmation || !this.matchesIdentifier(identifier)) return;
 
-      // Only the first matching confirmation completes the reconnect cycle. This
-      // prevents unrelated subscription confirmations on the shared socket from
-      // triggering duplicate catch-up requests.
-      this.awaitingReconnectConfirmation = false;
-      this.reconnectCallbacks.forEach(callback => callback());
+    // Only the first matching confirmation completes the reconnect cycle. This
+    // prevents unrelated subscription confirmations on the shared socket from
+    // triggering duplicate catch-up requests.
+    this.awaitingReconnectConfirmation = false;
+    this.reconnectCallbacks.forEach(callback => callback());
+  }
+  matchesIdentifier(identifier) {
+    let params;
+    try {
+      params = typeof identifier === 'string' ? JSON.parse(identifier) : identifier;
+    } catch {
+      return false;
     }
-  }, {
-    key: "matchesIdentifier",
-    value: function matchesIdentifier(identifier) {
-      let params;
-      try {
-        params = typeof identifier === 'string' ? JSON.parse(identifier) : identifier;
-      } catch {
-        return false;
-      }
 
-      // ActionCable sends the same identifier payload we used when subscribing.
-      // Matching every routing key keeps a confirmation for another webchat,
-      // session, or conversation from being treated as this channel's reconnect.
-      return params.channel === 'WebchatChannel' && params.id === this.id && params.session === this.session && params.conversation === this.conversation;
-    }
-  }, {
-    key: "startTypingIndicator",
-    value: function startTypingIndicator() {
-      const params = {
-        channel: 'WebchatChannel',
-        id: this.id,
-        session: this.session,
-        conversation: this.conversation
-      };
-      this.send({
-        command: 'message',
-        identifier: params,
-        data: {
-          action: 'started_typing'
-        }
-      });
-    }
-  }, {
-    key: "stopTypingIndicator",
-    value: function stopTypingIndicator() {
-      const params = {
-        channel: 'WebchatChannel',
-        id: this.id,
-        session: this.session,
-        conversation: this.conversation
-      };
-      this.send({
-        command: 'typing:stop',
-        identifier: params,
-        data: {
-          action: 'stopped_typing'
-        }
-      });
-    }
-  }, {
-    key: "onMessage",
-    value: function onMessage(callback) {
-      _get(_getPrototypeOf(WebchatChannel.prototype), "onMessage", this).call(this, message => {
-        if (message.type !== 'message') return;
+    // ActionCable sends the same identifier payload we used when subscribing.
+    // Matching every routing key keeps a confirmation for another webchat,
+    // session, or conversation from being treated as this channel's reconnect.
+    return params.channel === 'WebchatChannel' && params.id === this.id && params.session === this.session && params.conversation === this.conversation;
+  }
+  startTypingIndicator() {
+    const params = {
+      channel: 'WebchatChannel',
+      id: this.id,
+      session: this.session,
+      conversation: this.conversation
+    };
+    this.send({
+      command: 'message',
+      identifier: params,
+      data: {
+        action: 'started_typing'
+      }
+    });
+  }
+  stopTypingIndicator() {
+    const params = {
+      channel: 'WebchatChannel',
+      id: this.id,
+      session: this.session,
+      conversation: this.conversation
+    };
+    this.send({
+      command: 'typing:stop',
+      identifier: params,
+      data: {
+        action: 'stopped_typing'
+      }
+    });
+  }
+  onMessage(callback) {
+    super.onMessage(message => {
+      if (message.type !== 'message') return;
+      callback(message);
+    });
+  }
+  onReaction(callback) {
+    super.onMessage(message => {
+      if (message.type === 'reaction.create' || message.type === 'reaction.destroy') {
         callback(message);
-      });
-    }
-  }, {
-    key: "onReaction",
-    value: function onReaction(callback) {
-      _get(_getPrototypeOf(WebchatChannel.prototype), "onMessage", this).call(this, message => {
-        if (message.type === 'reaction.create' || message.type === 'reaction.destroy') {
-          callback(message);
-        }
-      });
-    }
-  }, {
-    key: "onTypingStart",
-    value: function onTypingStart(callback) {
-      _get(_getPrototypeOf(WebchatChannel.prototype), "onMessage", this).call(this, message => {
-        if (message.type === 'started_typing') {
-          callback(message);
-        }
-      });
-    }
-  }, {
-    key: "updateSubscriptionWith",
-    value: function updateSubscriptionWith(conversation) {
-      this.unsubscribe();
-      setTimeout(() => {
-        this.conversation = conversation;
-        this.subscribe();
-      }, 1000);
-    }
-  }]);
-  return WebchatChannel;
-}(_application_channel.default);
+      }
+    });
+  }
+  onTypingStart(callback) {
+    super.onMessage(message => {
+      if (message.type === 'started_typing') {
+        callback(message);
+      }
+    });
+  }
+  updateSubscriptionWith(conversation) {
+    this.unsubscribe();
+    setTimeout(() => {
+      this.conversation = conversation;
+      this.subscribe();
+    }, 1000);
+  }
+}
 var _default = WebchatChannel;
 exports.default = _default;

package/lib/channels/webchat_channel.js

@@ -1,186 +1,141 @@
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 import ApplicationChannel from './application_channel';
-var WebchatChannel = /*#__PURE__*/function (_ApplicationChannel) {
-  _inherits(WebchatChannel, _ApplicationChannel);
-  var _super = _createSuper(WebchatChannel);
-  function WebchatChannel(id, session, conversation) {
-    var _this;
-    _classCallCheck(this, WebchatChannel);
-    _this = _super.call(this);
-    _this.id = id;
-    _this.session = session;
-    _this.conversation = conversation;
+class WebchatChannel extends ApplicationChannel {
+  constructor(id, session, conversation) {
+    super();
+    this.id = id;
+    this.session = session;
+    this.conversation = conversation;
     // Keep our own subscription intent instead of trusting the socket state.
     // The shared WebSocket can reconnect independently, but an explicit
     // unsubscribe means this channel should not silently join again.
-    _this.subscribed = false;
-    _this.awaitingReconnectConfirmation = false;
-    _this.reconnectCallbacks = new Set();
+    this.subscribed = false;
+    this.awaitingReconnectConfirmation = false;
+    this.reconnectCallbacks = new Set();
 
     // ActionCable confirms subscriptions at the socket level. This channel
     // listens for those confirmations so the controller can wait until Rails has
     // accepted this exact WebchatChannel subscription before fetching missed
     // messages from the REST catch-up endpoint.
-    _this.onSubscriptionConfirmed(identifier => _this.handleSubscriptionConfirmed(identifier));
-    _this.subscribe();
-    return _this;
+    this.onSubscriptionConfirmed(identifier => this.handleSubscriptionConfirmed(identifier));
+    this.subscribe();
   }
-  _createClass(WebchatChannel, [{
-    key: "subscribe",
-    value: function subscribe() {
-      this.subscribed = true;
-      var params = {
-        channel: 'WebchatChannel',
-        id: this.id,
-        session: this.session,
-        conversation: this.conversation
-      };
-      this.send({
-        command: 'subscribe',
-        identifier: params
-      });
-    }
-  }, {
-    key: "unsubscribe",
-    value: function unsubscribe() {
-      this.subscribed = false;
-      var params = {
-        channel: 'WebchatChannel',
-        id: this.id,
-        session: this.session,
-        conversation: this.conversation
-      };
-      this.send({
-        command: 'unsubscribe',
-        identifier: params
-      });
-    }
-  }, {
-    key: "resubscribe",
-    value: function resubscribe() {
-      if (this.subscribed === false) return;
+  subscribe() {
+    this.subscribed = true;
+    const params = {
+      channel: 'WebchatChannel',
+      id: this.id,
+      session: this.session,
+      conversation: this.conversation
+    };
+    this.send({
+      command: 'subscribe',
+      identifier: params
+    });
+  }
+  unsubscribe() {
+    this.subscribed = false;
+    const params = {
+      channel: 'WebchatChannel',
+      id: this.id,
+      session: this.session,
+      conversation: this.conversation
+    };
+    this.send({
+      command: 'unsubscribe',
+      identifier: params
+    });
+  }
+  resubscribe() {
+    if (this.subscribed === false) return;
 
-      // Reconnect recovery has two phases: send the subscription command first,
-      // then wait for ActionCable to confirm it. Catch-up work should run after
-      // that confirmation so broadcasts and REST backfill are pointed at the same
-      // live conversation subscription.
-      this.awaitingReconnectConfirmation = true;
-      this.subscribe();
-    }
-  }, {
-    key: "onReconnect",
-    value: function onReconnect(callback) {
-      this.reconnectCallbacks.add(callback);
-    }
-  }, {
-    key: "handleSubscriptionConfirmed",
-    value: function handleSubscriptionConfirmed(identifier) {
-      if (!this.awaitingReconnectConfirmation || !this.matchesIdentifier(identifier)) return;
+    // Reconnect recovery has two phases: send the subscription command first,
+    // then wait for ActionCable to confirm it. Catch-up work should run after
+    // that confirmation so broadcasts and REST backfill are pointed at the same
+    // live conversation subscription.
+    this.awaitingReconnectConfirmation = true;
+    this.subscribe();
+  }
+  onReconnect(callback) {
+    this.reconnectCallbacks.add(callback);
+  }
+  handleSubscriptionConfirmed(identifier) {
+    if (!this.awaitingReconnectConfirmation || !this.matchesIdentifier(identifier)) return;
 
-      // Only the first matching confirmation completes the reconnect cycle. This
-      // prevents unrelated subscription confirmations on the shared socket from
-      // triggering duplicate catch-up requests.
-      this.awaitingReconnectConfirmation = false;
-      this.reconnectCallbacks.forEach(callback => callback());
+    // Only the first matching confirmation completes the reconnect cycle. This
+    // prevents unrelated subscription confirmations on the shared socket from
+    // triggering duplicate catch-up requests.
+    this.awaitingReconnectConfirmation = false;
+    this.reconnectCallbacks.forEach(callback => callback());
+  }
+  matchesIdentifier(identifier) {
+    let params;
+    try {
+      params = typeof identifier === 'string' ? JSON.parse(identifier) : identifier;
+    } catch {
+      return false;
     }
-  }, {
-    key: "matchesIdentifier",
-    value: function matchesIdentifier(identifier) {
-      var params;
-      try {
-        params = typeof identifier === 'string' ? JSON.parse(identifier) : identifier;
-      } catch (_unused) {
-        return false;
-      }
 
-      // ActionCable sends the same identifier payload we used when subscribing.
-      // Matching every routing key keeps a confirmation for another webchat,
-      // session, or conversation from being treated as this channel's reconnect.
-      return params.channel === 'WebchatChannel' && params.id === this.id && params.session === this.session && params.conversation === this.conversation;
-    }
-  }, {
-    key: "startTypingIndicator",
-    value: function startTypingIndicator() {
-      var params = {
-        channel: 'WebchatChannel',
-        id: this.id,
-        session: this.session,
-        conversation: this.conversation
-      };
-      this.send({
-        command: 'message',
-        identifier: params,
-        data: {
-          action: 'started_typing'
-        }
-      });
-    }
-  }, {
-    key: "stopTypingIndicator",
-    value: function stopTypingIndicator() {
-      var params = {
-        channel: 'WebchatChannel',
-        id: this.id,
-        session: this.session,
-        conversation: this.conversation
-      };
-      this.send({
-        command: 'typing:stop',
-        identifier: params,
-        data: {
-          action: 'stopped_typing'
-        }
-      });
-    }
-  }, {
-    key: "onMessage",
-    value: function onMessage(callback) {
-      _get(_getPrototypeOf(WebchatChannel.prototype), "onMessage", this).call(this, message => {
-        if (message.type !== 'message') return;
+    // ActionCable sends the same identifier payload we used when subscribing.
+    // Matching every routing key keeps a confirmation for another webchat,
+    // session, or conversation from being treated as this channel's reconnect.
+    return params.channel === 'WebchatChannel' && params.id === this.id && params.session === this.session && params.conversation === this.conversation;
+  }
+  startTypingIndicator() {
+    const params = {
+      channel: 'WebchatChannel',
+      id: this.id,
+      session: this.session,
+      conversation: this.conversation
+    };
+    this.send({
+      command: 'message',
+      identifier: params,
+      data: {
+        action: 'started_typing'
+      }
+    });
+  }
+  stopTypingIndicator() {
+    const params = {
+      channel: 'WebchatChannel',
+      id: this.id,
+      session: this.session,
+      conversation: this.conversation
+    };
+    this.send({
+      command: 'typing:stop',
+      identifier: params,
+      data: {
+        action: 'stopped_typing'
+      }
+    });
+  }
+  onMessage(callback) {
+    super.onMessage(message => {
+      if (message.type !== 'message') return;
+      callback(message);
+    });
+  }
+  onReaction(callback) {
+    super.onMessage(message => {
+      if (message.type === 'reaction.create' || message.type === 'reaction.destroy') {
         callback(message);
-      });
-    }
-  }, {
-    key: "onReaction",
-    value: function onReaction(callback) {
-      _get(_getPrototypeOf(WebchatChannel.prototype), "onMessage", this).call(this, message => {
-        if (message.type === 'reaction.create' || message.type === 'reaction.destroy') {
-          callback(message);
-        }
-      });
-    }
-  }, {
-    key: "onTypingStart",
-    value: function onTypingStart(callback) {
-      _get(_getPrototypeOf(WebchatChannel.prototype), "onMessage", this).call(this, message => {
-        if (message.type === 'started_typing') {
-          callback(message);
-        }
-      });
-    }
-  }, {
-    key: "updateSubscriptionWith",
-    value: function updateSubscriptionWith(conversation) {
-      this.unsubscribe();
-      setTimeout(() => {
-        this.conversation = conversation;
-        this.subscribe();
-      }, 1000);
-    }
-  }]);
-  return WebchatChannel;
-}(ApplicationChannel);
+      }
+    });
+  }
+  onTypingStart(callback) {
+    super.onMessage(message => {
+      if (message.type === 'started_typing') {
+        callback(message);
+      }
+    });
+  }
+  updateSubscriptionWith(conversation) {
+    this.unsubscribe();
+    setTimeout(() => {
+      this.conversation = conversation;
+      this.subscribe();
+    }, 1000);
+  }
+}
 export default WebchatChannel;