@beinformed/ui 1.58.3 → 1.59.0

package/lib/utils/datetime/DateTimeUtil.js

@@ -5,53 +5,81 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.TimestampUtil = exports.TimeUtil = exports.DateUtil = exports.DateTimeUtil = void 0;
+var _startsWith = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/starts-with"));
+var _map = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/map"));
+var _trunc = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/math/trunc"));
+var _padStart = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/pad-start"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/defineProperty"));
 var _dateFns = require("date-fns");
 var _locale = require("date-fns/locale");
-var _Cookies = require("../browser/Cookies");
-var _Settings = require("../../constants/Settings");
+var _tz = require("@date-fns/tz");
+var _timezoneSoft = _interopRequireDefault(require("timezone-soft"));
 var _constants = require("../../constants");
+var _Cookies = require("../browser/Cookies");
 /**
  * @hideconstructor
  */
 class BaseDateTimeUtil {
   constructor(isoFormat) {
     (0, _defineProperty2.default)(this, "_isoFormat", void 0);
+    (0, _defineProperty2.default)(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 = (0, _Cookies.getCookie)("locale") ?? "en";
-    if (locale === "nl") {
-      return _locale.nl;
-    }
-    return _locale.enGB;
-  }
-
-  // returns the options defined in settings
   getOptions() {
     // indicates on what day the week starts
-    const weekStartsOn = (0, _Settings.getSetting)("CALENDAR_WEEK_STARTS_ON", _constants.DEFAULT_WEEK_STARTS_ON);
+    const weekStartsOn = (0, _constants.getSetting)("CALENDAR_WEEK_STARTS_ON", _constants.DEFAULT_WEEK_STARTS_ON);
 
     // indicates which date indicates the first week of the year
-    const firstWeekContainsDate = (0, _Settings.getSetting)("CALENDAR_FIRST_WEEK_CONTAINS_DATE", _constants.DEFAULT_FIRST_WEEK_CONTAINS_DATE);
+    const firstWeekContainsDate = (0, _constants.getSetting)("CALENDAR_FIRST_WEEK_CONTAINS_DATE", _constants.DEFAULT_FIRST_WEEK_CONTAINS_DATE);
     return {
       weekStartsOn,
       firstWeekContainsDate
     };
   }
 
+  /**
+   */
+  getIsoFormat() {
+    var _context;
+    if ((0, _constants.isIncludeTimeOffsetInDateTimes)() && (0, _startsWith.default)(_context = this._isoFormat).call(_context, _constants.ISO_DATETIME_FORMAT)) {
+      return this._isoFormat + _constants.DATETIME_OFFSET_FORMAT;
+    }
+    return this._isoFormat;
+  }
+
+  /**
+   */
+  convertFormat(sourceFormat) {
+    return sourceFormat ? sourceFormat : this.getIsoFormat();
+  }
+
+  /**
+   */
+  getLocale() {
+    const locale = (0, _Cookies.getCookie)("locale") ?? "en";
+    if (locale === "nl") {
+      return _locale.nl;
+    }
+    return _locale.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 (0, _dateFns.parse)(date, inputFormat, new Date(), {
+      in: this.getDateFnsContext(),
       weekStartsOn,
       firstWeekContainsDate
     });
@@ -59,13 +87,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 ((0, _dateFns.isValid)(parsedDate)) {
       return (0, _dateFns.format)(parsedDate, targetFormat, {
+        in: this.getDateFnsContext(),
         weekStartsOn,
         locale: this.getLocale()
       });
@@ -76,17 +106,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 ((0, _dateFns.isValid)(parsedDate)) {
-      return (0, _dateFns.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);
   }
 
   /**
@@ -95,86 +116,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 ((0, _dateFns.isValid)(realDate)) {
-      const formattedValue = (0, _dateFns.format)(realDate, sourceFormat, {
-        weekStartsOn
-      });
-      const isOutsideRange = (0, _dateFns.isBefore)(realDate, new Date(1000, 1, 1)) || (0, _dateFns.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 = (0, _dateFns.isBefore)(formattedValue, new Date(1000, 1, 1)) || (0, _dateFns.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 (0, _dateFns.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 (0, _dateFns.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 && (0, _dateFns.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 && (0, _dateFns.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 && (0, _dateFns.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);
   }
 
@@ -188,191 +202,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 (!(0, _dateFns.isValid)(dateTime)) {
+      return false;
+    }
+    const t = [60, -60, 30, -30];
+    const a = (0, _map.default)(t).call(t, x => {
+      const newDate = (0, _dateFns.add)(dateTime, {
+        minutes: x
+      });
+      return (0, _dateFns.format)(newDate, "HH:mm");
+    });
+    const time = (0, _dateFns.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((0, _dateFns.addSeconds)(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, _dateFns.add, "seconds", amount, inputFormat);
   }
 
   /**
    */
   addMinutes(date, amount) {
-    return this.toISO((0, _dateFns.addMinutes)(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, _dateFns.add, "minutes", amount, inputFormat);
   }
 
   /**
    */
   addHours(date, amount) {
-    return this.toISO((0, _dateFns.addHours)(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, _dateFns.add, "hours", amount, inputFormat);
   }
 
   /**
    */
   addDays(date, amount) {
-    return this.toISO((0, _dateFns.addDays)(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, _dateFns.add, "days", amount, inputFormat);
   }
 
   /**
    */
   addWeeks(date, amount) {
-    return this.toISO((0, _dateFns.addWeeks)(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, _dateFns.add, "weeks", amount, inputFormat);
   }
 
   /**
    */
   addMonths(date, amount) {
-    return this.toISO((0, _dateFns.addMonths)(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, _dateFns.add, "months", amount, inputFormat);
   }
 
   /**
    */
   addYears(date, amount) {
-    return this.toISO((0, _dateFns.addYears)(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, _dateFns.add, "years", amount, inputFormat);
   }
 
   /**
    */
   subtractSeconds(date, amount) {
-    return this.toISO((0, _dateFns.subSeconds)(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, _dateFns.sub, "seconds", amount, inputFormat);
   }
 
   /**
    */
   subtractMinutes(date, amount) {
-    return this.toISO((0, _dateFns.subMinutes)(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, _dateFns.sub, "minutes", amount, inputFormat);
   }
 
   /**
    */
   subtractHours(date, amount) {
-    return this.toISO((0, _dateFns.subHours)(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, _dateFns.sub, "hours", amount, inputFormat);
   }
 
   /**
    */
   subtractDays(date, amount) {
-    return this.toISO((0, _dateFns.subDays)(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, _dateFns.sub, "days", amount, inputFormat);
   }
 
   /**
    */
   subtractWeeks(date, amount) {
-    return this.toISO((0, _dateFns.subWeeks)(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, _dateFns.sub, "weeks", amount, inputFormat);
   }
 
   /**
    */
   subtractMonths(date, amount) {
-    return this.toISO((0, _dateFns.subMonths)(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, _dateFns.sub, "months", amount, inputFormat);
   }
 
   /**
    */
   subtractYears(date, amount) {
-    return this.toISO((0, _dateFns.subYears)(this.toDate(date), amount));
+    let inputFormat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getIsoFormat();
+    return this._calculate(date, _dateFns.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((0, _dateFns.startOfMonth)(this.toDate(date, inputFormat)));
+    let inputFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getIsoFormat();
+    return this._get(date, _dateFns.startOfMonth, inputFormat);
   }
 
   /**
    */
   endOfMonth(date) {
-    let inputFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this._isoFormat;
-    return this.toISO((0, _dateFns.endOfMonth)(this.toDate(date, inputFormat)));
+    let inputFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getIsoFormat();
+    return this._get(date, _dateFns.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((0, _dateFns.startOfWeek)(this.toDate(date, inputFormat), {
+    return this._get(date, _dateFns.startOfWeek, inputFormat, {
       weekStartsOn
-    }));
+    });
   }
 
   /**
    */
   getHours(date) {
-    const parsedDate = typeof date === "string" ? this.toDate(date) : date;
-    return (0, _dateFns.getHours)(parsedDate);
+    let inputFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getIsoFormat();
+    const parsedDate = this.toDate(date, inputFormat);
+    return (0, _dateFns.getHours)(parsedDate, {
+      in: this.getDateFnsContext()
+    });
   }
 
   /**
    */
   getMinutes(date) {
-    const parsedDate = typeof date === "string" ? this.toDate(date) : date;
-    return (0, _dateFns.getMinutes)(parsedDate);
+    let inputFormat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getIsoFormat();
+    const parsedDate = this.toDate(date, inputFormat);
+    return (0, _dateFns.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 (0, _dateFns.getWeek)(this.toDate(date), {
+    const parsedDate = this.toDate(date, inputFormat);
+    return (0, _dateFns.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((0, _dateFns.set)(parsedDate, {
+      [property]: value
+    }
+    // {
+    //   in: this.getDateFnsContext(),
+    // },
+    ));
+  }
+
   /**
-   * SETTERS
    */
   setYear(date, year) {
-    return this.toISO((0, _dateFns.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((0, _dateFns.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((0, _dateFns.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((0, _dateFns.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((0, _dateFns.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((0, _dateFns.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((0, _dateFns.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((0, _dateFns.set)(parsedDate, {
       hours,
       minutes,
       seconds,
       milliseconds
+    }, {
+      in: this.getDateFnsContext()
     }));
   }
+
+  //////////// Timezone related
+
+  /**
+   */
+  getTimeZone() {
+    return this._timeZone;
+  }
+
+  /**
+   */
+  setTimeZone(timeZone) {
+    this._timeZone = timeZone;
+  }
+
+  /**
+   */
+  getDateFnsContext() {
+    if (_constants.IS_GRAALJS) {
+      return null; // tz method does not work in graal (yet)
+    }
+    return (0, _tz.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 ((0, _dateFns.isValid)(parsedDate)) {
+      const dateOffset = this.toFormat(parsedDate, _constants.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 = (0, _trunc.default)(absOffset);
+      const minutes = Math.round(absOffset % 1 * 60);
+      const offsetString = `${sign}${(0, _padStart.default)(_context2 = String(hours + (minutes === 60 ? 1 : 0))).call(_context2, 2, "0")}:${(0, _padStart.default)(_context3 = String(minutes % 60)).call(_context3, 2, "0")}`;
+      return {
+        label: info.name,
+        abbr: info.abbr,
+        value: offsetString
+      };
+    };
+    const timezone = (0, _timezoneSoft.default)(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)
+    };
+  }
 }
 
 /**