@beinformed/ui 1.58.3 → 1.59.0

package/lib/utils/datetime/DateTimeUtil.js.flow

@@ -1,25 +1,14 @@
 // @flow
 import {
-  parse,
   format,
-  isValid,
   isAfter,
   isBefore,
   isSameDay,
-  addSeconds,
-  addMinutes,
-  addHours,
-  addDays,
-  addWeeks,
-  addMonths,
-  addYears,
-  subSeconds,
-  subMinutes,
-  subHours,
-  subDays,
-  subWeeks,
-  subMonths,
-  subYears,
+  isValid,
+  parse,
+  add,
+  sub,
+  set,
   startOfMonth,
   endOfMonth,
   startOfWeek,
@@ -27,52 +16,56 @@ import {
   getMinutes,
   getDay,
   getWeek,
-  setMilliseconds,
-  setSeconds,
-  setMinutes,
-  setHours,
-  setMonth,
-  setYear,
-  set,
 } from "date-fns";
-import { nl, enGB } from "date-fns/locale";
+import { enGB, nl } from "date-fns/locale";
+import { tz } from "@date-fns/tz";
 
-import { getCookie } from "../browser/Cookies";
-
-import { getSetting } from "../../constants/Settings";
+import soft from "timezone-soft";
 
 import {
+  DATETIME_OFFSET_FORMAT,
+  DEFAULT_FIRST_WEEK_CONTAINS_DATE,
+  DEFAULT_WEEK_STARTS_ON,
+  getSetting,
+  IS_GRAALJS,
+  isIncludeTimeOffsetInDateTimes,
   ISO_DATE_FORMAT,
   ISO_DATETIME_FORMAT,
   ISO_TIME_FORMAT,
   ISO_TIMESTAMP_FORMAT,
-  DEFAULT_WEEK_STARTS_ON,
-  DEFAULT_FIRST_WEEK_CONTAINS_DATE,
 } from "../../constants";
 
+import { getCookie } from "../browser/Cookies";
+
+type OffsetInfoInput = {
+  abbr: string,
+  offset: number,
+  name: string,
+};
+
+export type OffsetInfo = {
+  abbr: string,
+  label: string,
+  value: string,
+};
+
 /**
  * @hideconstructor
  */
 class BaseDateTimeUtil {
   _isoFormat: string;
+  _timeZone: string =
+    typeof Intl === "undefined"
+      ? "Etc/UTC"
+      : Intl.DateTimeFormat().resolvedOptions().timeZone || "Etc/UTC";
 
   constructor(isoFormat: string) {
     this._isoFormat = isoFormat;
   }
 
   /**
+   * Returns the options defined in settings
    */
-  getLocale(): typeof nl | typeof enGB {
-    const locale = getCookie("locale") ?? "en";
-
-    if (locale === "nl") {
-      return nl;
-    }
-
-    return enGB;
-  }
-
-  // returns the options defined in settings
   getOptions(): {
     weekStartsOn: 0 | 1 | 2 | 3 | 4 | 5 | 6,
     firstWeekContainsDate: 1 | 2 | 3 | 4 | 5 | 6 | 7,
@@ -94,10 +87,45 @@ class BaseDateTimeUtil {
 
   /**
    */
-  toDate(date: string, inputFormat: string = this._isoFormat): Date {
+  getIsoFormat(): string {
+    if (
+      isIncludeTimeOffsetInDateTimes() &&
+      this._isoFormat.startsWith(ISO_DATETIME_FORMAT)
+    ) {
+      return this._isoFormat + DATETIME_OFFSET_FORMAT;
+    }
+    return this._isoFormat;
+  }
+
+  /**
+   */
+  convertFormat(sourceFormat: string): string {
+    return sourceFormat ? sourceFormat : this.getIsoFormat();
+  }
+
+  /**
+   */
+  getLocale(): typeof nl | typeof enGB {
+    const locale = getCookie("locale") ?? "en";
+
+    if (locale === "nl") {
+      return nl;
+    }
+
+    return enGB;
+  }
+
+  /**
+   */
+  toDate(date: string | Date, inputFormat: string = this.getIsoFormat()): Date {
+    if (date instanceof Date) {
+      return date;
+    }
+
     const { weekStartsOn, firstWeekContainsDate } = this.getOptions();
 
     return parse(date, inputFormat, new Date(), {
+      in: this.getDateFnsContext(),
       weekStartsOn,
       firstWeekContainsDate,
     });
@@ -105,13 +133,18 @@ class BaseDateTimeUtil {
 
   /**
    */
-  toFormat(date: string | Date, targetFormat: string): string {
+  toFormat(
+    isoDate: string | Date,
+    targetFormat: string,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
     const { weekStartsOn } = this.getOptions();
 
-    const parsedDate = typeof date === "string" ? this.toDate(date) : date;
+    const parsedDate = this.toDate(isoDate, inputFormat);
 
     if (isValid(parsedDate)) {
       return format(parsedDate, targetFormat, {
+        in: this.getDateFnsContext(),
         weekStartsOn,
         locale: this.getLocale(),
       });
@@ -122,19 +155,11 @@ class BaseDateTimeUtil {
 
   /**
    */
-  toISO(date: string | Date, sourceFormat: string = this._isoFormat): string {
-    const { weekStartsOn } = this.getOptions();
-
-    const parsedDate =
-      typeof date === "string" ? this.toDate(date, sourceFormat) : date;
-
-    if (isValid(parsedDate)) {
-      return format(parsedDate, this._isoFormat, {
-        weekStartsOn,
-      });
-    }
-
-    return "Invalid Date";
+  toISO(
+    date: string | Date,
+    sourceFormat: string = this.getIsoFormat(),
+  ): string {
+    return this.toFormat(date, this.getIsoFormat(), sourceFormat);
   }
 
   /**
@@ -143,52 +168,49 @@ class BaseDateTimeUtil {
     return this.toISO(new Date());
   }
 
-  /**
-   */
-  convertFormat(sourceFormat: string): string {
-    return sourceFormat ? sourceFormat : this._isoFormat;
-  }
+  ////////////  VALIDATION
 
   /**
-   * VALIDATION
    */
   hasFormat(date: string, sourceFormat: string): boolean {
-    const { weekStartsOn } = this.getOptions();
-
-    const realDate = this.toDate(date, sourceFormat);
-    if (isValid(realDate)) {
-      const formattedValue = format(realDate, sourceFormat, {
-        weekStartsOn,
-      });
-
-      const isOutsideRange =
-        isBefore(realDate, new Date(1000, 1, 1)) ||
-        isAfter(realDate, new Date(9999, 11, 31));
-      if (isOutsideRange) {
-        return false;
-      }
+    const formattedValue = this.toFormat(date, sourceFormat, sourceFormat);
+    if (formattedValue === "Invalid Date") {
+      return false;
+    }
 
-      return (
-        formattedValue.replace(/0/gu, "").toUpperCase() ===
-        date.replace(/0/gu, "").toUpperCase()
-      );
+    const isOutsideRange =
+      isBefore(formattedValue, new Date(1000, 1, 1)) ||
+      isAfter(formattedValue, new Date(9999, 11, 31));
+    if (isOutsideRange) {
+      return false;
     }
 
-    return false;
+    return (
+      formattedValue.replace(/0/gu, "").toUpperCase() ===
+      date.replace(/0/gu, "").toUpperCase()
+    );
   }
 
   /**
    */
-  isValid(date: string, inputFormat: string = this._isoFormat): boolean {
-    return isValid(this.toDate(date, inputFormat));
+  isValid(
+    date: string | Date | null | void,
+    inputFormat: string = this.getIsoFormat(),
+  ): boolean {
+    if (!date) {
+      return false;
+    }
+
+    const parsedDate = this.toDate(date, inputFormat);
+    return isValid(parsedDate);
   }
 
   /**
    */
   isAfter(
-    inputDate: string,
-    afterISODate: ?string,
-    inputFormat: string = this._isoFormat,
+    inputDate: string | Date,
+    afterISODate: ?string | Date,
+    inputFormat: string = this.getIsoFormat(),
   ): boolean {
     return (
       afterISODate != null &&
@@ -199,9 +221,9 @@ class BaseDateTimeUtil {
   /**
    */
   isSameOrAfter(
-    inputDate: string,
-    afterISODate: ?string,
-    inputFormat: string = this._isoFormat,
+    inputDate: string | Date,
+    afterISODate: ?string | Date,
+    inputFormat: string = this.getIsoFormat(),
   ): boolean {
     return (
       afterISODate != null &&
@@ -213,9 +235,9 @@ class BaseDateTimeUtil {
   /**
    */
   isBefore(
-    inputDate: string,
-    beforeISODate: ?string,
-    inputFormat: string = this._isoFormat,
+    inputDate: string | Date,
+    beforeISODate: ?string | Date,
+    inputFormat: string = this.getIsoFormat(),
   ): boolean {
     return (
       beforeISODate != null &&
@@ -226,9 +248,9 @@ class BaseDateTimeUtil {
   /**
    */
   isSameOrBefore(
-    inputDate: string,
-    beforeISODate: ?string,
-    inputFormat: string = this._isoFormat,
+    inputDate: string | Date,
+    beforeISODate: ?string | Date,
+    inputFormat: string = this.getIsoFormat(),
   ): boolean {
     return (
       beforeISODate != null &&
@@ -240,9 +262,9 @@ class BaseDateTimeUtil {
   /**
    */
   isSame(
-    inputDate: string,
-    compareDate: ?string,
-    inputFormat: string = this._isoFormat,
+    inputDate: string | Date,
+    compareDate: ?string | Date,
+    inputFormat: string = this.getIsoFormat(),
   ): boolean {
     return (
       compareDate != null &&
@@ -254,9 +276,9 @@ class BaseDateTimeUtil {
   /**
    */
   isSameDay(
-    inputDate: string,
-    compareDate: string,
-    inputFormat: string = this._isoFormat,
+    inputDate: string | Date,
+    compareDate: string | Date,
+    inputFormat: string = this.getIsoFormat(),
   ): boolean {
     return (
       compareDate != null &&
@@ -270,16 +292,16 @@ class BaseDateTimeUtil {
   /**
    */
   isOther(
-    inputDate: string,
-    compareDate: ?string,
-    inputFormat: string = this._isoFormat,
+    inputDate: string | Date,
+    compareDate: ?string | Date,
+    inputFormat: string = this.getIsoFormat(),
   ): boolean {
     return !this.isSame(inputDate, compareDate, inputFormat);
   }
 
   /**
    */
-  isWeekend(inputDate: string): boolean {
+  isWeekend(inputDate: string | Date): boolean {
     const SATURDAY_NUMBER = 6;
     const SUNDAY_NUMBER = 0;
     const weekDay = getDay(this.toDate(inputDate));
@@ -288,175 +310,371 @@ class BaseDateTimeUtil {
   }
 
   /**
-   * CALCULATIONS
+   * Checks if a given local date and time is ambiguous in the specified timezone.
+   * Ambiguity happens during the end of daylight saving time (DST) transitions.
    */
-  addSeconds(date: string, amount: number): string {
-    return this.toISO(addSeconds(this.toDate(date), amount));
+  isAmbiguous(
+    inputDate: string | Date,
+    inputFormat: string = this.getIsoFormat(),
+  ): boolean {
+    if (inputDate == null || typeof Intl === "undefined") {
+      return false;
+    }
+
+    const dateTime = this.toDate(inputDate, inputFormat);
+    if (!isValid(dateTime)) {
+      return false;
+    }
+
+    const t = [60, -60, 30, -30];
+    const a = t.map((x) => {
+      const newDate = add(dateTime, { minutes: x });
+      return format(newDate, "HH:mm");
+    });
+    const time = format(dateTime, "HH:mm");
+    return a.indexOf(time) > -1;
   }
 
+  ////////////  CALCULATIONS
+
   /**
+   * @private
    */
-  addMinutes(date: string, amount: number): string {
-    return this.toISO(addMinutes(this.toDate(date), amount));
+  _calculate(
+    date: string | Date,
+    calculationFn: Function,
+    property: string,
+    value: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    const parsedDate = this.toDate(date, inputFormat);
+    return this.toISO(
+      calculationFn(
+        parsedDate,
+        { [property]: value },
+        {
+          in: this.getDateFnsContext(),
+        },
+      ),
+    );
   }
 
   /**
    */
-  addHours(date: string, amount: number): string {
-    return this.toISO(addHours(this.toDate(date), amount));
+  addSeconds(
+    date: string,
+    amount: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._calculate(date, add, "seconds", amount, inputFormat);
   }
 
   /**
    */
-  addDays(date: string, amount: number): string {
-    return this.toISO(addDays(this.toDate(date), amount));
+  addMinutes(
+    date: string,
+    amount: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._calculate(date, add, "minutes", amount, inputFormat);
   }
 
   /**
    */
-  addWeeks(date: string, amount: number): string {
-    return this.toISO(addWeeks(this.toDate(date), amount));
+  addHours(
+    date: string,
+    amount: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._calculate(date, add, "hours", amount, inputFormat);
   }
 
   /**
    */
-  addMonths(date: string, amount: number): string {
-    return this.toISO(addMonths(this.toDate(date), amount));
+  addDays(
+    date: string,
+    amount: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._calculate(date, add, "days", amount, inputFormat);
   }
 
   /**
    */
-  addYears(date: string, amount: number): string {
-    return this.toISO(addYears(this.toDate(date), amount));
+  addWeeks(
+    date: string,
+    amount: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._calculate(date, add, "weeks", amount, inputFormat);
   }
 
   /**
    */
-  subtractSeconds(date: string, amount: number): string {
-    return this.toISO(subSeconds(this.toDate(date), amount));
+  addMonths(
+    date: string,
+    amount: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._calculate(date, add, "months", amount, inputFormat);
   }
 
   /**
    */
-  subtractMinutes(date: string, amount: number): string {
-    return this.toISO(subMinutes(this.toDate(date), amount));
+  addYears(
+    date: string,
+    amount: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._calculate(date, add, "years", amount, inputFormat);
   }
 
   /**
    */
-  subtractHours(date: string, amount: number): string {
-    return this.toISO(subHours(this.toDate(date), amount));
+  subtractSeconds(
+    date: string,
+    amount: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._calculate(date, sub, "seconds", amount, inputFormat);
   }
 
   /**
    */
-  subtractDays(date: string, amount: number): string {
-    return this.toISO(subDays(this.toDate(date), amount));
+  subtractMinutes(
+    date: string,
+    amount: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._calculate(date, sub, "minutes", amount, inputFormat);
   }
 
   /**
    */
-  subtractWeeks(date: string, amount: number): string {
-    return this.toISO(subWeeks(this.toDate(date), amount));
+  subtractHours(
+    date: string,
+    amount: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._calculate(date, sub, "hours", amount, inputFormat);
   }
 
   /**
    */
-  subtractMonths(date: string, amount: number): string {
-    return this.toISO(subMonths(this.toDate(date), amount));
+  subtractDays(
+    date: string,
+    amount: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._calculate(date, sub, "days", amount, inputFormat);
   }
 
   /**
    */
-  subtractYears(date: string, amount: number): string {
-    return this.toISO(subYears(this.toDate(date), amount));
+  subtractWeeks(
+    date: string,
+    amount: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._calculate(date, sub, "weeks", amount, inputFormat);
   }
 
   /**
-   * GETTERS
    */
-  startOfMonth(date: string, inputFormat: string = this._isoFormat): string {
-    return this.toISO(startOfMonth(this.toDate(date, inputFormat)));
+  subtractMonths(
+    date: string,
+    amount: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._calculate(date, sub, "months", amount, inputFormat);
   }
 
   /**
    */
-  endOfMonth(date: string, inputFormat: string = this._isoFormat): string {
-    return this.toISO(endOfMonth(this.toDate(date, inputFormat)));
+  subtractYears(
+    date: string,
+    amount: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._calculate(date, sub, "years", amount, inputFormat);
   }
 
+  ////////////  GETTERS
+
   /**
+   * @private
    */
-  startOfWeek(date: string, inputFormat: string = this._isoFormat): string {
-    const { weekStartsOn } = this.getOptions();
-
+  _get(
+    date: string | Date,
+    method: Function,
+    inputFormat: string = this.getIsoFormat(),
+    options: Object = {},
+  ): string {
+    const parsedDate = this.toDate(date, inputFormat);
     return this.toISO(
-      startOfWeek(this.toDate(date, inputFormat), {
-        weekStartsOn,
+      method(parsedDate, {
+        in: this.getDateFnsContext(),
+        ...options,
       }),
     );
   }
 
   /**
    */
-  getHours(date: string | Date): number {
-    const parsedDate = typeof date === "string" ? this.toDate(date) : date;
-    return getHours(parsedDate);
+  startOfMonth(
+    date: string | Date,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._get(date, startOfMonth, inputFormat);
   }
 
   /**
    */
-  getMinutes(date: string | Date): number {
-    const parsedDate = typeof date === "string" ? this.toDate(date) : date;
-    return getMinutes(parsedDate);
+  endOfMonth(
+    date: string | Date,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._get(date, endOfMonth, inputFormat);
   }
 
   /**
    */
-  getWeek(date: string): number {
-    const { weekStartsOn, firstWeekContainsDate } = this.getOptions();
+  startOfWeek(
+    date: string | Date,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    const { weekStartsOn } = this.getOptions();
+    return this._get(date, startOfWeek, inputFormat, {
+      weekStartsOn,
+    });
+  }
+
+  /**
+   */
+  getHours(
+    date: string | Date,
+    inputFormat: string = this.getIsoFormat(),
+  ): number {
+    const parsedDate = this.toDate(date, inputFormat);
+    return getHours(parsedDate, { in: this.getDateFnsContext() });
+  }
+
+  /**
+   */
+  getMinutes(
+    date: string | Date,
+    inputFormat: string = this.getIsoFormat(),
+  ): number {
+    const parsedDate = this.toDate(date, inputFormat);
+    return getMinutes(parsedDate, { in: this.getDateFnsContext() });
+  }
 
-    return getWeek(this.toDate(date), {
+  /**
+   */
+  getWeek(
+    date: string | Date,
+    inputFormat: string = this.getIsoFormat(),
+  ): number {
+    const { weekStartsOn, firstWeekContainsDate } = this.getOptions();
+    const parsedDate = this.toDate(date, inputFormat);
+    return getWeek(parsedDate, {
+      in: this.getDateFnsContext(),
       weekStartsOn,
       firstWeekContainsDate,
     });
   }
 
+  //////////// SETTERS
+
   /**
-   * SETTERS
+   * @private
    */
-  setYear(date: string, year: number): string {
-    return this.toISO(setYear(this.toDate(date), year));
+  _set(
+    date: string | Date,
+    property: string,
+    value: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    const parsedDate = this.toDate(date, inputFormat);
+    return this.toISO(
+      set(
+        parsedDate,
+        { [property]: value },
+        // {
+        //   in: this.getDateFnsContext(),
+        // },
+      ),
+    );
   }
 
   /**
    */
-  setMonth(date: string, month: number): string {
-    return this.toISO(setMonth(this.toDate(date), month));
+  setYear(
+    date: string | Date,
+    year: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._set(date, "year", year, inputFormat);
   }
 
   /**
    */
-  setHour(date: string, hour: number): string {
-    return this.toISO(setHours(this.toDate(date), hour));
+  setMonth(
+    date: string | Date,
+    month: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._set(date, "month", month, inputFormat);
   }
 
   /**
    */
-  setMinute(date: string, minute: number): string {
-    return this.toISO(setMinutes(this.toDate(date), minute));
+  setDay(
+    date: string | Date,
+    day: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._set(date, "date", day, inputFormat);
   }
 
   /**
    */
-  setSecond(date: string, second: number): string {
-    return this.toISO(setSeconds(this.toDate(date), second));
+  setHour(
+    date: string | Date,
+    hour: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._set(date, "hours", hour, inputFormat);
   }
 
   /**
    */
-  setMilliseconds(date: string, milliseconds: number): string {
-    return this.toISO(setMilliseconds(this.toDate(date), milliseconds));
+  setMinute(
+    date: string | Date,
+    minute: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._set(date, "minutes", minute, inputFormat);
+  }
+
+  /**
+   */
+  setSecond(
+    date: string | Date,
+    second: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._set(date, "seconds", second, inputFormat);
+  }
+
+  /**
+   */
+  setMilliseconds(
+    date: string | Date,
+    millisecond: number,
+    inputFormat: string = this.getIsoFormat(),
+  ): string {
+    return this._set(date, "milliseconds", millisecond, inputFormat);
   }
 
   /**
@@ -467,16 +685,108 @@ class BaseDateTimeUtil {
     minutes: number,
     seconds: number,
     milliseconds: number,
+    inputFormat: string = this.getIsoFormat(),
   ): string {
+    const parsedDate = this.toDate(date, inputFormat);
     return this.toISO(
-      set(this.toDate(date), {
-        hours,
-        minutes,
-        seconds,
-        milliseconds,
-      }),
+      set(
+        parsedDate,
+        { hours, minutes, seconds, milliseconds },
+        {
+          in: this.getDateFnsContext(),
+        },
+      ),
     );
   }
+
+  //////////// Timezone related
+
+  /**
+   */
+  getTimeZone(): string {
+    return this._timeZone;
+  }
+
+  /**
+   */
+  setTimeZone(timeZone: string) {
+    this._timeZone = timeZone;
+  }
+
+  /**
+   */
+  getDateFnsContext(): null | Function {
+    if (IS_GRAALJS) {
+      return null; // tz method does not work in graal (yet)
+    }
+    return tz(this.getTimeZone());
+  }
+
+  //////////// Offsets
+
+  /**
+   */
+  getOffset(
+    date: string | Date,
+    inputFormat: string = this.getIsoFormat(),
+  ): OffsetInfo | null {
+    const parsedDate = this.toDate(date, inputFormat);
+    if (isValid(parsedDate)) {
+      const dateOffset = this.toFormat(parsedDate, DATETIME_OFFSET_FORMAT);
+      const offsets = this.getTimezoneOffsets();
+      if (
+        typeof offsets.daylight !== "undefined" &&
+        offsets.daylight.value === dateOffset
+      ) {
+        return offsets.daylight;
+      } else if (
+        typeof offsets.standard !== "undefined" &&
+        offsets.standard.value === dateOffset
+      ) {
+        return offsets.standard;
+      }
+    }
+    return null;
+  }
+
+  /**
+   */
+  getTimezoneOffsets(): {
+    standard?: OffsetInfo,
+    daylight?: OffsetInfo,
+  } {
+    const createOffsetObject = (info: OffsetInfoInput): OffsetInfo => {
+      const sign = info.offset < 0 ? "-" : "+";
+      const absOffset = Math.abs(info.offset);
+      const hours = Math.trunc(absOffset);
+      const minutes = Math.round((absOffset % 1) * 60);
+
+      const offsetString = `${sign}${String(hours + (minutes === 60 ? 1 : 0)).padStart(2, "0")}:${String(minutes % 60).padStart(2, "0")}`;
+
+      return {
+        label: info.name,
+        abbr: info.abbr,
+        value: offsetString,
+      };
+    };
+
+    const timezone = soft(this.getTimeZone());
+
+    if (timezone.length === 0) {
+      return {};
+    }
+
+    const { daylight, standard } = timezone[0];
+
+    if (daylight) {
+      return {
+        daylight: createOffsetObject(daylight),
+        standard: createOffsetObject(standard),
+      };
+    }
+
+    return { standard: createOffsetObject(standard) };
+  }
 }
 
 /**