@wabot-dev/framework 0.0.12 → 0.0.14

package/dist/src/node_modules/engine.io/build/socket.js

@@ -0,0 +1,469 @@
+import { __exports as socket } from '../../../_virtual/socket2.js';
+import require$$0 from 'events';
+import { __require as requireSrc } from '../node_modules/debug/src/index.js';
+import require$$2 from 'timers';
+
+var hasRequiredSocket;
+
+function requireSocket () {
+	if (hasRequiredSocket) return socket;
+	hasRequiredSocket = 1;
+	Object.defineProperty(socket, "__esModule", { value: true });
+	socket.Socket = void 0;
+	const events_1 = require$$0;
+	const debug_1 = requireSrc();
+	const timers_1 = require$$2;
+	const debug = (0, debug_1.default)("engine:socket");
+	class Socket extends events_1.EventEmitter {
+	    get readyState() {
+	        return this._readyState;
+	    }
+	    set readyState(state) {
+	        debug("readyState updated from %s to %s", this._readyState, state);
+	        this._readyState = state;
+	    }
+	    constructor(id, server, transport, req, protocol) {
+	        super();
+	        /**
+	         * The current state of the socket.
+	         */
+	        this._readyState = "opening";
+	        /* private */ this.upgrading = false;
+	        /* private */ this.upgraded = false;
+	        this.writeBuffer = [];
+	        this.packetsFn = [];
+	        this.sentCallbackFn = [];
+	        this.cleanupFn = [];
+	        this.id = id;
+	        this.server = server;
+	        this.request = req;
+	        this.protocol = protocol;
+	        // Cache IP since it might not be in the req later
+	        if (req) {
+	            if (req.websocket && req.websocket._socket) {
+	                this.remoteAddress = req.websocket._socket.remoteAddress;
+	            }
+	            else {
+	                this.remoteAddress = req.connection.remoteAddress;
+	            }
+	        }
+	        this.pingTimeoutTimer = null;
+	        this.pingIntervalTimer = null;
+	        this.setTransport(transport);
+	        this.onOpen();
+	    }
+	    /**
+	     * Called upon transport considered open.
+	     *
+	     * @private
+	     */
+	    onOpen() {
+	        this.readyState = "open";
+	        // sends an `open` packet
+	        this.transport.sid = this.id;
+	        this.sendPacket("open", JSON.stringify({
+	            sid: this.id,
+	            upgrades: this.getAvailableUpgrades(),
+	            pingInterval: this.server.opts.pingInterval,
+	            pingTimeout: this.server.opts.pingTimeout,
+	            maxPayload: this.server.opts.maxHttpBufferSize,
+	        }));
+	        if (this.server.opts.initialPacket) {
+	            this.sendPacket("message", this.server.opts.initialPacket);
+	        }
+	        this.emit("open");
+	        if (this.protocol === 3) {
+	            // in protocol v3, the client sends a ping, and the server answers with a pong
+	            this.resetPingTimeout();
+	        }
+	        else {
+	            // in protocol v4, the server sends a ping, and the client answers with a pong
+	            this.schedulePing();
+	        }
+	    }
+	    /**
+	     * Called upon transport packet.
+	     *
+	     * @param {Object} packet
+	     * @private
+	     */
+	    onPacket(packet) {
+	        if ("open" !== this.readyState) {
+	            return debug("packet received with closed socket");
+	        }
+	        // export packet event
+	        debug(`received packet ${packet.type}`);
+	        this.emit("packet", packet);
+	        switch (packet.type) {
+	            case "ping":
+	                if (this.transport.protocol !== 3) {
+	                    this.onError(new Error("invalid heartbeat direction"));
+	                    return;
+	                }
+	                debug("got ping");
+	                this.pingTimeoutTimer.refresh();
+	                this.sendPacket("pong");
+	                this.emit("heartbeat");
+	                break;
+	            case "pong":
+	                if (this.transport.protocol === 3) {
+	                    this.onError(new Error("invalid heartbeat direction"));
+	                    return;
+	                }
+	                debug("got pong");
+	                (0, timers_1.clearTimeout)(this.pingTimeoutTimer);
+	                this.pingIntervalTimer.refresh();
+	                this.emit("heartbeat");
+	                break;
+	            case "error":
+	                this.onClose("parse error");
+	                break;
+	            case "message":
+	                this.emit("data", packet.data);
+	                this.emit("message", packet.data);
+	                break;
+	        }
+	    }
+	    /**
+	     * Called upon transport error.
+	     *
+	     * @param {Error} err - error object
+	     * @private
+	     */
+	    onError(err) {
+	        debug("transport error");
+	        this.onClose("transport error", err);
+	    }
+	    /**
+	     * Pings client every `this.pingInterval` and expects response
+	     * within `this.pingTimeout` or closes connection.
+	     *
+	     * @private
+	     */
+	    schedulePing() {
+	        this.pingIntervalTimer = (0, timers_1.setTimeout)(() => {
+	            debug("writing ping packet - expecting pong within %sms", this.server.opts.pingTimeout);
+	            this.sendPacket("ping");
+	            this.resetPingTimeout();
+	        }, this.server.opts.pingInterval);
+	    }
+	    /**
+	     * Resets ping timeout.
+	     *
+	     * @private
+	     */
+	    resetPingTimeout() {
+	        (0, timers_1.clearTimeout)(this.pingTimeoutTimer);
+	        this.pingTimeoutTimer = (0, timers_1.setTimeout)(() => {
+	            if (this.readyState === "closed")
+	                return;
+	            this.onClose("ping timeout");
+	        }, this.protocol === 3
+	            ? this.server.opts.pingInterval + this.server.opts.pingTimeout
+	            : this.server.opts.pingTimeout);
+	    }
+	    /**
+	     * Attaches handlers for the given transport.
+	     *
+	     * @param {Transport} transport
+	     * @private
+	     */
+	    setTransport(transport) {
+	        const onError = this.onError.bind(this);
+	        const onReady = () => this.flush();
+	        const onPacket = this.onPacket.bind(this);
+	        const onDrain = this.onDrain.bind(this);
+	        const onClose = this.onClose.bind(this, "transport close");
+	        this.transport = transport;
+	        this.transport.once("error", onError);
+	        this.transport.on("ready", onReady);
+	        this.transport.on("packet", onPacket);
+	        this.transport.on("drain", onDrain);
+	        this.transport.once("close", onClose);
+	        this.cleanupFn.push(function () {
+	            transport.removeListener("error", onError);
+	            transport.removeListener("ready", onReady);
+	            transport.removeListener("packet", onPacket);
+	            transport.removeListener("drain", onDrain);
+	            transport.removeListener("close", onClose);
+	        });
+	    }
+	    /**
+	     * Upon transport "drain" event
+	     *
+	     * @private
+	     */
+	    onDrain() {
+	        if (this.sentCallbackFn.length > 0) {
+	            debug("executing batch send callback");
+	            const seqFn = this.sentCallbackFn.shift();
+	            if (seqFn) {
+	                for (let i = 0; i < seqFn.length; i++) {
+	                    seqFn[i](this.transport);
+	                }
+	            }
+	        }
+	    }
+	    /**
+	     * Upgrades socket to the given transport
+	     *
+	     * @param {Transport} transport
+	     * @private
+	     */
+	    /* private */ _maybeUpgrade(transport) {
+	        debug('might upgrade socket transport from "%s" to "%s"', this.transport.name, transport.name);
+	        this.upgrading = true;
+	        // set transport upgrade timer
+	        const upgradeTimeoutTimer = (0, timers_1.setTimeout)(() => {
+	            debug("client did not complete upgrade - closing transport");
+	            cleanup();
+	            if ("open" === transport.readyState) {
+	                transport.close();
+	            }
+	        }, this.server.opts.upgradeTimeout);
+	        let checkIntervalTimer;
+	        const onPacket = (packet) => {
+	            if ("ping" === packet.type && "probe" === packet.data) {
+	                debug("got probe ping packet, sending pong");
+	                transport.send([{ type: "pong", data: "probe" }]);
+	                this.emit("upgrading", transport);
+	                clearInterval(checkIntervalTimer);
+	                checkIntervalTimer = setInterval(check, 100);
+	            }
+	            else if ("upgrade" === packet.type && this.readyState !== "closed") {
+	                debug("got upgrade packet - upgrading");
+	                cleanup();
+	                this.transport.discard();
+	                this.upgraded = true;
+	                this.clearTransport();
+	                this.setTransport(transport);
+	                this.emit("upgrade", transport);
+	                this.flush();
+	                if (this.readyState === "closing") {
+	                    transport.close(() => {
+	                        this.onClose("forced close");
+	                    });
+	                }
+	            }
+	            else {
+	                cleanup();
+	                transport.close();
+	            }
+	        };
+	        // we force a polling cycle to ensure a fast upgrade
+	        const check = () => {
+	            if ("polling" === this.transport.name && this.transport.writable) {
+	                debug("writing a noop packet to polling for fast upgrade");
+	                this.transport.send([{ type: "noop" }]);
+	            }
+	        };
+	        const cleanup = () => {
+	            this.upgrading = false;
+	            clearInterval(checkIntervalTimer);
+	            (0, timers_1.clearTimeout)(upgradeTimeoutTimer);
+	            transport.removeListener("packet", onPacket);
+	            transport.removeListener("close", onTransportClose);
+	            transport.removeListener("error", onError);
+	            this.removeListener("close", onClose);
+	        };
+	        const onError = (err) => {
+	            debug("client did not complete upgrade - %s", err);
+	            cleanup();
+	            transport.close();
+	            transport = null;
+	        };
+	        const onTransportClose = () => {
+	            onError("transport closed");
+	        };
+	        const onClose = () => {
+	            onError("socket closed");
+	        };
+	        transport.on("packet", onPacket);
+	        transport.once("close", onTransportClose);
+	        transport.once("error", onError);
+	        this.once("close", onClose);
+	    }
+	    /**
+	     * Clears listeners and timers associated with current transport.
+	     *
+	     * @private
+	     */
+	    clearTransport() {
+	        let cleanup;
+	        const toCleanUp = this.cleanupFn.length;
+	        for (let i = 0; i < toCleanUp; i++) {
+	            cleanup = this.cleanupFn.shift();
+	            cleanup();
+	        }
+	        // silence further transport errors and prevent uncaught exceptions
+	        this.transport.on("error", function () {
+	            debug("error triggered by discarded transport");
+	        });
+	        // ensure transport won't stay open
+	        this.transport.close();
+	        (0, timers_1.clearTimeout)(this.pingTimeoutTimer);
+	    }
+	    /**
+	     * Called upon transport considered closed.
+	     * Possible reasons: `ping timeout`, `client error`, `parse error`,
+	     * `transport error`, `server close`, `transport close`
+	     */
+	    onClose(reason, description) {
+	        if ("closed" !== this.readyState) {
+	            this.readyState = "closed";
+	            // clear timers
+	            (0, timers_1.clearTimeout)(this.pingIntervalTimer);
+	            (0, timers_1.clearTimeout)(this.pingTimeoutTimer);
+	            // clean writeBuffer in next tick, so developers can still
+	            // grab the writeBuffer on 'close' event
+	            process.nextTick(() => {
+	                this.writeBuffer = [];
+	            });
+	            this.packetsFn = [];
+	            this.sentCallbackFn = [];
+	            this.clearTransport();
+	            this.emit("close", reason, description);
+	        }
+	    }
+	    /**
+	     * Sends a message packet.
+	     *
+	     * @param {Object} data
+	     * @param {Object} options
+	     * @param {Function} callback
+	     * @return {Socket} for chaining
+	     */
+	    send(data, options, callback) {
+	        this.sendPacket("message", data, options, callback);
+	        return this;
+	    }
+	    /**
+	     * Alias of {@link send}.
+	     *
+	     * @param data
+	     * @param options
+	     * @param callback
+	     */
+	    write(data, options, callback) {
+	        this.sendPacket("message", data, options, callback);
+	        return this;
+	    }
+	    /**
+	     * Sends a packet.
+	     *
+	     * @param {String} type - packet type
+	     * @param {String} data
+	     * @param {Object} options
+	     * @param {Function} callback
+	     *
+	     * @private
+	     */
+	    sendPacket(type, data, options = {}, callback) {
+	        if ("function" === typeof options) {
+	            callback = options;
+	            options = {};
+	        }
+	        if ("closing" !== this.readyState && "closed" !== this.readyState) {
+	            debug('sending packet "%s" (%s)', type, data);
+	            // compression is enabled by default
+	            options.compress = options.compress !== false;
+	            const packet = {
+	                type,
+	                options: options,
+	            };
+	            if (data)
+	                packet.data = data;
+	            // exports packetCreate event
+	            this.emit("packetCreate", packet);
+	            this.writeBuffer.push(packet);
+	            // add send callback to object, if defined
+	            if ("function" === typeof callback)
+	                this.packetsFn.push(callback);
+	            this.flush();
+	        }
+	    }
+	    /**
+	     * Attempts to flush the packets buffer.
+	     *
+	     * @private
+	     */
+	    flush() {
+	        if ("closed" !== this.readyState &&
+	            this.transport.writable &&
+	            this.writeBuffer.length) {
+	            debug("flushing buffer to transport");
+	            this.emit("flush", this.writeBuffer);
+	            this.server.emit("flush", this, this.writeBuffer);
+	            const wbuf = this.writeBuffer;
+	            this.writeBuffer = [];
+	            if (this.packetsFn.length) {
+	                this.sentCallbackFn.push(this.packetsFn);
+	                this.packetsFn = [];
+	            }
+	            else {
+	                this.sentCallbackFn.push(null);
+	            }
+	            this.transport.send(wbuf);
+	            this.emit("drain");
+	            this.server.emit("drain", this);
+	        }
+	    }
+	    /**
+	     * Get available upgrades for this socket.
+	     *
+	     * @private
+	     */
+	    getAvailableUpgrades() {
+	        const availableUpgrades = [];
+	        const allUpgrades = this.server.upgrades(this.transport.name);
+	        for (let i = 0; i < allUpgrades.length; ++i) {
+	            const upg = allUpgrades[i];
+	            if (this.server.opts.transports.indexOf(upg) !== -1) {
+	                availableUpgrades.push(upg);
+	            }
+	        }
+	        return availableUpgrades;
+	    }
+	    /**
+	     * Closes the socket and underlying transport.
+	     *
+	     * @param {Boolean} discard - optional, discard the transport
+	     * @return {Socket} for chaining
+	     */
+	    close(discard) {
+	        if (discard &&
+	            (this.readyState === "open" || this.readyState === "closing")) {
+	            return this.closeTransport(discard);
+	        }
+	        if ("open" !== this.readyState)
+	            return;
+	        this.readyState = "closing";
+	        if (this.writeBuffer.length) {
+	            debug("there are %d remaining packets in the buffer, waiting for the 'drain' event", this.writeBuffer.length);
+	            this.once("drain", () => {
+	                debug("all packets have been sent, closing the transport");
+	                this.closeTransport(discard);
+	            });
+	            return;
+	        }
+	        debug("the buffer is empty, closing the transport right away");
+	        this.closeTransport(discard);
+	    }
+	    /**
+	     * Closes the underlying transport.
+	     *
+	     * @param {Boolean} discard
+	     * @private
+	     */
+	    closeTransport(discard) {
+	        debug("closing the transport (discard? %s)", !!discard);
+	        if (discard)
+	            this.transport.discard();
+	        this.transport.close(this.onClose.bind(this, "forced close"));
+	    }
+	}
+	socket.Socket = Socket;
+	return socket;
+}
+
+export { requireSocket as __require };

package/dist/src/node_modules/engine.io/build/transport.js

@@ -0,0 +1,131 @@
+import { __exports as transport } from '../../../_virtual/transport.js';
+import require$$0 from 'events';
+import { __require as requireCjs } from '../../engine.io-parser/build/cjs/index.js';
+import { __require as requireParserV3 } from './parser-v3/index.js';
+import { __require as requireSrc } from '../node_modules/debug/src/index.js';
+
+var hasRequiredTransport;
+
+function requireTransport () {
+	if (hasRequiredTransport) return transport;
+	hasRequiredTransport = 1;
+	Object.defineProperty(transport, "__esModule", { value: true });
+	transport.Transport = void 0;
+	const events_1 = require$$0;
+	const parser_v4 = requireCjs();
+	const parser_v3 = requireParserV3();
+	const debug_1 = requireSrc();
+	const debug = (0, debug_1.default)("engine:transport");
+	function noop() { }
+	class Transport extends events_1.EventEmitter {
+	    get readyState() {
+	        return this._readyState;
+	    }
+	    set readyState(state) {
+	        debug("readyState updated from %s to %s (%s)", this._readyState, state, this.name);
+	        this._readyState = state;
+	    }
+	    /**
+	     * Transport constructor.
+	     *
+	     * @param {EngineRequest} req
+	     */
+	    constructor(req) {
+	        super();
+	        /**
+	         * Whether the transport is currently ready to send packets.
+	         */
+	        this.writable = false;
+	        /**
+	         * The current state of the transport.
+	         * @protected
+	         */
+	        this._readyState = "open";
+	        /**
+	         * Whether the transport is discarded and can be safely closed (used during upgrade).
+	         * @protected
+	         */
+	        this.discarded = false;
+	        this.protocol = req._query.EIO === "4" ? 4 : 3; // 3rd revision by default
+	        this.parser = this.protocol === 4 ? parser_v4 : parser_v3;
+	        this.supportsBinary = !(req._query && req._query.b64);
+	    }
+	    /**
+	     * Flags the transport as discarded.
+	     *
+	     * @package
+	     */
+	    discard() {
+	        this.discarded = true;
+	    }
+	    /**
+	     * Called with an incoming HTTP request.
+	     *
+	     * @param req
+	     * @package
+	     */
+	    onRequest(req) { }
+	    /**
+	     * Closes the transport.
+	     *
+	     * @package
+	     */
+	    close(fn) {
+	        if ("closed" === this.readyState || "closing" === this.readyState)
+	            return;
+	        this.readyState = "closing";
+	        this.doClose(fn || noop);
+	    }
+	    /**
+	     * Called with a transport error.
+	     *
+	     * @param {String} msg - message error
+	     * @param {Object} desc - error description
+	     * @protected
+	     */
+	    onError(msg, desc) {
+	        if (this.listeners("error").length) {
+	            const err = new Error(msg);
+	            // @ts-ignore
+	            err.type = "TransportError";
+	            // @ts-ignore
+	            err.description = desc;
+	            this.emit("error", err);
+	        }
+	        else {
+	            debug("ignored transport error %s (%s)", msg, desc);
+	        }
+	    }
+	    /**
+	     * Called with parsed out a packets from the data stream.
+	     *
+	     * @param {Object} packet
+	     * @protected
+	     */
+	    onPacket(packet) {
+	        this.emit("packet", packet);
+	    }
+	    /**
+	     * Called with the encoded packet data.
+	     *
+	     * @param {String} data
+	     * @protected
+	     */
+	    onData(data) {
+	        this.onPacket(this.parser.decodePacket(data));
+	    }
+	    /**
+	     * Called upon transport close.
+	     *
+	     * @protected
+	     */
+	    onClose() {
+	        this.readyState = "closed";
+	        this.emit("close");
+	    }
+	}
+	transport.Transport = Transport;
+	return transport;
+}
+
+export { requireTransport as __require };

package/dist/src/node_modules/engine.io/build/transports/index.js

@@ -0,0 +1,37 @@
+import { __exports as transports } from '../../../../_virtual/index15.js';
+import { __require as requirePolling } from './polling.js';
+import { __require as requirePollingJsonp } from './polling-jsonp.js';
+import { __require as requireWebsocket } from './websocket.js';
+import { __require as requireWebtransport } from './webtransport.js';
+
+var hasRequiredTransports;
+
+function requireTransports () {
+	if (hasRequiredTransports) return transports;
+	hasRequiredTransports = 1;
+	Object.defineProperty(transports, "__esModule", { value: true });
+	const polling_1 = requirePolling();
+	const polling_jsonp_1 = requirePollingJsonp();
+	const websocket_1 = requireWebsocket();
+	const webtransport_1 = requireWebtransport();
+	transports.default = {
+	    polling: polling,
+	    websocket: websocket_1.WebSocket,
+	    webtransport: webtransport_1.WebTransport,
+	};
+	/**
+	 * Polling polymorphic constructor.
+	 */
+	function polling(req) {
+	    if ("string" === typeof req._query.j) {
+	        return new polling_jsonp_1.JSONP(req);
+	    }
+	    else {
+	        return new polling_1.Polling(req);
+	    }
+	}
+	polling.upgradesTo = ["websocket", "webtransport"];
+	return transports;
+}
+
+export { requireTransports as __require };

package/dist/src/node_modules/engine.io/build/transports/polling-jsonp.js

@@ -0,0 +1,53 @@
+import { __exports as pollingJsonp } from '../../../../_virtual/polling-jsonp.js';
+import { __require as requirePolling } from './polling.js';
+import require$$1 from 'querystring';
+
+var hasRequiredPollingJsonp;
+
+function requirePollingJsonp () {
+	if (hasRequiredPollingJsonp) return pollingJsonp;
+	hasRequiredPollingJsonp = 1;
+	Object.defineProperty(pollingJsonp, "__esModule", { value: true });
+	pollingJsonp.JSONP = void 0;
+	const polling_1 = requirePolling();
+	const qs = require$$1;
+	const rDoubleSlashes = /\\\\n/g;
+	const rSlashes = /(\\)?\\n/g;
+	class JSONP extends polling_1.Polling {
+	    /**
+	     * JSON-P polling transport.
+	     */
+	    constructor(req) {
+	        super(req);
+	        this.head = "___eio[" + (req._query.j || "").replace(/[^0-9]/g, "") + "](";
+	        this.foot = ");";
+	    }
+	    onData(data) {
+	        // we leverage the qs module so that we get built-in DoS protection
+	        // and the fast alternative to decodeURIComponent
+	        data = qs.parse(data).d;
+	        if ("string" === typeof data) {
+	            // client will send already escaped newlines as \\\\n and newlines as \\n
+	            // \\n must be replaced with \n and \\\\n with \\n
+	            data = data.replace(rSlashes, function (match, slashes) {
+	                return slashes ? match : "\n";
+	            });
+	            super.onData(data.replace(rDoubleSlashes, "\\n"));
+	        }
+	    }
+	    doWrite(data, options, callback) {
+	        // we must output valid javascript, not valid json
+	        // see: http://timelessrepo.com/json-isnt-a-javascript-subset
+	        const js = JSON.stringify(data)
+	            .replace(/\u2028/g, "\\u2028")
+	            .replace(/\u2029/g, "\\u2029");
+	        // prepare response
+	        data = this.head + js + this.foot;
+	        super.doWrite(data, options, callback);
+	    }
+	}
+	pollingJsonp.JSONP = JSONP;
+	return pollingJsonp;
+}
+
+export { requirePollingJsonp as __require };