@naturalcycles/js-lib 14.162.0 → 14.164.0

package/dist/array/array.util.d.ts

@@ -16,6 +16,25 @@ export declare function _chunk<T>(array: readonly T[], size?: number): T[][];
  * Removes duplicates from given array.
  */
 export declare function _uniq<T>(a: readonly T[]): T[];
+/**
+ * Pushes an item to an array if it's not already there.
+ * Mutates the array (same as normal `push`) and also returns it for chaining convenience.
+ *
+ * _pushUniq([1, 2, 3], 2) // => [1, 2, 3]
+ *
+ * Shortcut for:
+ * if (!a.includes(item)) a.push(item)
+ * // or
+ * a = [...new Set(a).add(item)]
+ * // or
+ * a = _uniq([...a, item])
+ */
+export declare function _pushUniq<T>(a: T[], ...items: T[]): T[];
+/**
+ * Like _pushUniq but uses a mapper to determine uniqueness (like _uniqBy).
+ * Mutates the array (same as normal `push`).
+ */
+export declare function _pushUniqBy<T>(a: T[], mapper: Mapper<T, any>, ...items: T[]): T[];
 /**
  * This method is like `_.uniq` except that it accepts `iteratee` which is
  * invoked for each element in `array` to generate the criterion by which

package/dist/array/array.util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._minByOrUndefined = exports._maxByOrUndefined = exports._minBy = exports._maxBy = exports._max = exports._maxOrUndefined = exports._min = exports._minOrUndefined = exports._lastOrUndefined = exports._last = exports._shuffle = exports._mapToObject = exports._sumBy = exports._sum = exports._difference = exports._intersection = exports._countBy = exports._dropRightWhile = exports._dropWhile = exports._takeRightWhile = exports._takeWhile = exports._findLast = exports._sortBy = exports._groupBy = exports._by = exports._uniqBy = exports._uniq = exports._chunk = void 0;
+exports._minByOrUndefined = exports._maxByOrUndefined = exports._minBy = exports._maxBy = exports._max = exports._maxOrUndefined = exports._min = exports._minOrUndefined = exports._lastOrUndefined = exports._last = exports._shuffle = exports._mapToObject = exports._sumBy = exports._sum = exports._difference = exports._intersection = exports._countBy = exports._dropRightWhile = exports._dropWhile = exports._takeRightWhile = exports._takeWhile = exports._findLast = exports._sortBy = exports._groupBy = exports._by = exports._uniqBy = exports._pushUniqBy = exports._pushUniq = exports._uniq = exports._chunk = void 0;
 const is_util_1 = require("../is.util");
 /**
  * Creates an array of elements split into groups the length of size. If collection can’t be split evenly, the
@@ -27,6 +27,43 @@ function _uniq(a) {
     return [...new Set(a)];
 }
 exports._uniq = _uniq;
+/**
+ * Pushes an item to an array if it's not already there.
+ * Mutates the array (same as normal `push`) and also returns it for chaining convenience.
+ *
+ * _pushUniq([1, 2, 3], 2) // => [1, 2, 3]
+ *
+ * Shortcut for:
+ * if (!a.includes(item)) a.push(item)
+ * // or
+ * a = [...new Set(a).add(item)]
+ * // or
+ * a = _uniq([...a, item])
+ */
+function _pushUniq(a, ...items) {
+    items.forEach(item => {
+        if (!a.includes(item))
+            a.push(item);
+    });
+    return a;
+}
+exports._pushUniq = _pushUniq;
+/**
+ * Like _pushUniq but uses a mapper to determine uniqueness (like _uniqBy).
+ * Mutates the array (same as normal `push`).
+ */
+function _pushUniqBy(a, mapper, ...items) {
+    const mappedSet = new Set(a.map((item, i) => mapper(item, i)));
+    items.forEach((item, i) => {
+        const mapped = mapper(item, i);
+        if (!mappedSet.has(mapped)) {
+            a.push(item);
+            mappedSet.add(mapped);
+        }
+    });
+    return a;
+}
+exports._pushUniqBy = _pushUniqBy;
 /**
  * This method is like `_.uniq` except that it accepts `iteratee` which is
  * invoked for each element in `array` to generate the criterion by which

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/error/error.model.d.ts

@@ -44,12 +44,16 @@ export interface ErrorData {
      * Can be used by error-reporting tools (e.g Sentry).
      * If fingerprint is defined - it'll be used INSTEAD of default fingerprint of a tool.
      * Can be used to force-group errors that are NOT needed to be split by endpoint or calling function.
+     *
+     * Sentry takes string[], but for convenience we allow to pass a singe string.
      */
-    fingerprint?: string[];
+    fingerprint?: string | string[];
     /**
      * If set to true - it'll use error.message as fingerprint,
      * so, all errors with the same message will be grouped together, even if they occurred in different places.
      * Defaults to false.
+     *
+     * @experimental
      */
     fingerprintByMessage?: boolean;
     /**

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/array/array.util.js

@@ -22,6 +22,41 @@ export function _chunk(array, size = 1) {
 export function _uniq(a) {
     return [...new Set(a)];
 }
+/**
+ * Pushes an item to an array if it's not already there.
+ * Mutates the array (same as normal `push`) and also returns it for chaining convenience.
+ *
+ * _pushUniq([1, 2, 3], 2) // => [1, 2, 3]
+ *
+ * Shortcut for:
+ * if (!a.includes(item)) a.push(item)
+ * // or
+ * a = [...new Set(a).add(item)]
+ * // or
+ * a = _uniq([...a, item])
+ */
+export function _pushUniq(a, ...items) {
+    items.forEach(item => {
+        if (!a.includes(item))
+            a.push(item);
+    });
+    return a;
+}
+/**
+ * Like _pushUniq but uses a mapper to determine uniqueness (like _uniqBy).
+ * Mutates the array (same as normal `push`).
+ */
+export function _pushUniqBy(a, mapper, ...items) {
+    const mappedSet = new Set(a.map((item, i) => mapper(item, i)));
+    items.forEach((item, i) => {
+        const mapped = mapper(item, i);
+        if (!mappedSet.has(mapped)) {
+            a.push(item);
+            mappedSet.add(mapped);
+        }
+    });
+    return a;
+}
 /**
  * This method is like `_.uniq` except that it accepts `iteratee` which is
  * invoked for each element in `array` to generate the criterion by which

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.162.0",
+  "version": "14.164.0",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",

package/src/array/array.util.ts

@@ -26,6 +26,42 @@ export function _uniq<T>(a: readonly T[]): T[] {
   return [...new Set(a)]
 }
 
+/**
+ * Pushes an item to an array if it's not already there.
+ * Mutates the array (same as normal `push`) and also returns it for chaining convenience.
+ *
+ * _pushUniq([1, 2, 3], 2) // => [1, 2, 3]
+ *
+ * Shortcut for:
+ * if (!a.includes(item)) a.push(item)
+ * // or
+ * a = [...new Set(a).add(item)]
+ * // or
+ * a = _uniq([...a, item])
+ */
+export function _pushUniq<T>(a: T[], ...items: T[]): T[] {
+  items.forEach(item => {
+    if (!a.includes(item)) a.push(item)
+  })
+  return a
+}
+
+/**
+ * Like _pushUniq but uses a mapper to determine uniqueness (like _uniqBy).
+ * Mutates the array (same as normal `push`).
+ */
+export function _pushUniqBy<T>(a: T[], mapper: Mapper<T, any>, ...items: T[]): T[] {
+  const mappedSet = new Set(a.map((item, i) => mapper(item, i)))
+  items.forEach((item, i) => {
+    const mapped = mapper(item, i)
+    if (!mappedSet.has(mapped)) {
+      a.push(item)
+      mappedSet.add(mapped)
+    }
+  })
+  return a
+}
+
 /**
  * This method is like `_.uniq` except that it accepts `iteratee` which is
  * invoked for each element in `array` to generate the criterion by which

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/error/error.model.ts

@@ -54,13 +54,17 @@ export interface ErrorData {
    * Can be used by error-reporting tools (e.g Sentry).
    * If fingerprint is defined - it'll be used INSTEAD of default fingerprint of a tool.
    * Can be used to force-group errors that are NOT needed to be split by endpoint or calling function.
+   *
+   * Sentry takes string[], but for convenience we allow to pass a singe string.
    */
-  fingerprint?: string[]
+  fingerprint?: string | string[]
 
   /**
    * If set to true - it'll use error.message as fingerprint,
    * so, all errors with the same message will be grouped together, even if they occurred in different places.
    * Defaults to false.
+   *
+   * @experimental
    */
   fingerprintByMessage?: boolean
 

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)
+}