@bgord/tools 1.3.24 → 1.4.0

package/dist/src/pagination-skip.vo.js

@@ -0,0 +1,3 @@
+import * as v from "valibot";
+export const PaginationSkipError = { Type: "pagination.skip.type", Invalid: "pagination.skip.invalid" };
+export const Skip = v.pipe(v.number(PaginationSkipError.Type), v.integer(PaginationSkipError.Type), v.minValue(0, PaginationSkipError.Invalid));

package/dist/src/pagination-take.vo.d.ts

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export declare const PaginationTakeError: {
+    Type: string;
+    Invalid: string;
+};
+export declare const Take: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 1, string>]>;
+export type TakeType = v.InferOutput<typeof Take>;

package/dist/src/pagination-take.vo.js

@@ -0,0 +1,3 @@
+import * as v from "valibot";
+export const PaginationTakeError = { Type: "pagination.take.type", Invalid: "pagination.take.invalid" };
+export const Take = v.pipe(v.number(PaginationTakeError.Type), v.integer(PaginationTakeError.Type), v.minValue(1, PaginationTakeError.Invalid));

package/dist/{pagination.service.js → src/pagination.service.js}

@@ -1,20 +1,21 @@
+import * as v from "valibot";
 import { Page } from "./pagination-page.vo";
 import { Skip } from "./pagination-skip.vo";
 import { Take } from "./pagination-take.vo";
 import { RoundingUpStrategy } from "./rounding-up.strategy";
 export class Pagination {
     static parse(values, _take) {
-        const page = Page.parse(values.page);
-        const take = Take.parse(_take);
-        const skip = Skip.parse((page - 1) * take);
+        const page = v.parse(Page, values.page);
+        const take = v.parse(Take, _take);
+        const skip = v.parse(Skip, (page - 1) * take);
         return { values: { take, skip }, page };
     }
     static prepare(config) {
         const exhausted = Pagination.isExhausted(config);
         const currentPage = config.pagination.page;
         const lastPage = Pagination.getLastPage(config);
-        const previousPage = currentPage > 1 ? Page.parse(currentPage - 1) : undefined;
-        const nextPage = currentPage < lastPage ? Page.parse(currentPage + 1) : undefined;
+        const previousPage = currentPage > 1 ? v.parse(Page, currentPage - 1) : undefined;
+        const nextPage = currentPage < lastPage ? v.parse(Page, currentPage + 1) : undefined;
         return {
             result: config.result,
             meta: { exhausted, currentPage, previousPage, nextPage, lastPage, total: config.total },
@@ -24,7 +25,7 @@ export class Pagination {
         return Pagination.getLastPage(config) <= config.pagination.page;
     }
     static getLastPage(config) {
-        return Page.parse(new RoundingUpStrategy().round(config.total / config.pagination.values.take));
+        return v.parse(Page, new RoundingUpStrategy().round(config.total / config.pagination.values.take));
     }
     static empty = {
         result: [],
@@ -38,6 +39,6 @@ export class Pagination {
         },
     };
     static getFirstPage(input) {
-        return { values: { take: Take.parse(input.take), skip: Skip.parse(0) }, page: Page.parse(1) };
+        return { values: { take: v.parse(Take, input.take), skip: v.parse(Skip, 0) }, page: v.parse(Page, 1) };
     }
 }

package/dist/src/quarter-iso-id.vo.d.ts

@@ -0,0 +1,8 @@
+import * as v from "valibot";
+export declare const QuarterIsoIdError: {
+    Type: string;
+    BadChars: string;
+};
+export declare const QUARTER_ISO_ID_CHARS_WHITELIST: RegExp;
+export declare const QuarterIsoId: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.RegexAction<string, string>, v.BrandAction<string, "QuarterIsoId">]>;
+export type QuarterIsoIdType = v.InferOutput<typeof QuarterIsoId>;

package/dist/src/quarter-iso-id.vo.js

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export const QuarterIsoIdError = { Type: "quarter.iso.id.type", BadChars: "quarter.iso.id.bad.chars" };
+// 4 digits, hyphen, Q, digits from 1 to 4
+export const QUARTER_ISO_ID_CHARS_WHITELIST = /^\d{4}-Q[1-4]$/;
+export const QuarterIsoId = v.pipe(v.string(QuarterIsoIdError.Type), v.regex(QUARTER_ISO_ID_CHARS_WHITELIST, QuarterIsoIdError.BadChars), 
+// Stryker disable next-line StringLiteral
+v.brand("QuarterIsoId"));

package/dist/{quarter.vo.js → src/quarter.vo.js}

@@ -1,4 +1,5 @@
 import { endOfQuarter, getQuarter, getYear, startOfQuarter } from "date-fns";
+import * as v from "valibot";
 import { DateRange } from "./date-range.vo";
 import { QuarterIsoId } from "./quarter-iso-id.vo";
 import { Timestamp } from "./timestamp.vo";
@@ -15,13 +16,13 @@ export class Quarter extends DateRange {
         return Quarter.fromTimestamp(now);
     }
     static fromIsoId(isoId) {
-        const [year, quarter] = QuarterIsoId.parse(isoId).split("-Q").map(Number);
+        const [year, quarter] = v.parse(QuarterIsoId, isoId).split("-Q").map(Number);
         return Quarter.fromTimestamp(Timestamp.fromNumber(Date.UTC(year, (quarter - 1) * 3, 1)));
     }
     toIsoId() {
         const year = getYear(this.getStart().ms);
         const quarter = getQuarter(this.getStart().ms);
-        return QuarterIsoId.parse(`${year}-Q${quarter}`);
+        return v.parse(QuarterIsoId, `${year}-Q${quarter}`);
     }
     toString() {
         return this.toIsoId();

package/dist/src/reordering-item-position-value.vo.d.ts

@@ -0,0 +1,6 @@
+import * as v from "valibot";
+export declare const ReorderingItemPositionValueError: {
+    Invalid: string;
+};
+export declare const ReorderingItemPositionValue: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 0, string>]>;
+export type ReorderingItemPositionValueType = v.InferOutput<typeof ReorderingItemPositionValue>;

package/dist/src/reordering-item-position-value.vo.js

@@ -0,0 +1,3 @@
+import * as v from "valibot";
+export const ReorderingItemPositionValueError = { Invalid: "reordering.position.type" };
+export const ReorderingItemPositionValue = v.pipe(v.number(ReorderingItemPositionValueError.Invalid), v.integer(ReorderingItemPositionValueError.Invalid), v.minValue(0, ReorderingItemPositionValueError.Invalid));

package/dist/{reordering.service.d.ts → src/reordering.service.d.ts}

@@ -1,18 +1,18 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 import { type ReorderingItemPositionValueType } from "./reordering-item-position-value.vo";
 export declare const ReorderingError: {
     CannotFindItem: string;
     CannotFindCurrent: string;
     CannotFindTarget: string;
 };
-export declare const ReorderingId: z.ZodString;
-export type ReorderingItemIdType = z.infer<typeof ReorderingId>;
-export declare const Reordering: z.ZodObject<{
-    correlationId: z.ZodString;
-    id: z.ZodString;
-    position: z.ZodNumber;
-}, z.core.$strip>;
-export type ReorderingType = z.infer<typeof Reordering>;
+export declare const ReorderingId: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>]>;
+export type ReorderingItemIdType = v.InferOutput<typeof ReorderingId>;
+export declare const Reordering: v.ObjectSchema<{
+    readonly correlationId: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>]>;
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>]>;
+    readonly position: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 0, string>]>;
+}, undefined>;
+export type ReorderingType = v.InferOutput<typeof Reordering>;
 export type WithReorderingPositionValue<T> = T & {
     position: ReorderingItemPositionValueType;
 };

package/dist/{reordering.service.js → src/reordering.service.js}

@@ -1,5 +1,5 @@
 // Stryker disable all
-import * as z from "zod/v4";
+import * as v from "valibot";
 import { DoublyLinkedList, Node } from "./dll.service";
 import { ReorderingItemPositionValue, } from "./reordering-item-position-value.vo";
 export const ReorderingError = {
@@ -8,8 +8,8 @@ export const ReorderingError = {
     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({
+export const ReorderingId = v.pipe(v.string(ReorderingIdError.Type), v.minLength(1, ReorderingIdError.Type));
+export const Reordering = v.object({
     correlationId: ReorderingId,
     id: ReorderingId,
     position: ReorderingItemPositionValue,
@@ -17,7 +17,7 @@ export const Reordering = z.object({
 export class ReorderingPosition {
     value;
     constructor(value) {
-        this.value = ReorderingItemPositionValue.parse(value);
+        this.value = v.parse(ReorderingItemPositionValue, value);
     }
     eq(another) {
         return this.value === another.value;
@@ -71,7 +71,7 @@ export class ReorderingCalculator {
     }
     add(id) {
         const size = this.dll.getSize();
-        const position = new ReorderingPosition(ReorderingItemPositionValue.parse(size));
+        const position = new ReorderingPosition(v.parse(ReorderingItemPositionValue, size));
         const item = new ReorderingItem(id, position);
         const node = new Node(item);
         this.dll.append(node);
@@ -114,7 +114,7 @@ export class ReorderingCalculator {
         let index = 0;
         for (const node of this.dll) {
             const id = node.data.id;
-            const position = new ReorderingPosition(ReorderingItemPositionValue.parse(index));
+            const position = new ReorderingPosition(v.parse(ReorderingItemPositionValue, index));
             node.data = new ReorderingItem(id, position);
             index += 1;
         }
@@ -124,7 +124,7 @@ export class ReorderingIntegrator {
     static appendPosition(reordering) {
         return function (item) {
             const found = reordering.find((x) => x.id === item.id);
-            const positionValue = ReorderingItemPositionValue.parse(found?.position ?? 0);
+            const positionValue = v.parse(ReorderingItemPositionValue, found?.position ?? 0);
             return { ...item, position: positionValue };
         };
     }

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

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export declare const RevisionValueError: {
+    Type: string;
+    Invalid: string;
+};
+export declare const RevisionValue: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 0, string>]>;
+export type RevisionValueType = v.InferOutput<typeof RevisionValue>;

package/dist/src/revision-value.vo.js

@@ -0,0 +1,3 @@
+import * as v from "valibot";
+export const RevisionValueError = { Type: "revision.value.type", Invalid: "revision.value.invalid" };
+export const RevisionValue = v.pipe(v.number(RevisionValueError.Type), v.integer(RevisionValueError.Type), v.minValue(0, RevisionValueError.Invalid));

package/dist/{revision.vo.js → src/revision.vo.js}

@@ -1,10 +1,11 @@
+import * as v from "valibot";
 import { RevisionValue } from "./revision-value.vo";
 export const RevisionError = { Missing: "revision.missing", Mismatch: "revision.mismatch" };
 export class Revision {
-    static INITIAL = RevisionValue.parse(0);
+    static INITIAL = v.parse(RevisionValue, 0);
     value;
     constructor(value) {
-        this.value = RevisionValue.parse(value);
+        this.value = v.parse(RevisionValue, value);
     }
     equals(another) {
         return this.value === another;

package/dist/{rounding-decimal.strategy.d.ts → src/rounding-decimal.strategy.d.ts}

@@ -1,10 +1,10 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 import type { RoundingStrategy } from "./rounding.strategy";
 export declare const RoundingDecimalError: {
     Type: string;
     Invalid: string;
 };
-export declare const RoundingDecimal: z.core.$ZodBranded<z.ZodNumber, "RoundingDecimal", "out">;
+export declare const RoundingDecimal: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 1, string>, v.MaxValueAction<number, 100, string>, v.BrandAction<number, "RoundingDecimal">]>;
 export declare class RoundingDecimalStrategy implements RoundingStrategy {
     private readonly decimals;
     constructor(candidate: number);

package/dist/src/rounding-decimal.strategy.js

@@ -0,0 +1,14 @@
+import * as v from "valibot";
+export const RoundingDecimalError = { Type: "rounding.decimal.type", Invalid: "rounding.decimal.invalid" };
+export const RoundingDecimal = v.pipe(v.number(RoundingDecimalError.Type), v.integer(RoundingDecimalError.Invalid), v.minValue(1, RoundingDecimalError.Invalid), v.maxValue(100, RoundingDecimalError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("RoundingDecimal"));
+export class RoundingDecimalStrategy {
+    decimals;
+    constructor(candidate) {
+        this.decimals = v.parse(RoundingDecimal, candidate);
+    }
+    round(value) {
+        return Number.parseFloat(value.toFixed(this.decimals));
+    }
+}

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

@@ -0,0 +1,6 @@
+import * as v from "valibot";
+export declare const SizeBytesError: {
+    Invalid: string;
+};
+export declare const SizeBytes: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 0, string>, v.BrandAction<number, "SizeBytes">]>;
+export type SizeBytesType = v.InferOutput<typeof SizeBytes>;

package/dist/src/size-bytes.vo.js

@@ -0,0 +1,5 @@
+import * as v from "valibot";
+export const SizeBytesError = { Invalid: "size.bytes.invalid" };
+export const SizeBytes = v.pipe(v.number(SizeBytesError.Invalid), v.integer(SizeBytesError.Invalid), v.minValue(0, SizeBytesError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("SizeBytes"));

package/dist/{size.vo.js → src/size.vo.js}

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import { RoundingDecimalStrategy } from "./rounding-decimal.strategy";
 import { RoundingUpStrategy } from "./rounding-up.strategy";
 import { SizeBytes } from "./size-bytes.vo";
@@ -72,13 +73,13 @@ export class Size {
     calculateBytes(value, unit) {
         switch (unit) {
             case SizeUnitEnum.kB:
-                return SizeBytes.parse(value * Size.KB_MULTIPLIER);
+                return v.parse(SizeBytes, value * Size.KB_MULTIPLIER);
             case SizeUnitEnum.MB:
-                return SizeBytes.parse(value * Size.MB_MULTIPLIER);
+                return v.parse(SizeBytes, value * Size.MB_MULTIPLIER);
             case SizeUnitEnum.GB:
-                return SizeBytes.parse(value * Size.GB_MULTIPLIER);
+                return v.parse(SizeBytes, value * Size.GB_MULTIPLIER);
             default:
-                return SizeBytes.parse(value);
+                return v.parse(SizeBytes, value);
         }
     }
     toString() {

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

@@ -0,0 +1,8 @@
+import * as v from "valibot";
+export declare const TimeZoneOffsetValueError: {
+    Type: string;
+    Min: string;
+    Max: string;
+};
+export declare const TimeZoneOffsetValue: v.SchemaWithPipe<readonly [v.UnknownSchema, v.TransformAction<unknown, number>, v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, -840, string>, v.MaxValueAction<number, 720, string>, v.BrandAction<number, "TimeZoneOffsetValue">]>;
+export type TimeZoneOffsetValueType = v.InferOutput<typeof TimeZoneOffsetValue>;

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

@@ -0,0 +1,13 @@
+import * as v from "valibot";
+export const TimeZoneOffsetValueError = {
+    Type: "time.zone.offset.value.type",
+    Min: "time.zone.offset.value.min",
+    Max: "time.zone.offset.value.max",
+};
+export const TimeZoneOffsetValue = v.pipe(v.unknown(), v.transform((value) => (value === undefined ? 0 : Number(value))), v.number(TimeZoneOffsetValueError.Type), v.integer(TimeZoneOffsetValueError.Type), 
+// UTC+14 (Kiribati)
+v.minValue(-840, TimeZoneOffsetValueError.Min), 
+// UTC-12 (Baker Island)
+v.maxValue(720, TimeZoneOffsetValueError.Max), 
+// Stryker disable next-line StringLiteral
+v.brand("TimeZoneOffsetValue"));

package/dist/src/timestamp-value.vo.d.ts

@@ -0,0 +1,6 @@
+import * as v from "valibot";
+export declare const TimestampValueError: {
+    Invalid: string;
+};
+export declare const TimestampValue: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 0, string>, v.BrandAction<number, "TimestampValue">]>;
+export type TimestampValueType = v.InferOutput<typeof TimestampValue>;

package/dist/src/timestamp-value.vo.js

@@ -0,0 +1,5 @@
+import * as v from "valibot";
+export const TimestampValueError = { Invalid: "timestamp.invalid" };
+export const TimestampValue = v.pipe(v.number(TimestampValueError.Invalid), v.integer(TimestampValueError.Invalid), v.minValue(0, TimestampValueError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("TimestampValue"));

package/dist/{timestamp.vo.js → src/timestamp.vo.js}

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import { Duration } from "./duration.service";
 import { TimestampValue } from "./timestamp-value.vo";
 export class Timestamp {
@@ -9,7 +10,7 @@ export class Timestamp {
         return new Timestamp(value);
     }
     static fromNumber(value) {
-        return new Timestamp(TimestampValue.parse(value));
+        return new Timestamp(v.parse(TimestampValue, value));
     }
     static fromDate(value) {
         return Timestamp.fromNumber(value.getTime());

package/dist/src/timezone.vo.d.ts

@@ -0,0 +1,9 @@
+import * as v from "valibot";
+export declare const TimezoneError: {
+    Type: string;
+    Empty: string;
+    TooLong: string;
+    Invalid: string;
+};
+export declare const Timezone: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>, v.MaxLengthAction<string, 128, string>, v.CheckAction<string, string>, v.BrandAction<string, "Timezone">]>;
+export type TimezoneType = v.InferOutput<typeof Timezone>;

package/dist/{timezone.vo.js → src/timezone.vo.js}

@@ -1,17 +1,12 @@
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const TimezoneError = {
     Type: "timezone.type",
     Empty: "timezone.empty",
     TooLong: "timezone.too.long",
     Invalid: "timezone.invalid",
 };
-// Stryker disable all
-export const Timezone = z
-    // Stryker restore all
-    .string(TimezoneError.Type)
-    .min(1, TimezoneError.Empty)
-    .max(128, TimezoneError.TooLong)
-    .refine((value) => {
+export const Timezone = v.pipe(v.string(TimezoneError.Type), v.minLength(1, TimezoneError.Empty), v.maxLength(128, TimezoneError.TooLong), v.check((value) => {
+    // Stryker disable all
     try {
         new Intl.DateTimeFormat("en-US", { timeZone: value }).format(Date.now());
         return true;
@@ -19,5 +14,7 @@ export const Timezone = z
     catch {
         return false;
     }
-}, TimezoneError.Invalid)
-    .brand("Timezone");
+    // Stryker restore all
+}, TimezoneError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("Timezone"));

package/dist/src/url-with-slash.vo.d.ts

@@ -0,0 +1,6 @@
+import * as v from "valibot";
+export declare const UrlWithSlashError: {
+    Invalid: string;
+};
+export declare const UrlWithSlash: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.UrlAction<string, string>, v.EndsWithAction<string, "/", string>, v.BrandAction<string, "UrlWithSlash">]>;
+export type UrlWithSlashType = v.InferOutput<typeof UrlWithSlash>;

package/dist/src/url-with-slash.vo.js

@@ -0,0 +1,5 @@
+import * as v from "valibot";
+export const UrlWithSlashError = { Invalid: "url.with.slash.invalid" };
+export const UrlWithSlash = v.pipe(v.string(UrlWithSlashError.Invalid), v.url(UrlWithSlashError.Invalid), v.endsWith("/", UrlWithSlashError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("UrlWithSlash"));

package/dist/src/url-without-slash.vo.d.ts

@@ -0,0 +1,6 @@
+import * as v from "valibot";
+export declare const UrlWithoutSlashError: {
+    Invalid: string;
+};
+export declare const UrlWithoutSlash: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.UrlAction<string, string>, v.CheckAction<string, string>, v.BrandAction<string, "UrlWithoutSlash">]>;
+export type UrlWithoutSlashType = v.InferOutput<typeof UrlWithoutSlash>;

package/dist/src/url-without-slash.vo.js

@@ -0,0 +1,5 @@
+import * as v from "valibot";
+export const UrlWithoutSlashError = { Invalid: "url.without.slash.invalid" };
+export const UrlWithoutSlash = v.pipe(v.string(UrlWithoutSlashError.Invalid), v.url(UrlWithoutSlashError.Invalid), v.check((value) => !value.endsWith("/"), UrlWithoutSlashError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("UrlWithoutSlash"));

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

@@ -0,0 +1,8 @@
+import * as v from "valibot";
+export declare const WeekIsoIdError: {
+    Type: string;
+    BadChars: string;
+    Invalid: string;
+};
+export declare const WeekIsoId: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.RegexAction<string, string>, v.CheckAction<string, string>, v.BrandAction<string, "WeekIsoId">]>;
+export type WeekIsoIdType = v.InferOutput<typeof WeekIsoId>;

package/dist/{week-iso-id.vo.js → src/week-iso-id.vo.js}

@@ -1,5 +1,5 @@
 import { getISOWeeksInYear } from "date-fns";
-import * as z from "zod/v4";
+import * as v from "valibot";
 export const WeekIsoIdError = {
     Type: "week.iso.id.type",
     BadChars: "week.iso.id.bad.chars",
@@ -7,17 +7,13 @@ export const WeekIsoIdError = {
 };
 // Four digits, hypen, W, followed by two digits
 const WEEK_ISO_ID_CHARS_WHITELIST = /^[0-9]{4}-W[0-9]{2}$/;
-// Stryker disable all
-export const WeekIsoId = z
-    // Stryker restore all
-    .string(WeekIsoIdError.Type)
-    .regex(WEEK_ISO_ID_CHARS_WHITELIST, WeekIsoIdError.BadChars)
-    .refine((value) => {
+export const WeekIsoId = v.pipe(v.string(WeekIsoIdError.Type), v.regex(WEEK_ISO_ID_CHARS_WHITELIST, WeekIsoIdError.BadChars), v.check((value) => {
     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;
     return week <= weeksInYear;
-}, WeekIsoIdError.Invalid)
-    .brand("WeekIsoId");
+}, WeekIsoIdError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("WeekIsoId"));

package/dist/{week.vo.js → src/week.vo.js}

@@ -1,4 +1,5 @@
 import { addWeeks, endOfISOWeek, getISOWeek, getISOWeekYear, startOfISOWeek } from "date-fns";
+import * as v from "valibot";
 import { DateRange } from "./date-range.vo";
 import { Duration } from "./duration.service";
 import { Integer } from "./integer.vo";
@@ -17,7 +18,7 @@ export class Week extends DateRange {
         return Week.fromTimestamp(now);
     }
     static fromIsoId(isoId) {
-        const [year, week] = WeekIsoId.parse(isoId).split("-W").map(Number);
+        const [year, week] = v.parse(WeekIsoId, isoId).split("-W").map(Number);
         // ISO-8601 rule: Jan 4 is always in week 01 of the ISO week-year.
         const januaryFourth = Timestamp.fromNumber(Date.UTC(year, 0, 4));
         const firstWeekStart = Timestamp.fromNumber(startOfISOWeek(januaryFourth.ms).getTime());
@@ -26,13 +27,13 @@ export class Week extends DateRange {
     toIsoId() {
         const year = getISOWeekYear(this.getStart().ms);
         const week = getISOWeek(this.getStart().ms);
-        return WeekIsoId.parse(`${year}-W${String(week).padStart(2, "0")}`);
+        return v.parse(WeekIsoId, `${year}-W${String(week).padStart(2, "0")}`);
     }
     previous() {
-        return this.shift(Integer.parse(-1));
+        return this.shift(v.parse(Integer, -1));
     }
     next() {
-        return this.shift(Integer.parse(1));
+        return this.shift(v.parse(Integer, 1));
     }
     shift(count) {
         const shifted = addWeeks(this.getStart().ms, count).getTime();

package/dist/src/weekday-iso-id.vo.d.ts

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export declare const WeekdayIsoIdError: {
+    Type: string;
+    Invalid: string;
+};
+export declare const WeekdayIsoId: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 1, string>, v.MaxValueAction<number, 7, string>, v.BrandAction<number, "WeekdayIsoId">]>;
+export type WeekdayIsoIdType = v.InferOutput<typeof WeekdayIsoId>;

package/dist/src/weekday-iso-id.vo.js

@@ -0,0 +1,5 @@
+import * as v from "valibot";
+export const WeekdayIsoIdError = { Type: "weekday.iso.id.type", Invalid: "weekday.iso.id.invalid" };
+export const WeekdayIsoId = v.pipe(v.number(WeekdayIsoIdError.Type), v.integer(WeekdayIsoIdError.Type), v.minValue(1, WeekdayIsoIdError.Invalid), v.maxValue(7, WeekdayIsoIdError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("WeekdayIsoId"));

package/dist/{weekday.vo.js → src/weekday.vo.js}

@@ -1,21 +1,22 @@
+import * as v from "valibot";
 import { Timestamp } from "./timestamp.vo";
 import { WeekdayIsoId } from "./weekday-iso-id.vo";
 export class Weekday {
     value;
-    static MONDAY = Weekday.fromIsoId(WeekdayIsoId.parse(1));
-    static TUESDAY = Weekday.fromIsoId(WeekdayIsoId.parse(2));
-    static WEDNESDAY = Weekday.fromIsoId(WeekdayIsoId.parse(3));
-    static THURSDAY = Weekday.fromIsoId(WeekdayIsoId.parse(4));
-    static FRIDAY = Weekday.fromIsoId(WeekdayIsoId.parse(5));
-    static SATURDAY = Weekday.fromIsoId(WeekdayIsoId.parse(6));
-    static SUNDAY = Weekday.fromIsoId(WeekdayIsoId.parse(7));
+    static MONDAY = Weekday.fromIsoId(v.parse(WeekdayIsoId, 1));
+    static TUESDAY = Weekday.fromIsoId(v.parse(WeekdayIsoId, 2));
+    static WEDNESDAY = Weekday.fromIsoId(v.parse(WeekdayIsoId, 3));
+    static THURSDAY = Weekday.fromIsoId(v.parse(WeekdayIsoId, 4));
+    static FRIDAY = Weekday.fromIsoId(v.parse(WeekdayIsoId, 5));
+    static SATURDAY = Weekday.fromIsoId(v.parse(WeekdayIsoId, 6));
+    static SUNDAY = Weekday.fromIsoId(v.parse(WeekdayIsoId, 7));
     constructor(value) {
         this.value = value;
     }
     static fromTimestamp(timestamp) {
         // UTC returns numbers from 0-6, starting from Sunday
         const utc = new Date(timestamp.ms).getUTCDay();
-        return new Weekday(WeekdayIsoId.parse(utc === 0 ? 7 : utc));
+        return new Weekday(v.parse(WeekdayIsoId, utc === 0 ? 7 : utc));
     }
     static fromTimestampValue(timestamp) {
         return Weekday.fromTimestamp(Timestamp.fromValue(timestamp));

package/dist/src/weight-grams.vo.d.ts

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export declare const WeightGramsError: {
+    Type: string;
+    Invalid: string;
+};
+export declare const WeightGrams: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 0, string>, v.BrandAction<number, "WeightGrams">]>;
+export type WeightGramsType = v.InferOutput<typeof WeightGrams>;

package/dist/src/weight-grams.vo.js

@@ -0,0 +1,5 @@
+import * as v from "valibot";
+export const WeightGramsError = { Type: "weight.grams.type", Invalid: "weight.grams.invalid" };
+export const WeightGrams = v.pipe(v.number(WeightGramsError.Type), v.integer(WeightGramsError.Type), v.minValue(0, WeightGramsError.Invalid), 
+// Stryker disable next-line StringLiteral
+v.brand("WeightGrams"));

package/dist/{weight.vo.js → src/weight.vo.js}

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 import { RoundingToNearestStrategy } from "./rounding-to-nearest.strategy";
 import { WeightGrams } from "./weight-grams.vo";
 export class Weight {
@@ -10,13 +11,13 @@ export class Weight {
     }
     static fromKilograms(kilograms, rounding = new RoundingToNearestStrategy()) {
         const grams = rounding.round(kilograms * Weight.GRAMS_PER_KILOGRAM);
-        return new Weight(WeightGrams.parse(grams), rounding);
+        return new Weight(v.parse(WeightGrams, grams), rounding);
     }
     static fromGrams(grams, rounding = new RoundingToNearestStrategy()) {
-        return new Weight(WeightGrams.parse(grams), rounding);
+        return new Weight(v.parse(WeightGrams, grams), rounding);
     }
     static zero() {
-        return new Weight(WeightGrams.parse(0));
+        return new Weight(v.parse(WeightGrams, 0));
     }
     get() {
         return this.grams;
@@ -29,19 +30,19 @@ export class Weight {
         return `${this.grams} g`;
     }
     add(other) {
-        return new Weight(WeightGrams.parse(this.grams + other.grams));
+        return new Weight(v.parse(WeightGrams, this.grams + other.grams));
     }
     subtract(other) {
         const result = this.grams - other.grams;
-        return new Weight(WeightGrams.parse(Math.max(0, result)), this.rounding);
+        return new Weight(v.parse(WeightGrams, Math.max(0, result)), this.rounding);
     }
     multiply(factor) {
         const grams = this.rounding.round(this.grams * factor);
-        return new Weight(WeightGrams.parse(grams));
+        return new Weight(v.parse(WeightGrams, grams));
     }
     divide(divisor) {
         const grams = this.rounding.round(this.grams / divisor);
-        return new Weight(WeightGrams.parse(grams));
+        return new Weight(v.parse(WeightGrams, grams));
     }
     equals(other) {
         return this.grams === other.grams;

package/dist/src/year-iso-id.vo.d.ts

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export declare const YearIsoIdError: {
+    Type: string;
+    BadChars: string;
+};
+export declare const YearIsoId: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.RegexAction<string, string>, v.BrandAction<string, "YearIsoId">]>;
+export type YearIsoIdType = v.InferOutput<typeof YearIsoId>;

package/dist/src/year-iso-id.vo.js

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+export const YearIsoIdError = { Type: "year.iso.id.type", BadChars: "year.iso.id.bad.chars" };
+// Four digits
+const YEAR_ISO_ID_CHARS_WHITELIST = /^[0-9]{4}$/;
+export const YearIsoId = v.pipe(v.string(YearIsoIdError.Type), v.regex(YEAR_ISO_ID_CHARS_WHITELIST, YearIsoIdError.BadChars), 
+// Stryker disable next-line StringLiteral
+v.brand("YearIsoId"));