@opra/common 1.17.7 → 1.19.0

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

@@ -28,11 +28,6 @@ exports.ApiField = function (...args) {
         throw new Error('Field origin should be one of ComplexType, MappedType or MixinType');
     }
     _this.origin = origin;
-    _this.scopePattern = initArgs.scopePattern
-        ? Array.isArray(initArgs.scopePattern)
-            ? initArgs.scopePattern
-            : [initArgs.scopePattern]
-        : undefined;
     _this.type = initArgs.type || owner.node.getDataType('any');
     _this.description = initArgs.description;
     _this.isArray = initArgs.isArray;
@@ -48,6 +43,17 @@ exports.ApiField = function (...args) {
     _this.writeonly = initArgs.writeonly;
     _this.examples = initArgs.examples;
     _this.override = initArgs.override;
+    _this.scopePattern = initArgs.scopePattern
+        ? Array.isArray(initArgs.scopePattern)
+            ? initArgs.scopePattern
+            : [initArgs.scopePattern]
+        : undefined;
+    _this.convertToNative =
+        initArgs.convertToNative ??
+            (_this.type.kind === 'SimpleType' &&
+                typeof initArgs.designType === 'function' &&
+                initArgs.designType !== Object);
+    _this.override = initArgs.override;
 };
 /**
  * The ApiFieldClass represents a descriptive metadata structure for API fields,

package/cjs/document/data-type/complex-type-base.js

@@ -334,6 +334,8 @@ class ComplexTypeBaseClass extends data_type_js_1.DataType {
         let fn = field.type.generateCodec(codec, {
             ...context,
             level: context.level + 1,
+        }, {
+            convertToNative: field.convertToNative,
         });
         if (field.fixed)
             fn = valgen_1.vg.isEqual(field.fixed);

package/cjs/document/data-type/extended-types/base64.type.js

@@ -10,11 +10,14 @@ let Base64Type = class Base64Type {
         if (attributes)
             Object.assign(this, attributes);
     }
-    [constants_js_1.DECODER]() {
-        return valgen_1.vg.isBase64({ coerce: true });
+    [constants_js_1.DECODER](properties) {
+        const fn = valgen_1.vg.isBase64({ coerce: true });
+        if (properties.convertToNative)
+            return valgen_1.vg.pipe([fn, toBuffer], { coerce: true });
+        return fn;
     }
     [constants_js_1.ENCODER]() {
-        return valgen_1.vg.isBase64({ coerce: true });
+        return fromBuffer;
     }
 };
 exports.Base64Type = Base64Type;
@@ -29,3 +32,13 @@ exports.Base64Type = Base64Type = tslib_1.__decorate([
     }),
     tslib_1.__metadata("design:paramtypes", [Object])
 ], Base64Type);
+const toBuffer = (0, valgen_1.validator)((base64String) => {
+    return Buffer.from(base64String, 'base64');
+});
+const fromBuffer = (0, valgen_1.validator)((input) => {
+    if (Buffer.isBuffer(input))
+        return input.toString('base64');
+    else {
+        return (0, valgen_1.isBase64)(input);
+    }
+});

package/cjs/document/data-type/extended-types/date-time-tz.type.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateTimeTypeTz = void 0;
+const tslib_1 = require("tslib");
+const valgen_1 = require("valgen");
+const constants_js_1 = require("../../constants.js");
+const simple_type_js_1 = require("../simple-type.js");
+const _isDateString = valgen_1.vg.isDateString({
+    precisionMin: 'tz',
+    coerce: true,
+});
+let DateTimeTypeTz = class DateTimeTypeTz {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    [constants_js_1.DECODER](properties) {
+        const fn = valgen_1.vg.isDateString({
+            coerce: true,
+            precisionMin: 'tz',
+        });
+        const x = [];
+        if (properties.minValue != null) {
+            _isDateString(properties.minValue);
+            x.push(valgen_1.toString, valgen_1.vg.isGte(properties.minValue));
+        }
+        if (properties.maxValue != null) {
+            _isDateString(properties.maxValue);
+            x.push(valgen_1.toString, valgen_1.vg.isLte(properties.maxValue));
+        }
+        return x.length > 0 ? valgen_1.vg.pipe([fn, ...x], { returnIndex: 0 }) : fn;
+    }
+    [constants_js_1.ENCODER](properties) {
+        const x = [];
+        if (properties.minValue != null) {
+            (0, valgen_1.isDateString)(properties.minValue);
+            x.push(valgen_1.vg.isGte(properties.minValue));
+        }
+        if (properties.maxValue != null) {
+            (0, valgen_1.isDateString)(properties.maxValue);
+            x.push(valgen_1.vg.isLte(properties.maxValue));
+        }
+        return x.length > 0
+            ? valgen_1.vg.pipe([_isDateString, ...x], { returnIndex: 0 })
+            : _isDateString;
+    }
+};
+exports.DateTimeTypeTz = DateTimeTypeTz;
+tslib_1.__decorate([
+    simple_type_js_1.SimpleType.Attribute({
+        description: 'Minimum value',
+    }),
+    tslib_1.__metadata("design:type", String)
+], DateTimeTypeTz.prototype, "minValue", void 0);
+tslib_1.__decorate([
+    simple_type_js_1.SimpleType.Attribute({
+        description: 'Maximum value',
+    }),
+    tslib_1.__metadata("design:type", String)
+], DateTimeTypeTz.prototype, "maxValue", void 0);
+exports.DateTimeTypeTz = DateTimeTypeTz = tslib_1.__decorate([
+    ((0, simple_type_js_1.SimpleType)({
+        name: 'datetimetz',
+        description: 'A full datetime value with time zone information',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
+    }).Example('2021-04-18T22:30:15+03:00')),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], DateTimeTypeTz);

package/cjs/document/data-type/extended-types/date-time.type.js

@@ -5,30 +5,32 @@ const tslib_1 = require("tslib");
 const valgen_1 = require("valgen");
 const constants_js_1 = require("../../constants.js");
 const simple_type_js_1 = require("../simple-type.js");
+const _isDateString = valgen_1.vg.isDateString({
+    precisionMin: 'day',
+    coerce: true,
+    trim: 'tz',
+});
 let DateTimeType = class DateTimeType {
     constructor(attributes) {
         if (attributes)
             Object.assign(this, attributes);
     }
     [constants_js_1.DECODER](properties) {
-        const fn = valgen_1.vg.isDate({ precision: 'time', coerce: true });
+        const fn = valgen_1.vg.isDate({
+            coerce: properties?.convertToNative,
+        });
         const x = [];
         if (properties.minValue != null) {
-            (0, valgen_1.isDateString)(properties.minValue);
+            _isDateString(properties.minValue);
             x.push(valgen_1.toString, valgen_1.vg.isGte(properties.minValue));
         }
         if (properties.maxValue != null) {
-            (0, valgen_1.isDateString)(properties.maxValue);
+            _isDateString(properties.maxValue);
             x.push(valgen_1.toString, valgen_1.vg.isLte(properties.maxValue));
         }
         return x.length > 0 ? valgen_1.vg.pipe([fn, ...x], { returnIndex: 0 }) : fn;
     }
     [constants_js_1.ENCODER](properties) {
-        const fn = valgen_1.vg.isDateString({
-            precision: 'time',
-            trim: 'time',
-            coerce: true,
-        });
         const x = [];
         if (properties.minValue != null) {
             (0, valgen_1.isDateString)(properties.minValue);
@@ -38,7 +40,9 @@ let DateTimeType = class DateTimeType {
             (0, valgen_1.isDateString)(properties.maxValue);
             x.push(valgen_1.vg.isLte(properties.maxValue));
         }
-        return x.length > 0 ? valgen_1.vg.pipe([fn, ...x], { returnIndex: 0 }) : fn;
+        return x.length > 0
+            ? valgen_1.vg.pipe([_isDateString, ...x], { returnIndex: 0 })
+            : _isDateString;
     }
 };
 exports.DateTimeType = DateTimeType;

package/cjs/document/data-type/extended-types/date.type.js

@@ -5,30 +5,33 @@ const tslib_1 = require("tslib");
 const valgen_1 = require("valgen");
 const constants_js_1 = require("../../constants.js");
 const simple_type_js_1 = require("../simple-type.js");
+const _isDateString = valgen_1.vg.isDateString({
+    precisionMin: 'day',
+    trim: 'day',
+    coerce: true,
+});
 let DateType = class DateType {
     constructor(attributes) {
         if (attributes)
             Object.assign(this, attributes);
     }
     [constants_js_1.DECODER](properties) {
-        const fn = valgen_1.vg.isDate({ precision: 'date', coerce: true });
+        const fn = valgen_1.vg.isDate({
+            trim: 'day',
+            coerce: properties?.convertToNative,
+        });
         const x = [];
         if (properties.minValue != null) {
-            (0, valgen_1.isDateString)(properties.minValue);
+            _isDateString(properties.minValue);
             x.push(valgen_1.toString, valgen_1.vg.isGte(properties.minValue));
         }
         if (properties.maxValue != null) {
-            (0, valgen_1.isDateString)(properties.maxValue);
+            _isDateString(properties.maxValue);
             x.push(valgen_1.toString, valgen_1.vg.isLte(properties.maxValue));
         }
         return x.length > 0 ? valgen_1.vg.pipe([fn, ...x], { returnIndex: 0 }) : fn;
     }
     [constants_js_1.ENCODER](properties) {
-        const fn = valgen_1.vg.isDateString({
-            precision: 'date',
-            trim: 'date',
-            coerce: true,
-        });
         const x = [];
         if (properties.minValue != null) {
             (0, valgen_1.isDateString)(properties.minValue);
@@ -38,7 +41,9 @@ let DateType = class DateType {
             (0, valgen_1.isDateString)(properties.maxValue);
             x.push(valgen_1.vg.isLte(properties.maxValue));
         }
-        return x.length > 0 ? valgen_1.vg.pipe([fn, ...x], { returnIndex: 0 }) : fn;
+        return x.length > 0
+            ? valgen_1.vg.pipe([_isDateString, ...x], { returnIndex: 0 })
+            : _isDateString;
     }
 };
 exports.DateType = DateType;

package/cjs/document/data-type/extended-types/index.js

@@ -3,14 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./base64.type.js"), exports);
 tslib_1.__exportStar(require("./date.type.js"), exports);
-tslib_1.__exportStar(require("./date-string.type.js"), exports);
 tslib_1.__exportStar(require("./date-time.type.js"), exports);
-tslib_1.__exportStar(require("./date-time-string.type.js"), exports);
+tslib_1.__exportStar(require("./date-time-tz.type.js"), exports);
 tslib_1.__exportStar(require("./email.type.js"), exports);
 tslib_1.__exportStar(require("./field-path.type.js"), exports);
 tslib_1.__exportStar(require("./filter.type.js"), exports);
 tslib_1.__exportStar(require("./object-id.type.js"), exports);
 tslib_1.__exportStar(require("./operation-result.type.js"), exports);
+tslib_1.__exportStar(require("./partial-date.type.js"), exports);
 tslib_1.__exportStar(require("./time.type.js"), exports);
 tslib_1.__exportStar(require("./url.type.js"), exports);
 tslib_1.__exportStar(require("./uuid.type.js"), exports);

package/cjs/document/data-type/extended-types/partial-date.type.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartialDateType = void 0;
+const tslib_1 = require("tslib");
+const valgen_1 = require("valgen");
+const constants_js_1 = require("../../constants.js");
+const simple_type_js_1 = require("../simple-type.js");
+let PartialDateType = class PartialDateType {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    [constants_js_1.DECODER](properties) {
+        const fn = toPartialDate;
+        const x = [];
+        if (properties.minValue != null) {
+            (0, valgen_1.isDateString)(properties.minValue);
+            x.push(valgen_1.toString, valgen_1.vg.isGte(properties.minValue));
+        }
+        if (properties.maxValue != null) {
+            (0, valgen_1.isDateString)(properties.maxValue);
+            x.push(valgen_1.toString, valgen_1.vg.isLte(properties.maxValue));
+        }
+        return x.length > 0 ? valgen_1.vg.pipe([fn, ...x], { returnIndex: 0 }) : fn;
+    }
+    [constants_js_1.ENCODER](properties) {
+        const fn = toPartialDate;
+        const x = [];
+        if (properties.minValue != null) {
+            (0, valgen_1.isDateString)(properties.minValue);
+            x.push(valgen_1.vg.isGte(properties.minValue));
+        }
+        if (properties.maxValue != null) {
+            (0, valgen_1.isDateString)(properties.maxValue);
+            x.push(valgen_1.vg.isLte(properties.maxValue));
+        }
+        return x.length > 0 ? valgen_1.vg.pipe([fn, ...x], { returnIndex: 0 }) : fn;
+    }
+};
+exports.PartialDateType = PartialDateType;
+tslib_1.__decorate([
+    simple_type_js_1.SimpleType.Attribute({
+        description: 'Minimum value',
+    }),
+    tslib_1.__metadata("design:type", String)
+], PartialDateType.prototype, "minValue", void 0);
+tslib_1.__decorate([
+    simple_type_js_1.SimpleType.Attribute({
+        description: 'Maximum value',
+    }),
+    tslib_1.__metadata("design:type", String)
+], PartialDateType.prototype, "maxValue", void 0);
+exports.PartialDateType = PartialDateType = tslib_1.__decorate([
+    ((0, simple_type_js_1.SimpleType)({
+        name: 'partialdate',
+        description: 'Specifies a point in time using a 24-hour clock notation.\rFormat: YYYY-[MM-[DD-[T?HH:[MM:[SS[.S[S[S[S]]]]]]]]][+/-ZZ:ZZ].',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
+    })
+        .Example('2021-04-18T22:30:15:22+03:00')
+        .Example('2021-04-18 22:30')
+        .Example('2021-04-18')
+        .Example('2021')),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], PartialDateType);
+const _isDateString = valgen_1.vg.isDateString({
+    precisionMin: 'year',
+});
+const toPartialDate = (0, valgen_1.validator)((input) => {
+    if (input instanceof Date) {
+        let s = _isDateString(input, { coerce: true });
+        if (s.endsWith('Z'))
+            s = s.substring(0, s.length - 1);
+        if (s.endsWith('.000'))
+            s = s.substring(0, s.length - 4);
+        if (s.endsWith(':00'))
+            s = s.substring(0, s.length - 3);
+        if (s.endsWith('00:00'))
+            s = s.substring(0, s.length - 6);
+        return s;
+    }
+    return _isDateString(input, { coerce: false });
+});

package/cjs/document/data-type/simple-type.js

@@ -52,6 +52,10 @@ exports.SimpleType = function (...args) {
  * @class SimpleType
  */
 class SimpleTypeClass extends data_type_js_1.DataType {
+    extend(properties) {
+        Object.setPrototypeOf(properties, this);
+        return properties;
+    }
     extendsFrom(baseType) {
         if (!(baseType instanceof data_type_js_1.DataType))
             baseType = this.node.getDataType(baseType);

package/cjs/document/decorators/api-field-decorator.js

@@ -19,6 +19,7 @@ function ApiFieldDecoratorFactory(options) {
         const designType = Reflect.getMetadata('design:type', target, propertyKey);
         const elemMeta = (metadata.fields[propertyKey] = {
             ...options,
+            designType,
         });
         if (designType === Array) {
             elemMeta.isArray = true;

package/cjs/document/factory/api-document.factory.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiDocumentFactory = void 0;
+const tslib_1 = require("tslib");
 const index_js_1 = require("../../helpers/index.js");
 const index_js_2 = require("../../schema/index.js");
 const api_document_js_1 = require("../api-document.js");
 const document_init_context_js_1 = require("../common/document-init-context.js");
 const opra_document_error_js_1 = require("../common/opra-document-error.js");
 const constants_js_1 = require("../constants.js");
-const index_js_3 = require("../data-type/extended-types/index.js");
-const index_js_4 = require("../data-type/primitive-types/index.js");
+const extendedTypes = tslib_1.__importStar(require("../data-type/extended-types/index.js"));
+const primitiveTypes = tslib_1.__importStar(require("../data-type/primitive-types/index.js"));
 const data_type_factory_js_1 = require("./data-type.factory.js");
 const http_api_factory_js_1 = require("./http-api.factory.js");
 const rpc_api_factory_js_1 = require("./rpc-api.factory.js");
@@ -157,29 +158,8 @@ class ApiDocumentFactory {
                 },
             },
             types: [
-                // Primitive types
-                index_js_4.AnyType,
-                index_js_4.BigintType,
-                index_js_4.BooleanType,
-                index_js_4.IntegerType,
-                index_js_4.NullType,
-                index_js_4.NumberType,
-                index_js_4.ObjectType,
-                index_js_4.StringType,
-                // Extended types
-                index_js_3.Base64Type,
-                index_js_3.DateType,
-                index_js_3.DateStringType,
-                index_js_3.DateTimeType,
-                index_js_3.DateTimeStringType,
-                index_js_3.EmailType,
-                index_js_3.FieldPathType,
-                index_js_3.FilterType,
-                index_js_3.ObjectIdType,
-                index_js_3.OperationResult,
-                index_js_3.TimeType,
-                index_js_3.UrlType,
-                index_js_3.UuidType,
+                ...Object.values(primitiveTypes),
+                ...Object.values(extendedTypes),
             ],
         };
         const document = new api_document_js_1.ApiDocument();

package/cjs/document/factory/data-type.factory.js

@@ -150,6 +150,7 @@ class DataTypeFactory {
      * @param context
      * @param owner
      * @param thunk
+     * @param checkCircularDeps
      * @protected
      */
     static async _importDataTypeArgs(context, owner, thunk, checkCircularDeps) {

package/cjs/filter/filter-rules.js

@@ -133,7 +133,7 @@ class FilterRules {
                             });
                             this._decoderCache.set(comp.left.field, decoder);
                         }
-                        ast.value = decoder(ast.value);
+                        ast.value = decoder(ast.value, { coerce: true });
                     }
                 }
             }

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

@@ -25,11 +25,6 @@ export const ApiField = function (...args) {
         throw new Error('Field origin should be one of ComplexType, MappedType or MixinType');
     }
     _this.origin = origin;
-    _this.scopePattern = initArgs.scopePattern
-        ? Array.isArray(initArgs.scopePattern)
-            ? initArgs.scopePattern
-            : [initArgs.scopePattern]
-        : undefined;
     _this.type = initArgs.type || owner.node.getDataType('any');
     _this.description = initArgs.description;
     _this.isArray = initArgs.isArray;
@@ -45,6 +40,17 @@ export const ApiField = function (...args) {
     _this.writeonly = initArgs.writeonly;
     _this.examples = initArgs.examples;
     _this.override = initArgs.override;
+    _this.scopePattern = initArgs.scopePattern
+        ? Array.isArray(initArgs.scopePattern)
+            ? initArgs.scopePattern
+            : [initArgs.scopePattern]
+        : undefined;
+    _this.convertToNative =
+        initArgs.convertToNative ??
+            (_this.type.kind === 'SimpleType' &&
+                typeof initArgs.designType === 'function' &&
+                initArgs.designType !== Object);
+    _this.override = initArgs.override;
 };
 /**
  * The ApiFieldClass represents a descriptive metadata structure for API fields,

package/esm/document/data-type/complex-type-base.js

@@ -330,6 +330,8 @@ class ComplexTypeBaseClass extends DataType {
         let fn = field.type.generateCodec(codec, {
             ...context,
             level: context.level + 1,
+        }, {
+            convertToNative: field.convertToNative,
         });
         if (field.fixed)
             fn = vg.isEqual(field.fixed);

package/esm/document/data-type/extended-types/base64.type.js

@@ -1,5 +1,5 @@
 import { __decorate, __metadata } from "tslib";
-import { vg } from 'valgen';
+import { isBase64, validator, vg } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 import { SimpleType } from '../simple-type.js';
 let Base64Type = class Base64Type {
@@ -7,11 +7,14 @@ let Base64Type = class Base64Type {
         if (attributes)
             Object.assign(this, attributes);
     }
-    [DECODER]() {
-        return vg.isBase64({ coerce: true });
+    [DECODER](properties) {
+        const fn = vg.isBase64({ coerce: true });
+        if (properties.convertToNative)
+            return vg.pipe([fn, toBuffer], { coerce: true });
+        return fn;
     }
     [ENCODER]() {
-        return vg.isBase64({ coerce: true });
+        return fromBuffer;
     }
 };
 Base64Type = __decorate([
@@ -26,3 +29,13 @@ Base64Type = __decorate([
     __metadata("design:paramtypes", [Object])
 ], Base64Type);
 export { Base64Type };
+const toBuffer = validator((base64String) => {
+    return Buffer.from(base64String, 'base64');
+});
+const fromBuffer = validator((input) => {
+    if (Buffer.isBuffer(input))
+        return input.toString('base64');
+    else {
+        return isBase64(input);
+    }
+});

package/esm/document/data-type/extended-types/date-time-tz.type.js

@@ -0,0 +1,68 @@
+import { __decorate, __metadata } from "tslib";
+import { isDateString, toString, vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+const _isDateString = vg.isDateString({
+    precisionMin: 'tz',
+    coerce: true,
+});
+let DateTimeTypeTz = class DateTimeTypeTz {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    [DECODER](properties) {
+        const fn = vg.isDateString({
+            coerce: true,
+            precisionMin: 'tz',
+        });
+        const x = [];
+        if (properties.minValue != null) {
+            _isDateString(properties.minValue);
+            x.push(toString, vg.isGte(properties.minValue));
+        }
+        if (properties.maxValue != null) {
+            _isDateString(properties.maxValue);
+            x.push(toString, vg.isLte(properties.maxValue));
+        }
+        return x.length > 0 ? vg.pipe([fn, ...x], { returnIndex: 0 }) : fn;
+    }
+    [ENCODER](properties) {
+        const x = [];
+        if (properties.minValue != null) {
+            isDateString(properties.minValue);
+            x.push(vg.isGte(properties.minValue));
+        }
+        if (properties.maxValue != null) {
+            isDateString(properties.maxValue);
+            x.push(vg.isLte(properties.maxValue));
+        }
+        return x.length > 0
+            ? vg.pipe([_isDateString, ...x], { returnIndex: 0 })
+            : _isDateString;
+    }
+};
+__decorate([
+    SimpleType.Attribute({
+        description: 'Minimum value',
+    }),
+    __metadata("design:type", String)
+], DateTimeTypeTz.prototype, "minValue", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'Maximum value',
+    }),
+    __metadata("design:type", String)
+], DateTimeTypeTz.prototype, "maxValue", void 0);
+DateTimeTypeTz = __decorate([
+    (SimpleType({
+        name: 'datetimetz',
+        description: 'A full datetime value with time zone information',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
+    }).Example('2021-04-18T22:30:15+03:00')),
+    __metadata("design:paramtypes", [Object])
+], DateTimeTypeTz);
+export { DateTimeTypeTz };

package/esm/document/data-type/extended-types/date-time.type.js

@@ -2,30 +2,32 @@ import { __decorate, __metadata } from "tslib";
 import { isDateString, toString, vg } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 import { SimpleType } from '../simple-type.js';
+const _isDateString = vg.isDateString({
+    precisionMin: 'day',
+    coerce: true,
+    trim: 'tz',
+});
 let DateTimeType = class DateTimeType {
     constructor(attributes) {
         if (attributes)
             Object.assign(this, attributes);
     }
     [DECODER](properties) {
-        const fn = vg.isDate({ precision: 'time', coerce: true });
+        const fn = vg.isDate({
+            coerce: properties?.convertToNative,
+        });
         const x = [];
         if (properties.minValue != null) {
-            isDateString(properties.minValue);
+            _isDateString(properties.minValue);
             x.push(toString, vg.isGte(properties.minValue));
         }
         if (properties.maxValue != null) {
-            isDateString(properties.maxValue);
+            _isDateString(properties.maxValue);
             x.push(toString, vg.isLte(properties.maxValue));
         }
         return x.length > 0 ? vg.pipe([fn, ...x], { returnIndex: 0 }) : fn;
     }
     [ENCODER](properties) {
-        const fn = vg.isDateString({
-            precision: 'time',
-            trim: 'time',
-            coerce: true,
-        });
         const x = [];
         if (properties.minValue != null) {
             isDateString(properties.minValue);
@@ -35,7 +37,9 @@ let DateTimeType = class DateTimeType {
             isDateString(properties.maxValue);
             x.push(vg.isLte(properties.maxValue));
         }
-        return x.length > 0 ? vg.pipe([fn, ...x], { returnIndex: 0 }) : fn;
+        return x.length > 0
+            ? vg.pipe([_isDateString, ...x], { returnIndex: 0 })
+            : _isDateString;
     }
 };
 __decorate([