@beinformed/ui 1.23.3-beta.0 → 1.23.4

package/lib/models/attributes/DatetimeAttributeModel.js

@@ -1,29 +1,45 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+
 var _includes = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/includes"));
+
 var _trim = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/trim"));
+
+var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));
+
 var _objects = require("../../utils/helpers/objects");
+
 var _DateTimeUtil = require("../../utils/datetime/DateTimeUtil");
+
 var _StringAttributeModel = _interopRequireDefault(require("./StringAttributeModel"));
+
 var _ConstraintCollection = _interopRequireDefault(require("./input-constraints/ConstraintCollection"));
+
 var _DateTimeDateFormatConstraint = _interopRequireDefault(require("./input-constraints/DateTimeDateFormatConstraint"));
+
 var _DateTimeTimeFormatConstraint = _interopRequireDefault(require("./input-constraints/DateTimeTimeFormatConstraint"));
+
 var _DatetimeFormatConstraint = _interopRequireDefault(require("./input-constraints/DatetimeFormatConstraint"));
+
 var _DateBoundaryConstraint = _interopRequireDefault(require("./input-constraints/DateBoundaryConstraint"));
+
 var _constants = require("../../constants");
+
 var _Settings = require("../../constants/Settings");
+
 var _LayoutHints = require("../../constants/LayoutHints");
 
 // date format of default
 const PRODUCT_DEFAULT_DATE_FORMAT = "dd-MM-yyyy";
-
 /**
  */
+
 class DatetimeAttributeModel extends _StringAttributeModel.default {
   /**
    */
@@ -31,342 +47,422 @@ class DatetimeAttributeModel extends _StringAttributeModel.default {
     super(attribute, attributeContributions);
     this.updateInitValue();
   }
-
   /**
    */
+
+
   static isApplicableModel(contributions) {
     var _context;
+
     return (0, _includes.default)(_context = ["date", "time", "datetime", "timestamp"]).call(_context, contributions.type);
   }
-
   /**
    */
+
+
   get formatUtil() {
     switch (this.type) {
       case "time":
         return _DateTimeUtil.TimeUtil;
+
       case "timestamp":
         return _DateTimeUtil.TimestampUtil;
+
       case "datetime":
         return _DateTimeUtil.DateTimeUtil;
+
       default:
         return _DateTimeUtil.DateUtil;
     }
   }
-
   /**
    */
+
+
   getInitValue() {
     let value = this.data.value;
+
     if (value != null) {
       if (this.type === "time" && value.length === 5) {
-        value = `${value}:00`;
-      }
+        value = "".concat(value, ":00");
+      } // handle old datetime values, which contained ms
+
 
-      // handle old datetime values, which contained ms
       if (this.type === "datetime" && (0, _includes.default)(value).call(value, ".")) {
         value = value.split(".")[0];
       }
+
       if (this.hasTime) {
         value = this.getTimeValue(value);
       }
     }
+
     return value;
   }
-
   /**
    */
+
+
   getTimeValue(value) {
     var _context2, _context3, _context4, _context5;
+
     let timeValue = value;
+
     if (!(0, _includes.default)(_context2 = this.timeInputFormat.toLowerCase()).call(_context2, "h")) {
       timeValue = this.formatUtil.setHour(value, 0);
     }
+
     if (!(0, _includes.default)(_context3 = this.timeInputFormat).call(_context3, "m")) {
       timeValue = this.formatUtil.setMinute(value, 0);
     }
+
     if (!(0, _includes.default)(_context4 = this.timeInputFormat).call(_context4, "s")) {
       timeValue = this.formatUtil.setSecond(value, 0);
     }
+
     if (this.type === "timestamp" && !(0, _includes.default)(_context5 = this.timeInputFormat).call(_context5, "S")) {
       timeValue = this.formatUtil.setMilliseconds(value, 0);
     }
+
     return timeValue;
   }
-
   /**
    * Set time in the correct value based on available elements in the time format
    */
+
+
   updateInitValue() {
     const value = this.getInitValue();
+
     if (value != null) {
       this._initvalue = value;
       this._inputvalue = this.getInitialInputValue(value);
       this._value = value;
     }
   }
-
   /**
    * Get initial user input value
    */
+
+
   getInitialInputValue(value) {
     if (!value) {
       return "";
     }
+
     let initValue = value;
+
     if (this.type === "time" && value.length === 5) {
-      initValue = `${value}:00`;
+      initValue = "".concat(value, ":00");
     }
+
     return this.formatUtil.toFormat(initValue, this.inputFormat);
   }
-
   /**
    * Set type to date
    */
+
+
   get type() {
     return this.getContribution("type", "date");
   }
-
   /**
    * Returns the value as entered by the user. This can differ from the internal iso value that is stored
    */
+
+
   getInputValue() {
     return this._inputvalue ? this._inputvalue.toString() : "";
   }
-
   /**
    * Get input value
    */
+
+
   get inputvalue() {
     return this.getInputValue();
   }
-
   /**
    * Sets the input value to the value entered by the user
    */
+
+
   set inputvalue(value) {
     this.validate(value);
     this._inputvalue = value;
     this.value = value !== null && value !== "" ? this.formatUtil.toISO(value, this.inputFormat) : null;
   }
-
   /**
    * Get date format
    */
+
+
   get format() {
     const format = this.getContribution("format", "");
     return this.formatUtil.convertFormat(format);
   }
-
   /**
    */
+
+
   get operator() {
     return this.getContribution("operator", "");
   }
-
   /**
    */
+
+
   get hasDate() {
     return this.type === "date" || this.type === "datetime" || this.type === "timestamp";
   }
-
   /**
    */
+
+
   get hasTime() {
     return this.type === "time" || this.type === "datetime" || this.type === "timestamp";
   }
-
   /**
    */
+
+
   get formatLabel() {
     switch (this.type) {
       case "date":
         return this.dateInputFormat.toLowerCase();
+
       case "time":
         return this.timeInputFormat.toLowerCase();
+
       default:
         return this.format.toLowerCase();
     }
   }
-
   /**
    */
+
+
   get inputFormat() {
     if (this.hasDate && this.hasTime) {
-      var _context6;
-      return (0, _trim.default)(_context6 = `${this.dateInputFormat} ${this.timeInputFormat}`).call(_context6);
+      var _context6, _context7;
+
+      return (0, _trim.default)(_context6 = (0, _concat.default)(_context7 = "".concat(this.dateInputFormat, " ")).call(_context7, this.timeInputFormat)).call(_context6);
     }
+
     if (this.hasDate) {
       return this.dateInputFormat;
     }
+
     if (this.hasTime) {
       return this.timeInputFormat;
     }
+
     return "";
   }
-
   /**
    */
+
+
   get dateInputFormat() {
-    var _context7;
+    var _context8;
+
     if (!this.hasDate) {
       return "";
-    }
+    } // setting for date input
+
 
-    // setting for date input
     const ignoreFormatSetting = this.layouthint.has(_LayoutHints.IGNORE_FORMAT_SETTING);
+
     if (!ignoreFormatSetting) {
       const dateInputFormatSetting = (0, _Settings.getSetting)("DATE_INPUT_FORMAT", "");
+
       if (dateInputFormatSetting) {
         return dateInputFormatSetting;
       }
     }
+
     let format = this.format;
-    let dateFormat = this.hasTime ? (0, _trim.default)(_context7 = format.replace(this.timeInputFormat, "")).call(_context7) : format;
+    let dateFormat = this.hasTime ? (0, _trim.default)(_context8 = format.replace(this.timeInputFormat, "")).call(_context8) : format;
     return dateFormat;
   }
-
   /**
    */
+
+
   get dateReadonlyFormat() {
-    var _context8;
+    var _context9;
+
     if (!this.hasDate) {
       return "";
     }
+
     let format = this.format;
-    let dateFormat = this.hasTime ? (0, _trim.default)(_context8 = format.replace(this.timeInputFormat, "")).call(_context8) : format;
+    let dateFormat = this.hasTime ? (0, _trim.default)(_context9 = format.replace(this.timeInputFormat, "")).call(_context9) : format;
     const readonlyFormatSetting = (0, _Settings.getSetting)("DATE_READONLY_FORMAT", "");
+
     if (dateFormat === PRODUCT_DEFAULT_DATE_FORMAT && readonlyFormatSetting) {
       dateFormat = readonlyFormatSetting;
     }
+
     return dateFormat;
   }
-
   /**
    * return attribute placeholder or, if DATE_INPUT_FORMAT setting is used, lowercased setting, otherwise return formatlabel without time input format from contributions
    */
+
+
   get placeholder() {
     if (this._placeholder !== "") {
       return this._placeholder;
     }
+
     const dateInputFormatSetting = (0, _Settings.getSetting)("DATE_INPUT_FORMAT", "");
+
     if (dateInputFormatSetting) {
       return dateInputFormatSetting.toLowerCase();
     }
+
     const formatLabel = this.getContribution("formatlabel", "");
+
     if (this.hasDate && this.hasTime && (0, _includes.default)(formatLabel).call(formatLabel, " ")) {
       // return first part of formatlabel to keep placeholder matching date input
       return formatLabel.split(" ")[0];
     }
+
     return formatLabel;
   }
-
   /**
    * Set placeholder text
    */
+
+
   set placeholder(placeholder) {
     this._placeholder = placeholder;
   }
-
   /**
    */
+
+
   get timeInputFormat() {
     if (!this.hasTime) {
       return "";
     }
+
     const format = this.format;
     let timeFormatParts = [];
+
     if ((0, _includes.default)(format).call(format, "H")) {
       timeFormatParts.push("HH");
     } else if ((0, _includes.default)(format).call(format, "h")) {
       timeFormatParts.push("hh");
     }
+
     if ((0, _includes.default)(format).call(format, "m")) {
       timeFormatParts.push("mm");
     }
+
     if ((0, _includes.default)(format).call(format, "s")) {
       timeFormatParts.push("ss");
     }
+
     let timeFormat = timeFormatParts.join(":");
+
     if ((0, _includes.default)(format).call(format, "S")) {
-      timeFormat = `${timeFormat}.SSS`;
+      timeFormat = "".concat(timeFormat, ".SSS");
     }
+
     if ((0, _includes.default)(format).call(format, "a")) {
-      return `${timeFormat} a`;
+      return "".concat(timeFormat, " a");
     }
+
     return timeFormat;
   }
-
   /**
    */
+
+
   get timeReadonlyFormat() {
     if (!this.hasTime) {
       return "";
     }
+
     return this.timeInputFormat;
   }
-
   /**
    */
+
+
   get dateInputValue() {
     return typeof this.value === "string" && this.dateInputFormat !== "" ? this.formatUtil.toFormat(this.value, this.dateInputFormat) : "";
   }
-
   /**
    */
+
+
   get timeInputValue() {
     return typeof this.value === "string" && this.timeInputFormat !== "" ? this.formatUtil.toFormat(this.value, this.timeInputFormat) : "";
-  }
+  } // format value in readonly rendering
 
-  // format value in readonly rendering
   /**
    */
+
+
   formatValue(value) {
     if (value == null || value.toString() === "") {
       return "";
-    }
+    } // when the value is exactly an iso date, render as date
+
 
-    // when the value is exactly an iso date, render as date
     if ((this.type === "datetime" || this.type === "timestamp") && _DateTimeUtil.DateUtil.hasFormat(value, _constants.ISO_DATE_FORMAT)) {
       return _DateTimeUtil.DateUtil.toFormat(value, this.dateReadonlyFormat);
     }
+
     if (this.hasDate && this.hasTime) {
-      const dateTimeReadonlyFormat = `${this.dateReadonlyFormat} ${this.timeReadonlyFormat}`;
+      var _context10;
+
+      const dateTimeReadonlyFormat = (0, _concat.default)(_context10 = "".concat(this.dateReadonlyFormat, " ")).call(_context10, this.timeReadonlyFormat);
       return this.formatUtil.toFormat(value, dateTimeReadonlyFormat);
     }
+
     if (this.type === "date") {
       return this.formatUtil.toFormat(value, this.dateReadonlyFormat);
     }
+
     return this.formatUtil.toFormat(value, this.format);
   }
-
   /**
    * Retrieve readonly value, the date in the configurated format
    */
+
+
   get readonlyvalue() {
     if (typeof this.value === "string") {
       return this.formatValue(this.value.toString());
     }
+
     return "";
   }
-
   /**
    * Get minimum date
    */
+
+
   get mindate() {
     return this.getContribution("mindate");
   }
-
   /**
    * Get maximum date
    */
+
+
   get maxdate() {
     return this.getContribution("maxdate");
   }
-
   /**
    * Registers an error that was received from a server response
    */
+
+
   addServerError(error) {
     const {
       id,
@@ -374,46 +470,58 @@ class DatetimeAttributeModel extends _StringAttributeModel.default {
       properties,
       layouthint
     } = error;
+
     if (properties && (0, _objects.has)(properties, "format") && this.formatLabel) {
       properties.format = this.formatLabel;
     }
+
     this._errorCollection.addServerError(id, message, properties, layouthint);
   }
-
   /**
    */
+
+
   getFormatConstraint() {
     switch (this.type) {
       case "date":
         return new _DateTimeDateFormatConstraint.default(this.dateInputFormat, this.formatLabel);
+
       case "time":
         return new _DateTimeTimeFormatConstraint.default(this.timeInputFormat, this.formatLabel);
+
       default:
         return new _DatetimeFormatConstraint.default(this.type, this.inputFormat, this.formatLabel);
     }
   }
-
   /**
    * Add Date constraints for attribute
    */
+
+
   addConstraints() {
     const constraints = new _ConstraintCollection.default();
     constraints.add(this.getFormatConstraint());
+
     if (this.mindate || this.maxdate) {
       constraints.add(new _DateBoundaryConstraint.default(this.type, this.mindate, this.maxdate, this.inputFormat));
     }
+
     return constraints;
   }
-
   /**
    */
+
+
   get readonlyWidth() {
     if (this.type === "date" || this.type === "time") {
       return _constants.ATTRIBUTE_WIDTH.SMALL;
     }
+
     return _constants.ATTRIBUTE_WIDTH.MEDIUM;
   }
+
 }
+
 var _default = DatetimeAttributeModel;
 exports.default = _default;
 //# sourceMappingURL=DatetimeAttributeModel.js.map