@opra/core 0.20.3 → 0.21.0

package/esm/adapter/http/impl/http-incoming-message-host.js

@@ -0,0 +1,122 @@
+/*
+  This file contains code blocks from open source NodeJs project
+  https://github.com/nodejs/
+ */
+import * as stream from 'stream';
+import { HTTPParser } from '@browsery/http-parser';
+import { isReadable } from '@opra/common';
+import { convertToHeaders, convertToHeadersDistinct } from '../helpers/convert-to-headers.js';
+import { convertToRawHeaders } from '../helpers/convert-to-raw-headers.js';
+export const CRLF = Buffer.from('\r\n');
+export const kHeaders = Symbol('kHeaders');
+export const kHeadersDistinct = Symbol('kHeadersDistinct');
+export const kTrailers = Symbol('kTrailers');
+export const kTrailersDistinct = Symbol('kTrailersDistinct');
+/**
+ *
+ * @class HttpIncomingMessageHost
+ */
+export class HttpIncomingMessageHost {
+    constructor() {
+        this.rawHeaders = [];
+        this.rawTrailers = [];
+        this.complete = false;
+        this.joinDuplicateHeaders = false;
+        stream.Readable.apply(this);
+    }
+    get httpVersion() {
+        return this.httpVersionMajor
+            ? this.httpVersionMajor + '.' + this.httpVersionMinor
+            : '';
+    }
+    get headers() {
+        if (!this[kHeaders])
+            this[kHeaders] = convertToHeaders(this.rawHeaders, {}, this.joinDuplicateHeaders);
+        return this[kHeaders];
+    }
+    set headers(headers) {
+        this[kHeaders] = headers;
+    }
+    get headersDistinct() {
+        if (!this[kHeadersDistinct])
+            this[kHeadersDistinct] = convertToHeadersDistinct(this.rawHeaders, {});
+        return this[kHeadersDistinct];
+    }
+    get trailers() {
+        if (!this[kTrailers])
+            this[kTrailers] = convertToHeaders(this.rawTrailers, {}, this.joinDuplicateHeaders);
+        return this[kTrailers];
+    }
+    set trailers(trailers) {
+        this[kTrailers] = trailers;
+    }
+    get trailersDistinct() {
+        if (!this[kTrailersDistinct])
+            this[kTrailersDistinct] = convertToHeadersDistinct(this.rawTrailers, {});
+        return this[kTrailersDistinct];
+    }
+    _readConfig(init) {
+        this.complete = true;
+        this.httpVersionMajor = init?.httpVersionMajor || 1;
+        this.httpVersionMinor = init?.httpVersionMinor || 0;
+        this.method = (init.method || 'GET').toUpperCase();
+        this.url = init.url || '';
+        this.body = init.body;
+        if (init.headers)
+            this.rawHeaders = Array.isArray(init.headers) ? init.headers : convertToRawHeaders(init.headers);
+        if (init.trailers)
+            this.rawTrailers = Array.isArray(init.trailers) ? init.trailers : convertToRawHeaders(init.trailers);
+        this.ip = init.ip || '';
+        this.ips = init.ips || (this.ip ? [this.ip] : []);
+    }
+    _readBuffer(buf) {
+        const parser = new HTTPParser(HTTPParser.REQUEST);
+        let bodyChunks;
+        parser[HTTPParser.kOnHeadersComplete] = (info) => {
+            this.httpVersionMajor = info.versionMajor;
+            this.httpVersionMinor = info.versionMinor;
+            this.rawHeaders = info.headers;
+            this.method = HTTPParser.methods[info.method];
+            this.url = info.url;
+        };
+        parser[HTTPParser.kOnHeaders] = (trailers) => {
+            this.rawTrailers = trailers;
+        };
+        parser[HTTPParser.kOnBody] = (chunk, offset, length) => {
+            bodyChunks = bodyChunks || [];
+            bodyChunks.push(chunk.subarray(offset, offset + length));
+        };
+        parser[HTTPParser.kOnMessageComplete] = () => {
+            this.complete = true;
+            if (bodyChunks)
+                this.body = Buffer.concat(bodyChunks);
+        };
+        const buffer = Buffer.from(buf);
+        let x = parser.execute(buffer, 0, buffer.length);
+        if (typeof x === 'object')
+            throw x;
+        if (!this.complete) {
+            x = parser.execute(CRLF);
+            if (typeof x === 'object')
+                throw x;
+        }
+        parser.finish();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _readStream(readable) {
+        throw new Error('_readStream is not implemented yet');
+    }
+    static create(init) {
+        const msg = new HttpIncomingMessageHost();
+        if (Buffer.isBuffer(init))
+            msg._readBuffer(init);
+        else if (isReadable(init)) {
+            throw new Error('fromStream is not implemented yet');
+        }
+        else if (init)
+            msg._readConfig(init);
+        return msg;
+    }
+}
+// Apply mixins
+Object.assign(HttpIncomingMessageHost.prototype, stream.Readable.prototype);

package/esm/adapter/http/impl/http-outgoing-message-host.js

@@ -0,0 +1,205 @@
+/*
+  This file contains code blocks from open source NodeJs project
+  https://github.com/nodejs/
+ */
+var _a;
+import * as stream from 'stream';
+import { validateHeaderName, validateHeaderValue, validateString } from '../helpers/common.js';
+export const kOutHeaders = Symbol('kOutHeaders');
+export const kOutTrailers = Symbol('kOutTrailers');
+export const kErrored = Symbol('kErrored');
+// noinspection JSUnusedLocalSymbols
+/**
+ *
+ * @class HttpOutgoingMessageHost
+ */
+export class HttpOutgoingMessageHost {
+    constructor() {
+        this._headersSent = false;
+        this._closed = false;
+        this[_a] = null;
+        this.finished = false;
+        stream.Stream.apply(this);
+    }
+    get headersSent() {
+        return this._headersSent;
+    }
+    get closed() {
+        return this._closed;
+    }
+    get errored() {
+        return this[kErrored];
+    }
+    appendHeader(name, value) {
+        if (this.headersSent)
+            throw new Error(`Cannot set headers after they are sent to the client`);
+        validateHeaderName(name);
+        validateHeaderValue(name, value);
+        const field = name.toLowerCase();
+        const headers = this[kOutHeaders];
+        if (headers == null || !headers[field]) {
+            return this.setHeader(name, value);
+        }
+        // Prepare the field for appending, if required
+        if (!Array.isArray(headers[field][1])) {
+            headers[field][1] = [headers[field][1]];
+        }
+        const existingValues = headers[field][1];
+        if (Array.isArray(value)) {
+            for (let i = 0, length = value.length; i < length; i++) {
+                existingValues.push(value[i]);
+            }
+        }
+        else {
+            existingValues.push(value);
+        }
+        return this;
+    }
+    addTrailers(headers) {
+        if (headers && typeof headers === 'object') {
+            const entries = typeof headers.entries === 'function'
+                ? headers.entries() : Object.entries(headers);
+            let trailers = this[kOutTrailers];
+            if (trailers == null)
+                this[kOutTrailers] = trailers = { __proto__: null };
+            for (const [name, value] of entries) {
+                validateHeaderName(name);
+                validateHeaderValue(name, value);
+                trailers[String(name).toLowerCase()] = [String(name), value];
+            }
+            return;
+        }
+        throw new TypeError('Invalid "headers" argument. Value must be an object or raw headers array');
+    }
+    setHeader(name, value) {
+        if (this.headersSent)
+            throw new Error(`Cannot set headers after they are sent to the client`);
+        validateHeaderName(name);
+        validateHeaderValue(name, value);
+        let headers = this[kOutHeaders];
+        if (headers == null)
+            this[kOutHeaders] = headers = { __proto__: null };
+        headers[name.toLowerCase()] = [name, value];
+        return this;
+    }
+    setHeaders(headers) {
+        if (this.headersSent)
+            throw new Error(`Cannot set headers after they are sent to the client`);
+        if (headers && typeof headers === 'object' && !Array.isArray(headers)) {
+            const entries = typeof headers.entries === 'function'
+                ? headers.entries() : Object.entries(headers);
+            for (const entry of entries) {
+                this.setHeader(entry[0], entry[1]);
+            }
+            return this;
+        }
+        throw new TypeError('Invalid "headers" argument. Value must be an instance of "Headers" or "Map"');
+    }
+    getHeader(name) {
+        validateString(name);
+        const headers = this[kOutHeaders];
+        if (headers == null)
+            return;
+        const entry = headers[name.toLowerCase()];
+        return entry && entry[1];
+    }
+    getHeaderNames() {
+        return this[kOutHeaders] != null ? Object.keys(this[kOutHeaders]) : [];
+    }
+    getRawHeaderNames() {
+        const headersMap = this[kOutHeaders];
+        if (!headersMap)
+            return [];
+        const values = Object.values(headersMap);
+        const headers = Array(values.length);
+        for (let i = 0, l = values.length; i < l; i++) {
+            headers[i] = values[i][0];
+        }
+        return headers;
+    }
+    getHeaders() {
+        const headers = this[kOutHeaders];
+        // @ts-ignore
+        const ret = { __proto__: null };
+        if (headers) {
+            const keys = Object.keys(headers);
+            let key;
+            let val;
+            for (let i = 0; i < keys.length; ++i) {
+                key = keys[i];
+                val = headers[key][1];
+                ret[key] = val;
+            }
+        }
+        return ret;
+    }
+    hasHeader(name) {
+        validateString(name);
+        return this[kOutHeaders] != null &&
+            !!this[kOutHeaders][name.toLowerCase()];
+    }
+    removeHeader(name) {
+        validateString(name);
+        if (this.headersSent)
+            throw new Error(`Cannot remove headers after they are sent to the client`);
+        const key = name.toLowerCase();
+        // switch (key) {
+        //   case 'connection':
+        //     this._removedConnection = true;
+        //     break;
+        //   case 'content-length':
+        //     this._removedContLen = true;
+        //     break;
+        //   case 'transfer-encoding':
+        //     this._removedTE = true;
+        //     break;
+        //   case 'date':
+        //     this.sendDate = false;
+        //     break;
+        // }
+        if (this[kOutHeaders] != null) {
+            delete this[kOutHeaders][key];
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    end(arg0, arg1, arg2) {
+        // let cb: (() => void) | undefined;
+        // let chunk: any;
+        // let encoding: BufferEncoding | undefined;
+        //
+        // if (typeof arg0 === 'function')
+        //   cb = arg0;
+        // else {
+        //   chunk = arg0;
+        //   if (typeof arg1 === 'function')
+        //     cb = arg1;
+        //   else {
+        //     encoding = arg1;
+        //     cb = arg2;
+        //   }
+        // }
+        //
+        return this;
+    }
+    _readConfig(init) {
+        this.req = init.req;
+        this.statusCode = init?.statusCode || 0;
+        this.statusMessage = init?.statusMessage || '';
+        this.chunkedEncoding = !!init?.chunkedEncoding;
+        this.sendDate = !!init?.sendDate;
+        this.strictContentLength = !!init?.strictContentLength;
+        if (init.headers) {
+            this.setHeaders(Array.isArray(init.headers) ? new Map([init.headers]) : init.headers);
+        }
+        this.body = init.body;
+    }
+    static create(init) {
+        const msg = new HttpOutgoingMessageHost();
+        if (init)
+            msg._readConfig(init);
+        return msg;
+    }
+}
+_a = kErrored;
+// Apply mixins
+Object.assign(HttpOutgoingMessageHost.prototype, stream.Stream.prototype);

package/esm/adapter/http/impl/http-server-request.js

@@ -0,0 +1,121 @@
+/*
+  Some parts of this file contains codes from open source express library
+  https://github.com/expressjs
+ */
+import accepts from 'accepts';
+import fresh from 'fresh';
+import parseRange from 'range-parser';
+import typeIs from 'type-is';
+import { isReadable, mergePrototype } from '@opra/common';
+import { HttpIncomingMessageHost } from './http-incoming-message-host.js';
+function isHttpIncomingMessage(v) {
+    return v && Array.isArray(v.rawHeaders) && isReadable(v);
+}
+export var HttpServerRequest;
+(function (HttpServerRequest) {
+    function create(instance) {
+        if (!isHttpIncomingMessage(instance))
+            instance = HttpIncomingMessageHost.create(instance);
+        mergePrototype(instance, HttpServerRequestHost.prototype);
+        return instance;
+    }
+    HttpServerRequest.create = create;
+})(HttpServerRequest || (HttpServerRequest = {}));
+class HttpServerRequestHost {
+    get protocol() {
+        const proto = this.header('X-Forwarded-Proto') || 'http';
+        const index = proto.indexOf(',');
+        return index !== -1
+            ? proto.substring(0, index).trim()
+            : proto.trim();
+    }
+    get secure() {
+        return this.protocol === 'https';
+    }
+    get hostname() {
+        let host = this.get('X-Forwarded-Host');
+        if (!host) {
+            host = this.get('Host');
+        }
+        else if (host.indexOf(',') !== -1) {
+            // Note: X-Forwarded-Host is normally only ever a
+            //       single value, but this is to be safe.
+            host = host.substring(0, host.indexOf(',')).trim();
+        }
+        if (!host)
+            return;
+        // IPv6 literal support
+        const offset = host[0] === '['
+            ? host.indexOf(']') + 1
+            : 0;
+        const index = host.indexOf(':', offset);
+        return index !== -1
+            ? host.substring(0, index)
+            : host;
+    }
+    get fresh() {
+        const method = this.method;
+        // GET or HEAD for weak freshness validation only
+        if ('GET' !== method && 'HEAD' !== method)
+            return false;
+        const status = this.res?.statusCode;
+        // 2xx or 304 as per rfc2616 14.26
+        if ((status >= 200 && status < 300) || 304 === status) {
+            return fresh(this.headers, {
+                'etag': this.res.getHeader('ETag'),
+                'last-modified': this.res.getHeader('Last-Modified')
+            });
+        }
+        return false;
+    }
+    get xhr() {
+        const val = this.get('X-Requested-With') || '';
+        return val.toLowerCase() === 'xmlhttprequest';
+    }
+    header(name) {
+        name = name.toLowerCase();
+        const headers = this.headers;
+        switch (name) {
+            case 'referer':
+                return headers.referer || headers.referrer;
+            case 'referrer':
+                return headers.referrer || headers.referer;
+            default:
+                return headers[name];
+        }
+    }
+    get(name) {
+        return this.header(name);
+    }
+    accepts(...types) {
+        const accept = accepts(this);
+        return accept.types.call(accept, ...types);
+    }
+    acceptsCharsets(...charsets) {
+        const accept = accepts(this);
+        return accept.charsets.call(accept, ...charsets);
+    }
+    acceptsEncodings(...encoding) {
+        const accept = accepts(this);
+        // eslint-disable-next-line prefer-spread
+        return accept.encodings.apply(accept, encoding);
+    }
+    acceptsLanguages(...lang) {
+        const accept = accepts(this);
+        // eslint-disable-next-line prefer-spread
+        return accept.languages.apply(accept, lang);
+    }
+    is(type, ...otherTypes) {
+        const types = Array.isArray(type) ? type : [type];
+        if (otherTypes.length)
+            types.push(...otherTypes);
+        const contentType = this.header('content-type');
+        return contentType ? typeIs.is(contentType, types) : null;
+    }
+    range(size, options) {
+        const range = this.header('range');
+        if (!range)
+            return;
+        return parseRange(size, range, options);
+    }
+}

package/esm/adapter/http/impl/http-server-response.js

@@ -0,0 +1,222 @@
+/*
+  Some parts of this file contains codes from open source express library
+  https://github.com/expressjs
+ */
+import contentDisposition from 'content-disposition';
+import contentType from 'content-type';
+import cookie from 'cookie';
+import cookieSignature from 'cookie-signature';
+import encodeUrl from 'encodeurl';
+import mime from 'mime-types';
+import path from 'path';
+import { toString } from 'putil-varhelpers';
+import vary from 'vary';
+import { HttpStatusCodes, isStream, mergePrototype } from '@opra/common';
+import { HttpOutgoingMessageHost } from './http-outgoing-message-host.js';
+const charsetRegExp = /;\s*charset\s*=/;
+function isHttpIncomingMessage(v) {
+    return v && typeof v.getHeaders === 'function' && isStream(v);
+}
+export var HttpServerResponse;
+(function (HttpServerResponse) {
+    function create(instance) {
+        if (!isHttpIncomingMessage(instance))
+            instance = HttpOutgoingMessageHost.create(instance);
+        mergePrototype(instance, HttpServerResponseHost.prototype);
+        return instance;
+    }
+    HttpServerResponse.create = create;
+})(HttpServerResponse || (HttpServerResponse = {}));
+class HttpServerResponseHost {
+    attachment(filename) {
+        if (filename)
+            this.contentType(path.extname(filename));
+        this.setHeader('Content-Disposition', contentDisposition(filename));
+        return this;
+    }
+    contentType(type) {
+        const ct = type.indexOf('/') === -1
+            ? mime.lookup(type)
+            : type;
+        this.setHeader('Content-Type', ct);
+        return this;
+    }
+    setHeader(field, val) {
+        const setHeader = Object.getPrototypeOf(this).setHeader;
+        if (typeof field === 'string') {
+            let value = Array.isArray(val)
+                ? val.map(String)
+                : (val ? String(val) : '');
+            // add charset to content-type
+            if (field.toLowerCase() === 'content-type') {
+                if (Array.isArray(value)) {
+                    throw new TypeError('Content-Type cannot be set to an Array');
+                }
+                if (!charsetRegExp.test(value)) {
+                    const charset = mime.charsets.lookup(value.split(';')[0]);
+                    if (charset)
+                        value += '; charset=' + charset.toLowerCase();
+                }
+            }
+            setHeader.call(this, field, value);
+        }
+        else {
+            for (const [k, v] of Object.entries(field)) {
+                this.setHeader(k, v);
+            }
+        }
+        return this;
+    }
+    clearCookie(name, options) {
+        const opts = {
+            expires: new Date(1),
+            path: '/',
+            ...options
+        };
+        return this.cookie(name, '', opts);
+    }
+    cookie(name, value, options) {
+        const opts = { ...options };
+        let val = typeof value === 'object'
+            ? 'j:' + JSON.stringify(value)
+            : String(value);
+        if (opts.signed) {
+            const secret = opts.secret || this.req?.secret;
+            if (!secret)
+                throw new Error('"secret" required for signed cookies');
+            val = 's:' + cookieSignature.sign(val, secret);
+        }
+        if (opts.maxAge != null) {
+            const maxAge = opts.maxAge - 0;
+            if (!isNaN(maxAge)) {
+                opts.expires = new Date(Date.now() + maxAge);
+                opts.maxAge = Math.floor(maxAge / 1000);
+            }
+        }
+        if (opts.path == null)
+            opts.path = '/';
+        this.appendHeader('Set-Cookie', cookie.serialize(name, String(val), opts));
+        return this;
+    }
+    status(code) {
+        this.statusCode = code;
+        return this;
+    }
+    sendStatus(statusCode) {
+        const body = HttpStatusCodes[statusCode] || String(statusCode);
+        this.statusCode = statusCode;
+        this.contentType('txt');
+        return this.send(body);
+    }
+    links(links) {
+        let link = this.getHeader('Link') || '';
+        if (link)
+            link += ', ';
+        this.setHeader('Link', link +
+            Object.keys(links)
+                .map(rel => '<' + links[rel] + '>; rel="' + rel + '"')
+                .join(', '));
+        return this;
+    }
+    location(url) {
+        let loc = url;
+        // "back" is an alias for the referrer
+        if (url === 'back')
+            loc = this.req?.get('Referrer') || '/';
+        // set location
+        return this.setHeader('Location', encodeUrl(loc));
+    }
+    redirect(arg0, arg1) {
+        const address = String(arg1 || arg0);
+        const status = typeof arg0 === 'number' ? arg0 : 302;
+        // Set location header
+        this.location(address);
+        // Respond
+        this.statusCode = status;
+        this.end();
+    }
+    send(body) {
+        let chunk = body;
+        let encoding;
+        const req = this.req;
+        let ctype = toString(this.getHeader('Content-Type'));
+        if (typeof chunk !== 'string') {
+            if (chunk === null)
+                chunk = '';
+            else if (Buffer.isBuffer(chunk)) {
+                if (!ctype)
+                    this.contentType('bin');
+            }
+            else {
+                ctype = 'json';
+                chunk = JSON.stringify(chunk);
+            }
+        }
+        // write strings in utf-8
+        if (typeof chunk === 'string') {
+            encoding = 'utf-8';
+            this.setHeader('Content-Type', setCharset(ctype || 'txt', encoding));
+        }
+        // populate Content-Length
+        let len = 0;
+        if (chunk !== undefined) {
+            if (Buffer.isBuffer(chunk)) {
+                // get length of Buffer
+                len = chunk.length;
+            }
+            else if (chunk.length < 1000) {
+                // just calculate length when small chunk
+                len = Buffer.byteLength(chunk, encoding);
+            }
+            else {
+                // convert chunk to Buffer and calculate
+                chunk = Buffer.from(chunk, encoding);
+                encoding = undefined;
+                len = chunk.length;
+            }
+            this.setHeader('Content-Length', len);
+        }
+        // freshness
+        if (req?.fresh)
+            this.statusCode = 304;
+        // strip irrelevant headers
+        if (204 === this.statusCode || 304 === this.statusCode) {
+            this.removeHeader('Content-Type');
+            this.removeHeader('Content-Length');
+            this.removeHeader('Transfer-Encoding');
+            chunk = '';
+        }
+        // alter headers for 205
+        if (this.statusCode === 205) {
+            this.setHeader('Content-Length', '0');
+            this.removeHeader('Transfer-Encoding');
+            chunk = '';
+        }
+        if (req?.method === 'HEAD') {
+            // skip body for HEAD
+            this.end();
+        }
+        else {
+            // respond
+            if (encoding)
+                this.end(chunk, encoding);
+            else
+                this.end(chunk);
+        }
+        return this;
+    }
+    vary(field) {
+        vary(this, field);
+        return this;
+    }
+}
+function setCharset(type, charset) {
+    if (!(type && charset))
+        return type;
+    // parse type
+    const parsed = contentType.parse(type);
+    // set charset
+    parsed.parameters.charset = charset;
+    // format type
+    return contentType.format(parsed);
+}