laravel-echo-api-gateway 0.5.8 → 0.5.9

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

@@ -1,875 +1,516 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-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];
-        }
-      }
-    }
-
-    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
-          };
-          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.
-     */
+const LOG_PREFIX$2 = '[LE-AG-Websocket]';
+const OPEN = 1;
+class Websocket {
     constructor(options) {
+        this.buffer = [];
         /**
-         * Default connector options.
+         * Every channel that should be subscribed, re-subscribed each time a new connection is identified.
          */
-        this._defaultOptions = {
-            auth: {
-                headers: {},
-            },
-            authEndpoint: '/broadcasting/auth',
-            broadcaster: 'pusher',
-            csrfToken: null,
-            host: null,
-            key: null,
-            namespace: 'App.Events',
+        this.channels = new Map();
+        this.listeners = {};
+        this.closing = false;
+        this.reconnectAttempts = 0;
+        this.options = options;
+        if (this.options.host) {
+            this.connect();
+        }
+    }
+    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();
+        };
+        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();
+            }
         };
-        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;
+    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);
     }
-    /**
-     * Extract the CSRF token from the page.
-     */
-    csrfToken() {
-        let selector;
-        if (typeof window !== 'undefined' && window['Laravel'] && window['Laravel'].csrfToken) {
-            return window['Laravel'].csrfToken;
+    stopPing() {
+        clearInterval(this.pingTimer);
+        this.pingTimer = undefined;
+    }
+    handleMessage(body) {
+        var _a;
+        const message = this.parseMessage(body);
+        if (!message) {
+            return;
         }
-        else if (this.options.csrfToken) {
-            return this.options.csrfToken;
+        this.debug('onmessage', body);
+        if (message.channel) {
+            this.dispatch(message.channel, message.event, message.data);
+            return;
         }
-        else if (typeof document !== 'undefined' &&
-            typeof document.querySelector === 'function' &&
-            (selector = document.querySelector('meta[name="csrf-token"]'))) {
-            return selector.getAttribute('content');
+        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));
         }
-        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);
+    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);
         }
-      };
-
-      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);
-
-          if (!message) {
-            return;
-          }
-
-          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);
-            }
-
+        catch (error) {
+            this.options.debug && console.error(error);
+            return undefined;
+        }
+    }
+    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;
-          }
-
-          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 () {
-        _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 (err) {
-          _iterator.e(err);
-        } finally {
-          _iterator.f();
+        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);
         }
-      });
-    }
-  }, {
-    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;
+        else {
+            this.debug(`Channel ${channel.name} will be subscribed once connected`);
         }
-
-        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));
-          }
-
-          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)
-          });
-        })["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);
+    }
+    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);
         });
-      } 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);
+                    }
+                });
+            });
+        }
+        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);
         });
-      }
-    }
-  }, {
-    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
+    }
+    authorizationError(error, status) {
+        return { type: 'AuthError', status, error };
+    }
+    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 } });
         }
-      });
-
-      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] = {};
-      }
-
-      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];
-      }
+    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];
+        }
     }
-  }]);
-
-  return Websocket;
-}();
+    debug(...messages) {
+        this.options.debug && console.log(LOG_PREFIX$2, ...messages);
+    }
+}
 
 /**
- * Event name formatter
+ * Formats event names the same way laravel-echo does, so `listen('OrderCreated')` matches
+ * `App\Events\OrderCreated` and `listen('.custom-name')` matches `custom-name`.
  */
 class EventFormatter {
-    /**
-     * Create a new class instance.
-     */
     constructor(namespace) {
-        this.setNamespace(namespace);
+        this.namespace = namespace;
     }
-    /**
-     * Format the given event name.
-     */
     format(event) {
-        if (event.charAt(0) === '.' || event.charAt(0) === '\\') {
-            return event.substr(1);
+        if (['.', '\\'].includes(event.charAt(0))) {
+            return event.substring(1);
         }
-        else if (this.namespace) {
+        if (this.namespace) {
             event = this.namespace + '.' + event;
         }
         return event.replace(/\./g, '\\');
     }
-    /**
-     * Set the event namespace.
-     */
-    setNamespace(value) {
-        this.namespace = value;
+    setNamespace(namespace) {
+        this.namespace = namespace;
     }
 }
 
+const LOG_PREFIX$1 = '[LE-AG-Channel]';
+const NOTIFICATION_EVENT = '.Illuminate\\Notifications\\Events\\BroadcastNotificationCreated';
 /**
- * This class represents a basic channel.
+ * 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.
  */
 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('.Illuminate\\Notifications\\Events\\BroadcastNotificationCreated', callback);
+        return this.listen(NOTIFICATION_EVENT, callback);
     }
     /**
-     * Stop listening for a whisper event on the channel instance.
+     * Stop listening for notification events on the channel instance.
      */
-    stopListeningForWhisper(event, callback) {
-        return this.stopListening('.client-' + event, callback);
+    stopListeningForNotification(callback) {
+        return this.stopListening(NOTIFICATION_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);
-
-  /**
-   * Create a new class instance.
-   */
-  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;
-  }
-  /**
-   * 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);
+    /**
+     * Register a callback to be called anytime a subscription succeeds.
+     */
+    subscribed(callback) {
+        return this.on('subscription_succeeded', () => {
+            callback();
+        });
     }
     /**
-     * Unsubscribe from a Pusher channel.
+     * Register a callback to be called anytime a subscription or authorization error occurs.
      */
-
-  }, {
-    key: "unsubscribe",
-    value: function unsubscribe() {
-      this.options["debug"] && console.log("".concat(LOG_PREFIX$1, " unsubscribe for channel ").concat(this.name, " ..."));
-      this.socket.unsubscribe(this);
+    error(callback) {
+        return this.on('error', callback);
     }
     /**
-     * Listen for an event on the channel instance.
+     * Bind a channel to an event.
      */
-
-  }, {
-    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;
+    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;
     }
     /**
-     * Stop listening for an event on the channel instance.
+     * Send a client event to the other members of the channel.
      */
-
-  }, {
-    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;
+    whisper(event, data) {
+        this.socket.send({
+            event: 'client-' + event,
+            channel: this.name,
+            data,
+        });
+        return this;
     }
     /**
-     * Register a callback to be called anytime a subscription succeeds.
+     * Presence channels are not supported yet: member tracking is not implemented on the server.
      */
-
-  }, {
-    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;
+    here(_callback) {
+        return this;
     }
     /**
-     * Register a callback to be called anytime a subscription error occurs.
+     * Presence channels are not supported yet: member tracking is not implemented on the server.
      */
-
-  }, {
-    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;
+    joining(_callback) {
+        return this;
     }
     /**
-     * Bind a channel to an event.
+     * Presence channels are not supported yet: member tracking is not implemented on the server.
      */
+    leaving(_callback) {
+        return this;
+    }
+}
 
-  }, {
-    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;
+const LOG_PREFIX = '[LE-AG-Connector]';
+/**
+ * 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)`.
+ */
+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();
     }
     /**
-     * Listen for someone joining the channel.
+     * Merge the custom options with the defaults and add the CSRF and bearer token headers.
      */
-
-  }, {
-    key: "joining",
-    value: function joining(callback) {
-      // TODO: implement
-      return this;
+    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;
+        }
     }
     /**
-     * Listen for someone leaving the channel.
+     * Extract the CSRF token from the page.
      */
-
-  }, {
-    key: "leaving",
-    value: function leaving(callback) {
-      // TODO: implement
-      return this;
+    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;
     }
-  }]);
-
-  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);
-
-  /**
-   * Create a new class instance.
-   */
-  function Connector(options) {
-    var _this;
-
-    _classCallCheck(this, Connector);
-
-    _this = _super.call(this, options);
     /**
-     * All of the subscribed channel names.
+     * Create a fresh websocket connection.
      */
-
-    _this.channels = {};
-    return _this;
-  }
-  /**
-   * 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', () => {
-      //     Object.values(this.channels).forEach((channel) => {
-      //         channel.subscribe();
-      //     });
-      // });
-      //
-      // return this.socket;
+    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.
      */
-
-  }, {
-    key: "channel",
-    value: function channel(name) {
-      if (!this.channels[name]) {
-        this.channels[name] = new Channel$1(this.socket, name, this.options);
-      }
-
-      return this.channels[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.
      */
-
-  }, {
-    key: "privateChannel",
-    value: function privateChannel(name) {
-      if (!this.channels['private-' + name]) {
-        this.channels['private-' + name] = new Channel$1(this.socket, 'private-' + name, this.options);
-      }
-
-      return this.channels['private-' + name];
+    privateChannel(name) {
+        return this.channel('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);
-      }
-
-      return this.channels['presence-' + name];
+    presenceChannel(name) {
+        return this.channel('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(name) {
+        [name, 'private-' + name, 'presence-' + name].forEach((channelName) => {
+            this.leaveChannel(channelName);
+        });
     }
     /**
      * Leave the given channel.
      */
-
-  }, {
-    key: "leaveChannel",
-    value: function leaveChannel(name) {
-      if (this.channels[name]) {
-        this.channels[name].unsubscribe();
-        delete this.channels[name];
-      }
+    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();
+    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();
+    disconnect() {
+        this.options.debug && console.log(LOG_PREFIX + ' Disconnect ...');
+        this.socket.close();
     }
-  }]);
-
-  return Connector;
-}(Connector);
+}
+/**
+ * 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);
+}
 
-exports.Connector = Connector$1;
+exports.Channel = Channel;
+exports.Connector = Connector;
+exports.EventFormatter = EventFormatter;
 exports.broadcaster = broadcaster;