@finnair/v-validation-luxon 1.1.0-alpha.4 → 1.1.0-alpha.7

package/CHANGELOG.md

@@ -3,6 +3,48 @@
 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.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)
+
+
+### Bug Fixes
+
+* Fix exports ([b9eacb6](https://github.com/finnair/v-validation/commit/b9eacb6e98a05a07049eb0a8f97b7e6b4958973a))
+
+
+### Features
+
+* fromISO helper for Luxon wrapper construction ([e3b8f24](https://github.com/finnair/v-validation/commit/e3b8f247b3a9bfef8ad474688f995862fdd810e3))
+* Support for Luxon ([00d0a8e](https://github.com/finnair/v-validation/commit/00d0a8e8c8de46bfeb3502f51bb8cd5a3627070e))
+
+
+
+
+
+# [1.1.0-alpha.5](https://github.com/finnair/v-validation/compare/v1.0.1...v1.1.0-alpha.5) (2022-08-16)
+
+
+### Bug Fixes
+
+* Fix exports ([904e63c](https://github.com/finnair/v-validation/commit/904e63c4a40e65d274349ae0f5ea80c697c5c8ce))
+
+
+### Features
+
+* fromISO helper for Luxon wrapper construction ([81d5b2e](https://github.com/finnair/v-validation/commit/81d5b2eb08f360ab56ec0c6caece392a0e6eb1a1))
+* Support for Luxon ([6a243f0](https://github.com/finnair/v-validation/commit/6a243f043db2ca6700180eb758a08d8edfe1e538))
+
+
+
+
+
 # [1.1.0-alpha.4](https://github.com/finnair/v-validation/compare/v1.1.0-alpha.3...v1.1.0-alpha.4) (2022-08-15)
 
 **Note:** Version bump only for package @finnair/v-validation-luxon

package/dist/Vluxon.d.ts

@@ -10,18 +10,18 @@ export interface ValidateLuxonParams {
     type: string;
     proto: any;
     pattern: RegExp;
+    parser: (value: string) => DateTime;
 }
-export declare function validateLuxon({ value, path, ctx, type, proto, pattern }: ValidateLuxonParams): ValidationResult;
+export declare function validateLuxon({ value, path, ctx, type, proto, pattern, parser }: ValidateLuxonParams): ValidationResult;
 export declare class DurationValidator extends Validator {
     validatePath(value: any, path: Path, ctx: ValidationContext): Promise<ValidationResult>;
 }
 export declare const Vluxon: {
-    date: () => import("@finnair/v-validation").ValidatorFnWrapper;
-    dateUtc: () => import("@finnair/v-validation").ValidatorFnWrapper;
+    localDate: () => import("@finnair/v-validation").ValidatorFnWrapper;
+    localTime: () => import("@finnair/v-validation").ValidatorFnWrapper;
     dateTime: () => import("@finnair/v-validation").ValidatorFnWrapper;
     dateTimeUtc: () => import("@finnair/v-validation").ValidatorFnWrapper;
     dateTimeMillis: () => import("@finnair/v-validation").ValidatorFnWrapper;
     dateTimeMillisUtc: () => import("@finnair/v-validation").ValidatorFnWrapper;
-    time: () => import("@finnair/v-validation").ValidatorFnWrapper;
     duration: () => DurationValidator;
 };

package/dist/Vluxon.js

@@ -13,7 +13,7 @@ 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 }) {
+function validateLuxon({ value, path, ctx, type, proto, pattern, parser }) {
     if ((0, v_validation_1.isNullOrUndefined)(value)) {
         return ctx.failure(v_validation_1.defaultViolations.notNull(path), value);
     }
@@ -27,7 +27,7 @@ function validateLuxon({ value, path, ctx, type, proto, pattern }) {
     }
     else if ((0, v_validation_1.isString)(value)) {
         if (pattern.test(value)) {
-            const dateTime = luxon_1.DateTime.fromISO(value, { setZone: true });
+            const dateTime = parser(value);
             if (dateTime.isValid) {
                 return ctx.success(new proto(dateTime));
             }
@@ -37,27 +37,30 @@ function validateLuxon({ value, path, ctx, type, proto, pattern }) {
 }
 exports.validateLuxon = validateLuxon;
 const datePattern = /^\d{4}-\d{2}-\d{2}$/;
-function dateValidator(value, path, ctx) {
+function localDateValidator(value, path, ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         return validateLuxon({
             value,
             path,
             ctx,
             type: 'Date',
-            proto: luxon_2.DateLuxon,
-            pattern: datePattern
+            proto: luxon_2.LocalDateLuxon,
+            pattern: datePattern,
+            parser: (value) => luxon_1.DateTime.fromISO(value, { zone: luxon_1.FixedOffsetZone.utcInstance }),
         });
     });
 }
-function dateUtcValidator(value, path, ctx) {
+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: 'Date',
-            proto: luxon_2.DateUtcLuxon,
-            pattern: datePattern
+            type: 'Time',
+            proto: luxon_2.LocalTimeLuxon,
+            pattern: timePattern,
+            parser: (value) => luxon_1.DateTime.fromISO(value, { zone: luxon_1.FixedOffsetZone.utcInstance }),
         });
     });
 }
@@ -70,7 +73,8 @@ function dateTimeValidator(value, path, ctx) {
             ctx,
             type: 'DateTime',
             proto: luxon_2.DateTimeLuxon,
-            pattern: dateTimePattern
+            pattern: dateTimePattern,
+            parser: (value) => luxon_1.DateTime.fromISO(value, { setZone: true }),
         });
     });
 }
@@ -82,7 +86,8 @@ function dateTimeUtcValidator(value, path, ctx) {
             ctx,
             type: 'DateTime',
             proto: luxon_2.DateTimeUtcLuxon,
-            pattern: dateTimePattern
+            pattern: dateTimePattern,
+            parser: (value) => luxon_1.DateTime.fromISO(value, { zone: luxon_1.FixedOffsetZone.utcInstance }),
         });
     });
 }
@@ -95,7 +100,8 @@ function dateTimeMillisValidator(value, path, ctx) {
             ctx,
             type: 'DateTimeMillis',
             proto: luxon_2.DateTimeMillisLuxon,
-            pattern: dateTimeMillisPattern
+            pattern: dateTimeMillisPattern,
+            parser: (value) => luxon_1.DateTime.fromISO(value, { setZone: true }),
         });
     });
 }
@@ -107,20 +113,8 @@ function dateTimeMillisUtcValidator(value, path, ctx) {
             ctx,
             type: 'DateTimeMillis',
             proto: luxon_2.DateTimeMillisUtcLuxon,
-            pattern: dateTimeMillisPattern
-        });
-    });
-}
-const timePattern = /^\d{2}:\d{2}:\d{2}$/;
-function timeValidator(value, path, ctx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return validateLuxon({
-            value,
-            path,
-            ctx,
-            type: 'Time',
-            proto: luxon_2.TimeLuxon,
-            pattern: timePattern
+            pattern: dateTimeMillisPattern,
+            parser: (value) => luxon_1.DateTime.fromISO(value, { zone: luxon_1.FixedOffsetZone.utcInstance }),
         });
     });
 }
@@ -146,12 +140,11 @@ class DurationValidator extends v_validation_1.Validator {
 }
 exports.DurationValidator = DurationValidator;
 exports.Vluxon = {
-    date: () => v_validation_1.V.fn(dateValidator),
-    dateUtc: () => v_validation_1.V.fn(dateUtcValidator),
+    localDate: () => v_validation_1.V.fn(localDateValidator),
+    localTime: () => v_validation_1.V.fn(localTimeValidator),
     dateTime: () => v_validation_1.V.fn(dateTimeValidator),
     dateTimeUtc: () => v_validation_1.V.fn(dateTimeUtcValidator),
     dateTimeMillis: () => v_validation_1.V.fn(dateTimeMillisValidator),
     dateTimeMillisUtc: () => v_validation_1.V.fn(dateTimeMillisUtcValidator),
-    time: () => v_validation_1.V.fn(timeValidator),
     duration: () => new DurationValidator(),
 };

package/dist/luxon.d.ts

@@ -1,53 +1,60 @@
-import { DateTime } from 'luxon';
+import { DateTime, DateTimeJSOptions, DateTimeOptions } from 'luxon';
 export declare type LuxonDateTimeInput = DateTime | LuxonDateTime;
 export declare abstract class LuxonDateTime {
     readonly dateTime: DateTime;
     constructor(input: LuxonDateTimeInput);
-    protected normalize(dateTime: DateTime): DateTime;
+    protected abstract normalize(dateTime: DateTime): DateTime;
     apply<R>(fn: (dateTime: DateTime) => R): R;
     valueOf(): number;
+    as<T extends LuxonDateTime>(type: {
+        new (...args: any[]): T;
+    }): T;
     equals(other: any): boolean;
     abstract wrap(fn: (dateTime: DateTime) => DateTime): LuxonDateTime;
     abstract toJSON(): string;
 }
-export declare class DateLuxon extends LuxonDateTime {
+export declare class LocalDateLuxon extends LuxonDateTime {
     static readonly format = "yyyy-MM-dd";
     constructor(input: LuxonDateTimeInput);
-    static now(): DateLuxon;
-    static fromISO(value: string, options?: Object): DateLuxon;
-    static fromJSDate(date: Date, options?: Object): DateLuxon;
-    static fromMillis(milliseconds: number, options?: Object): DateLuxon;
+    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;
     protected normalize(dateTime: DateTime): DateTime;
-    wrap(fn: (dateTime: DateTime) => DateTime): DateLuxon;
+    wrap(fn: (dateTime: DateTime) => DateTime): LocalDateLuxon;
     toJSON(): string;
 }
-export declare class DateUtcLuxon extends LuxonDateTime {
+export declare class LocalTimeLuxon extends LuxonDateTime {
+    static readonly format = "HH:mm:ss";
     constructor(input: LuxonDateTimeInput);
-    static now(): DateUtcLuxon;
-    static fromISO(value: string, options?: Object): DateUtcLuxon;
-    static fromJSDate(date: Date, options?: Object): DateUtcLuxon;
-    static fromMillis(milliseconds: number, options?: Object): DateUtcLuxon;
+    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;
     protected normalize(dateTime: DateTime): DateTime;
-    wrap(fn: (dateTime: DateTime) => DateTime): DateUtcLuxon;
+    wrap(fn: (dateTime: DateTime) => DateTime): LocalTimeLuxon;
     toJSON(): string;
 }
 export declare class DateTimeLuxon extends LuxonDateTime {
     static readonly format = "yyyy-MM-dd'T'HH:mm:ss";
     static readonly formatTz: string;
     constructor(input: LuxonDateTimeInput);
-    static now(): DateTimeLuxon;
-    static fromISO(value: string, options?: Object): DateTimeLuxon;
-    static fromJSDate(date: Date, options?: Object): DateTimeLuxon;
-    static fromMillis(milliseconds: number, options?: Object): DateTimeLuxon;
+    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;
+    protected normalize(dateTime: DateTime): DateTime;
     wrap(fn: (dateTime: DateTime) => DateTime): DateTimeLuxon;
     toJSON(): string;
 }
 export declare class DateTimeUtcLuxon extends LuxonDateTime {
     constructor(input: LuxonDateTimeInput);
     static now(): DateTimeUtcLuxon;
-    static fromISO(value: string): DateTimeUtcLuxon;
-    static fromJSDate(date: Date, options?: Object): DateTimeUtcLuxon;
-    static fromMillis(milliseconds: number, options?: Object): DateTimeUtcLuxon;
+    static fromISO(value: string, options?: DateTimeOptions): DateTimeUtcLuxon;
+    static fromJSDate(date: Date, options?: DateTimeOptions): DateTimeUtcLuxon;
+    static fromMillis(millis: number, options?: DateTimeOptions): DateTimeUtcLuxon;
     protected normalize(dateTime: DateTime): DateTime;
     wrap(fn: (dateTime: DateTime) => DateTime): DateTimeUtcLuxon;
     toJSON(): string;
@@ -56,30 +63,21 @@ export declare class DateTimeMillisLuxon extends LuxonDateTime {
     static readonly format = "yyyy-MM-dd'T'HH:mm:ss.SSS";
     static readonly formatTz: string;
     constructor(input: LuxonDateTimeInput);
-    static now(): DateTimeMillisLuxon;
-    static fromISO(value: string): DateTimeMillisLuxon;
-    static fromJSDate(date: Date, options?: Object): DateTimeMillisLuxon;
-    static fromMillis(milliseconds: number, options?: Object): DateTimeMillisLuxon;
+    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;
+    protected normalize(dateTime: DateTime): DateTime;
     wrap(fn: (dateTime: DateTime) => DateTime): DateTimeMillisLuxon;
     toJSON(): string;
 }
 export declare class DateTimeMillisUtcLuxon extends LuxonDateTime {
     constructor(input: LuxonDateTimeInput);
     static now(): DateTimeMillisUtcLuxon;
-    static fromISO(value: string, options?: Object): DateTimeMillisUtcLuxon;
-    static fromJSDate(date: Date, options?: Object): DateTimeMillisUtcLuxon;
-    static fromMillis(milliseconds: number, options?: Object): DateTimeMillisUtcLuxon;
+    static fromISO(value: string, options?: DateTimeOptions): DateTimeMillisUtcLuxon;
+    static fromJSDate(date: Date, options?: DateTimeOptions): DateTimeMillisUtcLuxon;
+    static fromMillis(millis: number, options?: DateTimeOptions): DateTimeMillisUtcLuxon;
     protected normalize(dateTime: DateTime): DateTime;
     wrap(fn: (dateTime: DateTime) => DateTime): DateTimeMillisUtcLuxon;
     toJSON(): string;
 }
-export declare class TimeLuxon extends LuxonDateTime {
-    static readonly format = "HH:mm:ss";
-    constructor(input: LuxonDateTimeInput);
-    static now(): TimeLuxon;
-    static fromISO(value: string, options?: Object): TimeLuxon;
-    static fromJSDate(date: Date, options?: Object): TimeLuxon;
-    static fromMillis(milliseconds: number, options?: Object): TimeLuxon;
-    wrap(fn: (dateTime: DateTime) => DateTime): TimeLuxon;
-    toJSON(): string;
-}

package/dist/luxon.js

@@ -1,7 +1,7 @@
 "use strict";
 var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TimeLuxon = exports.DateTimeMillisUtcLuxon = exports.DateTimeMillisLuxon = exports.DateTimeUtcLuxon = exports.DateTimeLuxon = exports.DateUtcLuxon = exports.DateLuxon = exports.LuxonDateTime = void 0;
+exports.DateTimeMillisUtcLuxon = exports.DateTimeMillisLuxon = exports.DateTimeUtcLuxon = exports.DateTimeLuxon = exports.LocalTimeLuxon = exports.LocalDateLuxon = exports.LuxonDateTime = void 0;
 const luxon_1 = require("luxon");
 class LuxonDateTime {
     constructor(input) {
@@ -15,15 +15,18 @@ class LuxonDateTime {
             this.dateTime = this.normalize(input);
         }
     }
-    normalize(dateTime) {
-        return dateTime;
-    }
     apply(fn) {
         return fn(this.dateTime);
     }
     valueOf() {
         return this.dateTime.valueOf();
     }
+    as(type) {
+        if (this instanceof type) {
+            return this;
+        }
+        return new type(this.dateTime);
+    }
     equals(other) {
         if (this.constructor === other.constructor) {
             return this.dateTime.equals(other.dateTime);
@@ -32,76 +35,86 @@ class LuxonDateTime {
     }
 }
 exports.LuxonDateTime = LuxonDateTime;
-class DateLuxon extends LuxonDateTime {
+class LocalDateLuxon extends LuxonDateTime {
     constructor(input) {
         super(input);
     }
-    static now() {
-        return new DateLuxon(luxon_1.DateTime.now());
+    static nowLocal(options) {
+        return new LocalDateLuxon(luxon_1.DateTime.local(options));
+    }
+    static nowUtc() {
+        return new LocalDateLuxon(luxon_1.DateTime.utc());
     }
     static fromISO(value, options) {
-        return new DateLuxon(luxon_1.DateTime.fromISO(value, options));
+        return new LocalDateLuxon(luxon_1.DateTime.fromISO(value, options));
     }
     static fromJSDate(date, options) {
-        return new DateLuxon(luxon_1.DateTime.fromJSDate(date, options));
+        return new LocalDateLuxon(luxon_1.DateTime.fromJSDate(date, options));
     }
-    static fromMillis(milliseconds, options) {
-        return new DateLuxon(luxon_1.DateTime.fromMillis(milliseconds, options));
+    static fromMillis(millis, options) {
+        return new LocalDateLuxon(luxon_1.DateTime.fromMillis(millis, options));
     }
     normalize(dateTime) {
-        return dateTime.startOf('day');
+        return luxon_1.DateTime.utc(dateTime.year, dateTime.month, dateTime.day);
     }
     wrap(fn) {
-        return new DateLuxon(fn(this.dateTime));
+        return new LocalDateLuxon(fn(this.dateTime));
     }
     toJSON() {
-        return this.dateTime.toFormat(DateLuxon.format);
+        return this.dateTime.toFormat(LocalDateLuxon.format);
     }
 }
-exports.DateLuxon = DateLuxon;
-DateLuxon.format = 'yyyy-MM-dd';
-class DateUtcLuxon extends LuxonDateTime {
+exports.LocalDateLuxon = LocalDateLuxon;
+LocalDateLuxon.format = 'yyyy-MM-dd';
+class LocalTimeLuxon extends LuxonDateTime {
     constructor(input) {
         super(input);
     }
-    static now() {
-        return new DateUtcLuxon(luxon_1.DateTime.now());
+    static nowLocal(options) {
+        return new LocalTimeLuxon(luxon_1.DateTime.local(options));
+    }
+    static nowUtc() {
+        return new LocalTimeLuxon(luxon_1.DateTime.utc());
     }
     static fromISO(value, options) {
-        return new DateUtcLuxon(luxon_1.DateTime.fromISO(value, options));
+        return new LocalTimeLuxon(luxon_1.DateTime.fromISO(value, options));
     }
     static fromJSDate(date, options) {
-        return new DateUtcLuxon(luxon_1.DateTime.fromJSDate(date, options));
+        return new LocalTimeLuxon(luxon_1.DateTime.fromJSDate(date, options));
     }
-    static fromMillis(milliseconds, options) {
-        return new DateUtcLuxon(luxon_1.DateTime.fromMillis(milliseconds, options));
+    static fromMillis(millis, options) {
+        return new LocalTimeLuxon(luxon_1.DateTime.fromMillis(millis, options));
     }
     normalize(dateTime) {
-        return luxon_1.DateTime.utc(dateTime.year, dateTime.month, dateTime.day, 0, 0, 0);
+        return luxon_1.DateTime.utc(1970, 1, 1, dateTime.hour, dateTime.minute, dateTime.second);
     }
     wrap(fn) {
-        return new DateUtcLuxon(fn(this.dateTime));
+        return new LocalTimeLuxon(fn(this.dateTime));
     }
     toJSON() {
-        return this.dateTime.toFormat(DateLuxon.format);
+        return this.dateTime.toFormat(LocalTimeLuxon.format);
     }
 }
-exports.DateUtcLuxon = DateUtcLuxon;
+exports.LocalTimeLuxon = LocalTimeLuxon;
+LocalTimeLuxon.format = 'HH:mm:ss';
 class DateTimeLuxon extends LuxonDateTime {
     constructor(input) {
         super(input);
     }
-    static now() {
-        return new DateTimeLuxon(luxon_1.DateTime.now());
+    static now(options) {
+        return new DateTimeLuxon(luxon_1.DateTime.local(options));
     }
     static fromISO(value, options) {
-        return new DateTimeLuxon(luxon_1.DateTime.fromISO(value, options));
+        return new DateTimeLuxon(luxon_1.DateTime.fromISO(value, Object.assign({ setZone: true }, options)));
     }
     static fromJSDate(date, options) {
         return new DateTimeLuxon(luxon_1.DateTime.fromJSDate(date, options));
     }
-    static fromMillis(milliseconds, options) {
-        return new DateTimeLuxon(luxon_1.DateTime.fromMillis(milliseconds, options));
+    static fromMillis(millis, options) {
+        return new DateTimeLuxon(luxon_1.DateTime.fromMillis(millis, options));
+    }
+    normalize(dateTime) {
+        return dateTime.startOf('second');
     }
     wrap(fn) {
         return new DateTimeLuxon(fn(this.dateTime));
@@ -122,19 +135,19 @@ class DateTimeUtcLuxon extends LuxonDateTime {
         super(input);
     }
     static now() {
-        return new DateTimeUtcLuxon(luxon_1.DateTime.now());
+        return new DateTimeUtcLuxon(luxon_1.DateTime.utc());
     }
-    static fromISO(value) {
-        return new DateTimeUtcLuxon(luxon_1.DateTime.fromISO(value));
+    static fromISO(value, options) {
+        return new DateTimeUtcLuxon(luxon_1.DateTime.fromISO(value, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
     static fromJSDate(date, options) {
-        return new DateTimeUtcLuxon(luxon_1.DateTime.fromJSDate(date, options));
+        return new DateTimeUtcLuxon(luxon_1.DateTime.fromJSDate(date, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
-    static fromMillis(milliseconds, options) {
-        return new DateTimeUtcLuxon(luxon_1.DateTime.fromMillis(milliseconds, options));
+    static fromMillis(millis, options) {
+        return new DateTimeUtcLuxon(luxon_1.DateTime.fromMillis(millis, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
     normalize(dateTime) {
-        return dateTime.toUTC();
+        return dateTime.toUTC().startOf('second');
     }
     wrap(fn) {
         return new DateTimeUtcLuxon(fn(this.dateTime));
@@ -148,17 +161,20 @@ class DateTimeMillisLuxon extends LuxonDateTime {
     constructor(input) {
         super(input);
     }
-    static now() {
-        return new DateTimeMillisLuxon(luxon_1.DateTime.now());
+    static now(options) {
+        return new DateTimeMillisLuxon(luxon_1.DateTime.local(options));
     }
-    static fromISO(value) {
-        return new DateTimeMillisLuxon(luxon_1.DateTime.fromISO(value));
+    static fromISO(value, options) {
+        return new DateTimeMillisLuxon(luxon_1.DateTime.fromISO(value, Object.assign({ setZone: true }, options)));
     }
     static fromJSDate(date, options) {
         return new DateTimeMillisLuxon(luxon_1.DateTime.fromJSDate(date, options));
     }
-    static fromMillis(milliseconds, options) {
-        return new DateTimeMillisLuxon(luxon_1.DateTime.fromMillis(milliseconds, options));
+    static fromMillis(millis, options) {
+        return new DateTimeMillisLuxon(luxon_1.DateTime.fromMillis(millis, options));
+    }
+    normalize(dateTime) {
+        return dateTime;
     }
     wrap(fn) {
         return new DateTimeMillisLuxon(fn(this.dateTime));
@@ -179,16 +195,16 @@ class DateTimeMillisUtcLuxon extends LuxonDateTime {
         super(input);
     }
     static now() {
-        return new DateTimeMillisUtcLuxon(luxon_1.DateTime.now());
+        return new DateTimeMillisUtcLuxon(luxon_1.DateTime.utc());
     }
     static fromISO(value, options) {
-        return new DateTimeMillisUtcLuxon(luxon_1.DateTime.fromISO(value, options));
+        return new DateTimeMillisUtcLuxon(luxon_1.DateTime.fromISO(value, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
     static fromJSDate(date, options) {
-        return new DateTimeMillisUtcLuxon(luxon_1.DateTime.fromJSDate(date, options));
+        return new DateTimeMillisUtcLuxon(luxon_1.DateTime.fromJSDate(date, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
-    static fromMillis(milliseconds, options) {
-        return new DateTimeMillisUtcLuxon(luxon_1.DateTime.fromMillis(milliseconds, options));
+    static fromMillis(millis, options) {
+        return new DateTimeMillisUtcLuxon(luxon_1.DateTime.fromMillis(millis, Object.assign({ zone: luxon_1.FixedOffsetZone.utcInstance }, options)));
     }
     normalize(dateTime) {
         return dateTime.toUTC();
@@ -201,28 +217,3 @@ class DateTimeMillisUtcLuxon extends LuxonDateTime {
     }
 }
 exports.DateTimeMillisUtcLuxon = DateTimeMillisUtcLuxon;
-class TimeLuxon extends LuxonDateTime {
-    constructor(input) {
-        super(input);
-    }
-    static now() {
-        return new TimeLuxon(luxon_1.DateTime.now());
-    }
-    static fromISO(value, options) {
-        return new TimeLuxon(luxon_1.DateTime.fromISO(value, options));
-    }
-    static fromJSDate(date, options) {
-        return new TimeLuxon(luxon_1.DateTime.fromJSDate(date, options));
-    }
-    static fromMillis(milliseconds, options) {
-        return new TimeLuxon(luxon_1.DateTime.fromMillis(milliseconds, options));
-    }
-    wrap(fn) {
-        return new TimeLuxon(fn(this.dateTime));
-    }
-    toJSON() {
-        return this.dateTime.toFormat(TimeLuxon.format);
-    }
-}
-exports.TimeLuxon = TimeLuxon;
-TimeLuxon.format = 'HH:mm:ss';

package/dist/test-luxon.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const luxon_1 = require("luxon");
-console.log(luxon_1.DateTime.now().toFormat('yyyy-MM-dd HH:mm:ss ZZZ'));
+console.log(luxon_1.DateTime.fromISO('2022-02-27').set({ day: 31 }).day);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@finnair/v-validation-luxon",
-  "version": "1.1.0-alpha.4",
+  "version": "1.1.0-alpha.7",
   "private": false,
   "description": "Luxon validators",
   "main": "dist/index.js",
@@ -25,12 +25,12 @@
     "build": "tsc -b ."
   },
   "dependencies": {
-    "@finnair/path": "^1.1.0-alpha.0",
-    "@finnair/v-validation": "^1.1.0-alpha.0",
+    "@finnair/path": "^1.1.0-alpha.6",
+    "@finnair/v-validation": "^1.1.0-alpha.6",
     "luxon": "3.0.1"
   },
   "devDependencies": {
     "@types/luxon": "3.0.0"
   },
-  "gitHead": "d2478122e33d247af89e16c84e8093b5f9bee294"
+  "gitHead": "b270437f1a403fbb012297653f05d7d6d732fa76"
 }