@opra/common 0.10.3 → 0.13.0

package/esm/http/http-params.d.ts

@@ -0,0 +1,99 @@
+import { StrictOmit } from 'ts-gems';
+import { ResponsiveMap } from '../helpers/responsive-map.js';
+import { HttpParamCodec } from './http-param-codec.js';
+declare const kEntries: unique symbol;
+declare const kSize: unique symbol;
+declare const kParamDefs: unique symbol;
+declare const kOptions: unique symbol;
+export type HttpParamsInit = string | URLSearchParams | HttpParams | Map<string, any> | Record<string, any>;
+export interface HttpParamsCodec {
+    encodeKey?: (key: string) => string;
+    decodeKey?: (key: string) => string;
+    encodeValue?: (value: any) => string;
+    decodeValue?: (value: string) => any;
+}
+interface HttpParamMeta {
+    codec: HttpParamCodec;
+    array?: boolean | 'strict';
+    arrayDelimiter?: string;
+    minArrayItems?: number;
+    maxArrayItems?: number;
+}
+export type HttpParamDefinition = StrictOmit<HttpParamMeta, 'codec'> & {
+    codec?: HttpParamCodec | string;
+};
+export interface HttpParamsOptions extends HttpParamsCodec {
+    onChange?: () => void;
+    params?: Record<string, HttpParamDefinition>;
+}
+export declare class HttpParams {
+    protected static kEntries: symbol;
+    protected static kSize: symbol;
+    protected static kParamDefs: symbol;
+    protected static kOptions: symbol;
+    protected [kEntries]: ResponsiveMap<string, any[]>;
+    protected [kSize]: number;
+    protected [kOptions]: HttpParamsOptions;
+    protected [kParamDefs]: Map<string, HttpParamMeta>;
+    constructor(init?: HttpParamsInit, options?: HttpParamsOptions);
+    get size(): number;
+    /**
+     * Appends a new value to the existing set of values for a parameter
+     * and returns this instance
+     */
+    append(name: string, value?: any): this;
+    appendAll(input: HttpParamsInit): this;
+    changed(): void;
+    clear(): void;
+    /**
+     * Deletes values for a given parameter
+     */
+    delete(name: string, value?: any): this;
+    /**
+     * Returns an iterable of key, value pairs for every entry in the map.
+     */
+    entries(): IterableIterator<[string, string]>;
+    forEach(callbackFn: (value: string, key: string, parent: HttpParams) => void, thisArg?: any): void;
+    /**
+     * Retrieves value of a given parameter at given index
+     */
+    get(name: string, index?: number): any;
+    /**
+     * Retrieves an array of values for a given parameter.
+     */
+    getAll(name: string): any[] | null;
+    /**
+     * Retrieves the names of the parameters.
+     */
+    keys(): IterableIterator<string>;
+    /**
+     * Retrieves the names of the parameters.
+     */
+    values(): IterableIterator<any>;
+    /**
+     * Checks for existence of a parameter.
+     */
+    has(name: string): boolean;
+    /**
+     * Sets or modifies a value for a given parameter.
+     * If the header already exists, its value is replaced with the given value
+     */
+    set(name: string, value: any): this;
+    sort(compareFn?: (a: string, b: string) => number): this;
+    /**
+     * Serializes the body to an encoded string, where key-value pairs (separated by `=`) are
+     * separated by `&`s.
+     */
+    toString(): string;
+    define(name: string, options?: HttpParamDefinition): this;
+    encodeKey(key: string): string;
+    decodeKey(key: string): string;
+    encodeValue(value: any, key: string): string;
+    decodeValue(value: string, key: string): any;
+    protected _append(name: string, value?: any): void;
+    protected _delete(name: string, value?: string | string[]): boolean;
+    protected _set(name: string, value: any, index?: number): void;
+    [Symbol.iterator](): IterableIterator<[string, string]>;
+    get [Symbol.toStringTag](): string;
+}
+export {};

package/esm/http/http-params.js

@@ -0,0 +1,317 @@
+var _a, _b, _c;
+import { splitString, tokenize } from 'fast-tokenizer';
+import { ResponsiveMap } from '../helpers/responsive-map.js';
+import { BooleanCodec } from './param-codec/boolean-codec.js';
+import { DateCodec } from './param-codec/date-codec.js';
+import { FilterCodec } from './param-codec/filter-codec.js';
+import { IntegerCodec } from './param-codec/integer-codec.js';
+import { NumberCodec } from './param-codec/number-codec.js';
+import { StringCodec } from './param-codec/string-codec.js';
+import { encodeURIParam } from './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) => encodeURIParam(s);
+const defaultValueEncoder = (s) => encodeURIParam(s);
+const internalCodecs = {
+    'boolean': new BooleanCodec(),
+    'date': new DateCodec(),
+    'filter': new FilterCodec(),
+    'integer': new IntegerCodec(),
+    'number': new NumberCodec(),
+    'string': new StringCodec()
+};
+export class HttpParams {
+    constructor(init, options) {
+        this[_a] = new 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 = tokenize(input, { delimiters: '&', quotes: true, brackets: true });
+            for (const token of tokenizer) {
+                if (!token)
+                    continue;
+                const itemTokenizer = 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) => 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 = 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';
+    }
+}
+HttpParams.kEntries = kEntries;
+HttpParams.kSize = kSize;
+HttpParams.kParamDefs = kParamDefs;
+HttpParams.kOptions = kOptions;

package/esm/http/http-request-node.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Readable } from 'stream';
+declare const kHeaders: unique symbol;
+declare const kHeadersCount: unique symbol;
+declare const kTrailers: unique symbol;
+declare const kTrailersCount: unique symbol;
+export declare class HttpRequestNode extends Readable {
+    httpVersionMajor: number;
+    httpVersionMinor: number;
+    httpVersion: string;
+    complete: boolean;
+    rawHeaders: string[];
+    rawTrailers: string[];
+    aborted: boolean;
+    upgrade: boolean;
+    url: string;
+    originalUrl: string;
+    method: string;
+    shouldKeepAlive: boolean;
+    data?: Buffer;
+    body?: any;
+    [kHeaders]: Record<string, string | string[]>;
+    [kHeadersCount]: number;
+    [kTrailers]: Record<string, string | string[]>;
+    [kTrailersCount]: number;
+    get headers(): Record<string, string | string[]>;
+    get headersCount(): number;
+    get trailers(): Record<string, string | string[]>;
+    get trailersCount(): number;
+    _read(): void;
+    static parse(input: Buffer): HttpRequestNode;
+}
+export {};

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

@@ -0,0 +1,101 @@
+import { HTTPParser } from 'http-parser-js';
+import { Readable } from '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
+export class HttpRequestNode extends 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 HTTPParser(HTTPParser.REQUEST);
+        const out = new HttpRequestNode();
+        const bodyChunks = [];
+        parser[HTTPParser.kOnHeadersComplete] = function (req) {
+            out.shouldKeepAlive = req.shouldKeepAlive;
+            out.upgrade = req.upgrade;
+            out.method = 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[HTTPParser.kOnBody] = function (chunk, offset, length) {
+            bodyChunks.push(chunk.subarray(offset, offset + length));
+        };
+        // This is actually the event for trailers, go figure.
+        parser[HTTPParser.kOnHeaders] = function (t) {
+            out.rawTrailers = t;
+            out[kTrailersCount] = Math.ceil(t.length / 2);
+        };
+        parser[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;
+    }
+}
+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/esm/http/http-request.d.ts

@@ -1,34 +1,76 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { Readable } from 'stream';
-declare const kHeaders: unique symbol;
-declare const kHeadersCount: unique symbol;
-declare const kTrailers: unique symbol;
-declare const kTrailersCount: unique symbol;
-export declare class HttpRequest extends Readable {
-    httpVersionMajor: number;
-    httpVersionMinor: number;
-    httpVersion: string;
-    complete: boolean;
-    rawHeaders: string[];
-    rawTrailers: string[];
-    aborted: boolean;
-    upgrade: boolean;
-    url: string;
-    originalUrl: string;
+/// <reference lib="dom" />
+import { OpraURL, OpraURLPath, OpraURLSearchParams } from '../url/index.js';
+import { HttpHeaders, HttpHeadersInit } from './http-headers.js';
+import { HttpParamsInit } from './http-params.js';
+export interface HttpRequestInit {
+    cache?: RequestCache;
+    credentials?: RequestCredentials;
+    destination?: RequestDestination;
+    headers?: HttpHeadersInit;
+    integrity?: string;
+    keepalive?: boolean;
+    method?: string;
+    mode?: RequestMode;
+    params?: HttpParamsInit;
+    redirect?: RequestRedirect;
+    referrer?: string;
+    referrerPolicy?: ReferrerPolicy;
+    signal?: AbortSignal;
+    url?: string;
+    body?: any;
+}
+export declare class HttpRequest {
+    /** Returns the cache mode associated with request, which is a string indicating
+     * how the request will interact with the browser's cache when fetching. */
+    cache: RequestCache;
+    /** Returns the credentials mode associated with request, which is a string indicating
+     * whether credentials will be sent with the request always, never,
+     * or only when sent to a same-origin URL. */
+    credentials: RequestCredentials;
+    /** Returns the kind of resource requested by request, e.g., "document" or "script". */
+    destination: RequestDestination;
+    /** Returns a Headers object consisting of the headers associated with request.
+     * Note that headers added in the network layer by the user agent will not be accounted for in this object,
+     * e.g., the "Host" header. */
+    headers: HttpHeaders;
+    /** Returns request's subresource integrity metadata, which is a cryptographic
+     * hash of the resource being fetched.
+     * Its value consists of multiple hashes separated by whitespace. [SRI] */
+    integrity: string;
+    /** Returns a boolean indicating whether or not request can outlive the global in which it was created. */
+    keepalive: boolean;
+    /** Returns request's HTTP method, which is "GET" by default. */
     method: string;
-    shouldKeepAlive: boolean;
-    data?: Buffer;
+    /** Returns the mode associated with request, which is a string indicating whether the request will use CORS,
+     *  or will be restricted to same-origin URLs. */
+    mode: RequestMode;
+    /** Returns the redirect mode associated with request, which is a string indicating
+     * how redirects for the request will be handled during fetching. A request will follow redirects by default. */
+    redirect: RequestRedirect;
+    /** Returns the referrer of request. Its value can be a same-origin URL if explicitly set in init,
+     *  the empty string to indicate no referrer, and "about:client" when defaulting to the global's default.
+     *  This is used during fetching to determine the value of the `Referer` header of the request being made. */
+    referrer: string;
+    /** Returns the referrer policy associated with request. This is used during fetching
+     * to compute the value of the request's referrer. */
+    referrerPolicy: ReferrerPolicy;
+    /** Returns the signal associated with request, which is an AbortSignal object indicating
+     *  whether or not request has been aborted, and its abort event handler. */
+    signal?: AbortSignal;
+    /** Returns the parsed url as OpraURL instance */
+    readonly urlInstance: OpraURL;
+    /** Body of the http request */
     body?: any;
-    [kHeaders]: Record<string, string | string[]>;
-    [kHeadersCount]: number;
-    [kTrailers]: Record<string, string | string[]>;
-    [kTrailersCount]: number;
-    get headers(): Record<string, string | string[]>;
-    get headersCount(): number;
-    get trailers(): Record<string, string | string[]>;
-    get trailersCount(): number;
-    _read(): void;
-    static parse(input: Buffer): HttpRequest;
+    duplex?: 'half';
+    constructor(init?: HttpRequestInit);
+    /** Returns the URL of request as a string. */
+    get url(): string;
+    set url(value: string);
+    /** Returns the searchParams of the URL as OpraURLSearchParams */
+    get params(): OpraURLSearchParams;
+    /** Returns the path part of URL as OpraURLPath */
+    get path(): OpraURLPath;
+    clone(...update: (HttpRequest | HttpRequestInit)[]): HttpRequest;
+    merge(update: HttpRequest | HttpRequestInit): void;
+    inset(src: HttpRequest | HttpRequestInit): void;
 }
-export {};