@opra/common 0.4.0 → 0.6.0

package/cjs/i18n/i18n.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18n = exports.BaseI18n = void 0;
+const tslib_1 = require("tslib");
+const fast_tokenizer_1 = require("fast-tokenizer");
+const i18next_1 = tslib_1.__importDefault(require("i18next"));
+const index_js_1 = require("../utils/index.js");
+const string_utils_js_1 = require("./string-utils.js");
+exports.BaseI18n = Object.getPrototypeOf(i18next_1.default).constructor;
+const globalLocaleDirs = [];
+class I18n extends exports.BaseI18n {
+    async init(arg0, arg1) {
+        const options = typeof arg0 === 'object' ? arg0 : {};
+        const callback = typeof arg0 === 'function' ? arg0 : arg1;
+        try {
+            const t = await super.init(options);
+            // Add formatters
+            const formatter = this.services.formatter;
+            formatter.add('lowercase', (value, lng) => value.toLocaleLowerCase(lng));
+            formatter.add('uppercase', (value, lng) => value.toLocaleUpperCase(lng));
+            formatter.add('upperFirst', (value, lng) => value.charAt(0).toLocaleUpperCase(lng) + value.substring(1));
+            // Load globally registered resources
+            if (globalLocaleDirs.length)
+                await this.loadResourceDir(globalLocaleDirs, false, true);
+            // Load resource dirs and overwrite existing
+            if (options?.resourceDirs?.length) {
+                await this.loadResourceDir(options.resourceDirs, false, true);
+            }
+            // overwrite existing resources with options.resources
+            if (options?.resources) {
+                for (const lang of Object.keys(options.resources)) {
+                    const langObj = options.resources[lang];
+                    for (const ns of Object.keys(langObj)) {
+                        this.addResourceBundle(lang, ns, langObj[ns], false, true);
+                    }
+                }
+            }
+            if (callback)
+                callback(null, t);
+            return t;
+        }
+        catch (err) {
+            if (callback)
+                callback(err, this.t);
+            throw err;
+        }
+    }
+    deep(input, options) {
+        if (input == null)
+            return input;
+        const objectStack = new WeakMap();
+        return this._deepTranslate(input, objectStack, options);
+    }
+    registerLocaleDir(...dirname) {
+        globalLocaleDirs.push(...dirname);
+    }
+    async loadResourceBundle(lang, ns, filePath, deep, overwrite) {
+        let obj;
+        if ((0, index_js_1.isUrl)(filePath)) {
+            obj = (await fetch(filePath, { headers: { accept: 'application/json' } })).json();
+        }
+        else {
+            const fs = await Promise.resolve().then(() => tslib_1.__importStar(require('fs/promises')));
+            const content = await fs.readFile(filePath, 'utf8');
+            obj = JSON.parse(content);
+        }
+        this.addResourceBundle(lang, ns, obj, deep, overwrite);
+    }
+    async loadResourceDir(dirnames, deep, overwrite) {
+        const fs = await Promise.resolve().then(() => tslib_1.__importStar(require('fs/promises')));
+        const path = await Promise.resolve().then(() => tslib_1.__importStar(require('path')));
+        for (const dirname of Array.isArray(dirnames) ? dirnames : [dirnames]) {
+            /* istanbul ignore next */
+            if (!(await fs.stat(dirname)).isDirectory()) {
+                // eslint-disable-next-line no-console
+                console.warn(`Locale directory does not exists. (${dirname})`);
+                continue;
+            }
+            const languageDirs = await fs.readdir(dirname);
+            for (const lang of languageDirs) {
+                const langDir = path.join(dirname, lang);
+                if ((await fs.stat(langDir)).isDirectory()) {
+                    const nsDirs = await fs.readdir(langDir);
+                    for (const nsfile of nsDirs) {
+                        const nsFilePath = path.join(langDir, nsfile);
+                        const ext = path.extname(nsfile);
+                        if (ext === '.json' && (await fs.stat(nsFilePath)).isFile()) {
+                            const ns = path.basename(nsfile, ext);
+                            await this.loadResourceBundle(lang, ns, nsFilePath, deep, overwrite);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    createInstance(options = {}, callback) {
+        return new I18n(options, callback);
+    }
+    static createInstance(options, callback) {
+        return new I18n(options, callback);
+    }
+    _deepTranslate(input, objectStack, options) {
+        if (input == null)
+            return input;
+        if (options?.ignore && options.ignore(input, this))
+            return input;
+        if (typeof input === 'object' && objectStack.has(input))
+            return objectStack.get(input);
+        if (typeof input === 'string') {
+            let s = '';
+            for (let token of (0, fast_tokenizer_1.tokenize)(input, {
+                brackets: { '$t(': ')' },
+                quotes: true,
+                keepQuotes: true,
+                keepBrackets: true,
+                keepDelimiters: true,
+            })) {
+                if (token.startsWith('$t(') && token.endsWith(')')) {
+                    token = token.substring(3, token.length - 1);
+                    const a = (0, fast_tokenizer_1.splitString)(token, { delimiters: '?', quotes: true, brackets: { '{': '}' } });
+                    const fallback = (0, string_utils_js_1.unescapeString)(token.substring((a[0] || '').length + 1));
+                    token = a[0] || '';
+                    const keys = [];
+                    let opts = null;
+                    for (const token2 of (0, fast_tokenizer_1.tokenize)(token, { delimiters: ',', quotes: true, brackets: { '{': '}' } })) {
+                        if (token2.startsWith('{')) {
+                            opts = JSON.parse(token2);
+                            continue;
+                        }
+                        keys.push(token2);
+                    }
+                    const k = keys.length > 1 ? '$t(' + keys.join(',') + ')' : keys[0];
+                    s += fallback
+                        ? this.t(k, fallback, { ...options, ...opts })
+                        : this.t(k, { ...options, ...opts });
+                    continue;
+                }
+                s += token;
+            }
+            return s;
+        }
+        if (Array.isArray(input)) {
+            const out = Array(input.length);
+            objectStack.set(input, out);
+            for (let i = 0, l = input.length; i < l; i++) {
+                out[i] = this._deepTranslate(input[i], objectStack, options);
+            }
+            objectStack.delete(input);
+            return out;
+        }
+        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)
+                return input;
+            const out = {};
+            objectStack.set(input, out);
+            const keys = Object.keys(input);
+            for (let i = 0, l = keys.length; i < l; i++) {
+                const k = keys[i];
+                out[k] = this._deepTranslate(input[k], objectStack, options);
+            }
+            objectStack.delete(input);
+            return out;
+        }
+        return input;
+    }
+    static get defaultInstance() {
+        return defaultInstance;
+    }
+}
+exports.I18n = I18n;
+const defaultInstance = I18n.createInstance();

package/cjs/i18n/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.i18n = void 0;
+const tslib_1 = require("tslib");
+const i18n_js_1 = require("./i18n.js");
+tslib_1.__exportStar(require("./i18n.js"), exports);
+tslib_1.__exportStar(require("./translate.js"), exports);
+const i18n = i18n_js_1.I18n.createInstance();
+exports.i18n = i18n;
+i18n.init().catch(() => void 0);

package/cjs/i18n/string-utils.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unescapeString = exports.escapeString = void 0;
+const unescapeRegEx = /\\(.)/g;
+const escapeRegEx = /(\\)/g;
+function escapeString(s) {
+    return s.replace(escapeRegEx, '\\\\');
+}
+exports.escapeString = escapeString;
+function unescapeString(s) {
+    return s.replace(unescapeRegEx, '$1');
+}
+exports.unescapeString = unescapeString;

package/cjs/i18n/translate.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translate = void 0;
+const string_utils_js_1 = require("./string-utils.js");
+const bracketRegEx = /(\))/g;
+function translate(key, arg0, arg1) {
+    const options = arg0 && typeof arg0 === 'object' ? arg0 : undefined;
+    const fallback = typeof arg0 === 'string' ? arg0 : arg1;
+    return '$t(' +
+        key +
+        (options ? ',' + JSON.stringify(options) : '') +
+        (fallback ? '?' + (0, string_utils_js_1.escapeString)(fallback).replace(bracketRegEx, '\\$1') : '') +
+        ')';
+}
+exports.translate = translate;

package/cjs/index.js

@@ -1,5 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.uid = void 0;
 const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./responsive-map.js"), exports);
-tslib_1.__exportStar(require("./types.js"), exports);
+tslib_1.__exportStar(require("./exception/index.js"), exports);
+tslib_1.__exportStar(require("./i18n/index.js"), exports);
+tslib_1.__exportStar(require("./filter/index.js"), exports); // todo. review
+tslib_1.__exportStar(require("./http/multipart/index.js"), exports);
+tslib_1.__exportStar(require("./schema/index.js"), exports);
+tslib_1.__exportStar(require("./url/index.js"), exports);
+tslib_1.__exportStar(require("./http/index.js"), exports);
+tslib_1.__exportStar(require("./helpers/index.js"), exports);
+tslib_1.__exportStar(require("./utils/index.js"), exports);
+var uid_1 = require("uid");
+Object.defineProperty(exports, "uid", { enumerable: true, get: function () { return uid_1.uid; } });

package/cjs/schema/constants.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectionMethods = exports.singletonMethods = exports.MAPPED_TYPE_METADATA = exports.IGNORE_RESOLVER_METHOD = exports.RESOLVER_METADATA = exports.RESOURCE_METADATA = exports.COMPLEXTYPE_FIELDS = exports.DATATYPE_METADATA = void 0;
+exports.DATATYPE_METADATA = 'opra:data_type.metadata';
+exports.COMPLEXTYPE_FIELDS = 'opra:complex_type.fields';
+exports.RESOURCE_METADATA = 'opra:resource.metadata';
+exports.RESOLVER_METADATA = 'opra:resolver.metadata';
+exports.IGNORE_RESOLVER_METHOD = 'opra:ignore_resolver-method';
+exports.MAPPED_TYPE_METADATA = 'opra:mapped_type.metadata';
+exports.singletonMethods = ['create', 'delete', 'get', 'update'];
+exports.collectionMethods = [...exports.singletonMethods, 'count', 'deleteMany', 'updateMany', 'search'];

package/cjs/schema/decorators/opr-collection-resource.decorator.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OprCollectionResource = void 0;
+require("reflect-metadata");
+const lodash_1 = require("lodash");
+const constants_js_1 = require("../constants.js");
+const NESTJS_INJECTABLE_WATERMARK = '__injectable__';
+const NAME_PATTERN = /^(.*)Resource$/;
+function OprCollectionResource(entityFunc, options) {
+    return function (target) {
+        const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
+        const meta = {
+            kind: 'CollectionResource',
+            type: entityFunc,
+            name
+        };
+        Object.assign(meta, (0, lodash_1.omit)(options, Object.keys(meta)));
+        Reflect.defineMetadata(constants_js_1.RESOURCE_METADATA, meta, target);
+        /* Define Injectable metadata for NestJS support*/
+        Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK, true, target);
+    };
+}
+exports.OprCollectionResource = OprCollectionResource;

package/cjs/schema/decorators/opr-complex-type.decorator.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OprComplexType = void 0;
+const lodash_1 = require("lodash");
+const constants_js_1 = require("../constants.js");
+const NAME_PATTERN = /^(.*)Type$/;
+function OprComplexType(options) {
+    return (target) => {
+        const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
+        const meta = {
+            kind: 'ComplexType',
+            name,
+        };
+        Object.assign(meta, (0, lodash_1.omit)(options, Object.keys(meta)));
+        const base = Object.getPrototypeOf(target);
+        const baseMeta = Reflect.getMetadata(constants_js_1.DATATYPE_METADATA, base);
+        if (baseMeta) {
+            if (baseMeta.additionalFields && meta.additionalFields == null)
+                meta.additionalFields = true;
+            meta.extends = [{
+                    type: base
+                }];
+        }
+        Reflect.defineMetadata(constants_js_1.DATATYPE_METADATA, meta, target);
+    };
+}
+exports.OprComplexType = OprComplexType;

package/cjs/schema/decorators/opr-field.decorator.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OprField = void 0;
+const lodash_1 = require("lodash");
+const constants_js_1 = require("../constants.js");
+function OprField(args) {
+    return (target, propertyKey) => {
+        if (typeof propertyKey !== 'string')
+            throw new TypeError(`Symbol properties can't be used as field`);
+        const designType = Reflect.getMetadata('design:type', target, propertyKey);
+        const metadata = {
+            type: args?.type
+        };
+        Object.assign(metadata, (0, lodash_1.omit)(args, Object.keys(metadata)));
+        if (designType === Array) {
+            metadata.isArray = true;
+            metadata.type = metadata.type || 'any';
+        }
+        else {
+            delete metadata.isArray;
+            metadata.type = metadata.type || designType;
+        }
+        const fields = Reflect.getOwnMetadata(constants_js_1.COMPLEXTYPE_FIELDS, target.constructor) || {};
+        fields[propertyKey] = metadata;
+        Reflect.defineMetadata(constants_js_1.COMPLEXTYPE_FIELDS, fields, target.constructor);
+    };
+}
+exports.OprField = OprField;

package/cjs/schema/decorators/opr-resolver.decorator.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OprSearchResolver = exports.OprGetResolver = exports.OprUpdateManyResolver = exports.OprUpdateResolver = exports.OprDeleteManyResolver = exports.OprDeleteResolver = exports.OprCreateResolver = void 0;
+const constants_js_1 = require("../constants.js");
+function OprCreateResolver(options) {
+    return (target, propertyKey) => {
+        if (propertyKey !== 'create')
+            throw new TypeError('This decorator can only be applied for the "create" property');
+        const metadata = {
+            ...options
+        };
+        Reflect.defineMetadata(constants_js_1.RESOLVER_METADATA, metadata, target, propertyKey);
+    };
+}
+exports.OprCreateResolver = OprCreateResolver;
+function OprDeleteResolver(options) {
+    return (target, propertyKey) => {
+        if (propertyKey !== 'delete')
+            throw new TypeError('This decorator can only be applied for the "delete" property');
+        const metadata = {
+            ...options
+        };
+        Reflect.defineMetadata(constants_js_1.RESOLVER_METADATA, metadata, target, propertyKey);
+    };
+}
+exports.OprDeleteResolver = OprDeleteResolver;
+function OprDeleteManyResolver(options) {
+    return (target, propertyKey) => {
+        if (propertyKey !== 'deleteMany')
+            throw new TypeError('This decorator can only be applied for the "deleteMany" property');
+        const metadata = {
+            ...options
+        };
+        Reflect.defineMetadata(constants_js_1.RESOLVER_METADATA, metadata, target, propertyKey);
+    };
+}
+exports.OprDeleteManyResolver = OprDeleteManyResolver;
+function OprUpdateResolver(options) {
+    return (target, propertyKey) => {
+        if (propertyKey !== 'update')
+            throw new TypeError('This decorator can only be applied for the "update" property');
+        const metadata = {
+            ...options
+        };
+        Reflect.defineMetadata(constants_js_1.RESOLVER_METADATA, metadata, target, propertyKey);
+    };
+}
+exports.OprUpdateResolver = OprUpdateResolver;
+function OprUpdateManyResolver(options) {
+    return (target, propertyKey) => {
+        if (propertyKey !== 'updateMany')
+            throw new TypeError('This decorator can only be applied for the "updateMany" property');
+        const metadata = {
+            ...options
+        };
+        Reflect.defineMetadata(constants_js_1.RESOLVER_METADATA, metadata, target, propertyKey);
+    };
+}
+exports.OprUpdateManyResolver = OprUpdateManyResolver;
+function OprGetResolver(options) {
+    return (target, propertyKey) => {
+        if (propertyKey !== 'get')
+            throw new TypeError('This decorator can only be applied for the "get" property');
+        const metadata = {
+            ...options
+        };
+        Reflect.defineMetadata(constants_js_1.RESOLVER_METADATA, metadata, target, propertyKey);
+    };
+}
+exports.OprGetResolver = OprGetResolver;
+function OprSearchResolver(options) {
+    return (target, propertyKey) => {
+        if (propertyKey !== 'search')
+            throw new TypeError('This decorator can only be applied for the "search" property');
+        const metadata = {
+            ...options
+        };
+        Reflect.defineMetadata(constants_js_1.RESOLVER_METADATA, metadata, target, propertyKey);
+    };
+}
+exports.OprSearchResolver = OprSearchResolver;

package/cjs/schema/decorators/opr-simple-type.decorator.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OprSimpleType = void 0;
+const lodash_1 = require("lodash");
+const constants_js_1 = require("../constants.js");
+const NAME_PATTERN = /^(.*)Type$/;
+function OprSimpleType(options) {
+    return (target) => {
+        const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
+        const meta = {
+            kind: 'SimpleType',
+            name
+        };
+        Object.assign(meta, (0, lodash_1.omit)(options, Object.keys(meta)));
+        Reflect.defineMetadata(constants_js_1.DATATYPE_METADATA, meta, target);
+    };
+}
+exports.OprSimpleType = OprSimpleType;

package/cjs/schema/decorators/opr-singleton-resource.decorator.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OprSingletonResource = void 0;
+require("reflect-metadata");
+const lodash_1 = require("lodash");
+const constants_js_1 = require("../constants.js");
+const NESTJS_INJECTABLE_WATERMARK = '__injectable__';
+const NAME_PATTERN = /^(.*)Resource$/;
+function OprSingletonResource(type, options) {
+    return function (target) {
+        const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
+        const meta = {
+            kind: 'SingletonResource',
+            type,
+            name
+        };
+        Object.assign(meta, (0, lodash_1.omit)(options, Object.keys(meta)));
+        Reflect.defineMetadata(constants_js_1.RESOURCE_METADATA, meta, target);
+        /* Define Injectable metadata for NestJS support*/
+        Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK, true, target);
+    };
+}
+exports.OprSingletonResource = OprSingletonResource;

package/cjs/schema/implementation/data-type/builtin/any.type.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnyType = void 0;
+exports.AnyType = {
+    kind: 'UnionType',
+    description: 'Any value',
+    ctor: Object,
+    types: []
+};

package/cjs/schema/implementation/data-type/builtin/base64-binary.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base64BinaryType = void 0;
+const BufferConstructor = Object.getPrototypeOf(Buffer.from('')).constructor;
+exports.Base64BinaryType = {
+    kind: 'SimpleType',
+    description: 'A stream of bytes, base64 encoded',
+    ctor: BufferConstructor,
+    parse(v) {
+        return Buffer.from(v);
+    },
+    serialize(v) {
+        return Buffer.isBuffer(v) ? v.toString('base64') : undefined;
+    }
+};

package/cjs/schema/implementation/data-type/builtin/bigint.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigIntType = void 0;
+const BigIntConstructor = Object.getPrototypeOf(BigInt(0)).constructor;
+exports.BigIntType = {
+    kind: 'SimpleType',
+    description: 'BigInt number',
+    ctor: BigIntConstructor,
+    parse(v) {
+        return BigInt(v);
+    },
+    serialize(v) {
+        return String(v);
+    }
+};

package/cjs/schema/implementation/data-type/builtin/boolean.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanType = void 0;
+const putil_varhelpers_1 = require("putil-varhelpers");
+exports.BooleanType = {
+    kind: 'SimpleType',
+    description: 'Simple true/false value',
+    ctor: Boolean,
+    parse(v) {
+        return (0, putil_varhelpers_1.toBoolean)(v);
+    },
+    serialize(v) {
+        return (0, putil_varhelpers_1.toBoolean)(v);
+    }
+};

package/cjs/schema/implementation/data-type/builtin/date-string.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateStringType = void 0;
+const putil_varhelpers_1 = require("putil-varhelpers");
+exports.DateStringType = {
+    kind: 'SimpleType',
+    description: 'A date, date-time or partial date in string format',
+    ctor: String,
+    parse(v) {
+        return (0, putil_varhelpers_1.toString)(v);
+    },
+    serialize(v) {
+        return (0, putil_varhelpers_1.toString)(v);
+    }
+};

package/cjs/schema/implementation/data-type/builtin/date.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateType = void 0;
+const putil_varhelpers_1 = require("putil-varhelpers");
+exports.DateType = {
+    kind: 'SimpleType',
+    description: 'A date, date-time or partial date',
+    ctor: String,
+    parse(v) {
+        return (0, putil_varhelpers_1.toDate)(v);
+    },
+    serialize(v) {
+        return String(v);
+    }
+};

package/cjs/schema/implementation/data-type/builtin/guid.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuidType = void 0;
+const putil_varhelpers_1 = require("putil-varhelpers");
+exports.GuidType = {
+    kind: 'SimpleType',
+    description: 'A guid value',
+    ctor: String,
+    parse(v) {
+        return (0, putil_varhelpers_1.toString)(v);
+    },
+    serialize(v) {
+        return (0, putil_varhelpers_1.toString)(v);
+    }
+};

package/cjs/schema/implementation/data-type/builtin/integer.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegerType = void 0;
+const putil_varhelpers_1 = require("putil-varhelpers");
+exports.IntegerType = {
+    kind: 'SimpleType',
+    description: 'An integer number',
+    ctor: Number,
+    parse(v) {
+        return (0, putil_varhelpers_1.toInt)(v);
+    },
+    serialize(v) {
+        return (0, putil_varhelpers_1.toInt)(v);
+    }
+};

package/cjs/schema/implementation/data-type/builtin/number.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberType = void 0;
+const putil_varhelpers_1 = require("putil-varhelpers");
+exports.NumberType = {
+    kind: 'SimpleType',
+    description: 'Both Integer as well as Floating-Point numbers',
+    ctor: Number,
+    parse(v) {
+        return (0, putil_varhelpers_1.toNumber)(v);
+    },
+    serialize(v) {
+        return (0, putil_varhelpers_1.toNumber)(v);
+    }
+};

package/cjs/schema/implementation/data-type/builtin/object.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectType = void 0;
+exports.ObjectType = {
+    kind: 'ComplexType',
+    description: 'A non modelled object',
+    ctor: Object,
+    additionalFields: true,
+    parse(v) {
+        return v;
+    },
+    serialize(v) {
+        return v;
+    }
+};

package/cjs/schema/implementation/data-type/builtin/string.type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringType = void 0;
+const putil_varhelpers_1 = require("putil-varhelpers");
+exports.StringType = {
+    kind: 'SimpleType',
+    description: 'A sequence of characters',
+    ctor: String,
+    parse(v) {
+        return (0, putil_varhelpers_1.toString)(v);
+    },
+    serialize(v) {
+        return (0, putil_varhelpers_1.toString)(v);
+    }
+};