@bgord/tools 0.15.1 → 0.16.0

package/dist/reordering.service.d.ts

@@ -1,13 +1,31 @@
 import { z } from "zod/v4";
+export declare const ReorderingPositionError: {
+    readonly error: "reordering.position.invalid";
+};
+export declare const ReorderingCannotFindItemError: {
+    readonly error: "reordering.item.not_found";
+};
+export declare const ReorderingCannotFindCurrentError: {
+    readonly error: "reordering.current_item.not_found";
+};
+export declare const ReorderingCannotFindTargetError: {
+    readonly error: "reordering.target_item.not_found";
+};
+export declare const ReorderingCorrelationIdError: {
+    readonly error: "reordering.correlation_id.invalid";
+};
+export declare const ReorderingItemIdError: {
+    readonly error: "reordering.item_id.invalid";
+};
 export declare const ReorderingItemPositionValue: z.ZodNumber;
 export type ReorderingItemPositionValueType = z.infer<typeof ReorderingItemPositionValue>;
 export declare const ReorderingCorrelationId: z.ZodString;
 export type ReorderingCorrelationIdType = z.infer<typeof ReorderingCorrelationId>;
-export declare const ReorderingItemId: z.ZodUUID;
+export declare const ReorderingItemId: z.ZodString;
 export type ReorderingItemIdType = z.infer<typeof ReorderingItemId>;
 export declare const Reordering: z.ZodObject<{
     correlationId: z.ZodString;
-    id: z.ZodUUID;
+    id: z.ZodString;
     position: z.ZodNumber;
 }, z.core.$strip>;
 export type ReorderingType = z.infer<typeof Reordering>;

package/dist/reordering.service.js

@@ -1,8 +1,19 @@
 import { z } from "zod/v4";
 import { DoublyLinkedList, Node } from "./dll.service";
-export const ReorderingItemPositionValue = z.number().int().min(0);
-export const ReorderingCorrelationId = z.string().min(1);
-export const ReorderingItemId = z.uuid();
+export const ReorderingPositionError = { error: "reordering.position.invalid" };
+export const ReorderingCannotFindItemError = { error: "reordering.item.not_found" };
+export const ReorderingCannotFindCurrentError = { error: "reordering.current_item.not_found" };
+export const ReorderingCannotFindTargetError = { error: "reordering.target_item.not_found" };
+export const ReorderingCorrelationIdError = { error: "reordering.correlation_id.invalid" };
+export const ReorderingItemIdError = { error: "reordering.item_id.invalid" };
+export const ReorderingItemPositionValue = z
+    .number(ReorderingPositionError)
+    .int(ReorderingPositionError)
+    .min(0, ReorderingPositionError);
+export const ReorderingCorrelationId = z
+    .string(ReorderingCorrelationIdError)
+    .min(1, ReorderingCorrelationIdError);
+export const ReorderingItemId = z.string(ReorderingItemIdError);
 export const Reordering = z.object({
     correlationId: ReorderingCorrelationId,
     id: ReorderingItemId,
@@ -11,9 +22,9 @@ export const Reordering = z.object({
 export class ReorderingPosition {
     value;
     constructor(value) {
-        if (!ReorderingItemPositionValue.safeParse(value).success) {
-            throw new Error("Position is not a positive integer");
-        }
+        const parsed = ReorderingItemPositionValue.safeParse(value);
+        if (!parsed.success)
+            throw new Error(ReorderingPositionError.error);
         this.value = value;
     }
     eq(another) {
@@ -41,15 +52,16 @@ export class ReorderingTransfer {
     id;
     to;
     constructor(config) {
-        this.id = config.id;
-        this.to = new ReorderingPosition(config.to);
+        const id = config.id;
+        const to = new ReorderingPosition(config.to);
+        this.id = id;
+        this.to = to;
     }
     getDirection(currentPosition) {
         if (this.to.value === currentPosition.value)
             return ReorderingTransferDirection.noop;
-        if (this.to.value > currentPosition.value) {
+        if (this.to.value > currentPosition.value)
             return ReorderingTransferDirection.downwards;
-        }
         return ReorderingTransferDirection.upwards;
     }
 }
@@ -66,54 +78,62 @@ export class ReorderingCalculator {
         return reordering;
     }
     add(id) {
-        const position = new ReorderingPosition(ReorderingItemPositionValue.parse(this.dll.getSize()));
+        const size = this.dll.getSize();
+        const position = new ReorderingPosition(ReorderingItemPositionValue.parse(size));
         const item = new ReorderingItem(id, position);
-        this.dll.append(new Node(item));
+        const node = new Node(item);
+        this.dll.append(node);
         return item;
     }
     delete(id) {
-        const item = this.dll.find((x) => x.data.eq(id));
-        if (!item)
-            throw new Error("Cannot find Item");
-        this.dll.remove(item);
+        const node = this.dll.find((x) => x.data.eq(id));
+        if (!node)
+            throw new Error(ReorderingCannotFindItemError.error);
+        this.dll.remove(node);
         this.recalculate();
     }
     transfer(transfer) {
         const current = this.dll.find((node) => node.data.eq(transfer.id));
-        const target = this.dll.find((node) => node.data.position.eq(transfer.to));
         if (!current)
-            throw new Error("Cannot find current Item");
+            throw new Error(ReorderingCannotFindCurrentError.error);
+        const target = this.dll.find((node) => node.data.position.eq(transfer.to));
         if (!target)
-            throw new Error("Cannot find target Item");
+            throw new Error(ReorderingCannotFindTargetError.error);
         const direction = transfer.getDirection(current.data.position);
         if (direction === ReorderingTransferDirection.noop)
             return this.read();
+        // remove first to avoid temporary invalid duplicates of positions
+        this.dll.remove(current);
         if (direction === ReorderingTransferDirection.upwards) {
-            this.dll.remove(current);
             this.dll.insertBefore(current, target);
-            this.recalculate();
         }
-        if (direction === ReorderingTransferDirection.downwards) {
-            this.dll.remove(current);
+        else {
             this.dll.insertAfter(current, target);
-            this.recalculate();
         }
+        this.recalculate();
         return this.read();
     }
     read() {
-        const ids = Array.from(this.dll).map((item) => item.data.id);
-        const items = Array.from(this.dll).map((item) => item.data);
+        const ids = Array.from(this.dll).map((node) => node.data.id);
+        const items = Array.from(this.dll).map((node) => node.data);
         return { ids, items };
     }
     recalculate() {
-        this.dll = ReorderingCalculator.fromArray(this.read().ids).dll;
+        let index = 0;
+        for (const node of this.dll) {
+            const id = node.data.id;
+            const position = new ReorderingPosition(index);
+            node.data = new ReorderingItem(id, position);
+            index += 1;
+        }
     }
 }
 export class ReorderingIntegrator {
     static appendPosition(reordering) {
         return function (item) {
-            const position = ReorderingItemPositionValue.parse(reordering.find((x) => x.id === item.id)?.position ?? 0);
-            return { ...item, position };
+            const found = reordering.find((x) => x.id === item.id);
+            const positionValue = ReorderingItemPositionValue.parse(found?.position ?? 0);
+            return { ...item, position: positionValue };
         };
     }
     static sortByPosition() {

package/dist/revision.vo.d.ts

@@ -1,12 +1,17 @@
 import { z } from "zod/v4";
 import type { ETag, WeakETag } from "./etags.vo";
-export declare const RevisionValue: z.ZodNumber;
+export declare const RevisionValueError: {
+    readonly error: "invalid.revision.value";
+};
+export declare const RevisionValue: z.core.$ZodBranded<z.ZodNumber, "RevisionValue">;
 export type RevisionValueType = z.infer<typeof RevisionValue>;
+export declare const RevisionInvalidErrorMessage: "revision.invalid";
+export declare const RevisionMismatchErrorMessage: "revision.mismatch";
 export declare class Revision {
+    static readonly INITIAL: RevisionValueType;
     readonly value: RevisionValueType;
-    static initial: RevisionValueType;
     constructor(value: unknown);
-    matches(another: RevisionValueType): boolean;
+    equals(another: RevisionValueType): boolean;
     validate(another: RevisionValueType): void;
     next(): Revision;
     static fromETag(etag: ETag | null): Revision;

package/dist/revision.vo.js

@@ -1,19 +1,26 @@
 import { z } from "zod/v4";
-export const RevisionValue = z.number().int().min(0);
+export const RevisionValueError = { error: "invalid.revision.value" };
+export const RevisionValue = z
+    .number(RevisionValueError)
+    .int(RevisionValueError)
+    .min(0, RevisionValueError)
+    .brand("RevisionValue");
+export const RevisionInvalidErrorMessage = "revision.invalid";
+export const RevisionMismatchErrorMessage = "revision.mismatch";
 export class Revision {
+    static INITIAL = RevisionValue.parse(0);
     value;
-    static initial = 0;
     constructor(value) {
         const result = RevisionValue.safeParse(value);
         if (!result.success)
             throw new InvalidRevisionError();
         this.value = result.data;
     }
-    matches(another) {
+    equals(another) {
         return this.value === another;
     }
     validate(another) {
-        if (!this.matches(another))
+        if (!this.equals(another))
             throw new RevisionMismatchError();
     }
     next() {
@@ -32,13 +39,13 @@ export class Revision {
 }
 export class RevisionMismatchError extends Error {
     constructor() {
-        super();
+        super(RevisionMismatchErrorMessage);
         Object.setPrototypeOf(this, RevisionMismatchError.prototype);
     }
 }
 export class InvalidRevisionError extends Error {
     constructor() {
-        super();
+        super(RevisionInvalidErrorMessage);
         Object.setPrototypeOf(this, InvalidRevisionError.prototype);
     }
 }

package/dist/rounding.adapter.js

@@ -18,9 +18,8 @@ export class RoundToDecimal {
     decimals;
     constructor(decimals) {
         this.decimals = decimals;
-        if (!Number.isInteger(decimals) || decimals < 0 || decimals > 100) {
+        if (!Number.isInteger(decimals) || decimals < 0 || decimals > 100)
             throw new Error(RoundingDecimalsError);
-        }
     }
     round(value) {
         return Number.parseFloat(value.toFixed(this.decimals));

package/dist/size.vo.d.ts

@@ -18,6 +18,7 @@ export declare class Size {
     private static readonly KB_MULTIPLIER;
     private static readonly MB_MULTIPLIER;
     private static readonly GB_MULTIPLIER;
+    private static readonly ROUNDER;
     constructor(config: SizeConfigType);
     static fromBytes(candidate: number): Size;
     static fromKb(candidate: number): Size;

package/dist/size.vo.js

@@ -15,6 +15,7 @@ export class Size {
     static KB_MULTIPLIER = 1024;
     static MB_MULTIPLIER = 1024 * Size.KB_MULTIPLIER;
     static GB_MULTIPLIER = 1024 * Size.MB_MULTIPLIER;
+    static ROUNDER = new RoundToDecimal(2);
     constructor(config) {
         this.unit = config.unit;
         this.value = SizeValue.parse(config.value);
@@ -46,19 +47,15 @@ export class Size {
         return this.bytes > another.toBytes();
     }
     format(unit) {
-        const rounding = new RoundToDecimal(2);
         switch (unit) {
             case SizeUnit.kB: {
-                const kbs = rounding.round(this.bytes / Size.KB_MULTIPLIER);
-                return `${kbs} ${SizeUnit.kB}`;
+                return `${Size.ROUNDER.round(this.bytes / Size.KB_MULTIPLIER)} ${SizeUnit.kB}`;
             }
             case SizeUnit.MB: {
-                const mbs = rounding.round(this.bytes / Size.MB_MULTIPLIER);
-                return `${mbs} ${SizeUnit.MB}`;
+                return `${Size.ROUNDER.round(this.bytes / Size.MB_MULTIPLIER)} ${SizeUnit.MB}`;
             }
             case SizeUnit.GB: {
-                const gbs = rounding.round(this.bytes / Size.GB_MULTIPLIER);
-                return `${gbs} ${SizeUnit.GB}`;
+                return `${Size.ROUNDER.round(this.bytes / Size.GB_MULTIPLIER)} ${SizeUnit.GB}`;
             }
             default: {
                 // SizeUnit.b

package/dist/streak-calculator.service.d.ts

@@ -1,4 +1,3 @@
-import { format } from "date-fns";
 type DateType = string;
 export type StreakType = {
     cutoff: DateType;
@@ -7,8 +6,8 @@ export type StreakType = {
 };
 export declare class StreakCalculator {
     private readonly cutoff;
-    constructor();
-    calculate(_dates: DateType[]): StreakType;
-    static format(date: Parameters<typeof format>[0]): DateType;
+    constructor(now?: Date);
+    calculate(inputDates: DateType[]): StreakType;
+    static format(date: Date | number): DateType;
 }
 export {};

package/dist/streak-calculator.service.js

@@ -1,24 +1,18 @@
-import { format, isAfter, isEqual, subDays } from "date-fns";
+import { format, subDays } from "date-fns";
 export class StreakCalculator {
     cutoff;
-    constructor() {
-        const today = new Date();
-        this.cutoff = StreakCalculator.format(today);
+    constructor(now = new Date()) {
+        this.cutoff = StreakCalculator.format(now);
     }
-    calculate(_dates) {
-        const dates = Array.from(new Set(_dates));
+    calculate(inputDates) {
+        const dates = Array.from(new Set(inputDates));
+        const datesSet = new Set(dates);
         let streak = 0;
-        let streakTail = this.cutoff;
-        for (let i = 0; i < dates.length; i++) {
-            const date = dates[i];
-            if (isAfter(date, streakTail))
-                continue;
-            if (isEqual(streakTail, date) || isAfter(date, streakTail)) {
-                streakTail = StreakCalculator.format(subDays(date, 1));
-                streak++;
-            }
-            else
-                break;
+        let cursor = this.cutoff;
+        while (datesSet.has(cursor)) {
+            streak++;
+            const cursorDate = new Date(`${cursor}T00:00:00Z`);
+            cursor = StreakCalculator.format(subDays(cursorDate, 1));
         }
         return { cutoff: this.cutoff, dates, streak };
     }

package/dist/time-zone-offset-value.vo.d.ts

@@ -1,3 +1,3 @@
 import { z } from "zod/v4";
-export declare const TimeZoneOffsetValue: z.core.$ZodBranded<z.ZodPipe<z.ZodPipe<z.ZodUnion<[z.ZodString, z.ZodUndefined]>, z.ZodTransform<number, string | undefined>>, z.ZodTransform<number, number>>, "TimeZoneOffsetValue">;
+export declare const TimeZoneOffsetValue: z.core.$ZodBranded<z.ZodCatch<z.ZodCoercedNumber<unknown>>, "TimeZoneOffsetValue">;
 export type TimeZoneOffsetValueType = z.infer<typeof TimeZoneOffsetValue>;

package/dist/time-zone-offset-value.vo.js

@@ -1,8 +1,2 @@
 import { z } from "zod/v4";
-export const TimeZoneOffsetValue = z
-    .string()
-    .trim()
-    .or(z.undefined())
-    .transform((value) => Number(value))
-    .transform((value) => (Number.isNaN(value) ? 0 : value))
-    .brand("TimeZoneOffsetValue");
+export const TimeZoneOffsetValue = z.coerce.number().catch(0).brand("TimeZoneOffsetValue");

package/dist/time.service.d.ts

@@ -7,16 +7,21 @@ interface TimeResultInterface {
     readonly ms: TimestampType;
     isAfter(another: TimeResultInterface): boolean;
     isBefore(another: TimeResultInterface): boolean;
+    add(another: TimeResultInterface): TimeResultInterface;
+    subtract(another: TimeResultInterface): TimeResultInterface;
 }
 export declare class TimeResult implements TimeResultInterface {
-    readonly days: number;
-    readonly hours: number;
-    readonly minutes: number;
-    readonly seconds: number;
-    readonly ms: TimestampType;
-    constructor(days: number, hours: number, minutes: number, seconds: number, ms: TimestampType);
+    private readonly valueMs;
+    constructor(ms: TimestampType);
+    get days(): number;
+    get hours(): number;
+    get minutes(): number;
+    get seconds(): number;
+    get ms(): TimestampType;
     isAfter(another: TimeResultInterface): boolean;
     isBefore(another: TimeResultInterface): boolean;
+    add(another: TimeResultInterface): TimeResultInterface;
+    subtract(another: TimeResultInterface): TimeResultInterface;
 }
 export declare class Time {
     static Days(value: number): TimeResultInterface;

package/dist/time.service.js

@@ -1,40 +1,53 @@
 import { RoundToDecimal } from "./rounding.adapter";
 const rounding = new RoundToDecimal(2);
 export class TimeResult {
-    days;
-    hours;
-    minutes;
-    seconds;
-    ms;
-    constructor(days, hours, minutes, seconds, ms) {
-        this.days = days;
-        this.hours = hours;
-        this.minutes = minutes;
-        this.seconds = seconds;
-        this.ms = ms;
+    valueMs;
+    constructor(ms) {
+        this.valueMs = ms;
+    }
+    get days() {
+        return rounding.round(this.valueMs / 86_400_000);
+    }
+    get hours() {
+        return rounding.round(this.valueMs / 3_600_000);
+    }
+    get minutes() {
+        return rounding.round(this.valueMs / 60_000);
+    }
+    get seconds() {
+        return rounding.round(this.valueMs / 1_000);
+    }
+    get ms() {
+        return this.valueMs;
     }
     isAfter(another) {
-        return this.ms > another.ms;
+        return this.valueMs > another.ms;
     }
     isBefore(another) {
-        return this.ms < another.ms;
+        return this.valueMs < another.ms;
+    }
+    add(another) {
+        return new TimeResult((this.valueMs + another.ms));
+    }
+    subtract(another) {
+        return new TimeResult((this.valueMs - another.ms));
     }
 }
 export class Time {
     static Days(value) {
-        return new TimeResult(value, value * 24, value * 24 * 60, value * 24 * 60 * 60, (value * 24 * 60 * 60 * 1000));
+        return new TimeResult((value * 86_400_000));
     }
     static Hours(value) {
-        return new TimeResult(rounding.round(value / 24), value, value * 60, value * 60 * 60, (value * 60 * 60 * 1000));
+        return new TimeResult((value * 3_600_000));
     }
     static Minutes(value) {
-        return new TimeResult(rounding.round(value / 60 / 24), rounding.round(value / 60), value, value * 60, (value * 60 * 1000));
+        return new TimeResult((value * 60_000));
     }
     static Seconds(value) {
-        return new TimeResult(rounding.round(value / 60 / 60 / 24), rounding.round(value / 60 / 60), rounding.round(value / 60), value, (value * 1000));
+        return new TimeResult((value * 1_000));
     }
     static Ms(value) {
-        return new TimeResult(rounding.round(value / 1000 / 60 / 60 / 24), rounding.round(value / 1000 / 60 / 60), rounding.round(value / 1000 / 60), rounding.round(value / 1000), value);
+        return new TimeResult(value);
     }
     static Now(now) {
         return {

package/dist/timezone.vo.js

@@ -5,9 +5,7 @@ export const Timezone = z
     .min(1, TimezoneError)
     .refine((value) => {
     try {
-        const date = new Date();
-        const formatter = new Intl.DateTimeFormat("en-US", { timeZone: value });
-        formatter.format(date);
+        new Intl.DateTimeFormat("en-US", { timeZone: value }).format(new Date());
         return true;
     }
     catch (_error) {

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/age.vo.ts","../src/api-key.vo.ts","../src/basename.vo.ts","../src/clock-format.service.ts","../src/clock.vo.ts","../src/date-calculator.service.ts","../src/date-formatter.service.ts","../src/date-range.vo.ts","../src/day-iso-id.vo.ts","../src/day.vo.ts","../src/directory-path-absolute.vo.ts","../src/directory-path-relative.vo.ts","../src/dll.service.ts","../src/email-mask.service.ts","../src/etags.vo.ts","../src/extension.vo.ts","../src/feature-flag.vo.ts","../src/file-path-absolute-schema.vo.ts","../src/file-path-relative-schema.vo.ts","../src/file-path.vo.ts","../src/filename-from-string.vo.ts","../src/filename-suffix.vo.ts","../src/filename.vo.ts","../src/height.vo.ts","../src/hour-format.service.ts","../src/hour.vo.ts","../src/iban-mask.service.ts","../src/iban.vo.ts","../src/image.vo.ts","../src/index.ts","../src/language.vo.ts","../src/mean.service.ts","../src/mime-types.vo.ts","../src/mime.vo.ts","../src/min-max-scaler.service.ts","../src/minute.vo.ts","../src/money.vo.ts","../src/month-iso-id.vo.ts","../src/month.vo.ts","../src/noop.service.ts","../src/notification-template.vo.ts","../src/object-key.vo.ts","../src/outlier-detector.service.ts","../src/package-version.vo.ts","../src/pagination.service.ts","../src/percentage.service.ts","../src/population-standard-deviation.service.ts","../src/quarter-iso-id.vo.ts","../src/quarter.vo.ts","../src/random.service.ts","../src/rate-limiter.service.ts","../src/relative-date.vo.ts","../src/reordering.service.ts","../src/revision.vo.ts","../src/rounding.adapter.ts","../src/rounding.port.ts","../src/simple-linear-regression.service.ts","../src/size.vo.ts","../src/stepper.service.ts","../src/stopwatch.service.ts","../src/streak-calculator.service.ts","../src/sum.service.ts","../src/thousands-separator.service.ts","../src/time-zone-offset-value.vo.ts","../src/time.service.ts","../src/timestamp.vo.ts","../src/timezone.vo.ts","../src/ts-utils.ts","../src/visually-unambiguous-characters-generator.service.ts","../src/week-iso-id.vo.ts","../src/week.vo.ts","../src/weekday.vo.ts","../src/weight.vo.ts","../src/year-iso-id.vo.ts","../src/year.vo.ts","../src/z-score.service.ts"],"version":"5.9.3"}
+{"root":["../src/age.vo.ts","../src/api-key.vo.ts","../src/basename.vo.ts","../src/clock-format.service.ts","../src/clock.vo.ts","../src/date-calculator.service.ts","../src/date-formatter.service.ts","../src/date-range.vo.ts","../src/day-iso-id.vo.ts","../src/day.vo.ts","../src/directory-path-absolute.vo.ts","../src/directory-path-relative.vo.ts","../src/dll.service.ts","../src/email-mask.service.ts","../src/etags.vo.ts","../src/extension.vo.ts","../src/feature-flag.vo.ts","../src/file-path-absolute-schema.vo.ts","../src/file-path-relative-schema.vo.ts","../src/file-path.vo.ts","../src/filename-from-string.vo.ts","../src/filename-suffix.vo.ts","../src/filename.vo.ts","../src/height.vo.ts","../src/hour-format.service.ts","../src/hour.vo.ts","../src/iban-mask.service.ts","../src/iban.vo.ts","../src/image.vo.ts","../src/index.ts","../src/language.vo.ts","../src/mean.service.ts","../src/mime-types.vo.ts","../src/mime.vo.ts","../src/min-max-scaler.service.ts","../src/minute.vo.ts","../src/money.vo.ts","../src/month-iso-id.vo.ts","../src/month.vo.ts","../src/noop.service.ts","../src/notification-template.vo.ts","../src/object-key.vo.ts","../src/outlier-detector.service.ts","../src/package-version.vo.ts","../src/pagination.service.ts","../src/percentage.service.ts","../src/population-standard-deviation.service.ts","../src/quarter-iso-id.vo.ts","../src/quarter.vo.ts","../src/random.service.ts","../src/rate-limiter.service.ts","../src/relative-date.vo.ts","../src/reordering.service.ts","../src/revision.vo.ts","../src/rounding.adapter.ts","../src/rounding.port.ts","../src/simple-linear-regression.service.ts","../src/size.vo.ts","../src/stopwatch.service.ts","../src/streak-calculator.service.ts","../src/sum.service.ts","../src/thousands-separator.service.ts","../src/time-zone-offset-value.vo.ts","../src/time.service.ts","../src/timestamp.vo.ts","../src/timezone.vo.ts","../src/ts-utils.ts","../src/visually-unambiguous-characters-generator.service.ts","../src/week-iso-id.vo.ts","../src/week.vo.ts","../src/weekday.vo.ts","../src/weight.vo.ts","../src/year-iso-id.vo.ts","../src/year.vo.ts","../src/z-score.service.ts"],"version":"5.9.3"}

package/dist/week-iso-id.vo.d.ts

@@ -1,3 +1,6 @@
 import { z } from "zod/v4";
+export declare const WeekIsoIdError: {
+    readonly error: "week-iso-id.invalid";
+};
 export declare const WeekIsoId: z.ZodString;
 export type WeekIsoIdType = z.infer<typeof WeekIsoId>;

package/dist/week-iso-id.vo.js

@@ -1,15 +1,15 @@
 import { getISOWeeksInYear } from "date-fns";
 import { z } from "zod/v4";
+export const WeekIsoIdError = { error: "week-iso-id.invalid" };
 export const WeekIsoId = z
-    .string()
-    .regex(/^\d{4}-W\d{2}$/)
+    .string(WeekIsoIdError)
+    .regex(/^\d{4}-W\d{2}$/, WeekIsoIdError)
     .refine((value) => {
     const [yearPart, weekPart] = value.split("-W");
     const year = Number(yearPart);
     const week = Number(weekPart);
     if (!(Number.isInteger(year) && Number.isInteger(week)) || week < 1)
         return false;
-    // Does this ISO week-year actually have that many weeks?
     const weeksInYear = getISOWeeksInYear(new Date(Date.UTC(year, 0, 4)));
     return week <= weeksInYear;
-}, { message: "week-iso-id.invalid" });
+}, WeekIsoIdError);

package/dist/week.vo.js

@@ -6,7 +6,7 @@ export class Week extends DateRange {
     toIsoId() {
         const year = getISOWeekYear(this.getStart());
         const week = getISOWeek(this.getStart()).toString().padStart(2, "0");
-        return `${year}-W${week}`;
+        return WeekIsoId.parse(`${year}-W${week}`);
     }
     previous() {
         const shifted = addWeeks(new Date(this.getStart()), -1).getTime();

package/dist/weekday.vo.d.ts

@@ -6,6 +6,7 @@ export declare enum WeekdayFormatterEnum {
     ISO_NUMBER = "ISO_NUMBER",// Monday=1 ... Sunday=7
     ZERO_BASED_NUMBER = "ZERO_BASED_NUMBER"
 }
+export declare const WeekdayValueError: "invalid.weekday";
 export declare const WeekdayFormatters: Record<WeekdayFormatterEnum, WeekdayFormatter>;
 export declare class Weekday {
     private readonly value;
@@ -19,11 +20,11 @@ export declare class Weekday {
     static readonly SATURDAY: Weekday;
     constructor(candidate: number, formatter?: WeekdayFormatter);
     static fromUtcTimestamp(timestamp: TimestampType, formatter?: WeekdayFormatter): Weekday;
-    get(formatter?: WeekdayFormatter): {
-        raw: number;
-        formatted: string;
-    };
+    get(): number;
+    format(formatter?: WeekdayFormatter): string;
+    toString(): string;
     equals(another: Weekday): boolean;
+    /** ISO-8601 weekday number: Monday=1 ... Sunday=7 */
     toIsoNumber(): number;
     isMonday(): boolean;
     isTuesday(): boolean;
@@ -32,6 +33,6 @@ export declare class Weekday {
     isFriday(): boolean;
     isSaturday(): boolean;
     isSunday(): boolean;
-    static list(formatter?: WeekdayFormatter): Weekday[];
-    static listMondayFirst(formatter?: WeekdayFormatter): Weekday[];
+    static list(formatter?: WeekdayFormatter): readonly Weekday[];
+    static listMondayFirst(formatter?: WeekdayFormatter): readonly Weekday[];
 }

package/dist/weekday.vo.js

@@ -5,6 +5,7 @@ export var WeekdayFormatterEnum;
     WeekdayFormatterEnum["ISO_NUMBER"] = "ISO_NUMBER";
     WeekdayFormatterEnum["ZERO_BASED_NUMBER"] = "ZERO_BASED_NUMBER";
 })(WeekdayFormatterEnum || (WeekdayFormatterEnum = {}));
+export const WeekdayValueError = "invalid.weekday";
 const FULL_NAMES = [
     "Sunday",
     "Monday",
@@ -22,7 +23,9 @@ export const WeekdayFormatters = {
     ZERO_BASED_NUMBER: (value) => value.toString(), // JS getUTCDay(): Sun=0..Sat=6
 };
 export class Weekday {
+    // 0..6 (Sun..Sat)
     value;
+    // default formatter used by toString()/format() when no runtime formatter given
     formatter;
     static SUNDAY = new Weekday(0);
     static MONDAY = new Weekday(1);
@@ -32,26 +35,29 @@ export class Weekday {
     static FRIDAY = new Weekday(5);
     static SATURDAY = new Weekday(6);
     constructor(candidate, formatter) {
-        if (!Number.isInteger(candidate))
-            throw new Error("Invalid weekday");
-        if (candidate < 0)
-            throw new Error("Invalid weekday");
-        if (candidate > 6)
-            throw new Error("Invalid weekday");
+        if (!Number.isInteger(candidate) || candidate < 0 || candidate > 6)
+            throw new Error(WeekdayValueError);
         this.value = candidate;
         this.formatter = formatter ?? WeekdayFormatters.FULL;
     }
     static fromUtcTimestamp(timestamp, formatter) {
-        const day = new Date(timestamp).getUTCDay(); // 0..6
-        return new Weekday(day, formatter);
+        const dayZeroBased = new Date(timestamp).getUTCDay(); // 0..6
+        return new Weekday(dayZeroBased, formatter);
     }
-    get(formatter) {
-        const format = formatter ?? this.formatter;
-        return { raw: this.value, formatted: format(this.value) };
+    get() {
+        return this.value;
+    }
+    format(formatter) {
+        const chosen = formatter ?? this.formatter;
+        return chosen(this.value);
+    }
+    toString() {
+        return this.format(WeekdayFormatters.FULL);
     }
     equals(another) {
-        return this.value === another.get().raw;
+        return this.value === another.value;
     }
+    /** ISO-8601 weekday number: Monday=1 ... Sunday=7 */
     toIsoNumber() {
         return this.value === 0 ? 7 : this.value;
     }
@@ -77,7 +83,8 @@ export class Weekday {
         return this.value === 0;
     }
     static list(formatter) {
-        return Array.from({ length: 7 }).map((_, index) => new Weekday(index, formatter));
+        const chosen = formatter ?? undefined;
+        return Array.from({ length: 7 }, (_, index) => new Weekday(index, chosen));
     }
     static listMondayFirst(formatter) {
         const days = Weekday.list(formatter);