@naturalcycles/js-lib 14.90.0 → 14.91.2

package/dist/datetime/localDate.d.ts

@@ -1,5 +1,6 @@
 import { Sequence } from '../seq/seq';
-import { IsoDate } from '../types';
+import { IsoDate, UnixTimestamp } from '../types';
+import { LocalTime } from './localTime';
 export declare type LocalDateUnit = 'year' | 'month' | 'day';
 export declare type LocalDateConfig = LocalDate | string;
 /**
@@ -18,6 +19,11 @@ export declare class LocalDate {
     static of(d: LocalDateConfig): LocalDate;
     static parseCompact(d: string): LocalDate;
     static fromDate(d: Date): LocalDate;
+    /**
+     * Returns null if invalid.
+     */
+    static parseOrNull(d: LocalDateConfig): LocalDate | null;
+    static isValid(iso: string): boolean;
     static today(): LocalDate;
     static sort(items: LocalDate[], mutate?: boolean, descending?: boolean): LocalDate[];
     static earliestOrUndefined(items: LocalDate[]): LocalDate | undefined;
@@ -54,9 +60,9 @@ export declare class LocalDate {
     subtract(num: number, unit: LocalDateUnit, mutate?: boolean): LocalDate;
     startOf(unit: LocalDateUnit): LocalDate;
     endOf(unit: LocalDateUnit): LocalDate;
-    private getYearDays;
-    private getMonthLen;
-    private isLeapYear;
+    static getYearLength(year: number): number;
+    static getMonthLength(year: number, month: number): number;
+    static isLeapYear(year: number): boolean;
     clone(): LocalDate;
     /**
      * Converts LocalDate into instance of Date.
@@ -65,8 +71,12 @@ export declare class LocalDate {
      * Timezone will match local timezone.
      */
     toDate(): Date;
+    toLocalTime(): LocalTime;
+    toISODate(): IsoDate;
     toString(): IsoDate;
     toStringCompact(): string;
+    unix(): UnixTimestamp;
+    unixMillis(): number;
     toJSON(): IsoDate;
 }
 /**

package/dist/datetime/localDate.js

@@ -4,6 +4,7 @@ exports.localDate = exports.LocalDate = void 0;
 const assert_1 = require("../error/assert");
 const seq_1 = require("../seq/seq");
 const types_1 = require("../types");
+const localTime_1 = require("./localTime");
 const m31 = new Set([1, 3, 5, 7, 8, 10, 12]);
 /**
  * @experimental
@@ -22,17 +23,15 @@ class LocalDate {
      * Input can already be a LocalDate - it is returned as-is in that case.
      */
     static of(d) {
-        if (d instanceof LocalDate)
-            return d;
-        const [year, month, day] = d.slice(0, 10).split('-').map(Number);
-        if (!day || !month || (!year && year !== 0)) {
+        const t = this.parseOrNull(d);
+        if (t === null) {
             throw new Error(`Cannot parse "${d}" into LocalDate`);
         }
-        return new LocalDate(year, month, day);
+        return t;
     }
     static parseCompact(d) {
         const [year, month, day] = [d.slice(0, 4), d.slice(4, 2), d.slice(6, 2)].map(Number);
-        if (!day || !month || (!year && year !== 0)) {
+        if (!day || !month || !year) {
             throw new Error(`Cannot parse "${d}" into LocalDate`);
         }
         return new LocalDate(year, month, day);
@@ -40,6 +39,28 @@ class LocalDate {
     static fromDate(d) {
         return new LocalDate(d.getFullYear(), d.getMonth() + 1, d.getDate());
     }
+    /**
+     * Returns null if invalid.
+     */
+    static parseOrNull(d) {
+        if (d instanceof LocalDate)
+            return d;
+        // todo: explore more performant options
+        const [year, month, day] = d.slice(0, 10).split('-').map(Number);
+        if (!year ||
+            !month ||
+            month < 1 ||
+            month > 12 ||
+            !day ||
+            day < 1 ||
+            day > this.getMonthLength(year, month)) {
+            return null;
+        }
+        return new LocalDate(year, month, day);
+    }
+    static isValid(iso) {
+        return this.parseOrNull(iso) !== null;
+    }
     static today() {
         return this.fromDate(new Date());
     }
@@ -148,22 +169,22 @@ class LocalDate {
         let days = this.day - d.day;
         if (d.year < this.year) {
             for (let year = d.year; year < this.year; year++) {
-                days += this.getYearDays(year);
+                days += LocalDate.getYearLength(year);
             }
         }
         else if (this.year < d.year) {
             for (let year = this.year; year < d.year; year++) {
-                days -= this.getYearDays(year);
+                days -= LocalDate.getYearLength(year);
             }
         }
         if (d.month < this.month) {
             for (let month = d.month; month < this.month; month++) {
-                days += this.getMonthLen(this.year, month);
+                days += LocalDate.getMonthLength(this.year, month);
             }
         }
         else if (this.month < d.month) {
             for (let month = this.month; month < d.month; month++) {
-                days -= this.getMonthLen(d.year, month);
+                days -= LocalDate.getMonthLength(d.year, month);
             }
         }
         return days;
@@ -180,7 +201,7 @@ class LocalDate {
             year += num;
         }
         // check day overflow
-        let monLen = this.getMonthLen(year, month);
+        let monLen = LocalDate.getMonthLength(year, month);
         while (day > monLen) {
             day -= monLen;
             month += 1;
@@ -188,7 +209,7 @@ class LocalDate {
                 year += 1;
                 month -= 12;
             }
-            monLen = this.getMonthLen(year, month);
+            monLen = LocalDate.getMonthLength(year, month);
         }
         while (day < 1) {
             day += monLen;
@@ -197,7 +218,7 @@ class LocalDate {
                 year -= 1;
                 month += 12;
             }
-            monLen = this.getMonthLen(year, month);
+            monLen = LocalDate.getMonthLength(year, month);
         }
         // check month overflow
         while (month > 12) {
@@ -231,19 +252,19 @@ class LocalDate {
         if (unit === 'day')
             return this;
         if (unit === 'month')
-            return LocalDate.create(this.year, this.month, this.getMonthLen(this.year, this.month));
+            return LocalDate.create(this.year, this.month, LocalDate.getMonthLength(this.year, this.month));
         // year
         return LocalDate.create(this.year, 12, 31);
     }
-    getYearDays(year) {
+    static getYearLength(year) {
         return this.isLeapYear(year) ? 366 : 365;
     }
-    getMonthLen(year, month) {
+    static getMonthLength(year, month) {
         if (month === 2)
             return this.isLeapYear(year) ? 29 : 28;
         return m31.has(month) ? 31 : 30;
     }
-    isLeapYear(year) {
+    static isLeapYear(year) {
         if (year % 4 !== 0)
             return false;
         if (year % 100 !== 0)
@@ -262,6 +283,12 @@ class LocalDate {
     toDate() {
         return new Date(this.year, this.month - 1, this.day);
     }
+    toLocalTime() {
+        return localTime_1.LocalTime.of(this.toDate());
+    }
+    toISODate() {
+        return this.toString();
+    }
     toString() {
         return [
             String(this.year).padStart(4, '0'),
@@ -276,6 +303,13 @@ class LocalDate {
             String(this.day).padStart(2, '0'),
         ].join('');
     }
+    // May be not optimal, as LocalTime better suits it
+    unix() {
+        return Math.floor(this.toDate().valueOf() / 1000);
+    }
+    unixMillis() {
+        return this.toDate().valueOf();
+    }
     toJSON() {
         return this.toString();
     }

package/dist/datetime/localTime.d.ts

@@ -1,4 +1,5 @@
-import { IsoDateTime, UnixTimestamp } from '../types';
+import { IsoDate, IsoDateTime, UnixTimestamp } from '../types';
+import { LocalDate } from './localDate';
 export declare type LocalTimeUnit = 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second';
 export declare type LocalTimeConfig = LocalTime | Date | IsoDateTime | UnixTimestamp;
 export interface LocalTimeComponents {
@@ -20,6 +21,11 @@ export declare class LocalTime {
      * Input can already be a LocalDate - it is returned as-is in that case.
      */
     static of(d: LocalTimeConfig): LocalTime;
+    /**
+     * Returns null if invalid
+     */
+    static parseOrNull(d: LocalTimeConfig): LocalTime | null;
+    static isValid(d: LocalTimeConfig): boolean;
     static unix(ts: UnixTimestamp): LocalTime;
     static now(): LocalTime;
     static fromComponents(c: {
@@ -66,9 +72,18 @@ export declare class LocalTime {
     getDate(): Date;
     clone(): LocalTime;
     unix(): UnixTimestamp;
+    unixMillis(): number;
     valueOf(): UnixTimestamp;
-    toISO8601(): IsoDateTime;
-    toPretty(): IsoDateTime;
+    toLocalDate(): LocalDate;
+    toPretty(seconds?: boolean): IsoDateTime;
+    /**
+     * Returns e.g: `1984-06-21T17:56:21`, only the date part of DateTime
+     */
+    toISODateTime(): IsoDateTime;
+    /**
+     * Returns e.g: `1984-06-21`, only the date part of DateTime
+     */
+    toISODate(): IsoDate;
     /**
      * Returns e.g: `19840621_1705`
      */

package/dist/datetime/localTime.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.localTime = exports.LocalTime = void 0;
 const assert_1 = require("../error/assert");
+const localDate_1 = require("./localDate");
 /* eslint-disable no-dupe-class-members */
 // Design choices:
 // No milliseconds
@@ -24,21 +25,38 @@ class LocalTime {
      * Input can already be a LocalDate - it is returned as-is in that case.
      */
     static of(d) {
+        const t = this.parseOrNull(d);
+        if (t === null) {
+            throw new TypeError(`Cannot parse "${d}" into LocalTime`);
+        }
+        return t;
+    }
+    /**
+     * Returns null if invalid
+     */
+    static parseOrNull(d) {
         if (d instanceof LocalTime)
             return d;
-        if (d instanceof Date)
-            return new LocalTime(d);
-        if (typeof d === 'number') {
-            // unix timestamp
-            return new LocalTime(new Date(d * 1000));
+        let date;
+        if (d instanceof Date) {
+            date = d;
+        }
+        else if (typeof d === 'number') {
+            date = new Date(d * 1000);
+        }
+        else {
+            date = new Date(d);
         }
-        const date = new Date(d);
         // validation
         if (isNaN(date.getDate())) {
-            throw new TypeError(`Cannot parse "${d}" into LocalTime`);
+            // throw new TypeError(`Cannot parse "${d}" into LocalTime`)
+            return null;
         }
         return new LocalTime(date);
     }
+    static isValid(d) {
+        return this.parseOrNull(d) !== null;
+    }
     static unix(ts) {
         return new LocalTime(new Date(ts * 1000));
     }
@@ -277,14 +295,33 @@ class LocalTime {
     unix() {
         return Math.floor(this.$date.valueOf() / 1000);
     }
+    unixMillis() {
+        return this.$date.valueOf();
+    }
     valueOf() {
         return Math.floor(this.$date.valueOf() / 1000);
     }
-    toISO8601() {
+    toLocalDate() {
+        return localDate_1.LocalDate.create(this.$date.getFullYear(), this.$date.getMonth() + 1, this.$date.getDate());
+    }
+    toPretty(seconds = true) {
+        return this.$date
+            .toISOString()
+            .slice(0, seconds ? 19 : 16)
+            .split('T')
+            .join(' ');
+    }
+    /**
+     * Returns e.g: `1984-06-21T17:56:21`, only the date part of DateTime
+     */
+    toISODateTime() {
         return this.$date.toISOString().slice(0, 19);
     }
-    toPretty() {
-        return this.$date.toISOString().slice(0, 19).split('T').join(' ');
+    /**
+     * Returns e.g: `1984-06-21`, only the date part of DateTime
+     */
+    toISODate() {
+        return this.$date.toISOString().slice(0, 10);
     }
     /**
      * Returns e.g: `19840621_1705`

package/dist-esm/datetime/localDate.js

@@ -1,6 +1,7 @@
 import { _assert } from '../error/assert';
 import { Sequence } from '../seq/seq';
 import { END } from '../types';
+import { LocalTime } from './localTime';
 const m31 = new Set([1, 3, 5, 7, 8, 10, 12]);
 /**
  * @experimental
@@ -19,17 +20,15 @@ export class LocalDate {
      * Input can already be a LocalDate - it is returned as-is in that case.
      */
     static of(d) {
-        if (d instanceof LocalDate)
-            return d;
-        const [year, month, day] = d.slice(0, 10).split('-').map(Number);
-        if (!day || !month || (!year && year !== 0)) {
+        const t = this.parseOrNull(d);
+        if (t === null) {
             throw new Error(`Cannot parse "${d}" into LocalDate`);
         }
-        return new LocalDate(year, month, day);
+        return t;
     }
     static parseCompact(d) {
         const [year, month, day] = [d.slice(0, 4), d.slice(4, 2), d.slice(6, 2)].map(Number);
-        if (!day || !month || (!year && year !== 0)) {
+        if (!day || !month || !year) {
             throw new Error(`Cannot parse "${d}" into LocalDate`);
         }
         return new LocalDate(year, month, day);
@@ -37,6 +36,28 @@ export class LocalDate {
     static fromDate(d) {
         return new LocalDate(d.getFullYear(), d.getMonth() + 1, d.getDate());
     }
+    /**
+     * Returns null if invalid.
+     */
+    static parseOrNull(d) {
+        if (d instanceof LocalDate)
+            return d;
+        // todo: explore more performant options
+        const [year, month, day] = d.slice(0, 10).split('-').map(Number);
+        if (!year ||
+            !month ||
+            month < 1 ||
+            month > 12 ||
+            !day ||
+            day < 1 ||
+            day > this.getMonthLength(year, month)) {
+            return null;
+        }
+        return new LocalDate(year, month, day);
+    }
+    static isValid(iso) {
+        return this.parseOrNull(iso) !== null;
+    }
     static today() {
         return this.fromDate(new Date());
     }
@@ -145,22 +166,22 @@ export class LocalDate {
         let days = this.day - d.day;
         if (d.year < this.year) {
             for (let year = d.year; year < this.year; year++) {
-                days += this.getYearDays(year);
+                days += LocalDate.getYearLength(year);
             }
         }
         else if (this.year < d.year) {
             for (let year = this.year; year < d.year; year++) {
-                days -= this.getYearDays(year);
+                days -= LocalDate.getYearLength(year);
             }
         }
         if (d.month < this.month) {
             for (let month = d.month; month < this.month; month++) {
-                days += this.getMonthLen(this.year, month);
+                days += LocalDate.getMonthLength(this.year, month);
             }
         }
         else if (this.month < d.month) {
             for (let month = this.month; month < d.month; month++) {
-                days -= this.getMonthLen(d.year, month);
+                days -= LocalDate.getMonthLength(d.year, month);
             }
         }
         return days;
@@ -177,7 +198,7 @@ export class LocalDate {
             year += num;
         }
         // check day overflow
-        let monLen = this.getMonthLen(year, month);
+        let monLen = LocalDate.getMonthLength(year, month);
         while (day > monLen) {
             day -= monLen;
             month += 1;
@@ -185,7 +206,7 @@ export class LocalDate {
                 year += 1;
                 month -= 12;
             }
-            monLen = this.getMonthLen(year, month);
+            monLen = LocalDate.getMonthLength(year, month);
         }
         while (day < 1) {
             day += monLen;
@@ -194,7 +215,7 @@ export class LocalDate {
                 year -= 1;
                 month += 12;
             }
-            monLen = this.getMonthLen(year, month);
+            monLen = LocalDate.getMonthLength(year, month);
         }
         // check month overflow
         while (month > 12) {
@@ -228,19 +249,19 @@ export class LocalDate {
         if (unit === 'day')
             return this;
         if (unit === 'month')
-            return LocalDate.create(this.year, this.month, this.getMonthLen(this.year, this.month));
+            return LocalDate.create(this.year, this.month, LocalDate.getMonthLength(this.year, this.month));
         // year
         return LocalDate.create(this.year, 12, 31);
     }
-    getYearDays(year) {
+    static getYearLength(year) {
         return this.isLeapYear(year) ? 366 : 365;
     }
-    getMonthLen(year, month) {
+    static getMonthLength(year, month) {
         if (month === 2)
             return this.isLeapYear(year) ? 29 : 28;
         return m31.has(month) ? 31 : 30;
     }
-    isLeapYear(year) {
+    static isLeapYear(year) {
         if (year % 4 !== 0)
             return false;
         if (year % 100 !== 0)
@@ -259,6 +280,12 @@ export class LocalDate {
     toDate() {
         return new Date(this.year, this.month - 1, this.day);
     }
+    toLocalTime() {
+        return LocalTime.of(this.toDate());
+    }
+    toISODate() {
+        return this.toString();
+    }
     toString() {
         return [
             String(this.year).padStart(4, '0'),
@@ -273,6 +300,13 @@ export class LocalDate {
             String(this.day).padStart(2, '0'),
         ].join('');
     }
+    // May be not optimal, as LocalTime better suits it
+    unix() {
+        return Math.floor(this.toDate().valueOf() / 1000);
+    }
+    unixMillis() {
+        return this.toDate().valueOf();
+    }
     toJSON() {
         return this.toString();
     }

package/dist-esm/datetime/localTime.js

@@ -1,4 +1,5 @@
 import { _assert } from '../error/assert';
+import { LocalDate } from './localDate';
 /* eslint-disable no-dupe-class-members */
 // Design choices:
 // No milliseconds
@@ -21,21 +22,38 @@ export class LocalTime {
      * Input can already be a LocalDate - it is returned as-is in that case.
      */
     static of(d) {
+        const t = this.parseOrNull(d);
+        if (t === null) {
+            throw new TypeError(`Cannot parse "${d}" into LocalTime`);
+        }
+        return t;
+    }
+    /**
+     * Returns null if invalid
+     */
+    static parseOrNull(d) {
         if (d instanceof LocalTime)
             return d;
-        if (d instanceof Date)
-            return new LocalTime(d);
-        if (typeof d === 'number') {
-            // unix timestamp
-            return new LocalTime(new Date(d * 1000));
+        let date;
+        if (d instanceof Date) {
+            date = d;
+        }
+        else if (typeof d === 'number') {
+            date = new Date(d * 1000);
+        }
+        else {
+            date = new Date(d);
         }
-        const date = new Date(d);
         // validation
         if (isNaN(date.getDate())) {
-            throw new TypeError(`Cannot parse "${d}" into LocalTime`);
+            // throw new TypeError(`Cannot parse "${d}" into LocalTime`)
+            return null;
         }
         return new LocalTime(date);
     }
+    static isValid(d) {
+        return this.parseOrNull(d) !== null;
+    }
     static unix(ts) {
         return new LocalTime(new Date(ts * 1000));
     }
@@ -274,14 +292,33 @@ export class LocalTime {
     unix() {
         return Math.floor(this.$date.valueOf() / 1000);
     }
+    unixMillis() {
+        return this.$date.valueOf();
+    }
     valueOf() {
         return Math.floor(this.$date.valueOf() / 1000);
     }
-    toISO8601() {
+    toLocalDate() {
+        return LocalDate.create(this.$date.getFullYear(), this.$date.getMonth() + 1, this.$date.getDate());
+    }
+    toPretty(seconds = true) {
+        return this.$date
+            .toISOString()
+            .slice(0, seconds ? 19 : 16)
+            .split('T')
+            .join(' ');
+    }
+    /**
+     * Returns e.g: `1984-06-21T17:56:21`, only the date part of DateTime
+     */
+    toISODateTime() {
         return this.$date.toISOString().slice(0, 19);
     }
-    toPretty() {
-        return this.$date.toISOString().slice(0, 19).split('T').join(' ');
+    /**
+     * Returns e.g: `1984-06-21`, only the date part of DateTime
+     */
+    toISODate() {
+        return this.$date.toISOString().slice(0, 10);
     }
     /**
      * Returns e.g: `19840621_1705`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.90.0",
+  "version": "14.91.2",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",

package/src/datetime/localDate.ts

@@ -1,6 +1,7 @@
 import { _assert } from '../error/assert'
 import { Sequence } from '../seq/seq'
-import { END, IsoDate } from '../types'
+import { END, IsoDate, UnixTimestamp } from '../types'
+import { LocalTime } from './localTime'
 
 export type LocalDateUnit = 'year' | 'month' | 'day'
 
@@ -23,21 +24,19 @@ export class LocalDate {
    * Input can already be a LocalDate - it is returned as-is in that case.
    */
   static of(d: LocalDateConfig): LocalDate {
-    if (d instanceof LocalDate) return d
-
-    const [year, month, day] = d.slice(0, 10).split('-').map(Number)
+    const t = this.parseOrNull(d)
 
-    if (!day || !month || (!year && year !== 0)) {
+    if (t === null) {
       throw new Error(`Cannot parse "${d}" into LocalDate`)
     }
 
-    return new LocalDate(year, month, day)
+    return t
   }
 
   static parseCompact(d: string): LocalDate {
     const [year, month, day] = [d.slice(0, 4), d.slice(4, 2), d.slice(6, 2)].map(Number)
 
-    if (!day || !month || (!year && year !== 0)) {
+    if (!day || !month || !year) {
       throw new Error(`Cannot parse "${d}" into LocalDate`)
     }
 
@@ -48,6 +47,34 @@ export class LocalDate {
     return new LocalDate(d.getFullYear(), d.getMonth() + 1, d.getDate())
   }
 
+  /**
+   * Returns null if invalid.
+   */
+  static parseOrNull(d: LocalDateConfig): LocalDate | null {
+    if (d instanceof LocalDate) return d
+
+    // todo: explore more performant options
+    const [year, month, day] = d.slice(0, 10).split('-').map(Number)
+
+    if (
+      !year ||
+      !month ||
+      month < 1 ||
+      month > 12 ||
+      !day ||
+      day < 1 ||
+      day > this.getMonthLength(year, month)
+    ) {
+      return null
+    }
+
+    return new LocalDate(year, month, day)
+  }
+
+  static isValid(iso: string): boolean {
+    return this.parseOrNull(iso) !== null
+  }
+
   static today(): LocalDate {
     return this.fromDate(new Date())
   }
@@ -203,21 +230,21 @@ export class LocalDate {
 
     if (d.year < this.year) {
       for (let year = d.year; year < this.year; year++) {
-        days += this.getYearDays(year)
+        days += LocalDate.getYearLength(year)
       }
     } else if (this.year < d.year) {
       for (let year = this.year; year < d.year; year++) {
-        days -= this.getYearDays(year)
+        days -= LocalDate.getYearLength(year)
       }
     }
 
     if (d.month < this.month) {
       for (let month = d.month; month < this.month; month++) {
-        days += this.getMonthLen(this.year, month)
+        days += LocalDate.getMonthLength(this.year, month)
       }
     } else if (this.month < d.month) {
       for (let month = this.month; month < d.month; month++) {
-        days -= this.getMonthLen(d.year, month)
+        days -= LocalDate.getMonthLength(d.year, month)
       }
     }
 
@@ -236,7 +263,7 @@ export class LocalDate {
     }
 
     // check day overflow
-    let monLen = this.getMonthLen(year, month)
+    let monLen = LocalDate.getMonthLength(year, month)
     while (day > monLen) {
       day -= monLen
       month += 1
@@ -245,7 +272,7 @@ export class LocalDate {
         month -= 12
       }
 
-      monLen = this.getMonthLen(year, month)
+      monLen = LocalDate.getMonthLength(year, month)
     }
     while (day < 1) {
       day += monLen
@@ -255,7 +282,7 @@ export class LocalDate {
         month += 12
       }
 
-      monLen = this.getMonthLen(year, month)
+      monLen = LocalDate.getMonthLength(year, month)
     }
 
     // check month overflow
@@ -292,21 +319,25 @@ export class LocalDate {
   endOf(unit: LocalDateUnit): LocalDate {
     if (unit === 'day') return this
     if (unit === 'month')
-      return LocalDate.create(this.year, this.month, this.getMonthLen(this.year, this.month))
+      return LocalDate.create(
+        this.year,
+        this.month,
+        LocalDate.getMonthLength(this.year, this.month),
+      )
     // year
     return LocalDate.create(this.year, 12, 31)
   }
 
-  private getYearDays(year: number): number {
+  static getYearLength(year: number): number {
     return this.isLeapYear(year) ? 366 : 365
   }
 
-  private getMonthLen(year: number, month: number): number {
+  static getMonthLength(year: number, month: number): number {
     if (month === 2) return this.isLeapYear(year) ? 29 : 28
     return m31.has(month) ? 31 : 30
   }
 
-  private isLeapYear(year: number): boolean {
+  static isLeapYear(year: number): boolean {
     if (year % 4 !== 0) return false
     if (year % 100 !== 0) return true
     return year % 400 === 0
@@ -326,6 +357,14 @@ export class LocalDate {
     return new Date(this.year, this.month - 1, this.day)
   }
 
+  toLocalTime(): LocalTime {
+    return LocalTime.of(this.toDate())
+  }
+
+  toISODate(): IsoDate {
+    return this.toString()
+  }
+
   toString(): IsoDate {
     return [
       String(this.year).padStart(4, '0'),
@@ -342,6 +381,15 @@ export class LocalDate {
     ].join('')
   }
 
+  // May be not optimal, as LocalTime better suits it
+  unix(): UnixTimestamp {
+    return Math.floor(this.toDate().valueOf() / 1000)
+  }
+
+  unixMillis(): number {
+    return this.toDate().valueOf()
+  }
+
   toJSON(): IsoDate {
     return this.toString()
   }

package/src/datetime/localTime.ts

@@ -1,5 +1,6 @@
 import { _assert } from '../error/assert'
-import { IsoDateTime, UnixTimestamp } from '../types'
+import { IsoDate, IsoDateTime, UnixTimestamp } from '../types'
+import { LocalDate } from './localDate'
 
 export type LocalTimeUnit = 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second'
 
@@ -36,24 +37,44 @@ export class LocalTime {
    * Input can already be a LocalDate - it is returned as-is in that case.
    */
   static of(d: LocalTimeConfig): LocalTime {
-    if (d instanceof LocalTime) return d
-    if (d instanceof Date) return new LocalTime(d)
+    const t = this.parseOrNull(d)
 
-    if (typeof d === 'number') {
-      // unix timestamp
-      return new LocalTime(new Date(d * 1000))
+    if (t === null) {
+      throw new TypeError(`Cannot parse "${d}" into LocalTime`)
     }
 
-    const date = new Date(d)
+    return t
+  }
+
+  /**
+   * Returns null if invalid
+   */
+  static parseOrNull(d: LocalTimeConfig): LocalTime | null {
+    if (d instanceof LocalTime) return d
+
+    let date
+
+    if (d instanceof Date) {
+      date = d
+    } else if (typeof d === 'number') {
+      date = new Date(d * 1000)
+    } else {
+      date = new Date(d)
+    }
 
     // validation
     if (isNaN(date.getDate())) {
-      throw new TypeError(`Cannot parse "${d}" into LocalTime`)
+      // throw new TypeError(`Cannot parse "${d}" into LocalTime`)
+      return null
     }
 
     return new LocalTime(date)
   }
 
+  static isValid(d: LocalTimeConfig): boolean {
+    return this.parseOrNull(d) !== null
+  }
+
   static unix(ts: UnixTimestamp): LocalTime {
     return new LocalTime(new Date(ts * 1000))
   }
@@ -331,16 +352,42 @@ export class LocalTime {
     return Math.floor(this.$date.valueOf() / 1000)
   }
 
+  unixMillis(): number {
+    return this.$date.valueOf()
+  }
+
   valueOf(): UnixTimestamp {
     return Math.floor(this.$date.valueOf() / 1000)
   }
 
-  toISO8601(): IsoDateTime {
+  toLocalDate(): LocalDate {
+    return LocalDate.create(
+      this.$date.getFullYear(),
+      this.$date.getMonth() + 1,
+      this.$date.getDate(),
+    )
+  }
+
+  toPretty(seconds = true): IsoDateTime {
+    return this.$date
+      .toISOString()
+      .slice(0, seconds ? 19 : 16)
+      .split('T')
+      .join(' ')
+  }
+
+  /**
+   * Returns e.g: `1984-06-21T17:56:21`, only the date part of DateTime
+   */
+  toISODateTime(): IsoDateTime {
     return this.$date.toISOString().slice(0, 19)
   }
 
-  toPretty(): IsoDateTime {
-    return this.$date.toISOString().slice(0, 19).split('T').join(' ')
+  /**
+   * Returns e.g: `1984-06-21`, only the date part of DateTime
+   */
+  toISODate(): IsoDate {
+    return this.$date.toISOString().slice(0, 10)
   }
 
   /**