@bgord/tools 0.15.1 → 0.16.0

package/dist/filename.vo.d.ts

@@ -1,6 +1,6 @@
 import { type BasenameType } from "./basename.vo";
 import { type ExtensionType } from "./extension.vo";
-import { type FilenameSuffixSchemaType } from "./filename-suffix.vo";
+import { type FilenameSuffixType } from "./filename-suffix.vo";
 export declare class Filename {
     private readonly basename;
     private readonly extension;
@@ -14,5 +14,5 @@ export declare class Filename {
     withExtension(extension: ExtensionType): Filename;
     withBasename(basename: BasenameType): Filename;
     withSuffix(candidate: string): Filename;
-    withSuffixSafe(suffix: FilenameSuffixSchemaType): Filename;
+    withSuffixSafe(suffix: FilenameSuffixType): Filename;
 }

package/dist/filename.vo.js

@@ -1,7 +1,7 @@
-import { BasenameSchema } from "./basename.vo";
-import { ExtensionSchema } from "./extension.vo";
-import { FilenameFromStringSchema } from "./filename-from-string.vo";
-import { FilenameSuffixSchema } from "./filename-suffix.vo";
+import { Basename } from "./basename.vo";
+import { Extension } from "./extension.vo";
+import { FilenameFromString } from "./filename-from-string.vo";
+import { FilenameSuffix } from "./filename-suffix.vo";
 export class Filename {
     basename;
     extension;
@@ -10,13 +10,13 @@ export class Filename {
         this.extension = extension;
     }
     static fromParts(basename, extension) {
-        return new Filename(BasenameSchema.parse(basename), ExtensionSchema.parse(extension));
+        return new Filename(Basename.parse(basename), Extension.parse(extension));
     }
     static fromPartsSafe(basename, extension) {
         return new Filename(basename, extension);
     }
     static fromString(candidate) {
-        const { basename, extension } = FilenameFromStringSchema.parse(candidate);
+        const { basename, extension } = FilenameFromString.parse(candidate);
         return new Filename(basename, extension);
     }
     get() {
@@ -35,12 +35,12 @@ export class Filename {
         return new Filename(basename, this.extension);
     }
     withSuffix(candidate) {
-        const suffix = FilenameSuffixSchema.parse(candidate);
-        const basename = BasenameSchema.parse(`${this.basename}${suffix}`);
+        const suffix = FilenameSuffix.parse(candidate);
+        const basename = Basename.parse(`${this.basename}${suffix}`);
         return new Filename(basename, this.extension);
     }
     withSuffixSafe(suffix) {
-        const basename = BasenameSchema.parse(`${this.basename}${suffix}`);
+        const basename = Basename.parse(`${this.basename}${suffix}`);
         return new Filename(basename, this.extension);
     }
 }

package/dist/height.vo.d.ts

@@ -13,6 +13,7 @@ export declare class Height {
     static fromFeetInches(feet: number, inches?: number, rounding?: RoundingPort): Height;
     static fromMillimeters(millimeters: number, rounding?: RoundingPort): Height;
     static zero(): Height;
+    get(): number;
     toMillimeters(): number;
     toCentimeters(rounding?: RoundingPort): number;
     toFeetInches(rounding?: RoundingPort): {
@@ -20,10 +21,11 @@ export declare class Height {
         inches: number;
     };
     format(unit: HeightUnit, rounding?: RoundingPort): string;
-    equals(other: Height): boolean;
-    compare(other: Height): -1 | 0 | 1;
-    greaterThan(other: Height): boolean;
-    lessThan(other: Height): boolean;
+    toString(): string;
+    equals(another: Height): boolean;
+    compare(another: Height): -1 | 0 | 1;
+    greaterThan(another: Height): boolean;
+    lessThan(another: Height): boolean;
     isZero(): boolean;
     toJSON(): {
         mm: number;

package/dist/height.vo.js

@@ -1,13 +1,13 @@
 import { z } from "zod/v4";
 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, {
-    message: "Millimeters must be an integer greater than or equal to 0",
-});
-const NonNegativeIntegerValue = FiniteNumericValue.int().min(0, {
-    message: "Value must be an integer greater than or equal to 0",
-});
+const NonFiniteNumberError = { error: "number.non_finite" };
+const NumberNegativeError = { error: "number.negative" };
+const MillimetersIntegerNonNegativeError = { error: "millimeters.integer_non_negative" };
+const IntegerNonNegativeError = { error: "integer.non_negative" };
+const HeightFiniteNumber = z.number(NonFiniteNumberError).refine(Number.isFinite, NonFiniteNumberError);
+const HeightNonNegativeQuantity = HeightFiniteNumber.min(0, NumberNegativeError);
+const HeightCanonicalMillimeters = HeightFiniteNumber.int(MillimetersIntegerNonNegativeError).min(0, MillimetersIntegerNonNegativeError);
+const HeightRoundedWholeInches = HeightFiniteNumber.int(IntegerNonNegativeError).min(0, IntegerNonNegativeError);
 export var HeightUnit;
 (function (HeightUnit) {
     HeightUnit["cm"] = "cm";
@@ -22,71 +22,76 @@ export class Height {
         this.millimeters = millimeters;
     }
     static fromCentimeters(centimeters, rounding = new RoundToNearest()) {
-        NonNegativeNumericValue.parse(centimeters);
-        const mmFloat = centimeters * Height.MILLIMETERS_PER_CENTIMETER;
-        const mmRounded = rounding.round(mmFloat);
-        NonNegativeIntegerMillimeters.parse(mmRounded);
-        return new Height(mmRounded);
+        const validatedCentimeters = HeightNonNegativeQuantity.parse(centimeters);
+        const millimetersFloat = validatedCentimeters * Height.MILLIMETERS_PER_CENTIMETER;
+        const millimetersRounded = rounding.round(millimetersFloat);
+        const validatedMillimeters = HeightCanonicalMillimeters.parse(millimetersRounded);
+        return new Height(validatedMillimeters);
     }
     static fromFeetInches(feet, inches = 0, rounding = new RoundToNearest()) {
-        NonNegativeNumericValue.parse(feet);
-        NonNegativeNumericValue.parse(inches);
-        const totalInches = feet * Height.INCHES_PER_FOOT + inches;
-        const mmFloat = totalInches * Height.MILLIMETERS_PER_INCH;
-        const mmRounded = rounding.round(mmFloat);
-        NonNegativeIntegerMillimeters.parse(mmRounded);
-        return new Height(mmRounded);
+        const validatedFeet = HeightNonNegativeQuantity.parse(feet);
+        const validatedInches = HeightNonNegativeQuantity.parse(inches);
+        const totalInches = validatedFeet * Height.INCHES_PER_FOOT + validatedInches;
+        const millimetersFloat = totalInches * Height.MILLIMETERS_PER_INCH;
+        const millimetersRounded = rounding.round(millimetersFloat);
+        const validatedMillimeters = HeightCanonicalMillimeters.parse(millimetersRounded);
+        return new Height(validatedMillimeters);
     }
     static fromMillimeters(millimeters, rounding = new RoundToNearest()) {
-        NonNegativeNumericValue.parse(millimeters);
-        const mmRounded = rounding.round(millimeters);
-        NonNegativeIntegerMillimeters.parse(mmRounded);
-        return new Height(mmRounded);
+        const validatedMillimetersInput = HeightNonNegativeQuantity.parse(millimeters);
+        const millimetersRounded = rounding.round(validatedMillimetersInput);
+        const validatedMillimeters = HeightCanonicalMillimeters.parse(millimetersRounded);
+        return new Height(validatedMillimeters);
     }
     static zero() {
         return new Height(0);
     }
+    get() {
+        return this.millimeters;
+    }
     toMillimeters() {
         return this.millimeters;
     }
     toCentimeters(rounding) {
-        const cm = this.millimeters / Height.MILLIMETERS_PER_CENTIMETER;
-        return rounding ? rounding.round(cm) : cm;
+        const centimeters = this.millimeters / Height.MILLIMETERS_PER_CENTIMETER;
+        if (rounding)
+            return rounding.round(centimeters);
+        return centimeters;
     }
     toFeetInches(rounding = new RoundToNearest()) {
         const totalInchesFloat = this.millimeters / Height.MILLIMETERS_PER_INCH;
         const totalInchesRounded = rounding.round(totalInchesFloat);
-        const integerInches = NonNegativeIntegerValue.parse(totalInchesRounded);
-        const feet = (integerInches - (integerInches % Height.INCHES_PER_FOOT)) / Height.INCHES_PER_FOOT;
-        const inches = integerInches % Height.INCHES_PER_FOOT;
+        const totalWholeInches = HeightRoundedWholeInches.parse(totalInchesRounded);
+        const feet = Math.floor(totalWholeInches / Height.INCHES_PER_FOOT);
+        const inches = totalWholeInches % Height.INCHES_PER_FOOT;
         return { feet, inches };
     }
     format(unit, rounding) {
-        return {
-            [HeightUnit.cm]: () => {
-                const chosen = rounding ?? new RoundToDecimal(1);
-                return `${this.toCentimeters(chosen)} cm`;
-            },
-            [HeightUnit.ft_in]: () => {
-                const chosen = rounding ?? new RoundToNearest();
-                const { feet, inches } = this.toFeetInches(chosen);
-                return `${feet}′${inches}″`;
-            },
-        }[unit]();
-    }
-    equals(other) {
-        return this.millimeters === other.millimeters;
-    }
-    compare(other) {
-        if (this.equals(other))
+        if (unit === HeightUnit.cm) {
+            const chosen = rounding ?? new RoundToDecimal(1);
+            const value = this.toCentimeters(chosen);
+            return `${value} cm`;
+        }
+        const chosen = rounding ?? new RoundToNearest();
+        const parts = this.toFeetInches(chosen);
+        return `${parts.feet}′${parts.inches}″`;
+    }
+    toString() {
+        return this.format(HeightUnit.cm, new RoundToDecimal(1));
+    }
+    equals(another) {
+        return this.millimeters === another.millimeters;
+    }
+    compare(another) {
+        if (this.equals(another))
             return 0;
-        return this.millimeters < other.millimeters ? -1 : 1;
+        return this.millimeters < another.millimeters ? -1 : 1;
     }
-    greaterThan(other) {
-        return this.millimeters > other.millimeters;
+    greaterThan(another) {
+        return this.millimeters > another.millimeters;
     }
-    lessThan(other) {
-        return this.millimeters < other.millimeters;
+    lessThan(another) {
+        return this.millimeters < another.millimeters;
     }
     isZero() {
         return this.millimeters === 0;

package/dist/index.d.ts

@@ -53,7 +53,6 @@ export * from "./rounding.adapter";
 export * from "./rounding.port";
 export * from "./simple-linear-regression.service";
 export * from "./size.vo";
-export * from "./stepper.service";
 export * from "./stopwatch.service";
 export * from "./streak-calculator.service";
 export * from "./sum.service";

package/dist/index.js

@@ -53,7 +53,6 @@ export * from "./rounding.adapter";
 export * from "./rounding.port";
 export * from "./simple-linear-regression.service";
 export * from "./size.vo";
-export * from "./stepper.service";
 export * from "./stopwatch.service";
 export * from "./streak-calculator.service";
 export * from "./sum.service";

package/dist/language.vo.d.ts

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

package/dist/language.vo.js

@@ -3,5 +3,4 @@ export const LanguageError = { error: "invalid.language" };
 export const Language = z
     .string(LanguageError)
     .length(2, LanguageError)
-    .regex(/^[a-z]{2}$/, LanguageError)
-    .brand("Language");
+    .regex(/^[a-z]{2}$/, LanguageError);

package/dist/mime.vo.d.ts

@@ -2,6 +2,8 @@ import { type ExtensionType } from "./extension.vo";
 export type MimeRawType = string;
 type MimeTypeType = string;
 type MimeSubtypeType = string;
+export declare const InvalidMimeErrorMessage: "invalid.mime";
+export declare const NotAcceptedMimeErrorMessage: "mime.not.accepted";
 export declare class Mime {
     readonly raw: MimeRawType;
     readonly type: MimeTypeType;
@@ -16,7 +18,7 @@ export declare class InvalidMimeError extends Error {
 }
 export declare class NotAcceptedMimeError extends Error {
     mime: MimeRawType;
-    constructor(mime: MimeRawType);
+    constructor(mimeValue: MimeRawType);
 }
 export declare const MIMES: {
     csv: Mime;

package/dist/mime.vo.js

@@ -1,5 +1,7 @@
 import * as mime from "mime-types";
-import { ExtensionSchema } from "./extension.vo";
+import { Extension } from "./extension.vo";
+export const InvalidMimeErrorMessage = "invalid.mime";
+export const NotAcceptedMimeErrorMessage = "mime.not.accepted";
 export class Mime {
     raw;
     type;
@@ -26,21 +28,21 @@ export class Mime {
         return this.subtype === another.subtype || this.subtype === "*";
     }
     toExtension() {
-        return ExtensionSchema.parse(mime.extension(this.raw));
+        return Extension.parse(mime.extension(this.raw));
     }
 }
 export class InvalidMimeError extends Error {
     constructor() {
-        super();
+        super(InvalidMimeErrorMessage);
         Object.setPrototypeOf(this, InvalidMimeError.prototype);
     }
 }
 export class NotAcceptedMimeError extends Error {
     mime;
-    constructor(mime) {
-        super();
+    constructor(mimeValue) {
+        super(NotAcceptedMimeErrorMessage);
         Object.setPrototypeOf(this, NotAcceptedMimeError.prototype);
-        this.mime = mime;
+        this.mime = mimeValue;
     }
 }
 export const MIMES = {

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

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

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

@@ -1,15 +1,10 @@
 import { z } from "zod/v4";
+export const MonthIsoIdError = { error: "month-iso-id.invalid" };
 export const MonthIsoId = z
-    .string()
-    .regex(/^\d{4}-\d{2}$/)
+    .string(MonthIsoIdError)
+    .regex(/^\d{4}-\d{2}$/, MonthIsoIdError)
     .refine((value) => {
-    const [y, m] = value.split("-");
-    const year = Number(y);
-    const month = Number(m);
-    return (y.length === 4 &&
-        m.length === 2 &&
-        Number.isInteger(year) &&
-        Number.isInteger(month) &&
-        month >= 1 &&
-        month <= 12);
-}, { message: "month-iso-id.invalid" });
+    const year = Number(value.slice(0, 4));
+    const month = Number(value.slice(5, 7));
+    return Number.isInteger(year) && Number.isInteger(month) && month >= 1 && month <= 12;
+}, MonthIsoIdError);

package/dist/month.vo.js

@@ -1,4 +1,4 @@
-import { addMonths, endOfMonth, startOfMonth } from "date-fns";
+// src/month.vo.ts
 import { DateRange } from "./date-range.vo";
 import { MonthIsoId } from "./month-iso-id.vo";
 import { Timestamp } from "./timestamp.vo";
@@ -7,28 +7,30 @@ export class Month extends DateRange {
         return new Date(this.getStart()).toISOString().slice(0, 7);
     }
     previous() {
-        const shifted = addMonths(new Date(this.getStart()), -1).getTime();
-        return Month.fromTimestamp(Timestamp.parse(shifted));
+        return Month.fromTimestamp(Timestamp.parse(this.getStart() - 1));
     }
     next() {
-        const shifted = addMonths(new Date(this.getStart()), 1).getTime();
-        return Month.fromTimestamp(Timestamp.parse(shifted));
+        return Month.fromTimestamp(Timestamp.parse(this.getEnd() + 1));
     }
     shift(count) {
-        const shifted = addMonths(new Date(this.getStart()), count).getTime();
-        return Month.fromTimestamp(Timestamp.parse(shifted));
+        const date = new Date(this.getStart());
+        date.setUTCMonth(date.getUTCMonth() + count);
+        return Month.fromTimestamp(Timestamp.parse(date.getTime()));
     }
     static fromTimestamp(timestamp) {
-        const start = Timestamp.parse(startOfMonth(timestamp).getTime());
-        const end = Timestamp.parse(endOfMonth(timestamp).getTime());
-        return new Month(start, end);
+        const isoMonth = new Date(timestamp).toISOString().slice(0, 7);
+        return Month.fromIsoId(isoMonth);
     }
     static fromNow(now) {
         return Month.fromTimestamp(now);
     }
     static fromIsoId(iso) {
-        const [year, month] = MonthIsoId.parse(iso).split("-").map(Number);
-        const reference = new Date(Date.UTC(year, month - 1, 1));
-        return Month.fromTimestamp(Timestamp.parse(reference.getTime()));
+        const validated = MonthIsoId.parse(iso);
+        const year = Number(validated.slice(0, 4));
+        const monthIndex = Number(validated.slice(5, 7)) - 1;
+        const startUtc = Date.UTC(year, monthIndex, 1);
+        const nextStartUtc = Date.UTC(year, monthIndex + 1, 1);
+        const endUtc = nextStartUtc - 1;
+        return new Month(Timestamp.parse(startUtc), Timestamp.parse(endUtc));
     }
 }

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

@@ -1,3 +1,8 @@
 import { z } from "zod/v4";
+export declare const ObjectKeyMustNotStartWithSlashError: "obj_key_must_not_start_with_slash";
+export declare const ObjectKeyBackslashForbiddenError: "obj_key_backslash_forbidden";
+export declare const ObjectKeyControlCharsForbiddenError: "obj_key_control_chars_forbidden";
+export declare const ObjectKeyEmptyError: "obj_key_empty";
+export declare const ObjectKeyBadSegmentsError: "obj_key_bad_segments";
 export declare const ObjectKey: z.core.$ZodBranded<z.ZodString, "object_key">;
 export type ObjectKeyType = z.infer<typeof ObjectKey>;

package/dist/object-key.vo.js

@@ -1,11 +1,21 @@
 import { z } from "zod/v4";
+export const ObjectKeyMustNotStartWithSlashError = "obj_key_must_not_start_with_slash";
+export const ObjectKeyBackslashForbiddenError = "obj_key_backslash_forbidden";
+export const ObjectKeyControlCharsForbiddenError = "obj_key_control_chars_forbidden";
+export const ObjectKeyEmptyError = "obj_key_empty";
+export const ObjectKeyBadSegmentsError = "obj_key_bad_segments";
+// biome-ignore lint: lint/suspicious/noControlCharactersInRegex
+const CONTROL_CHARS_REGEX = /[\u0000-\u001F\u007F]/;
+const SEGMENT_ALLOWED_REGEX = /^[a-z0-9._-]+$/;
 export const ObjectKey = z
     .string()
     .trim()
-    .refine((v) => !v.startsWith("/"), "obj_key_must_not_start_with_slash")
-    .refine((v) => !v.includes("\\"), "obj_key_backslash_forbidden")
-    // biome-ignore lint: lint/suspicious/noControlCharactersInRegex
-    .refine((v) => !/[\u0000-\u001F\u007F]/.test(v), "obj_key_control_chars_forbidden")
-    .refine((v) => v.length > 0, "obj_key_empty")
-    .refine((v) => v.split("/").every((s) => /^[a-z0-9._-]+$/.test(s) && s !== "." && s !== ".."), "obj_key_bad_segments")
+    // fastest early exits first:
+    .refine((value) => value.length > 0, ObjectKeyEmptyError)
+    .refine((value) => !value.startsWith("/"), ObjectKeyMustNotStartWithSlashError)
+    .refine((value) => !value.includes("\\"), ObjectKeyBackslashForbiddenError)
+    .refine((value) => !CONTROL_CHARS_REGEX.test(value), ObjectKeyControlCharsForbiddenError)
+    .refine((value) => value
+    .split("/")
+    .every((segment) => SEGMENT_ALLOWED_REGEX.test(segment) && segment !== "." && segment !== ".."), ObjectKeyBadSegmentsError)
     .brand("object_key");

package/dist/package-version.vo.d.ts

@@ -2,6 +2,9 @@ import { z } from "zod/v4";
 type MajorType = number;
 type MinorType = number;
 type PatchType = number;
+export declare const PackageVersionError: {
+    readonly error: "package.version.error";
+};
 export declare const PackageVersionValue: z.core.$ZodBranded<z.ZodPipe<z.ZodString, z.ZodTransform<{
     major: number;
     minor: number;

package/dist/package-version.vo.js

@@ -1,36 +1,14 @@
 import { z } from "zod/v4";
+export const PackageVersionError = { error: "package.version.error" };
 export const PackageVersionValue = z
-    .string()
-    .min(1)
-    .refine((value) => {
-    try {
-        if (!value.startsWith("v"))
-            return false;
-        const [, version] = value.split("v");
-        if (!version)
-            return false;
-        const [major, minor, patch] = version.split(".");
-        if (!(major && minor && patch))
-            return false;
-        if (!(Number.isInteger(Number(major)) &&
-            Number.isInteger(Number(minor)) &&
-            Number.isInteger(Number(patch)))) {
-            return false;
-        }
-        return true;
-    }
-    catch (_error) {
-        return false;
-    }
-}, { message: "package.version.error" })
+    .string(PackageVersionError)
+    .regex(/^v(\d+)\.(\d+)\.(\d+)$/, PackageVersionError)
     .transform((value) => {
-    const [, version] = value.split("v");
-    const [major, minor, patch] = version.split(".");
-    return {
-        major: Number(major),
-        minor: Number(minor),
-        patch: Number(patch),
-    };
+    const match = /^v(\d+)\.(\d+)\.(\d+)$/.exec(value);
+    const major = Number(match[1]);
+    const minor = Number(match[2]);
+    const patch = Number(match[3]);
+    return { major, minor, patch };
 })
     .brand("PackageVersionValue");
 export class PackageVersion {
@@ -61,11 +39,11 @@ export class PackageVersion {
         return `${this.major}.${this.minor}.${this.patch}`;
     }
     static fromStringWithV(value) {
-        const version = PackageVersionValue.parse(value);
-        return new PackageVersion(version.major, version.minor, version.patch);
+        const parsed = PackageVersionValue.parse(value);
+        return new PackageVersion(parsed.major, parsed.minor, parsed.patch);
     }
     static fromString(value) {
-        const version = PackageVersionValue.parse(`v${value}`);
-        return new PackageVersion(version.major, version.minor, version.patch);
+        const parsed = PackageVersionValue.parse(`v${value}`);
+        return new PackageVersion(parsed.major, parsed.minor, parsed.patch);
     }
 }

package/dist/pagination.service.d.ts

@@ -40,7 +40,7 @@ export declare class Pagination {
             total: number;
         };
     };
-    static getFirstPage({ take }: {
+    static getFirstPage(input: {
         take: TakeType;
     }): PaginationType;
 }

package/dist/pagination.service.js

@@ -1,9 +1,12 @@
 import { z } from "zod/v4";
-const Take = z.number().int().gte(0);
-const Skip = z.number().int().gte(0);
+const PaginationTakeError = { error: "pagination.take.invalid" };
+const PaginationSkipError = { error: "pagination.skip.invalid" };
+const PaginationPageError = { error: "pagination.page.invalid" };
+const Take = z.number(PaginationTakeError).int(PaginationTakeError).gte(1, PaginationTakeError);
+const Skip = z.number(PaginationSkipError).int(PaginationSkipError).gte(0, PaginationSkipError);
 const Page = z.coerce
-    .number()
-    .int()
+    .number(PaginationPageError)
+    .int(PaginationPageError)
     .transform((value) => (value <= 0 ? 1 : value))
     .default(1);
 export class Pagination {
@@ -25,13 +28,10 @@ export class Pagination {
         };
     }
     static isExhausted(config) {
-        const lastPage = Pagination.getLastPage(config);
-        const currentPage = config.pagination.page;
-        return lastPage <= currentPage;
+        return Pagination.getLastPage(config) <= config.pagination.page;
     }
     static getLastPage(config) {
-        const lastPage = Math.ceil(config.total / config.pagination.values.take);
-        return Page.parse(lastPage);
+        return Page.parse(Math.ceil(config.total / config.pagination.values.take));
     }
     static empty = {
         result: [],
@@ -44,7 +44,7 @@ export class Pagination {
             total: 0,
         },
     };
-    static getFirstPage({ take }) {
-        return { values: { take, skip: Skip.parse(0) }, page: Page.parse(1) };
+    static getFirstPage(input) {
+        return { values: { take: Take.parse(input.take), skip: Skip.parse(0) }, page: Page.parse(1) };
     }
 }

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

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

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

@@ -1,10 +1,11 @@
 import { z } from "zod/v4";
+export const QuarterIsoIdError = { error: "quarter-iso-id.invalid" };
 export const QuarterIsoId = z
-    .string()
-    .regex(/^\d{4}-Q[1-4]$/)
+    .string(QuarterIsoIdError)
+    .regex(/^\d{4}-Q[1-4]$/, QuarterIsoIdError)
     .refine((value) => {
-    const [y, q] = value.split("-Q");
-    const year = Number(y);
-    const quarter = Number(q);
-    return (y.length === 4 && Number.isInteger(year) && Number.isInteger(quarter) && quarter >= 1 && quarter <= 4);
-}, { message: "quarter-iso-id.invalid" });
+    const [yearPart, quarterPart] = value.split("-Q");
+    const year = Number(yearPart);
+    const quarter = Number(quarterPart);
+    return Number.isInteger(year) && Number.isInteger(quarter) && quarter >= 1 && quarter <= 4;
+}, QuarterIsoIdError);

package/dist/rate-limiter.service.d.ts

@@ -1,6 +1,7 @@
-import type { TimeResult } from "./time.service";
 import { type TimestampType } from "./timestamp.vo";
-type RateLimiterOptionsType = Pick<TimeResult, "ms">;
+type RateLimiterOptionsType = {
+    ms: TimestampType;
+};
 type RateLimiterResultSuccessType = {
     allowed: true;
 };

package/dist/rate-limiter.service.js

@@ -6,7 +6,7 @@ export class RateLimiter {
         this.options = options;
     }
     verify(currentTimestampMs) {
-        if (this.lastInvocationTimestampMs === null || this.lastInvocationTimestampMs === undefined) {
+        if (this.lastInvocationTimestampMs == null) {
             this.lastInvocationTimestampMs = currentTimestampMs;
             return { allowed: true };
         }
@@ -15,6 +15,8 @@ export class RateLimiter {
             this.lastInvocationTimestampMs = currentTimestampMs;
             return { allowed: true };
         }
-        return { allowed: false, remainingMs: Timestamp.parse(nextAllowedTimestampMs - currentTimestampMs) };
+        const remainingDelta = nextAllowedTimestampMs - currentTimestampMs;
+        const remainingMs = Timestamp.parse(remainingDelta);
+        return { allowed: false, remainingMs };
     }
 }