laravel-echo-api-gateway 0.5.1 → 0.5.3

package/dist/laravel-echo-api-gateway.common.js

@@ -2,6 +2,12 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var axios = require('axios');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
+
 function _classCallCheck(instance, Constructor) {
   if (!(instance instanceof Constructor)) {
     throw new TypeError("Cannot call a class as a function");
@@ -129,58 +135,133 @@ function _createSuper(Derived) {
   };
 }
 
-class Connector {
-    /**
-     * Create a new class instance.
-     */
-    constructor(options) {
-        /**
-         * Default connector options.
-         */
-        this._defaultOptions = {
-            auth: {
-                headers: {},
-            },
-            authEndpoint: '/broadcasting/auth',
-            broadcaster: 'pusher',
-            csrfToken: null,
-            host: null,
-            key: null,
-            namespace: 'App.Events',
-        };
-        this.setOptions(options);
-        this.connect();
-    }
-    /**
-     * Merge the custom options with the defaults.
-     */
-    setOptions(options) {
-        this.options = Object.assign(this._defaultOptions, options);
-        if (this.csrfToken()) {
-            this.options.auth.headers['X-CSRF-TOKEN'] = this.csrfToken();
-        }
-        return options;
-    }
-    /**
-     * Extract the CSRF token from the page.
-     */
-    csrfToken() {
-        let selector;
-        if (typeof window !== 'undefined' && window['Laravel'] && window['Laravel'].csrfToken) {
-            return window['Laravel'].csrfToken;
-        }
-        else if (this.options.csrfToken) {
-            return this.options.csrfToken;
-        }
-        else if (typeof document !== 'undefined' &&
-            typeof document.querySelector === 'function' &&
-            (selector = document.querySelector('meta[name="csrf-token"]'))) {
-            return selector.getAttribute('content');
-        }
-        return null;
-    }
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+  return arr2;
+}
+
+function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+
+  if (!it) {
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (it) o = it;
+      var i = 0;
+
+      var F = function () {};
+
+      return {
+        s: F,
+        n: function () {
+          if (i >= o.length) return {
+            done: true
+          };
+          return {
+            done: false,
+            value: o[i++]
+          };
+        },
+        e: function (e) {
+          throw e;
+        },
+        f: F
+      };
+    }
+
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+
+  var normalCompletion = true,
+      didErr = false,
+      err;
+  return {
+    s: function () {
+      it = it.call(o);
+    },
+    n: function () {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    },
+    e: function (e) {
+      didErr = true;
+      err = e;
+    },
+    f: function () {
+      try {
+        if (!normalCompletion && it.return != null) it.return();
+      } finally {
+        if (didErr) throw err;
+      }
+    }
+  };
+}
+
+class Connector {
+    /**
+     * Create a new class instance.
+     */
+    constructor(options) {
+        /**
+         * Default connector options.
+         */
+        this._defaultOptions = {
+            auth: {
+                headers: {},
+            },
+            authEndpoint: '/broadcasting/auth',
+            broadcaster: 'pusher',
+            csrfToken: null,
+            host: null,
+            key: null,
+            namespace: 'App.Events',
+        };
+        this.setOptions(options);
+        this.connect();
+    }
+    /**
+     * Merge the custom options with the defaults.
+     */
+    setOptions(options) {
+        this.options = Object.assign(this._defaultOptions, options);
+        if (this.csrfToken()) {
+            this.options.auth.headers['X-CSRF-TOKEN'] = this.csrfToken();
+        }
+        return options;
+    }
+    /**
+     * Extract the CSRF token from the page.
+     */
+    csrfToken() {
+        let selector;
+        if (typeof window !== 'undefined' && window['Laravel'] && window['Laravel'].csrfToken) {
+            return window['Laravel'].csrfToken;
+        }
+        else if (this.options.csrfToken) {
+            return this.options.csrfToken;
+        }
+        else if (typeof document !== 'undefined' &&
+            typeof document.querySelector === 'function' &&
+            (selector = document.querySelector('meta[name="csrf-token"]'))) {
+            return selector.getAttribute('content');
+        }
+        return null;
+    }
 }
 
+var LOG_PREFIX = '[LE-AG-Websocket]';
 var Websocket = /*#__PURE__*/function () {
   function Websocket(options) {
     _classCallCheck(this, Websocket);
@@ -190,6 +271,7 @@ var Websocket = /*#__PURE__*/function () {
     this.internalListeners = {};
     this.channelBacklog = [];
     this.closing = false;
+    this.hasConnected = false;
     this.options = options;
     this.connect(this.options.host);
     return this;
@@ -200,10 +282,28 @@ var Websocket = /*#__PURE__*/function () {
     value: function connect(host) {
       var _this = this;
 
-      this.options.debug && console.log('Connecting');
+      if (!host) {
+        this.options.debug && console.error(LOG_PREFIX + "Cannont connect without host !");
+        return;
+      }
+
+      this.options.debug && console.log(LOG_PREFIX + "Trying to connect to ".concat(host, "..."));
       this.websocket = new WebSocket(host);
 
+      this.websocket.onerror = function () {
+        if (!_this.hasConnected) {
+          setTimeout(function () {
+            _this.socketId = undefined;
+
+            _this.connect(host);
+          }, 3000);
+        }
+      };
+
       this.websocket.onopen = function () {
+        _this.options.debug && console.log(LOG_PREFIX + ' Connected !');
+        _this.hasConnected = true;
+
         _this.send({
           event: 'whoami'
         });
@@ -214,65 +314,83 @@ var Websocket = /*#__PURE__*/function () {
           _this.send(message);
 
           _this.buffer.splice(0, 1);
-        }
-      };
+        } // Register events only once connected, or they won't be registered if connection failed/lost
 
-      this.websocket.onmessage = function (messageEvent) {
-        var message = _this.parseMessage(messageEvent.data);
 
-        if (!message) {
-          return;
-        }
+        _this.websocket.onmessage = function (messageEvent) {
+          var message = _this.parseMessage(messageEvent.data);
 
-        if (message.channel) {
-          _this.options.debug && console.log("Received event ".concat(message.event, " on channel ").concat(message.channel));
+          _this.options.debug && console.log(LOG_PREFIX + ' onmessage', messageEvent.data);
 
-          if (_this.listeners[message.channel] && _this.listeners[message.channel][message.event]) {
-            _this.listeners[message.channel][message.event](message.data);
+          if (!message) {
+            return;
           }
 
-          return;
-        }
+          if (message.channel) {
+            _this.options.debug && console.log("".concat(LOG_PREFIX, " Received event ").concat(message.event, " on channel ").concat(message.channel));
 
-        if (_this.internalListeners[message.event]) {
-          _this.internalListeners[message.event](message.data);
-        }
+            if (_this.listeners[message.channel] && _this.listeners[message.channel][message.event]) {
+              _this.listeners[message.channel][message.event](message.data);
+            }
+
+            return;
+          }
+
+          if (_this.internalListeners[message.event]) {
+            _this.internalListeners[message.event](message.data);
+          }
+        }; // send ping every 60 seconds to keep connection alive
+
+
+        _this.pingInterval = setInterval(function () {
+          if (_this.websocket.readyState === _this.websocket.OPEN) {
+            _this.options.debug && console.log(LOG_PREFIX + ' Sending ping');
+
+            _this.send({
+              event: 'ping'
+            });
+          }
+        }, 60 * 1000);
       };
 
       this.websocket.onclose = function () {
-        if (_this.socketId && !_this.closing || !_this.socketId) {
-          _this.options.debug && console.info('Connection lost, reconnecting...');
-          setTimeout(function () {
-            _this.socketId = undefined;
+        _this.options.debug && console.info('Connection closed.');
 
-            _this.connect(host);
-          }, 1000);
+        if (_this.closing) {
+          return;
         }
+
+        _this.hasConnected = false;
+        _this.options.debug && console.info('Connection lost, reconnecting...');
+        setTimeout(function () {
+          _this.socketId = undefined;
+
+          _this.connect(host);
+        }, 1000);
       };
 
       this.on('whoami', function (_ref) {
         var socketId = _ref.socket_id;
         _this.socketId = socketId;
-        _this.options.debug && console.log("just set socketId to ".concat(socketId));
+        _this.options.debug && console.log("".concat(LOG_PREFIX, " Just set socketId to ").concat(socketId)); // Handle the backlog and don't empty it, we'll need it if we lose connection
 
-        while (_this.channelBacklog.length) {
-          var channel = _this.channelBacklog[0];
+        var channel;
 
-          _this.actuallySubscribe(channel);
-
-          _this.channelBacklog.splice(0, 1);
-        }
-      }); // send ping every 60 seconds to keep connection alive
+        var _iterator = _createForOfIteratorHelper(_this.channelBacklog),
+            _step;
 
-      this.pingInterval = setInterval(function () {
-        if (_this.websocket.readyState === _this.websocket.OPEN) {
-          _this.options.debug && console.log('Sending ping');
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            channel = _step.value;
 
-          _this.send({
-            event: 'ping'
-          });
+            _this.actuallySubscribe(channel);
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
         }
-      }, 60 * 1000);
+      });
     }
   }, {
     key: "parseMessage",
@@ -319,6 +437,7 @@ var Websocket = /*#__PURE__*/function () {
       if (this.getSocketId()) {
         this.actuallySubscribe(channel);
       } else {
+        this.options.debug && console.log("".concat(LOG_PREFIX, " subscribe - push channel backlog for channel ").concat(channel.name));
         this.channelBacklog.push(channel);
       }
     }
@@ -328,19 +447,19 @@ var Websocket = /*#__PURE__*/function () {
       var _this2 = this;
 
       if (channel.name.startsWith('private-') || channel.name.startsWith('presence-')) {
-        this.options.debug && console.log("Sending auth request for channel ".concat(channel.name));
+        this.options.debug && console.log("".concat(LOG_PREFIX, " Sending auth request for channel ").concat(channel.name));
 
         if (this.options.bearerToken) {
           this.options.auth.headers['Authorization'] = 'Bearer ' + this.options.bearerToken;
         }
 
-        axios.post(this.options.authEndpoint, {
+        axios__default['default'].post(this.options.authEndpoint, {
           socket_id: this.getSocketId(),
           channel_name: channel.name
         }, {
           headers: this.options.auth.headers || {}
         }).then(function (response) {
-          _this2.options.debug && console.log("Subscribing to channels ".concat(channel.name));
+          _this2.options.debug && console.log("".concat(LOG_PREFIX, " Subscribing to private channel ").concat(channel.name));
 
           _this2.send({
             event: 'subscribe',
@@ -349,11 +468,11 @@ var Websocket = /*#__PURE__*/function () {
             }, response.data)
           });
         })["catch"](function (error) {
-          _this2.options.debug && console.log("Auth request for channel ".concat(channel.name, " failed"));
+          _this2.options.debug && console.log("".concat(LOG_PREFIX, " Auth request for channel ").concat(channel.name, " failed"));
           _this2.options.debug && console.error(error);
         });
       } else {
-        this.options.debug && console.log("Subscribing to channels ".concat(channel.name));
+        this.options.debug && console.log("".concat(LOG_PREFIX, " Subscribing to channel ").concat(channel.name));
         this.send({
           event: 'subscribe',
           data: {
@@ -365,6 +484,7 @@ var Websocket = /*#__PURE__*/function () {
   }, {
     key: "unsubscribe",
     value: function unsubscribe(channel) {
+      this.options.debug && console.log("".concat(LOG_PREFIX, " unsubscribe for channel ").concat(channel.name));
       this.send({
         event: 'unsubscribe',
         data: {
@@ -380,11 +500,14 @@ var Websocket = /*#__PURE__*/function () {
     key: "on",
     value: function on(event) {
       var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      this.options.debug && console.log("".concat(LOG_PREFIX, " on event ").concat(event, " ..."));
       this.internalListeners[event] = callback;
     }
   }, {
     key: "bind",
     value: function bind(channel, event, callback) {
+      this.options.debug && console.log("".concat(LOG_PREFIX, " bind event ").concat(event, " for channel ").concat(channel.name, " ..."));
+
       if (!this.listeners[channel.name]) {
         this.listeners[channel.name] = {};
       }
@@ -395,6 +518,7 @@ var Websocket = /*#__PURE__*/function () {
     key: "unbindEvent",
     value: function unbindEvent(channel, event) {
       var callback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+      this.options.debug && console.log("".concat(LOG_PREFIX, " unbind event ").concat(event, " for channel ").concat(channel.name, " ..."));
 
       if (this.internalListeners[event] && (callback === null || this.internalListeners[event] === callback)) {
         delete this.internalListeners[event];
@@ -405,62 +529,63 @@ var Websocket = /*#__PURE__*/function () {
   return Websocket;
 }();
 
-/**
- * Event name formatter
- */
-class EventFormatter {
-    /**
-     * Create a new class instance.
-     */
-    constructor(namespace) {
-        this.setNamespace(namespace);
-    }
-    /**
-     * Format the given event name.
-     */
-    format(event) {
-        if (event.charAt(0) === '.' || event.charAt(0) === '\\') {
-            return event.substr(1);
-        }
-        else if (this.namespace) {
-            event = this.namespace + '.' + event;
-        }
-        return event.replace(/\./g, '\\');
-    }
-    /**
-     * Set the event namespace.
-     */
-    setNamespace(value) {
-        this.namespace = value;
-    }
+/**
+ * Event name formatter
+ */
+class EventFormatter {
+    /**
+     * Create a new class instance.
+     */
+    constructor(namespace) {
+        this.setNamespace(namespace);
+    }
+    /**
+     * Format the given event name.
+     */
+    format(event) {
+        if (event.charAt(0) === '.' || event.charAt(0) === '\\') {
+            return event.substr(1);
+        }
+        else if (this.namespace) {
+            event = this.namespace + '.' + event;
+        }
+        return event.replace(/\./g, '\\');
+    }
+    /**
+     * Set the event namespace.
+     */
+    setNamespace(value) {
+        this.namespace = value;
+    }
 }
 
-/**
- * This class represents a basic channel.
- */
-class Channel {
-    /**
-     * Listen for a whisper event on the channel instance.
-     */
-    listenForWhisper(event, callback) {
-        return this.listen('.client-' + event, callback);
-    }
-    /**
-     * Listen for an event on the channel instance.
-     */
-    notification(callback) {
-        return this.listen('.Illuminate\\Notifications\\Events\\BroadcastNotificationCreated', callback);
-    }
-    /**
-     * Stop listening for a whisper event on the channel instance.
-     */
-    stopListeningForWhisper(event, callback) {
-        return this.stopListening('.client-' + event, callback);
-    }
+/**
+ * This class represents a basic channel.
+ */
+class Channel {
+    /**
+     * Listen for a whisper event on the channel instance.
+     */
+    listenForWhisper(event, callback) {
+        return this.listen('.client-' + event, callback);
+    }
+    /**
+     * Listen for an event on the channel instance.
+     */
+    notification(callback) {
+        return this.listen('.Illuminate\\Notifications\\Events\\BroadcastNotificationCreated', callback);
+    }
+    /**
+     * Stop listening for a whisper event on the channel instance.
+     */
+    stopListeningForWhisper(event, callback) {
+        return this.stopListening('.client-' + event, callback);
+    }
 }
 
-/**
- * This class represents a Pusher channel.
+var LOG_PREFIX$1 = '[LE-AG-Channel]';
+/**
+ * This class represents a Pusher channel.
  */
 
 var Channel$1 = /*#__PURE__*/function (_BaseChannel) {
@@ -468,8 +593,8 @@ var Channel$1 = /*#__PURE__*/function (_BaseChannel) {
 
   var _super = _createSuper(Channel);
 
-  /**
-   * Create a new class instance.
+  /**
+   * Create a new class instance.
    */
   function Channel(socket, name, options) {
     var _this;
@@ -486,76 +611,83 @@ var Channel$1 = /*#__PURE__*/function (_BaseChannel) {
 
     return _this;
   }
-  /**
-   * Subscribe to a Pusher channel.
+  /**
+   * Subscribe to a Pusher channel.
    */
 
 
   _createClass(Channel, [{
     key: "subscribe",
     value: function subscribe() {
+      this.options["debug"] && console.log("".concat(LOG_PREFIX$1, " subscribe for channel ").concat(this.name, " ..."));
       this.socket.subscribe(this);
     }
-    /**
-     * Unsubscribe from a Pusher channel.
+    /**
+     * Unsubscribe from a Pusher channel.
      */
 
   }, {
     key: "unsubscribe",
     value: function unsubscribe() {
+      this.options["debug"] && console.log("".concat(LOG_PREFIX$1, " unsubscribe for channel ").concat(this.name, " ..."));
       this.socket.unsubscribe(this);
     }
-    /**
-     * Listen for an event on the channel instance.
+    /**
+     * Listen for an event on the channel instance.
      */
 
   }, {
     key: "listen",
     value: function listen(event, callback) {
+      this.options["debug"] && console.log("".concat(LOG_PREFIX$1, " listen to ").concat(event, " for channel ").concat(this.name, " ..."));
       this.on(this.eventFormatter.format(event), callback);
       return this;
     }
-    /**
-     * Stop listening for an event on the channel instance.
+    /**
+     * Stop listening for an event on the channel instance.
      */
 
   }, {
     key: "stopListening",
     value: function stopListening(event, callback) {
+      this.options["debug"] && console.log("".concat(LOG_PREFIX$1, " stop listening to ").concat(event, " for channel ").concat(this.name, " ..."));
       this.socket.unbindEvent(this, event, callback);
       return this;
     }
-    /**
-     * Register a callback to be called anytime a subscription succeeds.
+    /**
+     * Register a callback to be called anytime a subscription succeeds.
      */
 
   }, {
     key: "subscribed",
     value: function subscribed(callback) {
+      this.options["debug"] && console.log("".concat(LOG_PREFIX$1, " subscribed for channel ").concat(this.name, " ..."));
       this.on('subscription_succeeded', function () {
         callback();
       });
       return this;
     }
-    /**
-     * Register a callback to be called anytime a subscription error occurs.
+    /**
+     * Register a callback to be called anytime a subscription error occurs.
      */
 
   }, {
     key: "error",
     value: function error(callback) {
+      this.options["debug"] && console.log("".concat(LOG_PREFIX$1, " error for channel ").concat(this.name, " ..."));
       this.on('error', function (status) {
         callback(status);
       });
       return this;
     }
-    /**
-     * Bind a channel to an event.
+    /**
+     * Bind a channel to an event.
      */
 
   }, {
     key: "on",
     value: function on(event, callback) {
+      this.options["debug"] && console.log("".concat(LOG_PREFIX$1, " on ").concat(event, " for channel ").concat(this.name, " ..."));
       this.socket.bind(this, event, callback);
       return this;
     }
@@ -577,8 +709,8 @@ var Channel$1 = /*#__PURE__*/function (_BaseChannel) {
       // TODO: implement
       return this;
     }
-    /**
-     * Listen for someone joining the channel.
+    /**
+     * Listen for someone joining the channel.
      */
 
   }, {
@@ -587,8 +719,8 @@ var Channel$1 = /*#__PURE__*/function (_BaseChannel) {
       // TODO: implement
       return this;
     }
-    /**
-     * Listen for someone leaving the channel.
+    /**
+     * Listen for someone leaving the channel.
      */
 
   }, {
@@ -605,32 +737,37 @@ var Channel$1 = /*#__PURE__*/function (_BaseChannel) {
 var broadcaster = function broadcaster(options) {
   return new Connector$1(options);
 };
+var LOG_PREFIX$2 = '[LE-AG-Connector]';
 var Connector$1 = /*#__PURE__*/function (_BaseConnector) {
   _inherits(Connector, _BaseConnector);
 
   var _super = _createSuper(Connector);
 
-  function Connector() {
+  /**
+   * Create a new class instance.
+   */
+  function Connector(options) {
     var _this;
 
     _classCallCheck(this, Connector);
 
-    _this = _super.apply(this, arguments);
-    /**
-     * All of the subscribed channel names.
+    _this = _super.call(this, options);
+    /**
+     * All of the subscribed channel names.
      */
 
     _this.channels = {};
     return _this;
   }
-  /**
-   * Create a fresh Socket.io connection.
+  /**
+   * Create a fresh Socket.io connection.
    */
 
 
   _createClass(Connector, [{
     key: "connect",
     value: function connect() {
+      this.options.debug && console.log(LOG_PREFIX$2 + 'Connect ...');
       this.socket = new Websocket(this.options);
       return; //
       // this.socket.on('reconnect', () => {
@@ -641,8 +778,8 @@ var Connector$1 = /*#__PURE__*/function (_BaseConnector) {
       //
       // return this.socket;
     }
-    /**
-     * Get a channel instance by name.
+    /**
+     * Get a channel instance by name.
      */
 
   }, {
@@ -654,8 +791,8 @@ var Connector$1 = /*#__PURE__*/function (_BaseConnector) {
 
       return this.channels[name];
     }
-    /**
-     * Get a private channel instance by name.
+    /**
+     * Get a private channel instance by name.
      */
 
   }, {
@@ -667,8 +804,8 @@ var Connector$1 = /*#__PURE__*/function (_BaseConnector) {
 
       return this.channels['private-' + name];
     }
-    /**
-     * Get a presence channel instance by name.
+    /**
+     * Get a presence channel instance by name.
      */
 
   }, {
@@ -680,8 +817,8 @@ var Connector$1 = /*#__PURE__*/function (_BaseConnector) {
 
       return this.channels['presence-' + name];
     }
-    /**
-     * Leave the given channel, as well as its private and presence variants.
+    /**
+     * Leave the given channel, as well as its private and presence variants.
      */
 
   }, {
@@ -694,8 +831,8 @@ var Connector$1 = /*#__PURE__*/function (_BaseConnector) {
         _this2.leaveChannel(name);
       });
     }
-    /**
-     * Leave the given channel.
+    /**
+     * Leave the given channel.
      */
 
   }, {
@@ -706,8 +843,8 @@ var Connector$1 = /*#__PURE__*/function (_BaseConnector) {
         delete this.channels[name];
       }
     }
-    /**
-     * Get the socket ID for the connection.
+    /**
+     * Get the socket ID for the connection.
      */
 
   }, {
@@ -715,13 +852,14 @@ var Connector$1 = /*#__PURE__*/function (_BaseConnector) {
     value: function socketId() {
       return this.socket.getSocketId();
     }
-    /**
-     * Disconnect socket connection.
+    /**
+     * Disconnect socket connection.
      */
 
   }, {
     key: "disconnect",
     value: function disconnect() {
+      this.options.debug && console.log(LOG_PREFIX$2 + 'Disconnect ...');
       this.socket.close();
     }
   }]);