@opra/common 0.33.13 → 1.0.0-alpha.2

package/esm/helpers/parse-fields-projection.js

@@ -0,0 +1,61 @@
+import { splitString } from 'fast-tokenizer';
+const FIELD_PATTERN = /^([+-])?([a-z_$]\w*)$/i;
+const NO_DOT_BRACKET_PATTERN = /[^.]\(/g;
+export class FieldsProjection {
+}
+(function (FieldsProjection) {
+    class Item {
+    }
+    FieldsProjection.Item = Item;
+})(FieldsProjection || (FieldsProjection = {}));
+export function parseFieldsProjection(projection, keepCase) {
+    const arr = Array.isArray(projection) ? projection : [projection];
+    if (!(arr && arr.length))
+        return;
+    const out = new FieldsProjection();
+    for (let s of arr) {
+        if (!keepCase)
+            s = s.toLowerCase();
+        parse(s, out);
+    }
+    return out;
+}
+export function parse(input, target) {
+    /** Add dot before brackets which is required to split fields */
+    input = input.replace(NO_DOT_BRACKET_PATTERN, s => {
+        return s.charAt(0) + '.' + s.substring(1);
+    });
+    const fields = splitString(input, {
+        delimiters: '.',
+        brackets: true,
+        keepBrackets: false,
+    });
+    for (let i = 0; i < fields.length; i++) {
+        const f = fields[i];
+        if (f.includes(',')) {
+            const subFields = splitString(f, {
+                delimiters: ',',
+                brackets: true,
+                keepBrackets: true,
+            });
+            for (const n of subFields) {
+                parse(n, target);
+            }
+            continue;
+        }
+        const m = FIELD_PATTERN.exec(f);
+        /* istanbul ignore next */
+        if (!m)
+            throw new TypeError(`Invalid field path (${input})`);
+        const fieldName = m[2];
+        const treeItem = (target[fieldName] = target[fieldName] || new FieldsProjection.Item());
+        if (m[1])
+            treeItem.sign = m[1];
+        if (i === fields.length - 1) {
+            delete treeItem.projection;
+        }
+        else {
+            target = treeItem.projection = treeItem.projection || new FieldsProjection();
+        }
+    }
+}

package/esm/helpers/responsive-map.js

@@ -1,45 +1,86 @@
-var _a, _b, _c, _d;
 function isMap(v) {
     return v && typeof v.forEach === 'function';
 }
+const kEntries = Symbol.for('kEntries');
 const kKeyMap = Symbol.for('kKeyMap');
-const kKeyOrder = Symbol.for('kKeyOrder');
 const kWellKnownKeys = Symbol.for('kWellKnownKeys');
 const kOptions = Symbol.for('kOptions');
+const kSize = Symbol.for('kSize');
 /**
  * A Map implementation that supports case-insensitivity and ordered keys
  */
-export class ResponsiveMap extends Map {
+export class ResponsiveMap {
     constructor(init, options) {
-        super();
-        this[_a] = new Map();
-        this[_b] = [];
-        this[_c] = new Map();
-        this[_d] = { caseSensitive: false };
-        this[kOptions].caseSensitive = !!options?.caseSensitive;
+        Object.defineProperty(this, kSize, {
+            value: 0,
+            enumerable: false,
+            writable: true,
+        });
+        Object.defineProperty(this, kEntries, {
+            value: {},
+            enumerable: false,
+            writable: true,
+        });
+        Object.defineProperty(this, kKeyMap, {
+            value: {},
+            enumerable: false,
+            writable: true,
+        });
+        Object.defineProperty(this, kWellKnownKeys, {
+            value: {},
+            enumerable: false,
+            writable: true,
+        });
+        const caseSensitive = !!options?.caseSensitive;
+        Object.defineProperty(this, kOptions, {
+            value: {
+                caseSensitive,
+            },
+            enumerable: false,
+        });
         if (options?.wellKnownKeys)
-            options.wellKnownKeys.forEach(k => this[kWellKnownKeys].set(k.toLowerCase(), k));
+            options.wellKnownKeys.forEach(k => {
+                if (caseSensitive)
+                    this[kWellKnownKeys][k] = k;
+                else
+                    this[kWellKnownKeys][k.toLowerCase()] = k;
+            });
+        this.clear();
         if (init)
             this.setAll(init);
     }
+    get size() {
+        return this[kSize];
+    }
     clear() {
-        super.clear();
-        this[kKeyMap].clear();
-        this[kKeyOrder] = [];
+        Object.keys(this[kEntries]).forEach(k => delete this[kEntries][k]);
+        Object.keys(this[kKeyMap]).forEach(k => delete this[kKeyMap][k]);
+        this[kSize] = 0;
+    }
+    forEach(callbackfn, thisArg) {
+        for (const [k, v] of this.entries()) {
+            callbackfn.call(thisArg, v, k, this);
+        }
     }
     get(key) {
-        const orgKey = this._getOriginalKey(key);
-        return super.get(orgKey);
+        if (!key)
+            return;
+        return this[kEntries][this._getStoringKey(key)];
     }
     has(key) {
-        return this[kKeyMap].has(this._getStoringKey(key));
+        if (!key)
+            return false;
+        return this[kEntries].hasOwnProperty(this._getStoringKey(key));
     }
     set(key, value) {
+        const storeKey = this._getStoringKey(key);
         key = this._getOriginalKey(key);
-        this[kKeyMap].set(this._getStoringKey(key), key);
-        if (!this[kKeyOrder].includes(key))
-            this[kKeyOrder].push(key);
-        return super.set(key, value);
+        const exists = this[kEntries].hasOwnProperty(storeKey);
+        this[kEntries][storeKey] = value;
+        if (!exists)
+            this[kSize]++;
+        this[kKeyMap][storeKey] = key;
+        return this;
     }
     setAll(source) {
         if (isMap(source))
@@ -49,122 +90,57 @@ export class ResponsiveMap extends Map {
         return this;
     }
     keys() {
-        return [...this[kKeyOrder]][Symbol.iterator]();
+        return Object.values(this[kKeyMap])[Symbol.iterator]();
     }
     values() {
-        let i = -1;
-        const arr = [...this[kKeyOrder]];
-        const map = this;
-        return {
-            [Symbol.iterator]() {
-                return this;
-            },
-            next() {
-                i++;
-                return {
-                    done: i >= arr.length,
-                    value: map.get(arr[i])
-                };
-            }
-        };
+        return Object.values(this[kEntries])[Symbol.iterator]();
     }
     entries() {
-        let i = -1;
-        const arr = [...this[kKeyOrder]];
-        const map = this;
-        return {
-            [Symbol.iterator]() {
-                return this;
-            },
-            next() {
-                i++;
-                return {
-                    done: i >= arr.length,
-                    value: [arr[i], map.get(arr[i])]
-                };
-            }
-        };
+        return Object.entries(this[kEntries])[Symbol.iterator]();
     }
     delete(key) {
-        const orgKey = this._getOriginalKey(key);
-        const k = this._getStoringKey(key);
-        this[kKeyMap].delete(k);
-        const i = this[kKeyOrder].indexOf(orgKey);
-        if (i >= 0)
-            this[kKeyOrder].splice(i, 1);
-        return super.delete(orgKey);
+        const storeKey = this._getStoringKey(key);
+        const exists = this[kEntries].hasOwnProperty(storeKey);
+        delete this[kEntries][storeKey];
+        delete this[kKeyMap][storeKey];
+        if (!exists)
+            this[kSize]--;
+        return exists;
     }
     sort(compareFn) {
+        const oldValues = { ...this[kEntries] };
+        const oldKeymap = { ...this[kKeyMap] };
+        const keys = Array.from(this.keys());
         if (compareFn)
-            this[kKeyOrder].sort(compareFn);
-        else if (this[kOptions].caseSensitive)
-            this[kKeyOrder].sort();
+            keys.sort(compareFn);
         else
-            this[kKeyOrder].sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+            keys.sort();
+        this.clear();
+        for (const k of keys) {
+            this[kEntries][k] = oldValues[k];
+            this[kKeyMap][k] = oldKeymap[k];
+        }
+        this[kSize] = keys.length;
         return this;
     }
-    getProxy(handler) {
-        const _this = this;
-        const finalHandler = {
-            get(target, p, receiver) {
-                if (typeof p === 'string')
-                    return _this.get(p);
-                return Reflect.get(target, p, receiver);
-            },
-            set(target, p, newValue, receiver) {
-                if (typeof p === 'string') {
-                    _this.set(p, newValue);
-                    return true;
-                }
-                return Reflect.set(target, p, newValue, receiver);
-            },
-            has(target, p) {
-                if (typeof p === 'string')
-                    return _this.has(p);
-                return Reflect.has(target, p);
-            },
-            ownKeys() {
-                return Array.from(_this.keys()).map(x => x.toLowerCase());
-            },
-            getPrototypeOf() {
-                return Object.prototype;
-            },
-            defineProperty(target, property, attributes) {
-                if (typeof property === 'string') {
-                    _this.set(property, attributes.value);
-                    return true;
-                }
-                return false;
-            },
-            deleteProperty(target, p) {
-                if (typeof p === 'string')
-                    return _this.delete(p);
-                return false;
-            },
-            getOwnPropertyDescriptor(target, key) {
-                if (typeof key === 'string') {
-                    const value = finalHandler.get(target, key);
-                    return { configurable: true, enumerable: true, writable: true, value };
-                }
-            },
-            ...handler
-        };
-        return new Proxy({}, finalHandler);
-    }
     toObject() {
-        return Object.keys(this.keys()).reduce((trg, k) => {
-            trg[k] = this.get(k);
-            return trg;
-        }, {});
+        const out = {};
+        for (const [storeKey, orgKey] of Object.entries(this[kKeyMap])) {
+            out[orgKey] = this[kEntries][storeKey];
+        }
+        return out;
     }
-    [(_a = kKeyMap, _b = kKeyOrder, _c = kWellKnownKeys, _d = kOptions, Symbol.iterator)]() {
+    [Symbol.iterator]() {
         return this.entries();
     }
+    get [Symbol.toStringTag]() {
+        return '[Object ResponsiveMap]';
+    }
     _getOriginalKey(key) {
         if (!key || this[kOptions].caseSensitive)
             return key;
-        return this[kKeyMap].get(key.toLowerCase()) ??
-            (this[kWellKnownKeys].get(key.toLowerCase()) ?? key);
+        const storeKey = this._getStoringKey(key);
+        return this[kKeyMap][storeKey] ?? this[kWellKnownKeys][storeKey] ?? key;
     }
     _getStoringKey(key) {
         if (this[kOptions].caseSensitive)

package/esm/helpers/type-guards.js

@@ -1,48 +1,41 @@
 export function isConstructor(fn) {
-    return typeof fn === 'function' && fn.prototype &&
+    return (typeof fn === 'function' &&
+        fn.prototype &&
         fn.prototype.constructor === fn &&
         fn.prototype.constructor.name !== 'Function' &&
-        fn.prototype.constructor.name !== 'embedded';
+        fn.prototype.constructor.name !== 'embedded');
 }
-export function isStream(stream) {
-    return stream !== null
-        && typeof stream === 'object'
-        && typeof stream.pipe === 'function';
+export function isStream(x) {
+    return x !== null && typeof x === 'object' && typeof x.pipe === 'function';
 }
 export function isReadable(x) {
-    return isStream(x)
-        && typeof x._read === 'function'
-        && typeof x._readableState === 'object';
+    return isStream(x) && typeof x._read === 'function' && typeof x._readableState === 'object';
 }
 export function isWritable(x) {
-    return isStream(x)
-        && typeof x._write === 'function';
+    return isStream(x) && typeof x._write === 'function';
 }
 export function isReadableStream(x) {
-    return isStream(x)
-        && typeof x.getReader === 'function'
-        && typeof x.pipeThrough === 'function'
-        && typeof x.pipeTo === 'function';
+    return (isStream(x) &&
+        typeof x.getReader === 'function' &&
+        typeof x.pipeThrough === 'function' &&
+        typeof x.pipeTo === 'function');
 }
 export function isBlob(x) {
-    return x !== null
-        && typeof x === 'object'
-        && typeof x.size === 'number'
-        && typeof x.arrayBuffer === 'function'
-        && typeof x.stream === 'function';
+    return (x !== null &&
+        typeof x === 'object' &&
+        typeof x.size === 'number' &&
+        typeof x.arrayBuffer === 'function' &&
+        typeof x.stream === 'function');
 }
 export function isFormData(x) {
-    return x !== null
-        && typeof x.constructor === 'function'
-        && x.constructor.name === 'FormData'
-        && typeof x.append === 'function'
-        && typeof x.getAll === 'function';
+    return (x !== null &&
+        typeof x.constructor === 'function' &&
+        x.constructor.name === 'FormData' &&
+        typeof x.append === 'function' &&
+        typeof x.getAll === 'function');
 }
 export function isURL(x) {
-    return x !== null
-        && typeof x == 'object'
-        && typeof x.host === 'string'
-        && typeof x.href === 'string';
+    return x !== null && typeof x == 'object' && typeof x.host === 'string' && typeof x.href === 'string';
 }
 export function isIterable(x) {
     return Symbol.iterator in x;

package/esm/http/enums/http-status-messages.js

@@ -1,65 +1,65 @@
 export const HttpStatusMessages = {
-    "100": "Continue",
-    "101": "Switching Protocols",
-    "102": "Processing",
-    "103": "Early Hints",
-    "200": "OK",
-    "201": "Created",
-    "202": "Accepted",
-    "203": "Non-Authoritative Information",
-    "204": "No Content",
-    "205": "Reset Content",
-    "206": "Partial Content",
-    "207": "Multi-Status",
-    "208": "Already Reported",
-    "226": "IM Used",
-    "300": "Multiple Choices",
-    "301": "Moved Permanently",
-    "302": "Found",
-    "303": "See Other",
-    "304": "Not Modified",
-    "305": "Use Proxy",
-    "307": "Temporary Redirect",
-    "308": "Permanent Redirect",
-    "400": "Bad Request",
-    "401": "Unauthorized",
-    "402": "Payment Required",
-    "403": "Forbidden",
-    "404": "Not Found",
-    "405": "Method Not Allowed",
-    "406": "Not Acceptable",
-    "407": "Proxy Authentication Required",
-    "408": "Request Timeout",
-    "409": "Conflict",
-    "410": "Gone",
-    "411": "Length Required",
-    "412": "Precondition Failed",
-    "413": "Payload Too Large",
-    "414": "URI Too Long",
-    "415": "Unsupported Media Type",
-    "416": "Range Not Satisfiable",
-    "417": "Expectation Failed",
-    "418": "I'm a Teapot",
-    "421": "Misdirected Request",
-    "422": "Unprocessable Entity",
-    "423": "Locked",
-    "424": "Failed Dependency",
-    "425": "Too Early",
-    "426": "Upgrade Required",
-    "428": "Precondition Required",
-    "429": "Too Many Requests",
-    "431": "Request Header Fields Too Large",
-    "451": "Unavailable For Legal Reasons",
-    "500": "Internal Server Error",
-    "501": "Not Implemented",
-    "502": "Bad Gateway",
-    "503": "Service Unavailable",
-    "504": "Gateway Timeout",
-    "505": "HTTP Version Not Supported",
-    "506": "Variant Also Negotiates",
-    "507": "Insufficient Storage",
-    "508": "Loop Detected",
-    "509": "Bandwidth Limit Exceeded",
-    "510": "Not Extended",
-    "511": "Network Authentication Required"
+    '100': 'Continue',
+    '101': 'Switching Protocols',
+    '102': 'Processing',
+    '103': 'Early Hints',
+    '200': 'OK',
+    '201': 'Created',
+    '202': 'Accepted',
+    '203': 'Non-Authoritative Information',
+    '204': 'No Content',
+    '205': 'Reset Content',
+    '206': 'Partial Content',
+    '207': 'Multi-Status',
+    '208': 'Already Reported',
+    '226': 'IM Used',
+    '300': 'Multiple Choices',
+    '301': 'Moved Permanently',
+    '302': 'Found',
+    '303': 'See Other',
+    '304': 'Not Modified',
+    '305': 'Use Proxy',
+    '307': 'Temporary Redirect',
+    '308': 'Permanent Redirect',
+    '400': 'Bad Request',
+    '401': 'Unauthorized',
+    '402': 'Payment Required',
+    '403': 'Forbidden',
+    '404': 'Not Found',
+    '405': 'Method Not Allowed',
+    '406': 'Not Acceptable',
+    '407': 'Proxy Authentication Required',
+    '408': 'Request Timeout',
+    '409': 'Conflict',
+    '410': 'Gone',
+    '411': 'Length Required',
+    '412': 'Precondition Failed',
+    '413': 'Payload Too Large',
+    '414': 'URI Too Long',
+    '415': 'Unsupported Media Type',
+    '416': 'Range Not Satisfiable',
+    '417': 'Expectation Failed',
+    '418': "I'm a Teapot",
+    '421': 'Misdirected Request',
+    '422': 'Unprocessable Entity',
+    '423': 'Locked',
+    '424': 'Failed Dependency',
+    '425': 'Too Early',
+    '426': 'Upgrade Required',
+    '428': 'Precondition Required',
+    '429': 'Too Many Requests',
+    '431': 'Request Header Fields Too Large',
+    '451': 'Unavailable For Legal Reasons',
+    '500': 'Internal Server Error',
+    '501': 'Not Implemented',
+    '502': 'Bad Gateway',
+    '503': 'Service Unavailable',
+    '504': 'Gateway Timeout',
+    '505': 'HTTP Version Not Supported',
+    '506': 'Variant Also Negotiates',
+    '507': 'Insufficient Storage',
+    '508': 'Loop Detected',
+    '509': 'Bandwidth Limit Exceeded',
+    '510': 'Not Extended',
+    '511': 'Network Authentication Required',
 };

package/esm/http/enums/mime-types.enum.js

@@ -0,0 +1,14 @@
+// noinspection JSUnusedGlobalSymbols
+/**
+ * https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#successful_responses
+ */
+export var MimeTypes;
+(function (MimeTypes) {
+    MimeTypes["json"] = "application/json";
+    MimeTypes["opra_response_json"] = "application/opra.response+json";
+    MimeTypes["xml"] = "application/XML";
+    MimeTypes["text"] = "text/plain";
+    MimeTypes["html"] = "text/html";
+    MimeTypes["markdown"] = "text/markdown";
+    MimeTypes["binary"] = "binary/octet-stream";
+})(MimeTypes || (MimeTypes = {}));

package/esm/http/index.js

@@ -1,5 +1,4 @@
-export * from './opra-url.js';
-export * from './opra-url-path.js';
 export * from './enums/http-headers-codes.enum.js';
 export * from './enums/http-status-codes.enum.js';
 export * from './enums/http-status-messages.js';
+export * from './enums/mime-types.enum.js';

package/esm/i18n/i18n.js

@@ -75,9 +75,9 @@ export class I18n extends BaseI18n {
                         keys.push(token2);
                     }
                     const k = keys.length > 1 ? '$t(' + keys.join(',') + ')' : keys[0];
-                    s += (fallback
+                    s += fallback
                         ? this.t(k, fallback, { ...options, ...opts })
-                        : this.t(k, { ...options, ...opts }));
+                        : this.t(k, { ...options, ...opts });
                     continue;
                 }
                 s += token;
@@ -96,9 +96,13 @@ export class I18n extends BaseI18n {
         if (typeof input === 'object') {
             if (Buffer.isBuffer(input))
                 return input;
-            if (Buffer.isBuffer(input) || input instanceof Symbol ||
-                input instanceof RegExp || input instanceof Map || input instanceof Set ||
-                input instanceof WeakMap || input instanceof WeakSet)
+            if (Buffer.isBuffer(input) ||
+                input instanceof Symbol ||
+                input instanceof RegExp ||
+                input instanceof Map ||
+                input instanceof Set ||
+                input instanceof WeakMap ||
+                input instanceof WeakSet)
                 return input;
             const out = {};
             objectStack.set(input, out);

package/esm/i18n/translate.js

@@ -3,9 +3,9 @@ const bracketRegEx = /(\))/g;
 export function translate(key, arg0, arg1) {
     const options = arg0 && typeof arg0 === 'object' ? arg0 : undefined;
     const fallback = typeof arg0 === 'string' ? arg0 : arg1;
-    return '$t(' +
+    return ('$t(' +
         key +
         (options ? ',' + JSON.stringify(options) : '') +
         (fallback ? '?' + escapeString(fallback).replace(bracketRegEx, '\\$1') : '') +
-        ')';
+        ')');
 }

package/esm/index.js

@@ -1,7 +1,7 @@
 export * from './types.js';
 export * from './document/index.js';
 export * from './exception/index.js';
-export * from './filter/index.js'; // todo  review
+export * from './filter/index.js';
 export * from './helpers/index.js';
 export * from './http/index.js';
 export * from './i18n/index.js';

package/esm/schema/http/http-controller.interface.js

@@ -0,0 +1,8 @@
+/**
+ *
+ * @namespace HttpController
+ */
+export var HttpController;
+(function (HttpController) {
+    HttpController.Kind = 'HttpController';
+})(HttpController || (HttpController = {}));

package/esm/schema/http/http-operation.interface.js

@@ -0,0 +1,4 @@
+export var HttpOperation;
+(function (HttpOperation) {
+    HttpOperation.Kind = 'HttpOperation';
+})(HttpOperation || (HttpOperation = {}));

package/esm/schema/index.js

@@ -1,2 +1,27 @@
-import * as OpraSchema from './opra-schema.ns.js';
-export { OpraSchema };
+import * as constants_ from './constants.js';
+import * as complexType_ from './data-type/complex-type.interface.js';
+import * as enumType_ from './data-type/enum-type.interface.js';
+import * as mappedType_ from './data-type/mapped-type.interface.js';
+import * as mixinType_ from './data-type/mixin-type.interface.js';
+import * as simpleType_ from './data-type/simple-type.interface.js';
+import * as controller_ from './http/http-controller.interface.js';
+import * as operation_ from './http/http-operation.interface.js';
+import * as typeGuards_ from './type-guards.js';
+export var OpraSchema;
+(function (OpraSchema) {
+    OpraSchema.SpecVersion = constants_.SpecVersion;
+    OpraSchema.ComplexType = complexType_.ComplexType;
+    OpraSchema.EnumType = enumType_.EnumType;
+    OpraSchema.MappedType = mappedType_.MappedType;
+    OpraSchema.MixinType = mixinType_.MixinType;
+    OpraSchema.SimpleType = simpleType_.SimpleType;
+    OpraSchema.HttpController = controller_.HttpController;
+    OpraSchema.HttpOperation = operation_.HttpOperation;
+    OpraSchema.isComplexType = typeGuards_.isComplexType;
+    OpraSchema.isDataType = typeGuards_.isDataType;
+    OpraSchema.isSimpleType = typeGuards_.isSimpleType;
+    OpraSchema.isMixinType = typeGuards_.isMixinType;
+    OpraSchema.isMappedType = typeGuards_.isMappedType;
+    OpraSchema.isEnumType = typeGuards_.isEnumType;
+    OpraSchema.isHttpController = typeGuards_.isHttpController;
+})(OpraSchema || (OpraSchema = {}));