@finnair/v-validation-luxon 3.0.0-alpha.2 → 3.0.0

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.0.0](https://github.com/finnair/v-validation/compare/v2.0.0...v3.0.0) (2022-10-03)
+
+**Note:** Version bump only for package @finnair/v-validation-luxon
+
+
+
+
+
 # [3.0.0-alpha.2](https://github.com/finnair/v-validation/compare/v2.0.0...v3.0.0-alpha.2) (2022-09-28)
 
 

package/dist/Vluxon.d.ts

@@ -4,25 +4,26 @@ import { DateTime, DateTimeJSOptions, DateTimeOptions } from 'luxon';
 import { LuxonDateTime } from './luxon';
 export declare type LuxonInput = string | DateTime | LuxonDateTime;
 export interface ValidateLuxonParams {
-    value: any;
-    path: Path;
-    ctx: ValidationContext;
     type: string;
     pattern: RegExp;
     proto?: any;
     parser: (value: string, match: RegExpExecArray) => DateTime;
 }
-export declare function validateLuxon({ value, path, ctx, type, proto, pattern, parser }: ValidateLuxonParams): PromiseLike<ValidationResult>;
-declare function localDate(options?: DateTimeOptions): import("@finnair/v-validation").ValidatorFnWrapper;
-declare function localTime(options?: DateTimeOptions): import("@finnair/v-validation").ValidatorFnWrapper;
-declare function dateTime(options?: DateTimeOptions): import("@finnair/v-validation").ValidatorFnWrapper;
-declare function dateTimeUtc(options?: DateTimeOptions): import("@finnair/v-validation").ValidatorFnWrapper;
-declare function dateTimeMillis(options?: DateTimeOptions): import("@finnair/v-validation").ValidatorFnWrapper;
-declare function dateTimeMillisUtc(options?: DateTimeOptions): import("@finnair/v-validation").ValidatorFnWrapper;
-declare function dateTimeFromISO(options?: DateTimeOptions): import("@finnair/v-validation").ValidatorFnWrapper;
-declare function dateTimeFromRFC2822(options?: DateTimeOptions): import("@finnair/v-validation").ValidatorFnWrapper;
-declare function dateTimeFromHTTP(options?: DateTimeOptions): import("@finnair/v-validation").ValidatorFnWrapper;
-declare function dateTimeFromSQL(options?: DateTimeOptions): import("@finnair/v-validation").ValidatorFnWrapper;
+export declare class LuxonValidator extends Validator {
+    params: ValidateLuxonParams;
+    constructor(params: ValidateLuxonParams);
+    validatePath(value: any, path: Path, ctx: ValidationContext): PromiseLike<ValidationResult>;
+}
+declare function localDate(options?: DateTimeOptions): LuxonValidator;
+declare function localTime(options?: DateTimeOptions): LuxonValidator;
+declare function dateTime(options?: DateTimeOptions): LuxonValidator;
+declare function dateTimeUtc(options?: DateTimeOptions): LuxonValidator;
+declare function dateTimeMillis(options?: DateTimeOptions): LuxonValidator;
+declare function dateTimeMillisUtc(options?: DateTimeOptions): LuxonValidator;
+declare function dateTimeFromISO(options?: DateTimeOptions): LuxonValidator;
+declare function dateTimeFromRFC2822(options?: DateTimeOptions): LuxonValidator;
+declare function dateTimeFromHTTP(options?: DateTimeOptions): LuxonValidator;
+declare function dateTimeFromSQL(options?: DateTimeOptions): LuxonValidator;
 export interface ValidateLuxonNumberParams {
     value: any;
     path: Path;

package/dist/Vluxon.js

@@ -9,146 +9,125 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Vluxon = exports.DurationValidator = exports.validateLuxonNumber = exports.validateLuxon = void 0;
+exports.Vluxon = exports.DurationValidator = exports.validateLuxonNumber = exports.LuxonValidator = void 0;
 const v_validation_1 = require("@finnair/v-validation");
 const luxon_1 = require("luxon");
 const luxon_2 = require("./luxon");
-function validateLuxon({ value, path, ctx, type, proto, pattern, parser }) {
-    if ((0, v_validation_1.isNullOrUndefined)(value)) {
-        return ctx.failurePromise(v_validation_1.defaultViolations.notNull(path), value);
+class LuxonValidator extends v_validation_1.Validator {
+    constructor(params) {
+        super();
+        this.params = params;
+        Object.freeze(params);
+        Object.freeze(this);
     }
-    if (proto && value instanceof proto) {
-        return ctx.successPromise(value);
-    }
-    else if (luxon_1.DateTime.isDateTime(value)) {
-        if (value.isValid) {
-            return success(value);
+    validatePath(value, path, ctx) {
+        const params = this.params;
+        if ((0, v_validation_1.isNullOrUndefined)(value)) {
+            return ctx.failurePromise(v_validation_1.defaultViolations.notNull(path), value);
         }
-    }
-    else if ((0, v_validation_1.isString)(value)) {
-        const match = pattern.exec(value);
-        if (match) {
-            const dateTime = parser(value, match);
-            if (dateTime.isValid) {
-                return success(dateTime);
+        if (params.proto && value instanceof params.proto) {
+            return ctx.successPromise(value);
+        }
+        else if (luxon_1.DateTime.isDateTime(value)) {
+            if (value.isValid) {
+                return success(value);
             }
         }
-    }
-    return ctx.failurePromise(v_validation_1.defaultViolations.date(value, path, type), value);
-    function success(dateTime) {
-        return ctx.successPromise(proto ? new proto(dateTime) : dateTime);
+        else if ((0, v_validation_1.isString)(value)) {
+            const match = params.pattern.exec(value);
+            if (match) {
+                const dateTime = params.parser(value, match);
+                if (dateTime.isValid) {
+                    return success(dateTime);
+                }
+            }
+        }
+        return ctx.failurePromise(v_validation_1.defaultViolations.date(value, path, params.type), value);
+        function success(dateTime) {
+            return ctx.successPromise(params.proto ? new params.proto(dateTime) : dateTime);
+        }
     }
 }
-exports.validateLuxon = validateLuxon;
+exports.LuxonValidator = LuxonValidator;
 const datePattern = /^\d{4}-\d{2}-\d{2}$/;
 function localDate(options = { setZone: true }) {
-    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
-        value,
-        path,
-        ctx,
+    return new LuxonValidator({
         type: 'Date',
         proto: luxon_2.LocalDateLuxon,
         pattern: datePattern,
         parser: (value) => luxon_1.DateTime.fromISO(value, { zone: luxon_1.FixedOffsetZone.utcInstance }),
-    }));
+    });
 }
 const timePattern = /^\d{2}:\d{2}:\d{2}$/;
 function localTime(options = { zone: luxon_1.FixedOffsetZone.utcInstance }) {
-    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
-        value,
-        path,
-        ctx,
+    return new LuxonValidator({
         type: 'Time',
         proto: luxon_2.LocalTimeLuxon,
         pattern: timePattern,
         parser: (value) => luxon_1.DateTime.fromISO(value, options),
-    }));
+    });
 }
 const dateTimePattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:Z|[+-]\d{2}(?::?\d{2})?)$/;
 function dateTime(options = { setZone: true }) {
-    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
-        value,
-        path,
-        ctx,
+    return new LuxonValidator({
         type: 'DateTime',
         proto: luxon_2.DateTimeLuxon,
         pattern: dateTimePattern,
         parser: (value) => luxon_1.DateTime.fromISO(value, options),
-    }));
+    });
 }
 function dateTimeUtc(options = { zone: luxon_1.FixedOffsetZone.utcInstance }) {
-    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
-        value,
-        path,
-        ctx,
+    return new LuxonValidator({
         type: 'DateTime',
         proto: luxon_2.DateTimeUtcLuxon,
         pattern: dateTimePattern,
         parser: (value) => luxon_1.DateTime.fromISO(value, options),
-    }));
+    });
 }
 const dateTimeMillisPattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}(?:Z|[+-]\d{2}(?::?\d{2})?)$/;
 function dateTimeMillis(options = { setZone: true }) {
-    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
-        value,
-        path,
-        ctx,
+    return new LuxonValidator({
         type: 'DateTimeMillis',
         proto: luxon_2.DateTimeMillisLuxon,
         pattern: dateTimeMillisPattern,
         parser: (value) => luxon_1.DateTime.fromISO(value, options),
-    }));
+    });
 }
 function dateTimeMillisUtc(options = { zone: luxon_1.FixedOffsetZone.utcInstance }) {
-    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
-        value,
-        path,
-        ctx,
+    return new LuxonValidator({
         type: 'DateTimeMillis',
         proto: luxon_2.DateTimeMillisUtcLuxon,
         pattern: dateTimeMillisPattern,
         parser: (value) => luxon_1.DateTime.fromISO(value, options),
-    }));
+    });
 }
 function dateTimeFromISO(options = { setZone: true }) {
-    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
-        value,
-        path,
-        ctx,
+    return new LuxonValidator({
         type: 'ISODateTime',
         pattern: /./,
         parser: (value) => luxon_1.DateTime.fromISO(value, options),
-    }));
+    });
 }
 function dateTimeFromRFC2822(options = { setZone: true }) {
-    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
-        value,
-        path,
-        ctx,
+    return new LuxonValidator({
         type: 'RFC2822DateTime',
         pattern: /./,
         parser: (value) => luxon_1.DateTime.fromRFC2822(value, options),
-    }));
+    });
 }
 function dateTimeFromHTTP(options = { setZone: true }) {
-    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
-        value,
-        path,
-        ctx,
+    return new LuxonValidator({
         type: 'HTTPDateTime',
         pattern: /./,
         parser: (value) => luxon_1.DateTime.fromHTTP(value, options),
-    }));
+    });
 }
 function dateTimeFromSQL(options = { zone: luxon_1.FixedOffsetZone.utcInstance }) {
-    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
-        value,
-        path,
-        ctx,
+    return new LuxonValidator({
         type: 'SQLDateTime',
         pattern: /./,
         parser: (value) => luxon_1.DateTime.fromSQL(value, options),
-    }));
+    });
 }
 function validateLuxonNumber({ value, path, ctx, type, parser }) {
     return __awaiter(this, void 0, void 0, function* () {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@finnair/v-validation-luxon",
-  "version": "3.0.0-alpha.2",
+  "version": "3.0.0",
   "private": false,
   "description": "Luxon validators",
   "main": "dist/index.js",
@@ -25,12 +25,11 @@
     "build": "tsc -b ."
   },
   "dependencies": {
-    "@finnair/path": "^3.0.0-alpha.2",
-    "@finnair/v-validation": "^3.0.0-alpha.2",
-    "luxon": "3.0.3"
+    "@finnair/path": "^3.0.0",
+    "@finnair/v-validation": "^3.0.0"
   },
-  "devDependencies": {
-    "@types/luxon": "3.0.1"
+  "peerDependencies": {
+    "luxon": "^3.0.0"
   },
-  "gitHead": "d42bd7583bb684429e48ce8e5db3938cb95ffd5f"
+  "gitHead": "597b85f1fcef99722bccf47c6d30260973d6d88c"
 }