@opra/common 1.22.5 → 1.22.6

package/document/common/data-type-map.js

@@ -32,8 +32,11 @@ export class DataTypeMap {
         const out = this[kMap].get(name);
         if (!out)
             return;
-        if (typeof nameOrCtor === 'function' && out.kind === 'ComplexType')
-            return out.ctor === nameOrCtor ? out : undefined;
+        if (typeof nameOrCtor === 'function' &&
+            out.kind === 'ComplexType' &&
+            out.ctor !== nameOrCtor) {
+            throw new TypeError(`An other data type with same class (${nameOrCtor.name}) already exists.`);
+        }
         return out;
     }
     set(name, dataType) {

package/document/data-type/extended-types/date-time.type.d.ts

@@ -1,9 +1,11 @@
 import { Type } from 'ts-gems';
-import { type Validator } from 'valgen';
+import { type DatePrecision, type Validator } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 export declare class DateTimeType {
     designType?: Type;
     constructor(attributes?: Partial<DateTimeType>);
+    precisionMin?: DatePrecision;
+    precisionMax?: DatePrecision;
     protected [DECODER](properties: Partial<this>): Validator;
     protected [ENCODER](properties: Partial<this>): Validator;
     minValue?: string;

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

@@ -2,27 +2,26 @@ import { __decorate, __metadata } from "tslib";
 import { vg } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 import { SimpleType } from '../simple-type.js';
-const _isDateString = vg.isDateString({
-    precisionMin: 'day',
-    trim: 'tz',
-    coerce: true,
-});
-const _isDate = vg.isDate({
-    coerce: true,
-});
 let DateTimeType = class DateTimeType {
     designType;
     constructor(attributes) {
         if (attributes)
             Object.assign(this, attributes);
     }
+    precisionMin;
+    precisionMax;
     [DECODER](properties) {
         let fn;
         if (properties.designType === Date) {
-            fn = _isDate;
+            fn = vg.isDate({ coerce: true });
         }
         else {
-            fn = _isDateString;
+            fn = vg.isDateString({
+                precisionMin: properties.precisionMin || 'day',
+                precisionMax: properties.precisionMax || 'ms',
+                trim: true,
+                coerce: true,
+            });
         }
         const x = [fn];
         if (properties.minValue != null) {
@@ -34,7 +33,12 @@ let DateTimeType = class DateTimeType {
         return x.length > 0 ? vg.pipe(x, { returnIndex: 0 }) : fn;
     }
     [ENCODER](properties) {
-        const fn = _isDateString;
+        const fn = vg.isDateString({
+            precisionMin: properties.precisionMin || 'day',
+            precisionMax: properties.precisionMax || 'ms',
+            trim: true,
+            coerce: true,
+        });
         const x = [fn];
         if (properties.minValue != null) {
             x.push(vg.isGte(fn(properties.minValue)));
@@ -47,6 +51,18 @@ let DateTimeType = class DateTimeType {
     minValue;
     maxValue;
 };
+__decorate([
+    SimpleType.Attribute({
+        description: 'Determines the minimum precision, e.g. "year", "month", "hours", "minutes", "seconds" etc. Defaults to "day".',
+    }),
+    __metadata("design:type", String)
+], DateTimeType.prototype, "precisionMin", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'Determines the minimum precision, e.g. "year", "month", "hours", "minutes", "seconds" etc. Defaults to "ms".',
+    }),
+    __metadata("design:type", String)
+], DateTimeType.prototype, "precisionMax", void 0);
 __decorate([
     SimpleType.Attribute({
         description: 'Minimum value',
@@ -60,17 +76,14 @@ __decorate([
     __metadata("design:type", String)
 ], DateTimeType.prototype, "maxValue", void 0);
 DateTimeType = __decorate([
-    (SimpleType({
+    SimpleType({
         name: 'datetime',
         description: 'A full datetime value',
         nameMappings: {
             js: 'string',
             json: 'string',
         },
-    })
-        .Example('2021-04-18T22:30:15')
-        .Example('2021-04-18 22:30:15')
-        .Example('2021-04-18 22:30')),
+    }),
     __metadata("design:paramtypes", [Object])
 ], DateTimeType);
 export { DateTimeType };

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

@@ -4,7 +4,8 @@ import { DECODER, ENCODER } from '../../constants.js';
 import { SimpleType } from '../simple-type.js';
 const _isDateString = vg.isDateString({
     precisionMin: 'day',
-    trim: 'day',
+    precisionMax: 'day',
+    trim: true,
     coerce: true,
 });
 const _isDate = vg.isDate({

package/document/data-type/extended-types/index.d.ts

@@ -7,7 +7,6 @@ export * from './field-path.type.js';
 export * from './filter.type.js';
 export * from './object-id.type.js';
 export * from './operation-result.type.js';
-export * from './partial-date.type.js';
 export * from './time.type.js';
 export * from './url.type.js';
 export * from './uuid.type.js';

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

@@ -7,7 +7,6 @@ export * from './field-path.type.js';
 export * from './filter.type.js';
 export * from './object-id.type.js';
 export * from './operation-result.type.js';
-export * from './partial-date.type.js';
 export * from './time.type.js';
 export * from './url.type.js';
 export * from './uuid.type.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/common",
-  "version": "1.22.5",
+  "version": "1.22.6",
   "description": "Opra common package",
   "author": "Panates",
   "license": "MIT",
@@ -19,7 +19,7 @@
     "super-fast-md5": "^1.0.3",
     "tslib": "^2.8.1",
     "uid": "^2.0.2",
-    "valgen": "^5.18.2"
+    "valgen": "^5.19.3"
   },
   "type": "module",
   "module": "./index.js",

package/document/data-type/extended-types/partial-date.type.d.ts

@@ -1,9 +0,0 @@
-import { type Validator } from 'valgen';
-import { DECODER, ENCODER } from '../../constants.js';
-export declare class PartialDateType {
-    constructor(attributes?: Partial<PartialDateType>);
-    protected [DECODER](properties: Partial<this>): Validator;
-    protected [ENCODER](properties: Partial<this>): Validator;
-    minValue?: string;
-    maxValue?: string;
-}

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

@@ -1,84 +0,0 @@
-import { __decorate, __metadata } from "tslib";
-import { isDateString, toString, validator, vg } from 'valgen';
-import { DECODER, ENCODER } from '../../constants.js';
-import { SimpleType } from '../simple-type.js';
-let PartialDateType = class PartialDateType {
-    constructor(attributes) {
-        if (attributes)
-            Object.assign(this, attributes);
-    }
-    [DECODER](properties) {
-        const fn = toPartialDate;
-        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 fn = toPartialDate;
-        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([fn, ...x], { returnIndex: 0 }) : fn;
-    }
-    minValue;
-    maxValue;
-};
-__decorate([
-    SimpleType.Attribute({
-        description: 'Minimum value',
-    }),
-    __metadata("design:type", String)
-], PartialDateType.prototype, "minValue", void 0);
-__decorate([
-    SimpleType.Attribute({
-        description: 'Maximum value',
-    }),
-    __metadata("design:type", String)
-], PartialDateType.prototype, "maxValue", void 0);
-PartialDateType = __decorate([
-    (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')),
-    __metadata("design:paramtypes", [Object])
-], PartialDateType);
-export { PartialDateType };
-const _isDateString = vg.isDateString({
-    precisionMin: 'year',
-});
-const toPartialDate = 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 });
-});