@bgord/tools 0.17.2 → 1.0.1

package/dist/reordering.service.js

@@ -1,31 +1,22 @@
 import { z } from "zod/v4";
 import { DoublyLinkedList, Node } from "./dll.service";
-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);
+import { ReorderingItemPositionValue, } from "./reordering-item-position-value.vo";
+export const ReorderingError = {
+    CannotFindItem: "reordering.cannot.find.item",
+    CannotFindCurrent: "reordering.cannot.find.current",
+    CannotFindTarget: "reordering.cannot.find.target",
+};
+const ReorderingIdError = { Type: "reordering.id.type" };
+export const ReorderingId = z.string(ReorderingIdError.Type).min(1, ReorderingIdError.Type);
 export const Reordering = z.object({
-    correlationId: ReorderingCorrelationId,
-    id: ReorderingItemId,
+    correlationId: ReorderingId,
+    id: ReorderingId,
     position: ReorderingItemPositionValue,
 });
 export class ReorderingPosition {
     value;
     constructor(value) {
-        const parsed = ReorderingItemPositionValue.safeParse(value);
-        if (!parsed.success)
-            throw new Error(ReorderingPositionError.error);
-        this.value = value;
+        this.value = ReorderingItemPositionValue.parse(value);
     }
     eq(another) {
         return this.value === another.value;
@@ -88,17 +79,17 @@ export class ReorderingCalculator {
     delete(id) {
         const node = this.dll.find((x) => x.data.eq(id));
         if (!node)
-            throw new Error(ReorderingCannotFindItemError.error);
+            throw new Error(ReorderingError.CannotFindItem);
         this.dll.remove(node);
         this.recalculate();
     }
     transfer(transfer) {
         const current = this.dll.find((node) => node.data.eq(transfer.id));
         if (!current)
-            throw new Error(ReorderingCannotFindCurrentError.error);
+            throw new Error(ReorderingError.CannotFindCurrent);
         const target = this.dll.find((node) => node.data.position.eq(transfer.to));
         if (!target)
-            throw new Error(ReorderingCannotFindTargetError.error);
+            throw new Error(ReorderingError.CannotFindTarget);
         const direction = transfer.getDirection(current.data.position);
         if (direction === ReorderingTransferDirection.noop)
             return this.read();
@@ -122,7 +113,7 @@ export class ReorderingCalculator {
         let index = 0;
         for (const node of this.dll) {
             const id = node.data.id;
-            const position = new ReorderingPosition(index);
+            const position = new ReorderingPosition(ReorderingItemPositionValue.parse(index));
             node.data = new ReorderingItem(id, position);
             index += 1;
         }

package/dist/revision-value.vo.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod/v4";
+export declare const RevisionValueError: {
+    readonly Type: "revision.value.type";
+    readonly Invalid: "revision.value.invalid";
+};
+export declare const RevisionValue: z.ZodNumber;
+export type RevisionValueType = z.infer<typeof RevisionValue>;

package/dist/revision-value.vo.js

@@ -0,0 +1,6 @@
+import { z } from "zod/v4";
+export const RevisionValueError = { Type: "revision.value.type", Invalid: "revision.value.invalid" };
+export const RevisionValue = z
+    .number(RevisionValueError.Type)
+    .int(RevisionValueError.Type)
+    .min(0, RevisionValueError.Invalid);

package/dist/revision.vo.d.ts

@@ -1,12 +1,9 @@
-import { z } from "zod/v4";
 import type { ETag, WeakETag } from "./etags.vo";
-export declare const RevisionValueError: {
-    readonly error: "invalid.revision.value";
+import { type RevisionValueType } from "./revision-value.vo";
+export declare const RevisionError: {
+    readonly Missing: "revision.missing";
+    readonly Mismatch: "revision.mismatch";
 };
-export declare const RevisionValue: z.ZodNumber;
-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;
@@ -16,10 +13,6 @@ export declare class Revision {
     next(): Revision;
     static fromETag(etag: ETag | null): Revision;
     static fromWeakETag(weakEtag: WeakETag | null): Revision;
-}
-export declare class RevisionMismatchError extends Error {
-    constructor();
-}
-export declare class InvalidRevisionError extends Error {
-    constructor();
+    toString(): string;
+    toJSON(): number;
 }

package/dist/revision.vo.js

@@ -1,47 +1,35 @@
-import { z } from "zod/v4";
-export const RevisionValueError = { error: "invalid.revision.value" };
-export const RevisionValue = z.number(RevisionValueError).int(RevisionValueError).min(0, RevisionValueError);
-export const RevisionInvalidErrorMessage = "revision.invalid";
-export const RevisionMismatchErrorMessage = "revision.mismatch";
+import { RevisionValue } from "./revision-value.vo";
+export const RevisionError = { Missing: "revision.missing", Mismatch: "revision.mismatch" };
 export class Revision {
     static INITIAL = RevisionValue.parse(0);
     value;
     constructor(value) {
-        const result = RevisionValue.safeParse(value);
-        if (!result.success)
-            throw new InvalidRevisionError();
-        this.value = result.data;
+        this.value = RevisionValue.parse(value);
     }
     equals(another) {
         return this.value === another;
     }
     validate(another) {
         if (!this.equals(another))
-            throw new RevisionMismatchError();
+            throw new Error(RevisionError.Mismatch);
     }
     next() {
         return new Revision(this.value + 1);
     }
     static fromETag(etag) {
         if (!etag)
-            throw new InvalidRevisionError();
+            throw new Error(RevisionError.Missing);
         return new Revision(etag.revision);
     }
     static fromWeakETag(weakEtag) {
         if (!weakEtag)
-            throw new InvalidRevisionError();
+            throw new Error(RevisionError.Missing);
         return new Revision(weakEtag.revision);
     }
-}
-export class RevisionMismatchError extends Error {
-    constructor() {
-        super(RevisionMismatchErrorMessage);
-        Object.setPrototypeOf(this, RevisionMismatchError.prototype);
+    toString() {
+        return this.value.toString();
     }
-}
-export class InvalidRevisionError extends Error {
-    constructor() {
-        super(RevisionInvalidErrorMessage);
-        Object.setPrototypeOf(this, InvalidRevisionError.prototype);
+    toJSON() {
+        return this.value;
     }
 }

package/dist/rounding.adapter.d.ts

@@ -1,3 +1,4 @@
+import { z } from "zod/v4";
 import type { RoundingPort } from "./rounding.port";
 export declare class RoundToNearest implements RoundingPort {
     round(value: number): number;
@@ -8,9 +9,13 @@ export declare class RoundUp implements RoundingPort {
 export declare class RoundDown implements RoundingPort {
     round(value: number): number;
 }
-export declare const RoundingDecimalsError: "invalid.rounding.decimals";
+export declare const RoundingDecimalError: {
+    readonly Type: "rounding.decimal.type";
+    readonly Invalid: "rounding.decimal.invalid";
+};
+export declare const RoundingDecimal: z.core.$ZodBranded<z.ZodNumber, "RoundingDecimal">;
 export declare class RoundToDecimal implements RoundingPort {
     private readonly decimals;
-    constructor(decimals: number);
+    constructor(candidate: number);
     round(value: number): number;
 }

package/dist/rounding.adapter.js

@@ -1,3 +1,4 @@
+import { z } from "zod/v4";
 export class RoundToNearest {
     round(value) {
         return Math.round(value);
@@ -13,13 +14,20 @@ export class RoundDown {
         return Math.floor(value);
     }
 }
-export const RoundingDecimalsError = "invalid.rounding.decimals";
+export const RoundingDecimalError = {
+    Type: "rounding.decimal.type",
+    Invalid: "rounding.decimal.invalid",
+};
+export const RoundingDecimal = z
+    .number(RoundingDecimalError.Type)
+    .int(RoundingDecimalError.Invalid)
+    .min(1, RoundingDecimalError.Invalid)
+    .max(100, RoundingDecimalError.Invalid)
+    .brand("RoundingDecimal");
 export class RoundToDecimal {
     decimals;
-    constructor(decimals) {
-        this.decimals = decimals;
-        if (!Number.isInteger(decimals) || decimals < 0 || decimals > 100)
-            throw new Error(RoundingDecimalsError);
+    constructor(candidate) {
+        this.decimals = RoundingDecimal.parse(candidate);
     }
     round(value) {
         return Number.parseFloat(value.toFixed(this.decimals));

package/dist/size-bytes.vo.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod/v4";
+export declare const SizeBytesError: {
+    readonly Invalid: "size.bytes.invalid";
+};
+export declare const SizeBytes: z.core.$ZodBranded<z.ZodNumber, "SizeBytes">;
+export type SizeBytesType = z.infer<typeof SizeBytes>;

package/dist/size-bytes.vo.js

@@ -0,0 +1,7 @@
+import { z } from "zod/v4";
+export const SizeBytesError = { Invalid: "size.bytes.invalid" };
+export const SizeBytes = z
+    .number(SizeBytesError.Invalid)
+    .int(SizeBytesError.Invalid)
+    .gte(0, SizeBytesError.Invalid)
+    .brand("SizeBytes");

package/dist/size.vo.d.ts

@@ -1,35 +1,35 @@
-import { z } from "zod/v4";
-export declare enum SizeUnit {
+import { type SizeBytesType } from "./size-bytes.vo";
+declare enum SizeUnitEnum {
     b = "b",
     kB = "kB",
     MB = "MB",
     GB = "GB"
 }
-export declare const SizeValue: z.core.$ZodBranded<z.ZodNumber, "SizeValue">;
-type SizeValueType = z.infer<typeof SizeValue>;
 type SizeConfigType = {
-    unit: SizeUnit;
+    unit: SizeUnitEnum;
     value: number;
 };
 export declare class Size {
     private readonly unit;
-    private readonly value;
     private readonly bytes;
     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;
-    static fromMB(candidate: number): Size;
-    static fromGB(candidate: number): Size;
-    toString(): string;
-    toBytes(): SizeValueType;
+    static fromBytes(value: SizeConfigType["value"]): Size;
+    static fromKb(value: SizeConfigType["value"]): Size;
+    static fromMB(value: SizeConfigType["value"]): Size;
+    static fromGB(value: SizeConfigType["value"]): Size;
+    toBytes(): SizeBytesType;
     isGreaterThan(another: Size): boolean;
-    format(unit: SizeUnit): string;
-    static toBytes(config: SizeConfigType): SizeValueType;
-    static unit: typeof SizeUnit;
+    format(unit: SizeUnitEnum): string;
+    static toBytes(config: SizeConfigType): SizeBytesType;
+    static unit: typeof SizeUnitEnum;
     private calculateBytes;
+    toString(): string;
+    toJSON(): {
+        bytes: number;
+    };
 }
 export {};

package/dist/size.vo.js

@@ -1,16 +1,14 @@
-import { z } from "zod/v4";
 import { RoundToDecimal } from "./rounding.adapter";
-export var SizeUnit;
-(function (SizeUnit) {
-    SizeUnit["b"] = "b";
-    SizeUnit["kB"] = "kB";
-    SizeUnit["MB"] = "MB";
-    SizeUnit["GB"] = "GB";
-})(SizeUnit || (SizeUnit = {}));
-export const SizeValue = z.number().positive().brand("SizeValue");
+import { SizeBytes } from "./size-bytes.vo";
+var SizeUnitEnum;
+(function (SizeUnitEnum) {
+    SizeUnitEnum["b"] = "b";
+    SizeUnitEnum["kB"] = "kB";
+    SizeUnitEnum["MB"] = "MB";
+    SizeUnitEnum["GB"] = "GB";
+})(SizeUnitEnum || (SizeUnitEnum = {}));
 export class Size {
     unit;
-    value;
     bytes;
     static KB_MULTIPLIER = 1024;
     static MB_MULTIPLIER = 1024 * Size.KB_MULTIPLIER;
@@ -18,27 +16,19 @@ export class Size {
     static ROUNDER = new RoundToDecimal(2);
     constructor(config) {
         this.unit = config.unit;
-        this.value = SizeValue.parse(config.value);
-        this.bytes = this.calculateBytes();
+        this.bytes = this.calculateBytes(config.value, config.unit);
     }
-    static fromBytes(candidate) {
-        const value = SizeValue.parse(candidate);
-        return new Size({ value, unit: SizeUnit.b });
+    static fromBytes(value) {
+        return new Size({ value, unit: SizeUnitEnum.b });
     }
-    static fromKb(candidate) {
-        const value = SizeValue.parse(candidate);
-        return new Size({ value, unit: SizeUnit.kB });
+    static fromKb(value) {
+        return new Size({ value, unit: SizeUnitEnum.kB });
     }
-    static fromMB(candidate) {
-        const value = SizeValue.parse(candidate);
-        return new Size({ value, unit: SizeUnit.MB });
+    static fromMB(value) {
+        return new Size({ value, unit: SizeUnitEnum.MB });
     }
-    static fromGB(candidate) {
-        const value = SizeValue.parse(candidate);
-        return new Size({ value, unit: SizeUnit.GB });
-    }
-    toString() {
-        return `${this.value} ${this.unit}`;
+    static fromGB(value) {
+        return new Size({ value, unit: SizeUnitEnum.GB });
     }
     toBytes() {
         return this.bytes;
@@ -48,36 +38,36 @@ export class Size {
     }
     format(unit) {
         switch (unit) {
-            case SizeUnit.kB: {
-                return `${Size.ROUNDER.round(this.bytes / Size.KB_MULTIPLIER)} ${SizeUnit.kB}`;
-            }
-            case SizeUnit.MB: {
-                return `${Size.ROUNDER.round(this.bytes / Size.MB_MULTIPLIER)} ${SizeUnit.MB}`;
-            }
-            case SizeUnit.GB: {
-                return `${Size.ROUNDER.round(this.bytes / Size.GB_MULTIPLIER)} ${SizeUnit.GB}`;
-            }
-            default: {
-                // SizeUnit.b
-                return `${this.bytes} ${SizeUnit.b}`;
-            }
+            case SizeUnitEnum.kB:
+                return `${Size.ROUNDER.round(this.bytes / Size.KB_MULTIPLIER)} ${SizeUnitEnum.kB}`;
+            case SizeUnitEnum.MB:
+                return `${Size.ROUNDER.round(this.bytes / Size.MB_MULTIPLIER)} ${SizeUnitEnum.MB}`;
+            case SizeUnitEnum.GB:
+                return `${Size.ROUNDER.round(this.bytes / Size.GB_MULTIPLIER)} ${SizeUnitEnum.GB}`;
+            default:
+                return `${this.bytes} ${SizeUnitEnum.b}`;
         }
     }
     static toBytes(config) {
         return new Size(config).toBytes();
     }
-    static unit = SizeUnit;
-    calculateBytes() {
-        switch (this.unit) {
-            case SizeUnit.kB:
-                return SizeValue.parse(this.value * Size.KB_MULTIPLIER);
-            case SizeUnit.MB:
-                return SizeValue.parse(this.value * Size.MB_MULTIPLIER);
-            case SizeUnit.GB:
-                return SizeValue.parse(this.value * Size.GB_MULTIPLIER);
+    static unit = SizeUnitEnum;
+    calculateBytes(value, unit) {
+        switch (unit) {
+            case SizeUnitEnum.kB:
+                return SizeBytes.parse(value * Size.KB_MULTIPLIER);
+            case SizeUnitEnum.MB:
+                return SizeBytes.parse(value * Size.MB_MULTIPLIER);
+            case SizeUnitEnum.GB:
+                return SizeBytes.parse(value * Size.GB_MULTIPLIER);
             default:
-                // SizeUnit.b
-                return this.value;
+                return SizeBytes.parse(value);
         }
     }
+    toString() {
+        return this.format(this.unit);
+    }
+    toJSON() {
+        return { bytes: this.bytes };
+    }
 }

package/dist/stopwatch.service.d.ts

@@ -1,6 +1,8 @@
 import { Duration } from "./duration.service";
 import { type TimestampType } from "./timestamp.vo";
-export declare const StopwatchStateError: "stopwatch.already.stopped";
+export declare const StopwatchError: {
+    readonly AlreadyStopped: "stopwatch.already.stopped";
+};
 export type StopwatchResultType = Duration;
 export declare class Stopwatch {
     private readonly startMs;

package/dist/stopwatch.service.js

@@ -1,11 +1,11 @@
 import { Duration } from "./duration.service";
 import { Timestamp } from "./timestamp.vo";
+export const StopwatchError = { AlreadyStopped: "stopwatch.already.stopped" };
 var StopwatchState;
 (function (StopwatchState) {
     StopwatchState["started"] = "started";
     StopwatchState["stopped"] = "stopped";
 })(StopwatchState || (StopwatchState = {}));
-export const StopwatchStateError = "stopwatch.already.stopped";
 export class Stopwatch {
     startMs;
     state = StopwatchState.started;
@@ -14,7 +14,7 @@ export class Stopwatch {
     }
     stop() {
         if (this.state === StopwatchState.stopped)
-            throw new Error(StopwatchStateError);
+            throw new Error(StopwatchError.AlreadyStopped);
         this.state = StopwatchState.stopped;
         return Duration.Ms(Timestamp.parse(Date.now() - this.startMs));
     }

package/dist/sum.service.js

@@ -3,14 +3,14 @@ export class Sum {
         return values.reduce((sum, x) => sum + x, 0);
     }
     static precise(values) {
-        let runningTotal = 0;
-        let roundingCompensation = 0;
-        for (const currentValue of values) {
-            const correctedAddend = currentValue - roundingCompensation;
-            const tentativeTotal = runningTotal + correctedAddend;
-            roundingCompensation = tentativeTotal - runningTotal - correctedAddend;
-            runningTotal = tentativeTotal;
+        let sum = 0;
+        let compensation = 0;
+        for (const value of values) {
+            const adjusted = value - compensation;
+            const temporary = sum + adjusted;
+            compensation = temporary - sum - adjusted;
+            sum = temporary;
         }
-        return runningTotal;
+        return sum;
     }
 }

package/dist/thousands-separator.service.js

@@ -1,6 +1,9 @@
 export class ThousandsSeparator {
     static DEFAULT_SEPARATOR = " ";
     static format(value, separator = ThousandsSeparator.DEFAULT_SEPARATOR) {
-        return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+        // B - not a word boundary, prevents inserting at the very start
+        // (?=([0-9]{3})+(?![0-9])) - positive lookahead, find three digits
+        // (?![0-9]) - negative lookahead, the next character is not a digit
+        return value.toString().replace(/\B(?=([0-9]{3})+(?![0-9]))/g, separator);
     }
 }

package/dist/time.service.d.ts

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,13 @@
+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/dist/timestamp.vo.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod/v4";
 export declare const TimestampError: {
-    readonly error: "invalid.timestamp";
+    readonly Invalid: "timestamp.invalid";
 };
 export declare const Timestamp: z.core.$ZodBranded<z.ZodNumber, "Timestamp">;
 export type TimestampType = z.infer<typeof Timestamp>;

package/dist/timestamp.vo.js

@@ -1,8 +1,7 @@
 import { z } from "zod/v4";
-export const TimestampError = { error: "invalid.timestamp" };
+export const TimestampError = { Invalid: "timestamp.invalid" };
 export const Timestamp = z
-    .number(TimestampError)
-    .int(TimestampError)
-    .gte(0, TimestampError)
-    .lte(Number.MAX_SAFE_INTEGER, TimestampError)
+    .number(TimestampError.Invalid)
+    .int(TimestampError.Invalid)
+    .gte(0, TimestampError.Invalid)
     .brand("Timestamp");

package/dist/timezone.vo.d.ts

@@ -1,6 +1,9 @@
 import { z } from "zod/v4";
 export declare const TimezoneError: {
-    readonly error: "timezone.invalid";
+    readonly Type: "timezone.type";
+    readonly Empty: "timezone.empty";
+    readonly TooLong: "timezone.too.long";
+    readonly Invalid: "timezone.invalid";
 };
 export declare const Timezone: z.core.$ZodBranded<z.ZodString, "Timezone">;
 export type TimezoneType = z.infer<typeof Timezone>;

package/dist/timezone.vo.js

@@ -1,15 +1,21 @@
 import { z } from "zod/v4";
-export const TimezoneError = { error: "timezone.invalid" };
+export const TimezoneError = {
+    Type: "timezone.type",
+    Empty: "timezone.empty",
+    TooLong: "timezone.too.long",
+    Invalid: "timezone.invalid",
+};
 export const Timezone = z
-    .string(TimezoneError)
-    .min(1, TimezoneError)
+    .string(TimezoneError.Type)
+    .min(1, TimezoneError.Empty)
+    .max(128, TimezoneError.TooLong)
     .refine((value) => {
     try {
-        new Intl.DateTimeFormat("en-US", { timeZone: value }).format(new Date());
+        new Intl.DateTimeFormat("en-US", { timeZone: value }).format(Date.now());
         return true;
     }
-    catch (_error) {
+    catch {
         return false;
     }
-}, TimezoneError)
+}, TimezoneError.Invalid)
     .brand("Timezone");

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/duration.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/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-years.vo.ts","../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/division-factor.vo.ts","../src/dll.service.ts","../src/duration-ms.vo.ts","../src/duration.service.ts","../src/email-mask.service.ts","../src/etags.vo.ts","../src/extension.vo.ts","../src/feature-flag-value.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-milimiters.vo.ts","../src/height.vo.ts","../src/hour-format.service.ts","../src/hour-schema.vo.ts","../src/hour.vo.ts","../src/iban-mask.service.ts","../src/iban-schema.vo.ts","../src/iban.vo.ts","../src/image.vo.ts","../src/index.ts","../src/language.vo.ts","../src/linear-regression.service.ts","../src/mean.service.ts","../src/mime-types.vo.ts","../src/mime-value.vo.ts","../src/mime.vo.ts","../src/min-max-scaler.service.ts","../src/minute-schema.vo.ts","../src/minute.vo.ts","../src/money-amount.vo.ts","../src/money.vo.ts","../src/month-iso-id.vo.ts","../src/month.vo.ts","../src/multiplication-factor.vo.ts","../src/noop.service.ts","../src/notification-template.vo.ts","../src/object-key.vo.ts","../src/outlier-detector.service.ts","../src/package-version-schema.vo.ts","../src/package-version.vo.ts","../src/pagination-page.vo.ts","../src/pagination-skip.vo.ts","../src/pagination-take.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-item-position-value.vo.ts","../src/reordering.service.ts","../src/revision-value.vo.ts","../src/revision.vo.ts","../src/rounding.adapter.ts","../src/rounding.port.ts","../src/size-bytes.vo.ts","../src/size.vo.ts","../src/stopwatch.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-grams.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,6 +1,8 @@
 import { z } from "zod/v4";
 export declare const WeekIsoIdError: {
-    readonly error: "week-iso-id.invalid";
+    readonly Type: "week.iso.id.type";
+    readonly BadChars: "week.iso.id.bad.chars";
+    readonly Invalid: "week.iso.id.invalid";
 };
-export declare const WeekIsoId: z.ZodString;
+export declare const WeekIsoId: z.core.$ZodBranded<z.ZodString, "WeekIsoId">;
 export type WeekIsoIdType = z.infer<typeof WeekIsoId>;

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

@@ -1,15 +1,21 @@
 import { getISOWeeksInYear } from "date-fns";
 import { z } from "zod/v4";
-export const WeekIsoIdError = { error: "week-iso-id.invalid" };
+export const WeekIsoIdError = {
+    Type: "week.iso.id.type",
+    BadChars: "week.iso.id.bad.chars",
+    Invalid: "week.iso.id.invalid",
+};
+// Four digits, hypen, W, followed by two digits
+const WEEK_ISO_ID_CHARS_WHITELIST = /^[0-9]{4}-W[0-9]{2}$/;
 export const WeekIsoId = z
-    .string(WeekIsoIdError)
-    .regex(/^\d{4}-W\d{2}$/, WeekIsoIdError)
+    .string(WeekIsoIdError.Type)
+    .regex(WEEK_ISO_ID_CHARS_WHITELIST, WeekIsoIdError.BadChars)
     .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)
+    const [year, week] = value.split("-W").map(Number);
+    // ISO-8601 rule: Jan 4 is always in week 01 of the ISO week-year.
+    const weeksInYear = getISOWeeksInYear(Date.UTC(year, 0, 4));
+    if (week < 1)
         return false;
-    const weeksInYear = getISOWeeksInYear(new Date(Date.UTC(year, 0, 4)));
     return week <= weeksInYear;
-}, WeekIsoIdError);
+}, WeekIsoIdError.Invalid)
+    .brand("WeekIsoId");