laravel-echo-api-gateway 0.5.8 → 0.5.9

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

@@ -1,880 +1,521 @@
 var LaravelEchoApiGateway = (function (exports) {
-  'use strict';
-
-  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, 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 _extends() {
-    _extends = Object.assign || function (target) {
-      for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
-
-        for (var key in source) {
-          if (Object.prototype.hasOwnProperty.call(source, key)) {
-            target[key] = source[key];
-          }
+    'use strict';
+
+    const LOG_PREFIX$2 = '[LE-AG-Websocket]';
+    const OPEN = 1;
+    class Websocket {
+        constructor(options) {
+            this.buffer = [];
+            /**
+             * Every channel that should be subscribed, re-subscribed each time a new connection is identified.
+             */
+            this.channels = new Map();
+            this.listeners = {};
+            this.closing = false;
+            this.reconnectAttempts = 0;
+            this.options = options;
+            if (this.options.host) {
+                this.connect();
+            }
         }
-      }
-
-      return target;
-    };
-
-    return _extends.apply(this, arguments);
-  }
-
-  function _inherits(subClass, superClass) {
-    if (typeof superClass !== "function" && superClass !== null) {
-      throw new TypeError("Super expression must either be null or a function");
-    }
-
-    Object.defineProperty(subClass, "prototype", {
-      value: Object.create(superClass && superClass.prototype, {
-        constructor: {
-          value: subClass,
-          writable: true,
-          configurable: true
-        }
-      }),
-      writable: false
-    });
-    if (superClass) _setPrototypeOf(subClass, superClass);
-  }
-
-  function _getPrototypeOf(o) {
-    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
-      return o.__proto__ || Object.getPrototypeOf(o);
-    };
-    return _getPrototypeOf(o);
-  }
-
-  function _setPrototypeOf(o, p) {
-    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
-      o.__proto__ = p;
-      return o;
-    };
-
-    return _setPrototypeOf(o, p);
-  }
-
-  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 _assertThisInitialized(self) {
-    if (self === void 0) {
-      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-    }
-
-    return self;
-  }
-
-  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 _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 _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
+        connect() {
+            const host = this.options.host;
+            this.debug(`Trying to connect to ${host}...`);
+            const websocket = new WebSocket(host);
+            this.websocket = websocket;
+            websocket.onopen = () => {
+                this.debug('Connected !');
+                this.reconnectAttempts = 0;
+                this.send({ event: 'whoami' });
+                while (this.buffer.length) {
+                    this.send(this.buffer.shift());
+                }
+                this.startPing();
             };
-            return {
-              done: false,
-              value: o[i++]
+            websocket.onmessage = (messageEvent) => {
+                this.handleMessage(messageEvent.data);
+            };
+            websocket.onerror = () => {
+                // A close event always follows an error, so reconnecting is handled in onclose.
+                this.debug('Connection error.');
+            };
+            websocket.onclose = () => {
+                if (this.websocket !== websocket) {
+                    return;
+                }
+                this.debug('Connection closed.');
+                this.stopPing();
+                this.socketId = undefined;
+                if (!this.closing) {
+                    this.scheduleReconnect();
+                }
             };
-          },
-          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);
-
-      this.buffer = [];
-      this.listeners = {};
-      this.internalListeners = {};
-      this.channelBacklog = [];
-      this.closing = false;
-      this.hasConnected = false;
-      this.options = options;
-      this.connect(this.options.host);
-      return this;
-    }
-
-    _createClass(Websocket, [{
-      key: "connect",
-      value: function connect(host) {
-        var _this = this;
-
-        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'
-          });
-
-          while (_this.buffer.length) {
-            var message = _this.buffer[0];
-
-            _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);
-
-            _this.options.debug && console.log(LOG_PREFIX + ' onmessage', messageEvent.data);
-
+        scheduleReconnect() {
+            var _a, _b;
+            const baseDelay = (_a = this.options.reconnectDelay) !== null && _a !== void 0 ? _a : 1000;
+            const maxDelay = (_b = this.options.maxReconnectDelay) !== null && _b !== void 0 ? _b : 30000;
+            const delay = Math.min(baseDelay * 2 ** this.reconnectAttempts, maxDelay);
+            this.reconnectAttempts++;
+            this.debug(`Connection lost, reconnecting in ${delay}ms...`);
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = setTimeout(() => this.connect(), delay);
+        }
+        startPing() {
+            var _a;
+            this.stopPing();
+            this.pingTimer = setInterval(() => {
+                if (this.socketIsReady()) {
+                    this.debug('Sending ping');
+                    this.send({ event: 'ping' });
+                }
+            }, (_a = this.options.pingInterval) !== null && _a !== void 0 ? _a : 60 * 1000);
+        }
+        stopPing() {
+            clearInterval(this.pingTimer);
+            this.pingTimer = undefined;
+        }
+        handleMessage(body) {
+            var _a;
+            const message = this.parseMessage(body);
             if (!message) {
-              return;
+                return;
             }
-
+            this.debug('onmessage', body);
             if (message.channel) {
-              _this.options.debug && console.log("".concat(LOG_PREFIX, " Received event ").concat(message.event, " on channel ").concat(message.channel));
-
-              if (_this.listeners[message.channel] && _this.listeners[message.channel][message.event]) {
-                _this.listeners[message.channel][message.event](message.data);
-              }
-
-              return;
+                this.dispatch(message.channel, message.event, message.data);
+                return;
             }
-
-            if (_this.internalListeners[message.event]) {
-              _this.internalListeners[message.event](message.data);
+            if (message.event === 'whoami') {
+                this.socketId = (_a = message.data) === null || _a === void 0 ? void 0 : _a.socket_id;
+                this.debug(`Just set socketId to ${this.socketId}`);
+                this.channels.forEach((channel) => this.actuallySubscribe(channel));
             }
-          }; // 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'
-              });
+        }
+        dispatch(channelName, event, data) {
+            var _a, _b;
+            const callbacks = (_b = (_a = this.listeners[channelName]) === null || _a === void 0 ? void 0 : _a[event]) !== null && _b !== void 0 ? _b : [];
+            callbacks.slice().forEach((callback) => callback(data));
+        }
+        parseMessage(body) {
+            try {
+                return JSON.parse(body);
             }
-          }, 60 * 1000);
-        };
-
-        this.websocket.onclose = function () {
-          _this.options.debug && console.info('Connection closed.');
-
-          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("".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
-
-          var channel;
-
-          var _iterator = _createForOfIteratorHelper(_this.channelBacklog),
-              _step;
-
-          try {
-            for (_iterator.s(); !(_step = _iterator.n()).done;) {
-              channel = _step.value;
-
-              _this.actuallySubscribe(channel);
+            catch (error) {
+                this.options.debug && console.error(error);
+                return undefined;
             }
-          } catch (err) {
-            _iterator.e(err);
-          } finally {
-            _iterator.f();
-          }
-        });
-      }
-    }, {
-      key: "parseMessage",
-      value: function parseMessage(body) {
-        try {
-          return JSON.parse(body);
-        } catch (error) {
-          this.options.debug && console.error(error);
-          return undefined;
-        }
-      }
-    }, {
-      key: "getSocketId",
-      value: function getSocketId() {
-        return this.socketId;
-      }
-    }, {
-      key: "socketIsReady",
-      value: function socketIsReady() {
-        return this.websocket.readyState === this.websocket.OPEN;
-      }
-    }, {
-      key: "send",
-      value: function send(message) {
-        if (this.socketIsReady()) {
-          this.websocket.send(JSON.stringify(message));
-          return;
         }
-
-        this.buffer.push(message);
-      }
-    }, {
-      key: "close",
-      value: function close() {
-        this.closing = true;
-        this.internalListeners = {};
-        clearInterval(this.pingInterval);
-        this.pingInterval = undefined;
-        this.websocket.close();
-      }
-    }, {
-      key: "subscribe",
-      value: function subscribe(channel) {
-        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);
-        }
-      }
-    }, {
-      key: "actuallySubscribe",
-      value: function actuallySubscribe(channel) {
-        var _this2 = this;
-
-        if (channel.name.startsWith('private-') || channel.name.startsWith('presence-')) {
-          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;
-          }
-
-          fetch(this.options.authEndpoint, {
-            method: 'POST',
-            headers: _extends({
-              'Content-Type': 'application/json'
-            }, this.options.auth.headers),
-            body: JSON.stringify({
-              socket_id: this.getSocketId(),
-              channel_name: channel.name
-            })
-          }).then(function (response) {
-            if (!response.ok) {
-              throw new Error("Auth request failed: ".concat(response.status));
+        getSocketId() {
+            return this.socketId;
+        }
+        socketIsReady() {
+            var _a;
+            return ((_a = this.websocket) === null || _a === void 0 ? void 0 : _a.readyState) === OPEN;
+        }
+        send(message) {
+            if (this.socketIsReady()) {
+                this.websocket.send(JSON.stringify(message));
+                return;
             }
-
-            return response.json();
-          }).then(function (data) {
-            _this2.options.debug && console.log("".concat(LOG_PREFIX, " Subscribing to private channel ").concat(channel.name));
-
-            _this2.send({
-              event: 'subscribe',
-              data: _extends({
-                channel: channel.name
-              }, data)
+            this.buffer.push(message);
+        }
+        close() {
+            var _a;
+            this.closing = true;
+            clearTimeout(this.reconnectTimer);
+            this.stopPing();
+            (_a = this.websocket) === null || _a === void 0 ? void 0 : _a.close();
+        }
+        subscribe(channel) {
+            this.channels.set(channel.name, channel);
+            if (this.socketId && this.socketIsReady()) {
+                this.actuallySubscribe(channel);
+            }
+            else {
+                this.debug(`Channel ${channel.name} will be subscribed once connected`);
+            }
+        }
+        actuallySubscribe(channel) {
+            if (!channel.name.startsWith('private-') && !channel.name.startsWith('presence-')) {
+                this.debug(`Subscribing to channel ${channel.name}`);
+                this.send({ event: 'subscribe', data: { channel: channel.name } });
+                return;
+            }
+            const socketId = this.socketId;
+            this.debug(`Sending auth request for channel ${channel.name}`);
+            this.authorize(channel.name, socketId).then((data) => {
+                // Skip outdated authorizations: the connection changed or the channel was left meanwhile.
+                if (socketId !== this.socketId || this.channels.get(channel.name) !== channel) {
+                    return;
+                }
+                this.debug(`Subscribing to private channel ${channel.name}`);
+                this.send({ event: 'subscribe', data: Object.assign({ channel: channel.name }, data) });
+            }).catch((error) => {
+                this.debug(`Auth request for channel ${channel.name} failed`, error);
+                this.dispatch(channel.name, 'error', error);
             });
-          })["catch"](function (error) {
-            _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("".concat(LOG_PREFIX, " Subscribing to channel ").concat(channel.name));
-          this.send({
-            event: 'subscribe',
-            data: {
-              channel: channel.name
+        }
+        authorize(channelName, socketId) {
+            var _a, _b, _c;
+            const channelAuthorization = (_a = this.options.channelAuthorization) !== null && _a !== void 0 ? _a : {};
+            if (typeof channelAuthorization.customHandler === 'function') {
+                return new Promise((resolve, reject) => {
+                    channelAuthorization.customHandler({ socketId, channelName }, (error, data) => {
+                        var _a;
+                        if (error) {
+                            reject(this.authorizationError(error, (_a = error === null || error === void 0 ? void 0 : error.status) !== null && _a !== void 0 ? _a : null));
+                        }
+                        else {
+                            resolve(data);
+                        }
+                    });
+                });
             }
-          });
-        }
-      }
-    }, {
-      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: {
-            channel: channel.name
-          }
-        });
-
-        if (this.listeners[channel.name]) {
-          delete this.listeners[channel.name];
-        }
-      }
-    }, {
-      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] = {};
+            return fetch((_b = channelAuthorization.endpoint) !== null && _b !== void 0 ? _b : this.options.authEndpoint, {
+                method: 'POST',
+                headers: Object.assign(Object.assign({ 'Content-Type': 'application/json', 'Accept': 'application/json' }, (_c = this.options.auth) === null || _c === void 0 ? void 0 : _c.headers), channelAuthorization.headers),
+                body: JSON.stringify({
+                    socket_id: socketId,
+                    channel_name: channelName,
+                }),
+            }).then((response) => {
+                if (!response.ok) {
+                    throw this.authorizationError(new Error(`Auth request failed: ${response.status}`), response.status);
+                }
+                return response.json();
+            }, (error) => {
+                throw this.authorizationError(error, null);
+            });
         }
-
-        this.listeners[channel.name][event] = callback;
-      }
-    }, {
-      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];
+        authorizationError(error, status) {
+            return { type: 'AuthError', status, error };
         }
-      }
-    }]);
-
-    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;
-      }
-  }
-
-  /**
-   * 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);
-      }
-  }
-
-  var LOG_PREFIX$1 = '[LE-AG-Channel]';
-  /**
-   * This class represents a Pusher channel.
-   */
-
-  var Channel$1 = /*#__PURE__*/function (_BaseChannel) {
-    _inherits(Channel, _BaseChannel);
-
-    var _super = _createSuper(Channel);
+        unsubscribe(channel) {
+            this.debug(`unsubscribe for channel ${channel.name}`);
+            if (this.channels.get(channel.name) === channel) {
+                this.channels.delete(channel.name);
+                delete this.listeners[channel.name];
+            }
+            if (this.socketId && this.socketIsReady()) {
+                this.send({ event: 'unsubscribe', data: { channel: channel.name } });
+            }
+        }
+        bind(channel, event, callback) {
+            var _a, _b;
+            var _c, _d, _e;
+            this.debug(`bind event ${event} for channel ${channel.name} ...`);
+            (_a = (_c = this.listeners)[_d = channel.name]) !== null && _a !== void 0 ? _a : (_c[_d] = {});
+            (_b = (_e = this.listeners[channel.name])[event]) !== null && _b !== void 0 ? _b : (_e[event] = []);
+            this.listeners[channel.name][event].push(callback);
+        }
+        unbind(channel, event, callback) {
+            var _a;
+            this.debug(`unbind event ${event} for channel ${channel.name} ...`);
+            const callbacks = (_a = this.listeners[channel.name]) === null || _a === void 0 ? void 0 : _a[event];
+            if (!callbacks) {
+                return;
+            }
+            if (callback) {
+                this.listeners[channel.name][event] = callbacks.filter((existing) => existing !== callback);
+            }
+            else {
+                delete this.listeners[channel.name][event];
+            }
+        }
+        debug(...messages) {
+            this.options.debug && console.log(LOG_PREFIX$2, ...messages);
+        }
+    }
 
     /**
-     * Create a new class instance.
+     * Formats event names the same way laravel-echo does, so `listen('OrderCreated')` matches
+     * `App\Events\OrderCreated` and `listen('.custom-name')` matches `custom-name`.
      */
-    function Channel(socket, name, options) {
-      var _this;
-
-      _classCallCheck(this, Channel);
-
-      _this = _super.call(this);
-      _this.name = name;
-      _this.socket = socket;
-      _this.options = options;
-      _this.eventFormatter = new EventFormatter(_this.options["namespace"]);
-
-      _this.subscribe();
-
-      return _this;
+    class EventFormatter {
+        constructor(namespace) {
+            this.namespace = namespace;
+        }
+        format(event) {
+            if (['.', '\\'].includes(event.charAt(0))) {
+                return event.substring(1);
+            }
+            if (this.namespace) {
+                event = this.namespace + '.' + event;
+            }
+            return event.replace(/\./g, '\\');
+        }
+        setNamespace(namespace) {
+            this.namespace = namespace;
+        }
     }
-    /**
-     * 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.
-       */
-
-    }, {
-      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.
-       */
-
-    }, {
-      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.
-       */
-
-    }, {
-      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.
-       */
-
-    }, {
-      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.
-       */
-
-    }, {
-      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.
-       */
-
-    }, {
-      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;
-      }
-    }, {
-      key: "whisper",
-      value: function whisper(event, data) {
-        var channel = this.name;
-        var formattedEvent = "client-" + event;
-        this.socket.send({
-          "event": formattedEvent,
-          data: data,
-          channel: channel
-        });
-        return this;
-      }
-    }, {
-      key: "here",
-      value: function here(callback) {
-        // TODO: implement
-        return this;
-      }
-      /**
-       * Listen for someone joining the channel.
-       */
-
-    }, {
-      key: "joining",
-      value: function joining(callback) {
-        // TODO: implement
-        return this;
-      }
-      /**
-       * Listen for someone leaving the channel.
-       */
-
-    }, {
-      key: "leaving",
-      value: function leaving(callback) {
-        // TODO: implement
-        return this;
-      }
-    }]);
-
-    return Channel;
-  }(Channel);
-
-  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);
 
+    const LOG_PREFIX$1 = '[LE-AG-Channel]';
+    const NOTIFICATION_EVENT = '.Illuminate\\Notifications\\Events\\BroadcastNotificationCreated';
     /**
-     * Create a new class instance.
+     * A channel on the API Gateway websocket. It implements the public, private and presence channel
+     * interfaces of laravel-echo (v1 and v2) without extending its internal classes.
      */
-    function Connector(options) {
-      var _this;
-
-      _classCallCheck(this, Connector);
-
-      _this = _super.call(this, options);
-      /**
-       * All of the subscribed channel names.
-       */
-
-      _this.channels = {};
-      return _this;
+    class Channel {
+        /**
+         * Create a new class instance.
+         */
+        constructor(socket, name, options) {
+            this.name = name;
+            this.socket = socket;
+            this.options = options;
+            this.eventFormatter = new EventFormatter(this.options.namespace);
+            this.subscribe();
+        }
+        /**
+         * Subscribe to the channel.
+         */
+        subscribe() {
+            this.options.debug && console.log(`${LOG_PREFIX$1} subscribe for channel ${this.name} ...`);
+            this.socket.subscribe(this);
+        }
+        /**
+         * Unsubscribe from the channel.
+         */
+        unsubscribe() {
+            this.options.debug && console.log(`${LOG_PREFIX$1} unsubscribe for channel ${this.name} ...`);
+            this.socket.unsubscribe(this);
+        }
+        /**
+         * Listen for an event on the channel instance.
+         */
+        listen(event, callback) {
+            this.options.debug && console.log(`${LOG_PREFIX$1} listen to ${event} for channel ${this.name} ...`);
+            return this.on(this.eventFormatter.format(event), callback);
+        }
+        /**
+         * Stop listening for an event on the channel instance. Without a callback, every listener of the event is removed.
+         */
+        stopListening(event, callback) {
+            this.options.debug && console.log(`${LOG_PREFIX$1} stop listening to ${event} for channel ${this.name} ...`);
+            this.socket.unbind(this, this.eventFormatter.format(event), callback);
+            return this;
+        }
+        /**
+         * Listen for a whisper event on the channel instance.
+         */
+        listenForWhisper(event, callback) {
+            return this.listen('.client-' + event, callback);
+        }
+        /**
+         * Stop listening for a whisper event on the channel instance.
+         */
+        stopListeningForWhisper(event, callback) {
+            return this.stopListening('.client-' + event, callback);
+        }
+        /**
+         * Listen for an event on the channel instance.
+         */
+        notification(callback) {
+            return this.listen(NOTIFICATION_EVENT, callback);
+        }
+        /**
+         * Stop listening for notification events on the channel instance.
+         */
+        stopListeningForNotification(callback) {
+            return this.stopListening(NOTIFICATION_EVENT, callback);
+        }
+        /**
+         * Register a callback to be called anytime a subscription succeeds.
+         */
+        subscribed(callback) {
+            return this.on('subscription_succeeded', () => {
+                callback();
+            });
+        }
+        /**
+         * Register a callback to be called anytime a subscription or authorization error occurs.
+         */
+        error(callback) {
+            return this.on('error', callback);
+        }
+        /**
+         * Bind a channel to an event.
+         */
+        on(event, callback) {
+            this.options.debug && console.log(`${LOG_PREFIX$1} on ${event} for channel ${this.name} ...`);
+            this.socket.bind(this, event, callback);
+            return this;
+        }
+        /**
+         * Send a client event to the other members of the channel.
+         */
+        whisper(event, data) {
+            this.socket.send({
+                event: 'client-' + event,
+                channel: this.name,
+                data,
+            });
+            return this;
+        }
+        /**
+         * Presence channels are not supported yet: member tracking is not implemented on the server.
+         */
+        here(_callback) {
+            return this;
+        }
+        /**
+         * Presence channels are not supported yet: member tracking is not implemented on the server.
+         */
+        joining(_callback) {
+            return this;
+        }
+        /**
+         * Presence channels are not supported yet: member tracking is not implemented on the server.
+         */
+        leaving(_callback) {
+            return this;
+        }
     }
+
+    const LOG_PREFIX = '[LE-AG-Connector]';
     /**
-     * Create a fresh Socket.io connection.
+     * Laravel Echo connector for API Gateway websockets.
+     *
+     * It does not extend laravel-echo's internal classes, so it works with laravel-echo v1 and v2:
+     * both create custom connectors with `new options.broadcaster(options)`.
      */
-
-
-    _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', () => {
-        //     Object.values(this.channels).forEach((channel) => {
-        //         channel.subscribe();
-        //     });
-        // });
-        //
-        // return this.socket;
-      }
-      /**
-       * Get a channel instance by name.
-       */
-
-    }, {
-      key: "channel",
-      value: function channel(name) {
-        if (!this.channels[name]) {
-          this.channels[name] = new Channel$1(this.socket, name, this.options);
+    class Connector {
+        /**
+         * Create a new class instance. Without a host no connection is opened, which keeps
+         * laravel-echo v2's `new broadcaster()` capability check free of side effects.
+         */
+        constructor(options = {}) {
+            /**
+             * All of the subscribed channel names.
+             */
+            this.channels = {};
+            this.setOptions(options);
+            this.connect();
         }
-
-        return this.channels[name];
-      }
-      /**
-       * Get a private channel instance by name.
-       */
-
-    }, {
-      key: "privateChannel",
-      value: function privateChannel(name) {
-        if (!this.channels['private-' + name]) {
-          this.channels['private-' + name] = new Channel$1(this.socket, 'private-' + name, this.options);
+        /**
+         * Merge the custom options with the defaults and add the CSRF and bearer token headers.
+         */
+        setOptions(options) {
+            var _a, _b;
+            this.options = Object.assign(Object.assign(Object.assign({}, Connector._defaultOptions), options), { auth: {
+                    headers: Object.assign({}, ((_b = (_a = options.auth) === null || _a === void 0 ? void 0 : _a.headers) !== null && _b !== void 0 ? _b : {})),
+                } });
+            const csrfToken = this.csrfToken();
+            if (csrfToken) {
+                this.options.auth.headers['X-CSRF-TOKEN'] = csrfToken;
+            }
+            if (this.options.bearerToken) {
+                this.options.auth.headers['Authorization'] = 'Bearer ' + this.options.bearerToken;
+            }
         }
-
-        return this.channels['private-' + name];
-      }
-      /**
-       * Get a presence channel instance by name.
-       */
-
-    }, {
-      key: "presenceChannel",
-      value: function presenceChannel(name) {
-        if (!this.channels['presence-' + name]) {
-          this.channels['presence-' + name] = new Channel$1(this.socket, 'presence-' + name, this.options);
+        /**
+         * Extract the CSRF token from the page.
+         */
+        csrfToken() {
+            var _a, _b, _c;
+            if (typeof window !== 'undefined' && ((_a = window.Laravel) === null || _a === void 0 ? void 0 : _a.csrfToken)) {
+                return window.Laravel.csrfToken;
+            }
+            if (this.options.csrfToken) {
+                return this.options.csrfToken;
+            }
+            if (typeof document !== 'undefined' && typeof document.querySelector === 'function') {
+                return (_c = (_b = document.querySelector('meta[name="csrf-token"]')) === null || _b === void 0 ? void 0 : _b.getAttribute('content')) !== null && _c !== void 0 ? _c : null;
+            }
+            return null;
         }
+        /**
+         * Create a fresh websocket connection.
+         */
+        connect() {
+            this.options.debug && console.log(LOG_PREFIX + ' Connect ...');
+            this.socket = new Websocket(this.options);
+        }
+        /**
+         * Listen for an event on a channel instance.
+         */
+        listen(name, event, callback) {
+            return this.channel(name).listen(event, callback);
+        }
+        /**
+         * Get a channel instance by name.
+         */
+        channel(name) {
+            if (!this.channels[name]) {
+                this.channels[name] = new Channel(this.socket, name, this.options);
+            }
+            return this.channels[name];
+        }
+        /**
+         * Get a private channel instance by name.
+         */
+        privateChannel(name) {
+            return this.channel('private-' + name);
+        }
+        /**
+         * Get a presence channel instance by name.
+         */
+        presenceChannel(name) {
+            return this.channel('presence-' + name);
+        }
+        /**
+         * Leave the given channel, as well as its private and presence variants.
+         */
+        leave(name) {
+            [name, 'private-' + name, 'presence-' + name].forEach((channelName) => {
+                this.leaveChannel(channelName);
+            });
+        }
+        /**
+         * Leave the given channel.
+         */
+        leaveChannel(name) {
+            if (this.channels[name]) {
+                this.channels[name].unsubscribe();
+                delete this.channels[name];
+            }
+        }
+        /**
+         * Get the socket ID for the connection.
+         */
+        socketId() {
+            return this.socket.getSocketId();
+        }
+        /**
+         * Disconnect socket connection.
+         */
+        disconnect() {
+            this.options.debug && console.log(LOG_PREFIX + ' Disconnect ...');
+            this.socket.close();
+        }
+    }
+    /**
+     * Default connector options, matching laravel-echo's defaults.
+     */
+    Connector._defaultOptions = {
+        auth: {
+            headers: {},
+        },
+        authEndpoint: '/broadcasting/auth',
+        csrfToken: null,
+        bearerToken: null,
+        host: null,
+        namespace: 'App.Events',
+    };
+    /**
+     * Kept for backwards compatibility: `new Echo({ broadcaster })`. A function declaration (not an arrow
+     * function) so laravel-echo can call it with `new`.
+     */
+    function broadcaster(options) {
+        return new Connector(options);
+    }
 
-        return this.channels['presence-' + name];
-      }
-      /**
-       * Leave the given channel, as well as its private and presence variants.
-       */
-
-    }, {
-      key: "leave",
-      value: function leave(name) {
-        var _this2 = this;
-
-        var channels = [name, 'private-' + name, 'presence-' + name];
-        channels.forEach(function (name) {
-          _this2.leaveChannel(name);
-        });
-      }
-      /**
-       * Leave the given channel.
-       */
-
-    }, {
-      key: "leaveChannel",
-      value: function leaveChannel(name) {
-        if (this.channels[name]) {
-          this.channels[name].unsubscribe();
-          delete this.channels[name];
-        }
-      }
-      /**
-       * Get the socket ID for the connection.
-       */
-
-    }, {
-      key: "socketId",
-      value: function socketId() {
-        return this.socket.getSocketId();
-      }
-      /**
-       * Disconnect socket connection.
-       */
-
-    }, {
-      key: "disconnect",
-      value: function disconnect() {
-        this.options.debug && console.log(LOG_PREFIX$2 + 'Disconnect ...');
-        this.socket.close();
-      }
-    }]);
-
-    return Connector;
-  }(Connector);
-
-  exports.Connector = Connector$1;
-  exports.broadcaster = broadcaster;
-
-  Object.defineProperty(exports, '__esModule', { value: true });
+    exports.Channel = Channel;
+    exports.Connector = Connector;
+    exports.EventFormatter = EventFormatter;
+    exports.broadcaster = broadcaster;
 
-  return exports;
+    return exports;
 
-}({}));
+})({});