@bgord/tools 1.1.1 → 1.1.2

package/dist/age.vo.d.ts

@@ -8,7 +8,7 @@ export declare class Age {
     static readonly MAX: number;
     private constructor();
     static fromValue(candidate: number): Age;
-    static fromBirthdateEpochMs(params: {
+    static fromBirthdateTimestamp(params: {
         birthdate: TimestampVO;
         now: TimestampVO;
     }): Age;

package/dist/age.vo.js

@@ -12,7 +12,7 @@ export class Age {
     static fromValue(candidate) {
         return new Age(AgeYears.parse(candidate));
     }
-    static fromBirthdateEpochMs(params) {
+    static fromBirthdateTimestamp(params) {
         if (params.birthdate.isAfter(params.now))
             throw new Error(AgeError.FutureBirthdate);
         return Age.fromValue(differenceInYears(params.now.ms, params.birthdate.ms));

package/dist/clock.vo.d.ts

@@ -9,7 +9,7 @@ export declare class Clock {
     private readonly minute;
     private readonly formatter;
     constructor(hour: Hour, minute: Minute, formatter?: ClockFormatter);
-    static fromEpochMs(timestamp: TimestampVO, formatter?: ClockFormatter): Clock;
+    static fromTimestamp(timestamp: TimestampVO, formatter?: ClockFormatter): Clock;
     get(): {
         hour: HourSchemaType;
         minute: MinuteSchemaType;

package/dist/clock.vo.js

@@ -10,9 +10,9 @@ export class Clock {
         this.minute = minute;
         this.formatter = formatter ?? ClockFormatters.TWENTY_FOUR_HOURS;
     }
-    static fromEpochMs(timestamp, formatter) {
-        const hour = Hour.fromEpochMs(timestamp);
-        const minute = Minute.fromEpochMs(timestamp);
+    static fromTimestamp(timestamp, formatter) {
+        const hour = Hour.fromTimestamp(timestamp);
+        const minute = Minute.fromTimestamp(timestamp);
         return new Clock(hour, minute, formatter);
     }
     get() {

package/dist/day.vo.d.ts

@@ -1,8 +1,10 @@
 import { DateRange } from "./date-range.vo";
 import { type DayIsoIdType } from "./day-iso-id.vo";
 import { TimestampVO } from "./timestamp.vo";
+import type { TimestampValueType } from "./timestamp-value.vo";
 export declare class Day extends DateRange {
     static fromTimestamp(timestamp: TimestampVO): Day;
+    static fromTimestampValue(timestamp: TimestampValueType): Day;
     static fromNow(now: TimestampVO): Day;
     static fromIsoId(isoId: DayIsoIdType): Day;
     toIsoId(): DayIsoIdType;

package/dist/day.vo.js

@@ -10,6 +10,9 @@ export class Day extends DateRange {
         const endUtc = startUtc.add(Duration.Days(1)).subtract(Duration.Ms(1));
         return new Day(startUtc, endUtc);
     }
+    static fromTimestampValue(timestamp) {
+        return Day.fromTimestamp(TimestampVO.fromValue(timestamp));
+    }
     static fromNow(now) {
         return Day.fromTimestamp(now);
     }

package/dist/hour.vo.d.ts

@@ -1,12 +1,14 @@
 import { type HourFormatter } from "./hour-format.service";
 import { type HourSchemaType } from "./hour-schema.vo";
-import type { TimestampVO } from "./timestamp.vo";
+import { TimestampVO } from "./timestamp.vo";
+import type { TimestampValueType } from "./timestamp-value.vo";
 export declare class Hour {
     private readonly value;
     static readonly ZERO: Hour;
     static readonly MAX: Hour;
     constructor(candidate: number);
-    static fromEpochMs(timestamp: TimestampVO): Hour;
+    static fromTimestamp(timestamp: TimestampVO): Hour;
+    static fromTimestampValue(timestamp: TimestampValueType): Hour;
     get(): HourSchemaType;
     format(formatter: HourFormatter): string;
     equals(another: Hour): boolean;

package/dist/hour.vo.js

@@ -1,5 +1,6 @@
 import { HourFormatters } from "./hour-format.service";
 import { HourSchema } from "./hour-schema.vo";
+import { TimestampVO } from "./timestamp.vo";
 export class Hour {
     value;
     static ZERO = new Hour(0);
@@ -7,9 +8,12 @@ export class Hour {
     constructor(candidate) {
         this.value = HourSchema.parse(candidate);
     }
-    static fromEpochMs(timestamp) {
+    static fromTimestamp(timestamp) {
         return new Hour(new Date(timestamp.ms).getUTCHours());
     }
+    static fromTimestampValue(timestamp) {
+        return Hour.fromTimestamp(TimestampVO.fromValue(timestamp));
+    }
     get() {
         return this.value;
     }

package/dist/minute.vo.d.ts

@@ -1,11 +1,13 @@
 import { type MinuteSchemaType } from "./minute-schema.vo";
-import type { TimestampVO } from "./timestamp.vo";
+import { TimestampVO } from "./timestamp.vo";
+import type { TimestampValueType } from "./timestamp-value.vo";
 export declare class Minute {
     private readonly value;
     static readonly ZERO: Minute;
     static readonly MAX: Minute;
     constructor(candidate: number);
-    static fromEpochMs(timestamp: TimestampVO): Minute;
+    static fromTimestamp(timestamp: TimestampVO): Minute;
+    static fromTimestampValue(timestamp: TimestampValueType): Minute;
     get(): MinuteSchemaType;
     equals(another: Minute): boolean;
     isAfter(another: Minute): boolean;

package/dist/minute.vo.js

@@ -1,4 +1,5 @@
 import { MinuteSchema } from "./minute-schema.vo";
+import { TimestampVO } from "./timestamp.vo";
 export class Minute {
     value;
     static ZERO = new Minute(0);
@@ -6,9 +7,12 @@ export class Minute {
     constructor(candidate) {
         this.value = MinuteSchema.parse(candidate);
     }
-    static fromEpochMs(timestamp) {
+    static fromTimestamp(timestamp) {
         return new Minute(new Date(timestamp.ms).getUTCMinutes());
     }
+    static fromTimestampValue(timestamp) {
+        return Minute.fromTimestamp(TimestampVO.fromValue(timestamp));
+    }
     get() {
         return this.value;
     }

package/dist/month.vo.d.ts

@@ -1,8 +1,10 @@
 import { DateRange } from "./date-range.vo";
 import { type MonthIsoIdType } from "./month-iso-id.vo";
 import { TimestampVO } from "./timestamp.vo";
+import type { TimestampValueType } from "./timestamp-value.vo";
 export declare class Month extends DateRange {
     static fromTimestamp(timestamp: TimestampVO): Month;
+    static fromTimestampValue(timestamp: TimestampValueType): Month;
     static fromNow(now: TimestampVO): Month;
     static fromIsoId(iso: MonthIsoIdType): Month;
     toIsoId(): MonthIsoIdType;

package/dist/month.vo.js

@@ -8,6 +8,9 @@ export class Month extends DateRange {
         const end = TimestampVO.fromNumber(endOfMonth(timestamp.ms).getTime());
         return new Month(start, end);
     }
+    static fromTimestampValue(timestamp) {
+        return Month.fromTimestamp(TimestampVO.fromValue(timestamp));
+    }
     static fromNow(now) {
         return Month.fromTimestamp(now);
     }

package/dist/quarter.vo.d.ts

@@ -1,8 +1,10 @@
 import { DateRange } from "./date-range.vo";
 import { type QuarterIsoIdType } from "./quarter-iso-id.vo";
 import { TimestampVO } from "./timestamp.vo";
+import type { TimestampValueType } from "./timestamp-value.vo";
 export declare class Quarter extends DateRange {
     static fromTimestamp(timestamp: TimestampVO): Quarter;
+    static fromTimestampValue(timestamp: TimestampValueType): Quarter;
     static fromNow(now: TimestampVO): Quarter;
     static fromIsoId(isoId: QuarterIsoIdType): Quarter;
     toIsoId(): QuarterIsoIdType;

package/dist/quarter.vo.js

@@ -8,6 +8,9 @@ export class Quarter extends DateRange {
         const end = TimestampVO.fromNumber(endOfQuarter(timestamp.ms).getTime());
         return new Quarter(start, end);
     }
+    static fromTimestampValue(timestamp) {
+        return Quarter.fromTimestamp(TimestampVO.fromValue(timestamp));
+    }
     static fromNow(now) {
         return Quarter.fromTimestamp(now);
     }

package/dist/week.vo.d.ts

@@ -1,8 +1,10 @@
 import { DateRange } from "./date-range.vo";
 import { TimestampVO } from "./timestamp.vo";
+import type { TimestampValueType } from "./timestamp-value.vo";
 import { type WeekIsoIdType } from "./week-iso-id.vo";
 export declare class Week extends DateRange {
     static fromTimestamp(timestamp: TimestampVO): Week;
+    static fromTimestampValue(timestamp: TimestampValueType): Week;
     static fromNow(now: TimestampVO): Week;
     static fromIsoId(isoId: WeekIsoIdType): Week;
     toIsoId(): WeekIsoIdType;

package/dist/week.vo.js

@@ -8,6 +8,9 @@ export class Week extends DateRange {
         const end = TimestampVO.fromNumber(endOfISOWeek(timestamp.ms).getTime());
         return new Week(start, end);
     }
+    static fromTimestampValue(timestamp) {
+        return Week.fromTimestamp(TimestampVO.fromValue(timestamp));
+    }
     static fromNow(now) {
         return Week.fromTimestamp(now);
     }

package/dist/weekday.vo.d.ts

@@ -1,4 +1,5 @@
-import type { TimestampVO } from "./timestamp.vo";
+import { TimestampVO } from "./timestamp.vo";
+import type { TimestampValueType } from "./timestamp-value.vo";
 export type WeekdayFormatter = (value: Weekday["value"]) => string;
 export declare enum WeekdayFormatterEnum {
     FULL = "FULL",// "Sunday"
@@ -19,7 +20,8 @@ export declare class Weekday {
     static readonly FRIDAY: Weekday;
     static readonly SATURDAY: Weekday;
     constructor(candidate: number, formatter?: WeekdayFormatter);
-    static fromUtcTimestamp(timestamp: TimestampVO, formatter?: WeekdayFormatter): Weekday;
+    static fromTimestamp(timestamp: TimestampVO, formatter?: WeekdayFormatter): Weekday;
+    static fromTimestampValue(timestamp: TimestampValueType): Weekday;
     get(): number;
     format(): string;
     toString(): string;

package/dist/weekday.vo.js

@@ -1,3 +1,4 @@
+import { TimestampVO } from "./timestamp.vo";
 export var WeekdayFormatterEnum;
 (function (WeekdayFormatterEnum) {
     WeekdayFormatterEnum["FULL"] = "FULL";
@@ -40,10 +41,13 @@ export class Weekday {
         this.value = candidate;
         this.formatter = formatter ?? WeekdayFormatters.FULL;
     }
-    static fromUtcTimestamp(timestamp, formatter) {
+    static fromTimestamp(timestamp, formatter) {
         const dayZeroBased = new Date(timestamp.ms).getUTCDay(); // 0..6
         return new Weekday(dayZeroBased, formatter);
     }
+    static fromTimestampValue(timestamp) {
+        return Weekday.fromTimestamp(TimestampVO.fromValue(timestamp));
+    }
     get() {
         return this.value;
     }

package/dist/year.vo.d.ts

@@ -1,8 +1,10 @@
 import { DateRange } from "./date-range.vo";
 import { TimestampVO } from "./timestamp.vo";
+import type { TimestampValueType } from "./timestamp-value.vo";
 import { type YearIsoIdType } from "./year-iso-id.vo";
 export declare class Year extends DateRange {
     static fromTimestamp(timestamp: TimestampVO): Year;
+    static fromTimestampValue(timestamp: TimestampValueType): Year;
     static fromNow(now: TimestampVO): Year;
     static fromNumber(candidate: number): Year;
     static fromIsoId(isoId: YearIsoIdType): Year;

package/dist/year.vo.js

@@ -8,6 +8,9 @@ export class Year extends DateRange {
         const end = TimestampVO.fromNumber(endOfYear(timestamp.ms).getTime());
         return new Year(start, end);
     }
+    static fromTimestampValue(timestamp) {
+        return Year.fromTimestamp(TimestampVO.fromValue(timestamp));
+    }
     static fromNow(now) {
         return Year.fromTimestamp(now);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/tools",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "type": "module",
   "license": "MIT",
   "author": "Bartosz Gordon",
@@ -27,7 +27,7 @@
     "@types/bun": "1.3.1",
     "@types/mime-types": "3.0.1",
     "cspell": "9.2.2",
-    "knip": "5.66.4",
+    "knip": "5.67.0",
     "lefthook": "2.0.2",
     "only-allow": "1.2.1",
     "shellcheck": "4.1.0",

package/src/age.vo.ts

@@ -14,7 +14,7 @@ export class Age {
     return new Age(AgeYears.parse(candidate));
   }
 
-  static fromBirthdateEpochMs(params: { birthdate: TimestampVO; now: TimestampVO }): Age {
+  static fromBirthdateTimestamp(params: { birthdate: TimestampVO; now: TimestampVO }): Age {
     if (params.birthdate.isAfter(params.now)) throw new Error(AgeError.FutureBirthdate);
     return Age.fromValue(differenceInYears(params.now.ms, params.birthdate.ms));
   }

package/src/clock.vo.ts

@@ -16,9 +16,9 @@ export class Clock {
     this.formatter = formatter ?? ClockFormatters.TWENTY_FOUR_HOURS;
   }
 
-  static fromEpochMs(timestamp: TimestampVO, formatter?: ClockFormatter): Clock {
-    const hour = Hour.fromEpochMs(timestamp);
-    const minute = Minute.fromEpochMs(timestamp);
+  static fromTimestamp(timestamp: TimestampVO, formatter?: ClockFormatter): Clock {
+    const hour = Hour.fromTimestamp(timestamp);
+    const minute = Minute.fromTimestamp(timestamp);
 
     return new Clock(hour, minute, formatter);
   }

package/src/day.vo.ts

@@ -3,6 +3,7 @@ import { DateRange } from "./date-range.vo";
 import { DayIsoId, type DayIsoIdType } from "./day-iso-id.vo";
 import { Duration } from "./duration.service";
 import { TimestampVO } from "./timestamp.vo";
+import type { TimestampValueType } from "./timestamp-value.vo";
 
 export class Day extends DateRange {
   static fromTimestamp(timestamp: TimestampVO): Day {
@@ -16,6 +17,10 @@ export class Day extends DateRange {
     return new Day(startUtc, endUtc);
   }
 
+  static fromTimestampValue(timestamp: TimestampValueType): Day {
+    return Day.fromTimestamp(TimestampVO.fromValue(timestamp));
+  }
+
   static fromNow(now: TimestampVO): Day {
     return Day.fromTimestamp(now);
   }

package/src/hour.vo.ts

@@ -1,6 +1,7 @@
 import { type HourFormatter, HourFormatters } from "./hour-format.service";
 import { HourSchema, type HourSchemaType } from "./hour-schema.vo";
-import type { TimestampVO } from "./timestamp.vo";
+import { TimestampVO } from "./timestamp.vo";
+import type { TimestampValueType } from "./timestamp-value.vo";
 
 export class Hour {
   private readonly value: HourSchemaType;
@@ -12,10 +13,14 @@ export class Hour {
     this.value = HourSchema.parse(candidate);
   }
 
-  static fromEpochMs(timestamp: TimestampVO): Hour {
+  static fromTimestamp(timestamp: TimestampVO): Hour {
     return new Hour(new Date(timestamp.ms).getUTCHours());
   }
 
+  static fromTimestampValue(timestamp: TimestampValueType): Hour {
+    return Hour.fromTimestamp(TimestampVO.fromValue(timestamp));
+  }
+
   get(): HourSchemaType {
     return this.value;
   }

package/src/minute.vo.ts

@@ -1,5 +1,6 @@
 import { MinuteSchema, type MinuteSchemaType } from "./minute-schema.vo";
-import type { TimestampVO } from "./timestamp.vo";
+import { TimestampVO } from "./timestamp.vo";
+import type { TimestampValueType } from "./timestamp-value.vo";
 
 export class Minute {
   private readonly value: MinuteSchemaType;
@@ -11,10 +12,14 @@ export class Minute {
     this.value = MinuteSchema.parse(candidate);
   }
 
-  static fromEpochMs(timestamp: TimestampVO): Minute {
+  static fromTimestamp(timestamp: TimestampVO): Minute {
     return new Minute(new Date(timestamp.ms).getUTCMinutes());
   }
 
+  static fromTimestampValue(timestamp: TimestampValueType): Minute {
+    return Minute.fromTimestamp(TimestampVO.fromValue(timestamp));
+  }
+
   get(): MinuteSchemaType {
     return this.value;
   }

package/src/month.vo.ts

@@ -2,6 +2,7 @@ import { endOfMonth, format, getMonth, setMonth, startOfMonth } from "date-fns";
 import { DateRange } from "./date-range.vo";
 import { MonthIsoId, type MonthIsoIdType } from "./month-iso-id.vo";
 import { TimestampVO } from "./timestamp.vo";
+import type { TimestampValueType } from "./timestamp-value.vo";
 
 export class Month extends DateRange {
   static fromTimestamp(timestamp: TimestampVO): Month {
@@ -11,6 +12,10 @@ export class Month extends DateRange {
     return new Month(start, end);
   }
 
+  static fromTimestampValue(timestamp: TimestampValueType): Month {
+    return Month.fromTimestamp(TimestampVO.fromValue(timestamp));
+  }
+
   static fromNow(now: TimestampVO): Month {
     return Month.fromTimestamp(now);
   }

package/src/quarter.vo.ts

@@ -2,6 +2,7 @@ import { endOfQuarter, getQuarter, getYear, setQuarter, startOfQuarter } from "d
 import { DateRange } from "./date-range.vo";
 import { QuarterIsoId, type QuarterIsoIdType } from "./quarter-iso-id.vo";
 import { TimestampVO } from "./timestamp.vo";
+import type { TimestampValueType } from "./timestamp-value.vo";
 
 export class Quarter extends DateRange {
   static fromTimestamp(timestamp: TimestampVO): Quarter {
@@ -11,6 +12,10 @@ export class Quarter extends DateRange {
     return new Quarter(start, end);
   }
 
+  static fromTimestampValue(timestamp: TimestampValueType): Quarter {
+    return Quarter.fromTimestamp(TimestampVO.fromValue(timestamp));
+  }
+
   static fromNow(now: TimestampVO): Quarter {
     return Quarter.fromTimestamp(now);
   }

package/src/week.vo.ts

@@ -1,6 +1,7 @@
 import { addWeeks, endOfISOWeek, getISOWeek, getISOWeekYear, setISOWeek, startOfISOWeek } from "date-fns";
 import { DateRange } from "./date-range.vo";
 import { TimestampVO } from "./timestamp.vo";
+import type { TimestampValueType } from "./timestamp-value.vo";
 import { WeekIsoId, type WeekIsoIdType } from "./week-iso-id.vo";
 
 export class Week extends DateRange {
@@ -11,6 +12,10 @@ export class Week extends DateRange {
     return new Week(start, end);
   }
 
+  static fromTimestampValue(timestamp: TimestampValueType): Week {
+    return Week.fromTimestamp(TimestampVO.fromValue(timestamp));
+  }
+
   static fromNow(now: TimestampVO): Week {
     return Week.fromTimestamp(now);
   }

package/src/weekday.vo.ts

@@ -1,4 +1,5 @@
-import type { TimestampVO } from "./timestamp.vo";
+import { TimestampVO } from "./timestamp.vo";
+import type { TimestampValueType } from "./timestamp-value.vo";
 
 export type WeekdayFormatter = (value: Weekday["value"]) => string;
 
@@ -52,11 +53,15 @@ export class Weekday {
     this.formatter = formatter ?? WeekdayFormatters.FULL;
   }
 
-  static fromUtcTimestamp(timestamp: TimestampVO, formatter?: WeekdayFormatter): Weekday {
+  static fromTimestamp(timestamp: TimestampVO, formatter?: WeekdayFormatter): Weekday {
     const dayZeroBased = new Date(timestamp.ms).getUTCDay(); // 0..6
     return new Weekday(dayZeroBased, formatter);
   }
 
+  static fromTimestampValue(timestamp: TimestampValueType): Weekday {
+    return Weekday.fromTimestamp(TimestampVO.fromValue(timestamp));
+  }
+
   get(): number {
     return this.value;
   }

package/src/year.vo.ts

@@ -1,6 +1,7 @@
 import { addYears, endOfYear, getYear, startOfYear } from "date-fns";
 import { DateRange } from "./date-range.vo";
 import { TimestampVO } from "./timestamp.vo";
+import type { TimestampValueType } from "./timestamp-value.vo";
 import { YearIsoId, type YearIsoIdType } from "./year-iso-id.vo";
 
 export class Year extends DateRange {
@@ -11,6 +12,10 @@ export class Year extends DateRange {
     return new Year(start, end);
   }
 
+  static fromTimestampValue(timestamp: TimestampValueType): Year {
+    return Year.fromTimestamp(TimestampVO.fromValue(timestamp));
+  }
+
   static fromNow(now: TimestampVO): Year {
     return Year.fromTimestamp(now);
   }