@finnair/v-validation-luxon 1.1.0-alpha.8 → 2.0.0

package/CHANGELOG.md

@@ -3,6 +3,47 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.0.0](https://github.com/finnair/v-validation/compare/v1.1.0...v2.0.0) (2022-09-08)
+
+
+* Upgrade All Dependencies (#80) ([fb6309c](https://github.com/finnair/v-validation/commit/fb6309cc1d9fd90f3e8c5ba79798fae1450b66a6)), closes [#80](https://github.com/finnair/v-validation/issues/80)
+
+
+### Features
+
+* Implement toString in Luxon wrapper types ([#79](https://github.com/finnair/v-validation/issues/79)) ([3f3f3e8](https://github.com/finnair/v-validation/commit/3f3f3e8a4172c7803a7be4809f06aba554f7090f))
+
+
+### BREAKING CHANGES
+
+* Drop Node 12 support
+* Add .nvmrc
+* Introduce CI build for Node 18
+* Upgrade All Dependencies
+
+
+
+
+
+# [1.1.0](https://github.com/finnair/v-validation/compare/v1.0.1...v1.1.0) (2022-08-29)
+
+
+### Features
+
+* Support for Luxon ([94b3806](https://github.com/finnair/v-validation/commit/94b38060e07feeb0abb8c81659d8bda537a4d9aa))
+
+
+
+
+
+# [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

package/README.md

@@ -4,7 +4,8 @@
 
 `@finnair/v-validation-luxon` is an extension to `@finnair/v-validation`.
 
-`Vluxon` extension uses custom wrapper types for Luxon DateTime to support full JSON roundtrip with strict validation.
+`Vluxon` extension provides custom wrapper types for Luxon DateTime to support full JSON roundtrip with strict validation.
+Also plain DateTime validators are provided and custom formats are easy to define (see the code for examples).
 
 [Documentation for `v-validation`](https://github.com/finnair/v-validation).
 
@@ -24,20 +25,67 @@ npm install @finnair/v-validation-luxon
 
 ## Vluxon
 
-`validateLuxon` functions can be used to build custom DateTime validators/converters
-by supplying a RegExp pattern and a wrapper class (subclass of LuxonDateTime).
-The wrapper class should guarantee proper `toJSON()` and other required properties
-for the type (e.g. timezone handling).
-
-Time zone 00:00 is serialized as `Z`.
-
-| Vluxon .          | Format                     | Description                                            |
-| ----------------- | -------------------------- | ------------------------------------------------------ |
-| date              | `YYYY-MM-DD`               | Local date.                                            |
-| dateUtc           | `YYYY-MM-DD`               | Date in UTC time zone.                                 |
-| dateTime          | `YYYY-MM-DDTHH:mm:ssZ`     | Date and time in local (parsed) time zone.             |
-| dateTimeUtc       | `YYYY-MM-DDTHH:mm:ssZ`     | Date and time in UTC time zone.                        |
-| dateTimeMillis    | `YYYY-MM-DDTHH:mm:ss.SSSZ` | Date and time with millis in local (parsed) time zone. |
-| dateTimeMillisUtc | `YYYY-MM-DDTHH:mm:ss.SSSZ` | Date and time with millis in UTC time zone.            |
-| time              | `HH:mm:ss`                 | Local time.                                            |
-| duration          | ISO 8601 Duration          | Luxon `Duration` with pattern validation.              |
+Vluxon contains both plain DateTime validators and also validators that return
+DateTime wrappers that guarantee some normalizations (zone, date and/or time) and
+especially JSON serialization in the given format. The wrappers are immutable and
+they allow easy access to the DateTime instance for further processing.
+`validateLuxon` function can be used to build custom DateTime validators/converters
+by supplying a RegExp pattern and a parser function.
+
+## Supported DateTime Wrapper Types
+
+| Class                  | Description                                                                                                 |
+| ---------------------- | ----------------------------------------------------------------------------------------------------------- |
+| LuxonDateTime          | Abstract base class for the wrappers.                                                                       |
+| LocalDateLuxon         | Input and JSON output in `yyyy-MM-dd` format. Time normalized to midnight UTC.                              |
+| LocalTimeLuxon         | Input and JSON output in `HH:mm:ss` format. Date normalized to 1970-01-01 UTC (Unix Epoch).                 |
+| DateTimeLuxon          | Input and JSON output in `yyyy-MM-ddTHH:mm:ssZ` format in local/given/parsed zone with milliseconds zeroed. |
+| DateTimeUtcLuxon       | Input and JSON output in `yyyy-MM-ddTHH:mm:ssZ` format in UTC zone with milliseconds zeroed.                |
+| DateTimeMillisLuxon    | Input and JSON output in `yyyy-MM-ddTHH:mm:ss.SSSZ` format in local/given/parsed zone.                      |
+| DateTimeMillisUtcLuxon | Input and JSON output in `yyyy-MM-ddTHH:mm:ss.SSSZ` format in UTC zone.                                     |
+
+### Constructors
+
+Wrapper types may be constructed with `new` from DateTime instance, but there are also shortcuts:
+
+| Static Method                                                          | Description                                                     |
+| ---------------------------------------------------------------------- | --------------------------------------------------------------- |
+| `now()`                                                                | Current time in `DateTime*` types.                              |
+| `nowUtc()`                                                             | Current UTC time in `Local*` types.                             |
+| `nowLocal(options?: DateTimeJSOptions)`                                | Current local time in `Local*` types (defaults to system zone). |
+| `fromISO(value: string, options?: DateTimeOptions)`                    | Parse from ISO format (see Luxon `DateTime.fromISO`).           |
+| `fromFormat(value: string, format: string, options?: DateTimeOptions)` | Parse from custom format (see Luxon `DateTime.fromFormat`).     |
+| `fromJSDate(date: Date, options?: { zone?: string \| Zone })`          | From JavaScript Date object (see Luxon `DateTime.fromJSDate`).  |
+| `fromMillis(millis: number, options?: DateTimeJSOptions)`              | From Unix millis timestamp (see Luxon `DateTime.fromMillis`).   |
+
+### Instance Methods
+
+Wrappers are meant to be as thin as possible with most of the DateTime functionality accessed directly from the wrapped
+DateTime instance which is public readonly fiedl. However there are a few convenience methods for working with the wrapper types:
+
+| Method                                       | Description                                                                                                        |
+| -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
+| `as(type)`                                   | Conversion to the given type that extends LuxonDateTime. Note that the conversion is not guaranted to be lossless. |
+| `wrap(fn: (dateTime: DateTime) => DateTime)` | Executes the given function on the wrapped DateTime and rewraps the result.                                        |
+| `apply<R>(fn: (dateTime: DateTime) => R): R` | Executes the given function on the wrapped DateTime and returns the result as it is.                               |
+| `valueOf()`                                  | Conversion to millis. This allows comparing wrapper types directly using `==`, `<`, `>`, `<=` or `>=`.             |
+| `equals(other: any)`                         | Type-aware equality.                                                                                               |
+| `toJSON()`                                   | Type-specific serialization (string).                                                                              |
+
+## Build-in Validators
+
+| Vluxon.             | Format                     | Description                                               |
+| ------------------- | -------------------------- | --------------------------------------------------------- |
+| localDate           | `yyyy-MM-dd`               | Local date (time normalized to midninght UTC).            |
+| localTime           | `HH:mm:ss`                 | Local time (date normalized to 1970-01-01).               |
+| dateTime            | `yyyy-MM-ddTHH:mm:ssZ`     | Date and time in local (parsed) time zone.                |
+| dateTimeUtc         | `yyyy-MM-ddTHH:mm:ssZ`     | Date and time in UTC time zone.                           |
+| dateTimeMillis      | `yyyy-MM-ddTHH:mm:ss.SSSZ` | Date and time with millis in local (parsed) time zone.    |
+| dateTimeMillisUtc   | `yyyy-MM-ddTHH:mm:ss.SSSZ` | Date and time with millis in UTC time zone.               |
+| dateTimeFromISO     | Any ISO                    | Plain Luxon DateTime from ISO format.                     |
+| dateTimeFromRFC2822 | RFC2822                    | Plain Luxon DateTime from RFC2822 format.                 |
+| dateTimeFromHTTP    | HTTP date-time             | Plain Luxon DateTime from HTTP format.                    |
+| dateTimeFromSQL     | SQL date-time              | Plain Luxon DateTime from SQL format.                     |
+| dateTimeFromSeconds | Unix timestamp (number)    | Plain Luxon DateTime from Unix timestamp in seconds.      |
+| dateTimeFromMillis  | Unix timestamp (number)    | Plain Luxon DateTime from Unix timestamp in milliseconds. |
+| duration            | ISO 8601 Duration          | Luxon `Duration` with pattern validation.                 |

package/dist/Vluxon.d.ts

@@ -1,6 +1,6 @@
 import { ValidationContext, Validator, ValidationResult } from '@finnair/v-validation';
 import { Path } from '@finnair/path';
-import { DateTime } from 'luxon';
+import { DateTime, DateTimeJSOptions, DateTimeOptions } from 'luxon';
 import { LuxonDateTime } from './luxon';
 export declare type LuxonInput = string | DateTime | LuxonDateTime;
 export interface ValidateLuxonParams {
@@ -8,20 +8,47 @@ export interface ValidateLuxonParams {
     path: Path;
     ctx: ValidationContext;
     type: string;
-    proto: any;
     pattern: RegExp;
-    parser: (value: string) => DateTime;
+    proto?: any;
+    parser: (value: string, match: RegExpExecArray) => DateTime;
 }
 export declare function validateLuxon({ value, path, ctx, type, proto, pattern, parser }: ValidateLuxonParams): Promise<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 interface ValidateLuxonNumberParams {
+    value: any;
+    path: Path;
+    ctx: ValidationContext;
+    type: string;
+    parser: (value: number) => DateTime;
+}
+export declare function validateLuxonNumber({ value, path, ctx, type, parser }: ValidateLuxonNumberParams): Promise<ValidationResult>;
+declare function dateTimeFromMillis(options?: DateTimeJSOptions): import("@finnair/v-validation").ValidatorFnWrapper;
+declare function dateTimeFromSeconds(options?: DateTimeJSOptions): import("@finnair/v-validation").ValidatorFnWrapper;
 export declare class DurationValidator extends Validator {
     validatePath(value: any, path: Path, ctx: ValidationContext): Promise<ValidationResult>;
 }
 export declare const Vluxon: {
-    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;
+    localDate: typeof localDate;
+    localTime: typeof localTime;
+    dateTime: typeof dateTime;
+    dateTimeUtc: typeof dateTimeUtc;
+    dateTimeMillis: typeof dateTimeMillis;
+    dateTimeMillisUtc: typeof dateTimeMillisUtc;
+    dateTimeFromISO: typeof dateTimeFromISO;
+    dateTimeFromRFC2822: typeof dateTimeFromRFC2822;
+    dateTimeFromHTTP: typeof dateTimeFromHTTP;
+    dateTimeFromSQL: typeof dateTimeFromSQL;
+    dateTimeFromSeconds: typeof dateTimeFromSeconds;
+    dateTimeFromMillis: typeof dateTimeFromMillis;
     duration: () => DurationValidator;
 };
+export {};

package/dist/Vluxon.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Vluxon = exports.DurationValidator = exports.validateLuxon = void 0;
+exports.Vluxon = exports.DurationValidator = exports.validateLuxonNumber = exports.validateLuxon = void 0;
 const v_validation_1 = require("@finnair/v-validation");
 const luxon_1 = require("luxon");
 const luxon_2 = require("./luxon");
@@ -18,29 +18,33 @@ 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);
         }
-        if (value instanceof proto) {
+        if (proto && value instanceof proto) {
             return ctx.success(value);
         }
         else if (luxon_1.DateTime.isDateTime(value)) {
             if (value.isValid) {
-                return ctx.success(new proto(value));
+                return success(value);
             }
         }
         else if ((0, v_validation_1.isString)(value)) {
-            if (pattern.test(value)) {
-                const dateTime = parser(value);
+            const match = pattern.exec(value);
+            if (match) {
+                const dateTime = parser(value, match);
                 if (dateTime.isValid) {
-                    return ctx.success(new proto(dateTime));
+                    return success(dateTime);
                 }
             }
         }
         return ctx.failure(v_validation_1.defaultViolations.date(value, path, type), value);
+        function success(dateTime) {
+            return ctx.success(proto ? new proto(dateTime) : dateTime);
+        }
     });
 }
 exports.validateLuxon = validateLuxon;
 const datePattern = /^\d{4}-\d{2}-\d{2}$/;
-function localDateValidator(value, path, ctx) {
-    return validateLuxon({
+function localDate(options = { setZone: true }) {
+    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
         value,
         path,
         ctx,
@@ -48,66 +52,144 @@ function localDateValidator(value, path, ctx) {
         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 validateLuxon({
+function localTime(options = { zone: luxon_1.FixedOffsetZone.utcInstance }) {
+    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
         value,
         path,
         ctx,
         type: 'Time',
         proto: luxon_2.LocalTimeLuxon,
         pattern: timePattern,
-        parser: (value) => luxon_1.DateTime.fromISO(value, { zone: luxon_1.FixedOffsetZone.utcInstance }),
-    });
+        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 dateTimeValidator(value, path, ctx) {
-    return validateLuxon({
+function dateTime(options = { setZone: true }) {
+    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
         value,
         path,
         ctx,
         type: 'DateTime',
         proto: luxon_2.DateTimeLuxon,
         pattern: dateTimePattern,
-        parser: (value) => luxon_1.DateTime.fromISO(value, { setZone: true }),
-    });
+        parser: (value) => luxon_1.DateTime.fromISO(value, options),
+    }));
 }
-function dateTimeUtcValidator(value, path, ctx) {
-    return validateLuxon({
+function dateTimeUtc(options = { zone: luxon_1.FixedOffsetZone.utcInstance }) {
+    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
         value,
         path,
         ctx,
         type: 'DateTime',
         proto: luxon_2.DateTimeUtcLuxon,
         pattern: dateTimePattern,
-        parser: (value) => luxon_1.DateTime.fromISO(value, { zone: luxon_1.FixedOffsetZone.utcInstance }),
-    });
+        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 dateTimeMillisValidator(value, path, ctx) {
-    return validateLuxon({
+function dateTimeMillis(options = { setZone: true }) {
+    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
         value,
         path,
         ctx,
         type: 'DateTimeMillis',
         proto: luxon_2.DateTimeMillisLuxon,
         pattern: dateTimeMillisPattern,
-        parser: (value) => luxon_1.DateTime.fromISO(value, { setZone: true }),
-    });
+        parser: (value) => luxon_1.DateTime.fromISO(value, options),
+    }));
 }
-function dateTimeMillisUtcValidator(value, path, ctx) {
-    return validateLuxon({
+function dateTimeMillisUtc(options = { zone: luxon_1.FixedOffsetZone.utcInstance }) {
+    return v_validation_1.V.fn((value, path, ctx) => validateLuxon({
         value,
         path,
         ctx,
         type: 'DateTimeMillis',
         proto: luxon_2.DateTimeMillisUtcLuxon,
         pattern: dateTimeMillisPattern,
-        parser: (value) => luxon_1.DateTime.fromISO(value, { zone: luxon_1.FixedOffsetZone.utcInstance }),
+        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,
+        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,
+        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,
+        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,
+        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* () {
+        if ((0, v_validation_1.isNullOrUndefined)(value)) {
+            return ctx.failure(v_validation_1.defaultViolations.notNull(path), value);
+        }
+        else if (luxon_1.DateTime.isDateTime(value)) {
+            if (value.isValid) {
+                return ctx.success(value);
+            }
+        }
+        else if (typeof value === 'number' && !Number.isNaN(value)) {
+            const dateTime = parser(value);
+            if (dateTime.isValid) {
+                return ctx.success(dateTime);
+            }
+        }
+        return ctx.failure(v_validation_1.defaultViolations.date(value, path, type), value);
     });
 }
+exports.validateLuxonNumber = validateLuxonNumber;
+function dateTimeFromMillis(options = { zone: luxon_1.FixedOffsetZone.utcInstance }) {
+    return v_validation_1.V.fn((value, path, ctx) => validateLuxonNumber({
+        value,
+        path,
+        ctx,
+        type: 'MillisDateTime',
+        parser: value => luxon_1.DateTime.fromMillis(value, options),
+    }));
+}
+function dateTimeFromSeconds(options = { zone: luxon_1.FixedOffsetZone.utcInstance }) {
+    return v_validation_1.V.fn((value, path, ctx) => validateLuxonNumber({
+        value,
+        path,
+        ctx,
+        type: 'SecondsDateTime',
+        parser: value => luxon_1.DateTime.fromSeconds(value, options),
+    }));
+}
 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)?)?$/;
 class DurationValidator extends v_validation_1.Validator {
     validatePath(value, path, ctx) {
@@ -130,11 +212,19 @@ class DurationValidator extends v_validation_1.Validator {
 }
 exports.DurationValidator = DurationValidator;
 exports.Vluxon = {
-    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),
+    // DateTime wrapper validators
+    localDate,
+    localTime,
+    dateTime,
+    dateTimeUtc,
+    dateTimeMillis,
+    dateTimeMillisUtc,
+    // Plain DateTime validators
+    dateTimeFromISO,
+    dateTimeFromRFC2822,
+    dateTimeFromHTTP,
+    dateTimeFromSQL,
+    dateTimeFromSeconds,
+    dateTimeFromMillis,
     duration: () => new DurationValidator(),
 };

package/dist/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/dist/luxon.d.ts

@@ -10,6 +10,7 @@ export declare abstract class LuxonDateTime {
         new (...args: any[]): T;
     }): T;
     equals(other: any): boolean;
+    toString(): string;
     abstract wrap(fn: (dateTime: DateTime) => DateTime): LuxonDateTime;
     abstract toJSON(): string;
 }

package/dist/luxon.js

@@ -33,6 +33,9 @@ class LuxonDateTime {
         }
         return false;
     }
+    toString() {
+        return this.toJSON();
+    }
 }
 exports.LuxonDateTime = LuxonDateTime;
 class LocalDateLuxon extends LuxonDateTime {

package/dist/test-luxon.js

@@ -1,4 +1,7 @@
 "use strict";
+var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
 const luxon_1 = require("luxon");
-console.log(luxon_1.DateTime.fromFormat('20220819095432+0', 'yyyyMMddHHmmssZ').toJSON());
+console.log(luxon_1.DateTime.fromMillis(luxon_1.DateTime.fromISO('2022-08-30T23:00:00Z').toMillis(), { zone: luxon_1.FixedOffsetZone.instance(180) }).toJSON());
+let o = { foo: 1 };
+console.log((_b = (_a = o.foo) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : 'not found');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@finnair/v-validation-luxon",
-  "version": "1.1.0-alpha.8",
+  "version": "2.0.0",
   "private": false,
   "description": "Luxon validators",
   "main": "dist/index.js",
@@ -25,12 +25,12 @@
     "build": "tsc -b ."
   },
   "dependencies": {
-    "@finnair/path": "^1.1.0-alpha.6",
-    "@finnair/v-validation": "^1.1.0-alpha.6",
-    "luxon": "3.0.1"
+    "@finnair/path": "^2.0.0",
+    "@finnair/v-validation": "^2.0.0",
+    "luxon": "3.0.3"
   },
   "devDependencies": {
-    "@types/luxon": "3.0.0"
+    "@types/luxon": "3.0.1"
   },
-  "gitHead": "883052983f33664439c1baae629ed5f6d53cbdcb"
+  "gitHead": "432759665b664859d5ed80e4b573432abdb23afc"
 }