@eliasrrosa/tutorhub-public-assets 0.7.6 → 0.8.1

package/dist/application/dtos/UserTimeSlotDTO.d.ts

@@ -0,0 +1,11 @@
+export interface IUserTimeSlotDTO {
+    id: string;
+    userId: string;
+    groupId: string;
+    dayOfTheWeek: number;
+    startDateTime: Date;
+    endDateTime: Date;
+    isAvailableTime: boolean;
+    courseId?: string;
+    rescheduleRequestIds?: string[];
+}

package/dist/application/dtos/UserTimeSlotDTO.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/application/helpers/filterAsync.d.ts

@@ -0,0 +1 @@
+export declare function filterAsync<T>(arr: T[], predicate: (item: T) => Promise<boolean>): Promise<T[]>;

package/dist/application/helpers/filterAsync.js

@@ -0,0 +1,18 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterAsync = filterAsync;
+function filterAsync(arr, predicate) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const results = yield Promise.all(arr.map(predicate));
+        return arr.filter((_v, index) => results[index]);
+    });
+}

package/dist/application/helpers/filterAsync.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/application/helpers/filterAsync.test.js

@@ -0,0 +1,21 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const filterAsync_1 = require("./filterAsync");
+describe("filterAsync", () => {
+    it("Should filter accepting async operations.", () => __awaiter(void 0, void 0, void 0, function* () {
+        const numbers = [1, 2, 3];
+        const filteredNumbers = yield (0, filterAsync_1.filterAsync)(numbers, (number) => __awaiter(void 0, void 0, void 0, function* () {
+            return number > 1;
+        }));
+        expect(filteredNumbers).toEqual([2, 3]);
+    }));
+});

package/dist/application/helpers/tryCatch.d.ts

@@ -0,0 +1,2 @@
+export declare function tryCatch<T, E>(callback: () => T, fallback: (error: unknown) => E): T | E;
+export declare function tryCatchAsync<T, E>(callback: () => Promise<T>, fallback: (error: unknown) => Promise<E>): Promise<T | E>;

package/dist/application/helpers/tryCatch.js

@@ -0,0 +1,31 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryCatch = tryCatch;
+exports.tryCatchAsync = tryCatchAsync;
+function tryCatch(callback, fallback) {
+    try {
+        return callback();
+    }
+    catch (error) {
+        return fallback(error);
+    }
+}
+function tryCatchAsync(callback, fallback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield callback();
+        }
+        catch (error) {
+            return yield fallback(error);
+        }
+    });
+}

package/dist/application/helpers/tryCatch.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/application/helpers/tryCatch.test.js

@@ -0,0 +1,48 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tryCatch_1 = require("./tryCatch");
+describe("tryCatch", () => {
+    it("Should return try return value if success.", () => {
+        const a = (0, tryCatch_1.tryCatch)(() => {
+            return "abc";
+        }, () => {
+            return new Error("Trycatch failed.");
+        });
+        expect(a).toEqual("abc");
+    });
+    it("Should return catch return value if error.", () => {
+        const a = (0, tryCatch_1.tryCatch)(() => {
+            throw new Error("Error!");
+        }, () => {
+            return new Error("Trycatch failed.");
+        });
+        expect(a).toBeInstanceOf(Error);
+        expect(a.message).toEqual("Trycatch failed.");
+    });
+});
+describe("tryCatchAsync", () => {
+    it("Should return try return value if success.", () => __awaiter(void 0, void 0, void 0, function* () {
+        const a = yield (0, tryCatch_1.tryCatchAsync)(() => __awaiter(void 0, void 0, void 0, function* () {
+            return "abc";
+        }), () => __awaiter(void 0, void 0, void 0, function* () { return new Error(); }));
+        expect(a).toEqual("abc");
+    }));
+    it("Should return catch return value if error.", () => __awaiter(void 0, void 0, void 0, function* () {
+        const a = yield (0, tryCatch_1.tryCatchAsync)(() => __awaiter(void 0, void 0, void 0, function* () {
+            throw new Error("Error!");
+        }), () => __awaiter(void 0, void 0, void 0, function* () {
+            return new Error("Trycatch failed.");
+        }));
+        expect(a).toBeInstanceOf(Error);
+        expect(a.message).toEqual("Trycatch failed.");
+    }));
+});

package/dist/domain/entities/Class.d.ts

@@ -1,17 +0,0 @@
-import { IClassStatus } from "./ClassStatus";
-export interface IClass {
-    id: string;
-    title: string;
-    startDateTime: Date;
-    endDateTime: Date;
-    courseId: string;
-    ownerId: string;
-    status: IClassStatus;
-    groupId?: string;
-    description?: string;
-    createdAt?: Date;
-    updatedAt?: Date;
-    paymentId?: string;
-    meetingLink?: string;
-    contractId?: string;
-}

package/dist/domain/entities/Class.js

@@ -1,2 +1 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/domain/entities/ISO8601DateTime.d.ts

@@ -1,39 +1,44 @@
-import { IDate } from "./Date";
-import { ITime } from "./Time";
 export interface IDateTime {
-    getJSDateTime: () => Date;
+    getJsDateTime: () => Date;
     /**
-     * Returns DateTime string with added Brazilian timezone (-03:00) without converting the date or time.
-     * This function is analogous to ISO8601DateTime.getIsoString(-180)
-     * @returns an ISO8601 string with Brazilian timezone
-     */
-    getBrazilianIsoString: () => string;
-    /**
-     * Returns DateTime string with added timezone (eg. +03:00, -01:00, .000Z) without converting the date or time.
-     * @param timezoneOffsetMinutes defaults to 0.
-     * Can be derived from the negative return value of Date.getTimezoneOffset()
-     * @param newDate overrides the date for the output string, but does not change state.
-     * @param newTime overrides the time for the output string, but does not change state.
-     * @returns an ISO8601 string with the added timezone.
+     * @returns the same date but time is 00:00:00.000
      */
+    toMidnight: () => IDateTime;
     getIsoString: (opts?: {
-        timezoneOffsetMinutes?: number;
-        newDate?: IDate;
-        newTime?: ITime;
+        timezone?: string | number;
     }) => string;
+    /**
+     * @returns a time string without timezone like "13:30:00"
+     */
+    getTimeString: () => string;
+    getHoursString: () => string;
+    getMinutesString: () => string;
+    getSecondsString: () => string;
+    getMilisecondsString: () => string;
 }
 export declare class ISO8601DateTime implements IDateTime {
-    private date;
-    private time;
-    constructor(opts: {
-        date: IDate;
-        time: ITime;
-    });
-    getJSDateTime: () => Date;
-    getBrazilianIsoString: () => string;
-    getIsoString(opts?: {
-        timezoneOffsetMinutes?: number;
-        newDate?: IDate;
-        newTime?: ITime;
-    }): string;
+    private readonly timeFormatValidator;
+    private readonly dateFormatValidator;
+    private readonly dateString;
+    private readonly timeUnitConverter;
+    dateTimePattern: RegExp;
+    onlyDatePattern: RegExp;
+    constructor(
+    /**
+     * Accepts ISO8601 date time format with timezone.
+     * Eg:. `2025-01-01T00:00:00Z`, `2025-01-01T00:00:00.000Z`,
+     * `2025-01-01T00:00:00-03:00`, `2025-01-01T00:00:00+04:00`
+     */
+    dateString: string);
+    private normalizeDateString;
+    getTimeString: () => string;
+    getHoursString: () => string;
+    getMinutesString: () => string;
+    getSecondsString: () => string;
+    getMilisecondsString: () => string;
+    getJsDateTime: () => Date;
+    getIsoString: (opts?: {
+        timezone?: string | number;
+    }) => string;
+    toMidnight: () => IDateTime;
 }

package/dist/domain/entities/ISO8601DateTime.js

@@ -1,44 +1,82 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ISO8601DateTime = void 0;
+const ISO8601DateValidator_1 = require("./ISO8601DateValidator");
+const ISO8601TimeValidator_1 = require("./ISO8601TimeValidator");
+const ISO8601TimezoneParser_1 = require("./ISO8601TimezoneParser");
+const ISO8601TimezoneValidator_1 = require("./ISO8601TimezoneValidator");
+const TimeUnitConverter_1 = require("./TimeUnitConverter");
 class ISO8601DateTime {
-    constructor(opts) {
-        this.getJSDateTime = () => {
-            return new Date(parseInt(this.date.getYear()), parseInt(this.date.getMonth()) - 1, parseInt(this.date.getDay()), parseInt(this.time.getHoursString()), parseInt(this.time.getMinutesString()), parseInt(this.time.getSecondsString()));
+    constructor(
+    /**
+     * Accepts ISO8601 date time format with timezone.
+     * Eg:. `2025-01-01T00:00:00Z`, `2025-01-01T00:00:00.000Z`,
+     * `2025-01-01T00:00:00-03:00`, `2025-01-01T00:00:00+04:00`
+     */
+    dateString) {
+        this.timeFormatValidator = new ISO8601TimeValidator_1.ISO8601TimeValidator();
+        this.dateFormatValidator = new ISO8601DateValidator_1.ISO8601DateValidator();
+        this.timeUnitConverter = new TimeUnitConverter_1.TimeUnitConverter();
+        this.dateTimePattern = new RegExp(`^${this.dateFormatValidator.YYYYmmDDpatternString}T(${this.timeFormatValidator.hhMMssPlusNumberedTimezonePatternString}|${this.timeFormatValidator.hhMMssSSSZPatternString}|${this.timeFormatValidator.hhMMssZPatternString})$`);
+        this.onlyDatePattern = new RegExp(`^${this.dateFormatValidator.YYYYmmDDpatternString}$`);
+        this.getTimeString = () => {
+            return `${this.getHoursString()}:${this.getMinutesString()}:${this.getSecondsString()}`;
         };
-        this.getBrazilianIsoString = () => {
-            return this.getIsoString({
-                timezoneOffsetMinutes: -180,
-            });
+        this.getHoursString = () => {
+            return this.dateString.split("T")[1].slice(0, 8).split(":")[0];
         };
-        this.date = opts.date;
-        this.time = opts.time;
+        this.getMinutesString = () => {
+            return this.dateString.split("T")[1].slice(0, 8).split(":")[1];
+        };
+        this.getSecondsString = () => {
+            return this.dateString.split("T")[1].slice(0, 8).split(":")[2];
+        };
+        this.getMilisecondsString = () => {
+            return this.dateString.split("T")[1].slice(0, 8).split(":")[3];
+        };
+        this.getJsDateTime = () => {
+            return new Date(this.dateString);
+        };
+        this.getIsoString = (opts) => {
+            if (!opts || !(opts === null || opts === void 0 ? void 0 : opts.timezone))
+                return this.getJsDateTime().toISOString();
+            const parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+            const validator = new ISO8601TimezoneValidator_1.ISO8601TimezoneValidator();
+            const timezoneInMinutes = typeof opts.timezone == "string"
+                ? parser.toMinutes(opts.timezone)
+                : opts.timezone;
+            const isValid = validator.formatIsValid(timezoneInMinutes);
+            if (!isValid)
+                throw new Error("Invalid timezone format.");
+            const timezoneInMs = this.timeUnitConverter.minutesToMs(timezoneInMinutes);
+            const newDateUtcString = new Date(this.getJsDateTime().getTime() + timezoneInMs).toISOString();
+            const newDateUtcStringWithoutTimezone = newDateUtcString.split(".")[0];
+            const timezoneString = parser.toString(timezoneInMinutes);
+            const newDateWithTimezoneString = `${newDateUtcStringWithoutTimezone}${timezoneString}`;
+            return newDateWithTimezoneString;
+        };
+        this.toMidnight = () => {
+            const currentTimeString = this.getTimeString();
+            const matches = new RegExp(currentTimeString).exec(this.dateString);
+            if (!matches || matches.length < 1)
+                throw new Error("Error getting current time string.");
+            const datePlusT = this.dateString.slice(0, matches.index);
+            const matchedString = matches[0];
+            const timezone = this.dateString.slice(matchedString.length + matches.index);
+            return new ISO8601DateTime(`${datePlusT}00:00:00${timezone}`);
+        };
+        const normalizedDateString = this.normalizeDateString(dateString);
+        if (!normalizedDateString)
+            throw new Error("Date time format invalid.");
+        this.dateString = normalizedDateString;
     }
-    getIsoString(opts) {
-        const padLeft = (n) => String(n).padStart(2, "0");
-        const newDateTime = new ISO8601DateTime({
-            date: (opts === null || opts === void 0 ? void 0 : opts.newDate) || this.date,
-            time: (opts === null || opts === void 0 ? void 0 : opts.newTime) || this.time,
-        });
-        const jsDate = newDateTime.getJSDateTime();
-        const year = jsDate.getFullYear();
-        const month = padLeft(jsDate.getMonth() + 1);
-        const day = padLeft(jsDate.getDate());
-        const hour = padLeft(jsDate.getHours());
-        const minute = padLeft(jsDate.getMinutes());
-        const second = padLeft(jsDate.getSeconds());
-        const timezoneOffsetMinutes = (opts === null || opts === void 0 ? void 0 : opts.timezoneOffsetMinutes)
-            ? opts.timezoneOffsetMinutes
-            : 0;
-        const sign = timezoneOffsetMinutes == 0
-            ? undefined
-            : timezoneOffsetMinutes < 0
-                ? "-"
-                : "+";
-        const offsetHours = padLeft(Math.floor(Math.abs(timezoneOffsetMinutes) / 60));
-        const offsetMinutes = padLeft(Math.abs(timezoneOffsetMinutes) % 60);
-        const timezone = sign ? `${sign}${offsetHours}:${offsetMinutes}` : ".000Z";
-        return `${year}-${month}-${day}T${hour}:${minute}:${second}${timezone}`;
+    normalizeDateString(dateString) {
+        if (this.onlyDatePattern.test(dateString)) {
+            return `${dateString}T00:00:00Z`;
+        }
+        if (this.dateTimePattern.test(dateString)) {
+            return dateString;
+        }
     }
 }
 exports.ISO8601DateTime = ISO8601DateTime;

package/dist/domain/entities/ISO8601DateTime.test.js

@@ -1,146 +1,64 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const ISO8601Date_1 = require("./ISO8601Date");
 const ISO8601DateTime_1 = require("./ISO8601DateTime");
-const ISO8601Time_1 = require("./ISO8601Time");
 describe("ISO8601DateTime", () => {
-    describe("ISO8601DateTime getJSDateTime()", () => {
-        it("Should return a JS Date object.", () => {
-            const dateTime = new ISO8601DateTime_1.ISO8601DateTime({
-                date: new ISO8601Date_1.ISO8601Date("2025-01-01"),
-                time: new ISO8601Time_1.ISO8601Time("10:00:00"),
-            });
-            const jsDateTime = dateTime.getJSDateTime();
-            expect(jsDateTime).toBeInstanceOf(Date);
+    describe("ISO8601DateTime constructor", () => {
+        it("Should throw given non ISO8601 format", () => {
+            const getDateTime = () => new ISO8601DateTime_1.ISO8601DateTime("abc");
+            expect(getDateTime).toThrow();
         });
-        it("Should return the same year, month and day when returning UTC date.", () => {
-            const dateTime = new ISO8601DateTime_1.ISO8601DateTime({
-                date: new ISO8601Date_1.ISO8601Date("2025-01-02"),
-                time: new ISO8601Time_1.ISO8601Time("00:00:00"),
-            });
-            const jsDateTime = dateTime.getJSDateTime();
-            expect(jsDateTime.getUTCDate()).toBe(2);
-            expect(jsDateTime.getUTCMonth()).toBe(0);
-            expect(jsDateTime.getUTCFullYear()).toBe(2025);
-        });
-        it("Should return locale date string of same date and time as constructed.", () => {
-            const dateTime = new ISO8601DateTime_1.ISO8601DateTime({
-                date: new ISO8601Date_1.ISO8601Date("2025-01-02"),
-                time: new ISO8601Time_1.ISO8601Time("01:02:03"),
-            });
-            const jsDateTime = dateTime.getJSDateTime();
-            expect(jsDateTime.toLocaleDateString("pt-BR")).toBe("02/01/2025");
-        });
-        it("Should return ISO string converted to UTC.", () => {
-            const dateTime = new ISO8601DateTime_1.ISO8601DateTime({
-                date: new ISO8601Date_1.ISO8601Date("2025-01-02"),
-                time: new ISO8601Time_1.ISO8601Time("01:02:03"),
-            });
-            const jsDateTime = dateTime.getJSDateTime();
-            expect(jsDateTime.toISOString()).toBe("2025-01-02T04:02:03.000Z");
-        });
-    });
-    describe("ISO8601DateTime.getBrazilianIsoString()", () => {
-        it("Should return ISO string converted to Brazilian time.", () => {
-            const dateTime = new ISO8601DateTime_1.ISO8601DateTime({
-                date: new ISO8601Date_1.ISO8601Date("2025-01-02"),
-                time: new ISO8601Time_1.ISO8601Time("01:02:03"),
-            });
-            const brazilianIsoString = dateTime.getBrazilianIsoString();
-            expect(brazilianIsoString).toBe("2025-01-02T01:02:03-03:00");
+        it("Should not throw given non ISO8601 format but with no time", () => {
+            const getDateTime = () => new ISO8601DateTime_1.ISO8601DateTime("2025-01-01");
+            expect(getDateTime).not.toThrow();
         });
     });
     describe("ISO8601DateTime.getIsoString()", () => {
-        it("Should return ISO UTC string if no arguments.", () => {
-            const dateTime = new ISO8601DateTime_1.ISO8601DateTime({
-                date: new ISO8601Date_1.ISO8601Date("2025-01-02"),
-                time: new ISO8601Time_1.ISO8601Time("03:01:02"),
-            });
-            const utcIsoString = dateTime.getIsoString();
-            expect(utcIsoString).toBe("2025-01-02T03:01:02.000Z");
-        });
-        it("Should return ISO string +01:00 for London timezone.", () => {
-            const dateTime = new ISO8601DateTime_1.ISO8601DateTime({
-                date: new ISO8601Date_1.ISO8601Date("2025-01-02"),
-                time: new ISO8601Time_1.ISO8601Time("03:01:02"),
-            });
-            const isoString = dateTime.getIsoString({ timezoneOffsetMinutes: 60 });
-            expect(isoString).toBe("2025-01-02T03:01:02+01:00");
-        });
-        it("Should return ISO string -05:00 for Chicago DST timezone.", () => {
-            const dateTime = new ISO8601DateTime_1.ISO8601DateTime({
-                date: new ISO8601Date_1.ISO8601Date("2025-01-02"),
-                time: new ISO8601Time_1.ISO8601Time("03:01:02"),
-            });
-            const isoString = dateTime.getIsoString({
-                timezoneOffsetMinutes: -300,
-            });
-            expect(isoString).toBe("2025-01-02T03:01:02-05:00");
+        it("Should convert to brazilian timezone properly.", () => {
+            expect(new ISO8601DateTime_1.ISO8601DateTime("2025-01-01T03:00:00Z").getIsoString({
+                timezone: "-03:00",
+            })).toEqual("2025-01-01T00:00:00-03:00");
+            expect(new ISO8601DateTime_1.ISO8601DateTime("2025-01-01T03:00:00Z").getIsoString({
+                timezone: -180,
+            })).toEqual("2025-01-01T00:00:00-03:00");
+            expect(new ISO8601DateTime_1.ISO8601DateTime("2025-01-01T03:00:00Z").getIsoString({
+                timezone: "-04:00",
+            })).toEqual("2024-12-31T23:00:00-04:00");
+            expect(new ISO8601DateTime_1.ISO8601DateTime("2025-01-01T00:00:00-03:00").getIsoString({
+                timezone: "Z",
+            })).toEqual("2025-01-01T03:00:00Z");
+            expect(new ISO8601DateTime_1.ISO8601DateTime("2025-01-01T00:00:00-03:00").getIsoString({
+                timezone: "-03:00",
+            })).toEqual("2025-01-01T00:00:00-03:00");
+            expect(new ISO8601DateTime_1.ISO8601DateTime("2025-01-01T00:00:00-03:00").getIsoString({
+                timezone: undefined,
+            })).toEqual("2025-01-01T03:00:00.000Z");
+            expect(new ISO8601DateTime_1.ISO8601DateTime("2025-01-01T00:00:00-03:00").getIsoString({
+                timezone: "-02:00",
+            })).toEqual("2025-01-01T01:00:00-02:00");
+            expect(new ISO8601DateTime_1.ISO8601DateTime("2025-01-01T00:00:00-03:00").getIsoString({
+                timezone: "+03:00",
+            })).toEqual("2025-01-01T06:00:00+03:00");
+            expect(new ISO8601DateTime_1.ISO8601DateTime("2025-01-01").getIsoString({
+                timezone: "+03:00",
+            })).toEqual("2025-01-01T03:00:00+03:00");
+            expect(new ISO8601DateTime_1.ISO8601DateTime("2025-01-01").getIsoString({
+                timezone: undefined,
+            })).toEqual("2025-01-01T00:00:00.000Z");
         });
-        it("Should return ISO string -03:00 for Brazilian timezone.", () => {
-            const dateTime = new ISO8601DateTime_1.ISO8601DateTime({
-                date: new ISO8601Date_1.ISO8601Date("2025-01-02"),
-                time: new ISO8601Time_1.ISO8601Time("03:01:02"),
-            });
-            const isoString = dateTime.getIsoString({
-                timezoneOffsetMinutes: -180,
-            });
-            expect(isoString).toBe("2025-01-02T03:01:02-03:00");
-        });
-        it("Should return ISO string -03:00 for Brazilian timezone derived from Date.", () => {
-            const dateTime = new ISO8601DateTime_1.ISO8601DateTime({
-                date: new ISO8601Date_1.ISO8601Date("2025-01-02"),
-                time: new ISO8601Time_1.ISO8601Time("03:01:02"),
-            });
-            const isoString = dateTime.getIsoString({
-                timezoneOffsetMinutes: -new Date().getTimezoneOffset(),
-            });
-            expect(isoString).toBe("2025-01-02T03:01:02-03:00");
-        });
-        it("Should accept newDate and properly output it.", () => {
-            const dateTime = new ISO8601DateTime_1.ISO8601DateTime({
-                date: new ISO8601Date_1.ISO8601Date("2025-01-02"),
-                time: new ISO8601Time_1.ISO8601Time("03:01:02"),
-            });
-            const isoString = dateTime.getIsoString({
-                timezoneOffsetMinutes: -new Date().getTimezoneOffset(),
-                newDate: new ISO8601Date_1.ISO8601Date("2025-01-03"),
-            });
-            expect(isoString).toBe("2025-01-03T03:01:02-03:00");
-        });
-        it("Should accept newTime and properly output it.", () => {
-            const dateTime = new ISO8601DateTime_1.ISO8601DateTime({
-                date: new ISO8601Date_1.ISO8601Date("2025-01-02"),
-                time: new ISO8601Time_1.ISO8601Time("03:01:02"),
-            });
-            const isoString = dateTime.getIsoString({
-                timezoneOffsetMinutes: -new Date().getTimezoneOffset(),
-                newTime: new ISO8601Time_1.ISO8601Time("03:01:03")
-            });
-            expect(isoString).toBe("2025-01-02T03:01:03-03:00");
-        });
-        it("Should accept newTime and newDate and properly output them.", () => {
-            const dateTime = new ISO8601DateTime_1.ISO8601DateTime({
-                date: new ISO8601Date_1.ISO8601Date("2025-01-02"),
-                time: new ISO8601Time_1.ISO8601Time("03:01:02"),
-            });
-            const isoString = dateTime.getIsoString({
-                timezoneOffsetMinutes: -new Date().getTimezoneOffset(),
-                newTime: new ISO8601Time_1.ISO8601Time("03:01:03"),
-                newDate: new ISO8601Date_1.ISO8601Date("2025-01-03")
-            });
-            expect(isoString).toBe("2025-01-03T03:01:03-03:00");
+    });
+    describe("ISO8601DateTime.toMidnight()", () => {
+        it("Should return midnight of the same day.", () => {
+            expect(new ISO8601DateTime_1.ISO8601DateTime("2025-01-01T03:00:00Z").toMidnight().getJsDateTime()).toEqual(new Date("2025-01-01T00:00:00Z"));
+            expect(new ISO8601DateTime_1.ISO8601DateTime("2025-01-01T03:00:00-03:00")
+                .toMidnight()
+                .getJsDateTime()).toEqual(new Date("2025-01-01T00:00:00-03:00"));
         });
-        it("Should accept newTime and newDate and properly output them, even when timezone is UTC.", () => {
-            const dateTime = new ISO8601DateTime_1.ISO8601DateTime({
-                date: new ISO8601Date_1.ISO8601Date("2025-01-02"),
-                time: new ISO8601Time_1.ISO8601Time("03:01:02"),
-            });
-            const isoString = dateTime.getIsoString({
-                newTime: new ISO8601Time_1.ISO8601Time("03:01:03"),
-                newDate: new ISO8601Date_1.ISO8601Date("2025-01-03")
-            });
-            expect(isoString).toBe("2025-01-03T03:01:03.000Z");
+    });
+    describe("ISO8601DateTime.toMidnight().getIsoString()", () => {
+        it("Must take UTC ISO string and return it midnight", () => {
+            expect(new ISO8601DateTime_1.ISO8601DateTime("2025-01-01T03:00:00Z")
+                .toMidnight()
+                .getIsoString()).toEqual("2025-01-01T00:00:00.000Z");
         });
     });
 });

package/dist/domain/entities/ISO8601DateValidator.d.ts

@@ -5,7 +5,8 @@ import { IDateValidator } from "./DateValidator";
  * @throws on get methods if format is wrong
  */
 export declare class ISO8601DateValidator implements IDateValidator {
-    private YYYYmmDD;
+    YYYYmmDDpatternString: string;
+    YYYYmmDDpattern: RegExp;
     /**
      * Accepted format: YYYY-MM-DD
      */

package/dist/domain/entities/ISO8601DateValidator.js

@@ -8,16 +8,17 @@ exports.ISO8601DateValidator = void 0;
  */
 class ISO8601DateValidator {
     constructor() {
-        this.YYYYmmDD = new RegExp("^[0-9]{4}-([0][1-9]|[1][0-2])-([0][1-9]|[1-2][0-9]|[3][0-1])");
+        this.YYYYmmDDpatternString = "[0-9]{4}-([0][1-9]|[1][0-2])-([0][1-9]|[1-2][0-9]|[3][0-1])";
+        this.YYYYmmDDpattern = new RegExp(`^${this.YYYYmmDDpatternString}`);
     }
     /**
      * Accepted format: YYYY-MM-DD
      */
     formatIsValid(date) {
-        return this.YYYYmmDD.test(date);
+        return this.YYYYmmDDpattern.test(date);
     }
     match(date) {
-        const matches = date.match(this.YYYYmmDD);
+        const matches = date.match(this.YYYYmmDDpattern);
         if (!matches || matches.length < 1) {
             return undefined;
         }

package/dist/domain/entities/ISO8601TimeValidator.d.ts

@@ -20,9 +20,12 @@ export declare class ISO8601TimeValidator implements IISO8601TimeValidator {
     private zAndMillisecondsPatternString;
     private hhMMssPattern;
     private hhMMPattern;
-    private hhMMssPlusNumberedTimezonePattern;
-    private hhMMssZPattern;
-    private hhMMssSSSZPattern;
+    hhMMssPlusNumberedTimezonePatternString: string;
+    hhMMssPlusNumberedTimezonePattern: RegExp;
+    hhMMssZPatternString: string;
+    hhMMssZPattern: RegExp;
+    hhMMssSSSZPatternString: string;
+    hhMMssSSSZPattern: RegExp;
     formatIsValid(time: string): boolean;
     isHHmmSS(time: string): boolean;
     isHHmm(time: string): boolean;

package/dist/domain/entities/ISO8601TimeValidator.js

@@ -13,9 +13,12 @@ class ISO8601TimeValidator {
         this.zAndMillisecondsPatternString = `.[0-9]{3}Z`;
         this.hhMMssPattern = new RegExp(`^${this.upTo23}:${this.upTo59}:${this.upTo59}$`);
         this.hhMMPattern = new RegExp(`^${this.upTo23}:${this.upTo59}$`);
-        this.hhMMssPlusNumberedTimezonePattern = new RegExp(`^${this.upTo23}:${this.upTo59}:${this.upTo59}${this.numberedTimezonePatternString}$`);
-        this.hhMMssZPattern = new RegExp(`^${this.upTo23}:${this.upTo59}:${this.upTo59}${this.zTimezonePatternString}$`);
-        this.hhMMssSSSZPattern = new RegExp(`^${this.upTo23}:${this.upTo59}:${this.upTo59}${this.zAndMillisecondsPatternString}$`);
+        this.hhMMssPlusNumberedTimezonePatternString = `${this.upTo23}:${this.upTo59}:${this.upTo59}${this.numberedTimezonePatternString}`;
+        this.hhMMssPlusNumberedTimezonePattern = new RegExp(`^${this.hhMMssPlusNumberedTimezonePatternString}$`);
+        this.hhMMssZPatternString = `${this.upTo23}:${this.upTo59}:${this.upTo59}${this.zTimezonePatternString}`;
+        this.hhMMssZPattern = new RegExp(`^${this.hhMMssZPatternString}$`);
+        this.hhMMssSSSZPatternString = `${this.upTo23}:${this.upTo59}:${this.upTo59}${this.zAndMillisecondsPatternString}`;
+        this.hhMMssSSSZPattern = new RegExp(`^${this.hhMMssSSSZPatternString}$`);
         this.isHHmmSSPlusNumberedTimezone = (time) => {
             return this.hhMMssPlusNumberedTimezonePattern.test(time);
         };