@bgord/tools 0.14.3 → 0.15.1

package/dist/age.vo.d.ts

@@ -1,8 +1,10 @@
 import { z } from "zod/v4";
 import type { TimestampType } from "./timestamp.vo";
 export declare const AgeValueError: {
-    error: string;
+    readonly error: "invalid.age";
 };
+export declare const InvalidBirthdateInFutureError: "invalid.birthdate_in_future";
+export declare const InvalidBirthdateError: "invalid.birthdate";
 export declare class Age {
     private readonly value;
     static readonly MIN = 1;
@@ -11,12 +13,12 @@ export declare class Age {
     private constructor();
     get(): number;
     compare(other: Age): -1 | 0 | 1;
-    equals(another: Age): boolean;
-    isOlderThan(another: Age): boolean;
-    isYoungerThan(another: Age): boolean;
-    isAdult(minAge: Age): boolean;
+    equals(other: Age): boolean;
+    isOlderThan(other: Age): boolean;
+    isYoungerThan(other: Age): boolean;
+    isAdult(minimumAge: Age): boolean;
     static fromValue(candidate: number): Age;
-    static fromBirthdateTimestamp(params: {
+    static fromBirthdateEpochMs(params: {
         birthdate: TimestampType;
         now: TimestampType;
     }): Age;
@@ -24,4 +26,6 @@ export declare class Age {
         birthdate: string;
         now: TimestampType;
     }): Age;
+    toJSON(): number;
+    toString(): string;
 }

package/dist/age.vo.js

@@ -1,6 +1,8 @@
 import { differenceInYears } from "date-fns";
 import { z } from "zod/v4";
 export const AgeValueError = { error: "invalid.age" };
+export const InvalidBirthdateInFutureError = "invalid.birthdate_in_future";
+export const InvalidBirthdateError = "invalid.birthdate";
 export class Age {
     value;
     static MIN = 1;
@@ -20,30 +22,36 @@ export class Age {
     compare(other) {
         return this.value === other.value ? 0 : this.value < other.value ? -1 : 1;
     }
-    equals(another) {
-        return this.compare(another) === 0;
+    equals(other) {
+        return this.value === other.value;
     }
-    isOlderThan(another) {
-        return this.compare(another) === 1;
+    isOlderThan(other) {
+        return this.value > other.value;
     }
-    isYoungerThan(another) {
-        return this.compare(another) === -1;
+    isYoungerThan(other) {
+        return this.value < other.value;
     }
-    isAdult(minAge) {
-        return this.equals(minAge) || this.isOlderThan(minAge);
+    isAdult(minimumAge) {
+        return this.value >= minimumAge.value;
     }
     static fromValue(candidate) {
         return new Age(Age.AgeValue.parse(candidate));
     }
-    static fromBirthdateTimestamp(params) {
+    static fromBirthdateEpochMs(params) {
         if (params.birthdate > params.now)
-            throw new Error("invalid.birthdate_in_future");
+            throw new Error(InvalidBirthdateInFutureError);
         return Age.fromValue(differenceInYears(params.now, params.birthdate));
     }
     static fromBirthdate(params) {
-        const birthdate = new Date(params.birthdate).getTime();
-        if (birthdate > params.now)
-            throw new Error("invalid.birthdate_in_future");
-        return Age.fromValue(differenceInYears(params.now, birthdate));
+        const birthdateMs = new Date(params.birthdate).getTime();
+        if (birthdateMs > params.now)
+            throw new Error(InvalidBirthdateInFutureError);
+        return Age.fromValue(differenceInYears(params.now, birthdateMs));
+    }
+    toJSON() {
+        return this.get();
+    }
+    toString() {
+        return String(this.value);
     }
 }

package/dist/api-key.vo.d.ts

@@ -1,3 +1,6 @@
 import { z } from "zod/v4";
+export declare const ApiKeyError: {
+    error: string;
+};
 export declare const ApiKey: z.core.$ZodBranded<z.ZodString, "ApiKey">;
 export type ApiKeyType = z.infer<typeof ApiKey>;

package/dist/api-key.vo.js

@@ -1,2 +1,8 @@
 import { z } from "zod/v4";
-export const ApiKey = z.string().trim().length(64).brand("ApiKey");
+export const ApiKeyError = { error: "invalid.api.key" };
+export const ApiKey = z
+    .string(ApiKeyError)
+    .trim()
+    .length(64, ApiKeyError)
+    .regex(/^[0-9a-zA-Z]{64}$/i, ApiKeyError)
+    .brand("ApiKey");

package/dist/clock-format.service.d.ts

@@ -0,0 +1,9 @@
+import type { Hour } from "./hour.vo";
+import type { Minute } from "./minute.vo";
+export type ClockFormatter = (hour: Hour, minute: Minute) => string;
+declare enum ClockFormatterEnum {
+    TWENTY_FOUR_HOURS = "TWENTY_FOUR_HOURS",
+    TWELVE_HOURS = "TWELVE_HOURS"
+}
+export declare const ClockFormatters: Record<ClockFormatterEnum, ClockFormatter>;
+export {};

package/dist/clock-format.service.js

@@ -0,0 +1,10 @@
+import { HourFormatters } from "./hour-format.service";
+var ClockFormatterEnum;
+(function (ClockFormatterEnum) {
+    ClockFormatterEnum["TWENTY_FOUR_HOURS"] = "TWENTY_FOUR_HOURS";
+    ClockFormatterEnum["TWELVE_HOURS"] = "TWELVE_HOURS";
+})(ClockFormatterEnum || (ClockFormatterEnum = {}));
+export const ClockFormatters = {
+    TWENTY_FOUR_HOURS: (hour, minute) => `${hour.toString()}:${minute.toString()}`,
+    TWELVE_HOURS: (hour, minute) => `${hour.format(HourFormatters.TWELVE_HOURS)}:${minute.toString()}`,
+};

package/dist/clock.vo.d.ts

@@ -1,27 +1,20 @@
+import { type ClockFormatter } from "./clock-format.service";
 import { Hour } from "./hour.vo";
 import { Minute } from "./minute.vo";
 import type { TimestampType } from "./timestamp.vo";
-export type ClockFormatter = (hour: Hour, minute: Minute) => string;
-declare enum ClockFormatterEnum {
-    TWENTY_FOUR_HOURS = "TWENTY_FOUR_HOURS",
-    TWELVE_HOURS = "TWELVE_HOURS"
-}
-export declare const ClockFormatters: Record<ClockFormatterEnum, ClockFormatter>;
 export declare class Clock {
     private readonly hour;
     private readonly minute;
     private readonly formatter;
     constructor(hour: Hour, minute: Minute, formatter?: ClockFormatter);
-    static fromUtcTimestamp(timestamp: TimestampType, formatter?: ClockFormatter): Clock;
-    get(formatter?: ClockFormatter): {
-        raw: {
-            hour: number;
-            minute: number;
-        };
-        formatted: string;
+    static fromEpochMs(timestamp: TimestampType, formatter?: ClockFormatter): Clock;
+    get(): {
+        hour: number;
+        minute: number;
     };
+    format(formatter?: ClockFormatter): string;
+    toString(): string;
     equals(another: Clock): boolean;
     isAfter(another: Clock): boolean;
     isBefore(another: Clock): boolean;
 }
-export {};

package/dist/clock.vo.js

@@ -1,14 +1,6 @@
-import { Hour, HourFormatters } from "./hour.vo";
+import { ClockFormatters } from "./clock-format.service";
+import { Hour } from "./hour.vo";
 import { Minute } from "./minute.vo";
-var ClockFormatterEnum;
-(function (ClockFormatterEnum) {
-    ClockFormatterEnum["TWENTY_FOUR_HOURS"] = "TWENTY_FOUR_HOURS";
-    ClockFormatterEnum["TWELVE_HOURS"] = "TWELVE_HOURS";
-})(ClockFormatterEnum || (ClockFormatterEnum = {}));
-export const ClockFormatters = {
-    TWENTY_FOUR_HOURS: (hour, minute) => `${hour.get().formatted}:${minute.get().formatted}`,
-    TWELVE_HOURS: (hour, minute) => `${hour.get(HourFormatters.TWELVE_HOURS).formatted}:${minute.get().formatted}`,
-};
 export class Clock {
     hour;
     minute;
@@ -18,37 +10,36 @@ export class Clock {
         this.minute = minute;
         this.formatter = formatter ?? ClockFormatters.TWENTY_FOUR_HOURS;
     }
-    static fromUtcTimestamp(timestamp, formatter) {
-        const hour = Hour.fromUtcTimestamp(timestamp);
-        const minute = Minute.fromUtcTimestamp(timestamp);
+    static fromEpochMs(timestamp, formatter) {
+        const hour = Hour.fromEpochMs(timestamp);
+        const minute = Minute.fromEpochMs(timestamp);
         return new Clock(hour, minute, formatter);
     }
-    get(formatter) {
-        const format = formatter ?? this.formatter;
-        return {
-            raw: { hour: this.hour.get().raw, minute: this.minute.get().raw },
-            formatted: format(this.hour, this.minute),
-        };
+    get() {
+        return { hour: this.hour.get(), minute: this.minute.get() };
+    }
+    format(formatter) {
+        const chosen = formatter ?? this.formatter;
+        return chosen(this.hour, this.minute);
+    }
+    toString() {
+        return this.format();
     }
     equals(another) {
-        return (this.hour.get().raw === another.get().raw.hour && this.minute.get().raw === another.get().raw.minute);
+        return this.hour.get() === another.hour.get() && this.minute.get() === another.minute.get();
     }
     isAfter(another) {
-        if (this.hour.get().raw > another.hour.get().raw) {
-            return true;
-        }
-        if (this.hour.get().raw === another.hour.get().raw && this.minute.get().raw > another.minute.get().raw) {
-            return true;
-        }
-        return false;
+        const thisHour = this.hour.get();
+        const otherHour = another.hour.get();
+        if (thisHour !== otherHour)
+            return thisHour > otherHour;
+        return this.minute.get() > another.minute.get();
     }
     isBefore(another) {
-        if (this.hour.get().raw < another.hour.get().raw) {
-            return true;
-        }
-        if (this.hour.get().raw === another.hour.get().raw && this.minute.get().raw < another.minute.get().raw) {
-            return true;
-        }
-        return false;
+        const thisHour = this.hour.get();
+        const otherHour = another.hour.get();
+        if (thisHour !== otherHour)
+            return thisHour < otherHour;
+        return this.minute.get() < another.minute.get();
     }
 }

package/dist/height.vo.d.ts

@@ -1,4 +1,4 @@
-import { type RoundingStrategy } from "./rounding.service";
+import type { RoundingPort } from "./rounding.port";
 export declare enum HeightUnit {
     cm = "cm",
     ft_in = "ft_in"
@@ -9,17 +9,17 @@ export declare class Height {
     private static readonly MILLIMETERS_PER_INCH;
     private static readonly INCHES_PER_FOOT;
     private constructor();
-    static fromCentimeters(centimeters: number, rounding?: RoundingStrategy): Height;
-    static fromFeetInches(feet: number, inches?: number, rounding?: RoundingStrategy): Height;
-    static fromMillimeters(millimeters: number, rounding?: RoundingStrategy): Height;
+    static fromCentimeters(centimeters: number, rounding?: RoundingPort): Height;
+    static fromFeetInches(feet: number, inches?: number, rounding?: RoundingPort): Height;
+    static fromMillimeters(millimeters: number, rounding?: RoundingPort): Height;
     static zero(): Height;
     toMillimeters(): number;
-    toCentimeters(rounding?: RoundingStrategy): number;
-    toFeetInches(rounding?: RoundingStrategy): {
+    toCentimeters(rounding?: RoundingPort): number;
+    toFeetInches(rounding?: RoundingPort): {
         feet: number;
         inches: number;
     };
-    format(unit: HeightUnit, roundingStrategy?: RoundingStrategy): string;
+    format(unit: HeightUnit, rounding?: RoundingPort): string;
     equals(other: Height): boolean;
     compare(other: Height): -1 | 0 | 1;
     greaterThan(other: Height): boolean;

package/dist/height.vo.js

@@ -1,5 +1,5 @@
 import { z } from "zod/v4";
-import { RoundToDecimal, RoundToNearest } from "./rounding.service";
+import { RoundToDecimal, RoundToNearest } from "./rounding.adapter";
 const FiniteNumericValue = z.number().refine(Number.isFinite, { message: "Expected a finite number" });
 const NonNegativeNumericValue = FiniteNumericValue.min(0, { message: "Must be greater than or equal to 0" });
 const NonNegativeIntegerMillimeters = FiniteNumericValue.int().min(0, {
@@ -61,15 +61,15 @@ export class Height {
         const inches = integerInches % Height.INCHES_PER_FOOT;
         return { feet, inches };
     }
-    format(unit, roundingStrategy) {
+    format(unit, rounding) {
         return {
             [HeightUnit.cm]: () => {
-                const rounding = roundingStrategy ?? new RoundToDecimal(1);
-                return `${this.toCentimeters(rounding)} cm`;
+                const chosen = rounding ?? new RoundToDecimal(1);
+                return `${this.toCentimeters(chosen)} cm`;
             },
             [HeightUnit.ft_in]: () => {
-                const rounding = roundingStrategy ?? new RoundToNearest();
-                const { feet, inches } = this.toFeetInches(rounding);
+                const chosen = rounding ?? new RoundToNearest();
+                const { feet, inches } = this.toFeetInches(chosen);
                 return `${feet}′${inches}″`;
             },
         }[unit]();

package/dist/hour-format.service.d.ts

@@ -0,0 +1,10 @@
+export type HourFormatter = (value: number) => string;
+declare enum HourFormatterEnum {
+    TWENTY_FOUR_HOURS = "TWENTY_FOUR_HOURS",
+    TWENTY_FOUR_HOURS_WO_PADDING = "TWENTY_FOUR_HOURS_WO_PADDING",
+    AM_PM = "AM_PM",
+    TWELVE_HOURS = "TWELVE_HOURS",
+    TWELVE_HOURS_WO_PADDING = "TWELVE_HOURS_WO_PADDING"
+}
+export declare const HourFormatters: Record<HourFormatterEnum, HourFormatter>;
+export {};

package/dist/hour-format.service.js

@@ -0,0 +1,19 @@
+var HourFormatterEnum;
+(function (HourFormatterEnum) {
+    HourFormatterEnum["TWENTY_FOUR_HOURS"] = "TWENTY_FOUR_HOURS";
+    HourFormatterEnum["TWENTY_FOUR_HOURS_WO_PADDING"] = "TWENTY_FOUR_HOURS_WO_PADDING";
+    HourFormatterEnum["AM_PM"] = "AM_PM";
+    HourFormatterEnum["TWELVE_HOURS"] = "TWELVE_HOURS";
+    HourFormatterEnum["TWELVE_HOURS_WO_PADDING"] = "TWELVE_HOURS_WO_PADDING";
+})(HourFormatterEnum || (HourFormatterEnum = {}));
+export const HourFormatters = {
+    TWENTY_FOUR_HOURS: (value) => value.toString().padStart(2, "0"),
+    TWENTY_FOUR_HOURS_WO_PADDING: (value) => value.toString(),
+    AM_PM: (value) => {
+        const twelveHourValue = value % 12 || 12;
+        const suffix = value < 12 ? "a.m." : "p.m.";
+        return `${twelveHourValue} ${suffix}`;
+    },
+    TWELVE_HOURS: (value) => (value % 12 || 12).toString().padStart(2, "0"),
+    TWELVE_HOURS_WO_PADDING: (value) => (value % 12 || 12).toString(),
+};

package/dist/hour.vo.d.ts

@@ -1,26 +1,17 @@
+import { type HourFormatter } from "./hour-format.service";
 import type { TimestampType } from "./timestamp.vo";
-export type HourFormatter = (value: Hour["value"]) => string;
-export declare enum HourFormatterEnum {
-    TWENTY_FOUR_HOURS = "TWENTY_FOUR_HOURS",
-    TWENTY_FOUR_HOURS_WO_PADDING = "TWENTY_FOUR_HOURS_WO_PADDING",
-    AM_PM = "AM_PM",
-    TWELVE_HOURS = "TWELVE_HOURS",
-    TWELVE_HOURS_WO_PADDING = "TWELVE_HOURS_WO_PADDING"
-}
-export declare const HourFormatters: Record<HourFormatterEnum, HourFormatter>;
+export declare const HourValueError: "invalid.hour";
 export declare class Hour {
     private readonly value;
-    private readonly formatter;
     static readonly ZERO: Hour;
     static readonly MAX: Hour;
-    constructor(candidate: number, formatter?: HourFormatter);
-    get(formatter?: HourFormatter): {
-        raw: number;
-        formatted: string;
-    };
+    constructor(candidate: number);
+    static fromEpochMs(timestamp: TimestampType): Hour;
+    get(): number;
+    toString(): string;
+    format(formatter: HourFormatter): string;
     equals(another: Hour): boolean;
     isAfter(another: Hour): boolean;
     isBefore(another: Hour): boolean;
-    static fromUtcTimestamp(timestamp: TimestampType, formatter?: HourFormatter): Hour;
-    static list(formatter?: HourFormatter): Hour[];
+    static list(): readonly Hour[];
 }

package/dist/hour.vo.js

@@ -1,54 +1,37 @@
-export var HourFormatterEnum;
-(function (HourFormatterEnum) {
-    HourFormatterEnum["TWENTY_FOUR_HOURS"] = "TWENTY_FOUR_HOURS";
-    HourFormatterEnum["TWENTY_FOUR_HOURS_WO_PADDING"] = "TWENTY_FOUR_HOURS_WO_PADDING";
-    HourFormatterEnum["AM_PM"] = "AM_PM";
-    HourFormatterEnum["TWELVE_HOURS"] = "TWELVE_HOURS";
-    HourFormatterEnum["TWELVE_HOURS_WO_PADDING"] = "TWELVE_HOURS_WO_PADDING";
-})(HourFormatterEnum || (HourFormatterEnum = {}));
-export const HourFormatters = {
-    TWENTY_FOUR_HOURS: (value) => value.toString().padStart(2, "0"),
-    TWENTY_FOUR_HOURS_WO_PADDING: (value) => value.toString(),
-    AM_PM: (value) => {
-        const twelveHour = value % 12 || 12;
-        return `${twelveHour.toString()} ${value < 12 ? "a.m." : "p.m."}`;
-    },
-    TWELVE_HOURS: (value) => (value % 12 || 12).toString().padStart(2, "0"),
-    TWELVE_HOURS_WO_PADDING: (value) => (value % 12 || 12).toString(),
-};
+import { HourFormatters } from "./hour-format.service";
+export const HourValueError = "invalid.hour";
 export class Hour {
     value;
-    formatter;
     static ZERO = new Hour(0);
     static MAX = new Hour(23);
-    constructor(candidate, formatter) {
-        if (!Number.isInteger(candidate))
-            throw new Error("Invalid hour");
-        if (candidate < 0)
-            throw new Error("Invalid hour");
-        if (candidate >= 24)
-            throw new Error("Invalid hour");
+    constructor(candidate) {
+        if (!Number.isInteger(candidate) || candidate < 0 || candidate >= 24) {
+            throw new Error(HourValueError);
+        }
         this.value = candidate;
-        this.formatter = formatter ?? HourFormatters.TWENTY_FOUR_HOURS;
     }
-    get(formatter) {
-        const format = formatter ?? this.formatter;
-        return { raw: this.value, formatted: format(this.value) };
+    static fromEpochMs(timestamp) {
+        return new Hour(new Date(timestamp).getUTCHours());
+    }
+    get() {
+        return this.value;
+    }
+    toString() {
+        return HourFormatters.TWENTY_FOUR_HOURS(this.value);
+    }
+    format(formatter) {
+        return formatter(this.value);
     }
     equals(another) {
-        return this.value === another.get().raw;
+        return this.value === another.value;
     }
     isAfter(another) {
-        return this.value > another.get().raw;
+        return this.value > another.value;
     }
     isBefore(another) {
-        return this.value < another.get().raw;
-    }
-    static fromUtcTimestamp(timestamp, formatter) {
-        const hours = new Date(timestamp).getUTCHours();
-        return new Hour(hours, formatter);
+        return this.value < another.value;
     }
-    static list(formatter) {
-        return Array.from({ length: 24 }).map((_, index) => new Hour(index, formatter));
+    static list() {
+        return Array.from({ length: 24 }, (_, index) => new Hour(index));
     }
 }

package/dist/iban-mask.service.js

@@ -1,9 +1,12 @@
 export class IbanMask {
     static censor(iban) {
         const value = iban.format();
-        const start = value.slice(0, 4);
-        const middle = value.slice(5, -5).replace(/\d/g, "*");
+        const FIRST_SPACE_INDEX = 4;
+        const LAST_SPACE_START_INDEX = value.length - 5;
+        const start = value.slice(0, FIRST_SPACE_INDEX);
+        const middle = value.slice(FIRST_SPACE_INDEX + 1, LAST_SPACE_START_INDEX);
         const end = value.slice(-4);
-        return `${start} ${middle} ${end}`;
+        const maskedMiddle = middle.replace(/[A-Z0-9]/g, "*");
+        return `${start} ${maskedMiddle} ${end}`;
     }
 }

package/dist/iban.vo.d.ts

@@ -1,7 +1,10 @@
 import { z } from "zod/v4";
-declare const IBANValueSchema: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-type IBANValueType = z.infer<typeof IBANValueSchema>;
-type IBANCountryCode = string;
+export declare const IBANError: {
+    readonly error: "invalid.iban.format";
+};
+export declare const IBANValue: z.core.$ZodBranded<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, "IBAN">;
+export type IBANValueType = z.infer<typeof IBANValue>;
+export type IBANCountryCode = string;
 export declare class IBAN {
     private readonly value;
     constructor(value: string);
@@ -10,4 +13,3 @@ export declare class IBAN {
     get countryCode(): IBANCountryCode;
     equals(other: IBAN): boolean;
 }
-export {};

package/dist/iban.vo.js

@@ -1,16 +1,18 @@
 import { z } from "zod/v4";
-// Basic IBAN format regex (2-letter country code + 2 digits + 11–30 alphanumerics)
+export const IBANError = { error: "invalid.iban.format" };
+// 2-letter country code + 2 digits + 11–30 alphanumerics (overall 15–34 chars)
 const IBAN_REGEX = /^[A-Z]{2}[0-9]{2}[A-Z0-9]{11,30}$/;
-const IBANValueSchema = z
-    .string()
+export const IBANValue = z
+    .string(IBANError)
     .trim()
     .toUpperCase()
     .transform((val) => val.replace(/\s+/g, ""))
-    .refine((iban) => IBAN_REGEX.test(iban), { message: "invalid.iban.format" });
+    .refine((iban) => IBAN_REGEX.test(iban), IBANError)
+    .brand("IBAN");
 export class IBAN {
     value;
     constructor(value) {
-        this.value = IBANValueSchema.parse(value);
+        this.value = IBANValue.parse(value);
     }
     toString() {
         return this.value;

package/dist/image.vo.d.ts

@@ -1,5 +1,11 @@
 import { z } from "zod/v4";
+export declare const ImageWidthError: {
+    readonly error: "invalid.image.width";
+};
+export declare const ImageHeightError: {
+    readonly error: "invalid.image.height";
+};
 export declare const ImageWidth: z.core.$ZodBranded<z.ZodNumber, "image-width">;
-export type WidthType = z.infer<typeof ImageWidth>;
+export type ImageWidthType = z.infer<typeof ImageWidth>;
 export declare const ImageHeight: z.core.$ZodBranded<z.ZodNumber, "image-height">;
-export type HeightType = z.infer<typeof ImageHeight>;
+export type ImageHeightType = z.infer<typeof ImageHeight>;

package/dist/image.vo.js

@@ -1,3 +1,15 @@
 import { z } from "zod/v4";
-export const ImageWidth = z.number().int().positive().max(10000).brand("image-width");
-export const ImageHeight = z.number().int().positive().max(10000).brand("image-height");
+export const ImageWidthError = { error: "invalid.image.width" };
+export const ImageHeightError = { error: "invalid.image.height" };
+export const ImageWidth = z
+    .number(ImageWidthError)
+    .int(ImageWidthError)
+    .positive(ImageWidthError)
+    .max(10_000, ImageWidthError)
+    .brand("image-width");
+export const ImageHeight = z
+    .number(ImageHeightError)
+    .int(ImageHeightError)
+    .positive(ImageHeightError)
+    .max(10_000, ImageHeightError)
+    .brand("image-height");

package/dist/index.d.ts

@@ -5,7 +5,6 @@ export * from "./clock.vo";
 export * from "./date-calculator.service";
 export * from "./date-formatter.service";
 export * from "./date-range.vo";
-export * from "./dates-of-the-week.vo";
 export * from "./day.vo";
 export * from "./day-iso-id.vo";
 export * from "./directory-path-absolute.vo";
@@ -50,7 +49,8 @@ export * from "./rate-limiter.service";
 export * from "./relative-date.vo";
 export * from "./reordering.service";
 export * from "./revision.vo";
-export * from "./rounding.service";
+export * from "./rounding.adapter";
+export * from "./rounding.port";
 export * from "./simple-linear-regression.service";
 export * from "./size.vo";
 export * from "./stepper.service";

package/dist/index.js

@@ -5,7 +5,6 @@ export * from "./clock.vo";
 export * from "./date-calculator.service";
 export * from "./date-formatter.service";
 export * from "./date-range.vo";
-export * from "./dates-of-the-week.vo";
 export * from "./day.vo";
 export * from "./day-iso-id.vo";
 export * from "./directory-path-absolute.vo";
@@ -50,7 +49,8 @@ export * from "./rate-limiter.service";
 export * from "./relative-date.vo";
 export * from "./reordering.service";
 export * from "./revision.vo";
-export * from "./rounding.service";
+export * from "./rounding.adapter";
+export * from "./rounding.port";
 export * from "./simple-linear-regression.service";
 export * from "./size.vo";
 export * from "./stepper.service";

package/dist/language.vo.d.ts

@@ -1,3 +1,6 @@
 import { z } from "zod/v4";
-export declare const Language: z.ZodString;
+export declare const LanguageError: {
+    readonly error: "invalid.language";
+};
+export declare const Language: z.core.$ZodBranded<z.ZodString, "Language">;
 export type LanguageType = z.infer<typeof Language>;

package/dist/language.vo.js

@@ -1,5 +1,7 @@
 import { z } from "zod/v4";
+export const LanguageError = { error: "invalid.language" };
 export const Language = z
-    .string()
-    .length(2)
-    .regex(/^[a-z]{2}$/, { message: "invalid_language" });
+    .string(LanguageError)
+    .length(2, LanguageError)
+    .regex(/^[a-z]{2}$/, LanguageError)
+    .brand("Language");

package/dist/mean.service.d.ts

@@ -1,4 +1,6 @@
-import { type RoundingStrategy } from "./rounding.service";
+import type { RoundingPort } from "./rounding.port";
+export declare const MeanEmptyValuesError: "mean.values.empty";
 export declare class Mean {
-    static calculate(values: number[], rounding?: RoundingStrategy): number;
+    private static readonly DEFAULT_ROUNDING;
+    static calculate(values: number[], rounding?: RoundingPort): number;
 }

package/dist/mean.service.js

@@ -1,10 +1,14 @@
-import { RoundToDecimal } from "./rounding.service";
+import { RoundToDecimal } from "./rounding.adapter";
 import { Sum } from "./sum.service";
+export const MeanEmptyValuesError = "mean.values.empty";
 export class Mean {
-    static calculate(values, rounding = new RoundToDecimal(2)) {
+    static DEFAULT_ROUNDING = new RoundToDecimal(2);
+    static calculate(values, rounding) {
         if (values.length === 0)
-            throw new Error("Values should not be empty");
-        const mean = Sum.of(values) / values.length;
-        return rounding.round(mean);
+            throw new Error(MeanEmptyValuesError);
+        const sum = Sum.of(values);
+        const mean = sum / values.length;
+        const chosen = rounding ?? Mean.DEFAULT_ROUNDING;
+        return chosen.round(mean);
     }
 }