@opra/common 1.25.1 → 1.25.3

package/document/data-type/complex-type-base.d.ts

@@ -1,5 +1,5 @@
 import { type StrictOmit, type Type } from 'ts-gems';
-import { type IsObject, type Validator } from 'valgen';
+import { type Validator, vg } from 'valgen';
 import { FieldsProjection, ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import type { DocumentElement } from '../common/document-element.js';
@@ -73,7 +73,7 @@ declare abstract class ComplexTypeBaseClass extends DataType {
      *
      */
     generateCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions): Validator;
-    protected _generateSchema(codec: 'encode' | 'decode', context: GenerateCodecContext): IsObject.Schema;
+    protected _generateSchema(codec: 'encode' | 'decode', context: GenerateCodecContext): vg.isObject.Schema;
     protected _generateFieldCodec(codec: 'encode' | 'decode', field: ApiField, context: GenerateCodecContext): Validator;
 }
 type GenerateCodecContext = StrictOmit<DataType.GenerateCodecOptions, 'projection'> & {

package/document/data-type/extended-types/credit-card.type.d.ts

@@ -0,0 +1,8 @@
+import { type Validator, vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class CreditCardType {
+    constructor(attributes?: Partial<CreditCardType>);
+    provider?: vg.isCreditCard.Provider;
+    protected [DECODER](properties?: Partial<this>): Validator;
+    protected [ENCODER](properties?: Partial<this>): Validator;
+}

package/document/data-type/extended-types/credit-card.type.js

@@ -0,0 +1,35 @@
+import { __decorate, __metadata } from "tslib";
+import { vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+let CreditCardType = class CreditCardType {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    provider;
+    [DECODER](properties) {
+        return vg.isCreditCard({ coerce: true, provider: properties?.provider });
+    }
+    [ENCODER](properties) {
+        return vg.isCreditCard({ coerce: true, provider: properties?.provider });
+    }
+};
+__decorate([
+    SimpleType.Attribute({
+        description: 'Locale to use for validation',
+    }),
+    __metadata("design:type", Object)
+], CreditCardType.prototype, "provider", void 0);
+CreditCardType = __decorate([
+    SimpleType({
+        name: 'creditcard',
+        description: 'A Credit Card value',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
+    }),
+    __metadata("design:paramtypes", [Object])
+], CreditCardType);
+export { CreditCardType };

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

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

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

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

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

@@ -0,0 +1,28 @@
+import { __decorate, __metadata } from "tslib";
+import { vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+let EanType = class EanType {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    [DECODER]() {
+        return vg.isEAN({ coerce: true });
+    }
+    [ENCODER]() {
+        return vg.isEAN({ coerce: true });
+    }
+};
+EanType = __decorate([
+    SimpleType({
+        name: 'ean',
+        description: 'An EAN (European Article Number)',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
+    }),
+    __metadata("design:paramtypes", [Object])
+], EanType);
+export { EanType };

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

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

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

@@ -0,0 +1,28 @@
+import { __decorate, __metadata } from "tslib";
+import { vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+let IbanType = class IbanType {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    [DECODER]() {
+        return vg.isIBAN({ coerce: true });
+    }
+    [ENCODER]() {
+        return vg.isIBAN({ coerce: true });
+    }
+};
+IbanType = __decorate([
+    SimpleType({
+        name: 'iban',
+        description: 'An IBAN (International Bank Account Number)',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
+    }),
+    __metadata("design:paramtypes", [Object])
+], IbanType);
+export { IbanType };

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

@@ -1,10 +1,13 @@
 export * from './base64.type.js';
+export * from './credit-card.type.js';
 export * from './date.type.js';
 export * from './date-time.type.js';
 export * from './date-time-tz.type.js';
 export * from './email.type.js';
 export * from './field-path.type.js';
 export * from './filter.type.js';
+export * from './iban.type.js';
+export * from './ip.type.js';
 export * from './object-id.type.js';
 export * from './operation-result.type.js';
 export * from './time.type.js';

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

@@ -1,10 +1,13 @@
 export * from './base64.type.js';
+export * from './credit-card.type.js';
 export * from './date.type.js';
 export * from './date-time.type.js';
 export * from './date-time-tz.type.js';
 export * from './email.type.js';
 export * from './field-path.type.js';
 export * from './filter.type.js';
+export * from './iban.type.js';
+export * from './ip.type.js';
 export * from './object-id.type.js';
 export * from './operation-result.type.js';
 export * from './time.type.js';

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

@@ -0,0 +1,8 @@
+import { type Validator, vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class IpType {
+    constructor(attributes?: Partial<IpType>);
+    version?: vg.isIP.IPVersion;
+    protected [DECODER](properties?: Partial<this>): Validator;
+    protected [ENCODER](properties?: Partial<this>): Validator;
+}

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

@@ -0,0 +1,45 @@
+import { __decorate, __metadata } from "tslib";
+import { vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+let IpType = class IpType {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    version;
+    [DECODER](properties) {
+        return properties?.version
+            ? vg.isIP(properties?.version, { coerce: true })
+            : vg.oneOf([
+                vg.isIP('4', { coerce: true }),
+                vg.isIP('6', { coerce: true }),
+            ]);
+    }
+    [ENCODER](properties) {
+        return properties?.version
+            ? vg.isIP(properties?.version, { coerce: true })
+            : vg.oneOf([
+                vg.isIP('4', { coerce: true }),
+                vg.isIP('6', { coerce: true }),
+            ]);
+    }
+};
+__decorate([
+    SimpleType.Attribute({
+        description: 'IP version to use for validation',
+    }),
+    __metadata("design:type", Object)
+], IpType.prototype, "version", void 0);
+IpType = __decorate([
+    SimpleType({
+        name: 'ip',
+        description: 'An IP address',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
+    }),
+    __metadata("design:paramtypes", [Object])
+], IpType);
+export { IpType };

package/document/data-type/extended-types/mobile-phone.type.d.ts

@@ -0,0 +1,8 @@
+import { type Validator, vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class MobilePhoneType {
+    constructor(attributes?: Partial<MobilePhoneType>);
+    locale?: vg.isMobilePhone.MobilePhoneLocale;
+    protected [DECODER](properties?: Partial<this>): Validator;
+    protected [ENCODER](properties?: Partial<this>): Validator;
+}

package/document/data-type/extended-types/mobile-phone.type.js

@@ -0,0 +1,41 @@
+import { __decorate, __metadata } from "tslib";
+import { vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+let MobilePhoneType = class MobilePhoneType {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    locale;
+    [DECODER](properties) {
+        return vg.isMobilePhone({
+            coerce: true,
+            locale: properties?.locale || 'tr-TR',
+        });
+    }
+    [ENCODER](properties) {
+        return vg.isMobilePhone({
+            coerce: true,
+            locale: properties?.locale || 'tr-TR',
+        });
+    }
+};
+__decorate([
+    SimpleType.Attribute({
+        description: 'Locale to use for validation',
+    }),
+    __metadata("design:type", String)
+], MobilePhoneType.prototype, "locale", void 0);
+MobilePhoneType = __decorate([
+    SimpleType({
+        name: 'mobilephone',
+        description: 'A Mobile Phone Number value',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
+    }),
+    __metadata("design:paramtypes", [Object])
+], MobilePhoneType);
+export { MobilePhoneType };

package/document/data-type/extended-types/passport-number.type.d.ts

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

package/document/data-type/extended-types/passport-number.type.js

@@ -0,0 +1,39 @@
+import { __decorate, __metadata } from "tslib";
+import { vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+let PassportNumberType = class PassportNumberType {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    countryCode;
+    [DECODER](properties) {
+        return vg.isPassportNumber(properties?.countryCode || 'TR', {
+            coerce: true,
+        });
+    }
+    [ENCODER](properties) {
+        return vg.isPassportNumber(properties?.countryCode || 'TR', {
+            coerce: true,
+        });
+    }
+};
+__decorate([
+    SimpleType.Attribute({
+        description: 'Country code',
+    }),
+    __metadata("design:type", String)
+], PassportNumberType.prototype, "countryCode", void 0);
+PassportNumberType = __decorate([
+    SimpleType({
+        name: 'passportnumber',
+        description: 'A Passport Number',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
+    }),
+    __metadata("design:paramtypes", [Object])
+], PassportNumberType);
+export { PassportNumberType };

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

@@ -1,8 +1,8 @@
-import { type Validator } from 'valgen';
+import { type Validator, vg } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 export declare class UuidType {
     constructor(attributes?: Partial<UuidType>);
-    version?: 1 | 2 | 3 | 4 | 5;
+    version?: vg.isUUID.UUIDVersion;
     protected [DECODER](properties?: Partial<this>): Validator;
     protected [ENCODER](properties?: Partial<this>): Validator;
 }

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

@@ -19,7 +19,7 @@ __decorate([
     SimpleType.Attribute({
         description: 'Version of the UUID',
     }),
-    __metadata("design:type", Number)
+    __metadata("design:type", Object)
 ], UuidType.prototype, "version", void 0);
 UuidType = __decorate([
     SimpleType({

package/document/data-type/extended-types/vat-number.type.d.ts

@@ -0,0 +1,8 @@
+import { type Validator, vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class VatNumberType {
+    constructor(attributes?: Partial<VatNumberType>);
+    countryCode?: vg.isVATNumber.CountryCode;
+    protected [DECODER](properties?: Partial<this>): Validator;
+    protected [ENCODER](properties?: Partial<this>): Validator;
+}

package/document/data-type/extended-types/vat-number.type.js

@@ -0,0 +1,39 @@
+import { __decorate, __metadata } from "tslib";
+import { vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+let VatNumberType = class VatNumberType {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    countryCode;
+    [DECODER](properties) {
+        return vg.isVATNumber(properties?.countryCode || 'TR', {
+            coerce: true,
+        });
+    }
+    [ENCODER](properties) {
+        return vg.isVATNumber(properties?.countryCode || 'TR', {
+            coerce: true,
+        });
+    }
+};
+__decorate([
+    SimpleType.Attribute({
+        description: 'Country code',
+    }),
+    __metadata("design:type", String)
+], VatNumberType.prototype, "countryCode", void 0);
+VatNumberType = __decorate([
+    SimpleType({
+        name: 'vatnumber',
+        description: 'A VAT Number',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
+    }),
+    __metadata("design:paramtypes", [Object])
+], VatNumberType);
+export { VatNumberType };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/common",
-  "version": "1.25.1",
+  "version": "1.25.3",
   "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.19.5"
+    "valgen": "^6.0.3"
   },
   "type": "module",
   "module": "./index.js",