@finnair/v-validation-luxon 1.1.0-alpha.6 → 1.1.0-alpha.9

package/CHANGELOG.md

@@ -3,6 +3,30 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.1.0-alpha.9](https://github.com/finnair/v-validation/compare/v1.1.0-alpha.8...v1.1.0-alpha.9) (2022-08-19)
+
+**Note:** Version bump only for package @finnair/v-validation-luxon
+
+
+
+
+
+# [1.1.0-alpha.8](https://github.com/finnair/v-validation/compare/v1.1.0-alpha.7...v1.1.0-alpha.8) (2022-08-19)
+
+**Note:** Version bump only for package @finnair/v-validation-luxon
+
+
+
+
+
+# [1.1.0-alpha.7](https://github.com/finnair/v-validation/compare/v1.1.0-alpha.6...v1.1.0-alpha.7) (2022-08-18)
+
+**Note:** Version bump only for package @finnair/v-validation-luxon
+
+
+
+
+
 # [1.1.0-alpha.6](https://github.com/finnair/v-validation/compare/v1.0.1...v1.1.0-alpha.6) (2022-08-17)
 
 

package/dist/Vluxon.d.ts

@@ -1,6 +1,6 @@
 import { ValidationContext, Validator, ValidationResult } from '@finnair/v-validation';
 import { Path } from '@finnair/path';
-import { DateTime, DateTimeOptions } from 'luxon';
+import { DateTime } from 'luxon';
 import { LuxonDateTime } from './luxon';
 export declare type LuxonInput = string | DateTime | LuxonDateTime;
 export interface ValidateLuxonParams {
@@ -10,9 +10,9 @@ export interface ValidateLuxonParams {
     type: string;
     proto: any;
     pattern: RegExp;
-    options: DateTimeOptions;
+    parser: (value: string, match: RegExpExecArray) => DateTime;
 }
-export declare function validateLuxon({ value, path, ctx, type, proto, pattern, options }: ValidateLuxonParams): ValidationResult;
+export declare function validateLuxon({ value, path, ctx, type, proto, pattern, parser }: ValidateLuxonParams): Promise<ValidationResult>;
 export declare class DurationValidator extends Validator {
     validatePath(value: any, path: Path, ctx: ValidationContext): Promise<ValidationResult>;
 }

package/dist/Vluxon.js

@@ -13,109 +13,100 @@ exports.Vluxon = exports.DurationValidator = exports.validateLuxon = 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, options }) {
-    if ((0, v_validation_1.isNullOrUndefined)(value)) {
-        return ctx.failure(v_validation_1.defaultViolations.notNull(path), value);
-    }
-    if (value instanceof proto) {
-        return ctx.success(value);
-    }
-    else if (luxon_1.DateTime.isDateTime(value)) {
-        if (value.isValid) {
-            return ctx.success(new proto(value));
+function validateLuxon({ value, path, ctx, type, proto, pattern, parser }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if ((0, v_validation_1.isNullOrUndefined)(value)) {
+            return ctx.failure(v_validation_1.defaultViolations.notNull(path), value);
         }
-    }
-    else if ((0, v_validation_1.isString)(value)) {
-        if (pattern.test(value)) {
-            const dateTime = luxon_1.DateTime.fromISO(value, options);
-            if (dateTime.isValid) {
-                return ctx.success(new proto(dateTime));
+        if (value instanceof proto) {
+            return ctx.success(value);
+        }
+        else if (luxon_1.DateTime.isDateTime(value)) {
+            if (value.isValid) {
+                return ctx.success(new proto(value));
             }
         }
-    }
-    return ctx.failure(v_validation_1.defaultViolations.date(value, path, type), 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 ctx.success(new proto(dateTime));
+                }
+            }
+        }
+        return ctx.failure(v_validation_1.defaultViolations.date(value, path, type), value);
+    });
 }
 exports.validateLuxon = validateLuxon;
 const datePattern = /^\d{4}-\d{2}-\d{2}$/;
 function localDateValidator(value, path, ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return validateLuxon({
-            value,
-            path,
-            ctx,
-            type: 'Date',
-            proto: luxon_2.LocalDateLuxon,
-            pattern: datePattern,
-            options: { zone: luxon_1.FixedOffsetZone.utcInstance },
-        });
+    return validateLuxon({
+        value,
+        path,
+        ctx,
+        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 localTimeValidator(value, path, ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return validateLuxon({
-            value,
-            path,
-            ctx,
-            type: 'Time',
-            proto: luxon_2.LocalTimeLuxon,
-            pattern: timePattern,
-            options: { zone: luxon_1.FixedOffsetZone.utcInstance },
-        });
+    return validateLuxon({
+        value,
+        path,
+        ctx,
+        type: 'Time',
+        proto: luxon_2.LocalTimeLuxon,
+        pattern: timePattern,
+        parser: (value) => luxon_1.DateTime.fromISO(value, { zone: luxon_1.FixedOffsetZone.utcInstance }),
     });
 }
 const dateTimePattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:Z|[+-]\d{2}(?::?\d{2})?)$/;
 function dateTimeValidator(value, path, ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return validateLuxon({
-            value,
-            path,
-            ctx,
-            type: 'DateTime',
-            proto: luxon_2.DateTimeLuxon,
-            pattern: dateTimePattern,
-            options: { setZone: true },
-        });
+    return validateLuxon({
+        value,
+        path,
+        ctx,
+        type: 'DateTime',
+        proto: luxon_2.DateTimeLuxon,
+        pattern: dateTimePattern,
+        parser: (value) => luxon_1.DateTime.fromISO(value, { setZone: true }),
     });
 }
 function dateTimeUtcValidator(value, path, ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return validateLuxon({
-            value,
-            path,
-            ctx,
-            type: 'DateTime',
-            proto: luxon_2.DateTimeUtcLuxon,
-            pattern: dateTimePattern,
-            options: { zone: luxon_1.FixedOffsetZone.utcInstance },
-        });
+    return validateLuxon({
+        value,
+        path,
+        ctx,
+        type: 'DateTime',
+        proto: luxon_2.DateTimeUtcLuxon,
+        pattern: dateTimePattern,
+        parser: (value) => luxon_1.DateTime.fromISO(value, { zone: luxon_1.FixedOffsetZone.utcInstance }),
     });
 }
 const dateTimeMillisPattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}(?:Z|[+-]\d{2}(?::?\d{2})?)$/;
 function dateTimeMillisValidator(value, path, ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return validateLuxon({
-            value,
-            path,
-            ctx,
-            type: 'DateTimeMillis',
-            proto: luxon_2.DateTimeMillisLuxon,
-            pattern: dateTimeMillisPattern,
-            options: { setZone: true },
-        });
+    return validateLuxon({
+        value,
+        path,
+        ctx,
+        type: 'DateTimeMillis',
+        proto: luxon_2.DateTimeMillisLuxon,
+        pattern: dateTimeMillisPattern,
+        parser: (value) => luxon_1.DateTime.fromISO(value, { setZone: true }),
     });
 }
 function dateTimeMillisUtcValidator(value, path, ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return validateLuxon({
-            value,
-            path,
-            ctx,
-            type: 'DateTimeMillis',
-            proto: luxon_2.DateTimeMillisUtcLuxon,
-            pattern: dateTimeMillisPattern,
-            options: { zone: luxon_1.FixedOffsetZone.utcInstance },
-        });
+    return validateLuxon({
+        value,
+        path,
+        ctx,
+        type: 'DateTimeMillis',
+        proto: luxon_2.DateTimeMillisUtcLuxon,
+        pattern: dateTimeMillisPattern,
+        parser: (value) => luxon_1.DateTime.fromISO(value, { zone: luxon_1.FixedOffsetZone.utcInstance }),
     });
 }
 const durationPattern = /^P(?!$)(\d+(?:\.\d+)?Y)?(\d+(?:\.\d+)?M)?(\d+(?:\.\d+)?W)?(\d+(?:\.\d+)?D)?(T(?=\d)(\d+(?:\.\d+)?H)?(\d+(?:\.\d+)?M)?(\d+(?:\.\d+)?S)?)?$/;

package/dist/luxon.d.ts

@@ -1,4 +1,4 @@
-import { DateTime, DateTimeJSOptions, DateTimeOptions } from 'luxon';
+import { DateTime, DateTimeJSOptions, DateTimeOptions, Zone } from 'luxon';
 export declare type LuxonDateTimeInput = DateTime | LuxonDateTime;
 export declare abstract class LuxonDateTime {
     readonly dateTime: DateTime;
@@ -19,8 +19,11 @@ export declare class LocalDateLuxon extends LuxonDateTime {
     static nowLocal(options?: DateTimeJSOptions): LocalDateLuxon;
     static nowUtc(): LocalDateLuxon;
     static fromISO(value: string, options?: DateTimeOptions): LocalDateLuxon;
-    static fromJSDate(date: Date, options?: DateTimeOptions): LocalDateLuxon;
-    static fromMillis(millis: number, options?: DateTimeOptions): LocalDateLuxon;
+    static fromFormat(value: string, format: string, options?: DateTimeOptions): LocalDateLuxon;
+    static fromJSDate(date: Date, options?: {
+        zone?: string | Zone;
+    }): LocalDateLuxon;
+    static fromMillis(millis: number, options?: DateTimeJSOptions): LocalDateLuxon;
     protected normalize(dateTime: DateTime): DateTime;
     wrap(fn: (dateTime: DateTime) => DateTime): LocalDateLuxon;
     toJSON(): string;
@@ -31,8 +34,11 @@ export declare class LocalTimeLuxon extends LuxonDateTime {
     static nowLocal(options?: DateTimeJSOptions): LocalTimeLuxon;
     static nowUtc(): LocalTimeLuxon;
     static fromISO(value: string, options?: DateTimeOptions): LocalTimeLuxon;
-    static fromJSDate(date: Date, options?: DateTimeOptions): LocalTimeLuxon;
-    static fromMillis(millis: number, options?: DateTimeOptions): LocalTimeLuxon;
+    static fromFormat(value: string, format: string, options?: DateTimeOptions): LocalTimeLuxon;
+    static fromJSDate(date: Date, options?: {
+        zone?: string | Zone;
+    }): LocalTimeLuxon;
+    static fromMillis(millis: number, options?: DateTimeJSOptions): LocalTimeLuxon;
     protected normalize(dateTime: DateTime): DateTime;
     wrap(fn: (dateTime: DateTime) => DateTime): LocalTimeLuxon;
     toJSON(): string;
@@ -43,8 +49,11 @@ export declare class DateTimeLuxon extends LuxonDateTime {
     constructor(input: LuxonDateTimeInput);
     static now(options?: DateTimeJSOptions): DateTimeLuxon;
     static fromISO(value: string, options?: DateTimeOptions): DateTimeLuxon;
-    static fromJSDate(date: Date, options?: DateTimeOptions): DateTimeLuxon;
-    static fromMillis(millis: number, options?: DateTimeOptions): DateTimeLuxon;
+    static fromFormat(value: string, format: string, options?: DateTimeOptions): DateTimeLuxon;
+    static fromJSDate(date: Date, options?: {
+        zone?: string | Zone;
+    }): DateTimeLuxon;
+    static fromMillis(millis: number, options?: DateTimeJSOptions): DateTimeLuxon;
     protected normalize(dateTime: DateTime): DateTime;
     wrap(fn: (dateTime: DateTime) => DateTime): DateTimeLuxon;
     toJSON(): string;
@@ -53,8 +62,11 @@ export declare class DateTimeUtcLuxon extends LuxonDateTime {
     constructor(input: LuxonDateTimeInput);
     static now(): DateTimeUtcLuxon;
     static fromISO(value: string, options?: DateTimeOptions): DateTimeUtcLuxon;
-    static fromJSDate(date: Date, options?: DateTimeOptions): DateTimeUtcLuxon;
-    static fromMillis(millis: number, options?: DateTimeOptions): DateTimeUtcLuxon;
+    static fromFormat(value: string, format: string, options?: DateTimeOptions): DateTimeUtcLuxon;
+    static fromJSDate(date: Date, options?: {
+        zone?: string | Zone;
+    }): DateTimeUtcLuxon;
+    static fromMillis(millis: number, options?: DateTimeJSOptions): DateTimeUtcLuxon;
     protected normalize(dateTime: DateTime): DateTime;
     wrap(fn: (dateTime: DateTime) => DateTime): DateTimeUtcLuxon;
     toJSON(): string;
@@ -65,8 +77,11 @@ export declare class DateTimeMillisLuxon extends LuxonDateTime {
     constructor(input: LuxonDateTimeInput);
     static now(options?: DateTimeJSOptions): DateTimeMillisLuxon;
     static fromISO(value: string, options?: DateTimeOptions): DateTimeMillisLuxon;
-    static fromJSDate(date: Date, options?: DateTimeOptions): DateTimeMillisLuxon;
-    static fromMillis(millis: number, options?: DateTimeOptions): DateTimeMillisLuxon;
+    static fromFormat(value: string, format: string, options?: DateTimeOptions): DateTimeMillisLuxon;
+    static fromJSDate(date: Date, options?: {
+        zone?: string | Zone;
+    }): DateTimeMillisLuxon;
+    static fromMillis(millis: number, options?: DateTimeJSOptions): DateTimeMillisLuxon;
     protected normalize(dateTime: DateTime): DateTime;
     wrap(fn: (dateTime: DateTime) => DateTime): DateTimeMillisLuxon;
     toJSON(): string;
@@ -75,8 +90,11 @@ export declare class DateTimeMillisUtcLuxon extends LuxonDateTime {
     constructor(input: LuxonDateTimeInput);
     static now(): DateTimeMillisUtcLuxon;
     static fromISO(value: string, options?: DateTimeOptions): DateTimeMillisUtcLuxon;
-    static fromJSDate(date: Date, options?: DateTimeOptions): DateTimeMillisUtcLuxon;
-    static fromMillis(millis: number, options?: DateTimeOptions): DateTimeMillisUtcLuxon;
+    static fromFormat(value: string, format: string, options?: DateTimeOptions): DateTimeMillisUtcLuxon;
+    static fromJSDate(date: Date, options?: {
+        zone?: string | Zone;
+    }): DateTimeMillisUtcLuxon;
+    static fromMillis(millis: number, options?: DateTimeJSOptions): DateTimeMillisUtcLuxon;
     protected normalize(dateTime: DateTime): DateTime;
     wrap(fn: (dateTime: DateTime) => DateTime): DateTimeMillisUtcLuxon;
     toJSON(): string;

package/dist/luxon.js

@@ -22,6 +22,9 @@ class LuxonDateTime {
         return this.dateTime.valueOf();
     }
     as(type) {
+        if (this instanceof type) {
+            return this;
+        }
         return new type(this.dateTime);
     }
     equals(other) {
@@ -43,13 +46,16 @@ class LocalDateLuxon extends LuxonDateTime {
         return new LocalDateLuxon(luxon_1.DateTime.utc());
     }
     static fromISO(value, options) {
-        return new LocalDateLuxon(luxon_1.DateTime.fromISO(value, options));
+        return new LocalDateLuxon(luxon_1.DateTime.fromISO(value, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
+    }
+    static fromFormat(value, format, options) {
+        return new LocalDateLuxon(luxon_1.DateTime.fromFormat(value, format, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
     static fromJSDate(date, options) {
-        return new LocalDateLuxon(luxon_1.DateTime.fromJSDate(date, options));
+        return new LocalDateLuxon(luxon_1.DateTime.fromJSDate(date, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
     static fromMillis(millis, options) {
-        return new LocalDateLuxon(luxon_1.DateTime.fromMillis(millis, options));
+        return new LocalDateLuxon(luxon_1.DateTime.fromMillis(millis, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
     normalize(dateTime) {
         return luxon_1.DateTime.utc(dateTime.year, dateTime.month, dateTime.day);
@@ -74,13 +80,16 @@ class LocalTimeLuxon extends LuxonDateTime {
         return new LocalTimeLuxon(luxon_1.DateTime.utc());
     }
     static fromISO(value, options) {
-        return new LocalTimeLuxon(luxon_1.DateTime.fromISO(value, options));
+        return new LocalTimeLuxon(luxon_1.DateTime.fromISO(value, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
+    }
+    static fromFormat(value, format, options) {
+        return new LocalTimeLuxon(luxon_1.DateTime.fromFormat(value, format, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
     static fromJSDate(date, options) {
-        return new LocalTimeLuxon(luxon_1.DateTime.fromJSDate(date, options));
+        return new LocalTimeLuxon(luxon_1.DateTime.fromJSDate(date, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
     static fromMillis(millis, options) {
-        return new LocalTimeLuxon(luxon_1.DateTime.fromMillis(millis, options));
+        return new LocalTimeLuxon(luxon_1.DateTime.fromMillis(millis, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
     normalize(dateTime) {
         return luxon_1.DateTime.utc(1970, 1, 1, dateTime.hour, dateTime.minute, dateTime.second);
@@ -104,6 +113,9 @@ class DateTimeLuxon extends LuxonDateTime {
     static fromISO(value, options) {
         return new DateTimeLuxon(luxon_1.DateTime.fromISO(value, Object.assign({ setZone: true }, options)));
     }
+    static fromFormat(value, format, options) {
+        return new DateTimeLuxon(luxon_1.DateTime.fromFormat(value, format, Object.assign({ setZone: true }, options)));
+    }
     static fromJSDate(date, options) {
         return new DateTimeLuxon(luxon_1.DateTime.fromJSDate(date, options));
     }
@@ -137,6 +149,9 @@ class DateTimeUtcLuxon extends LuxonDateTime {
     static fromISO(value, options) {
         return new DateTimeUtcLuxon(luxon_1.DateTime.fromISO(value, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
+    static fromFormat(value, format, options) {
+        return new DateTimeUtcLuxon(luxon_1.DateTime.fromFormat(value, format, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
+    }
     static fromJSDate(date, options) {
         return new DateTimeUtcLuxon(luxon_1.DateTime.fromJSDate(date, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
@@ -164,6 +179,9 @@ class DateTimeMillisLuxon extends LuxonDateTime {
     static fromISO(value, options) {
         return new DateTimeMillisLuxon(luxon_1.DateTime.fromISO(value, Object.assign({ setZone: true }, options)));
     }
+    static fromFormat(value, format, options) {
+        return new DateTimeMillisLuxon(luxon_1.DateTime.fromFormat(value, format, Object.assign({ setZone: true }, options)));
+    }
     static fromJSDate(date, options) {
         return new DateTimeMillisLuxon(luxon_1.DateTime.fromJSDate(date, options));
     }
@@ -197,6 +215,9 @@ class DateTimeMillisUtcLuxon extends LuxonDateTime {
     static fromISO(value, options) {
         return new DateTimeMillisUtcLuxon(luxon_1.DateTime.fromISO(value, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
+    static fromFormat(value, format, options) {
+        return new DateTimeMillisUtcLuxon(luxon_1.DateTime.fromFormat(value, format, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
+    }
     static fromJSDate(date, options) {
         return new DateTimeMillisUtcLuxon(luxon_1.DateTime.fromJSDate(date, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }

package/dist/test-luxon.js

@@ -1,5 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const luxon_1 = require("luxon");
-const d = luxon_1.DateTime.fromISO('2016-05-25T09:08:34.123');
-console.log(d === d.toUTC());
+console.log(luxon_1.DateTime.fromFormat('2022-08-19+0', 'yyyy-MM-ddZ').toJSON());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@finnair/v-validation-luxon",
-  "version": "1.1.0-alpha.6",
+  "version": "1.1.0-alpha.9",
   "private": false,
   "description": "Luxon validators",
   "main": "dist/index.js",
@@ -32,5 +32,5 @@
   "devDependencies": {
     "@types/luxon": "3.0.0"
   },
-  "gitHead": "cbca3585a6777f34cd135c6c22be566aea34e69b"
+  "gitHead": "dcae3dd01e676de15d600898de5188c8384cb360"
 }