@wabot-dev/framework 0.0.12 → 0.0.14

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

@@ -0,0 +1,346 @@
+import { __exports as polling } from '../../../../_virtual/polling.js';
+import { __require as requireTransport } from '../transport.js';
+import require$$0 from 'zlib';
+import { __require as requireAccepts } from '../../node_modules/accepts/index.js';
+import { __require as requireSrc } from '../../node_modules/debug/src/index.js';
+
+var hasRequiredPolling;
+
+function requirePolling () {
+	if (hasRequiredPolling) return polling;
+	hasRequiredPolling = 1;
+	Object.defineProperty(polling, "__esModule", { value: true });
+	polling.Polling = void 0;
+	const transport_1 = requireTransport();
+	const zlib_1 = require$$0;
+	const accepts = requireAccepts();
+	const debug_1 = requireSrc();
+	const debug = (0, debug_1.default)("engine:polling");
+	const compressionMethods = {
+	    gzip: zlib_1.createGzip,
+	    deflate: zlib_1.createDeflate,
+	};
+	class Polling extends transport_1.Transport {
+	    /**
+	     * HTTP polling constructor.
+	     */
+	    constructor(req) {
+	        super(req);
+	        this.closeTimeout = 30 * 1000;
+	    }
+	    /**
+	     * Transport name
+	     */
+	    get name() {
+	        return "polling";
+	    }
+	    /**
+	     * Overrides onRequest.
+	     *
+	     * @param {EngineRequest} req
+	     * @package
+	     */
+	    onRequest(req) {
+	        const res = req.res;
+	        // remove the reference to the ServerResponse object (as the first request of the session is kept in memory by default)
+	        req.res = null;
+	        if ("GET" === req.method) {
+	            this.onPollRequest(req, res);
+	        }
+	        else if ("POST" === req.method) {
+	            this.onDataRequest(req, res);
+	        }
+	        else {
+	            res.writeHead(500);
+	            res.end();
+	        }
+	    }
+	    /**
+	     * The client sends a request awaiting for us to send data.
+	     *
+	     * @private
+	     */
+	    onPollRequest(req, res) {
+	        if (this.req) {
+	            debug("request overlap");
+	            // assert: this.res, '.req and .res should be (un)set together'
+	            this.onError("overlap from client");
+	            res.writeHead(400);
+	            res.end();
+	            return;
+	        }
+	        debug("setting request");
+	        this.req = req;
+	        this.res = res;
+	        const onClose = () => {
+	            this.onError("poll connection closed prematurely");
+	        };
+	        const cleanup = () => {
+	            req.removeListener("close", onClose);
+	            this.req = this.res = null;
+	        };
+	        req.cleanup = cleanup;
+	        req.on("close", onClose);
+	        this.writable = true;
+	        this.emit("ready");
+	        // if we're still writable but had a pending close, trigger an empty send
+	        if (this.writable && this.shouldClose) {
+	            debug("triggering empty send to append close packet");
+	            this.send([{ type: "noop" }]);
+	        }
+	    }
+	    /**
+	     * The client sends a request with data.
+	     *
+	     * @private
+	     */
+	    onDataRequest(req, res) {
+	        if (this.dataReq) {
+	            // assert: this.dataRes, '.dataReq and .dataRes should be (un)set together'
+	            this.onError("data request overlap from client");
+	            res.writeHead(400);
+	            res.end();
+	            return;
+	        }
+	        const isBinary = "application/octet-stream" === req.headers["content-type"];
+	        if (isBinary && this.protocol === 4) {
+	            return this.onError("invalid content");
+	        }
+	        this.dataReq = req;
+	        this.dataRes = res;
+	        let chunks = isBinary ? Buffer.concat([]) : "";
+	        const cleanup = () => {
+	            req.removeListener("data", onData);
+	            req.removeListener("end", onEnd);
+	            req.removeListener("close", onClose);
+	            this.dataReq = this.dataRes = chunks = null;
+	        };
+	        const onClose = () => {
+	            cleanup();
+	            this.onError("data request connection closed prematurely");
+	        };
+	        const onData = (data) => {
+	            let contentLength;
+	            if (isBinary) {
+	                chunks = Buffer.concat([chunks, data]);
+	                contentLength = chunks.length;
+	            }
+	            else {
+	                chunks += data;
+	                contentLength = Buffer.byteLength(chunks);
+	            }
+	            if (contentLength > this.maxHttpBufferSize) {
+	                res.writeHead(413).end();
+	                cleanup();
+	            }
+	        };
+	        const onEnd = () => {
+	            this.onData(chunks);
+	            const headers = {
+	                // text/html is required instead of text/plain to avoid an
+	                // unwanted download dialog on certain user-agents (GH-43)
+	                "Content-Type": "text/html",
+	                "Content-Length": "2",
+	            };
+	            res.writeHead(200, this.headers(req, headers));
+	            res.end("ok");
+	            cleanup();
+	        };
+	        req.on("close", onClose);
+	        if (!isBinary)
+	            req.setEncoding("utf8");
+	        req.on("data", onData);
+	        req.on("end", onEnd);
+	    }
+	    /**
+	     * Processes the incoming data payload.
+	     *
+	     * @param data - encoded payload
+	     * @protected
+	     */
+	    onData(data) {
+	        debug('received "%s"', data);
+	        const callback = (packet) => {
+	            if ("close" === packet.type) {
+	                debug("got xhr close packet");
+	                this.onClose();
+	                return false;
+	            }
+	            this.onPacket(packet);
+	        };
+	        if (this.protocol === 3) {
+	            this.parser.decodePayload(data, callback);
+	        }
+	        else {
+	            this.parser.decodePayload(data).forEach(callback);
+	        }
+	    }
+	    /**
+	     * Overrides onClose.
+	     *
+	     * @private
+	     */
+	    onClose() {
+	        if (this.writable) {
+	            // close pending poll request
+	            this.send([{ type: "noop" }]);
+	        }
+	        super.onClose();
+	    }
+	    send(packets) {
+	        this.writable = false;
+	        if (this.shouldClose) {
+	            debug("appending close packet to payload");
+	            packets.push({ type: "close" });
+	            this.shouldClose();
+	            this.shouldClose = null;
+	        }
+	        const doWrite = (data) => {
+	            const compress = packets.some((packet) => {
+	                return packet.options && packet.options.compress;
+	            });
+	            this.write(data, { compress });
+	        };
+	        if (this.protocol === 3) {
+	            this.parser.encodePayload(packets, this.supportsBinary, doWrite);
+	        }
+	        else {
+	            this.parser.encodePayload(packets, doWrite);
+	        }
+	    }
+	    /**
+	     * Writes data as response to poll request.
+	     *
+	     * @param {String} data
+	     * @param {Object} options
+	     * @private
+	     */
+	    write(data, options) {
+	        debug('writing "%s"', data);
+	        this.doWrite(data, options, () => {
+	            this.req.cleanup();
+	            this.emit("drain");
+	        });
+	    }
+	    /**
+	     * Performs the write.
+	     *
+	     * @protected
+	     */
+	    doWrite(data, options, callback) {
+	        // explicit UTF-8 is required for pages not served under utf
+	        const isString = typeof data === "string";
+	        const contentType = isString
+	            ? "text/plain; charset=UTF-8"
+	            : "application/octet-stream";
+	        const headers = {
+	            "Content-Type": contentType,
+	        };
+	        const respond = (data) => {
+	            headers["Content-Length"] =
+	                "string" === typeof data ? Buffer.byteLength(data) : data.length;
+	            this.res.writeHead(200, this.headers(this.req, headers));
+	            this.res.end(data);
+	            callback();
+	        };
+	        if (!this.httpCompression || !options.compress) {
+	            respond(data);
+	            return;
+	        }
+	        const len = isString ? Buffer.byteLength(data) : data.length;
+	        if (len < this.httpCompression.threshold) {
+	            respond(data);
+	            return;
+	        }
+	        const encoding = accepts(this.req).encodings(["gzip", "deflate"]);
+	        if (!encoding) {
+	            respond(data);
+	            return;
+	        }
+	        this.compress(data, encoding, (err, data) => {
+	            if (err) {
+	                this.res.writeHead(500);
+	                this.res.end();
+	                callback(err);
+	                return;
+	            }
+	            headers["Content-Encoding"] = encoding;
+	            respond(data);
+	        });
+	    }
+	    /**
+	     * Compresses data.
+	     *
+	     * @private
+	     */
+	    compress(data, encoding, callback) {
+	        debug("compressing");
+	        const buffers = [];
+	        let nread = 0;
+	        compressionMethods[encoding](this.httpCompression)
+	            .on("error", callback)
+	            .on("data", function (chunk) {
+	            buffers.push(chunk);
+	            nread += chunk.length;
+	        })
+	            .on("end", function () {
+	            callback(null, Buffer.concat(buffers, nread));
+	        })
+	            .end(data);
+	    }
+	    /**
+	     * Closes the transport.
+	     *
+	     * @private
+	     */
+	    doClose(fn) {
+	        debug("closing");
+	        let closeTimeoutTimer;
+	        if (this.dataReq) {
+	            debug("aborting ongoing data request");
+	            this.dataReq.destroy();
+	        }
+	        const onClose = () => {
+	            clearTimeout(closeTimeoutTimer);
+	            fn();
+	            this.onClose();
+	        };
+	        if (this.writable) {
+	            debug("transport writable - closing right away");
+	            this.send([{ type: "close" }]);
+	            onClose();
+	        }
+	        else if (this.discarded) {
+	            debug("transport discarded - closing right away");
+	            onClose();
+	        }
+	        else {
+	            debug("transport not writable - buffering orderly close");
+	            this.shouldClose = onClose;
+	            closeTimeoutTimer = setTimeout(onClose, this.closeTimeout);
+	        }
+	    }
+	    /**
+	     * Returns headers for a response.
+	     *
+	     * @param {http.IncomingMessage} req
+	     * @param {Object} headers - extra headers
+	     * @private
+	     */
+	    headers(req, headers = {}) {
+	        // prevent XSS warnings on IE
+	        // https://github.com/LearnBoost/socket.io/pull/1333
+	        const ua = req.headers["user-agent"];
+	        if (ua && (~ua.indexOf(";MSIE") || ~ua.indexOf("Trident/"))) {
+	            headers["X-XSS-Protection"] = "0";
+	        }
+	        headers["cache-control"] = "no-store";
+	        this.emit("headers", headers, req);
+	        return headers;
+	    }
+	}
+	polling.Polling = Polling;
+	return polling;
+}
+
+export { requirePolling as __require };

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

@@ -0,0 +1,106 @@
+import { __exports as websocket } from '../../../../_virtual/websocket2.js';
+import { __require as requireTransport } from '../transport.js';
+import { __require as requireSrc } from '../../node_modules/debug/src/index.js';
+
+var hasRequiredWebsocket;
+
+function requireWebsocket () {
+	if (hasRequiredWebsocket) return websocket;
+	hasRequiredWebsocket = 1;
+	Object.defineProperty(websocket, "__esModule", { value: true });
+	websocket.WebSocket = void 0;
+	const transport_1 = requireTransport();
+	const debug_1 = requireSrc();
+	const debug = (0, debug_1.default)("engine:ws");
+	class WebSocket extends transport_1.Transport {
+	    /**
+	     * WebSocket transport
+	     *
+	     * @param {EngineRequest} req
+	     */
+	    constructor(req) {
+	        super(req);
+	        this._doSend = (data) => {
+	            this.socket.send(data, this._onSent);
+	        };
+	        this._doSendLast = (data) => {
+	            this.socket.send(data, this._onSentLast);
+	        };
+	        this._onSent = (err) => {
+	            if (err) {
+	                this.onError("write error", err.stack);
+	            }
+	        };
+	        this._onSentLast = (err) => {
+	            if (err) {
+	                this.onError("write error", err.stack);
+	            }
+	            else {
+	                this.emit("drain");
+	                this.writable = true;
+	                this.emit("ready");
+	            }
+	        };
+	        this.socket = req.websocket;
+	        this.socket.on("message", (data, isBinary) => {
+	            const message = isBinary ? data : data.toString();
+	            debug('received "%s"', message);
+	            super.onData(message);
+	        });
+	        this.socket.once("close", this.onClose.bind(this));
+	        this.socket.on("error", this.onError.bind(this));
+	        this.writable = true;
+	        this.perMessageDeflate = null;
+	    }
+	    /**
+	     * Transport name
+	     */
+	    get name() {
+	        return "websocket";
+	    }
+	    /**
+	     * Advertise upgrade support.
+	     */
+	    get handlesUpgrades() {
+	        return true;
+	    }
+	    send(packets) {
+	        this.writable = false;
+	        for (let i = 0; i < packets.length; i++) {
+	            const packet = packets[i];
+	            const isLast = i + 1 === packets.length;
+	            if (this._canSendPreEncodedFrame(packet)) {
+	                // the WebSocket frame was computed with WebSocket.Sender.frame()
+	                // see https://github.com/websockets/ws/issues/617#issuecomment-283002469
+	                this.socket._sender.sendFrame(
+	                // @ts-ignore
+	                packet.options.wsPreEncodedFrame, isLast ? this._onSentLast : this._onSent);
+	            }
+	            else {
+	                this.parser.encodePacket(packet, this.supportsBinary, isLast ? this._doSendLast : this._doSend);
+	            }
+	        }
+	    }
+	    /**
+	     * Whether the encoding of the WebSocket frame can be skipped.
+	     * @param packet
+	     * @private
+	     */
+	    _canSendPreEncodedFrame(packet) {
+	        var _a, _b, _c;
+	        return (!this.perMessageDeflate &&
+	            typeof ((_b = (_a = this.socket) === null || _a === void 0 ? void 0 : _a._sender) === null || _b === void 0 ? void 0 : _b.sendFrame) === "function" &&
+	            // @ts-ignore
+	            ((_c = packet.options) === null || _c === void 0 ? void 0 : _c.wsPreEncodedFrame) !== undefined);
+	    }
+	    doClose(fn) {
+	        debug("closing");
+	        this.socket.close();
+	        fn && fn();
+	    }
+	}
+	websocket.WebSocket = WebSocket;
+	return websocket;
+}
+
+export { requireWebsocket as __require };

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

@@ -0,0 +1,76 @@
+import { __exports as webtransport } from '../../../../_virtual/webtransport.js';
+import { __require as requireTransport } from '../transport.js';
+import { __require as requireSrc } from '../../node_modules/debug/src/index.js';
+import { __require as requireCjs } from '../../../engine.io-parser/build/cjs/index.js';
+
+var hasRequiredWebtransport;
+
+function requireWebtransport () {
+	if (hasRequiredWebtransport) return webtransport;
+	hasRequiredWebtransport = 1;
+	Object.defineProperty(webtransport, "__esModule", { value: true });
+	webtransport.WebTransport = void 0;
+	const transport_1 = requireTransport();
+	const debug_1 = requireSrc();
+	const engine_io_parser_1 = requireCjs();
+	const debug = (0, debug_1.default)("engine:webtransport");
+	/**
+	 * Reference: https://developer.mozilla.org/en-US/docs/Web/API/WebTransport_API
+	 */
+	class WebTransport extends transport_1.Transport {
+	    constructor(session, stream, reader) {
+	        super({ _query: { EIO: "4" } });
+	        this.session = session;
+	        const transformStream = (0, engine_io_parser_1.createPacketEncoderStream)();
+	        transformStream.readable.pipeTo(stream.writable).catch(() => {
+	            debug("the stream was closed");
+	        });
+	        this.writer = transformStream.writable.getWriter();
+	        (async () => {
+	            try {
+	                while (true) {
+	                    const { value, done } = await reader.read();
+	                    if (done) {
+	                        debug("session is closed");
+	                        break;
+	                    }
+	                    debug("received chunk: %o", value);
+	                    this.onPacket(value);
+	                }
+	            }
+	            catch (e) {
+	                debug("error while reading: %s", e.message);
+	            }
+	        })();
+	        session.closed.then(() => this.onClose());
+	        this.writable = true;
+	    }
+	    get name() {
+	        return "webtransport";
+	    }
+	    async send(packets) {
+	        this.writable = false;
+	        try {
+	            for (let i = 0; i < packets.length; i++) {
+	                const packet = packets[i];
+	                await this.writer.write(packet);
+	            }
+	        }
+	        catch (e) {
+	            debug("error while writing: %s", e.message);
+	        }
+	        this.emit("drain");
+	        this.writable = true;
+	        this.emit("ready");
+	    }
+	    doClose(fn) {
+	        debug("closing WebTransport session");
+	        this.session.close();
+	        fn && fn();
+	    }
+	}
+	webtransport.WebTransport = WebTransport;
+	return webtransport;
+}
+
+export { requireWebtransport as __require };

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

@@ -0,0 +1,20 @@
+import { __exports as transportsUws } from '../../../../_virtual/index26.js';
+import { __require as requirePolling } from './polling.js';
+import { __require as requireWebsocket } from './websocket.js';
+
+var hasRequiredTransportsUws;
+
+function requireTransportsUws () {
+	if (hasRequiredTransportsUws) return transportsUws;
+	hasRequiredTransportsUws = 1;
+	Object.defineProperty(transportsUws, "__esModule", { value: true });
+	const polling_1 = requirePolling();
+	const websocket_1 = requireWebsocket();
+	transportsUws.default = {
+	    polling: polling_1.Polling,
+	    websocket: websocket_1.WebSocket,
+	};
+	return transportsUws;
+}
+
+export { requireTransportsUws as __require };