@opra/common 0.15.0 → 0.16.1

package/cjs/document/factory/import-resource-class.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractCollectionSchema = exports.extractSingletonSchema = exports.importResourceClass = void 0;
+require("reflect-metadata");
 const index_js_1 = require("../../helpers/index.js");
 const index_js_2 = require("../../schema/index.js");
 const constants_js_1 = require("../constants.js");

package/cjs/document/factory/import-type-class.js

@@ -26,6 +26,8 @@ async function importTypeClass(typeThunk) {
     const schema = (0, index_js_1.cloneObject)(metadata);
     const result = name || schema;
     if (name) {
+        if (this.document.types.has(name) || typeQueue.has(name))
+            throw new TypeError(`Type "${name}" already imported`);
         cache.set(thunk, result);
         typeQueue.set(name, schema);
     }
@@ -58,6 +60,7 @@ async function importTypeClass(typeThunk) {
     throw new TypeError(`No EnumType metadata found for object ${JSON.stringify(enumObject).substring(0, 20)}...`);
 }
 exports.importTypeClass = importTypeClass;
+// noinspection JSUnusedLocalSymbols
 async function extractSimpleTypeSchema(target, ctor, 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 metadata) {
@@ -85,12 +88,14 @@ async function extractComplexTypeSchema(target, ctor, metadata) {
                     ...elemMeta,
                     type
                 };
-                if (elemMeta.enum) {
+                if (elemMeta.enum)
                     elemSchema.type = await this.importTypeClass(elemMeta.enum);
-                }
                 if (!elemSchema.type && elemMeta.designType)
                     elemSchema.type = await this.importTypeClass(elemMeta.designType);
                 await this.extractFieldSchema(elemSchema, ctor, elemMeta, elemName);
+                // Check enum again. External packages may modify enum value
+                if (elemMeta.enum)
+                    elemSchema.type = await this.importTypeClass(elemMeta.enum);
                 if (typeof elemSchema.type === 'function')
                     elemSchema.type = await this.importTypeClass(elemSchema.type);
                 if (elemSchema.isArray && !elemSchema.type)
@@ -116,12 +121,14 @@ async function extractUnionTypeSchema(target, ctor, metadata) {
         target.types.push(await this.importTypeClass(type));
 }
 exports.extractUnionTypeSchema = extractUnionTypeSchema;
+// noinspection JSUnusedLocalSymbols
 async function extractEnumTypeSchema(
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 target, enumObject, metadata) {
     // Do nothing. This method is used by external modules for extending the factory
 }
 exports.extractEnumTypeSchema = extractEnumTypeSchema;
+// noinspection JSUnusedLocalSymbols
 async function extractFieldSchema(
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 target, ctor, metadata, name) {

package/cjs/document/resource/collection.js

@@ -129,8 +129,8 @@ const proto = {
         const normalized = this.normalizeFieldNames(fields);
         if (!normalized)
             return;
-        const searchEndpoint = this.operations.search;
-        const sortFields = searchEndpoint && searchEndpoint.sortFields;
+        const findManyEndpoint = this.operations.findMany;
+        const sortFields = findManyEndpoint && findManyEndpoint.sortFields;
         normalized.forEach(field => {
             if (!sortFields?.find(x => x === field))
                 throw new index_js_1.BadRequestError({
@@ -176,10 +176,10 @@ function createOperationDecorator(operation) {
         Reflect.defineMetadata(constants_js_1.METADATA_KEY, resourceMetadata, target.constructor);
     });
 }
-exports.Collection.CreateOperation = createOperationDecorator('create');
-exports.Collection.GetOperation = createOperationDecorator('get');
-exports.Collection.DeleteOperation = createOperationDecorator('delete');
-exports.Collection.UpdateOperation = createOperationDecorator('update');
-exports.Collection.SearchOperation = createOperationDecorator('search');
-exports.Collection.UpdateManyOperation = createOperationDecorator('updateMany');
-exports.Collection.DeleteManyOperation = createOperationDecorator('deleteMany');
+exports.Collection.Create = createOperationDecorator('create');
+exports.Collection.Delete = createOperationDecorator('delete');
+exports.Collection.DeleteMany = createOperationDecorator('deleteMany');
+exports.Collection.Get = createOperationDecorator('get');
+exports.Collection.FindMany = createOperationDecorator('findMany');
+exports.Collection.Update = createOperationDecorator('update');
+exports.Collection.UpdateMany = createOperationDecorator('updateMany');

package/cjs/document/resource/singleton.js

@@ -85,7 +85,7 @@ function createOperationDecorator(operation) {
         Reflect.defineMetadata(constants_js_1.METADATA_KEY, resourceMetadata, target.constructor);
     });
 }
-exports.Singleton.CreateOperation = createOperationDecorator('create');
-exports.Singleton.GetOperation = createOperationDecorator('get');
-exports.Singleton.DeleteOperation = createOperationDecorator('delete');
-exports.Singleton.UpdateOperation = createOperationDecorator('update');
+exports.Singleton.Create = createOperationDecorator('create');
+exports.Singleton.Get = createOperationDecorator('get');
+exports.Singleton.Delete = createOperationDecorator('delete');
+exports.Singleton.Update = createOperationDecorator('update');

package/cjs/url/opra-url.js

@@ -14,7 +14,7 @@ const hostRegEx = /^([^/:]+)(?::(\d+))?$/;
 const hostnameRegEx = /^([^/:]+)$/;
 const kContext = Symbol('kContext');
 const kPath = Symbol('kPath');
-const kSearchParams = Symbol('kSearchParams');
+const kParams = Symbol('kParams');
 class OpraURL {
     constructor(input, base) {
         this[_a] = {
@@ -32,7 +32,7 @@ class OpraURL {
                 this[kContext].address = undefined;
             }
         });
-        this[kSearchParams] = new index_js_1.HttpParams('', {
+        this[kParams] = new index_js_1.HttpParams('', {
             onChange: () => {
                 this[kContext].search = undefined;
             }
@@ -182,20 +182,20 @@ class OpraURL {
     }
     get search() {
         if (this[kContext].search == null) {
-            const s = this[kSearchParams].toString();
+            const s = this[kParams].toString();
             this[kContext].search = s ? ('?' + s) : '';
         }
         return this[kContext].search;
     }
     set search(v) {
         if (v) {
-            this[kSearchParams].clear();
-            this[kSearchParams].appendAll(v);
+            this[kParams].clear();
+            this[kParams].appendAll(v);
         }
         this[kContext].search = undefined;
     }
     get searchParams() {
-        return this[kSearchParams];
+        return this[kParams];
     }
     parse(input) {
         const m = urlRegEx.exec(input);
@@ -303,4 +303,4 @@ class OpraURL {
 exports.OpraURL = OpraURL;
 OpraURL.kContext = kContext;
 OpraURL.kPath = kPath;
-OpraURL.kSearchParams = kSearchParams;
+OpraURL.kParams = kParams;

package/esm/document/api-document.js

@@ -1,16 +1,19 @@
-import { NotAcceptableError, NotFoundError } from '../exception/index.js';
-import { cloneObject, omitUndefined, ResponsiveMap } from '../helpers/index.js';
-import { OpraSchema } from '../schema/index.js';
-import { NAMESPACE_PATTERN } from './constants.js';
-import { ComplexType } from './data-type/complex-type.js';
-import { SimpleType } from './data-type/simple-type.js';
-export class ApiDocument {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiDocument = void 0;
+const index_js_1 = require("../exception/index.js");
+const index_js_2 = require("../helpers/index.js");
+const index_js_3 = require("../schema/index.js");
+const constants_js_1 = require("./constants.js");
+const complex_type_js_1 = require("./data-type/complex-type.js");
+const simple_type_js_1 = require("./data-type/simple-type.js");
+class ApiDocument {
     constructor() {
-        this._typeCache = new ResponsiveMap();
+        this._typeCache = new index_js_2.ResponsiveMap();
         this._typesCacheByCtor = new Map();
-        this.references = new ResponsiveMap();
-        this.types = new ResponsiveMap();
-        this.resources = new ResponsiveMap();
+        this.references = new index_js_2.ResponsiveMap();
+        this.types = new index_js_2.ResponsiveMap();
+        this.resources = new index_js_2.ResponsiveMap();
         this.info = {
             version: '',
             title: ''
@@ -30,19 +33,19 @@ export class ApiDocument {
         if (t === null) {
             if (silent)
                 return;
-            throw new NotFoundError(`Data type "${nameOrCtorName}" does not exists`);
+            throw new index_js_1.NotFoundError(`Data type "${nameOrCtorName}" does not exists`);
         }
         if (typeof nameOrCtor === 'string') {
-            const m = NAMESPACE_PATTERN.exec(nameOrCtor);
+            const m = constants_js_1.NAMESPACE_PATTERN.exec(nameOrCtor);
             if (!m)
-                throw new NotFoundError(`Invalid data type name "${nameOrCtorName}"`);
+                throw new index_js_1.NotFoundError(`Invalid data type name "${nameOrCtorName}"`);
             // If given string has namespace pattern (ns:type_name)
             if (m[2]) {
                 const ref = this.references.get(m[1]);
                 if (!ref) {
                     if (silent)
                         return;
-                    throw new NotFoundError(`Reference "${m[1]}" not found`);
+                    throw new index_js_1.NotFoundError(`Reference "${m[1]}" not found`);
                 }
                 dataType = ref.getDataType(m[2]);
                 this._typeCache.set(nameOrCtor, dataType);
@@ -67,7 +70,7 @@ export class ApiDocument {
         else if (typeof nameOrCtor === 'function') {
             const types = Array.from(this.types.values()).reverse();
             for (const dt of types) {
-                if ((dt instanceof ComplexType || dt instanceof SimpleType) && dt.own.ctor === nameOrCtor) {
+                if ((dt instanceof complex_type_js_1.ComplexType || dt instanceof simple_type_js_1.SimpleType) && dt.own.ctor === nameOrCtor) {
                     dataType = dt;
                     break;
                 }
@@ -83,7 +86,7 @@ export class ApiDocument {
             }
         }
         if (dataType) {
-            if ((dataType instanceof ComplexType || dataType instanceof SimpleType) &&
+            if ((dataType instanceof complex_type_js_1.ComplexType || dataType instanceof simple_type_js_1.SimpleType) &&
                 dataType.own?.ctor && dataType.own.ctor !== Object)
                 this._typesCacheByCtor.set(dataType.own.ctor, dataType);
             return dataType;
@@ -96,7 +99,7 @@ export class ApiDocument {
         }
         if (silent)
             return;
-        throw new NotFoundError(`Data type "${nameOrCtorName}" does not exists`);
+        throw new index_js_1.NotFoundError(`Data type "${nameOrCtorName}" does not exists`);
     }
     getComplexType(nameOrCtor, silent) {
         if (nameOrCtor === Object)
@@ -104,30 +107,30 @@ export class ApiDocument {
         const t = this.getDataType(nameOrCtor);
         if (!t && silent)
             return;
-        if (t && t.kind === OpraSchema.ComplexType.Kind)
+        if (t && t.kind === index_js_3.OpraSchema.ComplexType.Kind)
             return t;
-        throw new NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
+        throw new index_js_1.NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
     }
     getSimpleType(nameOrCtor, silent) {
         const t = this.getDataType(nameOrCtor);
         if (!t && silent)
             return;
-        if (t && t.kind === OpraSchema.SimpleType.Kind)
+        if (t && t.kind === index_js_3.OpraSchema.SimpleType.Kind)
             return t;
-        throw new NotAcceptableError(`Data type "${t.name || t}" is not a SimpleType`);
+        throw new index_js_1.NotAcceptableError(`Data type "${t.name || t}" is not a SimpleType`);
     }
     getResource(path, silent) {
         let resource;
-        const m = NAMESPACE_PATTERN.exec(path);
+        const m = constants_js_1.NAMESPACE_PATTERN.exec(path);
         if (!m)
-            throw new NotFoundError(`Invalid resource path "${path}"`);
+            throw new index_js_1.NotFoundError(`Invalid resource path "${path}"`);
         // If given string has namespace pattern (ns:type_name)
         if (m[2]) {
             const ref = this.references.get(m[1]);
             if (!ref) {
                 if (silent)
                     return;
-                throw new NotFoundError(`Reference "${m[1]}" not found`);
+                throw new index_js_1.NotFoundError(`Reference "${m[1]}" not found`);
             }
             return ref.getResource(m[2]);
         }
@@ -147,32 +150,32 @@ export class ApiDocument {
         }
         if (silent)
             return;
-        throw new NotFoundError(`Resource not found (${path})`);
+        throw new index_js_1.NotFoundError(`Resource not found (${path})`);
     }
     getCollection(path, silent) {
         const t = this.getResource(path);
         if (!t && silent)
             return;
-        if (t && t.kind === OpraSchema.Collection.Kind)
+        if (t && t.kind === index_js_3.OpraSchema.Collection.Kind)
             return t;
-        throw new NotAcceptableError(`Resource type "${t.name}" is not a Collection`);
+        throw new index_js_1.NotAcceptableError(`Resource type "${t.name}" is not a Collection`);
     }
     getSingleton(path, silent) {
         const t = this.getResource(path);
         if (!t && silent)
             return;
-        if (t && t.kind === OpraSchema.Singleton.Kind)
+        if (t && t.kind === index_js_3.OpraSchema.Singleton.Kind)
             return t;
-        throw new NotAcceptableError(`Resource type "${t.name}" is not a Singleton`);
+        throw new index_js_1.NotAcceptableError(`Resource type "${t.name}" is not a Singleton`);
     }
     /**
      * Export as Opra schema definition object
      */
     exportSchema() {
         const schema = {
-            version: OpraSchema.SpecVersion,
+            version: index_js_3.OpraSchema.SpecVersion,
             url: this.url,
-            info: cloneObject(this.info)
+            info: (0, index_js_2.cloneObject)(this.info)
         };
         if (this.references.size) {
             const references = {};
@@ -198,10 +201,11 @@ export class ApiDocument {
                 types[name] = r.exportSchema();
             }
         }
-        return omitUndefined(schema);
+        return (0, index_js_2.omitUndefined)(schema);
     }
     invalidate() {
         this._typeCache.clear();
         this._typesCacheByCtor.clear();
     }
 }
+exports.ApiDocument = ApiDocument;

package/esm/document/constants.js

@@ -1,3 +1,6 @@
-export const METADATA_KEY = Symbol.for('opra.metadata');
-export const NAMESPACE_PATTERN = /([A-Z$_]\w+)(?::.+)?/i;
-export const TYPENAME_PATTERN = /^(.*)Type$/;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TYPENAME_PATTERN = exports.NAMESPACE_PATTERN = exports.METADATA_KEY = void 0;
+exports.METADATA_KEY = Symbol.for('opra.metadata');
+exports.NAMESPACE_PATTERN = /([A-Z$_]\w+)(?::.+)?/i;
+exports.TYPENAME_PATTERN = /^(.*)Type$/;

package/esm/document/data-type/api-field.js

@@ -1,19 +1,22 @@
-import { omitUndefined } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { METADATA_KEY } from '../constants.js';
-import { EnumType } from './enum-type.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiField = void 0;
+const index_js_1 = require("../../helpers/index.js");
+const index_js_2 = require("../../schema/index.js");
+const constants_js_1 = require("../constants.js");
+const enum_type_js_1 = require("./enum-type.js");
 /**
  * @class ComplexType
  */
-export const ApiField = function (...args) {
+exports.ApiField = function (...args) {
     // ClassDecorator
     if (!this) {
         const [options] = args;
         return function (target, propertyKey) {
             if (typeof propertyKey !== 'string')
                 throw new TypeError(`Symbol properties can't be used as a field`);
-            const metadata = Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {};
-            metadata.kind = OpraSchema.ComplexType.Kind;
+            const metadata = Reflect.getOwnMetadata(constants_js_1.METADATA_KEY, target.constructor) || {};
+            metadata.kind = index_js_2.OpraSchema.ComplexType.Kind;
             metadata.fields = metadata.fields || {};
             const designType = Reflect.getMetadata('design:type', target, propertyKey);
             const isArray = designType === Array;
@@ -31,17 +34,17 @@ export const ApiField = function (...args) {
                         o[v] = v;
                         return o;
                     }, {});
-                    EnumType(enumObj);
+                    (0, enum_type_js_1.EnumType)(enumObj);
                     elemMeta.enum = enumObj;
                 }
                 else {
-                    const m = Reflect.getOwnMetadata(METADATA_KEY, options?.enum);
-                    if (!OpraSchema.isEnumType(m))
+                    const m = Reflect.getOwnMetadata(constants_js_1.METADATA_KEY, options?.enum);
+                    if (!index_js_2.OpraSchema.isEnumType(m))
                         throw new TypeError(`Invalid "enum" value. Did you forget to set metadata using EnumType() method?`);
                     elemMeta.enum = options.enum;
                 }
             }
-            Reflect.defineMetadata(METADATA_KEY, omitUndefined(metadata), target.constructor);
+            Reflect.defineMetadata(constants_js_1.METADATA_KEY, (0, index_js_1.omitUndefined)(metadata), target.constructor);
         };
     }
     // Constructor
@@ -76,4 +79,4 @@ const proto = {
         return out;
     }
 };
-Object.assign(ApiField.prototype, proto);
+Object.assign(exports.ApiField.prototype, proto);

package/esm/document/data-type/builtin/any.type.js

@@ -1,11 +1,14 @@
-import { __decorate } from "tslib";
-import { SimpleType } from '../simple-type.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnyType = void 0;
+const tslib_1 = require("tslib");
+const simple_type_js_1 = require("../simple-type.js");
 let AnyType = class AnyType {
 };
-AnyType = __decorate([
-    SimpleType({
+AnyType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
         description: 'Any value',
         ctor: Object
     })
 ], AnyType);
-export { AnyType };
+exports.AnyType = AnyType;

package/esm/document/data-type/builtin/base64.type.js

@@ -1,5 +1,8 @@
-import { __decorate } from "tslib";
-import { SimpleType } from '../simple-type.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base64Type = void 0;
+const tslib_1 = require("tslib");
+const simple_type_js_1 = require("../simple-type.js");
 const BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:(?:[A-Za-z0-9+/][AQgw](:?==)?)|(?:[A-Za-z0-9+/]{2}[AEIMQUYcgkosw048]=?))?$/;
 let Base64Type = class Base64Type {
     decode(v) {
@@ -26,10 +29,10 @@ let Base64Type = class Base64Type {
             throw new TypeError(`Invalid base64 value "${String(v).substring(0, 10)}..."`);
     }
 };
-Base64Type = __decorate([
-    SimpleType({
+Base64Type = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
         description: 'A stream of bytes, base64 encoded',
         ctor: ArrayBuffer
     })
 ], Base64Type);
-export { Base64Type };
+exports.Base64Type = Base64Type;

package/esm/document/data-type/builtin/bigint.type.js

@@ -1,5 +1,8 @@
-import { __decorate } from "tslib";
-import { SimpleType } from '../simple-type.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigIntType = void 0;
+const tslib_1 = require("tslib");
+const simple_type_js_1 = require("../simple-type.js");
 const BigIntConstructor = Object.getPrototypeOf(BigInt(0)).constructor;
 let BigIntType = class BigIntType {
     decode(v) {
@@ -20,11 +23,11 @@ let BigIntType = class BigIntType {
             throw new TypeError(`Invalid number value "${v}"`);
     }
 };
-BigIntType = __decorate([
-    SimpleType({
+BigIntType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
         name: 'bigint',
         description: 'BigInt number',
         ctor: BigIntConstructor
     })
 ], BigIntType);
-export { BigIntType };
+exports.BigIntType = BigIntType;

package/esm/document/data-type/builtin/boolean.type.js

@@ -1,25 +1,28 @@
-import { __decorate } from "tslib";
-import { toBoolean } from 'putil-varhelpers';
-import { SimpleType } from '../simple-type.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanType = void 0;
+const tslib_1 = require("tslib");
+const putil_varhelpers_1 = require("putil-varhelpers");
+const simple_type_js_1 = require("../simple-type.js");
 let BooleanType = class BooleanType {
     decode(v) {
         if (v == null)
             return v;
-        return toBoolean(v);
+        return (0, putil_varhelpers_1.toBoolean)(v);
     }
     encode(v) {
         if (v == null)
             return v;
-        return toBoolean(v);
+        return (0, putil_varhelpers_1.toBoolean)(v);
     }
     coerce(v) {
         return this.decode(v);
     }
 };
-BooleanType = __decorate([
-    SimpleType({
+BooleanType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
         description: 'Simple true/false value',
         ctor: Boolean
     })
 ], BooleanType);
-export { BooleanType };
+exports.BooleanType = BooleanType;

package/esm/document/data-type/builtin/date.type.js

@@ -1,15 +1,18 @@
-import { __decorate } from "tslib";
-import { SimpleType } from '../simple-type.js';
-import { TimestampType } from './timestamp.type.js';
-let DateType = class DateType extends TimestampType {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateType = void 0;
+const tslib_1 = require("tslib");
+const simple_type_js_1 = require("../simple-type.js");
+const timestamp_type_js_1 = require("./timestamp.type.js");
+let DateType = class DateType extends timestamp_type_js_1.TimestampType {
     constructor() {
         super(...arguments);
         this.format = 'YYYY-MM-DD';
     }
 };
-DateType = __decorate([
-    SimpleType({
+DateType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
         description: 'full-date notation as defined by RFC 3339, section 5.6, for example, 2021-04-18',
     })
 ], DateType);
-export { DateType };
+exports.DateType = DateType;

package/esm/document/data-type/builtin/guid.type.js

@@ -1,13 +1,16 @@
-import { __decorate } from "tslib";
-import { toString } from 'putil-varhelpers';
-import { SimpleType } from '../simple-type.js';
-import { StringType } from './string.type.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuidType = void 0;
+const tslib_1 = require("tslib");
+const putil_varhelpers_1 = require("putil-varhelpers");
+const simple_type_js_1 = require("../simple-type.js");
+const string_type_js_1 = require("./string.type.js");
 const GUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-let GuidType = class GuidType extends StringType {
+let GuidType = class GuidType extends string_type_js_1.StringType {
     decode(v) {
         if (v == null)
             return v;
-        const s = toString(v);
+        const s = (0, putil_varhelpers_1.toString)(v);
         if (s)
             this.validate(s);
         return s;
@@ -24,9 +27,9 @@ let GuidType = class GuidType extends StringType {
             throw new TypeError(`Invalid GUID value "${v}"`);
     }
 };
-GuidType = __decorate([
-    SimpleType({
+GuidType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
         description: 'A Globally Unique Identifier (GUID) value',
     })
 ], GuidType);
-export { GuidType };
+exports.GuidType = GuidType;

package/esm/document/data-type/builtin/index.js

@@ -1,10 +1,13 @@
-export * from './any.type.js';
-export * from './base64.type.js';
-export * from './bigint.type.js';
-export * from './boolean.type.js';
-export * from './date.type.js';
-export * from './guid.type.js';
-export * from './integer.type.js';
-export * from './number.type.js';
-export * from './object.type.js';
-export * from './string.type.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./any.type.js"), exports);
+tslib_1.__exportStar(require("./base64.type.js"), exports);
+tslib_1.__exportStar(require("./bigint.type.js"), exports);
+tslib_1.__exportStar(require("./boolean.type.js"), exports);
+tslib_1.__exportStar(require("./date.type.js"), exports);
+tslib_1.__exportStar(require("./guid.type.js"), exports);
+tslib_1.__exportStar(require("./integer.type.js"), exports);
+tslib_1.__exportStar(require("./number.type.js"), exports);
+tslib_1.__exportStar(require("./object.type.js"), exports);
+tslib_1.__exportStar(require("./string.type.js"), exports);

package/esm/document/data-type/builtin/integer.type.js

@@ -1,25 +1,28 @@
-import { __decorate } from "tslib";
-import { toInt } from 'putil-varhelpers';
-import { SimpleType } from '../simple-type.js';
-import { NumberType } from './number.type.js';
-let IntegerType = class IntegerType extends NumberType {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegerType = void 0;
+const tslib_1 = require("tslib");
+const putil_varhelpers_1 = require("putil-varhelpers");
+const simple_type_js_1 = require("../simple-type.js");
+const number_type_js_1 = require("./number.type.js");
+let IntegerType = class IntegerType extends number_type_js_1.NumberType {
     decode(v) {
         if (v == null)
             return v;
-        return toInt(super.decode(v));
+        return (0, putil_varhelpers_1.toInt)(super.decode(v));
     }
     encode(v) {
         if (v == null)
             return v;
-        return toInt(super.encode(v));
+        return (0, putil_varhelpers_1.toInt)(super.encode(v));
     }
     coerce(v) {
         return this.decode(v);
     }
 };
-IntegerType = __decorate([
-    SimpleType({
+IntegerType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
         description: 'An integer number',
     })
 ], IntegerType);
-export { IntegerType };
+exports.IntegerType = IntegerType;