@opra/common 0.14.0 → 0.16.0

package/cjs/http/http-headers.js

@@ -1,26 +1,32 @@
 "use strict";
-var _a, _b;
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpHeaders = void 0;
-const responsive_map_js_1 = require("../helpers/responsive-map.js");
+const index_js_1 = require("../helpers/index.js");
 const http_headers_codes_enum_js_1 = require("./enums/http-headers-codes.enum.js");
-const knownKeys = Object.keys(http_headers_codes_enum_js_1.HttpHeaderCodes);
+const knownKeys = Object.values(http_headers_codes_enum_js_1.HttpHeaderCodes);
 const knownKeysLower = knownKeys.map(x => x.toLowerCase());
 const nodeInspectCustom = Symbol.for('nodejs.util.inspect.custom');
 const kEntries = Symbol('kEntries');
-const kSize = Symbol('kSize');
 const kOptions = Symbol('kOptions');
+/**
+ *
+ * @class HttpHeaders
+ */
 class HttpHeaders {
     constructor(init, options) {
-        this[_a] = new responsive_map_js_1.ResponsiveMap();
-        this[_b] = 0;
+        this[_a] = new index_js_1.ResponsiveMap();
         this[kOptions] = { ...options, onChange: undefined };
-        if (init)
-            this.appendAll(init);
+        if (init) {
+            if (typeof init === 'string')
+                this.parse(init);
+            else
+                this.set(init);
+        }
         this[kOptions].onChange = options?.onChange;
     }
     get size() {
-        return this[kSize];
+        return this[kEntries].size;
     }
     /**
      * Appends a new value to the existing set of values for a header
@@ -36,97 +42,87 @@ class HttpHeaders {
      * and returns this instance
      */
     appendAll(headers) {
-        if (typeof headers === 'string') {
-            headers.split('\n').forEach(line => {
-                const index = line.indexOf(':');
-                if (index > 0) {
-                    const name = line.slice(0, index);
-                    const value = line.slice(index + 1).trim();
-                    this._append(name, value);
-                }
-            });
-        }
-        else if (headers.forEach && typeof headers.forEach === 'function')
+        if (headers.forEach && typeof headers.forEach === 'function')
             headers.forEach((value, name) => this._append(name, value));
         else
             Object.keys(headers).forEach(name => this._append(name, headers[name]));
         this.changed();
         return this;
     }
-    changed() {
-        if (this[kOptions].onChange)
-            this[kOptions].onChange();
+    set(arg0, arg1) {
+        if (typeof arg0 === 'object') {
+            if (arg0.forEach && typeof arg0.forEach === 'function')
+                arg0.forEach((value, name) => this._set(name, value));
+            else
+                Object.keys(arg0).forEach(name => this._set(name, arg0[name]));
+        }
+        else {
+            if (!arg1 && arg1 !== 0)
+                this[kEntries].delete(arg0);
+            else
+                this._set(arg0, arg1);
+        }
+        this.changed();
+        return this;
+    }
+    parse(init) {
+        this.clear();
+        init.split('\n').forEach(line => {
+            const index = line.indexOf(':');
+            if (index > 0) {
+                const name = line.slice(0, index);
+                const value = line.slice(index + 1).trim();
+                if (HttpHeaders.NON_DELIMITED_HEADERS[name])
+                    this._append(name, value);
+                else if (HttpHeaders.SEMICOLON_DELIMITED_HEADERS[name]) {
+                    const a = value.split(';');
+                    this._append(name, a.length > 1 ? a : value);
+                }
+                else {
+                    const a = value.split(',');
+                    this._append(name, a.length > 1 ? a : value);
+                }
+            }
+        });
+    }
+    /**
+     * Retrieves value of a given header
+     */
+    get(name) {
+        return this[kEntries].get(name);
     }
     clear() {
         if (this[kEntries].size) {
             this[kEntries].clear();
-            this[kSize] = 0;
             this.changed();
         }
     }
     /**
-     * Deletes values for a given header
+     * Deletes a header entry
      */
-    delete(name, value) {
-        if (this._delete(name, value))
+    delete(name) {
+        if (this[kEntries].delete(name)) {
             this.changed();
-        return this;
+            return true;
+        }
+        return false;
     }
     /**
      * Returns an iterable of key, value pairs for every entry in the map.
      */
     entries() {
-        const iter = this[kEntries].entries();
-        let i = 0;
-        let key;
-        let values;
-        return {
-            [Symbol.iterator]() {
-                return this;
-            },
-            next() {
-                if (values) {
-                    if (i >= values.length) {
-                        values = undefined;
-                        i = 0;
-                    }
-                }
-                if (!values) {
-                    const n = iter.next();
-                    if (n.done)
-                        return { done: true, value: undefined };
-                    key = n.value[0];
-                    values = n.value[1];
-                }
-                return {
-                    done: false,
-                    value: [key, values[i++]]
-                };
-            }
-        };
+        return this[kEntries].entries();
     }
     forEach(callbackFn, thisArg) {
         const iterator = this.entries();
         let entry = iterator.next();
+        let v;
         while (!entry.done) {
-            callbackFn.call(thisArg || this, entry.value[1], entry.value[0], this);
+            v = entry.value[1];
+            callbackFn.call(thisArg || this, (Array.isArray(v) ? v.join(';') : String(v)), entry.value[0], this);
             entry = iterator.next();
         }
     }
-    /**
-     * Retrieves value of a given header at given index
-     */
-    get(name, index = 0) {
-        const values = this[kEntries].get(name.toLowerCase());
-        return values && values.length > index ? values[index] : null;
-    }
-    /**
-     * Retrieves an array of values for a given header.
-     */
-    getAll(name) {
-        const entry = this[kEntries].get(name);
-        return entry ? entry.slice(0) : null;
-    }
     /**
      * Retrieves the names of the headers.
      */
@@ -139,75 +135,93 @@ class HttpHeaders {
     has(name) {
         return this[kEntries].has(name);
     }
-    /**
-     * Sets or modifies a value for a given header.
-     * If the header already exists, its value is replaced with the given value
-     */
-    set(name, value) {
-        this._set(name, String(value));
-        this.changed();
-        return this;
-    }
     sort(compareFn) {
         this[kEntries].sort(compareFn);
         this.changed();
         return this;
     }
+    toObject() {
+        const out = {};
+        for (const [k, v] of this.entries())
+            out[k] = Array.isArray(v) ? v.join(';') : String(v);
+        return out;
+    }
+    getProxy() {
+        const _this = this;
+        return this[kEntries].getProxy({
+            set(target, p, newValue, receiver) {
+                if (typeof p === 'string') {
+                    _this.set(p, newValue);
+                    return true;
+                }
+                return Reflect.set(target, p, newValue, receiver);
+            },
+        });
+    }
+    [(_a = kEntries, nodeInspectCustom)]() {
+        return this[kEntries];
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    get [Symbol.toStringTag]() {
+        return 'HttpHeaders';
+    }
     _append(name, value) {
-        const i = knownKeysLower.indexOf(name);
+        const i = knownKeysLower.indexOf(name.toLowerCase());
         const normalizedName = knownKeys[i] || name;
-        let values = this[kEntries].get(normalizedName);
-        if (!values) {
-            values = [];
-            this[kEntries].set(normalizedName, values);
+        name = name.toLowerCase();
+        let stored = this[kEntries].get(normalizedName);
+        if (HttpHeaders.NON_DELIMITED_HEADERS[name]) {
+            value = String(Array.isArray(value) ? value[0] : value);
+            this[kEntries].set(normalizedName, value);
+            return;
+        }
+        if (HttpHeaders.ARRAY_HEADERS[name]) {
+            stored = (stored ? [stored, value] : [value])
+                .flat().map(String);
+            this[kEntries].set(normalizedName, stored);
+            return;
         }
-        const oldSize = values.length;
+        const arr = stored ? [stored] : [];
         if (Array.isArray(value))
-            values.push(...value.map(x => String(x)));
+            arr.push(...value);
         else
-            values.push(String(value));
-        this[kSize] = -oldSize + values.length;
-    }
-    _delete(name, value) {
-        const oldValues = this[kEntries].get(name);
-        if (!oldValues)
-            return false;
-        const oldSize = this[kSize];
-        if (value) {
-            const valueToDelete = Array.isArray(value) ? value.map(x => String(x)) : [String(value)];
-            const newValues = oldValues.filter(x => !valueToDelete.includes(x));
-            this[kEntries].set(name, newValues);
-            this[kSize] += -oldValues.length + newValues.length;
-        }
-        else {
-            this[kEntries].delete(name);
-            this[kSize] -= oldValues.length;
-        }
-        return oldSize !== this[kSize];
+            arr.push(value);
+        this[kEntries].set(normalizedName, arr.join(HttpHeaders.SEMICOLON_DELIMITED_HEADERS[name] ? '; ' : ', '));
     }
     _set(name, value) {
-        if (value == null) {
-            this._delete(name);
+        this[kEntries].delete(name);
+        if (!value && value !== 0)
             return;
-        }
-        const oldValues = this[kEntries].get(name);
-        const i = knownKeysLower.indexOf(name);
-        const normalizedName = knownKeys[i] || name;
-        const newValues = Array.isArray(value) ? value : [value];
-        this[kEntries].set(normalizedName, newValues);
-        this[kSize] += -(oldValues?.length || 0) + newValues.length;
-    }
-    [(_a = kEntries, _b = kSize, nodeInspectCustom)]() {
-        return this[kEntries];
-    }
-    [Symbol.iterator]() {
-        return this.entries();
+        this._append(name, value);
     }
-    get [Symbol.toStringTag]() {
-        return 'HttpHeaders';
+    changed() {
+        if (this[kOptions].onChange)
+            this[kOptions].onChange();
     }
 }
 exports.HttpHeaders = HttpHeaders;
 HttpHeaders.kEntries = kEntries;
-HttpHeaders.kSize = kSize;
 HttpHeaders.kOptions = kOptions;
+HttpHeaders.NON_DELIMITED_HEADERS = {
+    'age': true,
+    'from': true,
+    'etag': true,
+    'server': true,
+    'referer': true,
+    'expires': true,
+    'location': true,
+    'user-agent': true,
+    'retry-after': true,
+    'content-type': true,
+    'content-length': true,
+    'max-forwards': true,
+    'last-modified': true,
+    'authorization': true,
+    'proxy-authorization': true,
+    'if-modified-since': true,
+    'if-unmodified-since': true
+};
+HttpHeaders.SEMICOLON_DELIMITED_HEADERS = { 'cookie': true };
+HttpHeaders.ARRAY_HEADERS = { 'set-cookie': true };

package/cjs/http/http-message.host.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpMessageHost = void 0;
+const tslib_1 = require("tslib");
+const http_parser_js_1 = require("http-parser-js");
+const stream_1 = tslib_1.__importDefault(require("stream"));
+const http_headers_js_1 = require("./http-headers.js");
+const kHeaders = Symbol('kHeaders');
+const kHeadersProxy = Symbol('kHeadersProxy');
+const kTrailers = Symbol('kTrailers');
+const kTrailersProxy = Symbol('kTrailersProxy');
+const kOnHeaderReceived = Symbol('kOnHeaderReceived');
+const kOnTrailersReceived = Symbol('kOnTrailersReceived');
+const kOnBodyChunk = Symbol('kOnBodyChunk');
+const kOnReadComplete = Symbol('kOnReadComplete');
+const crlfBuffer = Buffer.from('\r\n');
+const HTTP_VERSION_PATTERN = /^(\d)\.(\d)$/;
+class HttpMessageHost {
+    constructor() {
+        this.complete = false;
+        stream_1.default.Duplex.apply(this);
+        this[kHeaders] = new http_headers_js_1.HttpHeaders(undefined, {
+            onChange: () => this._headersChanged = true
+        });
+        this[kTrailers] = new http_headers_js_1.HttpHeaders(undefined, {
+            onChange: () => this._trailersChanged = true
+        });
+    }
+    get httpVersion() {
+        return this.httpVersionMajor
+            ? this.httpVersionMajor + '.' + (this.httpVersionMinor || 0)
+            : undefined;
+    }
+    set httpVersion(value) {
+        if (value) {
+            const m = HTTP_VERSION_PATTERN.exec(value);
+            if (!m)
+                throw new TypeError(`Invalid http version string (${value})`);
+            this.httpVersionMajor = parseInt(m[1], 10);
+            this.httpVersionMinor = parseInt(m[2], 10);
+        }
+        else {
+            this.httpVersionMajor = undefined;
+            this.httpVersionMinor = undefined;
+        }
+    }
+    get headers() {
+        this._initHeaders();
+        return this[kHeadersProxy];
+    }
+    set headers(headers) {
+        this[kHeaders].clear();
+        this[kHeaders].set(headers);
+    }
+    get trailers() {
+        this._initTrailers();
+        return this[kTrailersProxy];
+    }
+    set trailers(trailers) {
+        this[kTrailers].clear();
+        this[kTrailers].set(trailers);
+    }
+    get rawHeaders() {
+        this._buildRawHeaders();
+        return this._rawHeaders;
+    }
+    set rawHeaders(headers) {
+        this[kHeadersProxy] = undefined;
+        this._headersChanged = false;
+        this._rawHeaders = headers;
+    }
+    get rawTrailers() {
+        this._buildRawTrailers();
+        return this._rawTrailers;
+    }
+    set rawTrailers(trailers) {
+        this[kTrailersProxy] = undefined;
+        this._trailersChanged = false;
+        this._rawTrailers = trailers;
+    }
+    getHeader(name) {
+        if (!name)
+            return;
+        this._initHeaders();
+        switch (name.toLowerCase()) {
+            case 'referer':
+            case 'referrer':
+                return this[kHeaders].get(name) ||
+                    this[kHeaders].get('referrer') ||
+                    this[kHeaders].get('referer');
+            default:
+                return this[kHeaders].get(name);
+        }
+    }
+    get(name) {
+        this._initHeaders();
+        return this[kHeaders].get(name);
+    }
+    setHeader(arg0, arg1) {
+        this._initHeaders();
+        if (typeof arg0 === 'object')
+            this[kHeaders].set(arg0);
+        else
+            this[kHeaders].set(arg0, arg1);
+        return this;
+    }
+    set(arg0, arg1) {
+        return this.setHeader(arg0, arg1);
+    }
+    getHeaders() {
+        this._initHeaders();
+        return this[kHeaders].toObject();
+    }
+    getHeaderNames() {
+        this._initHeaders();
+        return Array.from(this[kHeaders].keys());
+    }
+    hasHeader(name) {
+        this._initHeaders();
+        return this[kHeaders].has(name);
+    }
+    removeHeader(name) {
+        this._initHeaders();
+        this[kHeaders].delete(name);
+    }
+    send(body) {
+        this.body = body;
+        return this;
+    }
+    end(body) {
+        if (body)
+            this.body = body;
+        return this;
+    }
+    setTimeout() {
+        return this;
+    }
+    _init(args) {
+        this.complete = true;
+        this.httpVersionMajor = args?.httpVersionMajor;
+        this.httpVersionMinor = args?.httpVersionMinor;
+        this._rawHeaders = args.rawHeaders;
+        this._rawTrailers = args.rawTrailers;
+        if (args.headers)
+            this[kHeaders].set(args.headers);
+        if (args.trailers)
+            this[kTrailers].set(args.trailers);
+        this.body = args.body;
+    }
+    _parseBuffer(buf, parserType) {
+        const parser = new http_parser_js_1.HTTPParser(parserType);
+        parser[http_parser_js_1.HTTPParser.kOnHeadersComplete] = this[kOnHeaderReceived].bind(this);
+        parser[http_parser_js_1.HTTPParser.kOnBody] = this[kOnBodyChunk].bind(this);
+        parser[http_parser_js_1.HTTPParser.kOnHeaders] = this[kOnTrailersReceived].bind(this);
+        parser[http_parser_js_1.HTTPParser.kOnMessageComplete] = this[kOnReadComplete].bind(this);
+        const buffer = Buffer.from(buf);
+        let x = parser.execute(buffer);
+        if (typeof x === 'object')
+            throw x;
+        if (!this.complete) {
+            x = parser.execute(crlfBuffer);
+            if (typeof x === 'object')
+                throw x;
+        }
+        parser.finish();
+    }
+    _initHeaders() {
+        if (!this[kHeadersProxy]) {
+            this[kHeadersProxy] = this[kHeaders].getProxy();
+            if (this._rawHeaders) {
+                const src = this._rawHeaders;
+                const l = Math.floor(src.length / 2);
+                for (let n = 0; n <= l; n += 2) {
+                    this[kHeaders].append(src[n], src[n + 1]);
+                }
+            }
+        }
+    }
+    _initTrailers() {
+        if (!this[kTrailersProxy]) {
+            this[kTrailersProxy] = this[kTrailers].getProxy();
+            if (this._rawTrailers) {
+                const src = this._rawTrailers;
+                const l = Math.floor(src.length / 2);
+                for (let n = 0; n <= l; n += 2) {
+                    this[kTrailers].append(src[n], src[n + 1]);
+                }
+            }
+        }
+    }
+    _buildRawHeaders() {
+        // Rebuild rawHeaders if headers object changed
+        if (this._headersChanged || !this._rawHeaders) {
+            this._headersChanged = false;
+            this._rawHeaders = Object.entries(this.headers)
+                .reduce((a, [k, v]) => {
+                if (Array.isArray(v))
+                    v.forEach(x => a.push(k, String(x)));
+                else
+                    a.push(k, String(v));
+                return a;
+            }, []);
+        }
+    }
+    _buildRawTrailers() {
+        // Rebuild rawHeaders if headers object changed
+        if (this._trailersChanged || !this._rawTrailers) {
+            this._trailersChanged = false;
+            this._rawTrailers = Object.entries(this.trailers)
+                .reduce((a, [k, v]) => {
+                if (Array.isArray(v))
+                    v.forEach(x => a.push(k, String(x)));
+                else
+                    a.push(k, String(v));
+                return a;
+            }, []);
+        }
+    }
+    [kOnHeaderReceived](info) {
+        this.httpVersionMajor = info.versionMajor;
+        this.httpVersionMinor = info.versionMinor;
+        this._rawHeaders = info.headers;
+        this.shouldKeepAlive = info.shouldKeepAlive;
+        this.upgrade = info.upgrade;
+    }
+    [kOnTrailersReceived](trailers) {
+        this._rawTrailers = trailers;
+    }
+    [kOnBodyChunk](chunk, offset, length) {
+        this._bodyChunks = this._bodyChunks || [];
+        this._bodyChunks.push(chunk.subarray(offset, offset + length));
+    }
+    [kOnReadComplete]() {
+        this.complete = true;
+        if (this._bodyChunks) {
+            this.body = Buffer.concat(this._bodyChunks);
+            this._bodyChunks = undefined;
+        }
+    }
+}
+exports.HttpMessageHost = HttpMessageHost;
+HttpMessageHost.kHeaders = kHeaders;
+HttpMessageHost.kHeadersProxy = kHeadersProxy;
+HttpMessageHost.kTrailers = kTrailers;
+HttpMessageHost.kTrailersProxy = kTrailersProxy;
+HttpMessageHost.kOnHeaderReceived = kOnHeaderReceived;
+HttpMessageHost.kOnTrailersReceived = kOnTrailersReceived;
+HttpMessageHost.kOnBodyChunk = kOnBodyChunk;
+HttpMessageHost.kOnReadComplete = kOnReadComplete;
+// Mixin with Duplex
+Object.assign(HttpMessageHost.prototype, stream_1.default.Duplex.prototype);