@opra/common 0.5.0 → 0.7.0

package/esm/filter/ast/terms/string-literal.js

@@ -0,0 +1,10 @@
+import { quoteFilterString } from '../../utils.js';
+import { Literal } from '../abstract/literal.js';
+export class StringLiteral extends Literal {
+    constructor(value) {
+        super('' + value);
+    }
+    toString() {
+        return quoteFilterString(this.value);
+    }
+}

package/esm/filter/ast/terms/time-literal.d.ts

@@ -0,0 +1,6 @@
+import { Literal } from '../abstract/literal.js';
+export declare class TimeLiteral extends Literal {
+    value: string;
+    constructor(value: string | Date);
+    toString(): string;
+}

package/esm/filter/ast/terms/time-literal.js

@@ -0,0 +1,29 @@
+import { ValidationError } from '../../errors.js';
+import { quoteFilterString } from '../../utils.js';
+import { Literal } from '../abstract/literal.js';
+const TIME_PATTERN = /^([01]\d|2[0-3]):([0-5]\d)(:[0-5]\d)?(\.(\d+))?$/;
+export class TimeLiteral extends Literal {
+    value;
+    constructor(value) {
+        super('');
+        if (value instanceof Date) {
+            this.value = pad(value.getHours()) + ':' +
+                pad(value.getMinutes()) +
+                (value.getSeconds() ? ':' + pad(value.getSeconds()) : '') +
+                (value.getMilliseconds() ? '.' + pad(value.getMilliseconds()) : '');
+            return;
+        }
+        // noinspection SuspiciousTypeOfGuard
+        if (typeof value === 'string' && TIME_PATTERN.test(value)) {
+            this.value = value;
+            return;
+        }
+        throw new ValidationError(`Invalid time value "${value}"`);
+    }
+    toString() {
+        return quoteFilterString(this.value);
+    }
+}
+function pad(n) {
+    return n <= 9 ? '0' + n : '' + n;
+}

package/esm/filter/build.d.ts

@@ -0,0 +1,31 @@
+import { ArithmeticExpression, ArrayExpression, ComparisonExpression, DateLiteral, Expression, LogicalExpression, NumberLiteral, ParenthesesExpression, QualifiedIdentifier, TimeLiteral } from './ast/index.js';
+declare type _EntryValue = Expression | string | number | bigint | boolean | null | Date;
+export declare type EntryValue = _EntryValue | _EntryValue[];
+export declare function $or(...items: Expression[]): LogicalExpression;
+export declare function $and(...items: Expression[]): LogicalExpression;
+export declare function $date(v: string): DateLiteral;
+export declare function $time(v: string): TimeLiteral;
+export declare function $number(v: string | number | bigint): NumberLiteral;
+export declare function $array(...items: EntryValue[]): ArrayExpression;
+export declare function $field(v: string): QualifiedIdentifier;
+export declare function $eq(left: EntryValue, right: EntryValue): ComparisonExpression;
+export declare function $ne(left: EntryValue, right: EntryValue): ComparisonExpression;
+export declare function $gt(left: EntryValue, right: EntryValue): ComparisonExpression;
+export declare function $gte(left: EntryValue, right: EntryValue): ComparisonExpression;
+export declare function $lt(left: EntryValue, right: EntryValue): ComparisonExpression;
+export declare function $lte(left: EntryValue, right: EntryValue): ComparisonExpression;
+export declare function $in(left: EntryValue, right: EntryValue): ComparisonExpression;
+export declare function $notIn(left: EntryValue, right: EntryValue): ComparisonExpression;
+export declare function $like(left: EntryValue, right: EntryValue): ComparisonExpression;
+export declare function $notLike(left: _EntryValue, right: _EntryValue): ComparisonExpression;
+export declare function $ilike(left: _EntryValue, right: _EntryValue): ComparisonExpression;
+export declare function $notILike(left: _EntryValue, right: _EntryValue): ComparisonExpression;
+export declare function $paren(expression: Expression): ParenthesesExpression;
+declare type MathExpression = ArithmeticExpression & {
+    add(expression: EntryValue): MathExpression;
+    sub(expression: EntryValue): MathExpression;
+    mul(expression: EntryValue): MathExpression;
+    div(expression: EntryValue): MathExpression;
+};
+export declare function $arithmetic(n: EntryValue): MathExpression;
+export {};

package/esm/filter/build.js

@@ -0,0 +1,105 @@
+import { ArithmeticExpression, ArrayExpression, BooleanLiteral, ComparisonExpression, DateLiteral, Expression, LogicalExpression, NullLiteral, NumberLiteral, ParenthesesExpression, QualifiedIdentifier, StringLiteral, TimeLiteral } from './ast/index.js';
+export function $or(...items) {
+    return new LogicalExpression({ op: 'or', items });
+}
+export function $and(...items) {
+    return new LogicalExpression({ op: 'and', items });
+}
+export function $date(v) {
+    return new DateLiteral(v);
+}
+export function $time(v) {
+    return new TimeLiteral(v);
+}
+export function $number(v) {
+    return new NumberLiteral(v);
+}
+export function $array(...items) {
+    return new ArrayExpression(items.map(wrapEntryValue));
+}
+export function $field(v) {
+    return new QualifiedIdentifier(v);
+}
+export function $eq(left, right) {
+    return comparisonExpression('=', left, right);
+}
+export function $ne(left, right) {
+    return comparisonExpression('!=', left, right);
+}
+export function $gt(left, right) {
+    return comparisonExpression('>', left, right);
+}
+export function $gte(left, right) {
+    return comparisonExpression('>=', left, right);
+}
+export function $lt(left, right) {
+    return comparisonExpression('<', left, right);
+}
+export function $lte(left, right) {
+    return comparisonExpression('<=', left, right);
+}
+export function $in(left, right) {
+    return comparisonExpression('in', left, right);
+}
+export function $notIn(left, right) {
+    return comparisonExpression('!in', left, right);
+}
+export function $like(left, right) {
+    return comparisonExpression('like', left, right);
+}
+export function $notLike(left, right) {
+    return comparisonExpression('!like', left, right);
+}
+export function $ilike(left, right) {
+    return comparisonExpression('ilike', left, right);
+}
+export function $notILike(left, right) {
+    return comparisonExpression('!ilike', left, right);
+}
+export function $paren(expression) {
+    return new ParenthesesExpression(expression);
+}
+export function $arithmetic(n) {
+    const exp = new ArithmeticExpression();
+    exp.add = (expression) => {
+        exp.append('+', _wrapEntryValue(expression));
+        return exp;
+    };
+    exp.sub = (expression) => {
+        exp.append('-', _wrapEntryValue(expression));
+        return exp;
+    };
+    exp.mul = (expression) => {
+        exp.append('*', _wrapEntryValue(expression));
+        return exp;
+    };
+    exp.div = (expression) => {
+        exp.append('/', _wrapEntryValue(expression));
+        return exp;
+    };
+    exp.append('+', wrapEntryValue(n));
+    return exp;
+}
+function comparisonExpression(op, left, right) {
+    const lex = wrapEntryValue(left);
+    const rex = wrapEntryValue(right);
+    return new ComparisonExpression({ op, left: lex, right: rex });
+}
+const wrapEntryValue = (v) => {
+    return Array.isArray(v)
+        ? $array(...v.map(_wrapEntryValue))
+        : _wrapEntryValue(v);
+};
+const _wrapEntryValue = (v) => {
+    if (v instanceof Expression)
+        return v;
+    if (typeof v === 'boolean')
+        return new BooleanLiteral(v);
+    if (typeof v === 'number' || typeof v === 'bigint')
+        return new NumberLiteral(v);
+    if (v == null)
+        return new NullLiteral();
+    if (v instanceof Date)
+        return new DateLiteral(v);
+    return new StringLiteral('' + v);
+};

package/esm/filter/error-listener.d.ts

@@ -0,0 +1,8 @@
+import { ANTLRErrorListener, Recognizer } from 'antlr4ts';
+import { RecognitionException } from 'antlr4ts/RecognitionException';
+import { FilterParseError } from './errors.js';
+export declare class ErrorListener implements ANTLRErrorListener<any> {
+    errors: FilterParseError[];
+    constructor(errors: FilterParseError[]);
+    syntaxError<T>(recognizer: Recognizer<T, any>, offendingSymbol: T | undefined, line: number, charPositionInLine: number, msg: string, e: RecognitionException | undefined): void;
+}

package/esm/filter/error-listener.js

@@ -0,0 +1,10 @@
+import { FilterParseError } from './errors.js';
+export class ErrorListener {
+    errors;
+    constructor(errors) {
+        this.errors = errors;
+    }
+    syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e) {
+        this.errors.push(new FilterParseError(msg, { recognizer, offendingSymbol, line, charPositionInLine, e }));
+    }
+}

package/esm/filter/errors.d.ts

@@ -0,0 +1,20 @@
+import { Recognizer } from 'antlr4ts';
+import { RecognitionException } from 'antlr4ts/RecognitionException';
+export declare class SyntaxError extends TypeError {
+}
+export declare class ValidationError extends TypeError {
+}
+export declare class FilterParseError extends Error {
+    recognizer: Recognizer<any, any>;
+    offendingSymbol: any | undefined;
+    line: number;
+    charPositionInLine: number;
+    e: RecognitionException | undefined;
+    constructor(message: string, args: {
+        recognizer: Recognizer<any, any>;
+        offendingSymbol: any | undefined;
+        line: number;
+        charPositionInLine: number;
+        e: RecognitionException | undefined;
+    });
+}

package/esm/filter/errors.js

@@ -0,0 +1,15 @@
+export class SyntaxError extends TypeError {
+}
+export class ValidationError extends TypeError {
+}
+export class FilterParseError extends Error {
+    recognizer;
+    offendingSymbol;
+    line;
+    charPositionInLine;
+    e;
+    constructor(message, args) {
+        super(message);
+        Object.assign(this, args);
+    }
+}

package/esm/filter/filter-tree-visitor.d.ts

@@ -0,0 +1,30 @@
+import { AbstractParseTreeVisitor } from 'antlr4ts/tree/index.js';
+import { ArithmeticExpressionContext, ArrayExpressionContext, BooleanLiteralContext, ComparisonExpressionContext, DateLiteralContext, DateTimeLiteralContext, ExternalConstantTermContext, IdentifierContext, LogicalExpressionContext, NumberLiteralContext, ParenthesizedExpressionContext, PolarityExpressionContext, QualifiedIdentifierTermContext, RootContext, StringLiteralContext, TimeLiteralContext } from './antlr/OpraFilterParser.js';
+import { OpraFilterVisitor } from './antlr/OpraFilterVisitor.js';
+import { ArithmeticExpression, ArrayExpression, BooleanLiteral, DateLiteral, LogicalExpression, NullLiteral, NumberLiteral, ParenthesesExpression, QualifiedIdentifier, StringLiteral, TimeLiteral } from './ast/index.js';
+import { ExternalConstant } from './ast/terms/external-constant.js';
+export declare class FilterTreeVisitor extends AbstractParseTreeVisitor<any> implements OpraFilterVisitor<any> {
+    private _timeZone?;
+    constructor(options?: {
+        timeZone?: string;
+    });
+    protected defaultResult(): any;
+    visitRoot(ctx: RootContext): any;
+    visitIdentifier(ctx: IdentifierContext): string;
+    visitNullLiteral(): NullLiteral;
+    visitBooleanLiteral(ctx: BooleanLiteralContext): BooleanLiteral;
+    visitNumberLiteral(ctx: NumberLiteralContext): NumberLiteral;
+    visitStringLiteral(ctx: StringLiteralContext): StringLiteral;
+    visitInfinityLiteral(): NumberLiteral;
+    visitDateLiteral(ctx: DateLiteralContext): DateLiteral;
+    visitDateTimeLiteral(ctx: DateTimeLiteralContext): DateLiteral;
+    visitTimeLiteral(ctx: TimeLiteralContext): TimeLiteral;
+    visitQualifiedIdentifierTerm(ctx: QualifiedIdentifierTermContext): QualifiedIdentifier;
+    visitPolarityExpression(ctx: PolarityExpressionContext): any;
+    visitExternalConstantTerm(ctx: ExternalConstantTermContext): ExternalConstant;
+    visitParenthesizedExpression(ctx: ParenthesizedExpressionContext): ParenthesesExpression;
+    visitArrayExpression(ctx: ArrayExpressionContext): ArrayExpression;
+    visitComparisonExpression(ctx: ComparisonExpressionContext): any;
+    visitLogicalExpression(ctx: LogicalExpressionContext): LogicalExpression;
+    visitArithmeticExpression(ctx: ArithmeticExpressionContext): ArithmeticExpression;
+}

package/esm/filter/filter-tree-visitor.js

@@ -0,0 +1,109 @@
+import { AbstractParseTreeVisitor } from 'antlr4ts/tree/index.js';
+import { ArithmeticExpressionContext, LogicalExpressionContext, } from './antlr/OpraFilterParser.js';
+import { ArithmeticExpression, ArrayExpression, BooleanLiteral, ComparisonExpression, DateLiteral, LogicalExpression, NullLiteral, NumberLiteral, ParenthesesExpression, QualifiedIdentifier, StringLiteral, TimeLiteral } from './ast/index.js';
+import { ExternalConstant } from './ast/terms/external-constant.js';
+import { SyntaxError } from './errors.js';
+import { unquoteFilterString } from './utils.js';
+export class FilterTreeVisitor extends AbstractParseTreeVisitor {
+    _timeZone;
+    constructor(options) {
+        super();
+        this._timeZone = options?.timeZone;
+    }
+    defaultResult() {
+        return undefined;
+    }
+    visitRoot(ctx) {
+        return this.visit(ctx.expression());
+    }
+    visitIdentifier(ctx) {
+        return ctx.text;
+    }
+    visitNullLiteral() {
+        return new NullLiteral();
+    }
+    visitBooleanLiteral(ctx) {
+        return new BooleanLiteral(ctx.text === 'true');
+    }
+    visitNumberLiteral(ctx) {
+        return new NumberLiteral(ctx.text);
+    }
+    visitStringLiteral(ctx) {
+        return new StringLiteral(unquoteFilterString(ctx.text));
+    }
+    visitInfinityLiteral() {
+        return new NumberLiteral(Infinity);
+    }
+    visitDateLiteral(ctx) {
+        return new DateLiteral(unquoteFilterString(ctx.text));
+    }
+    visitDateTimeLiteral(ctx) {
+        return new DateLiteral(unquoteFilterString(ctx.text));
+    }
+    visitTimeLiteral(ctx) {
+        return new TimeLiteral(unquoteFilterString(ctx.text));
+    }
+    visitQualifiedIdentifierTerm(ctx) {
+        return new QualifiedIdentifier(ctx.text);
+    }
+    visitPolarityExpression(ctx) {
+        const x = this.visit(ctx.expression());
+        if (x.kind === 'NumberLiteral') {
+            if (ctx.polarOp().text === '-')
+                x.value *= -1;
+            return x;
+        }
+        throw new SyntaxError('Unexpected token "' + ctx.text + '"');
+    }
+    visitExternalConstantTerm(ctx) {
+        return new ExternalConstant(ctx.externalConstant().text.substring(1));
+    }
+    visitParenthesizedExpression(ctx) {
+        const expression = this.visit(ctx.expression());
+        return new ParenthesesExpression(expression);
+    }
+    visitArrayExpression(ctx) {
+        return new ArrayExpression(ctx.expression().map(child => this.visit(child)));
+    }
+    visitComparisonExpression(ctx) {
+        return new ComparisonExpression({
+            op: ctx.compOp().text,
+            left: this.visit(ctx.expression(0)),
+            right: this.visit(ctx.expression(1))
+        });
+    }
+    visitLogicalExpression(ctx) {
+        const items = [];
+        const wrapChildren = (arr, op) => {
+            for (const c of arr) {
+                if (c instanceof LogicalExpressionContext && c.logOp().text === op) {
+                    wrapChildren(c.expression(), c.logOp().text);
+                    continue;
+                }
+                const o = this.visit(c);
+                items.push(o);
+            }
+        };
+        wrapChildren(ctx.expression(), ctx.logOp().text);
+        return new LogicalExpression({
+            op: ctx.logOp().text,
+            items
+        });
+    }
+    visitArithmeticExpression(ctx) {
+        const exp = new ArithmeticExpression();
+        const wrapChildren = (children, op) => {
+            for (let i = 0, len = children.length; i < len; i++) {
+                const child = children[i];
+                if (child instanceof ArithmeticExpressionContext) {
+                    wrapChildren(child.expression(), child.arthOp().text);
+                    continue;
+                }
+                const value = this.visit(child);
+                exp.append(op || '+', value);
+            }
+        };
+        wrapChildren(ctx.expression(), ctx.arthOp().text);
+        return exp;
+    }
+}

package/esm/filter/index.d.ts

@@ -0,0 +1,5 @@
+export * from './ast/index.js';
+export * from './parse.js';
+export * from './build.js';
+export * from './error-listener.js';
+export * from './filter-tree-visitor.js';

package/esm/filter/index.js

@@ -0,0 +1,5 @@
+export * from './ast/index.js';
+export * from './parse.js';
+export * from './build.js';
+export * from './error-listener.js';
+export * from './filter-tree-visitor.js';

package/esm/filter/parse.d.ts

@@ -0,0 +1,2 @@
+import { AbstractParseTreeVisitor } from 'antlr4ts/tree';
+export declare function parseFilter(text: string, visitor?: AbstractParseTreeVisitor<any>): any;

package/esm/filter/parse.js

@@ -0,0 +1,33 @@
+import { CharStreams, CommonTokenStream } from 'antlr4ts';
+import { OpraFilterLexer } from './antlr/OpraFilterLexer.js';
+import { OpraFilterParser } from './antlr/OpraFilterParser.js';
+import { ErrorListener } from './error-listener.js';
+import { SyntaxError } from './errors.js';
+import { FilterTreeVisitor } from './filter-tree-visitor.js';
+export function parseFilter(text, visitor) {
+    const inputStream = CharStreams.fromString(text);
+    const lexer = new OpraFilterLexer(inputStream);
+    const tokenStream = new CommonTokenStream(lexer);
+    const parser = new OpraFilterParser(tokenStream);
+    parser.buildParseTree = true;
+    const errors = [];
+    const errorListener = new ErrorListener(errors);
+    lexer.removeErrorListeners();
+    lexer.addErrorListener(errorListener);
+    parser.removeErrorListeners();
+    parser.addErrorListener(errorListener);
+    const tree = parser.root();
+    visitor = visitor || new FilterTreeVisitor();
+    const result = visitor.visit(tree);
+    if (errors.length) {
+        const errMsgs = [];
+        for (const err of errors) {
+            errMsgs.push(err.message +
+                ' at (' + 'line: ' + err.line + ' column: ' + err.charPositionInLine + ')');
+        }
+        const e = new SyntaxError(errMsgs.join('\n'));
+        e.errors = errors;
+        throw e;
+    }
+    return result;
+}

package/esm/filter/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function quoteFilterString(s: string): string;
+export declare function unquoteFilterString(s: string): string;

package/esm/filter/utils.js

@@ -0,0 +1,21 @@
+const quotesRegEx = /'/g;
+const escapeRegEx = /(\\)/g;
+const unescapeRegEx = /\\(.)/g;
+function escapeString(s) {
+    return s.replace(escapeRegEx, '\\\\');
+}
+function unescapeString(s) {
+    return s.replace(unescapeRegEx, '$1');
+}
+export function quoteFilterString(s) {
+    return "'" +
+        escapeString(s).replace(quotesRegEx, '\\\'') +
+        "'";
+}
+export function unquoteFilterString(s) {
+    if (s && (s.startsWith("'") || s.startsWith('"')) && s.endsWith(s.charAt(0))) {
+        return unescapeString(s.substring(1, s.length - 1));
+    }
+    /* istanbul ignore next */
+    return s;
+}

package/esm/helpers/index.d.ts

@@ -0,0 +1 @@
+export * from './responsive-map.js';

package/esm/helpers/index.js

@@ -0,0 +1 @@
+export * from './responsive-map.js';

package/esm/{classes → helpers}/responsive-map.js

@@ -6,7 +6,7 @@ export class ResponsiveMap extends Map {
         super();
         if (wellKnownKeys)
             wellKnownKeys.forEach(k => this._wellKnownKeyMap.set(k.toLowerCase(), k));
-        if (data instanceof Map) {
+        if (typeof data?.forEach === 'function') {
             data.forEach((v, k) => this.set(k, v));
         }
         else if (data && typeof data === 'object')

package/esm/{enums → http/enums}/http-headers.enum.d.ts

@@ -164,6 +164,10 @@ export declare enum HttpHeaders {
      * or if it should be handled like a download and the browser should present a "Save As" dialog.
      */
     Content_Disposition = "Content-Disposition",
+    /**
+     * Indicates to uniquely identifies MIME entities in several contexts.
+     */
+    Content_ID = "Content-ID",
     /**
      * The size of the resource, in decimal number of bytes.
      */
@@ -172,6 +176,11 @@ export declare enum HttpHeaders {
      * Indicates the media type of the resource.
      */
     Content_Type = "Content-Type",
+    /**
+     * Indicates to specify how a MIME message or body part has been encoded,
+     * so that it can be decoded by its recipient.
+     */
+    Content_Transfer_Encoding = "Content-Transfer-Encoding",
     /**
      * Used to specify the compression algorithm.
      */

package/esm/{enums → http/enums}/http-headers.enum.js

@@ -177,6 +177,10 @@ export var HttpHeaders;
      */
     HttpHeaders["Content_Disposition"] = "Content-Disposition";
     /* *** Message body information *** */
+    /**
+     * Indicates to uniquely identifies MIME entities in several contexts.
+     */
+    HttpHeaders["Content_ID"] = "Content-ID";
     /**
      * The size of the resource, in decimal number of bytes.
      */
@@ -185,6 +189,11 @@ export var HttpHeaders;
      * Indicates the media type of the resource.
      */
     HttpHeaders["Content_Type"] = "Content-Type";
+    /**
+     * Indicates to specify how a MIME message or body part has been encoded,
+     * so that it can be decoded by its recipient.
+     */
+    HttpHeaders["Content_Transfer_Encoding"] = "Content-Transfer-Encoding";
     /**
      * Used to specify the compression algorithm.
      */

package/esm/http/http-request.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 HttpRequest 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): HttpRequest;
+}
+export {};