@opra/common 0.10.3 → 0.12.0

package/cjs/http/multipart/batch-multipart.js

@@ -5,8 +5,8 @@ const tslib_1 = require("tslib");
 const highland_1 = tslib_1.__importDefault(require("highland"));
 const uid_1 = require("uid");
 const type_guards_js_1 = require("../../utils/type-guards.js");
-const http_headers_enum_js_1 = require("../enums/http-headers.enum.js");
-const http_status_enum_js_1 = require("../enums/http-status.enum.js");
+const http_headers_codes_enum_js_1 = require("../enums/http-headers-codes.enum.js");
+const http_status_codes_enum_js_1 = require("../enums/http-status-codes.enum.js");
 const normalize_headers_js_1 = require("../utils/normalize-headers.js");
 const http_request_content_js_1 = require("./http-request-content.js");
 const http_response_content_js_1 = require("./http-response-content.js");
@@ -20,11 +20,11 @@ class BatchMultipart {
     addRequestPart(content, part) {
         const headers = {
             ...(0, normalize_headers_js_1.normalizeHeaders)(part?.headers || {}, true),
-            [http_headers_enum_js_1.HttpHeaders.Content_Type]: 'application/http',
-            [http_headers_enum_js_1.HttpHeaders.Content_Transfer_Encoding]: 'binary'
+            [http_headers_codes_enum_js_1.HttpHeaderCodes.Content_Type]: 'application/http',
+            [http_headers_codes_enum_js_1.HttpHeaderCodes.Content_Transfer_Encoding]: 'binary'
         };
         if (part?.contentId)
-            headers[http_headers_enum_js_1.HttpHeaders.Content_ID] = part.contentId;
+            headers[http_headers_codes_enum_js_1.HttpHeaderCodes.Content_ID] = part.contentId;
         this._parts.push({
             headers,
             contentId: part?.contentId,
@@ -35,11 +35,11 @@ class BatchMultipart {
     addHttpResponse(content, part) {
         const headers = {
             ...(0, normalize_headers_js_1.normalizeHeaders)(part?.headers || {}, true),
-            [http_headers_enum_js_1.HttpHeaders.Content_Type]: 'application/http',
-            [http_headers_enum_js_1.HttpHeaders.Content_Transfer_Encoding]: 'binary'
+            [http_headers_codes_enum_js_1.HttpHeaderCodes.Content_Type]: 'application/http',
+            [http_headers_codes_enum_js_1.HttpHeaderCodes.Content_Transfer_Encoding]: 'binary'
         };
         if (part?.contentId)
-            headers[http_headers_enum_js_1.HttpHeaders.Content_ID] = part.contentId;
+            headers[http_headers_codes_enum_js_1.HttpHeaderCodes.Content_ID] = part.contentId;
         this._parts.push({
             headers,
             contentId: part?.contentId,
@@ -50,11 +50,11 @@ class BatchMultipart {
     addBatch(batch, part) {
         const headers = {
             ...(0, normalize_headers_js_1.normalizeHeaders)(part?.headers || {}, true),
-            [http_headers_enum_js_1.HttpHeaders.Content_Type]: 'application/http',
-            [http_headers_enum_js_1.HttpHeaders.Content_Transfer_Encoding]: 'binary'
+            [http_headers_codes_enum_js_1.HttpHeaderCodes.Content_Type]: 'application/http',
+            [http_headers_codes_enum_js_1.HttpHeaderCodes.Content_Transfer_Encoding]: 'binary'
         };
         if (part?.contentId)
-            headers[http_headers_enum_js_1.HttpHeaders.Content_ID] = part.contentId;
+            headers[http_headers_codes_enum_js_1.HttpHeaderCodes.Content_ID] = part.contentId;
         this._parts.push({
             headers,
             contentId: part?.contentId,
@@ -126,7 +126,7 @@ class BatchMultipart {
                 if (part.content instanceof http_request_content_js_1.HttpRequestContent)
                     s += (part.content.method || 'GET').toUpperCase() + ' ' + part.content.url + ' HTTP/1.1' + CRLF;
                 else
-                    s += 'HTTP/1.1 ' + part.content.status + (http_status_enum_js_1.HttpStatus[part.content.status] || 'Unknown') + CRLF;
+                    s += 'HTTP/1.1 ' + part.content.status + (http_status_codes_enum_js_1.HttpStatusCodes[part.content.status] || 'Unknown') + CRLF;
                 if (part.content.headers) {
                     for (const [k, v] of Object.entries(part.content.headers)) {
                         if (v === '' || v == null)

package/cjs/http/param-codec/boolean-codec.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanCodec = void 0;
+const http_param_codec_js_1 = require("../http-param-codec.js");
+const trueValues = ['true', 't', 'yes', 'y', '1'];
+const falseValues = ['false', 'f', 'no', 'n', '0'];
+class BooleanCodec extends http_param_codec_js_1.HttpParamCodec {
+    decode(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`);
+    }
+    encode(value) {
+        return typeof value === 'boolean' ?
+            (value ? 'true' : 'false') : '';
+    }
+}
+exports.BooleanCodec = BooleanCodec;

package/cjs/http/param-codec/date-codec.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateCodec = void 0;
+/* eslint-disable max-len */
+const http_param_codec_js_1 = require("../http-param-codec.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])?))?)?$/;
+class DateCodec extends http_param_codec_js_1.HttpParamCodec {
+    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;
+    }
+    decode(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;
+    }
+    encode(value) {
+        return coerceToDateString(value, this.time, this.timeZone);
+    }
+}
+exports.DateCodec = DateCodec;
+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/cjs/http/param-codec/filter-codec.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterCodec = void 0;
+const index_js_1 = require("../../filter/ast/index.js");
+const parse_js_1 = require("../../filter/parse.js");
+const http_param_codec_js_1 = require("../http-param-codec.js");
+class FilterCodec extends http_param_codec_js_1.HttpParamCodec {
+    decode(value) {
+        if (value instanceof index_js_1.Expression)
+            return value;
+        return (0, parse_js_1.parseFilter)(value);
+    }
+    encode(value) {
+        // @ts-ignore
+        return value ? '' + value : '';
+    }
+}
+exports.FilterCodec = FilterCodec;

package/cjs/http/param-codec/integer-codec.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegerCodec = void 0;
+const number_codec_js_1 = require("./number-codec.js");
+class IntegerCodec extends number_codec_js_1.NumberCodec {
+    constructor(options) {
+        super(options);
+        this.enum = options?.enum;
+    }
+    decode(value) {
+        const v = super.decode(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;
+    }
+}
+exports.IntegerCodec = IntegerCodec;

package/cjs/http/param-codec/number-codec.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberCodec = void 0;
+const http_param_codec_js_1 = require("../http-param-codec.js");
+class NumberCodec extends http_param_codec_js_1.HttpParamCodec {
+    constructor(options) {
+        super();
+        this.max = options?.max;
+        this.min = options?.min;
+    }
+    decode(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;
+    }
+    encode(value) {
+        return typeof value === 'number' ? '' + value : '';
+    }
+}
+exports.NumberCodec = NumberCodec;

package/cjs/http/param-codec/string-codec.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringCodec = void 0;
+const http_param_codec_js_1 = require("../http-param-codec.js");
+class StringCodec extends http_param_codec_js_1.HttpParamCodec {
+    constructor(options) {
+        super();
+        this.maxLength = options?.maxLength;
+        this.minLength = options?.minLength;
+        this.enum = options?.enum;
+    }
+    decode(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;
+    }
+    encode(value) {
+        return value == null ? '' : '' + value;
+    }
+}
+exports.StringCodec = StringCodec;

package/cjs/http/utils/encodeURIParam.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeURIParam = void 0;
+/**
+ * Encode input string with standard encodeURIComponent and then un-encode specific characters.
+ */
+const ENCODING_REGEX = /%(\d[a-f0-9])/gi;
+const ENCODING_REPLACEMENTS = {
+    '2C': ',',
+    '2F': '/',
+    '24': '$',
+    '3A': ':',
+    '3B': ';',
+    '3D': '=',
+    '3F': '?',
+    '40': '@'
+};
+function encodeURIParam(v) {
+    return encodeURIComponent(v).replace(ENCODING_REGEX, (s, t) => ENCODING_REPLACEMENTS[t] ?? s);
+}
+exports.encodeURIParam = encodeURIParam;

package/cjs/http/utils/normalize-headers.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeHeaders = void 0;
-const http_headers_enum_js_1 = require("../enums/http-headers.enum.js");
-const knownKeys = Object.keys(http_headers_enum_js_1.HttpHeaders);
+const http_headers_codes_enum_js_1 = require("../enums/http-headers-codes.enum.js");
+const knownKeys = Object.keys(http_headers_codes_enum_js_1.HttpHeaderCodes);
 const knownKeysLower = knownKeys.map(x => x.toLowerCase());
 function normalizeHeaders(headers, normalCase) {
     if (!headers)

package/cjs/i18n/i18n.js

@@ -70,11 +70,8 @@ class I18n extends exports.BaseI18n {
     async loadResourceDir(dirnames, deep, overwrite) {
         for (const dirname of Array.isArray(dirnames) ? dirnames : [dirnames]) {
             /* istanbul ignore next */
-            if (!(fs_1.default.statSync(dirname)).isDirectory()) {
-                // eslint-disable-next-line no-console
-                console.warn(`Locale directory does not exists. (${dirname})`);
+            if (!(fs_1.default.existsSync(dirname)))
                 continue;
-            }
             const languageDirs = fs_1.default.readdirSync(dirname);
             for (const lang of languageDirs) {
                 const langDir = path_1.default.join(dirname, lang);

package/cjs/schema/implementation/opra-document.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpraDocument = void 0;
 const tslib_1 = require("tslib");
 const lodash_omit_1 = tslib_1.__importDefault(require("lodash.omit"));
+const index_js_1 = require("../../exception/index.js");
 const responsive_map_js_1 = require("../../helpers/responsive-map.js");
 const opra_schema_definition_js_1 = require("../opra-schema.definition.js");
 const clone_object_util_js_1 = require("../utils/clone-object.util.js");
@@ -43,25 +44,25 @@ class OpraDocument {
         const t = this.types.get(name);
         if (t)
             return t;
-        throw new Error(`Data type "${name}" does not exists`);
+        throw new index_js_1.NotFoundError(`Data type "${name}" does not exists`);
     }
     getComplexDataType(name) {
         const t = this.getDataType(name);
         if (t && t instanceof complex_type_js_1.ComplexType)
             return t;
-        throw new Error(`Data type "${name}" is not a ComplexType`);
+        throw new index_js_1.NotAcceptableError(`Data type "${name}" is not a ComplexType`);
     }
     getSimpleDataType(name) {
         const t = this.getDataType(name);
         if (t && t instanceof simple_type_js_1.SimpleType)
             return t;
-        throw new Error(`Data type "${name}" is not a SimpleType`);
+        throw new index_js_1.NotAcceptableError(`Data type "${name}" is not a SimpleType`);
     }
     getUnionDataType(name) {
         const t = this.getDataType(name);
         if (t && t instanceof union_type_js_1.UnionType)
             return t;
-        throw new Error(`Data type "${name}" is not a UnionType`);
+        throw new index_js_1.NotAcceptableError(`Data type "${name}" is not a UnionType`);
     }
     get resources() {
         return this._resources;
@@ -72,19 +73,19 @@ class OpraDocument {
     getResource(name) {
         const t = this.resources.get(name);
         if (!t)
-            throw new Error(`Resource "${name}" does not exists`);
+            throw new index_js_1.NotFoundError(`Resource "${name}" does not exists`);
         return t;
     }
     getCollectionResource(name) {
         const t = this.getResource(name);
         if (!(t instanceof collection_resource_info_js_1.CollectionResourceInfo))
-            throw new Error(`"${name}" is not a CollectionResource`);
+            throw new index_js_1.NotAcceptableError(`"${name}" is not a CollectionResource`);
         return t;
     }
     getSingletonResource(name) {
         const t = this.getResource(name);
         if (!(t instanceof singleton_resource_info_js_1.SingletonResourceInfo))
-            throw new Error(`"${name}" is not a SingletonResource`);
+            throw new index_js_1.NotAcceptableError(`"${name}" is not a SingletonResource`);
         return t;
     }
     getMetadata(jsonOnly) {
@@ -125,7 +126,7 @@ class OpraDocument {
             dataType = new union_type_js_1.UnionType(this, name, { ...schema, types: [] });
         }
         else
-            throw new TypeError(`Invalid data type schema`);
+            throw new index_js_1.InternalServerError(`Invalid data type schema`);
         this._types.set(name, dataType);
         if (isOwn)
             this._ownTypes.set(name, dataType);
@@ -135,16 +136,16 @@ class OpraDocument {
         if (opra_schema_definition_js_1.OpraSchema.isCollectionResource(schema) || opra_schema_definition_js_1.OpraSchema.isSingletonResource(schema)) {
             const dataType = this.getDataType(schema.type);
             if (!dataType)
-                throw new TypeError(`Datatype "${schema.type}" declared in CollectionResource (${name}) does not exists`);
+                throw new index_js_1.InternalServerError(`Datatype "${schema.type}" declared in CollectionResource (${name}) does not exists`);
             if (!(dataType instanceof complex_type_js_1.ComplexType))
-                throw new TypeError(`${schema.type} is not an ComplexType`);
+                throw new index_js_1.InternalServerError(`${schema.type} is not an ComplexType`);
             if (opra_schema_definition_js_1.OpraSchema.isCollectionResource(schema))
                 this.resources.set(name, new collection_resource_info_js_1.CollectionResourceInfo(this, name, dataType, schema));
             else
                 this.resources.set(name, new singleton_resource_info_js_1.SingletonResourceInfo(this, name, dataType, schema));
         }
         else
-            throw new TypeError(`Unknown resource kind (${schema.kind})`);
+            throw new index_js_1.InternalServerError(`Unknown resource kind (${schema.kind})`);
     }
     _initTypes() {
         for (const dataType of this._types.values()) {

package/cjs/schema/implementation/resource/collection-resource-info.js

@@ -16,6 +16,9 @@ class CollectionResourceInfo extends resource_info_js_1.ResourceInfo {
             metadata.search.sortFields = (0, normalize_field_array_util_js_1.normalizeFieldArray)(document, dataType, metadata.search.sortFields);
         }
     }
+    get instance() {
+        return this.metadata.instance;
+    }
     get keyFields() {
         return this.metadata.keyFields;
     }
@@ -43,6 +46,10 @@ class CollectionResourceInfo extends resource_info_js_1.ResourceInfo {
     get search() {
         return this.metadata.search;
     }
+    getHandler(method) {
+        const r = this.metadata[method];
+        return r && r.handler;
+    }
     getSchema(jsonOnly) {
         const out = super.getSchema(jsonOnly);
         if (out.keyFields.length < 2)

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

@@ -1,56 +1,46 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpraURLPath = void 0;
-const events_1 = require("events");
 const fast_tokenizer_1 = require("fast-tokenizer");
 const index_js_1 = require("../utils/index.js");
 const opra_url_path_component_js_1 = require("./opra-url-path-component.js");
 const path_utils_js_1 = require("./utils/path-utils.js");
 const nodeInspectCustom = Symbol.for('nodejs.util.inspect.custom');
-class OpraURLPath extends events_1.EventEmitter {
-    constructor(...args) {
-        super();
-        this._entries = [];
-        for (const x of args) {
-            if ((0, index_js_1.isURL)(x)) {
-                this._parse(x.pathname);
-                continue;
-            }
-            // noinspection SuspiciousTypeOfGuard
-            if (x instanceof OpraURLPath)
-                this._entries.push(...x._entries);
-            else
-                this.add(x);
-        }
+const kEntries = Symbol('kEntries');
+const kOptions = Symbol('kOptions');
+class OpraURLPath {
+    constructor(init, options) {
+        this[_a] = [];
+        this[kOptions] = { ...options, onChange: undefined };
+        if (Array.isArray(init))
+            this.join(...init);
+        else if (init)
+            this.join(init);
+        this[kOptions].onChange = options?.onChange;
     }
     get size() {
-        return this._entries.length;
+        return this[kEntries].length;
     }
-    add(component, key, typeCast) {
-        this._add(component, key, typeCast);
-        this.emit('change');
+    changed() {
+        if (this[kOptions].onChange)
+            this[kOptions].onChange();
     }
     clear() {
-        this._entries = [];
-        this.emit('change');
+        this[kEntries] = [];
+        this.changed();
     }
     get(index) {
-        return this._entries[index];
-    }
-    join(pathString) {
-        const pathTokenizer = (0, fast_tokenizer_1.tokenize)((0, path_utils_js_1.normalizePath)(pathString, true), {
-            delimiters: '/', quotes: true, brackets: true,
-        });
-        for (const x of pathTokenizer) {
-            const p = (0, path_utils_js_1.decodePathComponent)(x);
-            this._add(p);
-        }
-        this.emit('change');
+        return this[kEntries][index];
+    }
+    join(...source) {
+        source.forEach(x => this._join(this[kEntries], x));
+        this.changed();
         return this;
     }
     entries() {
         let i = -1;
-        const arr = [...this._entries];
+        const arr = [...this[kEntries]];
         return {
             [Symbol.iterator]() {
                 return this;
@@ -64,9 +54,46 @@ class OpraURLPath extends events_1.EventEmitter {
             }
         };
     }
+    forEach(callback) {
+        for (const item of this[kEntries]) {
+            callback.call(this, item, this);
+        }
+    }
+    getResource(index) {
+        const v = this[kEntries][index];
+        return v == null ? undefined : v.resource;
+    }
+    getKey(index) {
+        const v = this[kEntries][index];
+        return v == null ? undefined : v.key;
+    }
+    pop() {
+        const out = this[kEntries].pop();
+        this.changed();
+        return out;
+    }
+    shift() {
+        const out = this[kEntries].shift();
+        this.changed();
+        return out;
+    }
+    slice(start, end) {
+        return new OpraURLPath(this[kEntries].slice(start, end));
+    }
+    splice(start, deleteCount, join) {
+        const items = (join ? this._join([], join) : []);
+        this[kEntries].splice(start, deleteCount, ...items);
+        this.changed();
+    }
+    unshift(join) {
+        return this.splice(0, 0, join);
+    }
+    toString() {
+        return this[kEntries].map(x => (0, path_utils_js_1.encodePathComponent)(x.resource, x.key, x.typeCast)).join('/');
+    }
     values() {
         let i = -1;
-        const arr = [...this._entries];
+        const arr = [...this[kEntries]];
         return {
             [Symbol.iterator]() {
                 return this;
@@ -80,49 +107,46 @@ class OpraURLPath extends events_1.EventEmitter {
             }
         };
     }
-    forEach(callback) {
-        for (const item of this._entries) {
-            callback.call(this, item.resource, item.key, this);
+    _join(target, source) {
+        if (typeof source === 'string') {
+            const pathTokenizer = (0, fast_tokenizer_1.tokenize)((0, path_utils_js_1.normalizePath)(source, true), {
+                delimiters: '/', quotes: true, brackets: true,
+            });
+            for (const x of pathTokenizer) {
+                const p = (0, path_utils_js_1.decodePathComponent)(x);
+                target.push(new opra_url_path_component_js_1.OpraURLPathComponent(p));
+            }
+            return;
         }
+        if (source instanceof OpraURLPath) {
+            target.push(...source[kEntries].map(x => new opra_url_path_component_js_1.OpraURLPathComponent(x)));
+            return;
+        }
+        if (typeof source === 'object' && source.path instanceof OpraURLPath) {
+            this._join(target, source.path);
+            return;
+        }
+        if ((0, index_js_1.isURL)(source)) {
+            this._join(target, source.pathname);
+            return;
+        }
+        if (Array.isArray(source)) {
+            source.forEach(x => this._join(target, x));
+            return;
+        }
+        target.push(new opra_url_path_component_js_1.OpraURLPathComponent(source));
     }
-    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 => (0, path_utils_js_1.encodePathComponent)(x.resource, x.key, x.typeCast)).join('/');
+    /* istanbul ignore next */
+    [(_a = kEntries, nodeInspectCustom)]() {
+        return this[kEntries];
     }
     [Symbol.iterator]() {
         return this.entries();
     }
-    /* istanbul ignore next */
-    [nodeInspectCustom]() {
-        return this._entries;
-    }
-    _add(component, key, typeCast) {
-        if (component instanceof opra_url_path_component_js_1.OpraURLPathComponent) {
-            this._entries.push(component);
-        }
-        else if (typeof component === 'object')
-            this._entries.push(new opra_url_path_component_js_1.OpraURLPathComponent(component));
-        else
-            this._entries.push(new opra_url_path_component_js_1.OpraURLPathComponent({ resource: component, key, typeCast }));
-    }
-    _parse(v) {
-        if (!v)
-            return;
-        const pathTokenizer = (0, fast_tokenizer_1.tokenize)(v, { delimiters: '/', quotes: true, brackets: true });
-        for (const x of pathTokenizer) {
-            if (!x)
-                continue;
-            const p = (0, path_utils_js_1.decodePathComponent)(x);
-            this._add(p);
-        }
-        this.emit('change');
+    get [Symbol.toStringTag]() {
+        return 'OpraURLPath';
     }
 }
 exports.OpraURLPath = OpraURLPath;
+OpraURLPath.kEntries = kEntries;
+OpraURLPath.kOptions = kOptions;