@opra/common 0.10.2 → 0.12.0

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

@@ -1,16 +1,22 @@
-import antlr4 from 'antlr4';
+import antlr4 from '@browsery/antlr4';
 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';
-// Fix: antlr4 d.ts files is invalid
+// Fix: antlr4 d.ts files are invalid
 const ParseTreeVisitor = antlr4.tree.ParseTreeVisitor;
 export class FilterTreeVisitor extends ParseTreeVisitor {
     constructor(options) {
         super();
         this._timeZone = options?.timeZone;
     }
+    visitChildren(node) {
+        const result = super.visitChildren(node);
+        if (Array.isArray(result) && result.length < 2)
+            return result[0];
+        return result;
+    }
     defaultResult() {
         return undefined;
     }

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

@@ -1,5 +1,5 @@
-import { ErrorListener, RecognitionException } from 'antlr4';
-import { Recognizer } from 'antlr4/src/antlr4/Recognizer';
+import { ErrorListener, RecognitionException } from '@browsery/antlr4';
+import { Recognizer } from '@browsery/antlr4/typings/Recognizer';
 import { FilterParseError } from './errors.js';
 export declare class OpraErrorListener extends ErrorListener<any> {
     errors: FilterParseError[];

package/esm/filter/opra-error-listener.js

@@ -1,4 +1,4 @@
-import { ErrorListener } from 'antlr4';
+import { ErrorListener } from '@browsery/antlr4';
 import { FilterParseError } from './errors.js';
 export class OpraErrorListener extends ErrorListener {
     constructor(errors) {
@@ -6,6 +6,6 @@ export class OpraErrorListener extends ErrorListener {
         this.errors = errors;
     }
     syntaxError(recognizer, offendingSymbol, line, column, msg, e) {
-        this.errors.push(new FilterParseError(msg, { recognizer, offendingSymbol, line, e }));
+        this.errors.push(new FilterParseError(msg, { recognizer, offendingSymbol, line, column, e }));
     }
 }

package/esm/filter/parse.d.ts

@@ -1,2 +1,2 @@
-import type { ParseTreeVisitor } from 'antlr4';
+import type { ParseTreeVisitor } from '@browsery/antlr4';
 export declare function parseFilter(text: string, visitor?: ParseTreeVisitor<any>): any;

package/esm/filter/parse.js

@@ -1,4 +1,4 @@
-import { CharStream, CommonTokenStream } from 'antlr4';
+import { CharStream, CommonTokenStream } from '@browsery/antlr4';
 import OpraFilterLexer from './antlr/OpraFilterLexer.js';
 import OpraFilterParser from './antlr/OpraFilterParser.js';
 import { SyntaxError } from './errors.js';

package/esm/helpers/responsive-map.d.ts

@@ -1,8 +1,21 @@
+export interface ResponsiveMapOptions {
+    wellKnownKeys?: string[];
+    caseSensitive?: boolean;
+}
+export type ResponsiveMapInit<K, V> = ResponsiveMap<K, V> | Map<K, V> | Record<any, V>;
+declare const kKeyMap: unique symbol;
+declare const kKeyOrder: unique symbol;
+declare const kWellKnownKeys: unique symbol;
+declare const kOptions: unique symbol;
+/**
+ * A Map implementation that supports case-insensitivity and ordered keys
+ */
 export declare class ResponsiveMap<K, V> extends Map<K, V> {
-    private _keyMap;
-    private _keyOrder;
-    private _wellKnownKeyMap;
-    constructor(data?: any, wellKnownKeys?: string[]);
+    private [kKeyMap];
+    private [kKeyOrder];
+    private [kWellKnownKeys];
+    private [kOptions];
+    constructor(init?: ResponsiveMapInit<K, V>, options?: ResponsiveMapOptions);
     clear(): void;
     get(key: K): V | undefined;
     has(key: K): boolean;
@@ -14,5 +27,6 @@ export declare class ResponsiveMap<K, V> extends Map<K, V> {
     sort(compareFn?: (a: K, b: K) => number): this;
     [Symbol.iterator](): IterableIterator<[K, V]>;
     protected _getOriginalKey(key: K): K;
-    protected _getLowerKey(key: K): K;
+    protected _getStoringKey(key: K): K;
 }
+export {};

package/esm/helpers/responsive-map.js

@@ -1,42 +1,55 @@
+var _a, _b, _c, _d;
+function isMap(v) {
+    return v && typeof v.forEach === 'function';
+}
+const kKeyMap = Symbol('kKeyMap');
+const kKeyOrder = Symbol('kKeyOrder');
+const kWellKnownKeys = Symbol('kWellKnownKeys');
+const kOptions = Symbol('kOptions');
+/**
+ * A Map implementation that supports case-insensitivity and ordered keys
+ */
 export class ResponsiveMap extends Map {
-    constructor(data, wellKnownKeys) {
+    constructor(init, options) {
         super();
-        this._keyMap = new Map();
-        this._keyOrder = [];
-        this._wellKnownKeyMap = new Map();
-        if (wellKnownKeys)
-            wellKnownKeys.forEach(k => this._wellKnownKeyMap.set(k.toLowerCase(), k));
-        if (typeof data?.forEach === 'function') {
-            data.forEach((v, k) => this.set(k, v));
+        this[_a] = new Map();
+        this[_b] = [];
+        this[_c] = new Map();
+        this[_d] = { caseSensitive: false };
+        this[kOptions].caseSensitive = !!options?.caseSensitive;
+        if (options?.wellKnownKeys)
+            options.wellKnownKeys.forEach(k => this[kWellKnownKeys].set(k.toLowerCase(), k));
+        if (isMap(init)) {
+            init.forEach((v, k) => this.set(k, v));
         }
-        else if (data && typeof data === 'object')
-            Object.keys(data).forEach(k => this.set(k, data[k]));
+        else if (init && typeof init === 'object')
+            Object.keys(init).forEach(k => this.set(k, init[k]));
     }
     clear() {
         super.clear();
-        this._keyMap.clear();
-        this._keyOrder = [];
+        this[kKeyMap].clear();
+        this[kKeyOrder] = [];
     }
     get(key) {
         const orgKey = this._getOriginalKey(key);
         return super.get(orgKey);
     }
     has(key) {
-        return this._keyMap.has(this._getLowerKey(key));
+        return this[kKeyMap].has(this._getStoringKey(key));
     }
     set(key, value) {
         key = this._getOriginalKey(key);
-        this._keyMap.set(this._getLowerKey(key), key);
-        if (!this._keyOrder.includes(key))
-            this._keyOrder.push(key);
+        this[kKeyMap].set(this._getStoringKey(key), key);
+        if (!this[kKeyOrder].includes(key))
+            this[kKeyOrder].push(key);
         return super.set(key, value);
     }
     keys() {
-        return this._keyOrder.values();
+        return this[kKeyOrder].values();
     }
     values() {
         let i = -1;
-        const arr = this._keyOrder;
+        const arr = this[kKeyOrder];
         const map = this;
         return {
             [Symbol.iterator]() {
@@ -53,7 +66,7 @@ export class ResponsiveMap extends Map {
     }
     entries() {
         let i = -1;
-        const arr = this._keyOrder;
+        const arr = this[kKeyOrder];
         const map = this;
         return {
             [Symbol.iterator]() {
@@ -70,27 +83,31 @@ export class ResponsiveMap extends Map {
     }
     delete(key) {
         const orgKey = this._getOriginalKey(key);
-        const k = this._getLowerKey(key);
-        this._keyMap.delete(k);
-        const i = this._keyOrder.indexOf(orgKey);
+        const k = this._getStoringKey(key);
+        this[kKeyMap].delete(k);
+        const i = this[kKeyOrder].indexOf(orgKey);
         if (i >= 0)
-            this._keyOrder.splice(i, 1);
+            this[kKeyOrder].splice(i, 1);
         return super.delete(orgKey);
     }
     sort(compareFn) {
-        this._keyOrder.sort(compareFn);
+        this[kKeyOrder].sort(compareFn);
         return this;
     }
-    [Symbol.iterator]() {
+    [(_a = kKeyMap, _b = kKeyOrder, _c = kWellKnownKeys, _d = kOptions, Symbol.iterator)]() {
         return this.entries();
     }
     _getOriginalKey(key) {
+        if (this[kOptions].caseSensitive)
+            return key;
         if (typeof key === 'string')
-            return this._keyMap.get(key.toLowerCase()) ??
-                (this._wellKnownKeyMap.get(key.toLowerCase()) ?? key);
+            return this[kKeyMap].get(key.toLowerCase()) ??
+                (this[kWellKnownKeys].get(key.toLowerCase()) ?? key);
         return key;
     }
-    _getLowerKey(key) {
+    _getStoringKey(key) {
+        if (this[kOptions].caseSensitive)
+            return key;
         if (typeof key === 'string')
             return key.toLowerCase();
         return key;

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

@@ -1,7 +1,7 @@
 /**
  * https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers#controls
  */
-export declare enum HttpHeaders {
+export declare enum HttpHeaderCodes {
     X_Opra_Version = "X-Opra-Version",
     X_Opra_DataType = "X-Opra-DataType",
     X_Opra_Count = "X-Opra-Count",