@eliasrrosa/tutorhub-public-assets 0.0.9 → 0.0.11

package/dist/domain/entities/ISO8601DateTime.js

@@ -4,7 +4,7 @@ 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()));
+            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()));
         };
         this.getBrazilianIsoString = () => {
             return this.getIsoString({

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

@@ -1,4 +1,7 @@
 import { IISO8601TimeValidator } from "./ISO8601TimeValidator";
+import { IISO8601Timezone } from "./ISO8601Timezone";
+import { IISO8601TimezoneConverter } from "./ISO8601TimezoneConverter";
+import { IISO8601TimezoneParser } from "./ISO8601TimezoneParser";
 import { ITime } from "./Time";
 /**
  * Interface for interacting with ISO8601 time formats.
@@ -8,21 +11,28 @@ import { ITime } from "./Time";
  * @throws if any method is called with a different format
  */
 export declare class ISO8601Time implements ITime {
-    readonly value: string;
-    readonly validator: IISO8601TimeValidator;
-    readonly timezone?: string;
+    readonly originalTimeString: string;
+    readonly timeValidator: IISO8601TimeValidator;
+    readonly converter: IISO8601TimezoneConverter;
+    readonly parser: IISO8601TimezoneParser;
     /**
      * Throws if format is invalid.
-     * Accepted formats: HH:MM:SS and HH:MM.
+     * Accepted formats: HH:MM:SS, HH:MM, HH:MM:SS(+|-)HH:MM, HH:MM:SS.sssZ and HH:MM:SSZ.
      */
     constructor(value?: string);
     private validateFormatOrThrow;
-    getTime(opts?: {
-        format?: "HH:MM" | "HH:MM:SS";
+    getTimeString(opts?: {
+        format?: "HH:MM" | "HH:MM:SS" | "HH:MM:SS(+|-)HH:MM";
+        convertToTimezone?: string | number;
     }): string;
-    getMinutes(): string;
-    getHours(): string;
-    getSeconds(): string;
+    getMinutesString(): string;
+    getHoursString(): string;
+    getSecondsString(): string;
     static getNow(): string;
-    getNow: typeof ISO8601Time.getNow;
+    getNowTimeString: typeof ISO8601Time.getNow;
+    getTimezone: () => IISO8601Timezone;
+    addHours: (hours: number) => ITime;
+    addMinutes: (minutes: number) => ITime;
+    addTimezone: (timezone: string | number) => ITime;
+    getTimezoneString(): string;
 }

package/dist/domain/entities/ISO8601Time.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ISO8601Time = void 0;
 const ISO8601TimeValidator_1 = require("./ISO8601TimeValidator");
+const ISO8601Timezone_1 = require("./ISO8601Timezone");
+const ISO8601TimezoneConverter_1 = require("./ISO8601TimezoneConverter");
+const ISO8601TimezoneParser_1 = require("./ISO8601TimezoneParser");
 /**
  * Interface for interacting with ISO8601 time formats.
  * Accepted formats: HH:MM:SS, HH:MM, HH:MM:SSZ, HH:MM:SS.sssZ and HH:MM:SS(+|-)HH:MM.
@@ -12,49 +15,80 @@ const ISO8601TimeValidator_1 = require("./ISO8601TimeValidator");
 class ISO8601Time {
     /**
      * Throws if format is invalid.
-     * Accepted formats: HH:MM:SS and HH:MM.
+     * Accepted formats: HH:MM:SS, HH:MM, HH:MM:SS(+|-)HH:MM, HH:MM:SS.sssZ and HH:MM:SSZ.
      */
     constructor(value) {
-        this.validator = new ISO8601TimeValidator_1.ISO8601TimeValidator();
-        this.getNow = ISO8601Time.getNow;
-        this.value = value ? value : this.getNow();
+        this.timeValidator = new ISO8601TimeValidator_1.ISO8601TimeValidator();
+        this.converter = new ISO8601TimezoneConverter_1.ISO8601TimezoneConverter();
+        this.parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+        this.getNowTimeString = ISO8601Time.getNow;
+        this.getTimezone = () => {
+            return new ISO8601Timezone_1.ISO8601Timezone(this.originalTimeString);
+        };
+        this.addHours = (hours) => {
+            let targetHour = parseInt(this.getHoursString()) + hours;
+            while (targetHour >= 24) {
+                targetHour = targetHour - 24;
+            }
+            while (targetHour < 0) {
+                targetHour = 24 + targetHour;
+            }
+            const targetHourString = targetHour >= 0
+                ? targetHour.toString().padStart(2, "0")
+                : `-${Math.abs(targetHour).toString().padStart(2, "0")}`;
+            const targetTimeString = `${targetHourString}:${this.getMinutesString()}:${this.getSecondsString()}${this.getTimezone().selector.getTimezoneString(this.originalTimeString)}`;
+            return new ISO8601Time(targetTimeString);
+        };
+        this.addMinutes = (minutes) => {
+            const minutesToAddFromZeroMinutes = minutes + parseInt(this.getMinutesString());
+            const hoursToAdd = Math.floor(minutesToAddFromZeroMinutes / 60);
+            const targetMinutes = minutesToAddFromZeroMinutes - hoursToAdd * 60;
+            const timeWithAddedHours = new ISO8601Time(this.originalTimeString).addHours(hoursToAdd);
+            const targetMinutesString = targetMinutes.toString().padStart(2, "0");
+            return new ISO8601Time(`${timeWithAddedHours.getHoursString()}:${targetMinutesString}:${timeWithAddedHours.getSecondsString()}${timeWithAddedHours
+                .getTimezone()
+                .selector.getTimezoneString(timeWithAddedHours.originalTimeString)}`);
+        };
+        this.addTimezone = (timezone) => {
+            const newTimezone = typeof timezone == "number" ? this.parser.toString(timezone) : timezone;
+            return new ISO8601Time(`${this.getHoursString()}:${this.getMinutesString()}:${this.getSecondsString()}${newTimezone}`);
+        };
+        this.originalTimeString = value ? value : this.getNowTimeString();
         this.validateFormatOrThrow();
     }
     validateFormatOrThrow() {
-        if (!this.validator.formatIsValid(this.value))
+        if (!this.timeValidator.formatIsValid(this.originalTimeString))
             throw new Error("Time format must be ISO8601.");
     }
-    getTime(opts) {
+    getTimeString(opts) {
         this.validateFormatOrThrow();
-        if ((opts === null || opts === void 0 ? void 0 : opts.format) == "HH:MM" && this.validator.isHHmm(this.value)) {
-            return this.value;
+        if ((opts === null || opts === void 0 ? void 0 : opts.format) == "HH:MM") {
+            return `${this.getHoursString()}:${this.getMinutesString()}`;
         }
-        if (((opts === null || opts === void 0 ? void 0 : opts.format) == "HH:MM:SS" || !(opts === null || opts === void 0 ? void 0 : opts.format)) &&
-            this.validator.isHHmmSS(this.value)) {
-            return this.value;
+        if ((opts === null || opts === void 0 ? void 0 : opts.format) == "HH:MM:SS") {
+            return `${this.getHoursString()}:${this.getMinutesString()}:${this.getSecondsString()}`;
         }
-        if ((opts === null || opts === void 0 ? void 0 : opts.format) == "HH:MM" && this.validator.isHHmmSS(this.value)) {
-            return `${this.getHours()}:${this.getMinutes()}`;
+        if ((opts === null || opts === void 0 ? void 0 : opts.format) == "HH:MM:SS(+|-)HH:MM") {
+            const timezone = new ISO8601Timezone_1.ISO8601Timezone(this.originalTimeString);
+            return `${this.getHoursString()}:${this.getMinutesString()}:${this.getSecondsString()}${timezone.selector.getTimezoneString(this.originalTimeString)}`;
         }
-        if (((opts === null || opts === void 0 ? void 0 : opts.format) == "HH:MM:SS" || !(opts === null || opts === void 0 ? void 0 : opts.format)) &&
-            this.validator.isHHmm(this.value)) {
-            return `${this.getHours()}:${this.getMinutes()}:${this.getSeconds()}`;
-        }
-        throw new Error("Time format is invalid.");
+        return `${this.getHoursString()}:${this.getMinutesString()}:${this.getSecondsString()}`;
     }
-    getMinutes() {
+    getMinutesString() {
         this.validateFormatOrThrow();
-        return this.value.split(":")[1];
+        return this.originalTimeString.split(":")[1];
     }
-    getHours() {
+    getHoursString() {
         this.validateFormatOrThrow();
-        return this.value.split(":")[0];
+        return this.originalTimeString.split(":")[0];
     }
-    getSeconds() {
+    getSecondsString() {
         this.validateFormatOrThrow();
-        const seconds = this.value.split(":")[2];
+        const seconds = this.originalTimeString.split(":")[2];
+        const secondsFirstDigit = seconds === null || seconds === void 0 ? void 0 : seconds.split("")[0];
+        const secondsSecondDigit = seconds === null || seconds === void 0 ? void 0 : seconds.split("")[1];
         if (seconds)
-            return seconds;
+            return `${secondsFirstDigit}${secondsSecondDigit}`;
         return "00";
     }
     static getNow() {
@@ -64,5 +98,8 @@ class ISO8601Time {
         const seconds = nowDate.getSeconds().toString().padStart(2, "0");
         return `${hours}:${minutes}:${seconds}`;
     }
+    getTimezoneString() {
+        return this.getTimezone().selector.getTimezoneString(this.originalTimeString);
+    }
 }
 exports.ISO8601Time = ISO8601Time;

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

@@ -18,7 +18,7 @@ describe("ISO8601Time", () => {
         });
         it("Should construct with now time when receiving no arguments.", () => {
             const time = new ISO8601Time_1.ISO8601Time();
-            expect(time.value).toBe("23:00:00");
+            expect(time.originalTimeString).toBe("23:00:00");
         });
         it("Should throw given irregular time format", () => {
             const time = () => new ISO8601Time_1.ISO8601Time("000:00:10");
@@ -69,55 +69,146 @@ describe("ISO8601Time", () => {
     describe("ISO8601Time.getHours()", () => {
         it("Should return hours when valid", () => {
             const time = new ISO8601Time_1.ISO8601Time("00:01");
-            expect(time.getHours()).toBe("00");
+            expect(time.getHoursString()).toBe("00");
             const time2 = new ISO8601Time_1.ISO8601Time("00:01:02");
-            expect(time2.getHours()).toBe("00");
+            expect(time2.getHoursString()).toBe("00");
         });
     });
     describe("ISO8601Time.getMinutes()", () => {
         it("Should return minutes when valid", () => {
             const time = new ISO8601Time_1.ISO8601Time("00:01");
-            expect(time.getMinutes()).toBe("01");
+            expect(time.getMinutesString()).toBe("01");
             const time2 = new ISO8601Time_1.ISO8601Time("00:01:02");
-            expect(time2.getMinutes()).toBe("01");
+            expect(time2.getMinutesString()).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");
+            expect(time2.getSecondsString()).toBe("02");
         });
         it("Should return 00 when seconds are not present.", () => {
             const time = new ISO8601Time_1.ISO8601Time("00:01");
-            expect(time.getSeconds()).toBe("00");
+            expect(time.getSecondsString()).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");
+            expect(time.getTimeString()).toBe("00:01:00");
             const time2 = new ISO8601Time_1.ISO8601Time("00:01:02");
-            expect(time2.getTime()).toBe("00:01:02");
+            expect(time2.getTimeString()).toBe("00:01:02");
         });
         it("Should return HH:MM if format argument is passed", () => {
             const time = new ISO8601Time_1.ISO8601Time("00:01");
-            expect(time.getTime({ format: "HH:MM" })).toBe("00:01");
+            expect(time.getTimeString({ format: "HH:MM" })).toBe("00:01");
         });
         it("Should return HH:MM if format argument is passed and time format is HH:MM:SS", () => {
             const time = new ISO8601Time_1.ISO8601Time("00:01:10");
-            expect(time.getTime({ format: "HH:MM" })).toBe("00:01");
+            expect(time.getTimeString({ format: "HH:MM" })).toBe("00:01");
         });
         it("Should return HH:MM:SS by default", () => {
             const time = new ISO8601Time_1.ISO8601Time("00:01:10");
-            expect(time.getTime()).toBe("00:01:10");
+            expect(time.getTimeString()).toBe("00:01:10");
         });
         it("Should return HH:MM:SS by default even if format is HH:MM", () => {
             const time = new ISO8601Time_1.ISO8601Time("00:01");
-            expect(time.getTime()).toBe("00:01:00");
+            expect(time.getTimeString()).toBe("00:01:00");
         });
         it("Should return HH:MM:SS given format argument", () => {
             const time = new ISO8601Time_1.ISO8601Time("00:01");
-            expect(time.getTime({ format: "HH:MM:SS" })).toBe("00:01:00");
+            expect(time.getTimeString({ format: "HH:MM:SS" })).toBe("00:01:00");
+        });
+        it("Should return HH:MM:SS(+|-)HH:MM given format argument, defaulting to Z given no timezone.", () => {
+            const time = new ISO8601Time_1.ISO8601Time("00:01");
+            expect(time.getTimeString({ format: "HH:MM:SS(+|-)HH:MM" })).toBe("00:01:00Z");
+        });
+        it("Should return HH:MM:SS(+|-)HH:MM given format argument.", () => {
+            const time = new ISO8601Time_1.ISO8601Time("00:01:00+03:00");
+            expect(time.getTimeString({ format: "HH:MM:SS(+|-)HH:MM" })).toBe("00:01:00+03:00");
+        });
+        it("Should return HH:MM:SSZ given format argument and UTC timezone.", () => {
+            const time = new ISO8601Time_1.ISO8601Time("00:01:00Z");
+            expect(time.getTimeString({ format: "HH:MM:SS(+|-)HH:MM" })).toBe("00:01:00Z");
+        });
+        it("Should return HH:MM:SSZ given format argument and UTC timezone with milliseconds.", () => {
+            const time = new ISO8601Time_1.ISO8601Time("00:01:00.222Z");
+            expect(time.getTimeString({ format: "HH:MM:SS(+|-)HH:MM" })).toBe("00:01:00Z");
+        });
+    });
+    describe("ISO8601Time.addHours()", () => {
+        it("Should change from 21 to 22 when adding 1", () => {
+            const time = new ISO8601Time_1.ISO8601Time("21:00:00");
+            expect(time.addHours(1).getHoursString()).toEqual("22");
+        });
+        it("Should change from 21 to 00 when adding 3", () => {
+            const time = new ISO8601Time_1.ISO8601Time("21:00:00");
+            expect(time.addHours(3).getHoursString()).toEqual("00");
+        });
+        it("Should change from 21 to 22 when adding 25", () => {
+            const time = new ISO8601Time_1.ISO8601Time("21:00:00");
+            expect(time.addHours(25).getHoursString()).toEqual("22");
+        });
+        it("Should change from 23 to 22 when adding -1", () => {
+            const time = new ISO8601Time_1.ISO8601Time("23:00:00");
+            expect(time.addHours(-1).getHoursString()).toEqual("22");
+        });
+        it("Should change from 00 to 23 when adding -1", () => {
+            const time = new ISO8601Time_1.ISO8601Time("00:00:00");
+            expect(time.addHours(-1).getHoursString()).toEqual("23");
+        });
+    });
+    describe("ISO8601Time.addMinutes()", () => {
+        it("Should change from 00 to 50 when adding 50", () => {
+            const time = new ISO8601Time_1.ISO8601Time("21:00:00");
+            expect(time.addMinutes(50).getMinutesString()).toEqual("50");
+            expect(time.addMinutes(50).getHoursString()).toEqual("21");
+        });
+        it("Should change from 00 to 01 when adding 61", () => {
+            const time = new ISO8601Time_1.ISO8601Time("21:00:00");
+            expect(time.addMinutes(61).getMinutesString()).toEqual("01");
+            expect(time.addMinutes(61).getHoursString()).toEqual("22");
+        });
+        it("Should change from 50 to 00 when adding 10", () => {
+            const time = new ISO8601Time_1.ISO8601Time("21:50:00");
+            expect(time.addMinutes(10).getMinutesString()).toEqual("00");
+            expect(time.addMinutes(10).getHoursString()).toEqual("22");
+        });
+        it("Should change from 00 to 10 when adding 610", () => {
+            const time = new ISO8601Time_1.ISO8601Time("23:00:00");
+            expect(time.addMinutes(610).getMinutesString()).toEqual("10");
+            expect(time.addMinutes(610).getHoursString()).toEqual("09");
+        });
+        it("Should change from 00 to 50 when adding -10", () => {
+            const time = new ISO8601Time_1.ISO8601Time("23:00:00");
+            expect(time.addMinutes(-10).getMinutesString()).toEqual("50");
+            expect(time.addMinutes(-10).getHoursString()).toEqual("22");
+        });
+    });
+    describe("ISO8601Time.addTimezone()", () => {
+        it("Should add a timezone using a number without converting it", () => {
+            const time = new ISO8601Time_1.ISO8601Time("23:00:00");
+            expect(time.addTimezone(-180).getTimeString({ format: "HH:MM:SS(+|-)HH:MM" })).toEqual("23:00:00-03:00");
+            expect(time.addTimezone(-180).getTimezoneString()).toEqual("-03:00");
+        });
+        it("Should add a timezone using a string without converting it", () => {
+            const time = new ISO8601Time_1.ISO8601Time("23:00:00");
+            expect(time
+                .addTimezone("-03:00")
+                .getTimeString({ format: "HH:MM:SS(+|-)HH:MM" })).toEqual("23:00:00-03:00");
+            expect(time.addTimezone("-03:00").getTimezoneString()).toEqual("-03:00");
+        });
+        it("Should add a timezone using a positive number without converting it", () => {
+            const time = new ISO8601Time_1.ISO8601Time("23:00:00");
+            expect(time.addTimezone(180).getTimeString({ format: "HH:MM:SS(+|-)HH:MM" })).toEqual("23:00:00+03:00");
+            expect(time.addTimezone(180).getTimezoneString()).toEqual("+03:00");
+        });
+        it("Should add a timezone using a positive timezone string without converting it", () => {
+            const time = new ISO8601Time_1.ISO8601Time("23:00:00");
+            expect(time
+                .addTimezone("+03:00")
+                .getTimeString({ format: "HH:MM:SS(+|-)HH:MM" })).toEqual("23:00:00+03:00");
+            expect(time.addTimezone("+03:00").getTimezoneString()).toEqual("+03:00");
         });
     });
 });

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

@@ -7,10 +7,17 @@ export interface IISO8601TimeValidator extends ITimeValidator {
     isHHmmSSZ: (time: string) => boolean;
     /** Accepted formats: `HH:MM:SS`, `HH:MM`, `HH:MM:SSZ`, `HH:MM:SS.sssZ` and `HH:MM:SS(+|-)HH:MM`. */
     formatIsValid: (time: string) => boolean;
+    numberedTimezonePattern: RegExp;
 }
 export declare class ISO8601TimeValidator implements IISO8601TimeValidator {
     private upTo23;
     private upTo59;
+    private upTo11;
+    private upTo13;
+    numberedTimezonePatternString: string;
+    numberedTimezonePattern: RegExp;
+    private zTimezonePatternString;
+    private zAndMillisecondsPatternString;
     private hhMMssPattern;
     private hhMMPattern;
     private hhMMssPlusNumberedTimezonePattern;

package/dist/domain/entities/ISO8601TimeValidator.js

@@ -5,11 +5,17 @@ class ISO8601TimeValidator {
     constructor() {
         this.upTo23 = "([0-1][0-9]|[2][0-3])";
         this.upTo59 = "[0-5][0-9]";
+        this.upTo11 = "(0[0-9]|1[0-2])";
+        this.upTo13 = "(0[0-9]|1[0-4])";
+        this.numberedTimezonePatternString = `(\\+(${this.upTo11}:${this.upTo59}|12:00)|\\-(${this.upTo13}:${this.upTo59}|14:00))`;
+        this.numberedTimezonePattern = new RegExp(`^${this.numberedTimezonePatternString}$`);
+        this.zTimezonePatternString = "Z";
+        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}(\\+((0[0-9]|1[0-2]):${this.upTo59})|\\-((0[0-9]|1[0-4]):${this.upTo59}))$`);
-        this.hhMMssZPattern = new RegExp(`^${this.upTo23}:${this.upTo59}:${this.upTo59}Z$`);
-        this.hhMMssSSSZPattern = new RegExp(`^${this.upTo23}:${this.upTo59}:${this.upTo59}.[0-9]{3}Z$`);
+        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.isHHmmSSPlusNumberedTimezone = (time) => {
             return this.hhMMssPlusNumberedTimezonePattern.test(time);
         };

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

@@ -0,0 +1,12 @@
+import { IISO8601TimezoneParser, ISO8601TimezoneParser } from "./ISO8601TimezoneParser";
+import { IISO8601TimezoneSelector, ISO8601TimezoneSelector } from "./ISO8601TimezoneSelector";
+export interface IISO8601Timezone {
+    selector: IISO8601TimezoneSelector;
+    parser: IISO8601TimezoneParser;
+}
+export declare class ISO8601Timezone implements IISO8601Timezone {
+    readonly originalTimezoneString: string;
+    selector: ISO8601TimezoneSelector;
+    parser: ISO8601TimezoneParser;
+    constructor(originalTimezoneString?: string);
+}

package/dist/domain/entities/ISO8601Timezone.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISO8601Timezone = void 0;
+const ISO8601TimezoneParser_1 = require("./ISO8601TimezoneParser");
+const ISO8601TimezoneSelector_1 = require("./ISO8601TimezoneSelector");
+class ISO8601Timezone {
+    constructor(originalTimezoneString) {
+        this.selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+        this.parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+        this.originalTimezoneString = originalTimezoneString || "Z";
+    }
+}
+exports.ISO8601Timezone = ISO8601Timezone;

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

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

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ISO8601Timezone_1 = require("./ISO8601Timezone");
+describe("ISO8601Timezone", () => {
+    describe("ISO8601Timezone constructor", () => {
+        it("Should be instantiable without arguments", () => {
+            const timezone = new ISO8601Timezone_1.ISO8601Timezone();
+            expect(timezone).toBeDefined();
+        });
+    });
+});

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

@@ -0,0 +1,19 @@
+import { ITime } from "./Time";
+export interface IISO8601TimezoneConverter {
+    /**
+     * Converts an ISO8601 time, like `00:00:00` or `00:00:00+03:00` to a target timezone.
+     * If no timezone is present on the time string, it is considered UTC.
+     */
+    convertTo: (opts: {
+        time: ITime;
+        targetTimezone: string | number;
+    }) => ITime;
+}
+export declare class ISO8601TimezoneConverter implements IISO8601TimezoneConverter {
+    private timezoneParser;
+    private timezoneValidator;
+    convertTo: (opts: {
+        time: ITime;
+        targetTimezone: string | number;
+    }) => ITime;
+}

package/dist/domain/entities/ISO8601TimezoneConverter.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISO8601TimezoneConverter = void 0;
+const ISO8601TimezoneParser_1 = require("./ISO8601TimezoneParser");
+const ISO8601TimezoneValidator_1 = require("./ISO8601TimezoneValidator");
+class ISO8601TimezoneConverter {
+    constructor() {
+        this.timezoneParser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+        this.timezoneValidator = new ISO8601TimezoneValidator_1.ISO8601TimezoneValidator();
+        this.convertTo = (opts) => {
+            if (!this.timezoneValidator.formatIsValid(opts.targetTimezone)) {
+                throw new Error("Timezone format is invalid, could not convert.");
+            }
+            const originalTimezoneInMinutes = opts.time
+                .getTimezone()
+                .parser.toMinutes(opts.time.originalTimeString);
+            const targetTimezoneInMinutes = typeof opts.targetTimezone == "number"
+                ? opts.targetTimezone
+                : this.timezoneParser.toMinutes(opts.targetTimezone);
+            const timezoneOffsetMinutes = targetTimezoneInMinutes - originalTimezoneInMinutes;
+            const hoursOffset = Math.floor(timezoneOffsetMinutes / 60);
+            const minutesOffset = timezoneOffsetMinutes - hoursOffset * 60;
+            const targetTime = opts.time.addHours(hoursOffset).addMinutes(minutesOffset).addTimezone(opts.targetTimezone);
+            return targetTime;
+        };
+    }
+}
+exports.ISO8601TimezoneConverter = ISO8601TimezoneConverter;

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

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

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ISO8601Time_1 = require("./ISO8601Time");
+const ISO8601TimezoneConverter_1 = require("./ISO8601TimezoneConverter");
+describe("ISO8601TimezoneConverter", () => {
+    describe("ISO8601TimezoneConverter constructor", () => {
+        it("Should be instantiable without arguments", () => {
+            const converter = new ISO8601TimezoneConverter_1.ISO8601TimezoneConverter();
+            expect(converter).toBeDefined();
+        });
+    });
+    describe("ISO8601TimezoneConverter.convertTo", () => {
+        it("Should convert UTC to Brazilian time", () => {
+            const converter = new ISO8601TimezoneConverter_1.ISO8601TimezoneConverter();
+            expect(converter
+                .convertTo({
+                time: new ISO8601Time_1.ISO8601Time("12:00:00"),
+                targetTimezone: -180,
+            })
+                .getTimeString({ format: "HH:MM:SS(+|-)HH:MM" })).toEqual("09:00:00-03:00");
+        });
+        it("Should convert Brazilian time to UTC", () => {
+            const converter = new ISO8601TimezoneConverter_1.ISO8601TimezoneConverter();
+            expect(converter
+                .convertTo({
+                time: new ISO8601Time_1.ISO8601Time("09:00:00-03:00"),
+                targetTimezone: 0,
+            })
+                .getTimeString({ format: "HH:MM:SS(+|-)HH:MM" })).toEqual("12:00:00Z");
+        });
+        it("Should convert to positive timezones", () => {
+            const converter = new ISO8601TimezoneConverter_1.ISO8601TimezoneConverter();
+            expect(converter
+                .convertTo({
+                time: new ISO8601Time_1.ISO8601Time("12:00:00"),
+                targetTimezone: 180,
+            })
+                .getTimeString({ format: "HH:MM:SS(+|-)HH:MM" })).toEqual("15:00:00+03:00");
+        });
+        it("Should convert timezones even when days would change", () => {
+            const converter = new ISO8601TimezoneConverter_1.ISO8601TimezoneConverter();
+            expect(converter
+                .convertTo({
+                time: new ISO8601Time_1.ISO8601Time("01:00:00"),
+                targetTimezone: -180,
+            })
+                .getTimeString({ format: "HH:MM:SS(+|-)HH:MM" })).toEqual("22:00:00-03:00");
+        });
+    });
+});

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

@@ -0,0 +1,17 @@
+export interface IISO8601TimezoneParser {
+    /**
+     * Takes a number from -840 to 720 and converts it to a timezone string eg:. `+03:00`, `-02:00`, `Z`,
+     */
+    toString: (timezoneInMinutes: number) => string;
+    /**
+     * Takes a string, eg:. `+03:00`, `-02:00`, `Z` and returns a number representing the quantity of minutes
+     * from UTC.
+     */
+    toMinutes: (timezone: string) => number;
+}
+export declare class ISO8601TimezoneParser implements IISO8601TimezoneParser {
+    private timezoneValidator;
+    private timezoneSelector;
+    toMinutes: (timezone: string) => number;
+    toString: (timezoneInMinutes: number) => string;
+}

package/dist/domain/entities/ISO8601TimezoneParser.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISO8601TimezoneParser = void 0;
+const ISO8601TimezoneSelector_1 = require("./ISO8601TimezoneSelector");
+const ISO8601TimezoneValidator_1 = require("./ISO8601TimezoneValidator");
+class ISO8601TimezoneParser {
+    constructor() {
+        this.timezoneValidator = new ISO8601TimezoneValidator_1.ISO8601TimezoneValidator();
+        this.timezoneSelector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+        this.toMinutes = (timezone) => {
+            if (this.timezoneValidator.timezoneIsZ(timezone) ||
+                this.timezoneValidator.timezoneIsZandMilliseconds(timezone)) {
+                return 0;
+            }
+            if (this.timezoneValidator.timezoneIsNumbered(timezone)) {
+                const minutesString = this.timezoneSelector.getMinutesString(timezone);
+                const hoursString = this.timezoneSelector.getHoursString(timezone);
+                if (minutesString == undefined || hoursString == undefined) {
+                    return 0;
+                }
+                const minutes = parseInt(minutesString);
+                const hours = parseInt(hoursString);
+                const sign = this.timezoneSelector.getTimezoneSign(timezone);
+                return sign == undefined
+                    ? 0
+                    : sign == "+"
+                        ? minutes + hours * 60
+                        : -(minutes + hours * 60);
+            }
+            return 0;
+        };
+        this.toString = (timezoneInMinutes) => {
+            if (this.timezoneValidator.timezoneNumberIsValid(timezoneInMinutes)) {
+                if (timezoneInMinutes == 0)
+                    return "Z";
+                const hours = Math.floor(Math.abs(timezoneInMinutes / 60));
+                const minutes = Math.abs(Math.abs(timezoneInMinutes) - hours * 60);
+                const hoursString = hours.toString().padStart(2, "0");
+                const minutesString = minutes.toString().padStart(2, "0");
+                const symbol = timezoneInMinutes > 0 ? "+" : "-";
+                return `${symbol}${hoursString}:${minutesString}`;
+            }
+            return "Z";
+        };
+    }
+}
+exports.ISO8601TimezoneParser = ISO8601TimezoneParser;

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

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