@opra/common 0.10.2 → 0.12.0

package/esm/url/opra-url-path.js

@@ -1,53 +1,43 @@
-import { EventEmitter } from 'events';
+var _a;
 import { tokenize } from 'fast-tokenizer';
 import { isURL } from '../utils/index.js';
 import { OpraURLPathComponent } from './opra-url-path-component.js';
 import { decodePathComponent, encodePathComponent, normalizePath } from './utils/path-utils.js';
 const nodeInspectCustom = Symbol.for('nodejs.util.inspect.custom');
-export class OpraURLPath extends EventEmitter {
-    constructor(...args) {
-        super();
-        this._entries = [];
-        for (const x of args) {
-            if (isURL(x)) {
-                this._parse(x.pathname);
-                continue;
-            }
-            // noinspection SuspiciousTypeOfGuard
-            if (x instanceof OpraURLPath)
-                this._entries.push(...x._entries);
-            else
-                this.add(x);
-        }
+const kEntries = Symbol('kEntries');
+const kOptions = Symbol('kOptions');
+export class OpraURLPath {
+    constructor(init, options) {
+        this[_a] = [];
+        this[kOptions] = { ...options, onChange: undefined };
+        if (Array.isArray(init))
+            this.join(...init);
+        else if (init)
+            this.join(init);
+        this[kOptions].onChange = options?.onChange;
     }
     get size() {
-        return this._entries.length;
+        return this[kEntries].length;
     }
-    add(component, key, typeCast) {
-        this._add(component, key, typeCast);
-        this.emit('change');
+    changed() {
+        if (this[kOptions].onChange)
+            this[kOptions].onChange();
     }
     clear() {
-        this._entries = [];
-        this.emit('change');
+        this[kEntries] = [];
+        this.changed();
     }
     get(index) {
-        return this._entries[index];
-    }
-    join(pathString) {
-        const pathTokenizer = tokenize(normalizePath(pathString, true), {
-            delimiters: '/', quotes: true, brackets: true,
-        });
-        for (const x of pathTokenizer) {
-            const p = decodePathComponent(x);
-            this._add(p);
-        }
-        this.emit('change');
+        return this[kEntries][index];
+    }
+    join(...source) {
+        source.forEach(x => this._join(this[kEntries], x));
+        this.changed();
         return this;
     }
     entries() {
         let i = -1;
-        const arr = [...this._entries];
+        const arr = [...this[kEntries]];
         return {
             [Symbol.iterator]() {
                 return this;
@@ -61,9 +51,46 @@ export class OpraURLPath extends EventEmitter {
             }
         };
     }
+    forEach(callback) {
+        for (const item of this[kEntries]) {
+            callback.call(this, item, this);
+        }
+    }
+    getResource(index) {
+        const v = this[kEntries][index];
+        return v == null ? undefined : v.resource;
+    }
+    getKey(index) {
+        const v = this[kEntries][index];
+        return v == null ? undefined : v.key;
+    }
+    pop() {
+        const out = this[kEntries].pop();
+        this.changed();
+        return out;
+    }
+    shift() {
+        const out = this[kEntries].shift();
+        this.changed();
+        return out;
+    }
+    slice(start, end) {
+        return new OpraURLPath(this[kEntries].slice(start, end));
+    }
+    splice(start, deleteCount, join) {
+        const items = (join ? this._join([], join) : []);
+        this[kEntries].splice(start, deleteCount, ...items);
+        this.changed();
+    }
+    unshift(join) {
+        return this.splice(0, 0, join);
+    }
+    toString() {
+        return this[kEntries].map(x => encodePathComponent(x.resource, x.key, x.typeCast)).join('/');
+    }
     values() {
         let i = -1;
-        const arr = [...this._entries];
+        const arr = [...this[kEntries]];
         return {
             [Symbol.iterator]() {
                 return this;
@@ -77,48 +104,45 @@ export class OpraURLPath extends EventEmitter {
             }
         };
     }
-    forEach(callback) {
-        for (const item of this._entries) {
-            callback.call(this, item.resource, item.key, this);
+    _join(target, source) {
+        if (typeof source === 'string') {
+            const pathTokenizer = tokenize(normalizePath(source, true), {
+                delimiters: '/', quotes: true, brackets: true,
+            });
+            for (const x of pathTokenizer) {
+                const p = decodePathComponent(x);
+                target.push(new OpraURLPathComponent(p));
+            }
+            return;
         }
+        if (source instanceof OpraURLPath) {
+            target.push(...source[kEntries].map(x => new OpraURLPathComponent(x)));
+            return;
+        }
+        if (typeof source === 'object' && source.path instanceof OpraURLPath) {
+            this._join(target, source.path);
+            return;
+        }
+        if (isURL(source)) {
+            this._join(target, source.pathname);
+            return;
+        }
+        if (Array.isArray(source)) {
+            source.forEach(x => this._join(target, x));
+            return;
+        }
+        target.push(new OpraURLPathComponent(source));
     }
-    getResource(index) {
-        const v = this._entries[index];
-        return v == null ? undefined : v.resource;
-    }
-    getKey(index) {
-        const v = this._entries[index];
-        return v == null ? undefined : v.key;
-    }
-    toString() {
-        return this._entries.map(x => encodePathComponent(x.resource, x.key, x.typeCast)).join('/');
+    /* istanbul ignore next */
+    [(_a = kEntries, nodeInspectCustom)]() {
+        return this[kEntries];
     }
     [Symbol.iterator]() {
         return this.entries();
     }
-    /* istanbul ignore next */
-    [nodeInspectCustom]() {
-        return this._entries;
-    }
-    _add(component, key, typeCast) {
-        if (component instanceof OpraURLPathComponent) {
-            this._entries.push(component);
-        }
-        else if (typeof component === 'object')
-            this._entries.push(new OpraURLPathComponent(component));
-        else
-            this._entries.push(new OpraURLPathComponent({ resource: component, key, typeCast }));
-    }
-    _parse(v) {
-        if (!v)
-            return;
-        const pathTokenizer = tokenize(v, { delimiters: '/', quotes: true, brackets: true });
-        for (const x of pathTokenizer) {
-            if (!x)
-                continue;
-            const p = decodePathComponent(x);
-            this._add(p);
-        }
-        this.emit('change');
+    get [Symbol.toStringTag]() {
+        return 'OpraURLPath';
     }
 }
+OpraURLPath.kEntries = kEntries;
+OpraURLPath.kOptions = kOptions;

package/esm/url/opra-url-search-params.d.ts

@@ -1,44 +1,5 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import { StrictOmit } from 'ts-gems';
-import { ResponsiveMap } from '../helpers/index.js';
-import { Format } from './formats/format.js';
-declare const nodeInspectCustom: unique symbol;
-interface OpraURLSearchParamItem {
-    name: string;
-    format?: Format | string;
-    array?: boolean | 'strict';
-    arrayDelimiter?: string;
-    minArrayItems?: number;
-    maxArrayItems?: number;
-}
-export declare class OpraURLSearchParams extends EventEmitter {
-    protected _params: ResponsiveMap<string, OpraURLSearchParamItem>;
-    private _entries;
-    private _size;
-    constructor(init?: (string | URLSearchParams | OpraURLSearchParams));
-    get size(): number;
-    addAll(values: URLSearchParams | OpraURLSearchParams | Map<string, any> | Record<string, any>): void;
-    append(name: string, value?: any): void;
-    clear(): void;
-    defineParam(name: string, options?: StrictOmit<OpraURLSearchParamItem, 'name'>): this;
-    delete(name: string): void;
-    entries(): IterableIterator<[string, any]>;
-    forEach(callback: (value: any, name: string, _this: this) => void): void;
-    get(name: string, index?: number): any | null;
-    getAll(name: string): any[];
-    has(name: string): boolean;
-    keys(): IterableIterator<string>;
-    set(name: string, value?: any): void;
-    sort(compareFn?: (a: string, b: string) => number): void;
-    values(): IterableIterator<any>;
-    toString(): string;
-    parse(input: string): void;
-    toURLSearchParams(): URLSearchParams;
-    [Symbol.iterator](): IterableIterator<[string, any]>;
+import { HttpParams, HttpParamsInit, HttpParamsOptions } from '../http/http-params.js';
+export declare class OpraURLSearchParams extends HttpParams {
+    constructor(init?: HttpParamsInit, options?: HttpParamsOptions);
     get [Symbol.toStringTag](): string;
-    [nodeInspectCustom](): ResponsiveMap<string, any[]>;
-    protected _delete(name: string): boolean;
-    protected _add(name: string, value: any): boolean;
 }
-export {};

package/esm/url/opra-url-search-params.js

@@ -1,242 +1,24 @@
-import { EventEmitter } from 'events';
-import { splitString, tokenize } from 'fast-tokenizer';
-import { ResponsiveMap } from '../helpers/index.js';
-import { BooleanFormat } from './formats/boolean-format.js';
-import { DateFormat } from './formats/date-format.js';
-import { FilterFormat } from './formats/filter-format.js';
-import { IntegerFormat } from './formats/integer-format.js';
-import { NumberFormat } from './formats/number-format.js';
-import { StringFormat } from './formats/string-format.js';
-const internalFormats = {
-    'integer': new IntegerFormat(),
-    'number': new NumberFormat(),
-    'string': new StringFormat(),
-    'boolean': new BooleanFormat(),
-    'date': new DateFormat(),
-    'filter': new FilterFormat()
-};
-const nodeInspectCustom = Symbol.for('nodejs.util.inspect.custom');
-export class OpraURLSearchParams extends EventEmitter {
-    constructor(init) {
-        super();
-        this._params = new ResponsiveMap();
-        this._entries = new ResponsiveMap();
-        this._size = 0;
-        this.defineParam('$filter', { format: 'filter' });
-        this.defineParam('$limit', { format: new IntegerFormat({ min: 0 }) });
-        this.defineParam('$skip', { format: new IntegerFormat({ min: 0 }) });
-        this.defineParam('$pick', { format: 'string', array: 'strict' });
-        this.defineParam('$omit', { format: 'string', array: 'strict' });
-        this.defineParam('$include', { format: 'string', array: 'strict' });
-        this.defineParam('$sort', { format: 'string', array: 'strict' });
-        this.defineParam('$distinct', { format: 'boolean' });
-        this.defineParam('$count', { format: 'boolean' });
-        if (init) {
-            if (typeof init === 'string')
-                this.parse(init);
-            else
-                this.addAll(init);
-        }
-    }
-    get size() {
-        return this._size;
-    }
-    addAll(values) {
-        let changed = false;
-        if (typeof values.forEach === 'function') {
-            values.forEach((value, name) => {
-                changed = this._add(name, value) || changed;
-            });
-        }
-        else if (typeof values === 'object') {
-            Object.entries((name, value) => {
-                changed = this._add(name, value) || changed;
-            });
-        }
-        else
-            throw new TypeError(`Invalid argument`);
-        if (changed)
-            this.emit('change');
-    }
-    append(name, value) {
-        if (this._add(name, value))
-            this.emit('change');
-    }
-    clear() {
-        this._entries.clear();
-        this._size = 0;
-        this.emit('change');
-    }
-    defineParam(name, options) {
-        if (!name)
-            throw new Error('Parameter name required');
-        const meta = {
+import { HttpParams } from '../http/http-params.js';
+import { IntegerCodec } from '../http/param-codec/integer-codec.js';
+export class OpraURLSearchParams extends HttpParams {
+    constructor(init, options) {
+        super(init, {
             ...options,
-            name,
-            format: options?.format || 'string'
-        };
-        if (typeof meta.format === 'string' && !internalFormats[meta.format])
-            throw new Error(`Unknown data format "${meta.format}"`);
-        meta.format = meta.format || 'string';
-        this._params.set(name, meta);
-        return this;
-    }
-    delete(name) {
-        if (this._delete(name))
-            this.emit('change');
-    }
-    entries() {
-        const items = [];
-        this.forEach((value, name) => {
-            items.push([name, value]);
-        });
-        return items.values();
-    }
-    forEach(callback) {
-        for (const [name, entry] of this._entries.entries()) {
-            for (let i = 0; i < entry.length; i++) {
-                callback(entry[i], name, this);
-            }
-        }
-    }
-    get(name, index) {
-        const entry = this._entries.get(name);
-        const v = entry && entry[index || 0];
-        return v == null ? null : v;
-    }
-    getAll(name) {
-        const entry = this._entries.get(name);
-        return entry ? entry.slice(0) : [];
-    }
-    has(name) {
-        return this._entries.has(name);
-    }
-    keys() {
-        return this._entries.keys();
-    }
-    set(name, value) {
-        this._delete(name);
-        this._add(name, value);
-        this.emit('change');
-    }
-    sort(compareFn) {
-        this._entries.sort(compareFn);
-        this.emit('change');
-    }
-    values() {
-        const items = [];
-        this.forEach((value) => items.push(value));
-        return items.values();
-    }
-    toString() {
-        let out = '';
-        this.forEach((v, k) => {
-            const qi = this._params.get(k);
-            const format = qi
-                ? (typeof qi.format === 'string' ? internalFormats[qi.format] : qi.format)
-                : undefined;
-            const stringify = (x) => encodeURIComponent(format ? format.stringify(x, k) : (x == null ? '' : '' + x));
-            const val = Array.isArray(v)
-                ? v.map(stringify).join(qi?.arrayDelimiter || ',')
-                : stringify(v);
-            if (val) {
-                if (out.length > 0)
-                    out += '&';
-                out += k + '=' + val;
-            }
-        });
-        return out;
-    }
-    parse(input) {
-        this._entries.clear();
-        this._size = 0;
-        if (input && input.startsWith('?'))
-            input = input.substring(1);
-        if (!input)
-            return;
-        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 = decodeURIComponent(itemTokenizer.next() || '');
-            const v = itemTokenizer.join('=');
-            const qi = this._params.get(k);
-            if (qi?.array) {
-                const values = splitString(v, {
-                    delimiters: qi?.arrayDelimiter || ',',
-                    brackets: true,
-                    quotes: true
-                }).map((x) => decodeURIComponent(x));
-                this._add(k, values);
+            params: {
+                '$filter': { codec: 'filter' },
+                '$limit': { codec: new IntegerCodec({ min: 0 }) },
+                '$skip': { codec: new IntegerCodec({ min: 0 }) },
+                '$pick': { codec: 'string', array: 'strict' },
+                '$omit': { codec: 'string', array: 'strict' },
+                '$include': { codec: 'string', array: 'strict' },
+                '$sort': { codec: 'string', array: 'strict' },
+                '$distinct': { codec: 'boolean' },
+                '$count': { codec: 'boolean' },
+                ...options?.params
             }
-            else {
-                this._add(k, decodeURIComponent(v));
-            }
-        }
-        this.emit('change');
-    }
-    toURLSearchParams() {
-        const out = new URLSearchParams();
-        this.forEach((v, k) => {
-            const qi = this._params.get(k);
-            const format = qi
-                ? (typeof qi.format === 'string' ? internalFormats[qi.format] : qi.format)
-                : undefined;
-            const stringify = (x) => format ? format.stringify(x, k) : (x == null ? '' : '' + x);
-            const val = Array.isArray(v)
-                ? v.map(stringify).join(qi?.arrayDelimiter || ',')
-                : stringify(v);
-            out.append(k, val);
         });
-        return out;
-    }
-    [Symbol.iterator]() {
-        return this.entries();
     }
     get [Symbol.toStringTag]() {
         return 'URLSearchParams';
     }
-    [nodeInspectCustom]() {
-        return this._entries;
-    }
-    _delete(name) {
-        const a = this._entries.get(name);
-        if (!a)
-            return false;
-        this._size -= a.length;
-        this._entries.delete(name);
-        return true;
-    }
-    _add(name, value) {
-        const qi = this._params.get(name);
-        const format = qi ?
-            (typeof qi.format === 'string' ? internalFormats[qi.format] : qi.format) : undefined;
-        const fn = (x) => format ? format.parse(x, name) : x;
-        let v = Array.isArray(value) ? value.map(fn) : fn(value);
-        if (qi) {
-            if (qi.array === 'strict')
-                v = Array.isArray(v) ? v : [v];
-            else if (qi.array)
-                v = Array.isArray(v) && v.length === 1 ? v[0] : v;
-            if (Array.isArray(v)) {
-                if (qi.minArrayItems && v.length < qi.minArrayItems)
-                    throw new Error(`"${name}" parameter requires at least ${qi.minArrayItems} values`);
-                if (qi.maxArrayItems && v.length > qi.maxArrayItems)
-                    throw new Error(`"${name}" parameter accepts up to ${qi.maxArrayItems} values`);
-            }
-        }
-        let entry = this._entries.get(name);
-        if (!entry) {
-            entry = [];
-            this._entries.set(name, entry);
-        }
-        entry.push(v);
-        this._size++;
-        return true;
-    }
 }

package/esm/url/opra-url.d.ts

@@ -1,42 +1,52 @@
+import type { HttpParamDefinition } from '../http/http-params.js';
 import { OpraURLPath } from './opra-url-path.js';
+import { OpraURLPathComponentInit } from './opra-url-path-component.js';
 import { OpraURLSearchParams } from './opra-url-search-params.js';
 declare const nodeInspectCustom: unique symbol;
-declare const CONTEXT_KEY: unique symbol;
-declare const PATH_KEY: unique symbol;
-declare const SEARCHPARAMS_KEY: unique symbol;
+declare const kContext: unique symbol;
+declare const kPath: unique symbol;
+declare const kSearchParams: unique symbol;
 export declare class OpraURL {
-    protected [CONTEXT_KEY]: {
+    protected static kContext: symbol;
+    protected static kPath: symbol;
+    protected static kSearchParams: symbol;
+    protected [kContext]: {
         protocol: string;
         username: string;
-        password: string;
+        pathname: string;
+        prefix: string;
         hostname: string;
-        pathPrefix: string;
-        port: number | null;
+        port: string;
         hash: string;
-        pathname: string;
+        password: string;
         search: string;
+        address: string;
         needUpdate: boolean;
     };
-    protected [PATH_KEY]: OpraURLPath;
-    protected [SEARCHPARAMS_KEY]: OpraURLSearchParams;
-    constructor(input?: string, pathPrefix?: string);
+    protected [kPath]: OpraURLPath;
+    protected [kSearchParams]: OpraURLSearchParams;
+    constructor(input?: string | URL | OpraURL, base?: string | URL | OpraURL);
+    constructor(input?: string | URL | OpraURL, options?: {
+        base?: string | URL | OpraURL;
+        params?: Record<string, HttpParamDefinition>;
+    });
     get address(): string;
+    get host(): string;
+    set host(v: string);
+    get hostname(): string;
+    set hostname(v: string);
     get href(): string;
+    get password(): string;
+    set password(v: string);
+    get port(): string;
+    set port(value: string);
+    get prefix(): string;
+    set prefix(value: string);
     get protocol(): string;
     set protocol(v: string);
     get username(): string;
     set username(v: string);
-    get password(): string;
-    set password(v: string);
-    get host(): string;
-    set host(v: string);
-    get hostname(): string;
-    set hostname(v: string);
-    get port(): number | null;
-    set port(v: number | null);
     get origin(): string;
-    get pathPrefix(): string;
-    set pathPrefix(v: string);
     get path(): OpraURLPath;
     get pathname(): string;
     set pathname(v: string);
@@ -45,18 +55,18 @@ export declare class OpraURL {
     set hash(v: string);
     get search(): string;
     set search(v: string);
-    addPath(name: string, key?: any): this;
-    addSearchParam(name: string, value?: any): this;
+    parse(input: string): void;
+    join(...source: (string | OpraURLPath | URL | OpraURL | OpraURLPathComponentInit)[]): this;
+    addParam(name: string, value?: any): this;
+    setParam(name: string, value?: any): this;
     setHost(v: string): this;
     setHostname(v: string): this;
     setProtocol(v: string): this;
-    setPort(v: number | null): this;
+    setPort(v: string | number | null): this;
     setPrefix(v: string): this;
     setPathname(v: string): this;
     setHash(v: string): this;
     setSearch(v: string): this;
-    setSearchParam(name: string, value?: any): this;
-    parse(input: string): this;
     toString(): string;
     [nodeInspectCustom](): {
         protocol: string;
@@ -72,8 +82,8 @@ export declare class OpraURL {
         searchParams: OpraURLSearchParams;
         hash: string;
     };
-    protected _invalidate(): void;
     protected _update(): void;
-    protected _setPathname(v: string, inclSvcRoot?: boolean): void;
+    protected _setPathname(v: string, trimPrefix?: boolean): void;
+    protected _changed(): void;
 }
 export {};