@everymatrix/nuts-inbox-widget 1.98.18 → 1.98.19

package/dist/esm/nuts-inbox-widget_3.entry.js

@@ -1563,39 +1563,29 @@ if (withEventListeners) {
 }
 /**
  * This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established
- * with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.
+ * with one of the available low-level transports, like HTTP long-polling, WebSocket, or WebTransport.
  *
- * This class comes without upgrade mechanism, which means that it will keep the first low-level transport that
- * successfully establishes the connection.
- *
- * In order to allow tree-shaking, there are no transports included, that's why the `transports` option is mandatory.
+ * This class comes with an upgrade mechanism, which means that once the connection is established with the first
+ * low-level transport, it will try to upgrade to a better transport.
  *
  * @example
- * import { SocketWithoutUpgrade, WebSocket } from "engine.io-client";
+ * import { Socket } from "engine.io-client";
  *
- * const socket = new SocketWithoutUpgrade({
- *   transports: [WebSocket]
- * });
+ * const socket = new Socket();
  *
  * socket.on("open", () => {
  *   socket.send("hello");
  * });
  *
- * @see SocketWithUpgrade
- * @see Socket
  */
-class SocketWithoutUpgrade extends Emitter {
-    /**
-     * Socket constructor.
-     *
-     * @param {String|Object} uri - uri or options
-     * @param {Object} opts - options
-     */
-    constructor(uri, opts) {
+class Socket$1 extends Emitter {
+    constructor(uri, opts = {}) {
+        var _a, _b;
         super();
         this.binaryType = defaultBinaryType;
         this.writeBuffer = [];
         this._prevBufferLen = 0;
+        this._upgrades = [];
         this._pingInterval = -1;
         this._pingTimeout = -1;
         this._maxPayload = -1;
@@ -1639,13 +1629,26 @@ class SocketWithoutUpgrade extends Emitter {
                     : this.secure
                         ? "443"
                         : "80");
-        this.transports = [];
-        this._transportsByName = {};
-        opts.transports.forEach((t) => {
-            const transportName = t.prototype.name;
-            this.transports.push(transportName);
-            this._transportsByName[transportName] = t;
-        });
+        if (opts.transportImplementations && opts.transports) {
+            throw new Error("specifying both 'transportImplementations' and 'transports' options is not supported");
+        }
+        if (opts.transportImplementations ||
+            (((_a = opts.transports) === null || _a === void 0 ? void 0 : _a.length) && typeof opts.transports[0] === "function")) {
+            // 'transports' option as an array of transport implementations is kept for backward compatibility
+            this.transports = [];
+            this._transportsByName = Object.create(null);
+            ((_b = opts.transportImplementations) !== null && _b !== void 0 ? _b : opts.transports).forEach((t) => {
+                const transportName = t.prototype.name;
+                this.transports.push(transportName);
+                this._transportsByName[transportName] = t;
+            });
+        }
+        else {
+            this.transports = opts.transports
+                ? [...opts.transports]
+                : ["polling", "websocket", "webtransport"];
+            this._transportsByName = transports;
+        }
         this.opts = Object.assign({
             path: "/engine.io",
             agent: false,
@@ -1734,7 +1737,7 @@ class SocketWithoutUpgrade extends Emitter {
             return;
         }
         const transportName = this.opts.rememberUpgrade &&
-            SocketWithoutUpgrade.priorWebsocketSuccess &&
+            Socket$1.priorWebsocketSuccess &&
             this.transports.indexOf("websocket") !== -1
             ? "websocket"
             : this.transports[0];
@@ -1761,6 +1764,107 @@ class SocketWithoutUpgrade extends Emitter {
             .on("error", this._onError.bind(this))
             .on("close", (reason) => this._onClose("transport close", reason));
     }
+    /**
+     * Probes a transport.
+     *
+     * @param {String} name - transport name
+     * @private
+     */
+    _probe(name) {
+        let transport = this.createTransport(name);
+        let failed = false;
+        Socket$1.priorWebsocketSuccess = false;
+        const onTransportOpen = () => {
+            if (failed)
+                return;
+            transport.send([{ type: "ping", data: "probe" }]);
+            transport.once("packet", (msg) => {
+                if (failed)
+                    return;
+                if ("pong" === msg.type && "probe" === msg.data) {
+                    this.upgrading = true;
+                    this.emitReserved("upgrading", transport);
+                    if (!transport)
+                        return;
+                    Socket$1.priorWebsocketSuccess = "websocket" === transport.name;
+                    this.transport.pause(() => {
+                        if (failed)
+                            return;
+                        if ("closed" === this.readyState)
+                            return;
+                        cleanup();
+                        this.setTransport(transport);
+                        transport.send([{ type: "upgrade" }]);
+                        this.emitReserved("upgrade", transport);
+                        transport = null;
+                        this.upgrading = false;
+                        this.flush();
+                    });
+                }
+                else {
+                    const err = new Error("probe error");
+                    // @ts-ignore
+                    err.transport = transport.name;
+                    this.emitReserved("upgradeError", err);
+                }
+            });
+        };
+        function freezeTransport() {
+            if (failed)
+                return;
+            // Any callback called by transport should be ignored since now
+            failed = true;
+            cleanup();
+            transport.close();
+            transport = null;
+        }
+        // Handle any error that happens while probing
+        const onerror = (err) => {
+            const error = new Error("probe error: " + err);
+            // @ts-ignore
+            error.transport = transport.name;
+            freezeTransport();
+            this.emitReserved("upgradeError", error);
+        };
+        function onTransportClose() {
+            onerror("transport closed");
+        }
+        // When the socket is closed while we're probing
+        function onclose() {
+            onerror("socket closed");
+        }
+        // When the socket is upgraded while we're probing
+        function onupgrade(to) {
+            if (transport && to.name !== transport.name) {
+                freezeTransport();
+            }
+        }
+        // Remove all listeners on the transport and on self
+        const cleanup = () => {
+            transport.removeListener("open", onTransportOpen);
+            transport.removeListener("error", onerror);
+            transport.removeListener("close", onTransportClose);
+            this.off("close", onclose);
+            this.off("upgrading", onupgrade);
+        };
+        transport.once("open", onTransportOpen);
+        transport.once("error", onerror);
+        transport.once("close", onTransportClose);
+        this.once("close", onclose);
+        this.once("upgrading", onupgrade);
+        if (this._upgrades.indexOf("webtransport") !== -1 &&
+            name !== "webtransport") {
+            // favor WebTransport
+            this.setTimeoutFn(() => {
+                if (!failed) {
+                    transport.open();
+                }
+            }, 200);
+        }
+        else {
+            transport.open();
+        }
+    }
     /**
      * Called when connection is deemed open.
      *
@@ -1768,10 +1872,14 @@ class SocketWithoutUpgrade extends Emitter {
      */
     onOpen() {
         this.readyState = "open";
-        SocketWithoutUpgrade.priorWebsocketSuccess =
-            "websocket" === this.transport.name;
+        Socket$1.priorWebsocketSuccess = "websocket" === this.transport.name;
         this.emitReserved("open");
         this.flush();
+        if ("open" === this.readyState && this.opts.upgrade) {
+            for (let i = 0; i < this._upgrades.length; i++) {
+                this._probe(this._upgrades[i]);
+            }
+        }
     }
     /**
      * Handles a packet.
@@ -1818,6 +1926,7 @@ class SocketWithoutUpgrade extends Emitter {
         this.emitReserved("handshake", data);
         this.id = data.sid;
         this.transport.query.sid = data.sid;
+        this._upgrades = this._filterUpgrades(data.upgrades);
         this._pingInterval = data.pingInterval;
         this._pingTimeout = data.pingTimeout;
         this._maxPayload = data.maxPayload;
@@ -2029,7 +2138,7 @@ class SocketWithoutUpgrade extends Emitter {
      * @private
      */
     _onError(err) {
-        SocketWithoutUpgrade.priorWebsocketSuccess = false;
+        Socket$1.priorWebsocketSuccess = false;
         if (this.opts.tryAllTransports &&
             this.transports.length > 1 &&
             this.readyState === "opening") {
@@ -2079,150 +2188,6 @@ class SocketWithoutUpgrade extends Emitter {
             this._prevBufferLen = 0;
         }
     }
-}
-SocketWithoutUpgrade.protocol = protocol$1;
-/**
- * This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established
- * with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.
- *
- * This class comes with an upgrade mechanism, which means that once the connection is established with the first
- * low-level transport, it will try to upgrade to a better transport.
- *
- * In order to allow tree-shaking, there are no transports included, that's why the `transports` option is mandatory.
- *
- * @example
- * import { SocketWithUpgrade, WebSocket } from "engine.io-client";
- *
- * const socket = new SocketWithUpgrade({
- *   transports: [WebSocket]
- * });
- *
- * socket.on("open", () => {
- *   socket.send("hello");
- * });
- *
- * @see SocketWithoutUpgrade
- * @see Socket
- */
-class SocketWithUpgrade extends SocketWithoutUpgrade {
-    constructor() {
-        super(...arguments);
-        this._upgrades = [];
-    }
-    onOpen() {
-        super.onOpen();
-        if ("open" === this.readyState && this.opts.upgrade) {
-            for (let i = 0; i < this._upgrades.length; i++) {
-                this._probe(this._upgrades[i]);
-            }
-        }
-    }
-    /**
-     * Probes a transport.
-     *
-     * @param {String} name - transport name
-     * @private
-     */
-    _probe(name) {
-        let transport = this.createTransport(name);
-        let failed = false;
-        SocketWithoutUpgrade.priorWebsocketSuccess = false;
-        const onTransportOpen = () => {
-            if (failed)
-                return;
-            transport.send([{ type: "ping", data: "probe" }]);
-            transport.once("packet", (msg) => {
-                if (failed)
-                    return;
-                if ("pong" === msg.type && "probe" === msg.data) {
-                    this.upgrading = true;
-                    this.emitReserved("upgrading", transport);
-                    if (!transport)
-                        return;
-                    SocketWithoutUpgrade.priorWebsocketSuccess =
-                        "websocket" === transport.name;
-                    this.transport.pause(() => {
-                        if (failed)
-                            return;
-                        if ("closed" === this.readyState)
-                            return;
-                        cleanup();
-                        this.setTransport(transport);
-                        transport.send([{ type: "upgrade" }]);
-                        this.emitReserved("upgrade", transport);
-                        transport = null;
-                        this.upgrading = false;
-                        this.flush();
-                    });
-                }
-                else {
-                    const err = new Error("probe error");
-                    // @ts-ignore
-                    err.transport = transport.name;
-                    this.emitReserved("upgradeError", err);
-                }
-            });
-        };
-        function freezeTransport() {
-            if (failed)
-                return;
-            // Any callback called by transport should be ignored since now
-            failed = true;
-            cleanup();
-            transport.close();
-            transport = null;
-        }
-        // Handle any error that happens while probing
-        const onerror = (err) => {
-            const error = new Error("probe error: " + err);
-            // @ts-ignore
-            error.transport = transport.name;
-            freezeTransport();
-            this.emitReserved("upgradeError", error);
-        };
-        function onTransportClose() {
-            onerror("transport closed");
-        }
-        // When the socket is closed while we're probing
-        function onclose() {
-            onerror("socket closed");
-        }
-        // When the socket is upgraded while we're probing
-        function onupgrade(to) {
-            if (transport && to.name !== transport.name) {
-                freezeTransport();
-            }
-        }
-        // Remove all listeners on the transport and on self
-        const cleanup = () => {
-            transport.removeListener("open", onTransportOpen);
-            transport.removeListener("error", onerror);
-            transport.removeListener("close", onTransportClose);
-            this.off("close", onclose);
-            this.off("upgrading", onupgrade);
-        };
-        transport.once("open", onTransportOpen);
-        transport.once("error", onerror);
-        transport.once("close", onTransportClose);
-        this.once("close", onclose);
-        this.once("upgrading", onupgrade);
-        if (this._upgrades.indexOf("webtransport") !== -1 &&
-            name !== "webtransport") {
-            // favor WebTransport
-            this.setTimeoutFn(() => {
-                if (!failed) {
-                    transport.open();
-                }
-            }, 200);
-        }
-        else {
-            transport.open();
-        }
-    }
-    onHandshake(data) {
-        this._upgrades = this._filterUpgrades(data.upgrades);
-        super.onHandshake(data);
-    }
     /**
      * Filters upgrades, returning only those matching client transports.
      *
@@ -2238,38 +2203,7 @@ class SocketWithUpgrade extends SocketWithoutUpgrade {
         return filteredUpgrades;
     }
 }
-/**
- * This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established
- * with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.
- *
- * This class comes with an upgrade mechanism, which means that once the connection is established with the first
- * low-level transport, it will try to upgrade to a better transport.
- *
- * @example
- * import { Socket } from "engine.io-client";
- *
- * const socket = new Socket();
- *
- * socket.on("open", () => {
- *   socket.send("hello");
- * });
- *
- * @see SocketWithoutUpgrade
- * @see SocketWithUpgrade
- */
-class Socket$1 extends SocketWithUpgrade {
-    constructor(uri, opts = {}) {
-        const isOptionsOnly = typeof uri === "object";
-        const o = isOptionsOnly ? { ...uri } : { ...opts };
-        if (!o.transports ||
-            (o.transports && typeof o.transports[0] === "string")) {
-            o.transports = (o.transports || ["polling", "websocket", "webtransport"])
-                .map((transportName) => transports[transportName])
-                .filter((t) => !!t);
-        }
-        super(isOptionsOnly ? o : uri, o);
-    }
-}
+Socket$1.protocol = protocol$1;
 
 /**
  * URL parser.