@beinformed/ui 1.58.3 → 1.59.0

package/esm/utils/datetime/DateTimeUtil.js

@@ -1,30 +1,27 @@
 import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
-import { parse, format, isValid, isAfter, isBefore, isSameDay, addSeconds, addMinutes, addHours, addDays, addWeeks, addMonths, addYears, subSeconds, subMinutes, subHours, subDays, subWeeks, subMonths, subYears, startOfMonth, endOfMonth, startOfWeek, getHours, getMinutes, getDay, getWeek, setMilliseconds, setSeconds, setMinutes, setHours, setMonth, setYear, set } from "date-fns";
-import { nl, enGB } from "date-fns/locale";
+import _startsWithInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/starts-with";
+import _mapInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/map";
+import _Math$trunc from "@babel/runtime-corejs3/core-js-stable/math/trunc";
+import _padStartInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/pad-start";
+import { format, isAfter, isBefore, isSameDay, isValid, parse, add, sub, set, startOfMonth, endOfMonth, startOfWeek, getHours, getMinutes, getDay, getWeek } from "date-fns";
+import { enGB, nl } from "date-fns/locale";
+import { tz } from "@date-fns/tz";
+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 } from "../../constants";
 import { getCookie } from "../browser/Cookies";
-import { getSetting } from "../../constants/Settings";
-import { ISO_DATE_FORMAT, ISO_DATETIME_FORMAT, ISO_TIME_FORMAT, ISO_TIMESTAMP_FORMAT, DEFAULT_WEEK_STARTS_ON, DEFAULT_FIRST_WEEK_CONTAINS_DATE } from "../../constants";
-
 /**
  * @hideconstructor
  */
 class BaseDateTimeUtil {
   constructor(isoFormat) {
     _defineProperty(this, "_isoFormat", void 0);
+    _defineProperty(this, "_timeZone", typeof Intl === "undefined" ? "Etc/UTC" : Intl.DateTimeFormat().resolvedOptions().timeZone || "Etc/UTC");
     this._isoFormat = isoFormat;
   }
 
   /**
+   * Returns the options defined in settings
    */
-  getLocale() {
-    const locale = getCookie("locale") ?? "en";
-    if (locale === "nl") {
-      return nl;
-    }
-    return enGB;
-  }
-
-  // returns the options defined in settings
   getOptions() {
     // indicates on what day the week starts
     const weekStartsOn = getSetting("CALENDAR_WEEK_STARTS_ON", DEFAULT_WEEK_STARTS_ON);
@@ -37,15 +34,45 @@ class BaseDateTimeUtil {
     };
   }
 
+  /**
+   */
+  getIsoFormat() {
+    var _context;
+    if (isIncludeTimeOffsetInDateTimes() && _startsWithInstanceProperty(_context = this._isoFormat).call(_context, ISO_DATETIME_FORMAT)) {
+      return this._isoFormat + DATETIME_OFFSET_FORMAT;
+    }
+    return this._isoFormat;
+  }
+
+  /**
+   */
+  convertFormat(sourceFormat) {
+    return sourceFormat ? sourceFormat : this.getIsoFormat();
+  }
+
+  /**
+   */
+  getLocale() {
+    const locale = getCookie("locale") ?? "en";
+    if (locale === "nl") {
+      return nl;
+    }
+    return enGB;
+  }
+
   /**
    */
   toDate(date) {
-    let inputFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this._isoFormat;
+    let inputFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getIsoFormat();
+    if (date instanceof Date) {
+      return date;
+    }
     const {
       weekStartsOn,
       firstWeekContainsDate
     } = this.getOptions();
     return parse(date, inputFormat, new Date(), {
+      in: this.getDateFnsContext(),
       weekStartsOn,
       firstWeekContainsDate
     });
@@ -53,13 +80,15 @@ class BaseDateTimeUtil {
 
   /**
    */
-  toFormat(date, targetFormat) {
+  toFormat(isoDate, targetFormat) {
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
     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()
       });
@@ -70,17 +99,8 @@ class BaseDateTimeUtil {
   /**
    */
   toISO(date) {
-    let sourceFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this._isoFormat;
-    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";
+    let sourceFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getIsoFormat();
+    return this.toFormat(date, this.getIsoFormat(), sourceFormat);
   }
 
   /**
@@ -89,86 +109,79 @@ class BaseDateTimeUtil {
     return this.toISO(new Date());
   }
 
-  /**
-   */
-  convertFormat(sourceFormat) {
-    return sourceFormat ? sourceFormat : this._isoFormat;
-  }
+  ////////////  VALIDATION
 
   /**
-   * VALIDATION
    */
   hasFormat(date, sourceFormat) {
-    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;
-      }
-      return formattedValue.replace(/0/gu, "").toUpperCase() === date.replace(/0/gu, "").toUpperCase();
+    const formattedValue = this.toFormat(date, sourceFormat, sourceFormat);
+    if (formattedValue === "Invalid Date") {
+      return false;
+    }
+    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) {
-    let inputFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this._isoFormat;
-    return isValid(this.toDate(date, inputFormat));
+    let inputFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getIsoFormat();
+    if (!date) {
+      return false;
+    }
+    const parsedDate = this.toDate(date, inputFormat);
+    return isValid(parsedDate);
   }
 
   /**
    */
   isAfter(inputDate, afterISODate) {
-    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this._isoFormat;
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
     return afterISODate != null && isAfter(this.toDate(inputDate, inputFormat), this.toDate(afterISODate));
   }
 
   /**
    */
   isSameOrAfter(inputDate, afterISODate) {
-    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this._isoFormat;
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
     return afterISODate != null && (this.isAfter(inputDate, afterISODate, inputFormat) || this.isSame(inputDate, afterISODate, inputFormat));
   }
 
   /**
    */
   isBefore(inputDate, beforeISODate) {
-    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this._isoFormat;
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
     return beforeISODate != null && isBefore(this.toDate(inputDate, inputFormat), this.toDate(beforeISODate));
   }
 
   /**
    */
   isSameOrBefore(inputDate, beforeISODate) {
-    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this._isoFormat;
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
     return beforeISODate != null && (this.isBefore(inputDate, beforeISODate, inputFormat) || this.isSame(inputDate, beforeISODate, inputFormat));
   }
 
   /**
    */
   isSame(inputDate, compareDate) {
-    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this._isoFormat;
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
     return compareDate != null && this.toDate(inputDate, inputFormat).getTime() === this.toDate(compareDate).getTime();
   }
 
   /**
    */
   isSameDay(inputDate, compareDate) {
-    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this._isoFormat;
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
     return compareDate != null && isSameDay(this.toDate(inputDate, inputFormat), this.toDate(compareDate, inputFormat));
   }
 
   /**
    */
   isOther(inputDate, compareDate) {
-    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this._isoFormat;
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
     return !this.isSame(inputDate, compareDate, inputFormat);
   }
 
@@ -182,191 +195,376 @@ 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.
+   */
+  isAmbiguous(inputDate) {
+    let inputFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getIsoFormat();
+    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 = _mapInstanceProperty(t).call(t, 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
+   */
+  _calculate(date, calculationFn, property, value) {
+    let inputFormat = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : this.getIsoFormat();
+    const parsedDate = this.toDate(date, inputFormat);
+    return this.toISO(calculationFn(parsedDate, {
+      [property]: value
+    }, {
+      in: this.getDateFnsContext()
+    }));
+  }
+
+  /**
    */
   addSeconds(date, amount) {
-    return this.toISO(addSeconds(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, add, "seconds", amount, inputFormat);
   }
 
   /**
    */
   addMinutes(date, amount) {
-    return this.toISO(addMinutes(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, add, "minutes", amount, inputFormat);
   }
 
   /**
    */
   addHours(date, amount) {
-    return this.toISO(addHours(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, add, "hours", amount, inputFormat);
   }
 
   /**
    */
   addDays(date, amount) {
-    return this.toISO(addDays(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, add, "days", amount, inputFormat);
   }
 
   /**
    */
   addWeeks(date, amount) {
-    return this.toISO(addWeeks(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, add, "weeks", amount, inputFormat);
   }
 
   /**
    */
   addMonths(date, amount) {
-    return this.toISO(addMonths(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, add, "months", amount, inputFormat);
   }
 
   /**
    */
   addYears(date, amount) {
-    return this.toISO(addYears(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, add, "years", amount, inputFormat);
   }
 
   /**
    */
   subtractSeconds(date, amount) {
-    return this.toISO(subSeconds(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, sub, "seconds", amount, inputFormat);
   }
 
   /**
    */
   subtractMinutes(date, amount) {
-    return this.toISO(subMinutes(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, sub, "minutes", amount, inputFormat);
   }
 
   /**
    */
   subtractHours(date, amount) {
-    return this.toISO(subHours(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, sub, "hours", amount, inputFormat);
   }
 
   /**
    */
   subtractDays(date, amount) {
-    return this.toISO(subDays(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, sub, "days", amount, inputFormat);
   }
 
   /**
    */
   subtractWeeks(date, amount) {
-    return this.toISO(subWeeks(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, sub, "weeks", amount, inputFormat);
   }
 
   /**
    */
   subtractMonths(date, amount) {
-    return this.toISO(subMonths(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, sub, "months", amount, inputFormat);
   }
 
   /**
    */
   subtractYears(date, amount) {
-    return this.toISO(subYears(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, sub, "years", amount, inputFormat);
+  }
+
+  ////////////  GETTERS
+
+  /**
+   * @private
+   */
+  _get(date, method) {
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    const parsedDate = this.toDate(date, inputFormat);
+    return this.toISO(method(parsedDate, {
+      in: this.getDateFnsContext(),
+      ...options
+    }));
   }
 
   /**
-   * GETTERS
    */
   startOfMonth(date) {
-    let inputFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this._isoFormat;
-    return this.toISO(startOfMonth(this.toDate(date, inputFormat)));
+    let inputFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getIsoFormat();
+    return this._get(date, startOfMonth, inputFormat);
   }
 
   /**
    */
   endOfMonth(date) {
-    let inputFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this._isoFormat;
-    return this.toISO(endOfMonth(this.toDate(date, inputFormat)));
+    let inputFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getIsoFormat();
+    return this._get(date, endOfMonth, inputFormat);
   }
 
   /**
    */
   startOfWeek(date) {
-    let inputFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this._isoFormat;
+    let inputFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getIsoFormat();
     const {
       weekStartsOn
     } = this.getOptions();
-    return this.toISO(startOfWeek(this.toDate(date, inputFormat), {
+    return this._get(date, startOfWeek, inputFormat, {
       weekStartsOn
-    }));
+    });
   }
 
   /**
    */
   getHours(date) {
-    const parsedDate = typeof date === "string" ? this.toDate(date) : date;
-    return getHours(parsedDate);
+    let inputFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getIsoFormat();
+    const parsedDate = this.toDate(date, inputFormat);
+    return getHours(parsedDate, {
+      in: this.getDateFnsContext()
+    });
   }
 
   /**
    */
   getMinutes(date) {
-    const parsedDate = typeof date === "string" ? this.toDate(date) : date;
-    return getMinutes(parsedDate);
+    let inputFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getIsoFormat();
+    const parsedDate = this.toDate(date, inputFormat);
+    return getMinutes(parsedDate, {
+      in: this.getDateFnsContext()
+    });
   }
 
   /**
    */
   getWeek(date) {
+    let inputFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getIsoFormat();
     const {
       weekStartsOn,
       firstWeekContainsDate
     } = this.getOptions();
-    return getWeek(this.toDate(date), {
+    const parsedDate = this.toDate(date, inputFormat);
+    return getWeek(parsedDate, {
+      in: this.getDateFnsContext(),
       weekStartsOn,
       firstWeekContainsDate
     });
   }
 
+  //////////// SETTERS
+
+  /**
+   * @private
+   */
+  _set(date, property, value) {
+    let inputFormat = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : this.getIsoFormat();
+    const parsedDate = this.toDate(date, inputFormat);
+    return this.toISO(set(parsedDate, {
+      [property]: value
+    }
+    // {
+    //   in: this.getDateFnsContext(),
+    // },
+    ));
+  }
+
   /**
-   * SETTERS
    */
   setYear(date, year) {
-    return this.toISO(setYear(this.toDate(date), year));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._set(date, "year", year, inputFormat);
   }
 
   /**
    */
   setMonth(date, month) {
-    return this.toISO(setMonth(this.toDate(date), month));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._set(date, "month", month, inputFormat);
+  }
+
+  /**
+   */
+  setDay(date, day) {
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._set(date, "date", day, inputFormat);
   }
 
   /**
    */
   setHour(date, hour) {
-    return this.toISO(setHours(this.toDate(date), hour));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._set(date, "hours", hour, inputFormat);
   }
 
   /**
    */
   setMinute(date, minute) {
-    return this.toISO(setMinutes(this.toDate(date), minute));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._set(date, "minutes", minute, inputFormat);
   }
 
   /**
    */
   setSecond(date, second) {
-    return this.toISO(setSeconds(this.toDate(date), second));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._set(date, "seconds", second, inputFormat);
   }
 
   /**
    */
-  setMilliseconds(date, milliseconds) {
-    return this.toISO(setMilliseconds(this.toDate(date), milliseconds));
+  setMilliseconds(date, millisecond) {
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._set(date, "milliseconds", millisecond, inputFormat);
   }
 
   /**
    */
   setTime(date, hours, minutes, seconds, milliseconds) {
-    return this.toISO(set(this.toDate(date), {
+    let inputFormat = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : this.getIsoFormat();
+    const parsedDate = this.toDate(date, inputFormat);
+    return this.toISO(set(parsedDate, {
       hours,
       minutes,
       seconds,
       milliseconds
+    }, {
+      in: this.getDateFnsContext()
     }));
   }
+
+  //////////// Timezone related
+
+  /**
+   */
+  getTimeZone() {
+    return this._timeZone;
+  }
+
+  /**
+   */
+  setTimeZone(timeZone) {
+    this._timeZone = timeZone;
+  }
+
+  /**
+   */
+  getDateFnsContext() {
+    if (IS_GRAALJS) {
+      return null; // tz method does not work in graal (yet)
+    }
+    return tz(this.getTimeZone());
+  }
+
+  //////////// Offsets
+
+  /**
+   */
+  getOffset(date) {
+    let inputFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getIsoFormat();
+    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() {
+    const createOffsetObject = info => {
+      var _context2, _context3;
+      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}${_padStartInstanceProperty(_context2 = String(hours + (minutes === 60 ? 1 : 0))).call(_context2, 2, "0")}:${_padStartInstanceProperty(_context3 = String(minutes % 60)).call(_context3, 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)
+    };
+  }
 }
 
 /**