@bgord/tools 1.0.5 → 1.1.0

package/src/timestamp.vo.ts

@@ -1,11 +1,54 @@
-import { z } from "zod/v4";
+import type { Duration } from "./duration.service";
+import { TimestampValue, type TimestampValueType } from "./timestamp-value.vo";
 
-export const TimestampError = { Invalid: "timestamp.invalid" } as const;
+export class Timestamp {
+  constructor(private readonly value: TimestampValueType) {}
 
-export const Timestamp = z
-  .number(TimestampError.Invalid)
-  .int(TimestampError.Invalid)
-  .gte(0, TimestampError.Invalid)
-  .brand("Timestamp");
+  static fromValue(value: TimestampValueType): Timestamp {
+    return new Timestamp(value);
+  }
 
-export type TimestampType = z.infer<typeof Timestamp>;
+  static fromNumber(value: number): Timestamp {
+    return new Timestamp(TimestampValue.parse(value));
+  }
+
+  add(duration: Duration): Timestamp {
+    return Timestamp.fromNumber(this.value + duration.ms);
+  }
+
+  subtract(duration: Duration): Timestamp {
+    return Timestamp.fromNumber(this.value - duration.ms);
+  }
+
+  isBefore(another: Timestamp): boolean {
+    return this.value < another.value;
+  }
+
+  isBeforeOrEqual(another: Timestamp): boolean {
+    return this.value <= another.value;
+  }
+
+  isAfter(another: Timestamp): boolean {
+    return this.value > another.value;
+  }
+
+  isAfterOrEqual(another: Timestamp): boolean {
+    return this.value >= another.value;
+  }
+
+  equals(another: Timestamp): boolean {
+    return this.value === another.value;
+  }
+
+  get(): TimestampValueType {
+    return this.value;
+  }
+
+  toJSON(): TimestampValueType {
+    return this.value;
+  }
+
+  toString(): string {
+    return this.value.toString();
+  }
+}

package/src/week.vo.ts

@@ -1,17 +1,17 @@
 import { addWeeks, endOfISOWeek, getISOWeek, getISOWeekYear, setISOWeek, startOfISOWeek } from "date-fns";
 import { DateRange } from "./date-range.vo";
-import { Timestamp, type TimestampType } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 import { WeekIsoId, type WeekIsoIdType } from "./week-iso-id.vo";
 
 export class Week extends DateRange {
-  static fromTimestamp(timestamp: TimestampType): Week {
-    const start = Timestamp.parse(startOfISOWeek(timestamp).getTime());
-    const end = Timestamp.parse(endOfISOWeek(timestamp).getTime());
+  static fromTimestamp(timestamp: Timestamp): Week {
+    const start = Timestamp.fromNumber(startOfISOWeek(timestamp.get()).getTime());
+    const end = Timestamp.fromNumber(endOfISOWeek(timestamp.get()).getTime());
 
     return new Week(start, end);
   }
 
-  static fromNow(now: TimestampType): Week {
+  static fromNow(now: Timestamp): Week {
     return Week.fromTimestamp(now);
   }
 
@@ -21,12 +21,12 @@ export class Week extends DateRange {
     // ISO-8601 rule: Jan 4 is always in week 01 of the ISO week-year.
     const reference = setISOWeek(Date.UTC(year, 0, 4), week).getTime();
 
-    return Week.fromTimestamp(Timestamp.parse(reference));
+    return Week.fromTimestamp(Timestamp.fromNumber(reference));
   }
 
   toIsoId(): WeekIsoIdType {
-    const year = getISOWeekYear(this.getStart());
-    const week = getISOWeek(this.getStart());
+    const year = getISOWeekYear(this.getStart().get());
+    const week = getISOWeek(this.getStart().get());
 
     return WeekIsoId.parse(`${year}-W${String(week).padStart(2, "0")}`);
   }
@@ -40,9 +40,9 @@ export class Week extends DateRange {
   }
 
   shift(count: number): Week {
-    const shifted = addWeeks(this.getStart(), count).getTime();
+    const shifted = addWeeks(this.getStart().get(), count).getTime();
 
-    return Week.fromTimestamp(Timestamp.parse(shifted));
+    return Week.fromTimestamp(Timestamp.fromNumber(shifted));
   }
 
   toString(): string {

package/src/weekday.vo.ts

@@ -1,4 +1,4 @@
-import type { TimestampType } from "./timestamp.vo";
+import type { Timestamp } from "./timestamp.vo";
 
 export type WeekdayFormatter = (value: Weekday["value"]) => string;
 
@@ -52,8 +52,8 @@ export class Weekday {
     this.formatter = formatter ?? WeekdayFormatters.FULL;
   }
 
-  static fromUtcTimestamp(timestamp: TimestampType, formatter?: WeekdayFormatter): Weekday {
-    const dayZeroBased = new Date(timestamp).getUTCDay(); // 0..6
+  static fromUtcTimestamp(timestamp: Timestamp, formatter?: WeekdayFormatter): Weekday {
+    const dayZeroBased = new Date(timestamp.get()).getUTCDay(); // 0..6
     return new Weekday(dayZeroBased, formatter);
   }
 

package/src/year.vo.ts

@@ -1,17 +1,17 @@
 import { addYears, endOfYear, getYear, startOfYear } from "date-fns";
 import { DateRange } from "./date-range.vo";
-import { Timestamp, type TimestampType } from "./timestamp.vo";
+import { Timestamp } from "./timestamp.vo";
 import { YearIsoId, type YearIsoIdType } from "./year-iso-id.vo";
 
 export class Year extends DateRange {
-  static fromTimestamp(timestamp: TimestampType): Year {
-    const start = Timestamp.parse(startOfYear(timestamp).getTime());
-    const end = Timestamp.parse(endOfYear(timestamp).getTime());
+  static fromTimestamp(timestamp: Timestamp): Year {
+    const start = Timestamp.fromNumber(startOfYear(timestamp.get()).getTime());
+    const end = Timestamp.fromNumber(endOfYear(timestamp.get()).getTime());
 
     return new Year(start, end);
   }
 
-  static fromNow(now: TimestampType): Year {
+  static fromNow(now: Timestamp): Year {
     return Year.fromTimestamp(now);
   }
 
@@ -22,15 +22,15 @@ export class Year extends DateRange {
   static fromIsoId(isoId: YearIsoIdType): Year {
     const reference = Date.UTC(Number(isoId));
 
-    return Year.fromTimestamp(Timestamp.parse(reference));
+    return Year.fromTimestamp(Timestamp.fromNumber(reference));
   }
 
   toIsoId(): YearIsoIdType {
-    return YearIsoId.parse(String(getYear(this.getStart())));
+    return YearIsoId.parse(String(getYear(this.getStart().get())));
   }
 
   isLeapYear(): boolean {
-    const year = getYear(this.getStart());
+    const year = getYear(this.getStart().get());
 
     return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
   }
@@ -44,9 +44,9 @@ export class Year extends DateRange {
   }
 
   shift(count: number): Year {
-    const shifted = addYears(this.getStart(), count).getTime();
+    const shifted = addYears(this.getStart().get(), count).getTime();
 
-    return Year.fromTimestamp(Timestamp.parse(shifted));
+    return Year.fromTimestamp(Timestamp.fromNumber(shifted));
   }
 
   toString(): string {

package/dist/time.service.d.ts

@@ -1,8 +0,0 @@
-import type { Duration } from "./duration.service";
-import { type TimestampType } from "./timestamp.vo";
-export declare const Time: {
-    Now(now: TimestampType): {
-        Add(duration: Duration): TimestampType;
-        Minus(duration: Duration): TimestampType;
-    };
-};

package/dist/time.service.js

@@ -1,13 +0,0 @@
-import { Timestamp } from "./timestamp.vo";
-export const Time = {
-    Now(now) {
-        return {
-            Add(duration) {
-                return Timestamp.parse(now + duration.ms);
-            },
-            Minus(duration) {
-                return Timestamp.parse(now - duration.ms);
-            },
-        };
-    },
-};

package/src/time.service.ts

@@ -1,15 +0,0 @@
-import type { Duration } from "./duration.service";
-import { Timestamp, type TimestampType } from "./timestamp.vo";
-
-export const Time = {
-  Now(now: TimestampType) {
-    return {
-      Add(duration: Duration): TimestampType {
-        return Timestamp.parse(now + duration.ms);
-      },
-      Minus(duration: Duration): TimestampType {
-        return Timestamp.parse(now - duration.ms);
-      },
-    };
-  },
-};