@eliasrrosa/tutorhub-public-assets 0.0.1 → 0.0.2

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

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ISO8601Date_1 = require("./ISO8601Date");
+describe("ISO8601Date", () => {
+    describe("ISO8601Date constructor", () => {
+        beforeEach(() => {
+            jest.useFakeTimers().setSystemTime(new Date("2025-01-01T23:00:00-03:00"));
+        });
+        afterEach(() => {
+            jest.useRealTimers();
+        });
+        it("Should construct if date is valid", () => {
+            const date = new ISO8601Date_1.ISO8601Date("2025-01-01");
+            expect(date.value).toBe("2025-01-01");
+        });
+        it("Should throw if value is not valid", () => {
+            const instantiateDate = () => {
+                new ISO8601Date_1.ISO8601Date("2025-01-011");
+            };
+            expect(instantiateDate).toThrow();
+        });
+        it("Should construct with no arguments.", () => {
+            const date = new ISO8601Date_1.ISO8601Date();
+            expect(date).toBeDefined();
+        });
+        it("Should have value set as today when constructed with no arguments.", () => {
+            const date = new ISO8601Date_1.ISO8601Date();
+            expect(date.value).toBe("2025-01-01");
+            const validateFormat = () => {
+                return date.validator.formatIsValid(date.value);
+            };
+            expect(validateFormat).not.toThrow();
+        });
+    });
+    describe("ISO8601Date.getDay()", () => {
+        it("Should return the day if format is valid.", () => {
+            const date = new ISO8601Date_1.ISO8601Date("2025-01-02");
+            expect(date.getDay()).toBe("02");
+        });
+    });
+    describe("ISO8601Date.getMonth()", () => {
+        it("Should return the month if format is valid.", () => {
+            const date = new ISO8601Date_1.ISO8601Date("2025-01-02");
+            expect(date.getMonth()).toBe("01");
+        });
+    });
+    describe("ISO8601Date.getYear()", () => {
+        it("Should return the year if format is valid.", () => {
+            const date = new ISO8601Date_1.ISO8601Date("2025-01-02");
+            expect(date.getYear()).toBe("2025");
+        });
+    });
+    describe("ISO8601Date.addDays()", () => {
+        it("Should add days resulting in the same month", () => {
+            const date = new ISO8601Date_1.ISO8601Date("2025-01-02");
+            expect(date.addDays(10).value).toBe("2025-01-12");
+        });
+        it("Should add days resulting in the next month", () => {
+            const date = new ISO8601Date_1.ISO8601Date("2025-01-01");
+            expect(date.addDays(31).value).toBe("2025-02-01");
+        });
+        it("Should add days resulting in multiple months ahead", () => {
+            const date = new ISO8601Date_1.ISO8601Date("2025-03-01");
+            expect(date.addDays(31 + 30 + 31 + 3).value).toBe("2025-06-04");
+        });
+        it("Should add days resulting in multiple months ahead", () => {
+            const date = new ISO8601Date_1.ISO8601Date("2025-03-01");
+            expect(date.addDays(31 + 30 + 31 + 3).value).toBe("2025-06-04");
+        });
+        it("Should be chainable.", () => {
+            const date = new ISO8601Date_1.ISO8601Date("2025-03-01");
+            expect(date.addDays(31).addDays(30).addDays(31).addDays(3).value).toBe("2025-06-04");
+        });
+        it("Should accept negative values", () => {
+            const date = new ISO8601Date_1.ISO8601Date("2025-03-02");
+            expect(date.addDays(-1).value).toBe("2025-03-01");
+        });
+        describe("ISO8601Date.addDays() in a timezone ahead of UTC", () => {
+            beforeEach(() => {
+                jest
+                    .useFakeTimers()
+                    .setSystemTime(new Date("2025-01-01T23:00:00+03:00"));
+            });
+            afterEach(() => {
+                jest.useRealTimers();
+            });
+            it("Should add days resulting in the same month", () => {
+                const date = new ISO8601Date_1.ISO8601Date("2025-01-02");
+                expect(date.addDays(10).value).toBe("2025-01-12");
+            });
+            it("Should add days resulting in the next month", () => {
+                const date = new ISO8601Date_1.ISO8601Date("2025-01-01");
+                expect(date.addDays(31).value).toBe("2025-02-01");
+            });
+            it("Should add days resulting in multiple months ahead", () => {
+                const date = new ISO8601Date_1.ISO8601Date("2025-03-01");
+                expect(date.addDays(31 + 30 + 31 + 3).value).toBe("2025-06-04");
+            });
+            it("Should add days resulting in multiple months ahead", () => {
+                const date = new ISO8601Date_1.ISO8601Date("2025-03-01");
+                expect(date.addDays(31 + 30 + 31 + 3).value).toBe("2025-06-04");
+            });
+            it("Should be chainable.", () => {
+                const date = new ISO8601Date_1.ISO8601Date("2025-03-01");
+                expect(date.addDays(31).addDays(30).addDays(31).addDays(3).value).toBe("2025-06-04");
+            });
+        });
+    });
+    describe("ISO8601Date.jsDateTimeToDate()", () => {
+        it("Should return an IDate instance", () => {
+            expect(ISO8601Date_1.ISO8601Date.jsDateTimeToDate(new Date(2025, 5, 4))).toBeInstanceOf(ISO8601Date_1.ISO8601Date);
+        });
+        it("Should return expected value in ISO8601 format.", () => {
+            expect(ISO8601Date_1.ISO8601Date.jsDateTimeToDate(new Date(2025, 5, 4)).value).toBe("2025-06-04");
+            expect(ISO8601Date_1.ISO8601Date.jsDateTimeToDate(new Date(2025, 0, 1)).value).toBe("2025-01-01");
+        });
+        it("If js date is in UTC (created without timezone and with a string) and converting would cause a change of date, should return date changed.", () => {
+            expect(ISO8601Date_1.ISO8601Date.jsDateTimeToDate(new Date("2025-06-04")).value).toBe("2025-06-03");
+        });
+        it("If js date is in UTC (created with timezone and with a string) and converting would cause a change of date, should return date changed.", () => {
+            expect(ISO8601Date_1.ISO8601Date.jsDateTimeToDate(new Date("2025-06-04T00:00:00Z")).value).toBe("2025-06-03");
+        });
+        it("If js date is in UTC and useUtc param is true, should return utc date.", () => {
+            expect(ISO8601Date_1.ISO8601Date.jsDateTimeToDate(new Date("2025-06-04T00:00:00Z"), {
+                useUtc: true,
+            }).value).toBe("2025-06-04");
+        });
+    });
+    describe("ISO8601Date.getToday()", () => {
+        afterEach(() => {
+            jest.useRealTimers();
+        });
+        it("Should return today's date properly with different timezones", () => {
+            jest.useFakeTimers().setSystemTime(new Date("2025-01-01T23:00:00-03:00"));
+            expect(ISO8601Date_1.ISO8601Date.getToday()).toBe("2025-01-01");
+            jest.setSystemTime(new Date("2025-01-02T23:00:00+03:00"));
+            expect(ISO8601Date_1.ISO8601Date.getToday()).toBe("2025-01-02");
+            jest.setSystemTime(new Date("2025-01-04T23:00:00+12:00"));
+            expect(ISO8601Date_1.ISO8601Date.getToday()).toBe("2025-01-04");
+        });
+    });
+    describe("ISO8601Date.toLocalJsDateTime()", () => {
+        it("Should return js date time of same day, month and year, considering local time.", () => {
+            const date = new ISO8601Date_1.ISO8601Date("2025-01-01").toLocalJsDateTime();
+            expect(date.getMonth()).toEqual(0);
+            expect(date.getDate()).toEqual(1);
+            expect(date.getFullYear()).toEqual(2025);
+            expect(date.getHours()).toEqual(0);
+            expect(date.getMinutes()).toEqual(0);
+            expect(date.getSeconds()).toEqual(0);
+        });
+    });
+    describe("ISO8601Date.toUtcJsDateTime()", () => {
+        afterEach(() => {
+            jest.useRealTimers();
+        });
+        it("Should return js date time of same day, month and year, considering utc time.", () => {
+            jest.useFakeTimers().setSystemTime(new Date("2025-01-01T00:00:00Z"));
+            const date = new ISO8601Date_1.ISO8601Date("2025-01-01").toUtcJsDateTime();
+            expect(date).toBeInstanceOf(Date);
+            expect(date.getUTCMonth()).toEqual(0);
+            expect(date.getUTCDate()).toEqual(1);
+            expect(date.getUTCFullYear()).toEqual(2025);
+            expect(date.getUTCHours()).toEqual(0);
+            expect(date.getUTCMinutes()).toEqual(0);
+            expect(date.getUTCSeconds()).toEqual(0);
+        });
+    });
+    describe("ISO8601Date.getDaysSinceEpoch()", () => {
+        it("Should return expected days count", () => {
+            const days = new ISO8601Date_1.ISO8601Date("1970-01-02").getDaysSinceEpoch();
+            expect(days).toEqual(1);
+        });
+        it("From a UTC date, should return expected days count", () => {
+            const utcDate = new Date("1970-01-02T00:00:00Z");
+            const days = new ISO8601Date_1.ISO8601Date()
+                .jsDateTimeToDate(utcDate, { useUtc: true })
+                .getDaysSinceEpoch();
+            expect(days).toEqual(1);
+        });
+    });
+    describe("ISO8601Date.getDayOfTheWeek()", () => {
+        afterEach(() => {
+            jest.useRealTimers();
+        });
+        jest.useFakeTimers().setSystemTime(new Date("2025-04-21"));
+        const today = new ISO8601Date_1.ISO8601Date();
+        it("Should return 0 for Monday.", () => {
+            expect(today.getDayOfTheWeek()).toEqual(0);
+        });
+        it("Should return 1 for Tuesday.", () => {
+            expect(today.addDays(1).getDayOfTheWeek()).toEqual(1);
+        });
+        it("Should return 2 for Wednesday.", () => {
+            expect(today.addDays(2).getDayOfTheWeek()).toEqual(2);
+        });
+        it("Should return 3 for Thursday.", () => {
+            expect(today.addDays(3).getDayOfTheWeek()).toEqual(3);
+        });
+        it("Should return 4 for Friday.", () => {
+            expect(today.addDays(4).getDayOfTheWeek()).toEqual(4);
+        });
+        it("Should return 5 for Saturday.", () => {
+            expect(today.addDays(5).getDayOfTheWeek()).toEqual(5);
+        });
+        it("Should return 6 for Sunday.", () => {
+            expect(today.addDays(6).getDayOfTheWeek()).toEqual(6);
+        });
+    });
+});

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

@@ -0,0 +1,41 @@
+import { IDate } from "./Date";
+import { ITime } from "./Time";
+export interface IDateTime {
+    date: IDate;
+    time: ITime;
+    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.
+     */
+    getIsoString: (opts?: {
+        timezoneOffsetMinutes?: number;
+        newDate?: IDate;
+        newTime?: ITime;
+    }) => string;
+}
+export declare class ISO8601DateTime implements IDateTime {
+    date: IDate;
+    time: ITime;
+    constructor(opts: {
+        date: IDate;
+        time: ITime;
+    });
+    getJSDateTime: () => Date;
+    getBrazilianIsoString: () => string;
+    getIsoString(opts?: {
+        timezoneOffsetMinutes?: number;
+        newDate?: IDate;
+        newTime?: ITime;
+    }): string;
+}

package/dist/domain/entities/ISO8601DateTime.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISO8601DateTime = void 0;
+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.getHours()), parseInt(this.time.getMinutes()), parseInt(this.time.getSeconds()));
+        };
+        this.getBrazilianIsoString = () => {
+            return this.getIsoString({
+                timezoneOffsetMinutes: -180,
+            });
+        };
+        this.date = opts.date;
+        this.time = opts.time;
+    }
+    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}`;
+    }
+}
+exports.ISO8601DateTime = ISO8601DateTime;

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

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

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

@@ -0,0 +1,146 @@
+"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);
+        });
+        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");
+        });
+    });
+    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 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");
+        });
+        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");
+        });
+    });
+});

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

@@ -0,0 +1,13 @@
+import { IDateValidator } from "./DateValidator";
+/**
+ * Accepted format: YYYY-MM-DD
+ * @throws on construction if format is wrong
+ * @throws on get methods if format is wrong
+ */
+export declare class ISO8601DateValidator implements IDateValidator {
+    private YYYYmmDD;
+    /**
+     * Accepted format: YYYY-MM-DD
+     */
+    formatIsValid(date: string): boolean;
+}

package/dist/domain/entities/ISO8601DateValidator.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISO8601DateValidator = void 0;
+/**
+ * Accepted format: YYYY-MM-DD
+ * @throws on construction if format is wrong
+ * @throws on get methods if format is wrong
+ */
+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])$");
+    }
+    /**
+     * Accepted format: YYYY-MM-DD
+     */
+    formatIsValid(date) {
+        return this.YYYYmmDD.test(date);
+    }
+}
+exports.ISO8601DateValidator = ISO8601DateValidator;

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

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

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ISO8601DateValidator_1 = require("./ISO8601DateValidator");
+describe("ISO8601DateValidator", () => {
+    describe("ISO8601DateValidator.formatIsValid()", () => {
+        it("Should return true if format is YYYY-MM-DD.", () => {
+            const date = new ISO8601DateValidator_1.ISO8601DateValidator();
+            expect(date.formatIsValid("2025-01-01")).toBe(true);
+        });
+        it("Should return false if format is not YYYY-MM-DD.", () => {
+            const date = new ISO8601DateValidator_1.ISO8601DateValidator();
+            expect(date.formatIsValid("2025-01-011")).toBe(false);
+        });
+    });
+});

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

@@ -0,0 +1,25 @@
+import { IISO8601TimeValidator } from "./ISO8601TimeValidator";
+import { ITime } from "./Time";
+/**
+ * Interface for interacting with ISO8601 time formats.
+ * Accepted formats: HH:MM:SS and HH:MM.
+ *
+ * @throws if instantiated with a different format
+ * @throws if any method is called with a different format
+ */
+export declare class ISO8601Time implements ITime {
+    readonly value: string;
+    readonly validator: IISO8601TimeValidator;
+    /**
+     * Throws if format is invalid.
+     * Accepted formats: HH:MM:SS and HH:MM.
+     */
+    constructor(value?: string);
+    private validateFormatOrThrow;
+    getTime(): string;
+    getMinutes(): string;
+    getHours(): string;
+    getSeconds(): string;
+    static getNow(): string;
+    getNow: typeof ISO8601Time.getNow;
+}

package/dist/domain/entities/ISO8601Time.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISO8601Time = void 0;
+const ISO8601TimeValidator_1 = require("./ISO8601TimeValidator");
+/**
+ * Interface for interacting with ISO8601 time formats.
+ * Accepted formats: HH:MM:SS and HH:MM.
+ *
+ * @throws if instantiated with a different format
+ * @throws if any method is called with a different format
+ */
+class ISO8601Time {
+    /**
+     * Throws if format is invalid.
+     * Accepted formats: HH:MM:SS and HH:MM.
+     */
+    constructor(value) {
+        this.validator = new ISO8601TimeValidator_1.ISO8601TimeValidator();
+        this.getNow = ISO8601Time.getNow;
+        this.value = value ? value : this.getNow();
+        this.validateFormatOrThrow();
+    }
+    validateFormatOrThrow() {
+        if (!this.validator.formatIsValid(this.value))
+            throw new Error("Time format must be ISO8601.");
+    }
+    getTime() {
+        this.validateFormatOrThrow();
+        if (this.validator.isHHmm(this.value)) {
+            return `${this.value}:00`;
+        }
+        return this.value;
+    }
+    getMinutes() {
+        this.validateFormatOrThrow();
+        return this.value.split(":")[1];
+    }
+    getHours() {
+        this.validateFormatOrThrow();
+        return this.value.split(":")[0];
+    }
+    getSeconds() {
+        this.validateFormatOrThrow();
+        const seconds = this.value.split(":")[2];
+        if (seconds)
+            return seconds;
+        return "00";
+    }
+    static getNow() {
+        const nowDate = new Date();
+        const hours = nowDate.getHours().toString().padStart(2, "0");
+        const minutes = nowDate.getMinutes().toString().padStart(2, "0");
+        const seconds = nowDate.getSeconds().toString().padStart(2, "0");
+        return `${hours}:${minutes}:${seconds}`;
+    }
+}
+exports.ISO8601Time = ISO8601Time;

package/dist/domain/entities/ISO8601Time.test.d.ts

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

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ISO8601Time_1 = require("./ISO8601Time");
+describe("ISO8601Time", () => {
+    beforeAll(() => {
+        jest.useFakeTimers({
+            now: new Date("2025-01-01T23:00:00-03:00"),
+            legacyFakeTimers: false,
+        });
+    });
+    afterAll(() => {
+        jest.useRealTimers();
+    });
+    describe("ISO8601Time constructor", () => {
+        it("Should construct with no arguments.", () => {
+            const time = new ISO8601Time_1.ISO8601Time();
+            expect(time).toBeDefined();
+        });
+        it("Should construct with now time when receiving no arguments.", () => {
+            const time = new ISO8601Time_1.ISO8601Time();
+            expect(time.value).toBe("23:00:00");
+        });
+    });
+    describe("ISO8601Time.getNow()", () => {
+        it("Should get now time.", () => {
+            expect(ISO8601Time_1.ISO8601Time.getNow()).toBe("23:00:00");
+        });
+    });
+    describe("ISO8601Time.getHours()", () => {
+        it("Should return hours when valid", () => {
+            const time = new ISO8601Time_1.ISO8601Time("00:01");
+            expect(time.getHours()).toBe("00");
+            const time2 = new ISO8601Time_1.ISO8601Time("00:01:02");
+            expect(time2.getHours()).toBe("00");
+        });
+    });
+    describe("ISO8601Time.getMinutes()", () => {
+        it("Should return minutes when valid", () => {
+            const time = new ISO8601Time_1.ISO8601Time("00:01");
+            expect(time.getMinutes()).toBe("01");
+            const time2 = new ISO8601Time_1.ISO8601Time("00:01:02");
+            expect(time2.getMinutes()).toBe("01");
+        });
+    });
+    describe("ISO8601Time.getSeconds()", () => {
+        it("Should return seconds when valid", () => {
+            const time2 = new ISO8601Time_1.ISO8601Time("00:01:02");
+            expect(time2.getSeconds()).toBe("02");
+        });
+        it("Should return 00 when seconds are not present.", () => {
+            const time = new ISO8601Time_1.ISO8601Time("00:01");
+            expect(time.getSeconds()).toBe("00");
+        });
+    });
+    describe("ISO8601Time.getTime()", () => {
+        it("Should return time when valid", () => {
+            const time = new ISO8601Time_1.ISO8601Time("00:01");
+            expect(time.getTime()).toBe("00:01:00");
+            const time2 = new ISO8601Time_1.ISO8601Time("00:01:02");
+            expect(time2.getTime()).toBe("00:01:02");
+        });
+    });
+});

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

@@ -0,0 +1,12 @@
+import { ITimeValidator } from "./TimeValidator";
+export interface IISO8601TimeValidator extends ITimeValidator {
+    isHHmmSS: (time: string) => boolean;
+    isHHmm: (time: string) => boolean;
+}
+export declare class ISO8601TimeValidator implements ITimeValidator {
+    private hhMMssPattern;
+    private hhMMPattern;
+    formatIsValid(time: string): boolean;
+    isHHmmSS(time: string): boolean;
+    isHHmm(time: string): boolean;
+}