@wabot-dev/framework 0.0.12 → 0.0.14

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

@@ -0,0 +1,292 @@
+import { __exports as userver } from '../../../_virtual/userver.js';
+import { __require as requireSrc } from '../node_modules/debug/src/index.js';
+import { __require as requireServer } from './server.js';
+import { __require as requireTransportsUws } from './transports-uws/index.js';
+
+var hasRequiredUserver;
+
+function requireUserver () {
+	if (hasRequiredUserver) return userver;
+	hasRequiredUserver = 1;
+	Object.defineProperty(userver, "__esModule", { value: true });
+	userver.uServer = void 0;
+	const debug_1 = requireSrc();
+	const server_1 = requireServer();
+	const transports_uws_1 = requireTransportsUws();
+	const debug = (0, debug_1.default)("engine:uws");
+	/**
+	 * An Engine.IO server based on the `uWebSockets.js` package.
+	 */
+	// TODO export it into its own package
+	class uServer extends server_1.BaseServer {
+	    init() { }
+	    cleanup() { }
+	    /**
+	     * Prepares a request by processing the query string.
+	     *
+	     * @private
+	     */
+	    prepare(req, res) {
+	        req.method = req.getMethod().toUpperCase();
+	        req.url = req.getUrl();
+	        const params = new URLSearchParams(req.getQuery());
+	        req._query = Object.fromEntries(params.entries());
+	        req.headers = {};
+	        req.forEach((key, value) => {
+	            req.headers[key] = value;
+	        });
+	        req.connection = {
+	            remoteAddress: Buffer.from(res.getRemoteAddressAsText()).toString(),
+	        };
+	        res.onAborted(() => {
+	            debug("response has been aborted");
+	        });
+	    }
+	    createTransport(transportName, req) {
+	        return new transports_uws_1.default[transportName](req);
+	    }
+	    /**
+	     * Attach the engine to a µWebSockets.js server
+	     * @param app
+	     * @param options
+	     */
+	    attach(app /* : TemplatedApp */, options = {}) {
+	        const path = this._computePath(options);
+	        app
+	            .any(path, this.handleRequest.bind(this))
+	            //
+	            .ws(path, {
+	            compression: options.compression,
+	            idleTimeout: options.idleTimeout,
+	            maxBackpressure: options.maxBackpressure,
+	            maxPayloadLength: this.opts.maxHttpBufferSize,
+	            upgrade: this.handleUpgrade.bind(this),
+	            open: (ws) => {
+	                const transport = ws.getUserData().transport;
+	                transport.socket = ws;
+	                transport.writable = true;
+	                transport.emit("ready");
+	            },
+	            message: (ws, message, isBinary) => {
+	                ws.getUserData().transport.onData(isBinary ? message : Buffer.from(message).toString());
+	            },
+	            close: (ws, code, message) => {
+	                ws.getUserData().transport.onClose(code, message);
+	            },
+	        });
+	    }
+	    _applyMiddlewares(req, res, callback) {
+	        if (this.middlewares.length === 0) {
+	            return callback();
+	        }
+	        // needed to buffer headers until the status is computed
+	        req.res = new ResponseWrapper(res);
+	        super._applyMiddlewares(req, req.res, (err) => {
+	            // some middlewares (like express-session) wait for the writeHead() call to flush their headers
+	            // see https://github.com/expressjs/session/blob/1010fadc2f071ddf2add94235d72224cf65159c6/index.js#L220-L244
+	            req.res.writeHead();
+	            callback(err);
+	        });
+	    }
+	    handleRequest(res, req) {
+	        debug('handling "%s" http request "%s"', req.getMethod(), req.getUrl());
+	        this.prepare(req, res);
+	        req.res = res;
+	        const callback = (errorCode, errorContext) => {
+	            if (errorCode !== undefined) {
+	                this.emit("connection_error", {
+	                    req,
+	                    code: errorCode,
+	                    message: server_1.Server.errorMessages[errorCode],
+	                    context: errorContext,
+	                });
+	                this.abortRequest(req.res, errorCode, errorContext);
+	                return;
+	            }
+	            if (req._query.sid) {
+	                debug("setting new request for existing client");
+	                // @ts-ignore
+	                this.clients[req._query.sid].transport.onRequest(req);
+	            }
+	            else {
+	                const closeConnection = (errorCode, errorContext) => this.abortRequest(res, errorCode, errorContext);
+	                this.handshake(req._query.transport, req, closeConnection);
+	            }
+	        };
+	        this._applyMiddlewares(req, res, (err) => {
+	            if (err) {
+	                callback(server_1.Server.errors.BAD_REQUEST, { name: "MIDDLEWARE_FAILURE" });
+	            }
+	            else {
+	                this.verify(req, false, callback);
+	            }
+	        });
+	    }
+	    handleUpgrade(res, req, context) {
+	        debug("on upgrade");
+	        this.prepare(req, res);
+	        req.res = res;
+	        const callback = async (errorCode, errorContext) => {
+	            if (errorCode !== undefined) {
+	                this.emit("connection_error", {
+	                    req,
+	                    code: errorCode,
+	                    message: server_1.Server.errorMessages[errorCode],
+	                    context: errorContext,
+	                });
+	                this.abortRequest(res, errorCode, errorContext);
+	                return;
+	            }
+	            const id = req._query.sid;
+	            let transport;
+	            if (id) {
+	                const client = this.clients[id];
+	                if (!client) {
+	                    debug("upgrade attempt for closed client");
+	                    return res.close();
+	                }
+	                else if (client.upgrading) {
+	                    debug("transport has already been trying to upgrade");
+	                    return res.close();
+	                }
+	                else if (client.upgraded) {
+	                    debug("transport had already been upgraded");
+	                    return res.close();
+	                }
+	                else {
+	                    debug("upgrading existing transport");
+	                    transport = this.createTransport(req._query.transport, req);
+	                    client._maybeUpgrade(transport);
+	                }
+	            }
+	            else {
+	                transport = await this.handshake(req._query.transport, req, (errorCode, errorContext) => this.abortRequest(res, errorCode, errorContext));
+	                if (!transport) {
+	                    return;
+	                }
+	            }
+	            // calling writeStatus() triggers the flushing of any header added in a middleware
+	            req.res.writeStatus("101 Switching Protocols");
+	            res.upgrade({
+	                transport,
+	            }, req.getHeader("sec-websocket-key"), req.getHeader("sec-websocket-protocol"), req.getHeader("sec-websocket-extensions"), context);
+	        };
+	        this._applyMiddlewares(req, res, (err) => {
+	            if (err) {
+	                callback(server_1.Server.errors.BAD_REQUEST, { name: "MIDDLEWARE_FAILURE" });
+	            }
+	            else {
+	                this.verify(req, true, callback);
+	            }
+	        });
+	    }
+	    abortRequest(res, errorCode, errorContext) {
+	        const statusCode = errorCode === server_1.Server.errors.FORBIDDEN
+	            ? "403 Forbidden"
+	            : "400 Bad Request";
+	        const message = errorContext && errorContext.message
+	            ? errorContext.message
+	            : server_1.Server.errorMessages[errorCode];
+	        res.writeStatus(statusCode);
+	        res.writeHeader("Content-Type", "application/json");
+	        res.end(JSON.stringify({
+	            code: errorCode,
+	            message,
+	        }));
+	    }
+	}
+	userver.uServer = uServer;
+	class ResponseWrapper {
+	    constructor(res) {
+	        this.res = res;
+	        this.statusWritten = false;
+	        this.headers = [];
+	        this.isAborted = false;
+	    }
+	    set statusCode(status) {
+	        if (!status) {
+	            return;
+	        }
+	        // FIXME: handle all status codes?
+	        this.writeStatus(status === 200 ? "200 OK" : "204 No Content");
+	    }
+	    writeHead(status) {
+	        this.statusCode = status;
+	    }
+	    setHeader(key, value) {
+	        if (Array.isArray(value)) {
+	            value.forEach((val) => {
+	                this.writeHeader(key, val);
+	            });
+	        }
+	        else {
+	            this.writeHeader(key, value);
+	        }
+	    }
+	    removeHeader() {
+	        // FIXME: not implemented
+	    }
+	    // needed by vary: https://github.com/jshttp/vary/blob/5d725d059b3871025cf753e9dfa08924d0bcfa8f/index.js#L134
+	    getHeader() { }
+	    writeStatus(status) {
+	        if (this.isAborted)
+	            return;
+	        this.res.writeStatus(status);
+	        this.statusWritten = true;
+	        this.writeBufferedHeaders();
+	        return this;
+	    }
+	    writeHeader(key, value) {
+	        if (this.isAborted)
+	            return;
+	        if (key === "Content-Length") {
+	            // the content length is automatically added by uWebSockets.js
+	            return;
+	        }
+	        if (this.statusWritten) {
+	            this.res.writeHeader(key, value);
+	        }
+	        else {
+	            this.headers.push([key, value]);
+	        }
+	    }
+	    writeBufferedHeaders() {
+	        this.headers.forEach(([key, value]) => {
+	            this.res.writeHeader(key, value);
+	        });
+	    }
+	    end(data) {
+	        if (this.isAborted)
+	            return;
+	        this.res.cork(() => {
+	            if (!this.statusWritten) {
+	                // status will be inferred as "200 OK"
+	                this.writeBufferedHeaders();
+	            }
+	            this.res.end(data);
+	        });
+	    }
+	    onData(fn) {
+	        if (this.isAborted)
+	            return;
+	        this.res.onData(fn);
+	    }
+	    onAborted(fn) {
+	        if (this.isAborted)
+	            return;
+	        this.res.onAborted(() => {
+	            // Any attempt to use the UWS response object after abort will throw!
+	            this.isAborted = true;
+	            fn();
+	        });
+	    }
+	    cork(fn) {
+	        if (this.isAborted)
+	            return;
+	        this.res.cork(fn);
+	    }
+	}
+	return userver;
+}
+
+export { requireUserver as __require };

package/dist/src/node_modules/engine.io/node_modules/accepts/index.js

@@ -0,0 +1,250 @@
+import { __require as requireNegotiator } from '../negotiator/index.js';
+import { __require as requireMimeTypes } from '../mime-types/index.js';
+
+/*!
+ * accepts
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var accepts;
+var hasRequiredAccepts;
+
+function requireAccepts () {
+	if (hasRequiredAccepts) return accepts;
+	hasRequiredAccepts = 1;
+
+	/**
+	 * Module dependencies.
+	 * @private
+	 */
+
+	var Negotiator = requireNegotiator();
+	var mime = requireMimeTypes();
+
+	/**
+	 * Module exports.
+	 * @public
+	 */
+
+	accepts = Accepts;
+
+	/**
+	 * Create a new Accepts object for the given req.
+	 *
+	 * @param {object} req
+	 * @public
+	 */
+
+	function Accepts (req) {
+	  if (!(this instanceof Accepts)) {
+	    return new Accepts(req)
+	  }
+
+	  this.headers = req.headers;
+	  this.negotiator = new Negotiator(req);
+	}
+
+	/**
+	 * Check if the given `type(s)` is acceptable, returning
+	 * the best match when true, otherwise `undefined`, in which
+	 * case you should respond with 406 "Not Acceptable".
+	 *
+	 * The `type` value may be a single mime type string
+	 * such as "application/json", the extension name
+	 * such as "json" or an array `["json", "html", "text/plain"]`. When a list
+	 * or array is given the _best_ match, if any is returned.
+	 *
+	 * Examples:
+	 *
+	 *     // Accept: text/html
+	 *     this.types('html');
+	 *     // => "html"
+	 *
+	 *     // Accept: text/*, application/json
+	 *     this.types('html');
+	 *     // => "html"
+	 *     this.types('text/html');
+	 *     // => "text/html"
+	 *     this.types('json', 'text');
+	 *     // => "json"
+	 *     this.types('application/json');
+	 *     // => "application/json"
+	 *
+	 *     // Accept: text/*, application/json
+	 *     this.types('image/png');
+	 *     this.types('png');
+	 *     // => undefined
+	 *
+	 *     // Accept: text/*;q=.5, application/json
+	 *     this.types(['html', 'json']);
+	 *     this.types('html', 'json');
+	 *     // => "json"
+	 *
+	 * @param {String|Array} types...
+	 * @return {String|Array|Boolean}
+	 * @public
+	 */
+
+	Accepts.prototype.type =
+	Accepts.prototype.types = function (types_) {
+	  var types = types_;
+
+	  // support flattened arguments
+	  if (types && !Array.isArray(types)) {
+	    types = new Array(arguments.length);
+	    for (var i = 0; i < types.length; i++) {
+	      types[i] = arguments[i];
+	    }
+	  }
+
+	  // no types, return all requested types
+	  if (!types || types.length === 0) {
+	    return this.negotiator.mediaTypes()
+	  }
+
+	  // no accept header, return first given type
+	  if (!this.headers.accept) {
+	    return types[0]
+	  }
+
+	  var mimes = types.map(extToMime);
+	  var accepts = this.negotiator.mediaTypes(mimes.filter(validMime));
+	  var first = accepts[0];
+
+	  return first
+	    ? types[mimes.indexOf(first)]
+	    : false
+	};
+
+	/**
+	 * Return accepted encodings or best fit based on `encodings`.
+	 *
+	 * Given `Accept-Encoding: gzip, deflate`
+	 * an array sorted by quality is returned:
+	 *
+	 *     ['gzip', 'deflate']
+	 *
+	 * @param {String|Array} encodings...
+	 * @return {String|Array}
+	 * @public
+	 */
+
+	Accepts.prototype.encoding =
+	Accepts.prototype.encodings = function (encodings_) {
+	  var encodings = encodings_;
+
+	  // support flattened arguments
+	  if (encodings && !Array.isArray(encodings)) {
+	    encodings = new Array(arguments.length);
+	    for (var i = 0; i < encodings.length; i++) {
+	      encodings[i] = arguments[i];
+	    }
+	  }
+
+	  // no encodings, return all requested encodings
+	  if (!encodings || encodings.length === 0) {
+	    return this.negotiator.encodings()
+	  }
+
+	  return this.negotiator.encodings(encodings)[0] || false
+	};
+
+	/**
+	 * Return accepted charsets or best fit based on `charsets`.
+	 *
+	 * Given `Accept-Charset: utf-8, iso-8859-1;q=0.2, utf-7;q=0.5`
+	 * an array sorted by quality is returned:
+	 *
+	 *     ['utf-8', 'utf-7', 'iso-8859-1']
+	 *
+	 * @param {String|Array} charsets...
+	 * @return {String|Array}
+	 * @public
+	 */
+
+	Accepts.prototype.charset =
+	Accepts.prototype.charsets = function (charsets_) {
+	  var charsets = charsets_;
+
+	  // support flattened arguments
+	  if (charsets && !Array.isArray(charsets)) {
+	    charsets = new Array(arguments.length);
+	    for (var i = 0; i < charsets.length; i++) {
+	      charsets[i] = arguments[i];
+	    }
+	  }
+
+	  // no charsets, return all requested charsets
+	  if (!charsets || charsets.length === 0) {
+	    return this.negotiator.charsets()
+	  }
+
+	  return this.negotiator.charsets(charsets)[0] || false
+	};
+
+	/**
+	 * Return accepted languages or best fit based on `langs`.
+	 *
+	 * Given `Accept-Language: en;q=0.8, es, pt`
+	 * an array sorted by quality is returned:
+	 *
+	 *     ['es', 'pt', 'en']
+	 *
+	 * @param {String|Array} langs...
+	 * @return {Array|String}
+	 * @public
+	 */
+
+	Accepts.prototype.lang =
+	Accepts.prototype.langs =
+	Accepts.prototype.language =
+	Accepts.prototype.languages = function (languages_) {
+	  var languages = languages_;
+
+	  // support flattened arguments
+	  if (languages && !Array.isArray(languages)) {
+	    languages = new Array(arguments.length);
+	    for (var i = 0; i < languages.length; i++) {
+	      languages[i] = arguments[i];
+	    }
+	  }
+
+	  // no languages, return all requested languages
+	  if (!languages || languages.length === 0) {
+	    return this.negotiator.languages()
+	  }
+
+	  return this.negotiator.languages(languages)[0] || false
+	};
+
+	/**
+	 * Convert extnames to mime.
+	 *
+	 * @param {String} type
+	 * @return {String}
+	 * @private
+	 */
+
+	function extToMime (type) {
+	  return type.indexOf('/') === -1
+	    ? mime.lookup(type)
+	    : type
+	}
+
+	/**
+	 * Check if mime is valid.
+	 *
+	 * @param {String} type
+	 * @return {String}
+	 * @private
+	 */
+
+	function validMime (type) {
+	  return typeof type === 'string'
+	}
+	return accepts;
+}
+
+export { requireAccepts as __require };