laravel-echo-api-gateway 0.5.1 → 0.5.2

package/dist/js-src/Websocket.d.ts

@@ -20,6 +20,7 @@ export declare class Websocket {
     private channelBacklog;
     private socketId;
     private closing;
+    private hasConnected;
     private pingInterval;
     private connect;
     constructor(options: Options);

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

@@ -129,6 +129,80 @@ function _createSuper(Derived) {
   };
 }
 
+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.
@@ -190,6 +264,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 +275,23 @@ var Websocket = /*#__PURE__*/function () {
     value: function connect(host) {
       var _this = this;
 
-      this.options.debug && console.log('Connecting');
+      this.options.debug && console.log('Trying to connect...');
       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('Connected !');
+        _this.hasConnected = true;
+
         _this.send({
           event: 'whoami'
         });
@@ -214,65 +302,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('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("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('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));
-
-        while (_this.channelBacklog.length) {
-          var channel = _this.channelBacklog[0];
+        _this.options.debug && console.log("just set socketId to ".concat(socketId)); // Handle the backlog and don't empty it, we'll need it if we lose connection
 
-          _this.actuallySubscribe(channel);
+        var 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",

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

@@ -128,6 +128,80 @@ var LaravelEchoApiGateway = (function (exports) {
     };
   }
 
+  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.
@@ -189,6 +263,7 @@ var LaravelEchoApiGateway = (function (exports) {
       this.internalListeners = {};
       this.channelBacklog = [];
       this.closing = false;
+      this.hasConnected = false;
       this.options = options;
       this.connect(this.options.host);
       return this;
@@ -199,10 +274,23 @@ var LaravelEchoApiGateway = (function (exports) {
       value: function connect(host) {
         var _this = this;
 
-        this.options.debug && console.log('Connecting');
+        this.options.debug && console.log('Trying to connect...');
         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('Connected !');
+          _this.hasConnected = true;
+
           _this.send({
             event: 'whoami'
           });
@@ -213,65 +301,83 @@ var LaravelEchoApiGateway = (function (exports) {
             _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('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("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('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));
-
-          while (_this.channelBacklog.length) {
-            var channel = _this.channelBacklog[0];
+          _this.options.debug && console.log("just set socketId to ".concat(socketId)); // Handle the backlog and don't empty it, we'll need it if we lose connection
 
-            _this.actuallySubscribe(channel);
+          var 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",

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

@@ -125,6 +125,80 @@ function _createSuper(Derived) {
   };
 }
 
+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.
@@ -186,6 +260,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;
@@ -196,10 +271,23 @@ var Websocket = /*#__PURE__*/function () {
     value: function connect(host) {
       var _this = this;
 
-      this.options.debug && console.log('Connecting');
+      this.options.debug && console.log('Trying to connect...');
       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('Connected !');
+        _this.hasConnected = true;
+
         _this.send({
           event: 'whoami'
         });
@@ -210,65 +298,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('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("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('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));
-
-        while (_this.channelBacklog.length) {
-          var channel = _this.channelBacklog[0];
+        _this.options.debug && console.log("just set socketId to ".concat(socketId)); // Handle the backlog and don't empty it, we'll need it if we lose connection
 
-          _this.actuallySubscribe(channel);
+        var 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",

package/js-src/Websocket.ts

@@ -21,15 +21,27 @@ export class Websocket {
     private socketId: string;
 
     private closing = false;
+    private hasConnected = false;
 
     private pingInterval: NodeJS.Timeout;
 
     private connect(host: string): void {
-        this.options.debug && console.log('Connecting');
+        this.options.debug && console.log('Trying to connect...');
 
         this.websocket = new WebSocket(host)
 
+        this.websocket.onerror = () => {
+            if (!this.hasConnected) {
+                setTimeout(() => {
+                    this.socketId = undefined
+                    this.connect(host)
+                }, 3000);
+            }
+        }
+
         this.websocket.onopen = () => {
+            this.options.debug && console.log('Connected !');
+            this.hasConnected = true;
             this.send({
                 event: 'whoami',
             })
@@ -41,40 +53,56 @@ export class Websocket {
 
                 this.buffer.splice(0, 1)
             }
-        }
 
-        this.websocket.onmessage = (messageEvent: MessageEvent) => {
-            const message = this.parseMessage(messageEvent.data)
+            // Register events only once connected, or they won't be registered if connection failed/lost
 
-            if (!message) {
-                return
-            }
+            this.websocket.onmessage = (messageEvent: MessageEvent) => {
+                const message = this.parseMessage(messageEvent.data)
+                this.options.debug && console.log('onmessage', messageEvent.data)
+
+                if (!message) {
+                    return
+                }
+
+                if (message.channel) {
+                    this.options.debug && console.log(`Received event ${message.event} on channel ${message.channel}`)
 
-            if (message.channel) {
-                this.options.debug && console.log(`Received event ${message.event} on channel ${message.channel}`)
+                    if (this.listeners[message.channel] && this.listeners[message.channel][message.event]) {
+                        this.listeners[message.channel][message.event](message.data)
+                    }
 
-                if (this.listeners[message.channel] && this.listeners[message.channel][message.event]) {
-                    this.listeners[message.channel][message.event](message.data)
+                    return
                 }
 
-                return
+                if (this.internalListeners[message.event]) {
+                    this.internalListeners[message.event](message.data)
+                }
             }
 
-            if (this.internalListeners[message.event]) {
-                this.internalListeners[message.event](message.data)
-            }
 
+            // send ping every 60 seconds to keep connection alive
+            this.pingInterval = setInterval(() => {
+                if (this.websocket.readyState === this.websocket.OPEN) {
+                    this.options.debug && console.log('Sending ping')
+                    this.send({
+                        event: 'ping',
+                    })
+                }
+            }, 60 * 1000)
         }
 
 
         this.websocket.onclose = () => {
-            if (this.socketId && !this.closing || !this.socketId) {
-                this.options.debug && console.info('Connection lost, reconnecting...');
-                setTimeout(() => {
-                    this.socketId = undefined
-                    this.connect(host)
-                }, 1000);
+            this.options.debug && console.info('Connection closed.');
+            if (this.closing){
+                return;
             }
+            this.hasConnected = false
+            this.options.debug && console.info('Connection lost, reconnecting...');
+            setTimeout(() => {
+                this.socketId = undefined
+                this.connect(host)
+            }, 1000);
         };
 
         this.on('whoami', ({ socket_id: socketId }) => {
@@ -82,25 +110,14 @@ export class Websocket {
 
             this.options.debug && console.log(`just set socketId to ${socketId}`)
 
-            while (this.channelBacklog.length) {
-                const channel = this.channelBacklog[0]
-
+            // Handle the backlog and don't empty it, we'll need it if we lose connection
+            let channel: Channel;
+            for(channel of this.channelBacklog){
                 this.actuallySubscribe(channel)
-
-                this.channelBacklog.splice(0, 1)
             }
-        })
 
+        })
 
-        // send ping every 60 seconds to keep connection alive
-        this.pingInterval = setInterval(() => {
-            if (this.websocket.readyState === this.websocket.OPEN) {
-                this.options.debug && console.log('Sending ping')
-                this.send({
-                    event: 'ping',
-                })
-            }
-        }, 60 * 1000)
 
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "laravel-echo-api-gateway",
-    "version": "0.5.1",
+    "version": "0.5.2",
     "description": "Use Laravel Echo with API Gateway Websockets",
     "keywords": [
         "laravel",