@rsdk/common 5.7.0-next.6 → 6.0.0-next.1

package/dist/parsers/parser.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.interface.js","sourceRoot":"","sources":["../../src/parsers/parser.interface.ts"],"names":[],"mappings":""}

package/dist/parsers/size/index.d.ts

@@ -0,0 +1 @@
+export * from './size.parser';

package/dist/parsers/size/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./size.parser"), exports);
+//# sourceMappingURL=index.js.map

package/dist/parsers/size/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/parsers/size/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,gDAA8B"}

package/dist/parsers/size/size.parser.d.ts

@@ -0,0 +1,7 @@
+import { Size } from '../../size';
+import type { PropertyParser } from '../parser.interface';
+export declare class SizeParser implements PropertyParser<Size> {
+    type(): string;
+    description(): string;
+    parse(value: unknown): Size;
+}

package/dist/parsers/size/size.parser.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SizeParser = void 0;
+const size_1 = require("../../size");
+const strings_1 = require("../../strings");
+const types_1 = require("../../types");
+class SizeParser {
+    type() {
+        return 'Timespan';
+    }
+    description() {
+        return (0, strings_1.text) `
+      Parses string in size format into Timespan instance.
+      Format is: ${size_1.SIZE_STRING_PATTERN}. For example: 8b, 10kb, 2gb.
+    `;
+    }
+    parse(value) {
+        types_1.Assert.isString(value);
+        return size_1.Size.parse(value);
+    }
+}
+exports.SizeParser = SizeParser;
+//# sourceMappingURL=size.parser.js.map

package/dist/parsers/size/size.parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"size.parser.js","sourceRoot":"","sources":["../../../src/parsers/size/size.parser.ts"],"names":[],"mappings":";;;AAAA,qCAAuD;AACvD,2CAAqC;AACrC,uCAAqC;AAGrC,MAAa,UAAU;IACrB,IAAI;QACF,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,WAAW;QACT,OAAO,IAAA,cAAI,EAAA;;mBAEI,0BAAmB;KACjC,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,KAAc;QAClB,cAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAEvB,OAAO,WAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC3B,CAAC;CACF;AAjBD,gCAiBC"}

package/dist/parsers/string/index.d.ts

@@ -0,0 +1 @@
+export * from './string.parser';

package/dist/parsers/string/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./string.parser"), exports);
+//# sourceMappingURL=index.js.map

package/dist/parsers/string/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/parsers/string/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,kDAAgC"}

package/dist/parsers/string/string.parser.d.ts

@@ -0,0 +1,8 @@
+import type { PropertyParser } from '../parser.interface';
+export declare class StringParser implements PropertyParser<string> {
+    private readonly pattern?;
+    constructor(pattern?: RegExp | undefined);
+    type(): string;
+    description(): string;
+    parse(value: unknown): string;
+}

package/dist/parsers/string/string.parser.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringParser = void 0;
+const types_1 = require("../../types");
+class StringParser {
+    pattern;
+    constructor(pattern) {
+        this.pattern = pattern;
+    }
+    type() {
+        return 'string';
+    }
+    description() {
+        return 'Extract arbitrary string.';
+    }
+    parse(value) {
+        types_1.Assert.isString(value);
+        if (this.pattern) {
+            types_1.Assert.isTrue(this.pattern.test(value));
+        }
+        return value;
+    }
+}
+exports.StringParser = StringParser;
+//# sourceMappingURL=string.parser.js.map

package/dist/parsers/string/string.parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.parser.js","sourceRoot":"","sources":["../../../src/parsers/string/string.parser.ts"],"names":[],"mappings":";;;AAAA,uCAAqC;AAGrC,MAAa,YAAY;IACM;IAA7B,YAA6B,OAAgB;QAAhB,YAAO,GAAP,OAAO,CAAS;IAAG,CAAC;IAEjD,IAAI;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,WAAW;QACT,OAAO,2BAA2B,CAAC;IACrC,CAAC;IAED,KAAK,CAAC,KAAc;QAClB,cAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAEvB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,cAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QAC1C,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;CACF;AApBD,oCAoBC"}

package/dist/parsers/timespan/index.d.ts

@@ -0,0 +1 @@
+export * from './timespan.parser';

package/dist/parsers/timespan/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./timespan.parser"), exports);
+//# sourceMappingURL=index.js.map

package/dist/parsers/timespan/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/parsers/timespan/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,oDAAkC"}

package/dist/parsers/timespan/timespan.parser.d.ts

@@ -0,0 +1,7 @@
+import { Timespan } from '../../time';
+import type { PropertyParser } from '../parser.interface';
+export declare class TimespanParser implements PropertyParser<Timespan> {
+    type(): string;
+    description(): string;
+    parse(value: unknown): Timespan;
+}

package/dist/parsers/timespan/timespan.parser.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimespanParser = void 0;
+const strings_1 = require("../../strings");
+const time_1 = require("../../time");
+const types_1 = require("../../types");
+class TimespanParser {
+    type() {
+        return 'Timespan';
+    }
+    description() {
+        return (0, strings_1.text) `
+      Parses string in timespan format into Timespan instance.
+      Format is: ${time_1.TIMESPAN_STRING_PATTERN}. For example: 1s, 2h, 4d.
+    `;
+    }
+    parse(value) {
+        types_1.Assert.isString(value);
+        return time_1.Timespan.parse(value);
+    }
+}
+exports.TimespanParser = TimespanParser;
+//# sourceMappingURL=timespan.parser.js.map

package/dist/parsers/timespan/timespan.parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timespan.parser.js","sourceRoot":"","sources":["../../../src/parsers/timespan/timespan.parser.ts"],"names":[],"mappings":";;;AAAA,2CAAqC;AACrC,qCAA+D;AAC/D,uCAAqC;AAGrC,MAAa,cAAc;IACzB,IAAI;QACF,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,WAAW;QACT,OAAO,IAAA,cAAI,EAAA;;mBAEI,8BAAuB;KACrC,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,KAAc;QAClB,cAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAEvB,OAAO,eAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;CACF;AAjBD,wCAiBC"}

package/dist/parsers/url/errors.d.ts

@@ -0,0 +1,6 @@
+export declare class InvalidUrl extends Error {
+    constructor(str: string, cause: unknown);
+}
+export declare class InvalidProtocol extends Error {
+    constructor(expectedProtocols: string[], protocol: string, url: URL);
+}

package/dist/parsers/url/errors.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidProtocol = exports.InvalidUrl = void 0;
+class InvalidUrl extends Error {
+    constructor(str, cause) {
+        super(`Invalid url string: <${str}>`);
+        this.name = 'InvalidUrl';
+        this.cause = cause;
+    }
+}
+exports.InvalidUrl = InvalidUrl;
+class InvalidProtocol extends Error {
+    constructor(expectedProtocols, protocol, url) {
+        super(`Invalid protocol: <${protocol}>, expected: ${expectedProtocols}`);
+        this.name = 'InvalidProtocol';
+        this.cause = {
+            protocol,
+            url,
+            expected: expectedProtocols,
+        };
+    }
+}
+exports.InvalidProtocol = InvalidProtocol;
+//# sourceMappingURL=errors.js.map

package/dist/parsers/url/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../src/parsers/url/errors.ts"],"names":[],"mappings":";;;AAAA,MAAa,UAAW,SAAQ,KAAK;IACnC,YAAY,GAAW,EAAE,KAAc;QACrC,KAAK,CAAC,wBAAwB,GAAG,GAAG,CAAC,CAAC;QACtC,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;QACzB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;CACF;AAND,gCAMC;AAED,MAAa,eAAgB,SAAQ,KAAK;IACxC,YAAY,iBAA2B,EAAE,QAAgB,EAAE,GAAQ;QACjE,KAAK,CAAC,sBAAsB,QAAQ,gBAAgB,iBAAiB,EAAE,CAAC,CAAC;QACzE,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;QAC9B,IAAI,CAAC,KAAK,GAAG;YACX,QAAQ;YACR,GAAG;YACH,QAAQ,EAAE,iBAAiB;SAC5B,CAAC;IACJ,CAAC;CACF;AAVD,0CAUC"}

package/dist/parsers/url/index.d.ts

@@ -0,0 +1 @@
+export * from './url.parser';

package/dist/parsers/url/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./url.parser"), exports);
+//# sourceMappingURL=index.js.map

package/dist/parsers/url/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/parsers/url/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+CAA6B"}

package/dist/parsers/url/url.parser.d.ts

@@ -0,0 +1,9 @@
+import type { PropertyParser } from '../parser.interface';
+export declare class UrlParser implements PropertyParser<URL> {
+    private readonly protocols;
+    constructor(...protocols: string[]);
+    type(): string;
+    description(): string;
+    parse(value: unknown): URL;
+    private assertProtocol;
+}

package/dist/parsers/url/url.parser.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UrlParser = void 0;
+const types_1 = require("../../types");
+const errors_1 = require("./errors");
+class UrlParser {
+    protocols;
+    constructor(...protocols) {
+        this.protocols = protocols;
+    }
+    type() {
+        return 'URL';
+    }
+    description() {
+        return 'Parses string into instance of URL';
+    }
+    parse(value) {
+        types_1.Assert.isString(value);
+        try {
+            const url = new URL(value);
+            this.assertProtocol(url);
+            return url;
+        }
+        catch (error) {
+            throw new errors_1.InvalidUrl(value, error);
+        }
+    }
+    assertProtocol(url) {
+        if (this.protocols.length === 0) {
+            return;
+        }
+        if (!this.protocols.includes(url.protocol)) {
+            throw new errors_1.InvalidProtocol(this.protocols, url.protocol, url);
+        }
+    }
+}
+exports.UrlParser = UrlParser;
+//# sourceMappingURL=url.parser.js.map

package/dist/parsers/url/url.parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.parser.js","sourceRoot":"","sources":["../../../src/parsers/url/url.parser.ts"],"names":[],"mappings":";;;AAAA,uCAAqC;AAGrC,qCAAuD;AAEvD,MAAa,SAAS;IACH,SAAS,CAAW;IAErC,YAAY,GAAG,SAAmB;QAChC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAED,IAAI;QACF,OAAO,KAAK,CAAC;IACf,CAAC;IAED,WAAW;QACT,OAAO,oCAAoC,CAAC;IAC9C,CAAC;IAED,KAAK,CAAC,KAAc;QAClB,cAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAEvB,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC;YAE3B,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;YACzB,OAAO,GAAG,CAAC;QACb,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,mBAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QACrC,CAAC;IACH,CAAC;IAEO,cAAc,CAAC,GAAQ;QAC7B,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAChC,OAAO;QACT,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC3C,MAAM,IAAI,wBAAe,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;QAC/D,CAAC;IACH,CAAC;CACF;AArCD,8BAqCC"}

package/dist/types/assert.class.d.ts

@@ -1,5 +1,7 @@
 export declare class Assert {
     static isString(x: unknown): asserts x is string;
     static isNumber(x: unknown): asserts x is number;
+    static isBoolean(x: unknown): asserts x is boolean;
+    static isTrue(x: unknown): asserts x is true;
     static isError(x: unknown): asserts x is Error;
 }

package/dist/types/assert.class.js

@@ -14,6 +14,18 @@ class Assert {
         }
         throw new Error(`<${x}> is not a number.`);
     }
+    static isBoolean(x) {
+        if (typeof x === 'boolean') {
+            return;
+        }
+        throw new Error(`<${x}> is not a boolean.`);
+    }
+    static isTrue(x) {
+        if (x === true) {
+            return;
+        }
+        throw new Error(`<${x}> is not true.`);
+    }
     static isError(x) {
         if (x instanceof Error) {
             return;

package/dist/types/assert.class.js.map

@@ -1 +1 @@
-{"version":3,"file":"assert.class.js","sourceRoot":"","sources":["../../src/types/assert.class.ts"],"names":[],"mappings":";;;AAAA,MAAa,MAAM;IACjB,MAAM,CAAC,QAAQ,CAAC,CAAU;QACxB,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;YAC1B,OAAO;QACT,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;IAC7C,CAAC;IAED,MAAM,CAAC,QAAQ,CAAC,CAAU;QACxB,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;YAC1B,OAAO;QACT,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;IAC7C,CAAC;IAED,MAAM,CAAC,OAAO,CAAC,CAAU;QACvB,IAAI,CAAC,YAAY,KAAK,EAAE,CAAC;YACvB,OAAO;QACT,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,6BAA6B,CAAC,CAAC;IACtE,CAAC;CACF;AAxBD,wBAwBC"}
+{"version":3,"file":"assert.class.js","sourceRoot":"","sources":["../../src/types/assert.class.ts"],"names":[],"mappings":";;;AAAA,MAAa,MAAM;IACjB,MAAM,CAAC,QAAQ,CAAC,CAAU;QACxB,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;YAC1B,OAAO;QACT,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;IAC7C,CAAC;IAED,MAAM,CAAC,QAAQ,CAAC,CAAU;QACxB,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;YAC1B,OAAO;QACT,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;IAC7C,CAAC;IAED,MAAM,CAAC,SAAS,CAAC,CAAU;QACzB,IAAI,OAAO,CAAC,KAAK,SAAS,EAAE,CAAC;YAC3B,OAAO;QACT,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;IAC9C,CAAC;IAED,MAAM,CAAC,MAAM,CAAC,CAAU;QACtB,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC;YACf,OAAO;QACT,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IACzC,CAAC;IAED,MAAM,CAAC,OAAO,CAAC,CAAU;QACvB,IAAI,CAAC,YAAY,KAAK,EAAE,CAAC;YACvB,OAAO;QACT,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,6BAA6B,CAAC,CAAC;IACtE,CAAC;CACF;AAxCD,wBAwCC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsdk/common",
-  "version": "5.7.0-next.6",
+  "version": "6.0.0-next.1",
   "description": "Useful common classes, functions and types",
   "license": "Apache License 2.0",
   "publishConfig": {
@@ -13,8 +13,8 @@
   "scripts": {
     "prepublishOnly": "npm run build"
   },
-  "peerDependencies": {
-    "rxjs": "^7.1.0"
+  "dependencies": {
+    "rxjs": "^7.8.1"
   },
-  "gitHead": "287622c55e8717861544f0be502bb37a6b19bbfb"
+  "gitHead": "3114a76df17cf98d6f3cbb8a931599a883af6783"
 }

package/src/functions/obj-normalization.spec.ts

@@ -207,3 +207,105 @@ describe('max depth', () => {
     );
   });
 });
+
+describe('keep origin prototype', () => {
+  class TestObject {
+    a = 1;
+  }
+
+  const objectCases: {
+    input: any;
+    output: any;
+    options?: NormalizeOptions;
+    title: string;
+  }[] = [
+    {
+      input: new TestObject(),
+      output: Object,
+      title: `should have the Object prototype if input is an instance of a class without keepOriginPrototype option`,
+    },
+    {
+      input: new TestObject(),
+      output: Object,
+      options: { keepOriginPrototype: false },
+      title: `should not have the same prototype if keepOriginPrototype is false`,
+    },
+    {
+      input: new TestObject(),
+      output: Object,
+      options: { keepOriginPrototype: true },
+      title: `should have the same prototype if keepOriginPrototype is true`,
+    },
+    {
+      input: {},
+      output: Object,
+      title: `should have the object prototype if input is an object by default without keepOriginPrototype option`,
+    },
+    {
+      input: {},
+      options: { keepOriginPrototype: false },
+      output: Object,
+      title: `should have the same prototype if input is an object and keepOriginPrototype is false`,
+    },
+    {
+      input: {},
+      options: { keepOriginPrototype: true },
+      output: Object,
+      title: `should have the same prototype if input is an object and keepOriginPrototype is true`,
+    },
+  ] as const;
+
+  it.each(objectCases)('$title', ({ input, output, options }) => {
+    const result = normalizer()(input, options);
+
+    expect(result).toBeInstanceOf(output);
+  });
+
+  const primitiveCases: {
+    input: any;
+    output: any;
+    options?: NormalizeOptions;
+    title: string;
+  }[] = [
+    {
+      input: 1,
+      output: 'number',
+      title: `should not affect number primitive if options is not set`,
+    },
+    {
+      input: 1,
+      options: { keepOriginPrototype: false },
+      output: 'number',
+      title: `should not affect number primitive if keepOriginPrototype is false`,
+    },
+    {
+      input: 1,
+      options: { keepOriginPrototype: true },
+      output: 'number',
+      title: `should not affect number primitive if keepOriginPrototype is true`,
+    },
+    {
+      input: '1',
+      output: 'string',
+      title: `should not affect string primitive if options is not set`,
+    },
+    {
+      input: '1',
+      options: { keepOriginPrototype: false },
+      output: 'string',
+      title: `should not affect string primitive if keepOriginPrototype is false`,
+    },
+    {
+      input: '1',
+      options: { keepOriginPrototype: true },
+      output: 'string',
+      title: `should not affect string primitive if keepOriginPrototype is true`,
+    },
+  ];
+
+  it.each(primitiveCases)('$title', ({ input, output, options }) => {
+    const result = normalizer()(input, options);
+
+    expect(typeof result).toBe(output);
+  });
+});

package/src/functions/obj-normalization.ts

@@ -9,20 +9,50 @@ export interface NormalizeOptions {
   filterKeys?: string[];
   sortKeys?: SortKeys;
   maxDepth?: number;
+  keepOriginPrototype?: boolean;
 }
 
 const DEFAULT_MAX_DEPTH = 10;
 
 /**
- * Prepares object to be stringified with JSON.stringify()
- * - removes circular references.
- * - makes message, stack and cause properties of Errors enumerable
- * - (optional) sorts error keys for human readability
- * - (optional) filters out provided keys
+ * Creates a function that prepares objects for JSON.stringify().
  *
- * NOTE: Function is recursive
+ * This is a higher-order function that creates a closure over a cache Set.
+ * The cache is used to detect circular references during normalization.
+ * Each call to normalizer() creates a new cache, ensuring thread-safety
+ * and preventing memory leaks between different normalization operations.
  *
- * @returns unknown
+ * Features:
+ * - Removes circular references (replaces with '[circular]')
+ * - Makes Error properties (message, stack, cause) enumerable
+ * - Handles special types:
+ *   - Buffer -> '[Buffer size]'
+ *   - ArrayBuffer -> '[ArrayBuffer size]'
+ *   - Map -> '[Map size]'
+ *   - Set -> '[Set size]'
+ * - Limits object nesting depth (default: 10)
+ * - Keeps origin prototype (default: false)
+ * - Protects against large objects (>16M keys)
+ *
+ * @example
+ * // Create two independent normalizers
+ * const normalizer1 = normalizer();
+ * const normalizer2 = normalizer();
+ *
+ * // Each normalizer has its own circular reference cache
+ * const obj1 = { circular: {} };
+ * obj1.circular = obj1;
+ * normalizer1(obj1); // Safe: uses first cache
+ * normalizer2(obj1); // Safe: uses second cache
+ *
+ * @returns A normalization function with its own circular reference cache that accepts:
+ *   @param x - Value to normalize
+ *   @param options - Normalization options:
+ *     - filterKeys: Array of keys to exclude
+ *     - sortKeys: Custom key sorting configuration
+ *     - maxDepth: Maximum nesting depth (default: 10)
+ *     - keepOriginPrototype: Whether to keep the original prototype (default: false)
+ *   @param depth - Current recursion depth (internal use)
  */
 export const normalizer = (): ((
   x: unknown,
@@ -53,6 +83,11 @@ export const normalizer = (): ((
       return `[Buffer ${Buffer.byteLength(xObject)}]`;
     }
 
+    // Array is not serializable
+    if (xObject instanceof ArrayBuffer) {
+      return `[ArrayBuffer ${xObject.byteLength}]`;
+    }
+
     // TODO: maybe serialize Map as record/dict
     if (xObject instanceof Map) {
       return `[Map ${xObject.size}]`;
@@ -96,6 +131,16 @@ export const normalizer = (): ((
         keys.sort(options.sortKeys.sortFn);
       }
 
+      /**
+       * There is several cases, when we have to keep the origin prototype.
+       * For example, if normalizer is executing implicitly
+       * and normalized object will be used in `instanceof` condition
+       * next to execution context
+       */
+      const normalized = options?.keepOriginPrototype
+        ? Object.setPrototypeOf({}, Object.getPrototypeOf(xObject))
+        : {};
+
       return keys.reduce((acc: Record<string, unknown>, key) => {
         if (options?.filterKeys?.includes(key)) {
           return acc;
@@ -104,7 +149,7 @@ export const normalizer = (): ((
         acc[key] = normalize((xObject as any)[key], options, newDepth);
 
         return acc;
-      }, {});
+      }, normalized);
     } catch (error) {
       return `[Can not get keys from object. ${error}]`;
     }

package/src/index.ts

@@ -6,3 +6,4 @@ export * from './functions';
 export * from './size';
 export * from './strings';
 export * from './observable';
+export * from './parsers';

package/src/parsers/array/array.parser.ts

@@ -0,0 +1,34 @@
+import { text } from '../../strings';
+import { Assert } from '../../types';
+import type { PropertyParser } from '../parser.interface';
+
+export class ArrayParser<T> implements PropertyParser<T[]> {
+  constructor(
+    private readonly singleValueParser: PropertyParser<T>,
+    private readonly options = { separator: ',' },
+  ) {}
+
+  type(): string {
+    return `(array)${this.singleValueParser.type()}`;
+  }
+
+  description(): string {
+    return text`
+      Extracts array of values. If raw value is a string
+      <${this.options.separator}> will used as separator. Each value:
+      ${this.singleValueParser.description()}
+    `;
+  }
+
+  parse(value: unknown): T[] {
+    if (Array.isArray(value)) {
+      return value.map((x) => this.singleValueParser.parse(x));
+    }
+
+    Assert.isString(value);
+
+    return value
+      .split(this.options.separator)
+      .map((x) => this.singleValueParser.parse(x));
+  }
+}

package/src/parsers/array/index.ts

@@ -0,0 +1 @@
+export * from './array.parser';

package/src/parsers/boolean/bool.parser.ts

@@ -0,0 +1,20 @@
+import { Convert } from '../../convert';
+import { text } from '../../strings';
+import type { PropertyParser } from '../parser.interface';
+
+export class BoolParser implements PropertyParser<boolean> {
+  type(): string {
+    return 'boolean';
+  }
+
+  description(): string {
+    return text`
+      Extracts boolean value. Any boolean value or strings
+      'true' and 'false' will pass.
+    `;
+  }
+
+  parse(value: unknown): boolean {
+    return Convert.boolean(value);
+  }
+}

package/src/parsers/boolean/bool.spec.ts

@@ -0,0 +1,4 @@
+describe('BoolParser', () => {
+  it('See tests for Convert.boolean() in @rsdk/common', () =>
+    expect(true).toBe(true));
+});

package/src/parsers/boolean/index.ts

@@ -0,0 +1 @@
+export * from './bool.parser';