@naturalcycles/js-lib 14.163.0 → 14.164.0

package/dist/datetime/localDate.js

@@ -23,16 +23,14 @@ class LocalDate {
      */
     static of(d) {
         const t = this.parseOrNull(d);
-        if (t === null) {
-            throw new Error(`Cannot parse "${d}" into LocalDate`);
-        }
+        (0, assert_1._assert)(t !== null, `Cannot parse "${d}" into LocalDate`, {
+            input: d,
+        });
         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) {
-            throw new Error(`Cannot parse "${d}" into LocalDate`);
-        }
+        (0, assert_1._assert)(day && month && year, `Cannot parse "${d}" into LocalDate`);
         return new LocalDate(year, month, day);
     }
     static fromDate(d) {

package/dist/datetime/localTime.js

@@ -33,9 +33,9 @@ class LocalTime {
      */
     static of(d) {
         const t = this.parseOrNull(d);
-        if (t === null) {
-            throw new TypeError(`Cannot parse "${d}" into LocalTime`);
-        }
+        (0, assert_1._assert)(t !== null, `Cannot parse "${d}" into LocalTime`, {
+            input: d,
+        });
         return t;
     }
     /**
@@ -82,9 +82,9 @@ class LocalTime {
         if (d instanceof Date)
             return d;
         const date = typeof d === 'number' ? new Date(d * 1000) : new Date(d);
-        if (isNaN(date.getDate())) {
-            throw new TypeError(`Cannot parse "${d}" to Date`);
-        }
+        (0, assert_1._assert)(!isNaN(date.getDate()), `Cannot parse "${d}" to Date`, {
+            input: d,
+        });
         return date;
     }
     static parseToUnixTimestamp(d) {
@@ -93,9 +93,9 @@ class LocalTime {
         if (d instanceof LocalTime)
             return d.unix();
         const date = d instanceof Date ? d : new Date(d);
-        if (isNaN(date.getDate())) {
-            throw new TypeError(`Cannot parse "${d}" to UnixTimestamp`);
-        }
+        (0, assert_1._assert)(!isNaN(date.getDate()), `Cannot parse "${d}" to UnixTimestamp`, {
+            input: d,
+        });
         return date.valueOf() / 1000;
     }
     static isValid(d) {
@@ -171,8 +171,7 @@ class LocalTime {
         if (v === undefined) {
             return dow;
         }
-        if (!VALID_DAYS_OF_WEEK.has(v))
-            throw new Error(`Invalid dayOfWeek: ${v}`);
+        (0, assert_1._assert)(VALID_DAYS_OF_WEEK.has(v), `Invalid dayOfWeek: ${v}`);
         return this.add(v - dow, 'day');
     }
     hour(v) {

package/dist/index.d.ts

@@ -81,6 +81,7 @@ export * from './http/fetcher.model';
 export * from './string/hash.util';
 export * from './env/buildInfo';
 export * from './form.util';
+export * from './semver';
 export * from './zod/zod.util';
 export * from './zod/zod.shared.schemas';
 import { z, ZodSchema, ZodError, ZodIssue } from 'zod';

package/dist/index.js

@@ -85,6 +85,7 @@ tslib_1.__exportStar(require("./http/fetcher.model"), exports);
 tslib_1.__exportStar(require("./string/hash.util"), exports);
 tslib_1.__exportStar(require("./env/buildInfo"), exports);
 tslib_1.__exportStar(require("./form.util"), exports);
+tslib_1.__exportStar(require("./semver"), exports);
 tslib_1.__exportStar(require("./zod/zod.util"), exports);
 tslib_1.__exportStar(require("./zod/zod.shared.schemas"), exports);
 const zod_1 = require("zod");

package/dist/semver.d.ts

@@ -0,0 +1,44 @@
+export type SemverInput = string | Semver;
+export type SemverTokens = [major: number, minor: number, patch: number];
+/**
+ * Simple Semver implementation.
+ *
+ * Suitable for Browser usage, unlike npm `semver` which is Node-targeted and simply too big for the Browser.
+ *
+ * Parsing algorithm is simple:
+ * 1. Split by `.`
+ * 2. parseInt each of 3 tokens, set to 0 if falsy
+ *
+ * toString returns `major.minor.patch`
+ * Missing tokens are replaced with 0.
+ *
+ * _semver('1').toString() === '1.0.0'
+ *
+ * @experimental
+ */
+export declare class Semver {
+    tokens: SemverTokens;
+    private constructor();
+    get major(): number;
+    get minor(): number;
+    get patch(): number;
+    static of(input: SemverInput): Semver;
+    static parseOrNull(input: SemverInput | undefined | null): Semver | null;
+    isAfter: (other: SemverInput) => boolean;
+    isSameOrAfter: (other: SemverInput) => boolean;
+    isBefore: (other: SemverInput) => boolean;
+    isSameOrBefore: (other: SemverInput) => boolean;
+    isSame: (other: SemverInput) => boolean;
+    /**
+     * Returns 1 if this > other
+     * returns 0 if they are equal
+     * returns -1 if this < other
+     */
+    cmp(other: SemverInput): -1 | 0 | 1;
+    toJSON: () => string;
+    toString(): string;
+}
+/**
+ * Shortcut for Semver.of(input)
+ */
+export declare function _semver(input: SemverInput): Semver;

package/dist/semver.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._semver = exports.Semver = void 0;
+const range_1 = require("./array/range");
+const assert_1 = require("./error/assert");
+/**
+ * Simple Semver implementation.
+ *
+ * Suitable for Browser usage, unlike npm `semver` which is Node-targeted and simply too big for the Browser.
+ *
+ * Parsing algorithm is simple:
+ * 1. Split by `.`
+ * 2. parseInt each of 3 tokens, set to 0 if falsy
+ *
+ * toString returns `major.minor.patch`
+ * Missing tokens are replaced with 0.
+ *
+ * _semver('1').toString() === '1.0.0'
+ *
+ * @experimental
+ */
+class Semver {
+    constructor(tokens) {
+        this.tokens = tokens;
+        this.isAfter = (other) => this.cmp(other) > 0;
+        this.isSameOrAfter = (other) => this.cmp(other) >= 0;
+        this.isBefore = (other) => this.cmp(other) < 0;
+        this.isSameOrBefore = (other) => this.cmp(other) <= 0;
+        this.isSame = (other) => this.cmp(other) === 0;
+        this.toJSON = () => this.toString();
+    }
+    get major() {
+        return this.tokens[0];
+    }
+    get minor() {
+        return this.tokens[1];
+    }
+    get patch() {
+        return this.tokens[2];
+    }
+    static of(input) {
+        const s = this.parseOrNull(input);
+        (0, assert_1._assert)(s !== null, `Cannot parse "${input}" into Semver`, {
+            userFriendly: true,
+            input,
+        });
+        return s;
+    }
+    static parseOrNull(input) {
+        if (!input)
+            return null;
+        if (input instanceof Semver)
+            return input;
+        const t = input.split('.');
+        return new Semver((0, range_1._range)(3).map(i => parseInt(t[i]) || 0));
+    }
+    /**
+     * Returns 1 if this > other
+     * returns 0 if they are equal
+     * returns -1 if this < other
+     */
+    cmp(other) {
+        const { tokens } = Semver.of(other);
+        for (let i = 0; i < 3; i++) {
+            if (this.tokens[i] < tokens[i])
+                return -1;
+            if (this.tokens[i] > tokens[i])
+                return 1;
+        }
+        return 0;
+    }
+    toString() {
+        return this.tokens.join('.');
+    }
+}
+exports.Semver = Semver;
+/**
+ * Shortcut for Semver.of(input)
+ */
+function _semver(input) {
+    return Semver.of(input);
+}
+exports._semver = _semver;

package/dist-esm/datetime/localDate.js

@@ -20,16 +20,14 @@ export class LocalDate {
      */
     static of(d) {
         const t = this.parseOrNull(d);
-        if (t === null) {
-            throw new Error(`Cannot parse "${d}" into LocalDate`);
-        }
+        _assert(t !== null, `Cannot parse "${d}" into LocalDate`, {
+            input: d,
+        });
         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) {
-            throw new Error(`Cannot parse "${d}" into LocalDate`);
-        }
+        _assert(day && month && year, `Cannot parse "${d}" into LocalDate`);
         return new LocalDate(year, month, day);
     }
     static fromDate(d) {

package/dist-esm/datetime/localTime.js

@@ -30,9 +30,9 @@ export class LocalTime {
      */
     static of(d) {
         const t = this.parseOrNull(d);
-        if (t === null) {
-            throw new TypeError(`Cannot parse "${d}" into LocalTime`);
-        }
+        _assert(t !== null, `Cannot parse "${d}" into LocalTime`, {
+            input: d,
+        });
         return t;
     }
     /**
@@ -79,9 +79,9 @@ export class LocalTime {
         if (d instanceof Date)
             return d;
         const date = typeof d === 'number' ? new Date(d * 1000) : new Date(d);
-        if (isNaN(date.getDate())) {
-            throw new TypeError(`Cannot parse "${d}" to Date`);
-        }
+        _assert(!isNaN(date.getDate()), `Cannot parse "${d}" to Date`, {
+            input: d,
+        });
         return date;
     }
     static parseToUnixTimestamp(d) {
@@ -90,9 +90,9 @@ export class LocalTime {
         if (d instanceof LocalTime)
             return d.unix();
         const date = d instanceof Date ? d : new Date(d);
-        if (isNaN(date.getDate())) {
-            throw new TypeError(`Cannot parse "${d}" to UnixTimestamp`);
-        }
+        _assert(!isNaN(date.getDate()), `Cannot parse "${d}" to UnixTimestamp`, {
+            input: d,
+        });
         return date.valueOf() / 1000;
     }
     static isValid(d) {
@@ -168,8 +168,7 @@ export class LocalTime {
         if (v === undefined) {
             return dow;
         }
-        if (!VALID_DAYS_OF_WEEK.has(v))
-            throw new Error(`Invalid dayOfWeek: ${v}`);
+        _assert(VALID_DAYS_OF_WEEK.has(v), `Invalid dayOfWeek: ${v}`);
         return this.add(v - dow, 'day');
     }
     hour(v) {

package/dist-esm/index.js

@@ -81,6 +81,7 @@ export * from './http/fetcher.model';
 export * from './string/hash.util';
 export * from './env/buildInfo';
 export * from './form.util';
+export * from './semver';
 export * from './zod/zod.util';
 export * from './zod/zod.shared.schemas';
 import { z, ZodSchema, ZodError } from 'zod';

package/dist-esm/semver.js

@@ -0,0 +1,78 @@
+import { _range } from './array/range';
+import { _assert } from './error/assert';
+/**
+ * Simple Semver implementation.
+ *
+ * Suitable for Browser usage, unlike npm `semver` which is Node-targeted and simply too big for the Browser.
+ *
+ * Parsing algorithm is simple:
+ * 1. Split by `.`
+ * 2. parseInt each of 3 tokens, set to 0 if falsy
+ *
+ * toString returns `major.minor.patch`
+ * Missing tokens are replaced with 0.
+ *
+ * _semver('1').toString() === '1.0.0'
+ *
+ * @experimental
+ */
+export class Semver {
+    constructor(tokens) {
+        this.tokens = tokens;
+        this.isAfter = (other) => this.cmp(other) > 0;
+        this.isSameOrAfter = (other) => this.cmp(other) >= 0;
+        this.isBefore = (other) => this.cmp(other) < 0;
+        this.isSameOrBefore = (other) => this.cmp(other) <= 0;
+        this.isSame = (other) => this.cmp(other) === 0;
+        this.toJSON = () => this.toString();
+    }
+    get major() {
+        return this.tokens[0];
+    }
+    get minor() {
+        return this.tokens[1];
+    }
+    get patch() {
+        return this.tokens[2];
+    }
+    static of(input) {
+        const s = this.parseOrNull(input);
+        _assert(s !== null, `Cannot parse "${input}" into Semver`, {
+            userFriendly: true,
+            input,
+        });
+        return s;
+    }
+    static parseOrNull(input) {
+        if (!input)
+            return null;
+        if (input instanceof Semver)
+            return input;
+        const t = input.split('.');
+        return new Semver(_range(3).map(i => parseInt(t[i]) || 0));
+    }
+    /**
+     * Returns 1 if this > other
+     * returns 0 if they are equal
+     * returns -1 if this < other
+     */
+    cmp(other) {
+        const { tokens } = Semver.of(other);
+        for (let i = 0; i < 3; i++) {
+            if (this.tokens[i] < tokens[i])
+                return -1;
+            if (this.tokens[i] > tokens[i])
+                return 1;
+        }
+        return 0;
+    }
+    toString() {
+        return this.tokens.join('.');
+    }
+}
+/**
+ * Shortcut for Semver.of(input)
+ */
+export function _semver(input) {
+    return Semver.of(input);
+}

package/package.json

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

package/src/datetime/localDate.ts

@@ -38,9 +38,9 @@ export class LocalDate {
   static of(d: LocalDateInput): LocalDate {
     const t = this.parseOrNull(d)
 
-    if (t === null) {
-      throw new Error(`Cannot parse "${d}" into LocalDate`)
-    }
+    _assert(t !== null, `Cannot parse "${d}" into LocalDate`, {
+      input: d,
+    })
 
     return t
   }
@@ -48,9 +48,7 @@ export class LocalDate {
   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) {
-      throw new Error(`Cannot parse "${d}" into LocalDate`)
-    }
+    _assert(day && month && year, `Cannot parse "${d}" into LocalDate`)
 
     return new LocalDate(year, month, day)
   }

package/src/datetime/localTime.ts

@@ -53,9 +53,9 @@ export class LocalTime {
   static of(d: LocalTimeInput): LocalTime {
     const t = this.parseOrNull(d)
 
-    if (t === null) {
-      throw new TypeError(`Cannot parse "${d}" into LocalTime`)
-    }
+    _assert(t !== null, `Cannot parse "${d}" into LocalTime`, {
+      input: d,
+    })
 
     return t
   }
@@ -106,9 +106,9 @@ export class LocalTime {
 
     const date = typeof d === 'number' ? new Date(d * 1000) : new Date(d)
 
-    if (isNaN(date.getDate())) {
-      throw new TypeError(`Cannot parse "${d}" to Date`)
-    }
+    _assert(!isNaN(date.getDate()), `Cannot parse "${d}" to Date`, {
+      input: d,
+    })
 
     return date
   }
@@ -119,9 +119,9 @@ export class LocalTime {
 
     const date = d instanceof Date ? d : new Date(d)
 
-    if (isNaN(date.getDate())) {
-      throw new TypeError(`Cannot parse "${d}" to UnixTimestamp`)
-    }
+    _assert(!isNaN(date.getDate()), `Cannot parse "${d}" to UnixTimestamp`, {
+      input: d,
+    })
 
     return date.valueOf() / 1000
   }
@@ -220,7 +220,7 @@ export class LocalTime {
       return dow
     }
 
-    if (!VALID_DAYS_OF_WEEK.has(v)) throw new Error(`Invalid dayOfWeek: ${v}`)
+    _assert(VALID_DAYS_OF_WEEK.has(v), `Invalid dayOfWeek: ${v}`)
 
     return this.add(v - dow, 'day')
   }

package/src/index.ts

@@ -81,6 +81,7 @@ export * from './http/fetcher.model'
 export * from './string/hash.util'
 export * from './env/buildInfo'
 export * from './form.util'
+export * from './semver'
 export * from './zod/zod.util'
 export * from './zod/zod.shared.schemas'
 import { z, ZodSchema, ZodError, ZodIssue } from 'zod'

package/src/semver.ts

@@ -0,0 +1,87 @@
+import { _range } from './array/range'
+import { _assert } from './error/assert'
+
+export type SemverInput = string | Semver
+export type SemverTokens = [major: number, minor: number, patch: number]
+
+/**
+ * Simple Semver implementation.
+ *
+ * Suitable for Browser usage, unlike npm `semver` which is Node-targeted and simply too big for the Browser.
+ *
+ * Parsing algorithm is simple:
+ * 1. Split by `.`
+ * 2. parseInt each of 3 tokens, set to 0 if falsy
+ *
+ * toString returns `major.minor.patch`
+ * Missing tokens are replaced with 0.
+ *
+ * _semver('1').toString() === '1.0.0'
+ *
+ * @experimental
+ */
+export class Semver {
+  private constructor(public tokens: SemverTokens) {}
+
+  get major(): number {
+    return this.tokens[0]
+  }
+  get minor(): number {
+    return this.tokens[1]
+  }
+  get patch(): number {
+    return this.tokens[2]
+  }
+
+  static of(input: SemverInput): Semver {
+    const s = this.parseOrNull(input)
+
+    _assert(s !== null, `Cannot parse "${input}" into Semver`, {
+      userFriendly: true,
+      input,
+    })
+
+    return s
+  }
+
+  static parseOrNull(input: SemverInput | undefined | null): Semver | null {
+    if (!input) return null
+    if (input instanceof Semver) return input
+
+    const t = input.split('.')
+    return new Semver(_range(3).map(i => parseInt(t[i]!) || 0) as SemverTokens)
+  }
+
+  isAfter = (other: SemverInput): boolean => this.cmp(other) > 0
+  isSameOrAfter = (other: SemverInput): boolean => this.cmp(other) >= 0
+  isBefore = (other: SemverInput): boolean => this.cmp(other) < 0
+  isSameOrBefore = (other: SemverInput): boolean => this.cmp(other) <= 0
+  isSame = (other: SemverInput): boolean => this.cmp(other) === 0
+
+  /**
+   * Returns 1 if this > other
+   * returns 0 if they are equal
+   * returns -1 if this < other
+   */
+  cmp(other: SemverInput): -1 | 0 | 1 {
+    const { tokens } = Semver.of(other)
+    for (let i = 0; i < 3; i++) {
+      if (this.tokens[i]! < tokens[i]!) return -1
+      if (this.tokens[i]! > tokens[i]!) return 1
+    }
+    return 0
+  }
+
+  toJSON = (): string => this.toString()
+
+  toString(): string {
+    return this.tokens.join('.')
+  }
+}
+
+/**
+ * Shortcut for Semver.of(input)
+ */
+export function _semver(input: SemverInput): Semver {
+  return Semver.of(input)
+}