@opra/common 0.22.0 → 0.23.0

package/cjs/document/utils/generate-codec.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._generateDecoder = exports.generateCodec = void 0;
+const tslib_1 = require("tslib");
+const vg = tslib_1.__importStar(require("valgen"));
+const complex_type_js_1 = require("../data-type/complex-type.js");
+const enum_type_js_1 = require("../data-type/enum-type.js");
+const mapped_type_js_1 = require("../data-type/mapped-type.js");
+const simple_type_js_1 = require("../data-type/simple-type.js");
+const union_type_js_1 = require("../data-type/union-type.js");
+function generateCodec(type, codec, options) {
+    return _generateDecoder(type, codec, options);
+}
+exports.generateCodec = generateCodec;
+function _generateDecoder(type, codec, options) {
+    const schema = {};
+    for (const f of type.fields.values()) {
+        let fn;
+        if (f.type instanceof simple_type_js_1.SimpleType || f.type instanceof enum_type_js_1.EnumType) {
+            fn = f.type[codec];
+        }
+        else if (f.type instanceof complex_type_js_1.ComplexType || f.type instanceof mapped_type_js_1.MappedType || f.type instanceof union_type_js_1.UnionType) {
+            fn = _generateDecoder(f.type, codec, options);
+        }
+        /* istanbul ignore next */
+        if (!fn)
+            throw new TypeError(`Can't generate codec for (${f.type})`);
+        if (f.isArray)
+            fn = vg.isArray(fn);
+        schema[f.name] = !options.partial && f.required ? vg.required(fn) : vg.optional(fn);
+    }
+    return vg.isObject(schema, {
+        ctor: type.ctor,
+        additionalFields: type.additionalFields ?? 'ignore',
+        name: type.name,
+        caseInSensitive: true,
+    });
+}
+exports._generateDecoder = _generateDecoder;

package/cjs/exception/resource-errors/resource-not-found.error.js

@@ -10,7 +10,7 @@ const opra_exception_js_1 = require("../opra-exception.js");
 class ResourceNotFoundError extends opra_exception_js_1.OpraException {
     constructor(resource, keyValue, cause) {
         super({
-            message: (0, index_js_1.translate)(`error:RESOURCE_NOT_FOUND`, { resource: resource + (keyValue ? '@' + keyValue : '') }, `The resource '{{resource}}' could not be found`),
+            message: (0, index_js_1.translate)(`error:RESOURCE_NOT_FOUND`, { resource: resource + (keyValue ? '@' + keyValue : '') }, `The resource '{{resource}}' not found`),
             severity: 'error',
             code: 'RESOURCE_NOT_FOUND',
             details: {

package/cjs/helpers/index.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./function-utils.js"), exports);
 tslib_1.__exportStar(require("./get-stack-filename.js"), exports);
-tslib_1.__exportStar(require("./is-url.js"), exports);
+tslib_1.__exportStar(require("./is-url-string.js"), exports);
 tslib_1.__exportStar(require("./mixin-utils.js"), exports);
 tslib_1.__exportStar(require("./object-utils.js"), exports);
 tslib_1.__exportStar(require("./path-to-object-tree.js"), exports);

package/cjs/helpers/is-url-string.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAbsoluteUrl = exports.isUrlString = void 0;
+const url_1 = require("url");
+const URL_PATTERN = /^(https?:\/\/.)[-a-zA-Z0-9@:%._+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_+.~#?&/=]*)$/i;
+function isUrlString(url) {
+    return URL_PATTERN.test(url);
+}
+exports.isUrlString = isUrlString;
+const isAbsoluteUrl = (urlString) => {
+    return !urlString.includes('://') &&
+        (new url_1.URL(urlString, 'http://tempuri.org/')).host !== 'tempuri.org';
+};
+exports.isAbsoluteUrl = isAbsoluteUrl;

package/cjs/helpers/object-utils.js

@@ -17,13 +17,13 @@ function cloneObject(obj, jsonOnly) {
     });
 }
 exports.cloneObject = cloneObject;
-function omitUndefined(obj) {
+function omitUndefined(obj, recursive) {
     if (!(obj && typeof obj === 'object'))
         return obj;
     for (const k of Object.keys(obj)) {
         if (obj[k] === undefined)
             delete obj[k];
-        else if (typeof obj[k] === 'object')
+        else if (recursive && typeof obj[k] === 'object')
             omitUndefined(obj[k]);
     }
     return obj;

package/cjs/helpers/responsive-map.js

@@ -5,10 +5,10 @@ exports.ResponsiveMap = void 0;
 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');
+const kKeyMap = Symbol.for('kKeyMap');
+const kKeyOrder = Symbol.for('kKeyOrder');
+const kWellKnownKeys = Symbol.for('kWellKnownKeys');
+const kOptions = Symbol.for('kOptions');
 /**
  * A Map implementation that supports case-insensitivity and ordered keys
  */

package/cjs/helpers/type-guards.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isURL = exports.isFormData = exports.isBlob = exports.isReadableStream = exports.isReadable = exports.isStream = exports.isConstructor = void 0;
+exports.isAsyncIterable = exports.isIterable = exports.isURL = exports.isFormData = exports.isBlob = exports.isReadableStream = exports.isWritable = exports.isReadable = exports.isStream = exports.isConstructor = void 0;
 function isConstructor(fn) {
     return typeof fn === 'function' && fn.prototype &&
         fn.prototype.constructor === fn &&
@@ -16,14 +16,17 @@ function isStream(stream) {
 exports.isStream = isStream;
 function isReadable(x) {
     return isStream(x)
-        && x.readable !== false
         && typeof x._read === 'function'
         && typeof x._readableState === 'object';
 }
 exports.isReadable = isReadable;
+function isWritable(x) {
+    return isStream(x)
+        && typeof x._write === 'function';
+}
+exports.isWritable = isWritable;
 function isReadableStream(x) {
     return isStream(x)
-        && x.readable !== false
         && typeof x.getReader === 'function'
         && typeof x.pipeThrough === 'function'
         && typeof x.pipeTo === 'function';
@@ -47,7 +50,16 @@ function isFormData(x) {
 exports.isFormData = isFormData;
 function isURL(x) {
     return x !== null
+        && typeof x == 'object'
         && typeof x.host === 'string'
         && typeof x.href === 'string';
 }
 exports.isURL = isURL;
+function isIterable(x) {
+    return Symbol.iterator in x;
+}
+exports.isIterable = isIterable;
+function isAsyncIterable(x) {
+    return Symbol.asyncIterator in x;
+}
+exports.isAsyncIterable = isAsyncIterable;

package/cjs/http/index.js

@@ -1,15 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./http-params.js"), exports);
+tslib_1.__exportStar(require("./opra-url.js"), exports);
+tslib_1.__exportStar(require("./opra-url-path.js"), exports);
 tslib_1.__exportStar(require("./enums/http-headers-codes.enum.js"), exports);
 tslib_1.__exportStar(require("./enums/http-status-codes.enum.js"), exports);
 tslib_1.__exportStar(require("./enums/http-status-messages.js"), exports);
-tslib_1.__exportStar(require("./interfaces/client-http-headers.interface.js"), exports);
-tslib_1.__exportStar(require("./interfaces/server-http-headers.interface.js"), exports);
-tslib_1.__exportStar(require("./codecs/date-codec.js"), exports);
-tslib_1.__exportStar(require("./codecs/boolean-codec.js"), exports);
-tslib_1.__exportStar(require("./codecs/filter-codec.js"), exports);
-tslib_1.__exportStar(require("./codecs/integer-codec.js"), exports);
-tslib_1.__exportStar(require("./codecs/number-codec.js"), exports);
-tslib_1.__exportStar(require("./codecs/string-codec.js"), exports);

package/cjs/http/opra-url-path.js

@@ -0,0 +1,251 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraURLPath = void 0;
+const tslib_1 = require("tslib");
+const fast_tokenizer_1 = require("fast-tokenizer");
+const putil_isplainobject_1 = tslib_1.__importDefault(require("putil-isplainobject"));
+const nodeInspectCustom = Symbol.for('nodejs.util.inspect.custom');
+const kLength = Symbol.for('kLength');
+const pathComponentRegEx = /^([^/?#:@]+)(?:@([^/?#:]*))?(?:::(.*))?$/;
+const decimalPattern = /^[+-]?\d+(\.\d+)?$/;
+const booleanPattern = /^true|false$/;
+/**
+ * @class OpraURLPath
+ */
+class OpraURLPath {
+    constructor(...init) {
+        this[_a] = 0;
+        this._resolve(init.filter(x => x));
+    }
+    get length() {
+        return this[kLength];
+    }
+    resolve(...items) {
+        this._resolve(items);
+        return this;
+    }
+    join(...items) {
+        this._resolve(items, true);
+        return this;
+    }
+    isRelativeTo(basePath) {
+        basePath = basePath instanceof OpraURLPath ? basePath : new OpraURLPath(basePath);
+        let i;
+        for (i = 0; i < basePath.length; i++) {
+            if (String(this[i]) !== String(basePath[i]))
+                return false;
+        }
+        return true;
+    }
+    forEach(callback) {
+        let i = 0;
+        for (const item of this.values()) {
+            callback.call(this, item, i++, this);
+        }
+    }
+    values() {
+        const arr = new Array(this.length);
+        for (let i = 0; i < this.length; i++)
+            arr[i] = this[i];
+        return arr.values();
+    }
+    toString() {
+        const v = Array.from(this).join('/');
+        return v ? '/' + v : '';
+    }
+    /* istanbul ignore next */
+    [(_a = kLength, nodeInspectCustom)]() {
+        return `(UrlPath [${this.toString()}])`;
+    }
+    [Symbol.iterator]() {
+        return this.values();
+    }
+    _resolve(items, join) {
+        let paths = (Array.isArray(items) ? items : [items]).map(item => {
+            if (typeof item === 'object' && !(item instanceof OpraURLPath || item instanceof OpraURLPathComponent))
+                item = new OpraURLPathComponent(item);
+            item = String(item);
+            // Remove url parts coming after path (query, hash parts)
+            if (item.includes('?'))
+                item = (0, fast_tokenizer_1.splitString)(item, {
+                    delimiters: '?',
+                    quotes: true,
+                    brackets: true,
+                    keepBrackets: true,
+                    keepQuotes: true
+                })[0];
+            if (item.includes('#'))
+                item = (0, fast_tokenizer_1.splitString)(item, {
+                    delimiters: '#',
+                    quotes: true,
+                    brackets: true,
+                    keepBrackets: true,
+                    keepQuotes: true
+                })[0];
+            return join ? removeLeadingSeparator(item) : item;
+        });
+        const oldLength = this.length;
+        let n = 0;
+        if (!join) {
+            for (n = paths.length - 1; n >= 0; n--) {
+                if (String(items[n]).startsWith('/'))
+                    break;
+            }
+            if (n > 0)
+                paths = paths.slice(n);
+        }
+        const newPath = paths[0]?.startsWith('/') ? [] : Array.from(this).map(String);
+        for (let i = 0; i < paths.length; i++) {
+            const pathTokenizer = (0, fast_tokenizer_1.tokenize)(paths[i], { delimiters: '/', quotes: true, brackets: true });
+            for (const x of pathTokenizer) {
+                if (!x)
+                    continue;
+                if (x.startsWith('.')) {
+                    if (x === '.')
+                        continue;
+                    if (x === '..') {
+                        newPath.pop();
+                        continue;
+                    }
+                    throw new TypeError('Invalid path string');
+                }
+                newPath.push(x);
+            }
+        }
+        for (let i = 0; i < newPath.length; i++) {
+            this[i] = OpraURLPathComponent.parse(newPath[i]);
+        }
+        for (let i = newPath.length; i < oldLength; i++) {
+            delete this[i];
+        }
+        this[kLength] = newPath.length;
+    }
+    static join(...items) {
+        const instance = new OpraURLPath();
+        instance.join(...items);
+        return instance;
+    }
+    static resolve(...items) {
+        return new OpraURLPath(...items);
+    }
+    static relative(source, basePath) {
+        source = source instanceof OpraURLPath ? source : new OpraURLPath(source);
+        basePath = basePath instanceof OpraURLPath ? basePath : new OpraURLPath(basePath);
+        let i;
+        for (i = 0; i < basePath.length; i++) {
+            if (String(source[i]) !== String(basePath[i]))
+                return;
+        }
+        return new OpraURLPath(Array.from(source).slice(i).join('/'));
+    }
+}
+exports.OpraURLPath = OpraURLPath;
+/**
+ *
+ * @class OpraURLPathComponent
+ */
+class OpraURLPathComponent {
+    constructor(init) {
+        this.resource = init.resource;
+        this.key = init.key;
+        this.args = init.args;
+        this.typeCast = init.typeCast;
+    }
+    toString() {
+        let out = encodeURIComponent(this.resource).replace(/%24/, '$');
+        if (this.key) {
+            if (typeof this.key === 'object' && (0, putil_isplainobject_1.default)(this.key)) {
+                const arr = [];
+                for (const k of Object.keys(this.key)) {
+                    let v = this.key[k];
+                    if (typeof v === 'number' || typeof v === 'boolean')
+                        v = String(v);
+                    else
+                        v = '"' + encodeURIComponent(String(v)) + '"';
+                    arr.push(encodeURIComponent(k) + '=' + v);
+                }
+                out += '@' + arr.join(';');
+            }
+            else
+                out += '@' + encodeURIComponent(String(this.key));
+        }
+        if (this.args) {
+            const arr = [];
+            for (const k of Object.keys(this.args)) {
+                arr.push(encodeURIComponent(k) + '=' + encodeURIComponent(String(this.args[k])));
+            }
+            out += '(' + arr.join(';') + ')';
+        }
+        if (this.typeCast)
+            out += '::' + encodeURIComponent(this.typeCast);
+        return out;
+    }
+    /* istanbul ignore next */
+    [nodeInspectCustom]() {
+        return this.toString();
+    }
+    /**
+     * Factory method.
+     * @param input
+     */
+    static parse(input) {
+        const m = pathComponentRegEx.exec(input);
+        if (!m)
+            throw Object.assign(new TypeError('Invalid Opra URL'), {
+                code: 'ERR_INVALID_OPRA_URL',
+                input,
+            });
+        let key;
+        if (m[2]) {
+            const s = decodeURIComponent(m[2]);
+            const b = (0, fast_tokenizer_1.splitString)(s, { delimiters: ';', quotes: true, escape: false, keepQuotes: true, keepBrackets: true });
+            for (const n of b) {
+                const c = (0, fast_tokenizer_1.splitString)(n, { delimiters: '=', quotes: true, escape: false, keepQuotes: true, keepBrackets: true });
+                if ((b.length > 1 && c.length < 2) ||
+                    (key &&
+                        (c.length >= 2 && typeof key !== 'object') ||
+                        (c.length < 2 && typeof key === 'object')))
+                    throw Object.assign(new TypeError('Invalid Opra URL. name:value pair required for multiple key format'), {
+                        pathComponent: input,
+                        code: 'ERR_INVALID_OPRA_URL'
+                    });
+                if (c.length >= 2) {
+                    key = key || {};
+                    const k = c.shift() || '';
+                    let v = c.join('=');
+                    if (decimalPattern.test(v))
+                        v = Number(v);
+                    else if (booleanPattern.test(v))
+                        v = Boolean(v);
+                    else if (v.startsWith('"') && v.endsWith('"'))
+                        v = v.substring(1, v.length - 1);
+                    else if (v.startsWith("'") && v.endsWith("'"))
+                        v = v.substring(1, v.length - 1);
+                    key[k] = v;
+                }
+                else {
+                    if (decimalPattern.test(c[0]))
+                        key = Number(c[0]);
+                    else if (booleanPattern.test(c[0]))
+                        key = Boolean(c[0]);
+                    else
+                        key = c[0];
+                }
+            }
+            return new OpraURLPathComponent({
+                resource: decodeURIComponent(m[1]),
+                key,
+                typeCast: m[3] ? decodeURIComponent(m[3]) : undefined
+            });
+        }
+        return new OpraURLPathComponent({
+            resource: decodeURIComponent(m[1]),
+            typeCast: m[3] ? decodeURIComponent(m[3]) : undefined
+        });
+    }
+}
+function removeLeadingSeparator(s) {
+    const m = /^\/*(.*)/.exec(s);
+    return m?.[1] || s;
+}