@opra/common 0.10.2 → 0.12.0

package/cjs/http/http-params.js

@@ -0,0 +1,321 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpParams = void 0;
+const fast_tokenizer_1 = require("fast-tokenizer");
+const responsive_map_js_1 = require("../helpers/responsive-map.js");
+const boolean_codec_js_1 = require("./param-codec/boolean-codec.js");
+const date_codec_js_1 = require("./param-codec/date-codec.js");
+const filter_codec_js_1 = require("./param-codec/filter-codec.js");
+const integer_codec_js_1 = require("./param-codec/integer-codec.js");
+const number_codec_js_1 = require("./param-codec/number-codec.js");
+const string_codec_js_1 = require("./param-codec/string-codec.js");
+const encodeURIParam_js_1 = require("./utils/encodeURIParam.js");
+const kEntries = Symbol('kEntries');
+const kSize = Symbol('kSize');
+const kParamDefs = Symbol('kParamDefs');
+const kOptions = Symbol('kOptions');
+const defaultKeyDecoder = (s) => decodeURIComponent(s);
+const defaultValueDecoder = (s) => decodeURIComponent(s);
+const defaultKeyEncoder = (s) => (0, encodeURIParam_js_1.encodeURIParam)(s);
+const defaultValueEncoder = (s) => (0, encodeURIParam_js_1.encodeURIParam)(s);
+const internalCodecs = {
+    'boolean': new boolean_codec_js_1.BooleanCodec(),
+    'date': new date_codec_js_1.DateCodec(),
+    'filter': new filter_codec_js_1.FilterCodec(),
+    'integer': new integer_codec_js_1.IntegerCodec(),
+    'number': new number_codec_js_1.NumberCodec(),
+    'string': new string_codec_js_1.StringCodec()
+};
+class HttpParams {
+    constructor(init, options) {
+        this[_a] = new responsive_map_js_1.ResponsiveMap();
+        this[_b] = 0;
+        this[_c] = new Map();
+        this[kOptions] = { ...options, onChange: undefined };
+        const defineParams = options?.params;
+        if (defineParams)
+            Object.keys(defineParams).forEach(key => this.define(key, defineParams[key]));
+        if (init)
+            this.appendAll(init);
+        this[kOptions].onChange = options?.onChange;
+    }
+    get size() {
+        return this[kSize];
+    }
+    /**
+     * Appends a new value to the existing set of values for a parameter
+     * and returns this instance
+     */
+    append(name, value) {
+        this._append(name, value);
+        this.changed();
+        return this;
+    }
+    appendAll(input) {
+        if (typeof input === 'string') {
+            if (input && input.startsWith('?'))
+                input = input.substring(1);
+            if (!input)
+                return this;
+            const tokenizer = (0, fast_tokenizer_1.tokenize)(input, { delimiters: '&', quotes: true, brackets: true });
+            for (const token of tokenizer) {
+                if (!token)
+                    continue;
+                const itemTokenizer = (0, fast_tokenizer_1.tokenize)(token, {
+                    delimiters: '=',
+                    quotes: true,
+                    brackets: true
+                });
+                const k = this.decodeKey(itemTokenizer.next() || '');
+                const v = this.decodeValue(itemTokenizer.join('='), k);
+                this._append(k, v);
+            }
+        }
+        else if (input.forEach && typeof input.forEach === 'function')
+            input.forEach((value, name) => this._append(name, value));
+        else
+            Object.keys(input).forEach(name => this._append(name, input[name]));
+        return this;
+    }
+    changed() {
+        if (this[kOptions].onChange)
+            this[kOptions].onChange();
+    }
+    clear() {
+        if (this[kEntries].size) {
+            this[kEntries].clear();
+            this[kSize] = 0;
+            this.changed();
+        }
+    }
+    /**
+     * Deletes values for a given parameter
+     */
+    delete(name, value) {
+        if (this._delete(name, value))
+            this.changed();
+        return this;
+    }
+    /**
+     * 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++]]
+                };
+            }
+        };
+    }
+    forEach(callbackFn, thisArg) {
+        const iterator = this.entries();
+        let entry = iterator.next();
+        while (!entry.done) {
+            callbackFn.call(thisArg || this, entry.value[1], entry.value[0], this);
+            entry = iterator.next();
+        }
+    }
+    /**
+     * Retrieves value of a given parameter 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 parameter.
+     */
+    getAll(name) {
+        const entry = this[kEntries].get(name);
+        return entry ? entry.slice(0) : null;
+    }
+    /**
+     * Retrieves the names of the parameters.
+     */
+    keys() {
+        return this[kEntries].keys();
+    }
+    /**
+     * Retrieves the names of the parameters.
+     */
+    values() {
+        const items = [];
+        this.forEach((value) => items.push(value));
+        return items.values();
+    }
+    /**
+     * Checks for existence of a parameter.
+     */
+    has(name) {
+        return this[kEntries].has(name);
+    }
+    /**
+     * Sets or modifies a value for a given parameter.
+     * If the header already exists, its value is replaced with the given value
+     */
+    set(name, value) {
+        this._set(name, value);
+        this.changed();
+        return this;
+    }
+    sort(compareFn) {
+        this[kEntries].sort(compareFn);
+        this.changed();
+        return this;
+    }
+    /**
+     * Serializes the body to an encoded string, where key-value pairs (separated by `=`) are
+     * separated by `&`s.
+     */
+    toString() {
+        const out = [];
+        this.forEach((v, k) => {
+            out.push(this.encodeKey(k) +
+                (v ? '=' + this.encodeValue(v, k) : ''));
+        });
+        return out.join('&');
+    }
+    define(name, options) {
+        if (!name)
+            throw new Error('Parameter name required');
+        if (typeof options?.codec === 'string' && !internalCodecs[options.codec])
+            throw new Error(`Unknown url parameter format name "${options.codec}"`);
+        const codec = (typeof options?.codec === 'string'
+            ? internalCodecs[options.codec]
+            : options?.codec) || internalCodecs.string;
+        const meta = {
+            ...options,
+            codec
+        };
+        this[kParamDefs].set(name, meta);
+        return this;
+    }
+    encodeKey(key) {
+        return (this[kOptions].encodeKey || defaultKeyEncoder)(key);
+    }
+    decodeKey(key) {
+        return (this[kOptions].decodeKey || defaultKeyDecoder)(key);
+    }
+    encodeValue(value, key) {
+        const prmDef = this[kParamDefs].get(key);
+        if (prmDef) {
+            const delimReplace = '%' + (prmDef.arrayDelimiter || ',').charCodeAt(0).toString(16).toUpperCase();
+            const fn = (x) => (0, encodeURIParam_js_1.encodeURIParam)(prmDef.codec.encode(x)).replaceAll(',', delimReplace);
+            return Array.isArray(value)
+                ? value.map((v) => fn(v)).join(prmDef.arrayDelimiter || ',')
+                : fn(value);
+        }
+        return (this[kOptions].encodeValue || defaultValueEncoder)(value);
+    }
+    decodeValue(value, key) {
+        const prmDef = this[kParamDefs].get(key);
+        const valueDecoder = (this[kOptions].decodeValue || defaultValueDecoder);
+        let val = value;
+        if (prmDef) {
+            if (prmDef.array) {
+                val = (0, fast_tokenizer_1.splitString)(value, {
+                    delimiters: prmDef.arrayDelimiter || ',',
+                    brackets: true,
+                    quotes: true,
+                    keepQuotes: false
+                }).map((x) => valueDecoder(x));
+            }
+            else
+                val = valueDecoder(val);
+            const fn = (x) => prmDef.codec.decode(valueDecoder(x));
+            val = Array.isArray(val) ? val.map(fn) : fn(val);
+            if (prmDef.array === 'strict')
+                val = Array.isArray(val) ? val : [val];
+            else if (prmDef.array)
+                val = Array.isArray(val) && val.length === 1 ? val[0] : val;
+            if (Array.isArray(val)) {
+                if (prmDef.minArrayItems && val.length < prmDef.minArrayItems)
+                    throw new Error(`"${key}" parameter requires at least ${prmDef.minArrayItems} values`);
+                if (prmDef.maxArrayItems && val.length > prmDef.maxArrayItems)
+                    throw new Error(`"${key}" parameter accepts up to ${prmDef.maxArrayItems} values`);
+            }
+            return val;
+        }
+        return valueDecoder(value);
+    }
+    _append(name, value) {
+        let values = this[kEntries].get(name);
+        if (!values) {
+            values = [];
+            this[kEntries].set(name, values);
+        }
+        values.push(value ?? null);
+        this[kSize] += 1;
+    }
+    _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 : [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];
+    }
+    _set(name, value, index) {
+        if (value == null) {
+            this._delete(name);
+            return;
+        }
+        const values = this[kEntries].get(name);
+        if (!values) {
+            this[kEntries].set(name, [value]);
+            this[kSize] += 1;
+            return;
+        }
+        if (index == null || index < 0) {
+            this[kEntries].set(name, [value]);
+            this[kSize] += -(values.length) + 1;
+            return;
+        }
+        const oldLen = values.length;
+        values[Math.min(index, values.length)] = value;
+        this[kSize] += -oldLen + values.length;
+    }
+    [(_a = kEntries, _b = kSize, _c = kParamDefs, Symbol.iterator)]() {
+        return this.entries();
+    }
+    get [Symbol.toStringTag]() {
+        return 'HttpParams';
+    }
+}
+exports.HttpParams = HttpParams;
+HttpParams.kEntries = kEntries;
+HttpParams.kSize = kSize;
+HttpParams.kParamDefs = kParamDefs;
+HttpParams.kOptions = kOptions;

package/cjs/http/http-request-node.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpRequestNode = void 0;
+const http_parser_js_1 = require("http-parser-js");
+const stream_1 = require("stream");
+const crlfBuffer = Buffer.from('\r\n');
+const kHeaders = Symbol('kHeaders');
+const kHeadersCount = Symbol('kHeadersCount');
+const kTrailers = Symbol('kTrailers');
+const kTrailersCount = Symbol('kTrailersCount');
+// todo: Check is this class should be in common library
+class HttpRequestNode extends stream_1.Readable {
+    constructor() {
+        super(...arguments);
+        this.aborted = false;
+    }
+    get headers() {
+        if (!this[kHeaders])
+            this[kHeaders] = arrayToHeaders(this.rawHeaders);
+        return this[kHeaders];
+    }
+    get headersCount() {
+        return this[kHeadersCount];
+    }
+    get trailers() {
+        if (!this[kTrailers])
+            this[kTrailers] = arrayToHeaders(this.rawTrailers);
+        return this[kTrailers];
+    }
+    get trailersCount() {
+        return this[kTrailersCount];
+    }
+    _read() {
+        if (this.data) {
+            this.push(this.data);
+        }
+        this.push(null);
+    }
+    static parse(input) {
+        const parser = new http_parser_js_1.HTTPParser(http_parser_js_1.HTTPParser.REQUEST);
+        const out = new HttpRequestNode();
+        const bodyChunks = [];
+        parser[http_parser_js_1.HTTPParser.kOnHeadersComplete] = function (req) {
+            out.shouldKeepAlive = req.shouldKeepAlive;
+            out.upgrade = req.upgrade;
+            out.method = http_parser_js_1.HTTPParser.methods[req.method];
+            out.url = req.url;
+            out.originalUrl = req.url;
+            out.httpVersionMajor = req.versionMajor;
+            out.httpVersionMinor = req.versionMinor;
+            out.httpVersion = req.versionMajor + '.' + req.versionMinor;
+            out.rawHeaders = req.headers;
+            out[kHeadersCount] = Math.ceil(req.headers.length / 2);
+            out[kTrailersCount] = 0;
+        };
+        parser[http_parser_js_1.HTTPParser.kOnBody] = function (chunk, offset, length) {
+            bodyChunks.push(chunk.subarray(offset, offset + length));
+        };
+        // This is actually the event for trailers, go figure.
+        parser[http_parser_js_1.HTTPParser.kOnHeaders] = function (t) {
+            out.rawTrailers = t;
+            out[kTrailersCount] = Math.ceil(t.length / 2);
+        };
+        parser[http_parser_js_1.HTTPParser.kOnMessageComplete] = function () {
+            out.complete = true;
+        };
+        // Since we are sending the entire Buffer at once here all callbacks above happen synchronously.
+        // The parser does not do _anything_ asynchronous.
+        // However, you can of course call execute() multiple times with multiple chunks, e.g. from a stream.
+        // But then you have to refactor the entire logic to be async (e.g. resolve a Promise in kOnMessageComplete and add timeout logic).
+        parser.execute(input);
+        if (!out.complete)
+            parser.execute(crlfBuffer);
+        parser.finish();
+        if (!out.complete) {
+            throw new Error('Could not parse request');
+        }
+        out.rawTrailers = out.rawTrailers || [];
+        if (bodyChunks.length)
+            out.data = Buffer.concat(bodyChunks);
+        out.resume();
+        return out;
+    }
+}
+exports.HttpRequestNode = HttpRequestNode;
+function arrayToHeaders(arr) {
+    const headers = {};
+    for (let i = 0; i < arr.length; i++) {
+        const k = arr[i].toLowerCase();
+        const v = arr[++i];
+        const trgV = headers[k];
+        // Array header -- only Set-Cookie at the moment
+        if (trgV && k === 'set-cookie') {
+            const a = Array.isArray(trgV) ? trgV : [trgV];
+            a.push(v);
+            headers[k] = a;
+        }
+        else if (typeof trgV === 'string') {
+            headers[k] += (k === 'cookie' ? '; ' : ', ') + v;
+        }
+        else
+            headers[k] = v;
+    }
+    return headers;
+}

package/cjs/http/http-request.js

@@ -1,104 +1,89 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpRequest = void 0;
-const http_parser_js_1 = require("http-parser-js");
-const stream_1 = require("stream");
-const crlfBuffer = Buffer.from('\r\n');
-const kHeaders = Symbol('kHeaders');
-const kHeadersCount = Symbol('kHeadersCount');
-const kTrailers = Symbol('kTrailers');
-const kTrailersCount = Symbol('kTrailersCount');
-class HttpRequest extends stream_1.Readable {
-    constructor() {
-        super(...arguments);
-        this.aborted = false;
+/// <reference lib="dom" />
+const index_js_1 = require("../url/index.js");
+const http_headers_js_1 = require("./http-headers.js");
+const directCopyProperties = ['cache', 'credentials', 'destination', 'headers', 'integrity',
+    'keepalive', 'mode', 'redirect', 'referrer', 'referrerPolicy'];
+class HttpRequest {
+    constructor(init) {
+        this.cache = init?.cache || 'default';
+        this.credentials = init?.credentials || 'same-origin';
+        this.destination = init?.destination || '';
+        this.headers = new http_headers_js_1.HttpHeaders(init?.headers);
+        this.integrity = init?.integrity || '';
+        this.keepalive = init?.keepalive ?? false;
+        this.method = (init?.method || 'GET').toUpperCase();
+        this.mode = init?.mode || 'cors';
+        this.redirect = init?.redirect || 'follow';
+        this.mode = init?.mode || 'cors';
+        this.referrer = init?.referrer || '';
+        this.referrerPolicy = init?.referrerPolicy || '';
+        this.signal = init?.signal || new AbortController().signal;
+        this.body = init?.body;
+        this.urlInstance = new index_js_1.OpraURL(init?.url);
+        if (init?.params)
+            this.params.appendAll(init.params);
     }
-    get headers() {
-        if (!this[kHeaders])
-            this[kHeaders] = arrayToHeaders(this.rawHeaders);
-        return this[kHeaders];
+    /** Returns the URL of request as a string. */
+    get url() {
+        return this.urlInstance.href;
     }
-    get headersCount() {
-        return this[kHeadersCount];
+    set url(value) {
+        this.urlInstance.parse(value);
     }
-    get trailers() {
-        if (!this[kTrailers])
-            this[kTrailers] = arrayToHeaders(this.rawTrailers);
-        return this[kTrailers];
+    /** Returns the searchParams of the URL as OpraURLSearchParams */
+    get params() {
+        return this.urlInstance.searchParams;
     }
-    get trailersCount() {
-        return this[kTrailersCount];
+    /** Returns the path part of URL as OpraURLPath */
+    get path() {
+        return this.urlInstance.path;
     }
-    _read() {
-        if (this.data) {
-            this.push(this.data);
-        }
-        this.push(null);
-    }
-    static parse(input) {
-        const parser = new http_parser_js_1.HTTPParser(http_parser_js_1.HTTPParser.REQUEST);
+    clone(...update) {
         const out = new HttpRequest();
-        const bodyChunks = [];
-        parser[http_parser_js_1.HTTPParser.kOnHeadersComplete] = function (req) {
-            out.shouldKeepAlive = req.shouldKeepAlive;
-            out.upgrade = req.upgrade;
-            out.method = http_parser_js_1.HTTPParser.methods[req.method];
-            out.url = req.url;
-            out.originalUrl = req.url;
-            out.httpVersionMajor = req.versionMajor;
-            out.httpVersionMinor = req.versionMinor;
-            out.httpVersion = req.versionMajor + '.' + req.versionMinor;
-            out.rawHeaders = req.headers;
-            out[kHeadersCount] = Math.ceil(req.headers.length / 2);
-            out[kTrailersCount] = 0;
-        };
-        parser[http_parser_js_1.HTTPParser.kOnBody] = function (chunk, offset, length) {
-            bodyChunks.push(chunk.subarray(offset, offset + length));
-        };
-        // This is actually the event for trailers, go figure.
-        parser[http_parser_js_1.HTTPParser.kOnHeaders] = function (t) {
-            out.rawTrailers = t;
-            out[kTrailersCount] = Math.ceil(t.length / 2);
-        };
-        parser[http_parser_js_1.HTTPParser.kOnMessageComplete] = function () {
-            out.complete = true;
-        };
-        // Since we are sending the entire Buffer at once here all callbacks above happen synchronously.
-        // The parser does not do _anything_ asynchronous.
-        // However, you can of course call execute() multiple times with multiple chunks, e.g. from a stream.
-        // But then you have to refactor the entire logic to be async (e.g. resolve a Promise in kOnMessageComplete and add timeout logic).
-        parser.execute(input);
-        if (!out.complete)
-            parser.execute(crlfBuffer);
-        parser.finish();
-        if (!out.complete) {
-            throw new Error('Could not parse request');
+        out.merge(this);
+        for (const upd of update) {
+            out.merge(upd);
         }
-        out.rawTrailers = out.rawTrailers || [];
-        if (bodyChunks.length)
-            out.data = Buffer.concat(bodyChunks);
-        out.resume();
         return out;
     }
-}
-exports.HttpRequest = HttpRequest;
-function arrayToHeaders(arr) {
-    const headers = {};
-    for (let i = 0; i < arr.length; i++) {
-        const k = arr[i].toLowerCase();
-        const v = arr[++i];
-        const trgV = headers[k];
-        // Array header -- only Set-Cookie at the moment
-        if (trgV && k === 'set-cookie') {
-            const a = Array.isArray(trgV) ? trgV : [trgV];
-            a.push(v);
-            headers[k] = a;
+    merge(update) {
+        directCopyProperties.forEach(k => {
+            if (update[k] != null)
+                this[k] = update[k];
+        });
+        if (update.headers) {
+            const h = update.headers instanceof http_headers_js_1.HttpHeaders
+                ? update.headers
+                : new http_headers_js_1.HttpHeaders(update.headers);
+            h.forEach((v, k) => {
+                if (k.toLowerCase() === 'set-cookie') {
+                    this.headers.append(k, v);
+                }
+                else
+                    this.headers.set(k, v);
+            });
         }
-        else if (typeof trgV === 'string') {
-            headers[k] += (k === 'cookie' ? '; ' : ', ') + v;
+    }
+    inset(src) {
+        directCopyProperties.forEach(k => {
+            if (this[k] == null && src[k] != null)
+                this[k] = src[k];
+        });
+        if (src.headers) {
+            const h = src.headers instanceof http_headers_js_1.HttpHeaders
+                ? src.headers
+                : new http_headers_js_1.HttpHeaders(src.headers);
+            h.forEach((v, k) => {
+                if (k.toLowerCase() === 'set-cookie') {
+                    this.headers.append(k, v);
+                }
+                else if (!this.headers.has(k))
+                    this.headers.set(k, v);
+            });
         }
-        else
-            headers[k] = v;
     }
-    return headers;
 }
+exports.HttpRequest = HttpRequest;

package/cjs/http/http-response.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpResponse = void 0;
+const http_headers_js_1 = require("./http-headers.js");
+class HttpResponse {
+    constructor(init) {
+        /**
+         * Returns true if response has body to be received
+         */
+        this.hasBody = false;
+        this.headers = new http_headers_js_1.HttpHeaders(init?.headers);
+        this.status = init?.status || 200;
+        this.statusText = init?.statusText || 'OK';
+        this.url = init?.url || null;
+        this.ok = this.status >= 200 && this.status < 300;
+        this.body = init?.body;
+        this.hasBody = init?.body != null || !!init?.hasBody;
+    }
+    clone(update) {
+        return new HttpResponse({ ...this, ...update });
+    }
+}
+exports.HttpResponse = HttpResponse;

package/cjs/http/index.js

@@ -1,9 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./http-request-node.js"), exports);
+tslib_1.__exportStar(require("./http-headers.js"), exports);
 tslib_1.__exportStar(require("./http-request.js"), exports);
-tslib_1.__exportStar(require("./enums/http-headers.enum.js"), exports);
-tslib_1.__exportStar(require("./enums/http-status.enum.js"), exports);
+tslib_1.__exportStar(require("./http-response.js"), exports);
+tslib_1.__exportStar(require("./http-params.js"), exports);
+tslib_1.__exportStar(require("./http-param-codec.js"), exports);
+tslib_1.__exportStar(require("./enums/http-headers-codes.enum.js"), exports);
+tslib_1.__exportStar(require("./enums/http-status-codes.enum.js"), exports);
 tslib_1.__exportStar(require("./interfaces/client-http-headers.interface.js"), exports);
 tslib_1.__exportStar(require("./interfaces/server-http-headers.interface.js"), exports);
+tslib_1.__exportStar(require("./param-codec/date-codec.js"), exports);
+tslib_1.__exportStar(require("./param-codec/boolean-codec.js"), exports);
+tslib_1.__exportStar(require("./param-codec/filter-codec.js"), exports);
+tslib_1.__exportStar(require("./param-codec/integer-codec.js"), exports);
+tslib_1.__exportStar(require("./param-codec/number-codec.js"), exports);
+tslib_1.__exportStar(require("./param-codec/string-codec.js"), exports);
 tslib_1.__exportStar(require("./utils/normalize-headers.js"), exports);