@iobroker/adapter-react-v5 4.11.3 → 4.11.5

package/Components/SimpleCron/index.js

@@ -1,773 +1,623 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = void 0;
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
-var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
-var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
-var _react = _interopRequireDefault(require("react"));
-var _propTypes = _interopRequireDefault(require("prop-types"));
-var _styles = require("@mui/styles");
-var _InputLabel = _interopRequireDefault(require("@mui/material/InputLabel"));
-var _MenuItem = _interopRequireDefault(require("@mui/material/MenuItem"));
-var _FormControl = _interopRequireDefault(require("@mui/material/FormControl"));
-var _Select = _interopRequireDefault(require("@mui/material/Select"));
-var _TextField = _interopRequireDefault(require("@mui/material/TextField"));
-var _FormControlLabel = _interopRequireDefault(require("@mui/material/FormControlLabel"));
-var _Checkbox = _interopRequireDefault(require("@mui/material/Checkbox"));
-var _cronText = _interopRequireDefault(require("./cronText"));
-var _i18n = _interopRequireDefault(require("../../i18n"));
-function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
-function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
-var styles = function styles() {
-  return {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cron2state = void 0;
+const react_1 = __importDefault(require("react"));
+const styles_1 = require("@mui/styles");
+const InputLabel_1 = __importDefault(require("@mui/material/InputLabel"));
+const MenuItem_1 = __importDefault(require("@mui/material/MenuItem"));
+const FormControl_1 = __importDefault(require("@mui/material/FormControl"));
+const Select_1 = __importDefault(require("@mui/material/Select"));
+const TextField_1 = __importDefault(require("@mui/material/TextField"));
+const FormControlLabel_1 = __importDefault(require("@mui/material/FormControlLabel"));
+const Checkbox_1 = __importDefault(require("@mui/material/Checkbox"));
+const cronText_1 = __importDefault(require("./cronText"));
+const i18n_1 = __importDefault(require("../../i18n"));
+const styles = {
     mainDiv: {
-      width: '100%',
-      height: '100%',
-      overflow: 'auto'
+        width: '100%',
+        height: '100%',
+        overflow: 'auto',
     },
     formControl: {
-      margin: 0,
-      minWidth: 120
+        margin: 0,
+        minWidth: 120,
     },
     formControlMarginRight: {
-      marginRight: 5
+        marginRight: 5,
     },
     formControlPaddingTop: {
-      paddingTop: 6.2
-    }
-  };
+        paddingTop: 6.2,
+    },
 };
-var PERIODIC = {
-  once: 'once',
-  interval: 'interval',
-  intervalBetween: 'intervalBetween',
-  specific: 'specific'
+const PERIODIC = {
+    once: 'once',
+    interval: 'interval',
+    intervalBetween: 'intervalBetween',
+    specific: 'specific',
 };
-var PERIODIC_TYPES = {
-  seconds: 'seconds',
-  minutes: 'minutes'
-  // hours: 'hours',
+const PERIODIC_TYPES = {
+    seconds: 'seconds',
+    minutes: 'minutes',
+    // hours: 'hours',
 };
-var WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'];
+const WEEKDAYS = [
+    'Sunday',
+    'Monday',
+    'Tuesday',
+    'Wednesday',
+    'Thursday',
+    'Friday',
+    'Saturday',
+    'Sunday',
+];
 function padding(num) {
-  if (num < 10) {
-    return "0".concat(num);
-  }
-  return "".concat(num);
-}
-var DEFAULT_STATE = {
-  mode: PERIODIC.interval,
-  interval: {
-    period: 1,
-    unit: PERIODIC_TYPES.minutes
-  }
-};
-var SimpleCron = /*#__PURE__*/function (_React$Component) {
-  (0, _inherits2["default"])(SimpleCron, _React$Component);
-  function SimpleCron(props) {
-    var _this;
-    (0, _classCallCheck2["default"])(this, SimpleCron);
-    _this = _callSuper(this, SimpleCron, [props]);
-    var cron = typeof _this.props.cronExpression === 'string' ? _this.props.cronExpression.replace(/^["']/, '').replace(/["']\n?$/, '') : '';
-    if (cron[0] === '{') {
-      cron = '';
+    if (num < 10) {
+        return `0${num}`;
     }
-    var state = SimpleCron.cron2state(cron || '* * * * *') || DEFAULT_STATE;
-    _this.state = {
-      extended: false,
-      cron: SimpleCron.state2cron(state),
-      mode: 'interval',
-      once: {
-        time: '00:00',
-        date: ''
-      },
-      interval: {
-        period: 1,
-        unit: PERIODIC_TYPES.minutes
-      },
-      intervalBetween: {
+    return `${num}`;
+}
+const DEFAULT_STATE = {
+    mode: 'interval',
+    interval: {
         period: 1,
         unit: PERIODIC_TYPES.minutes,
-        timeFrom: 0,
-        timeTo: 24,
-        weekdays: [0, 1, 2, 3, 4, 5, 6]
-      },
-      specific: {
-        time: '00:00',
-        weekdays: [0, 1, 2, 3, 4, 5, 6]
-      }
-    };
-    Object.assign(_this.state, state);
-    if (_this.state.cron !== _this.props.cronExpression) {
-      setTimeout(function () {
-        return _this.props.onChange && _this.props.onChange(_this.state.cron);
-      }, 100);
+    },
+};
+function cron2state(cron) {
+    cron = cron.replace(/['"]/g, '').trim();
+    const cronParts = cron.split(' ');
+    let options;
+    let state = null;
+    if (cronParts.length === 6) {
+        options = {
+            seconds: cronParts[0] || '*',
+            minutes: cronParts[1] || '*',
+            hours: cronParts[2] || '*',
+            date: cronParts[3] || '*',
+            months: cronParts[4] || '*',
+            dow: cronParts[5] || '*',
+        };
     }
-    return _this;
-  }
-  (0, _createClass2["default"])(SimpleCron, [{
-    key: "recalcCron",
-    value: function recalcCron() {
-      this.onChange(SimpleCron.state2cron(this.state));
+    else {
+        options = {
+            seconds: null,
+            minutes: cronParts[0] || '*',
+            hours: cronParts[1] || '*',
+            date: cronParts[2] || '*',
+            months: cronParts[3] || '*',
+            dow: cronParts[4] || '*',
+        };
     }
-  }, {
-    key: "getControlsWeekdaysElements",
-    value: function getControlsWeekdaysElements(type) {
-      var _this2 = this;
-      var settings = this.state[type];
-      return /*#__PURE__*/_react["default"].createElement("div", {
-        key: "weekdays",
-        style: {
-          paddingLeft: 8,
-          width: '100%',
-          maxWidth: 600
-        }
-      }, /*#__PURE__*/_react["default"].createElement("h5", null, _i18n["default"].t('ra_On weekdays')), [1, 2, 3, 4, 5, 6, 0].map(function (day) {
-        return /*#__PURE__*/_react["default"].createElement(_FormControlLabel["default"], {
-          key: WEEKDAYS[day],
-          control: /*#__PURE__*/_react["default"].createElement(_Checkbox["default"], {
-            checked: settings.weekdays.indexOf(day) !== -1,
-            onChange: function onChange(e) {
-              var _settings = JSON.parse(JSON.stringify(_this2.state[type]));
-              var pos = _settings.weekdays.indexOf(day);
-              e.target.checked && pos === -1 && _settings.weekdays.push(day);
-              !e.target.checked && pos !== -1 && _settings.weekdays.splice(pos, 1);
-              _settings.weekdays.sort();
-              _this2.setState((0, _defineProperty2["default"])({}, type, _settings), function () {
-                return _this2.recalcCron();
-              });
+    // * * * * *
+    if (options.seconds === null &&
+        options.minutes === '*' &&
+        options.hours === '*' &&
+        options.date === '*' &&
+        options.months === '*') {
+        state = {
+            mode: 'interval',
+            interval: {
+                period: 1,
+                unit: PERIODIC_TYPES.minutes,
             },
-            value: day.toString()
-          }),
-          label: _i18n["default"].t(WEEKDAYS[day])
-        });
-      }));
-    }
-  }, {
-    key: "getControlsPeriodElements",
-    value: function getControlsPeriodElements(type) {
-      var _this3 = this;
-      var settings = this.state[type];
-      if (this.state.extended) {
-        return /*#__PURE__*/_react["default"].createElement("div", {
-          key: "period",
-          style: {
-            paddingLeft: 8,
-            display: 'inline-block'
-          }
-        }, /*#__PURE__*/_react["default"].createElement("h5", {
-          style: {
-            marginBottom: 5
-          }
-        }, _i18n["default"].t('sc_period')), /*#__PURE__*/_react["default"].createElement(_TextField["default"], {
-          variant: "standard",
-          style: {
-            marginTop: 0,
-            marginBottom: 0,
-            verticalAlign: 'bottom'
-          },
-          key: "value",
-          label: _i18n["default"].t('sc_minutes'),
-          value: settings.minutes,
-          onChange: function onChange(e) {
-            var _settings = JSON.parse(JSON.stringify(_this3.state[type]));
-            _settings.minutes = parseInt(e.target.value, 10);
-            if (_settings.minutes < 1) {
-              _settings.minutes = 1;
-            }
-            _this3.setState((0, _defineProperty2["default"])({}, type, _settings), function () {
-              return _this3.recalcCron();
-            });
-          },
-          min: 1,
-          max: 60,
-          type: "number",
-          InputLabelProps: {
-            shrink: true
-          },
-          margin: "normal"
-        }), /*#__PURE__*/_react["default"].createElement(_TextField["default"], {
-          variant: "standard",
-          style: {
-            marginTop: 0,
-            marginBottom: 0,
-            verticalAlign: 'bottom'
-          },
-          key: "value",
-          label: _i18n["default"].t('sc_hours'),
-          value: settings.hours,
-          onChange: function onChange(e) {
-            var _settings = JSON.parse(JSON.stringify(_this3.state[type]));
-            _settings.hours = parseInt(e.target.value, 10);
-            if (_settings.hours < 1) {
-              _settings.hours = 1;
-            }
-            _this3.setState((0, _defineProperty2["default"])({}, type, _settings), function () {
-              return _this3.recalcCron();
-            });
-          },
-          min: 1,
-          max: 24,
-          type: "number",
-          InputLabelProps: {
-            shrink: true
-          },
-          margin: "normal"
-        }));
-      }
-      return /*#__PURE__*/_react["default"].createElement("div", {
-        key: "period",
-        style: {
-          paddingLeft: 8,
-          display: 'inline-block'
-        }
-      }, /*#__PURE__*/_react["default"].createElement("h5", {
-        style: {
-          marginBottom: 5
-        }
-      }, _i18n["default"].t('sc_period')), /*#__PURE__*/_react["default"].createElement(_TextField["default"], {
-        variant: "standard",
-        style: {
-          marginTop: 0,
-          marginBottom: 0,
-          verticalAlign: 'bottom'
-        },
-        key: "value",
-        label: _i18n["default"].t('sc_every'),
-        value: settings.period,
-        onChange: function onChange(e) {
-          var _settings = JSON.parse(JSON.stringify(_this3.state[type]));
-          _settings.period = parseInt(e.target.value, 10);
-          if (_settings.period < 1) {
-            _settings.period = 1;
-          }
-          _this3.setState((0, _defineProperty2["default"])({}, type, _settings), function () {
-            return _this3.recalcCron();
-          });
-        },
-        min: 1,
-        max: 60,
-        type: "number",
-        InputLabelProps: {
-          shrink: true
-        },
-        margin: "normal"
-      }), /*#__PURE__*/_react["default"].createElement(_Select["default"], {
-        variant: "standard",
-        style: {
-          verticalAlign: 'bottom'
-        },
-        value: settings.unit,
-        onChange: function onChange(e) {
-          var _settings = JSON.parse(JSON.stringify(_this3.state[type]));
-          _settings.unit = e.target.value;
-          _this3.setState((0, _defineProperty2["default"])({}, type, _settings), function () {
-            return _this3.recalcCron();
-          });
-        }
-      }, Object.keys(PERIODIC_TYPES).map(function (mode) {
-        return /*#__PURE__*/_react["default"].createElement(_MenuItem["default"], {
-          key: PERIODIC_TYPES[mode],
-          value: PERIODIC_TYPES[mode]
-        }, _i18n["default"].t("sc_".concat(PERIODIC_TYPES[mode])));
-      })));
-    }
-  }, {
-    key: "getControlsTime",
-    value: function getControlsTime(type) {
-      var _this4 = this;
-      var settings = this.state[type];
-      return /*#__PURE__*/_react["default"].createElement(_FormControl["default"], {
-        variant: "standard",
-        className: this.props.classes.formControl,
-        classes: {
-          root: this.props.classes.formControlMarginRight
-        }
-      }, /*#__PURE__*/_react["default"].createElement(_TextField["default"], {
-        variant: "standard",
-        key: "at",
-        label: _i18n["default"].t('sc_time'),
-        value: settings.time,
-        type: "time",
-        onChange: function onChange(e) {
-          var _settings = JSON.parse(JSON.stringify(_this4.state[type]));
-          _settings.time = e.target.value;
-          _this4.setState((0, _defineProperty2["default"])({}, type, _settings), function () {
-            return _this4.recalcCron();
-          });
-        },
-        InputLabelProps: {
-          shrink: true
-        },
-        margin: "normal"
-      }));
-    }
-  }, {
-    key: "getControlsDate",
-    value: function getControlsDate(type) {
-      var _this5 = this;
-      var settings = this.state[type];
-      if (!settings.date) {
-        var d = new Date();
-        settings.date = "".concat(d.getDate(), ".").concat(padding(d.getMonth() + 1));
-      }
-
-      // <InputLabel htmlFor="formatted-text-mask-input">{I18n.t('sc_at')}</InputLabel>
-      return /*#__PURE__*/_react["default"].createElement(_FormControl["default"], {
-        variant: "standard",
-        className: this.props.classes.formControl
-      }, /*#__PURE__*/_react["default"].createElement(_TextField["default"], {
-        variant: "standard",
-        key: "date",
-        label: _i18n["default"].t('sc_date'),
-        value: settings.date,
-        type: "text",
-        inputProps: {
-          className: this.props.classes.formControlPaddingTop
-        },
-        onChange: function onChange(e) {
-          var _settings = JSON.parse(JSON.stringify(_this5.state[type]));
-          _settings.date = e.target.value;
-          _this5.setState((0, _defineProperty2["default"])({}, type, _settings), function () {
-            return _this5.recalcCron();
-          });
-        },
-        InputLabelProps: {
-          shrink: true
-        },
-        margin: "normal"
-      }));
-    }
-  }, {
-    key: "getOnceElements",
-    value: function getOnceElements() {
-      return /*#__PURE__*/_react["default"].createElement("div", {
-        style: {
-          marginLeft: 8
-        }
-      }, this.getControlsTime('once'), this.getControlsDate('once'));
-    }
-  }, {
-    key: "getIntervalElements",
-    value: function getIntervalElements() {
-      return this.getControlsPeriodElements('interval');
-    }
-  }, {
-    key: "getIntervalBetweenElements",
-    value: function getIntervalBetweenElements() {
-      var _this6 = this;
-      var settings = this.state.intervalBetween;
-      return [this.getControlsPeriodElements('intervalBetween'), /*#__PURE__*/_react["default"].createElement("div", {
-        key: "between",
-        style: {
-          paddingLeft: 8,
-          display: 'inline-block',
-          verticalAlign: 'top'
-        }
-      }, /*#__PURE__*/_react["default"].createElement("h5", {
-        style: {
-          marginBottom: 5
-        }
-      }, _i18n["default"].t('sc_hours')), /*#__PURE__*/_react["default"].createElement(_FormControl["default"], {
-        variant: "standard",
-        className: this.props.classes.formControl
-      }, /*#__PURE__*/_react["default"].createElement(_InputLabel["default"], {
-        shrink: true,
-        htmlFor: "age-label-placeholder"
-      }, _i18n["default"].t('sc_from')), /*#__PURE__*/_react["default"].createElement(_Select["default"], {
-        variant: "standard",
-        style: {
-          width: 100
-        },
-        value: settings.timeFrom,
-        onChange: function onChange(e) {
-          var _settings = JSON.parse(JSON.stringify(_this6.state.intervalBetween));
-          _settings.timeFrom = parseInt(e.target.value, 10);
-          _this6.setState({
-            intervalBetween: _settings
-          }, function () {
-            return _this6.recalcCron();
-          });
-        }
-      }, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23].map(function (hour) {
-        return /*#__PURE__*/_react["default"].createElement(_MenuItem["default"], {
-          key: "B_".concat(hour),
-          value: hour
-        }, "".concat(padding(hour), ":00"));
-      }))), /*#__PURE__*/_react["default"].createElement(_FormControl["default"], {
-        variant: "standard",
-        className: this.props.classes.formControl
-      }, /*#__PURE__*/_react["default"].createElement(_InputLabel["default"], {
-        shrink: true,
-        htmlFor: "age-label-placeholder"
-      }, _i18n["default"].t('sc_to')), /*#__PURE__*/_react["default"].createElement(_Select["default"], {
-        variant: "standard",
-        style: {
-          width: 100
-        },
-        value: settings.timeTo,
-        onChange: function onChange(e) {
-          var _settings = JSON.parse(JSON.stringify(_this6.state.intervalBetween));
-          _settings.timeTo = parseInt(e.target.value, 10);
-          _this6.setState({
-            intervalBetween: _settings
-          }, function () {
-            return _this6.recalcCron();
-          });
-        }
-      }, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24].map(function (hour) {
-        return /*#__PURE__*/_react["default"].createElement(_MenuItem["default"], {
-          key: "A_".concat(hour),
-          value: hour
-        }, "".concat(padding(hour), ":00"));
-      })))), this.getControlsWeekdaysElements('intervalBetween')];
-    }
-  }, {
-    key: "getSpecificTimeElements",
-    value: function getSpecificTimeElements() {
-      return [/*#__PURE__*/_react["default"].createElement("div", {
-        key: "time",
-        style: {
-          marginLeft: 8
-        }
-      }, this.getControlsTime('specific')), this.getControlsWeekdaysElements('specific')];
-    }
-  }, {
-    key: "onModeChange",
-    value: function onModeChange(mode) {
-      var _this7 = this;
-      if (mode !== this.state.mode) {
-        this.setState({
-          mode: mode
-        }, function () {
-          return _this7.recalcCron();
-        });
-      }
-    }
-  }, {
-    key: "onChange",
-    value: function onChange(cron) {
-      if (cron !== this.state.cron) {
-        this.setState({
-          cron: cron
-        });
-        this.props.onChange && this.props.onChange(cron);
-      }
-    }
-  }, {
-    key: "render",
-    value: function render() {
-      var _this8 = this;
-      return /*#__PURE__*/_react["default"].createElement("div", {
-        className: this.props.classes.mainDiv
-      }, /*#__PURE__*/_react["default"].createElement("div", {
-        style: {
-          paddingLeft: 8,
-          width: '100%'
-        }
-      }, /*#__PURE__*/_react["default"].createElement(_TextField["default"], {
-        style: {
-          width: '100%'
-        },
-        value: this.state.cron,
-        disabled: true
-      })), /*#__PURE__*/_react["default"].createElement("div", {
-        style: {
-          paddingLeft: 8,
-          width: '100%',
-          height: 60
-        }
-      }, (0, _cronText["default"])(this.state.cron, this.props.language || 'en')), /*#__PURE__*/_react["default"].createElement("div", null, /*#__PURE__*/_react["default"].createElement(_FormControl["default"], {
-        variant: "standard",
-        style: {
-          marginLeft: 8,
-          marginTop: 8
-        },
-        className: this.props.classes.formControl
-      }, /*#__PURE__*/_react["default"].createElement(_InputLabel["default"], null, _i18n["default"].t('ra_Repeat')), /*#__PURE__*/_react["default"].createElement(_Select["default"], {
-        variant: "standard",
-        value: this.state.mode,
-        onChange: function onChange(e) {
-          return _this8.onModeChange(e.target.value);
-        },
-        inputProps: {
-          name: 'mode',
-          id: 'mode'
-        }
-      }, Object.keys(PERIODIC).map(function (mode) {
-        return /*#__PURE__*/_react["default"].createElement(_MenuItem["default"], {
-          key: PERIODIC[mode],
-          value: PERIODIC[mode]
-        }, _i18n["default"].t("sc_".concat(PERIODIC[mode])));
-      })))), this.state.mode === PERIODIC.once && this.getOnceElements(), this.state.mode === PERIODIC.interval && this.getIntervalElements(), this.state.mode === PERIODIC.intervalBetween && this.getIntervalBetweenElements(), this.state.mode === PERIODIC.specific && this.getSpecificTimeElements());
-    }
-  }], [{
-    key: "periodArray2text",
-    value: function periodArray2text(list, max) {
-      max = max || 7;
-      if (list.length === max) {
-        return '*';
-      }
-      var text = [];
-      var start = null;
-      var end = null;
-      for (var i = 0; i < list.length; i++) {
-        if (start === null) {
-          start = list[i];
-          end = list[i];
-        } else if (list[i - 1] + 1 === list[i]) {
-          end = list[i];
-        } else {
-          if (start !== end) {
-            text.push("".concat(start, "-").concat(end));
-          } else {
-            text.push(start);
-          }
-          start = list[i];
-          end = list[i];
-        }
-      }
-      if (start !== end) {
-        text.push("".concat(start, "-").concat(end));
-      } else {
-        text.push(start);
-      }
-      return text.join(',');
-    }
-  }, {
-    key: "text2weekdays",
-    value: function text2weekdays(text) {
-      if (text === '*') {
-        return [0, 1, 2, 3, 4, 5, 6];
-      }
-      var parts = text.split(',');
-      var list = [];
-      parts.forEach(function (part) {
-        var _parts = part.split('-');
-        if (_parts.length === 2) {
-          var start = parseInt(_parts[0], 10);
-          var end = parseInt(_parts[1], 10);
-          for (var day = start; day <= end; day++) {
-            if (!list.includes(day === 7 ? 0 : day)) {
-              list.push(day === 7 ? 0 : day);
-            }
-          }
-        } else {
-          if (part === '7') {
-            part = 0;
-          }
-          part = parseInt(part, 10);
-          if (!list.includes(part)) {
-            list.push(part);
-          }
-        }
-      });
-      list.sort();
-      return list;
-    }
-  }, {
-    key: "cron2state",
-    value: function cron2state(cron) {
-      cron = cron.replace(/['"]/g, '').trim();
-      var cronParts = cron.split(' ');
-      var options = {};
-      var state = {
-        mode: ''
-      };
-      if (cronParts.length === 6) {
-        options.seconds = cronParts[0] || '*';
-        options.minutes = cronParts[1] || '*';
-        options.hours = cronParts[2] || '*';
-        options.date = cronParts[3] || '*';
-        options.months = cronParts[4] || '*';
-        options.dow = cronParts[5] || '*';
-      } else {
-        options.seconds = null;
-        options.minutes = cronParts[0] || '*';
-        options.hours = cronParts[1] || '*';
-        options.date = cronParts[2] || '*';
-        options.months = cronParts[3] || '*';
-        options.dow = cronParts[4] || '*';
-      }
-
-      // * * * * *
-      if (options.seconds === null && options.minutes === '*' && options.hours === '*' && options.date === '*' && options.months === '*') {
-        state.mode = PERIODIC.interval;
-        state.interval = {
-          period: 1,
-          unit: PERIODIC_TYPES.minutes
         };
-      } // * * * * * *
-      if (options.seconds === '*' && options.minutes === '*' && options.hours === '*' && options.date === '*' && options.months === '*') {
-        state.mode = PERIODIC.interval;
-        state.interval = {
-          period: 1,
-          unit: PERIODIC_TYPES.seconds
+    } // * * * * * *
+    if (options.seconds === '*' &&
+        options.minutes === '*' &&
+        options.hours === '*' &&
+        options.date === '*' &&
+        options.months === '*') {
+        state = {
+            mode: 'interval',
+            interval: {
+                period: 1,
+                unit: PERIODIC_TYPES.seconds,
+            },
         };
-      } else if (options.seconds === null && options.minutes.includes('/') && options.hours === '*' && options.date === '*' && options.months === '*') {
+    }
+    else if (options.seconds === null &&
+        options.minutes.includes('/') &&
+        options.hours === '*' &&
+        options.date === '*' &&
+        options.months === '*') {
         // */n * * * *
-        state.mode = PERIODIC.interval;
-        state.interval = {
-          period: parseInt(options.minutes.split('/')[1], 10),
-          unit: PERIODIC_TYPES.minutes
+        state = {
+            mode: 'interval',
+            interval: {
+                period: parseInt(options.minutes.split('/')[1], 10),
+                unit: PERIODIC_TYPES.minutes,
+            },
         };
-      } else if (options.seconds !== null && options.seconds.includes('/') && options.minutes === '*' && options.hours === '*' && options.date === '*' && options.months === '*') {
+    }
+    else if (options.seconds !== null &&
+        options.seconds.includes('/') &&
+        options.minutes === '*' &&
+        options.hours === '*' &&
+        options.date === '*' &&
+        options.months === '*') {
         // */n * * * * *
-        state.mode = PERIODIC.interval;
-        state.interval = {
-          period: parseInt(options.seconds.split('/')[1], 10),
-          unit: PERIODIC_TYPES.seconds
+        state = {
+            mode: 'interval',
+            interval: {
+                period: parseInt(options.seconds.split('/')[1], 10),
+                unit: PERIODIC_TYPES.seconds,
+            },
         };
-      } else if (options.seconds !== null && options.seconds.includes('/') && options.minutes === '*' && options.hours.includes('-') && options.date === '*' && options.months === '*') {
+    }
+    else if (options.seconds !== null &&
+        options.seconds.includes('/') &&
+        options.minutes === '*' &&
+        options.hours.includes('-') &&
+        options.date === '*' &&
+        options.months === '*') {
         // */n * 1-24 * * 1-7 or  */n * 1-24 * * *
-        state.mode = PERIODIC.intervalBetween;
-        state.intervalBetween = {
-          period: parseInt(options.seconds.split('/')[1], 10),
-          unit: PERIODIC_TYPES.seconds,
-          timeFrom: parseInt(options.hours.split('-')[0], 10),
-          timeTo: parseInt(options.hours.split('-')[1], 10),
-          weekdays: SimpleCron.text2weekdays(options.dow)
+        state = {
+            mode: 'intervalBetween',
+            intervalBetween: {
+                period: parseInt(options.seconds.split('/')[1], 10),
+                unit: PERIODIC_TYPES.seconds,
+                timeFrom: parseInt(options.hours.split('-')[0], 10),
+                timeTo: parseInt(options.hours.split('-')[1], 10),
+                weekdays: SimpleCron.text2weekdays(options.dow),
+            },
         };
-      } else if (options.seconds === null && options.minutes.includes('/') && options.hours.includes('-') && options.date === '*' && options.months === '*') {
+    }
+    else if (options.seconds === null &&
+        options.minutes.includes('/') &&
+        options.hours.includes('-') &&
+        options.date === '*' &&
+        options.months === '*') {
         // */n 1-24 * * 1-7 or  */n 1-24 * * *
-        state.mode = PERIODIC.intervalBetween;
-        state.intervalBetween = {
-          period: parseInt(options.minutes.split('/')[1], 10),
-          unit: PERIODIC_TYPES.minutes,
-          timeFrom: parseInt(options.hours.split('-')[0], 10),
-          timeTo: parseInt(options.hours.split('-')[1], 10),
-          weekdays: SimpleCron.text2weekdays(options.dow)
+        state = {
+            mode: 'intervalBetween',
+            intervalBetween: {
+                period: parseInt(options.minutes.split('/')[1], 10),
+                unit: PERIODIC_TYPES.minutes,
+                timeFrom: parseInt(options.hours.split('-')[0], 10),
+                timeTo: parseInt(options.hours.split('-')[1], 10),
+                weekdays: SimpleCron.text2weekdays(options.dow),
+            },
         };
-      } else if (options.seconds === null && parseInt(options.minutes, 10).toString() === options.minutes && parseInt(options.hours, 10).toString() === options.hours && options.date === '*' && options.months === '*') {
+    }
+    else if (options.seconds === null &&
+        parseInt(options.minutes, 10).toString() === options.minutes &&
+        parseInt(options.hours, 10).toString() === options.hours &&
+        options.date === '*' &&
+        options.months === '*') {
         // m h * * 1-7 or m h * * *
-        state.mode = PERIODIC.specific;
-        state.specific = {
-          time: "".concat(padding(parseInt(options.hours, 10)), ":").concat(padding(parseInt(options.minutes, 10))),
-          weekdays: SimpleCron.text2weekdays(options.dow)
+        state = {
+            mode: 'specific',
+            specific: {
+                time: `${padding(parseInt(options.hours, 10))}:${padding(parseInt(options.minutes, 10))}`,
+                weekdays: SimpleCron.text2weekdays(options.dow),
+            },
         };
-      } else if (options.seconds === null && parseInt(options.minutes, 10).toString() === options.minutes && parseInt(options.hours, 10).toString() === options.hours && parseInt(options.date, 10).toString() === options.date && parseInt(options.months, 10).toString() === options.months && options.dow === '*') {
+    }
+    else if (options.seconds === null &&
+        parseInt(options.minutes, 10).toString() === options.minutes &&
+        parseInt(options.hours, 10).toString() === options.hours &&
+        parseInt(options.date, 10).toString() === options.date &&
+        parseInt(options.months, 10).toString() === options.months &&
+        options.dow === '*') {
         // m h d M *
-        state.mode = PERIODIC.once;
-        state.once = {
-          time: "".concat(padding(parseInt(options.hours, 10)), ":").concat(padding(parseInt(options.minutes, 10))),
-          date: "".concat(padding(parseInt(options.date, 10)), ".").concat(padding(parseInt(options.months, 10))),
-          // ignored
-          weekdays: SimpleCron.text2weekdays(options.dow)
+        state = {
+            mode: 'once',
+            once: {
+                time: `${padding(parseInt(options.hours, 10))}:${padding(parseInt(options.minutes, 10))}`,
+                date: `${padding(parseInt(options.date, 10))}.${padding(parseInt(options.months, 10))}`,
+            },
         };
-      }
-      if (state.mode) {
-        return state;
-      }
-      return null;
     }
-  }, {
-    key: "state2cron",
-    value: function state2cron(state) {
-      var cron = '* * * * *';
-      if (state.mode === PERIODIC.interval) {
-        var settings = state.interval || {};
-        if (settings.period > 60) {
-          settings.period = 60;
+    return state;
+}
+exports.cron2state = cron2state;
+class SimpleCron extends react_1.default.Component {
+    constructor(props) {
+        super(props);
+        let cron = typeof props.cronExpression === 'string' ? props.cronExpression.replace(/^["']/, '').replace(/["']\n?$/, '') : '';
+        if (cron[0] === '{') {
+            cron = '';
         }
-        if (settings.period < 1) {
-          settings.period = 1;
+        const state = cron2state(cron || '* * * * *') || DEFAULT_STATE;
+        this.state = {
+            extended: false,
+            cron: SimpleCron.state2cron(state),
+            mode: 'interval',
+            once: {
+                time: '00:00',
+                date: '',
+            },
+            interval: {
+                period: 1,
+                unit: PERIODIC_TYPES.minutes,
+            },
+            intervalBetween: {
+                period: 1,
+                unit: PERIODIC_TYPES.minutes,
+                timeFrom: 0,
+                timeTo: 24,
+                weekdays: [0, 1, 2, 3, 4, 5, 6],
+            },
+            specific: {
+                time: '00:00',
+                weekdays: [0, 1, 2, 3, 4, 5, 6],
+            },
+        };
+        Object.assign(this.state, state);
+        if (this.state.cron !== props.cronExpression) {
+            setTimeout(() => props.onChange && props.onChange(this.state.cron), 100);
         }
-        if (settings.minutes > 60) {
-          settings.minutes = 60;
+    }
+    static periodArray2text(list, max = 7) {
+        max = max || 7;
+        if (list.length === max) {
+            return '*';
         }
-        if (settings.minutes < 1) {
-          settings.minutes = 1;
+        const text = [];
+        let start = null;
+        let end = null;
+        for (let i = 0; i < list.length; i++) {
+            if (start === null) {
+                start = list[i];
+                end = list[i];
+            }
+            else if (list[i - 1] + 1 === list[i]) {
+                end = list[i];
+            }
+            else {
+                if (start !== end) {
+                    text.push(`${start}-${end}`);
+                }
+                else {
+                    text.push(start);
+                }
+                start = list[i];
+                end = list[i];
+            }
         }
-        if (settings.hours > 24) {
-          settings.hours = 24;
+        if (start !== end) {
+            text.push(`${start}-${end}`);
         }
-        if (settings.hours < 1) {
-          settings.hours = 1;
+        else {
+            text.push(start);
         }
-        if (state.extended) {
-          cron = "".concat(settings.minutes > 1 ? "*/".concat(settings.minutes) : '*', " ").concat(settings.hours > 1 ? "*/".concat(settings.hours) : '*', " * * *");
-        } else {
-          switch (settings.unit) {
-            case PERIODIC_TYPES.seconds:
-              cron = "".concat(settings.period > 1 ? "*/".concat(settings.period) : '*', " * * * * *");
-              break;
-            case PERIODIC_TYPES.minutes:
-              cron = "".concat(settings.period > 1 ? "*/".concat(settings.period) : '*', " * * * *");
-              break;
-            default:
-              break;
-          }
+        return text.join(',');
+    }
+    static text2weekdays(text) {
+        if (text === '*') {
+            return [0, 1, 2, 3, 4, 5, 6];
         }
-      } else if (state.mode === PERIODIC.intervalBetween) {
-        var _settings2 = state.intervalBetween || {};
-        var hours;
-        _settings2.timeFrom = _settings2.timeFrom || 0;
-        _settings2.timeTo = _settings2.timeTo === undefined ? 24 : _settings2.timeTo;
-        if (_settings2.timeFrom === 0 && _settings2.timeTo === 24) {
-          hours = '*';
-        } else {
-          hours = _settings2.timeFrom !== _settings2.timeTo ? "".concat(_settings2.timeFrom, "-").concat(_settings2.timeTo) : '*';
+        const parts = text.split(',');
+        const list = [];
+        parts.forEach(part => {
+            const _parts = part.split('-');
+            if (_parts.length === 2) {
+                const start = parseInt(_parts[0], 10);
+                const end = parseInt(_parts[1], 10);
+                for (let day = start; day <= end; day++) {
+                    if (!list.includes(day === 7 ? 0 : day)) {
+                        list.push(day === 7 ? 0 : day);
+                    }
+                }
+            }
+            else {
+                if (part === '7') {
+                    part = '0';
+                }
+                const numPart = parseInt(part, 10);
+                if (!list.includes(numPart)) {
+                    list.push(numPart);
+                }
+            }
+        });
+        list.sort();
+        return list;
+    }
+    static state2cron(state) {
+        let cron = '* * * * *';
+        if (state.mode === 'interval') {
+            const settings = state.interval || {
+                period: 1,
+                unit: PERIODIC_TYPES.minutes,
+            };
+            if (settings.period !== undefined && settings.period > 60) {
+                settings.period = 60;
+            }
+            if (settings.period !== undefined && settings.period < 1) {
+                settings.period = 1;
+            }
+            if (settings.minutes !== undefined && settings.minutes !== null && settings.minutes > 60) {
+                settings.minutes = 60;
+            }
+            if (settings.minutes !== undefined && settings.minutes !== null && settings.minutes < 1) {
+                settings.minutes = 1;
+            }
+            if (settings.hours !== undefined && settings.hours !== null && settings.hours > 24) {
+                settings.hours = 24;
+            }
+            if (settings.hours !== undefined && settings.hours !== null && settings.hours < 1) {
+                settings.hours = 1;
+            }
+            if (state.extended) {
+                cron = `${settings.minutes !== undefined && settings.minutes !== null && settings.minutes > 1 ? `*/${settings.minutes}` : '*'} ${settings.hours !== undefined && settings.hours !== null && settings.hours > 1 ? `*/${settings.hours}` : '*'} * * *`;
+            }
+            else {
+                switch (settings.unit) {
+                    case PERIODIC_TYPES.seconds:
+                        cron = `${settings.period > 1 ? `*/${settings.period}` : '*'} * * * * *`;
+                        break;
+                    case PERIODIC_TYPES.minutes:
+                        cron = `${settings.period > 1 ? `*/${settings.period}` : '*'} * * * *`;
+                        break;
+                    default:
+                        break;
+                }
+            }
         }
-        if (_settings2.period > 60) _settings2.period = 60;
-        if (_settings2.period < 1) _settings2.period = 1;
-        _settings2.unit = _settings2.unit || PERIODIC_TYPES.minutes;
-        switch (_settings2.unit) {
-          case PERIODIC_TYPES.seconds:
-            cron = "".concat(_settings2.period > 1 ? "*/".concat(_settings2.period) : '*', " * ").concat(hours, " * * ").concat(this.periodArray2text(_settings2.weekdays));
-            break;
-          case PERIODIC_TYPES.minutes:
-            cron = "".concat(_settings2.period > 1 ? "*/".concat(_settings2.period) : '*', " ").concat(hours, " * * ").concat(this.periodArray2text(_settings2.weekdays));
-            break;
-          default:
-            break;
+        else if (state.mode === 'intervalBetween') {
+            const settings = state.intervalBetween || {
+                period: 1,
+                unit: PERIODIC_TYPES.minutes,
+                timeFrom: 0,
+                timeTo: 24,
+                weekdays: [0, 1, 2, 3, 4, 5, 6],
+            };
+            let hours;
+            settings.timeFrom = settings.timeFrom || 0;
+            settings.timeTo = settings.timeTo === undefined ? 24 : settings.timeTo;
+            if (settings.timeFrom === 0 && settings.timeTo === 24) {
+                hours = '*';
+            }
+            else {
+                hours = settings.timeFrom !== settings.timeTo ? `${settings.timeFrom}-${settings.timeTo}` : '*';
+            }
+            if (settings.period > 60)
+                settings.period = 60;
+            if (settings.period < 1)
+                settings.period = 1;
+            settings.unit = settings.unit || PERIODIC_TYPES.minutes;
+            switch (settings.unit) {
+                case PERIODIC_TYPES.seconds:
+                    cron = `${settings.period > 1 ? `*/${settings.period}` : '*'} * ${hours} * * ${this.periodArray2text(settings.weekdays)}`;
+                    break;
+                case PERIODIC_TYPES.minutes:
+                    cron = `${settings.period > 1 ? `*/${settings.period}` : '*'} ${hours} * * ${this.periodArray2text(settings.weekdays)}`;
+                    break;
+                default:
+                    break;
+            }
         }
-      } else if (state.mode === PERIODIC.specific) {
-        var _settings3 = state.specific || {};
-        var parts = (_settings3.time || '00:00').split(':');
-        var minutes = parseInt(parts[1], 10) || 0;
-        if (minutes > 59) minutes = 59;
-        if (minutes < 0) minutes = 0;
-        var _hours = parseInt(parts[0], 10) || 0;
-        if (_hours > 23) _hours = 59;
-        if (_hours < 0) _hours = 0;
-        cron = "".concat(minutes, " ").concat(_hours, " * * ").concat(this.periodArray2text(_settings3.weekdays || []));
-      } else if (state.mode === PERIODIC.once) {
-        var _settings4 = state.once || {};
-        if (!_settings4.date) {
-          _settings4.date = "".concat(new Date().getDate(), ".").concat(padding(new Date().getMonth() + 1));
+        else if (state.mode === 'specific') {
+            const settings = state.specific || {
+                time: '00:00',
+                weekdays: [0, 1, 2, 3, 4, 5, 6],
+            };
+            const parts = (settings.time || '00:00').split(':');
+            let minutes = parseInt(parts[1], 10) || 0;
+            if (minutes > 59)
+                minutes = 59;
+            if (minutes < 0)
+                minutes = 0;
+            let hours = parseInt(parts[0], 10) || 0;
+            if (hours > 23)
+                hours = 59;
+            if (hours < 0)
+                hours = 0;
+            cron = `${minutes} ${hours} * * ${this.periodArray2text(settings.weekdays || [])}`;
         }
-        var _parts2 = (_settings4.time || '00:00').split(':');
-        var partsDate = _settings4.date.split('.');
-        var _minutes = parseInt(_parts2[1], 10) || 0;
-        if (_minutes > 59) _minutes = 59;
-        if (_minutes < 0) _minutes = 0;
-        var _hours2 = parseInt(_parts2[0], 10) || 0;
-        if (_hours2 > 23) _hours2 = 59;
-        if (_hours2 < 0) _hours2 = 0;
-        var date = parseInt(partsDate[0], 10) || 1;
-        if (date > 31) date = 31;
-        if (date < 1) _hours2 = 1;
-        var month = parseInt(partsDate[1], 10) || 1;
-        if (month > 12) month = 12;
-        if (month < 1) month = 1;
-        cron = "".concat(_minutes, " ").concat(_hours2, " ").concat(date, " ").concat(month, " *");
-      }
-      return cron;
+        else if (state.mode === 'once') {
+            const settings = state.once || {
+                time: '00:00',
+                date: '',
+            };
+            if (!settings.date) {
+                settings.date = `${new Date().getDate()}.${padding(new Date().getMonth() + 1)}`;
+            }
+            const parts = (settings.time || '00:00').split(':');
+            const partsDate = settings.date.split('.');
+            let minutes = parseInt(parts[1], 10) || 0;
+            if (minutes > 59)
+                minutes = 59;
+            if (minutes < 0)
+                minutes = 0;
+            let hours = parseInt(parts[0], 10) || 0;
+            if (hours > 23)
+                hours = 59;
+            if (hours < 0)
+                hours = 0;
+            let date = parseInt(partsDate[0], 10) || 1;
+            if (date > 31)
+                date = 31;
+            if (date < 1)
+                hours = 1;
+            let month = parseInt(partsDate[1], 10) || 1;
+            if (month > 12)
+                month = 12;
+            if (month < 1)
+                month = 1;
+            cron = `${minutes} ${hours} ${date} ${month} *`;
+        }
+        return cron;
     }
-  }]);
-  return SimpleCron;
-}(_react["default"].Component);
-SimpleCron.propTypes = {
-  cronExpression: _propTypes["default"].string,
-  onChange: _propTypes["default"].func,
-  language: _propTypes["default"].string
-};
-var _default = exports["default"] = (0, _styles.withStyles)(styles)(SimpleCron);
-//# sourceMappingURL=index.js.map
+    recalcCron() {
+        this.onChange(SimpleCron.state2cron(this.state));
+    }
+    getControlsWeekdaysElements(type) {
+        const settings = type === 'intervalBetween' ? this.state.intervalBetween : this.state.specific;
+        return react_1.default.createElement("div", { key: "weekdays", style: { paddingLeft: 8, width: '100%', maxWidth: 600 } },
+            react_1.default.createElement("h5", null, i18n_1.default.t('ra_On weekdays')),
+            [1, 2, 3, 4, 5, 6, 0].map(day => (react_1.default.createElement(FormControlLabel_1.default, { key: WEEKDAYS[day], control: react_1.default.createElement(Checkbox_1.default, { checked: settings.weekdays.includes(day), onChange: e => {
+                        const _settings = JSON.parse(JSON.stringify(this.state[type]));
+                        const pos = _settings.weekdays.indexOf(day);
+                        e.target.checked && pos === -1 && _settings.weekdays.push(day);
+                        !e.target.checked && pos !== -1 && _settings.weekdays.splice(pos, 1);
+                        _settings.weekdays.sort();
+                        if (type === 'intervalBetween') {
+                            this.setState({ intervalBetween: _settings }, () => this.recalcCron());
+                        }
+                        else {
+                            this.setState({ specific: _settings }, () => this.recalcCron());
+                        }
+                    }, value: day.toString() }), label: i18n_1.default.t(WEEKDAYS[day]) }))));
+    }
+    getControlsPeriodElements(type) {
+        const settings = type === 'interval' ? this.state.interval : this.state.intervalBetween;
+        if (this.state.extended) {
+            return react_1.default.createElement("div", { key: "period", style: { paddingLeft: 8, display: 'inline-block' } },
+                react_1.default.createElement("h5", { style: { marginBottom: 5 } }, i18n_1.default.t('sc_period')),
+                react_1.default.createElement(TextField_1.default, { variant: "standard", style: { marginTop: 0, marginBottom: 0, verticalAlign: 'bottom' }, key: "value", label: i18n_1.default.t('sc_minutes'), value: settings.minutes, onChange: e => {
+                        const _settings = JSON.parse(JSON.stringify(this.state[type]));
+                        _settings.minutes = parseInt(e.target.value, 10);
+                        if (_settings.minutes < 1) {
+                            _settings.minutes = 1;
+                        }
+                        if (type === 'interval') {
+                            this.setState({ interval: _settings }, () => this.recalcCron());
+                        }
+                        else {
+                            this.setState({ intervalBetween: _settings }, () => this.recalcCron());
+                        }
+                    }, InputProps: { inputProps: { min: 1, max: 60 } }, type: "number", InputLabelProps: { shrink: true }, margin: "normal" }),
+                react_1.default.createElement(TextField_1.default, { variant: "standard", style: { marginTop: 0, marginBottom: 0, verticalAlign: 'bottom' }, key: "value", label: i18n_1.default.t('sc_hours'), value: settings.hours, onChange: e => {
+                        const _settings = JSON.parse(JSON.stringify(this.state[type]));
+                        _settings.hours = parseInt(e.target.value, 10);
+                        if (_settings.hours < 1) {
+                            _settings.hours = 1;
+                        }
+                        if (type === 'interval') {
+                            this.setState({ interval: _settings }, () => this.recalcCron());
+                        }
+                        else {
+                            this.setState({ intervalBetween: _settings }, () => this.recalcCron());
+                        }
+                    }, InputProps: { inputProps: { min: 1, max: 24 } }, type: "number", InputLabelProps: { shrink: true }, margin: "normal" }));
+        }
+        return react_1.default.createElement("div", { key: "period", style: { paddingLeft: 8, display: 'inline-block' } },
+            react_1.default.createElement("h5", { style: { marginBottom: 5 } }, i18n_1.default.t('sc_period')),
+            react_1.default.createElement(TextField_1.default, { variant: "standard", style: { marginTop: 0, marginBottom: 0, verticalAlign: 'bottom' }, key: "value", label: i18n_1.default.t('sc_every'), value: settings.period, onChange: e => {
+                    const _settings = JSON.parse(JSON.stringify(this.state[type]));
+                    _settings.period = parseInt(e.target.value, 10);
+                    if (_settings.period < 1) {
+                        _settings.period = 1;
+                    }
+                    if (type === 'interval') {
+                        this.setState({ interval: _settings }, () => this.recalcCron());
+                    }
+                    else {
+                        this.setState({ intervalBetween: _settings }, () => this.recalcCron());
+                    }
+                }, InputProps: { inputProps: { min: 1, max: 60 } }, type: "number", InputLabelProps: { shrink: true }, margin: "normal" }),
+            react_1.default.createElement(Select_1.default, { variant: "standard", style: { verticalAlign: 'bottom' }, value: settings.unit, onChange: e => {
+                    const _settings = JSON.parse(JSON.stringify(this.state[type]));
+                    _settings.unit = e.target.value;
+                    if (type === 'interval') {
+                        this.setState({ interval: _settings }, () => this.recalcCron());
+                    }
+                    else {
+                        this.setState({ intervalBetween: _settings }, () => this.recalcCron());
+                    }
+                } },
+                react_1.default.createElement(MenuItem_1.default, { value: "seconds" }, i18n_1.default.t('sc_seconds')),
+                ")",
+                react_1.default.createElement(MenuItem_1.default, { value: "minutes" }, i18n_1.default.t('sc_minutes')),
+                ")"));
+    }
+    getControlsTime(type) {
+        const settings = type === 'once' ? this.state.once : this.state.specific;
+        return react_1.default.createElement(FormControl_1.default, { variant: "standard", className: this.props.classes.formControl, classes: { root: this.props.classes.formControlMarginRight } },
+            react_1.default.createElement(TextField_1.default, { variant: "standard", key: "at", label: i18n_1.default.t('sc_time'), value: settings.time, type: "time", onChange: e => {
+                    const _settings = JSON.parse(JSON.stringify(this.state[type]));
+                    _settings.time = e.target.value;
+                    if (type === 'once') {
+                        this.setState({ once: _settings }, () => this.recalcCron());
+                    }
+                    else {
+                        this.setState({ specific: _settings }, () => this.recalcCron());
+                    }
+                }, InputLabelProps: { shrink: true }, margin: "normal" }));
+    }
+    getControlsDate() {
+        const settings = this.state.once;
+        if (!settings.date) {
+            const d = new Date();
+            settings.date = `${d.getDate()}.${padding(d.getMonth() + 1)}`;
+        }
+        // <InputLabel htmlFor="formatted-text-mask-input">{I18n.t('sc_at')}</InputLabel>
+        return react_1.default.createElement(FormControl_1.default, { variant: "standard", className: this.props.classes.formControl },
+            react_1.default.createElement(TextField_1.default, { variant: "standard", key: "date", label: i18n_1.default.t('sc_date'), value: settings.date, type: "text", inputProps: { className: this.props.classes.formControlPaddingTop }, onChange: e => {
+                    const _settings = JSON.parse(JSON.stringify(this.state.once));
+                    _settings.date = e.target.value;
+                    this.setState({ once: _settings }, () => this.recalcCron());
+                }, InputLabelProps: { shrink: true }, margin: "normal" }));
+    }
+    getOnceElements() {
+        return react_1.default.createElement("div", { style: { marginLeft: 8 } },
+            this.getControlsTime('once'),
+            this.getControlsDate());
+    }
+    getIntervalElements() {
+        return this.getControlsPeriodElements('interval');
+    }
+    getIntervalBetweenElements() {
+        const settings = this.state.intervalBetween;
+        return [
+            this.getControlsPeriodElements('intervalBetween'),
+            react_1.default.createElement("div", { key: "between", style: { paddingLeft: 8, display: 'inline-block', verticalAlign: 'top' } },
+                react_1.default.createElement("h5", { style: { marginBottom: 5 } }, i18n_1.default.t('sc_hours')),
+                react_1.default.createElement(FormControl_1.default, { variant: "standard", className: this.props.classes.formControl },
+                    react_1.default.createElement(InputLabel_1.default, { shrink: true, htmlFor: "age-label-placeholder" }, i18n_1.default.t('sc_from')),
+                    react_1.default.createElement(Select_1.default, { variant: "standard", style: { width: 100 }, value: settings.timeFrom, onChange: e => {
+                            const _settings = JSON.parse(JSON.stringify(this.state.intervalBetween));
+                            _settings.timeFrom = parseInt(e.target.value, 10);
+                            this.setState({ intervalBetween: _settings }, () => this.recalcCron());
+                        } }, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23].map(hour => react_1.default.createElement(MenuItem_1.default, { key: `B_${hour}`, value: hour }, `${padding(hour)}:00`)))),
+                react_1.default.createElement(FormControl_1.default, { variant: "standard", className: this.props.classes.formControl },
+                    react_1.default.createElement(InputLabel_1.default, { shrink: true, htmlFor: "age-label-placeholder" }, i18n_1.default.t('sc_to')),
+                    react_1.default.createElement(Select_1.default, { variant: "standard", style: { width: 100 }, value: settings.timeTo, onChange: e => {
+                            const _settings = JSON.parse(JSON.stringify(this.state.intervalBetween));
+                            _settings.timeTo = parseInt(e.target.value, 10);
+                            this.setState({ intervalBetween: _settings }, () => this.recalcCron());
+                        } }, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24].map(hour => (react_1.default.createElement(MenuItem_1.default, { key: `A_${hour}`, value: hour }, `${padding(hour)}:00`)))))),
+            this.getControlsWeekdaysElements('intervalBetween'),
+        ];
+    }
+    getSpecificTimeElements() {
+        return [
+            react_1.default.createElement("div", { key: "time", style: { marginLeft: 8 } }, this.getControlsTime('specific')),
+            this.getControlsWeekdaysElements('specific'),
+        ];
+    }
+    onModeChange(mode) {
+        if (mode !== this.state.mode) {
+            this.setState({ mode }, () => this.recalcCron());
+        }
+    }
+    onChange(cron) {
+        if (cron !== this.state.cron) {
+            this.setState({ cron });
+            this.props.onChange && this.props.onChange(cron);
+        }
+    }
+    render() {
+        return react_1.default.createElement("div", { className: this.props.classes.mainDiv },
+            react_1.default.createElement("div", { style: { paddingLeft: 8, width: '100%' } },
+                react_1.default.createElement(TextField_1.default, { style: { width: '100%' }, value: this.state.cron, disabled: true })),
+            react_1.default.createElement("div", { style: { paddingLeft: 8, width: '100%', height: 60 } }, (0, cronText_1.default)(this.state.cron, this.props.language || 'en')),
+            react_1.default.createElement("div", null,
+                react_1.default.createElement(FormControl_1.default, { variant: "standard", style: { marginLeft: 8, marginTop: 8 }, className: this.props.classes.formControl },
+                    react_1.default.createElement(InputLabel_1.default, null, i18n_1.default.t('ra_Repeat')),
+                    react_1.default.createElement(Select_1.default, { variant: "standard", value: this.state.mode, onChange: e => this.onModeChange(e.target.value), inputProps: { name: 'mode', id: 'mode' } },
+                        react_1.default.createElement(MenuItem_1.default, { value: "once" }, i18n_1.default.t('sc_once')),
+                        react_1.default.createElement(MenuItem_1.default, { value: "interval" }, i18n_1.default.t('sc_interval')),
+                        react_1.default.createElement(MenuItem_1.default, { value: "intervalBetween" }, i18n_1.default.t('sc_intervalBetween')),
+                        react_1.default.createElement(MenuItem_1.default, { value: "specific" }, i18n_1.default.t('sc_specific'))))),
+            this.state.mode === PERIODIC.once && this.getOnceElements(),
+            this.state.mode === 'interval' && this.getIntervalElements(),
+            this.state.mode === 'intervalBetween' && this.getIntervalBetweenElements(),
+            this.state.mode === 'specific' && this.getSpecificTimeElements());
+    }
+}
+exports.default = (0, styles_1.withStyles)(styles)(SimpleCron);