formiojs-eorion 0.1.60 → 0.1.62

package/dist/formio.min.js.LICENSE.txt

@@ -17,7 +17,7 @@
     MIT License: http://getify.mit-license.org
 */
 
-/*! formiojs v0.1.60 | https://unpkg.com/formiojs@0.1.60/LICENSE.txt */
+/*! formiojs v0.1.62 | https://unpkg.com/formiojs@0.1.62/LICENSE.txt */
 
 /**
  * @license

package/dist/formio.utils.min.js.LICENSE.txt

@@ -17,7 +17,7 @@
     MIT License: http://getify.mit-license.org
 */
 
-/*! formiojs v0.1.60 | https://unpkg.com/formiojs@0.1.60/LICENSE.txt */
+/*! formiojs v0.1.62 | https://unpkg.com/formiojs@0.1.62/LICENSE.txt */
 
 /**
  * @license

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "formiojs-eorion",
-  "version": "0.1.60",
+  "version": "0.1.62",
   "description": "Common js library for client side interaction with <form.io>",
   "main": "index.js",
   "types": "index.d.ts",

package/widgets/CalendarRangeWidget.js

@@ -0,0 +1,628 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/es.symbol.iterator.js");
+require("core-js/modules/es.symbol.to-primitive.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.date.to-primitive.js");
+require("core-js/modules/es.number.constructor.js");
+require("core-js/modules/es.object.get-own-property-descriptor.js");
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+require("core-js/modules/es.object.get-prototype-of.js");
+require("core-js/modules/es.object.keys.js");
+require("core-js/modules/es.reflect.construct.js");
+require("core-js/modules/es.reflect.get.js");
+require("core-js/modules/es.reflect.set.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.array.find.js");
+require("core-js/modules/es.array.find-index.js");
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.array.map.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.regexp.to-string.js");
+require("core-js/modules/es.string.includes.js");
+require("core-js/modules/es.string.match.js");
+require("core-js/modules/es.string.replace.js");
+require("core-js/modules/es.string.split.js");
+require("core-js/modules/es.string.trim.js");
+var _Formio = require("../Formio");
+var _InputWidget2 = _interopRequireDefault(require("./InputWidget"));
+var _utils = require("../utils/utils");
+var _moment = _interopRequireDefault(require("moment"));
+var _lodash = _interopRequireDefault(require("lodash"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
+function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _superPropSet(t, e, o, r, p, f) { return _set(_getPrototypeOf(f ? t.prototype : t), e, o, r, p); }
+function set(e, r, t, o) { return set = "undefined" != typeof Reflect && Reflect.set ? Reflect.set : function (e, r, t, o) { var f, i = _superPropBase(e, r); if (i) { if ((f = Object.getOwnPropertyDescriptor(i, r)).set) return f.set.call(o, t), !0; if (!f.writable) return !1; } if (f = Object.getOwnPropertyDescriptor(o, r)) { if (!f.writable) return !1; f.value = t, Object.defineProperty(o, r, f); } else _defineProperty(o, r, t); return !0; }, set(e, r, t, o); }
+function _set(e, r, t, o, f) { if (!set(e, r, t, o || e) && f) throw new TypeError("failed to set property"); return t; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _superPropGet(t, o, e, r) { var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+function _get() { return _get = "undefined" != typeof Reflect && Reflect.get ? Reflect.get.bind() : function (e, t, r) { var p = _superPropBase(e, t); if (p) { var n = Object.getOwnPropertyDescriptor(p, t); return n.get ? n.get.call(arguments.length < 3 ? e : r) : n.value; } }, _get.apply(null, arguments); }
+function _superPropBase(t, o) { for (; !{}.hasOwnProperty.call(t, o) && null !== (t = _getPrototypeOf(t));); return t; }
+function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
+function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+var DEFAULT_FORMAT = 'yyyy-MM-dd hh:mm a';
+var ISO_8601_FORMAT = 'yyyy-MM-ddTHH:mm:ssZ';
+var isIEBrowser = (0, _utils.getBrowserInfo)().ie;
+var CalendarWidget = exports.default = /*#__PURE__*/function (_InputWidget) {
+  /* eslint-enable camelcase */
+
+  function CalendarWidget(settings, component, instance, index) {
+    var _this;
+    _classCallCheck(this, CalendarWidget);
+    _this = _callSuper(this, CalendarWidget, [settings, component, instance, index]);
+    // Change the format to map to the settings.
+    if (_this.settings.noCalendar) {
+      _this.settings.format = _this.settings.format.replace(/yyyy-MM-dd /g, '');
+    }
+    if (!_this.settings.enableTime) {
+      _this.settings.format = _this.settings.format.replace(/ hh:mm a$/g, '');
+    } else if (_this.settings.time_24hr) {
+      _this.settings.format = _this.settings.format.replace(/hh:mm a$/g, 'HH:mm');
+    }
+    _this.zoneLoading = false;
+    _this.timezonesUrl = "".concat(_Formio.GlobalFormio.cdn['moment-timezone'], "/data/packed/latest.json");
+    return _this;
+  }
+
+  /**
+   * Load the timezones.
+   *
+   * @return {boolean} TRUE if the zones are loading, FALSE otherwise.
+   */
+  _inherits(CalendarWidget, _InputWidget);
+  return _createClass(CalendarWidget, [{
+    key: "loadZones",
+    value: function loadZones() {
+      var _this2 = this;
+      var timezone = this.timezone;
+      if (this.zoneLoading) {
+        return true;
+      }
+      if (!(0, _utils.zonesLoaded)() && (0, _utils.shouldLoadZones)(timezone)) {
+        this.zoneLoading = true;
+        (0, _utils.loadZones)(this.timezonesUrl, timezone).then(function () {
+          _this2.zoneLoading = false;
+          _this2.emit('redraw');
+        });
+
+        // Return zones are loading.
+        return true;
+      }
+
+      // Zones are already loaded.
+      return false;
+    }
+  }, {
+    key: "attach",
+    value: function attach(input) {
+      var _this3 = this,
+        _this$component$short;
+      var superAttach = _superPropGet(CalendarWidget, "attach", this, 3)([input]);
+      var dateFormatInfo = (0, _utils.getLocaleDateFormatInfo)(this.settings.language);
+      this.defaultFormat = {
+        date: dateFormatInfo.dayFirst ? 'd/m/Y ' : 'm/d/Y ',
+        time: 'G:i K'
+      };
+      this.closedOn = 0;
+      this.valueFormat = this.settings.saveAs === 'date' ? ISO_8601_FORMAT : this.settings.dateFormat || ISO_8601_FORMAT;
+      this.valueMomentFormat = (0, _utils.convertFormatToMoment)(this.valueFormat);
+      var isReadOnly = this.settings.readOnly;
+      this.settings.minDate = isReadOnly ? null : (0, _utils.getDateSetting)(this.settings.minDate);
+      this.settings.maxDate = isReadOnly ? null : (0, _utils.getDateSetting)(this.settings.maxDate);
+      this.settings.disable = this.disabledDates;
+      this.settings.disableWeekends ? this.settings.disable.push(this.disableWeekends) : '';
+      this.settings.disableWeekdays ? this.settings.disable.push(this.disableWeekdays) : '';
+      this.settings.disableFunction ? this.settings.disable.push(this.disableFunction) : '';
+      this.settings.wasDefaultValueChanged = false;
+      this.settings.defaultValue = '';
+      this.settings.manualInputValue = '';
+      this.settings.isManuallyOverriddenValue = false;
+      this.settings.currentValue = '';
+      this.settings.altFormat = (0, _utils.convertFormatToFlatpickr)(this.settings.format);
+      this.settings.dateFormat = (0, _utils.convertFormatToFlatpickr)(this.settings.dateFormat);
+      this.settings.position = 'auto center';
+      this.settings.onChange = function () {
+        if (_this3.settings.allowInput) {
+          if (_this3.settings.isManuallyOverriddenValue && _this3.settings.enableTime) {
+            _this3.calendar._input.value = _this3.settings.manualInputValue;
+          } else {
+            _this3.settings.manualInputValue = '';
+          }
+          _this3.settings.isManuallyOverriddenValue = false;
+        }
+        _this3.emit('update');
+      };
+      this.settings.onOpen = function () {
+        return _this3.hook('onCalendarOpen');
+      };
+      this.settings.onClose = function () {
+        _this3.hook('onCalendarClose');
+        _this3.closedOn = Date.now();
+        if (_this3.settings.allowInput && _this3.settings.enableTime) {
+          _this3.calendar._input.value = _this3.settings.manualInputValue || _this3.calendar._input.value;
+          _this3.settings.isManuallyOverriddenValue = false;
+          _this3.emit('update');
+        }
+        if (_this3.settings.wasDefaultValueChanged) {
+          _this3.calendar._input.value = _this3.settings.defaultValue;
+          _this3.settings.wasDefaultValueChanged = false;
+        }
+        if (_this3.calendar) {
+          _this3.emit('blur');
+        }
+      };
+      _Formio.GlobalFormio.requireLibrary('flatpickr-css', 'flatpickr', [{
+        type: 'styles',
+        src: "".concat(_Formio.GlobalFormio.cdn['flatpickr-formio'], "/flatpickr.min.css")
+      }], true);
+      if (this.component.shortcutButtons) {
+        this.component.shortcutButtons = this.component.shortcutButtons.filter(function (btn) {
+          return btn.label && btn.onClick;
+        });
+      }
+      if ((_this$component$short = this.component.shortcutButtons) !== null && _this$component$short !== void 0 && _this$component$short.length) {
+        _Formio.GlobalFormio.requireLibrary('shortcut-buttons-flatpickr-css', 'ShortcutButtonsPlugin', [{
+          type: 'styles',
+          src: "".concat(_Formio.GlobalFormio.cdn['shortcut-buttons-flatpickr'], "/themes/light.min.css")
+        }], true);
+      }
+      return superAttach.then(function () {
+        var _this3$component$shor;
+        if ((_this3$component$shor = _this3.component.shortcutButtons) !== null && _this3$component$shor !== void 0 && _this3$component$shor.length) {
+          return _Formio.GlobalFormio.requireLibrary('shortcut-buttons-flatpickr', 'ShortcutButtonsPlugin', "".concat(_Formio.GlobalFormio.cdn['shortcut-buttons-flatpickr'], "/shortcut-buttons-flatpickr.min.js"), true);
+        }
+      }).then(function (ShortcutButtonsPlugin) {
+        return _Formio.GlobalFormio.requireLibrary('flatpickr', 'flatpickr', "".concat(_Formio.GlobalFormio.cdn['flatpickr-formio'], "/flatpickr.min.js"), true).then(function (Flatpickr) {
+          var _this3$component$shor2;
+          if ((_this3$component$shor2 = _this3.component.shortcutButtons) !== null && _this3$component$shor2 !== void 0 && _this3$component$shor2.length && ShortcutButtonsPlugin) {
+            _this3.initShortcutButtonsPlugin(ShortcutButtonsPlugin);
+          }
+          _this3.settings.formatDate = _this3.getFlatpickrFormatDate(Flatpickr);
+          if (_this3._input) {
+            var locale = _this3.settings.locale;
+            if (locale && locale.length >= 2 && locale !== 'en') {
+              _Formio.GlobalFormio.requireLibrary("flatpickr-".concat(locale), "flatpickr-".concat(locale), "".concat(_Formio.GlobalFormio.cdn['flatpickr-formio'], "/l10n/flatpickr-").concat(locale, ".js"), true);
+              _Formio.GlobalFormio.libraryReady("flatpickr-".concat(locale)).then(function () {
+                return _this3.initFlatpickr(Flatpickr);
+              });
+            } else {
+              _this3.initFlatpickr(Flatpickr);
+            }
+          }
+        });
+      }).catch(function (err) {
+        console.warn(err);
+      });
+    }
+  }, {
+    key: "disableWeekends",
+    get: function get() {
+      return function (date) {
+        return date.getDay() === 0 || date.getDay() === 6;
+      };
+    }
+  }, {
+    key: "disableWeekdays",
+    get: function get() {
+      var _this4 = this;
+      return function (date) {
+        return !_this4.disableWeekends(date);
+      };
+    }
+  }, {
+    key: "disableFunction",
+    get: function get() {
+      var _this5 = this;
+      return function (date) {
+        return _this5.evaluate("return ".concat(_this5.settings.disableFunction), {
+          date: date
+        });
+      };
+    }
+  }, {
+    key: "timezone",
+    get: function get() {
+      return this.componentInstance.getTimezone(this.settings);
+    }
+  }, {
+    key: "defaultSettings",
+    get: function get() {
+      return CalendarWidget.defaultSettings;
+    }
+  }, {
+    key: "addSuffix",
+    value: function addSuffix(suffix) {
+      var _this6 = this;
+      this.addEventListener(suffix, 'click', function () {
+        setTimeout(function () {
+          if (_this6.calendar) {
+            if (!_this6.calendar.isOpen && Date.now() - _this6.closedOn > 200) {
+              _this6.calendar.open();
+            } else if (_this6.calendar.isOpen) {
+              _this6.calendar.close();
+            }
+          }
+        }, 0);
+      });
+      return suffix;
+    }
+  }, {
+    key: "disabled",
+    set: function set(disabled) {
+      _superPropSet(CalendarWidget, "disabled", disabled, this, 1, 1);
+      if (this.calendar) {
+        if (disabled) {
+          this.calendar._input.setAttribute('disabled', 'disabled');
+        } else {
+          this.calendar._input.removeAttribute('disabled');
+        }
+        this.calendar.close();
+        this.calendar.redraw();
+      }
+    }
+  }, {
+    key: "input",
+    get: function get() {
+      return this.calendar ? this.calendar.altInput : null;
+    }
+  }, {
+    key: "disabledDates",
+    get: function get() {
+      if (this.settings.disabledDates) {
+        var disabledDates = this.settings.disabledDates.split(',');
+        return disabledDates.map(function (item) {
+          var dateMask = /\d{4}-\d{2}-\d{2}/g;
+          var dates = item.match(dateMask);
+          if (dates && dates.length) {
+            return dates.length === 1 ? item.match(dateMask)[0] : {
+              from: item.match(dateMask)[0],
+              to: item.match(dateMask)[1]
+            };
+          }
+        });
+      }
+      return [];
+    }
+  }, {
+    key: "localeFormat",
+    get: function get() {
+      var format = '';
+      if (this.settings.enableDate) {
+        format += this.defaultFormat.date;
+      }
+      if (this.settings.enableTime) {
+        format += this.defaultFormat.time;
+      }
+      return format;
+    }
+  }, {
+    key: "dateTimeFormat",
+    get: function get() {
+      return this.settings.useLocaleSettings ? this.localeFormat : (0, _utils.convertFormatToFlatpickr)(this.dateFormat);
+    }
+  }, {
+    key: "dateFormat",
+    get: function get() {
+      return _lodash.default.get(this.settings, 'format', DEFAULT_FORMAT);
+    }
+
+    /**
+     * Return the date value.
+     *
+     * @param date
+     * @param format
+     * @return {string}
+     */
+  }, {
+    key: "getDateValue",
+    value: function getDateValue(date, format, useTimezone) {
+      if (useTimezone) {
+        return (0, _utils.momentDate)(date, this.valueFormat, this.timezone).format((0, _utils.convertFormatToMoment)(format));
+      }
+      return (0, _moment.default)(date).format((0, _utils.convertFormatToMoment)(format));
+    }
+
+    /**
+     * Return the value of the selected date.
+     *
+     * @return {*}
+     */
+  }, {
+    key: "getValue",
+    value: function getValue() {
+      var _this7 = this;
+      // Standard output format.
+      if (!this.calendar) {
+        return _superPropGet(CalendarWidget, "getValue", this, 3)([]);
+      }
+
+      // Get the selected dates from the calendar widget.
+      var dates = this.calendar.selectedDates;
+      if (!dates || !dates.length) {
+        return _superPropGet(CalendarWidget, "getValue", this, 3)([]);
+      }
+      if (dates.findIndex(function (date) {
+        return !(date instanceof Date);
+      }) > -1) {
+        return 'Invalid Date';
+      }
+      return dates.map(function (date) {
+        return _this7.getDateValue(date, _this7.valueFormat, _this7.settings.saveAs === 'date');
+      });
+    }
+  }, {
+    key: "isValueISO8601",
+    value: function isValueISO8601(value) {
+      return value && typeof value === 'string' && value.match(/-[0-9]{2}T[0-9]{2}:/);
+    }
+
+    /**
+     * Set the selected date value.
+     *
+     * @param value
+     */
+  }, {
+    key: "setValue",
+    value: function setValue(value) {
+      var _this8 = this;
+      var saveAsText = this.settings.saveAs === 'text';
+      if (!this.calendar) {
+        value = value ? (0, _utils.formatDate)(this.timezonesUrl, value, (0, _utils.convertFormatToMoment)(this.settings.format), this.timezone, (0, _utils.convertFormatToMoment)(this.valueMomentFormat)) : value;
+        return _superPropGet(CalendarWidget, "setValue", this, 3)([value]);
+      }
+      var zonesLoading = this.loadZones();
+      if (value && value.length > 0) {
+        if (!saveAsText && this.settings.readOnly && !zonesLoading) {
+          this.calendar.setDate(value.map(function (date) {
+            return (0, _utils.momentDate)(date, _this8.valueFormat, _this8.timezone).format();
+          }), false);
+        } else if (this.isValueISO8601(value[0])) {
+          this.calendar.setDate(value, false);
+        } else {
+          this.calendar.setDate(value.map(function (date) {
+            return (0, _moment.default)(date, _this8.valueMomentFormat).toDate();
+          }), false);
+        }
+      } else {
+        this.calendar.clear(false);
+      }
+    }
+  }, {
+    key: "getValueAsString",
+    value: function getValueAsString(value, format) {
+      var inputFormat = format || this.dateFormat;
+      var valueFormat = this.calendar ? this.valueFormat : this.settings.dateFormat;
+      if (this.settings.saveAs === 'text' && this.componentInstance.parent && !this.settings.readOnly) {
+        return (0, _moment.default)(value, (0, _utils.convertFormatToMoment)(valueFormat)).format((0, _utils.convertFormatToMoment)(valueFormat));
+      }
+      return (0, _utils.formatDate)(this.timezonesUrl, value, inputFormat, this.timezone, (0, _utils.convertFormatToMoment)(valueFormat));
+    }
+  }, {
+    key: "setErrorClasses",
+    value: function setErrorClasses(hasErrors) {
+      if (!this.input) {
+        return;
+      }
+      if (hasErrors) {
+        this.addClass(this.input, 'is-invalid');
+        this.input.setAttribute('aria-invalid', 'true');
+      } else {
+        this.removeClass(this.input, 'is-invalid');
+        this.input.setAttribute('aria-invalid', 'false');
+      }
+    }
+  }, {
+    key: "validationValue",
+    value: function validationValue(value) {
+      if (typeof value === 'string') {
+        return new Date(value);
+      }
+      return value.map(function (val) {
+        return new Date(val);
+      });
+    }
+  }, {
+    key: "isCalendarElement",
+    value: function isCalendarElement(element) {
+      var _this$calendar, _this$calendar$config, _this$calendar$config2, _this$calendar2, _this$calendar2$calen;
+      if (!element) {
+        return true;
+      }
+      if ((_this$calendar = this.calendar) !== null && _this$calendar !== void 0 && (_this$calendar$config = _this$calendar.config) !== null && _this$calendar$config !== void 0 && (_this$calendar$config2 = _this$calendar$config.appendTo) !== null && _this$calendar$config2 !== void 0 && _this$calendar$config2.contains(element)) {
+        return true;
+      }
+      return (_this$calendar2 = this.calendar) === null || _this$calendar2 === void 0 ? void 0 : (_this$calendar2$calen = _this$calendar2.calendarContainer) === null || _this$calendar2$calen === void 0 ? void 0 : _this$calendar2$calen.contains(element);
+    }
+  }, {
+    key: "initFlatpickr",
+    value: function initFlatpickr(Flatpickr) {
+      var _this9 = this;
+      // Create a new flatpickr.
+      this.calendar = new Flatpickr(this._input, _objectSpread(_objectSpread({}, this.settings), {}, {
+        disableMobile: true
+      }));
+      this.calendar.altInput.addEventListener('input', function (event) {
+        if (_this9.settings.allowInput && _this9.settings.currentValue !== event.target.value) {
+          _this9.settings.manualInputValue = event.target.value;
+          _this9.settings.isManuallyOverriddenValue = true;
+          _this9.settings.currentValue = event.target.value;
+        }
+        if (event.target.value === '' && _this9.calendar.selectedDates.length > 0) {
+          _this9.settings.wasDefaultValueChanged = true;
+          _this9.settings.defaultValue = event.target.value;
+          _this9.calendar.clear();
+        } else {
+          _this9.settings.wasDefaultValueChanged = false;
+        }
+      });
+      var excludedFromMaskFormats = ['MMMM'];
+      if (!this.settings.readOnly && !_lodash.default.some(excludedFromMaskFormats, function (format) {
+        return _lodash.default.includes(_this9.settings.format, format);
+      })) {
+        // Enforce the input mask of the format.
+        this.setInputMask(this.calendar._input, (0, _utils.convertFormatToMask)(this.settings.format));
+      }
+
+      // Fixes an issue with IE11 where value is set only after the second click
+      // TODO: Remove when the issue is solved in the flatpickr library
+      if (isIEBrowser) {
+        // Remove the original blur listener, because value will be set to empty since relatedTarget is null in IE11
+        var originalBlurListener = this.calendar._handlers.find(function (_ref) {
+          var event = _ref.event,
+            element = _ref.element;
+          return event === 'blur' && element === _this9.calendar._input;
+        });
+        this.calendar._input.removeEventListener('blur', originalBlurListener.handler);
+        // Add the same event listener as in the original library, but with workaround for IE11 issue
+        this.addEventListener(this.calendar._input, 'blur', function (event) {
+          var activeElement = _this9.settings.shadowRoot ? _this9.settings.shadowRoot.activeElement : document.activeElement;
+          var relatedTarget = event.relatedTarget ? event.relatedTarget : activeElement;
+          var isInput = event.target === _this9.calendar._input;
+          if (isInput && !_this9.isCalendarElement(relatedTarget)) {
+            _this9.calendar.setDate(_this9.calendar._input.value, true, event.target === _this9.calendar.altInput ? _this9.calendar.config.altFormat : _this9.calendar.config.dateFormat);
+          }
+        });
+      }
+      // Make sure we commit the value after a blur event occurs.
+      this.addEventListener(this.calendar._input, 'blur', function (event) {
+        var activeElement = _this9.settings.shadowRoot ? _this9.settings.shadowRoot.activeElement : document.activeElement;
+        var relatedTarget = event.relatedTarget ? event.relatedTarget : activeElement;
+        if (!(isIEBrowser && !relatedTarget) && !_this9.isCalendarElement(relatedTarget)) {
+          var _this9$calendar$l10n$;
+          var inputValue = _this9.calendar.input.value;
+          // 范围分割字符
+          var rangeSeparator = (_this9$calendar$l10n$ = _this9.calendar.l10n.rangeSeparator) !== null && _this9$calendar$l10n$ !== void 0 ? _this9$calendar$l10n$ : ' to ';
+          var dateValue = inputValue ? inputValue.split(rangeSeparator).map(function (value) {
+            return (0, _moment.default)(value.trim(), (0, _utils.convertFormatToMoment)(_this9.valueFormat)).toDate();
+          }) : [];
+          _this9.calendar.setDate(dateValue, true, _this9.settings.altFormat);
+        } else if (!_this9.calendar.input.value && _this9.calendar.config.noCalendar) {
+          var _this9$calendar, _this9$calendar$confi, _this9$calendar2, _this9$calendar2$conf;
+          var value = (0, _moment.default)({
+            hour: (_this9$calendar = _this9.calendar) === null || _this9$calendar === void 0 ? void 0 : (_this9$calendar$confi = _this9$calendar.config) === null || _this9$calendar$confi === void 0 ? void 0 : _this9$calendar$confi.defaultHour,
+            minute: (_this9$calendar2 = _this9.calendar) === null || _this9$calendar2 === void 0 ? void 0 : (_this9$calendar2$conf = _this9$calendar2.config) === null || _this9$calendar2$conf === void 0 ? void 0 : _this9$calendar2$conf.defaultMinute
+          }).toDate();
+          _this9.calendar.setDate([value], true, _this9.settings.format);
+        }
+      });
+
+      // FJS-1103: When hit the enter button, the field not saving the year correctly
+      this.addEventListener(this.calendar.altInput, 'keydown', function (event) {
+        if (event.keyCode === 13) {
+          if (_this9.calendar.isOpen) {
+            _this9.calendar.close();
+            event.stopPropagation();
+          }
+        }
+      });
+
+      // Restore the calendar value from the component value.
+      this.setValue(this.componentValue);
+    }
+  }, {
+    key: "initShortcutButtonsPlugin",
+    value: function initShortcutButtonsPlugin(ShortcutButtonsPlugin) {
+      var _this10 = this;
+      this.settings.plugins = [
+      // eslint-disable-next-line new-cap
+      ShortcutButtonsPlugin({
+        button: this.component.shortcutButtons.map(function (btn) {
+          return {
+            label: btn.label,
+            attributes: btn.attribute
+          };
+        }),
+        onClick: function onClick(index) {
+          var getValue = _this10.component.shortcutButtons[index].onClick;
+          var date = _this10.evaluate(getValue, {
+            date: new Date()
+          }, 'date');
+          _this10.calendar.setDate(date, true);
+        }
+      })];
+    }
+  }, {
+    key: "componentValue",
+    get: function get() {
+      return this.componentInstance.dataValue;
+    }
+  }, {
+    key: "getFlatpickrFormatDate",
+    value: function getFlatpickrFormatDate(Flatpickr) {
+      var _this11 = this;
+      return function (date, format) {
+        // Only format this if this is the altFormat and the form is readOnly.
+        if (_this11.settings.readOnly && format === _this11.settings.altFormat) {
+          if (_this11.loadZones()) {
+            return Flatpickr.formatDate(date, format);
+          }
+          var currentValue = new Date(_this11.getValue());
+          if (currentValue.toString() === date.toString()) {
+            return (0, _utils.formatOffset)(_this11.timezonesUrl, Flatpickr.formatDate.bind(Flatpickr), new Date(_this11.componentValue), format, _this11.timezone);
+          }
+          return (0, _utils.formatOffset)(_this11.timezonesUrl, Flatpickr.formatDate.bind(Flatpickr), date, format, _this11.timezone);
+        }
+        return Flatpickr.formatDate(date, format);
+      };
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      _superPropGet(CalendarWidget, "destroy", this, 3)([]);
+      if (this.calendar) {
+        this.calendar.destroy();
+      }
+    }
+  }], [{
+    key: "defaultSettings",
+    get: /* eslint-disable camelcase */
+    function get() {
+      return {
+        type: 'calendarRange',
+        altInput: true,
+        allowInput: true,
+        clickOpens: true,
+        enableDate: true,
+        enableTime: true,
+        mode: 'range',
+        noCalendar: false,
+        format: DEFAULT_FORMAT,
+        dateFormat: ISO_8601_FORMAT,
+        useLocaleSettings: false,
+        language: 'us-en',
+        hourIncrement: 1,
+        minuteIncrement: 5,
+        time_24hr: false,
+        saveAs: 'date',
+        displayInTimezone: '',
+        timezone: '',
+        disable: [],
+        minDate: '',
+        maxDate: ''
+      };
+    }
+  }]);
+}(_InputWidget2.default);

package/widgets/index.js

@@ -6,8 +6,10 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 var _InputWidget = _interopRequireDefault(require("./InputWidget"));
 var _CalendarWidget = _interopRequireDefault(require("./CalendarWidget"));
+var _CalendarRangeWidget = _interopRequireDefault(require("./CalendarRangeWidget"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 var _default = exports.default = {
   input: _InputWidget.default,
-  calendar: _CalendarWidget.default
+  calendar: _CalendarWidget.default,
+  calendarRange: _CalendarRangeWidget.default
 };