@opra/common 0.4.0 → 0.6.0

package/esm/url/formats/boolean-format.js

@@ -0,0 +1,21 @@
+import { Format } from './format.js';
+const trueValues = ['true', 't', 'yes', 'y', '1'];
+const falseValues = ['false', 'f', 'no', 'n', '0'];
+export class BooleanFormat extends Format {
+    parse(value) {
+        if (value === '')
+            return true;
+        // noinspection SuspiciousTypeOfGuard
+        if (typeof value === 'boolean')
+            return value;
+        if (trueValues.includes(value.toLowerCase()))
+            return true;
+        if (falseValues.includes(value.toLowerCase()))
+            return false;
+        throw new TypeError(`"${value}" is not a valid boolean`);
+    }
+    stringify(value) {
+        return typeof value === 'boolean' ?
+            (value ? 'true' : 'false') : '';
+    }
+}

package/esm/url/formats/date-format.d.ts

@@ -0,0 +1,16 @@
+import { Format } from './format.js';
+export interface DateFormatOptions {
+    time?: boolean;
+    timeZone?: boolean;
+    min?: string;
+    max?: string;
+}
+export declare class DateFormat extends Format {
+    time: boolean;
+    timeZone: boolean;
+    min?: string;
+    max?: string;
+    constructor(options?: DateFormatOptions);
+    parse(value: string): string;
+    stringify(value: any): string;
+}

package/esm/url/formats/date-format.js

@@ -0,0 +1,44 @@
+/* eslint-disable max-len */
+import { Format } from './format.js';
+// noinspection RegExpUnnecessaryNonCapturingGroup
+const DATE_FORMAT_PATTERN = /^(\d{4})(?:-?(0[1-9]|1[012])(?:-?([123]0|[012][1-9]|31))?)?(?:[T ]?([01][0-9]|2[0-3]):?([0-5][0-9]):?([0-5][0-9])?(?:\.(\d+))?(?:(Z)|(?:([+-])([01]?[0-9]|2[0-3]):?([0-5][0-9])?))?)?$/;
+export class DateFormat extends Format {
+    time;
+    timeZone;
+    min;
+    max;
+    constructor(options) {
+        super();
+        this.max = options?.max ? coerceToDateString(options.max) : undefined;
+        this.min = options?.min ? coerceToDateString(options.min) : undefined;
+        this.time = options?.time ?? true;
+        this.timeZone = options?.timeZone ?? true;
+    }
+    parse(value) {
+        const v = coerceToDateString(value, this.time, this.timeZone);
+        if (this.min != null && v < this.min)
+            throw new TypeError(`Value must be ${this.min} or greater.`);
+        if (this.max != null && v > this.max)
+            throw new TypeError(`Value must be ${this.max} or less.`);
+        return v;
+    }
+    stringify(value) {
+        return coerceToDateString(value, this.time, this.timeZone);
+    }
+}
+function coerceToDateString(value, time, timeZone) {
+    if (value === '' || value == null)
+        return '';
+    const m = value.match(DATE_FORMAT_PATTERN);
+    if (!m)
+        throw new TypeError(`"${value}" is not a valid date.`);
+    let v = m[1] + '-' + (m[2] || '01') + '-' + (m[3] || '01');
+    if (time) {
+        v += 'T' + (m[4] || '00') + ':' + (m[5] || '00') + ':' + (m[6] || '00') +
+            (m[7] ? '.' + m[7] : '');
+        if (timeZone)
+            v += m[8] ? 'Z' :
+                (m[9] ? (m[9] + (m[10] || '00') + ':' + (m[11] || '00')) : '');
+    }
+    return v;
+}

package/esm/url/formats/filter-format.d.ts

@@ -0,0 +1,6 @@
+import { Ast, Expression } from '../../filter/ast/index.js';
+import { Format } from './format.js';
+export declare class FilterFormat extends Format {
+    parse(value: string | Expression): object;
+    stringify(value: Ast): string;
+}

package/esm/url/formats/filter-format.js

@@ -0,0 +1,14 @@
+import { Expression } from '../../filter/ast/index.js';
+import { parseFilter } from '../../filter/parse.js';
+import { Format } from './format.js';
+export class FilterFormat extends Format {
+    parse(value) {
+        if (value instanceof Expression)
+            return value;
+        return parseFilter(value);
+    }
+    stringify(value) {
+        // @ts-ignore
+        return value ? '' + value : '';
+    }
+}

package/esm/url/formats/format.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class Format {
+    abstract parse(value: string): any;
+    abstract stringify(value: any): string;
+}

package/esm/url/formats/format.js

@@ -0,0 +1,2 @@
+export class Format {
+}

package/esm/url/formats/integer-format.d.ts

@@ -0,0 +1,9 @@
+import { NumberFormat, NumberFormatOptions } from './number-format.js';
+export interface IntegerFormatOptions extends NumberFormatOptions {
+    enum?: number[];
+}
+export declare class IntegerFormat extends NumberFormat {
+    enum?: number[];
+    constructor(options?: IntegerFormatOptions);
+    parse(value: string): number;
+}

package/esm/url/formats/integer-format.js

@@ -0,0 +1,16 @@
+import { NumberFormat } from './number-format.js';
+export class IntegerFormat extends NumberFormat {
+    enum;
+    constructor(options) {
+        super(options);
+        this.enum = options?.enum;
+    }
+    parse(value) {
+        const v = super.parse(value);
+        if (!Number.isInteger(v))
+            throw new TypeError(`"${value}" is not a valid integer`);
+        if (this.enum && !this.enum.includes(v))
+            throw new TypeError(`"${value}" is not one of allowed enum values (${this.enum}).`);
+        return v;
+    }
+}

package/esm/url/formats/number-format.d.ts

@@ -0,0 +1,12 @@
+import { Format } from './format.js';
+export interface NumberFormatOptions {
+    max?: number;
+    min?: number;
+}
+export declare class NumberFormat extends Format {
+    max?: number;
+    min?: number;
+    constructor(options?: NumberFormatOptions);
+    parse(value: string): number;
+    stringify(value: any): string;
+}

package/esm/url/formats/number-format.js

@@ -0,0 +1,24 @@
+import { Format } from './format.js';
+export class NumberFormat extends Format {
+    max;
+    min;
+    constructor(options) {
+        super();
+        this.max = options?.max;
+        this.min = options?.min;
+    }
+    parse(value) {
+        // noinspection SuspiciousTypeOfGuard
+        const v = typeof value === 'number' ? value : parseFloat(value);
+        if (isNaN(v))
+            throw new TypeError(`"${value}" is not a valid number`);
+        if (this.min != null && v < this.min)
+            throw new TypeError(`Value must be ${this.min} or greater.`);
+        if (this.max != null && v > this.max)
+            throw new TypeError(`Value must be ${this.max} or less.`);
+        return v;
+    }
+    stringify(value) {
+        return typeof value === 'number' ? '' + value : '';
+    }
+}

package/esm/url/formats/string-format.d.ts

@@ -0,0 +1,14 @@
+import { Format } from './format.js';
+export interface StringFormatOptions {
+    maxLength?: number;
+    minLength?: number;
+    enum?: string[];
+}
+export declare class StringFormat extends Format {
+    maxLength?: number;
+    minLength?: number;
+    enum?: string[];
+    constructor(options?: StringFormatOptions);
+    parse(value: string): string;
+    stringify(value: any): string;
+}

package/esm/url/formats/string-format.js

@@ -0,0 +1,24 @@
+import { Format } from './format.js';
+export class StringFormat extends Format {
+    maxLength;
+    minLength;
+    enum;
+    constructor(options) {
+        super();
+        this.maxLength = options?.maxLength;
+        this.minLength = options?.minLength;
+        this.enum = options?.enum;
+    }
+    parse(value) {
+        if (this.minLength != null && value.length < this.minLength)
+            throw new TypeError(`Value must be at least ${this.minLength} character${this.minLength > 1 ? 's' : ''} long.`);
+        if (this.maxLength != null && value.length > this.maxLength)
+            throw new TypeError(`Value can be up to ${this.maxLength} character${this.maxLength > 1 ? 's' : ''} long.`);
+        if (this.enum && !this.enum.includes(value))
+            throw new TypeError(`"${value}" is not one of allowed enum values (${this.enum}).`);
+        return value;
+    }
+    stringify(value) {
+        return value == null ? '' : '' + value;
+    }
+}

package/esm/url/index.d.ts

@@ -0,0 +1,5 @@
+export * from './opra-url.js';
+export * from './opra-url-path.js';
+export * from './opra-url-path-component.js';
+export * from './opra-url-search-params.js';
+export * from './utils/path-utils.js';

package/esm/url/index.js

@@ -0,0 +1,5 @@
+export * from './opra-url.js';
+export * from './opra-url-path.js';
+export * from './opra-url-path-component.js';
+export * from './opra-url-search-params.js';
+export * from './utils/path-utils.js';

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

@@ -0,0 +1,15 @@
+declare const nodeInspectCustom: unique symbol;
+export declare type OpraURLPathComponentInit = {
+    resource: string;
+    key?: any;
+    typeCast?: string;
+};
+export declare class OpraURLPathComponent {
+    resource: string;
+    key?: any;
+    typeCast?: string;
+    constructor(init: OpraURLPathComponentInit);
+    toString(): string;
+    [nodeInspectCustom](): any;
+}
+export {};

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

@@ -0,0 +1,29 @@
+import { encodePathComponent } from './utils/path-utils.js';
+const nodeInspectCustom = Symbol.for('nodejs.util.inspect.custom');
+export class OpraURLPathComponent {
+    resource;
+    key;
+    typeCast;
+    constructor(init) {
+        this.resource = init.resource;
+        this.key = init.key;
+        this.typeCast = init.typeCast;
+    }
+    toString() {
+        const obj = encodePathComponent(this.resource, this.key, this.typeCast);
+        if (obj)
+            Object.setPrototypeOf(obj, OpraURLPathComponent.prototype);
+        return obj;
+    }
+    /* istanbul ignore next */
+    [nodeInspectCustom]() {
+        const out = {
+            resource: this.resource,
+        };
+        if (this.key != null)
+            out.key = this.key;
+        if (this.typeCast != null)
+            out.typeCast = this.typeCast;
+        return out;
+    }
+}

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

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { OpraURLPathComponent, OpraURLPathComponentInit } from './opra-url-path-component.js';
+declare const nodeInspectCustom: unique symbol;
+export declare class OpraURLPath extends EventEmitter {
+    private _entries;
+    constructor(...components: (OpraURLPathComponent | OpraURLPathComponentInit)[]);
+    constructor(init?: string | OpraURLPath | URL | OpraURLPathComponent | OpraURLPathComponentInit);
+    get size(): number;
+    add(component: OpraURLPathComponent | {
+        resource: string;
+        key?: any;
+        typeCast?: string;
+    }): void;
+    add(name: string, key?: any, typeCast?: string): void;
+    clear(): void;
+    get(index: number): OpraURLPathComponent;
+    join(pathString: string): this;
+    entries(): IterableIterator<[OpraURLPathComponent, number]>;
+    values(): IterableIterator<OpraURLPathComponent>;
+    forEach(callback: (name: string, key: any, _this: this) => void): void;
+    getResource(index: number): string | undefined;
+    getKey(index: number): any;
+    toString(): string;
+    [Symbol.iterator](): IterableIterator<[OpraURLPathComponent, number]>;
+    [nodeInspectCustom](): OpraURLPathComponent[];
+    protected _add(component: any, key?: any, typeCast?: string): void;
+    protected _parse(v: string): void;
+}
+export {};

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

@@ -0,0 +1,124 @@
+import { EventEmitter } from 'events';
+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 {
+    _entries = [];
+    constructor(...args) {
+        super();
+        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);
+        }
+    }
+    get size() {
+        return this._entries.length;
+    }
+    add(component, key, typeCast) {
+        this._add(component, key, typeCast);
+        this.emit('change');
+    }
+    clear() {
+        this._entries = [];
+        this.emit('change');
+    }
+    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;
+    }
+    entries() {
+        let i = -1;
+        const arr = [...this._entries];
+        return {
+            [Symbol.iterator]() {
+                return this;
+            },
+            next() {
+                i++;
+                return {
+                    done: i >= arr.length,
+                    value: [arr[i], i]
+                };
+            }
+        };
+    }
+    values() {
+        let i = -1;
+        const arr = [...this._entries];
+        return {
+            [Symbol.iterator]() {
+                return this;
+            },
+            next() {
+                i++;
+                return {
+                    done: i >= arr.length,
+                    value: arr[i]
+                };
+            }
+        };
+    }
+    forEach(callback) {
+        for (const item of this._entries) {
+            callback.call(this, item.resource, item.key, this);
+        }
+    }
+    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('/');
+    }
+    [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');
+    }
+}

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

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { StrictOmit } from 'ts-gems';
+import { URLSearchParams } from 'url';
+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]>;
+    get [Symbol.toStringTag](): string;
+    [nodeInspectCustom](): ResponsiveMap<string, any[]>;
+    protected _delete(name: string): boolean;
+    protected _add(name: string, value: any): boolean;
+}
+export {};