@iobroker/adapter-react-v5 0.0.2

package/Components/SimpleCron/index.js

@@ -0,0 +1,861 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _withStyles = _interopRequireDefault(require("@mui/styles/withStyles"));
+
+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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var styles = function styles(theme) {
+  return {
+    mainDiv: {
+      width: '100%',
+      height: '100%',
+      overflow: 'auto'
+    },
+    formControl: {
+      margin: 0,
+      minWidth: 120
+    },
+    formControlMarginRight: {
+      marginRight: 5
+    },
+    formControlPaddingTop: {
+      paddingTop: 6.2
+    }
+  };
+};
+
+var PERIODIC = {
+  once: 'once',
+  interval: 'interval',
+  intervalBetween: 'intervalBetween',
+  specific: 'specific'
+};
+var PERIODIC_TYPES = {
+  seconds: 'seconds',
+  minutes: 'minutes' //hours: 'hours',
+
+};
+var WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'];
+
+function padding(num) {
+  if (num < 10) {
+    return '0' + num;
+  } else {
+    return '' + num;
+  }
+}
+
+var DEFAULT_STATE = {
+  mode: PERIODIC.interval,
+  interval: {
+    period: 1,
+    unit: PERIODIC_TYPES.minutes
+  }
+};
+
+var SimpleCron = /*#__PURE__*/function (_React$Component) {
+  _inherits(SimpleCron, _React$Component);
+
+  var _super = _createSuper(SimpleCron);
+
+  function SimpleCron(props) {
+    var _this;
+
+    _classCallCheck(this, SimpleCron);
+
+    _this = _super.call(this, props);
+    var cron = typeof _this.props.cronExpression === 'string' ? _this.props.cronExpression.replace(/^["']/, '').replace(/["']\n?$/, '') : '';
+
+    if (cron[0] === '{') {
+      cron = '';
+    }
+
+    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: {
+        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);
+    }
+
+    return _this;
+  }
+
+  _createClass(SimpleCron, [{
+    key: "recalcCron",
+    value: function recalcCron() {
+      this.onChange(SimpleCron.state2cron(this.state));
+    }
+  }, {
+    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(_defineProperty({}, type, settings), function () {
+                return _this2.recalcCron();
+              });
+            },
+            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(_defineProperty({}, 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(_defineProperty({}, type, settings), function () {
+              return _this3.recalcCron();
+            });
+          },
+          min: 1,
+          max: 24,
+          type: "number",
+          InputLabelProps: {
+            shrink: true
+          },
+          margin: "normal"
+        }));
+      } else {
+        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(_defineProperty({}, 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(_defineProperty({}, 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_' + 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(_defineProperty({}, 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 = d.getDate() + '.' + 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(_defineProperty({}, 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_' + hour,
+          value: hour
+        }, 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_' + hour,
+          value: hour
+        }, 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_' + 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 '*';
+      } else {
+        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(start + '-' + end);
+            } else {
+              text.push(start);
+            }
+
+            start = list[i];
+            end = list[i];
+          }
+        }
+
+        if (start !== end) {
+          text.push(start + '-' + 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.indexOf(day === 7 ? 0 : day) === -1) {
+              list.push(day === 7 ? 0 : day);
+            }
+          }
+        } else {
+          if (part === '7') {
+            part = 0;
+          }
+
+          part = parseInt(part, 10);
+
+          if (list.indexOf(part) === -1) {
+            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
+        };
+      } else // */n * * * *
+        if (options.seconds === null && options.minutes.indexOf('/') !== -1 && options.hours === '*' && options.date === '*' && options.months === '*') {
+          state.mode = PERIODIC.interval;
+          state.interval = {
+            period: parseInt(options.minutes.split('/')[1], 10),
+            unit: PERIODIC_TYPES.minutes
+          };
+        } else // */n * * * * *
+          if (options.seconds !== null && options.seconds.indexOf('/') !== -1 && options.minutes === '*' && options.hours === '*' && options.date === '*' && options.months === '*') {
+            state.mode = PERIODIC.interval;
+            state.interval = {
+              period: parseInt(options.seconds.split('/')[1], 10),
+              unit: PERIODIC_TYPES.seconds
+            };
+          } else // */n * 1-24 * * 1-7 or  */n * 1-24 * * *
+            if (options.seconds !== null && options.seconds.indexOf('/') !== -1 && options.minutes === '*' && options.hours.indexOf('-') !== -1 && options.date === '*' && options.months === '*') {
+              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)
+              };
+            } else // */n 1-24 * * 1-7 or  */n 1-24 * * *
+              if (options.seconds === null && options.minutes.indexOf('/') !== -1 && options.hours.indexOf('-') !== -1 && options.date === '*' && options.months === '*') {
+                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)
+                };
+              } else // m h * * 1-7 or m h * * *
+                if (options.seconds === null && parseInt(options.minutes, 10).toString() === options.minutes && parseInt(options.hours, 10).toString() === options.hours && options.date === '*' && options.months === '*') {
+                  state.mode = PERIODIC.specific;
+                  state.specific = {
+                    time: padding(parseInt(options.hours, 10)) + ':' + padding(parseInt(options.minutes, 10)),
+                    weekdays: SimpleCron.text2weekdays(options.dow)
+                  };
+                } else // m h d M *
+                  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 === '*') {
+                    state.mode = PERIODIC.once;
+                    state.once = {
+                      time: padding(parseInt(options.hours, 10)) + ':' + padding(parseInt(options.minutes, 10)),
+                      date: padding(parseInt(options.date, 10)) + '.' + padding(parseInt(options.months, 10)),
+                      // ignored
+                      weekdays: SimpleCron.text2weekdays(options.dow)
+                    };
+                  }
+
+      if (state.mode) {
+        return state;
+      } else {
+        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;
+        if (settings.period < 1) settings.period = 1;
+        if (settings.minutes > 60) settings.minutes = 60;
+        if (settings.minutes < 1) settings.minutes = 1;
+        if (settings.hours > 24) settings.hours = 24;
+        if (settings.hours < 1) settings.hours = 1;
+
+        if (state.extended) {
+          cron = "".concat(settings.minutes > 1 ? '*/' + settings.minutes : '*', " ").concat(settings.hours > 1 ? '*/' + settings.hours : '*', " * * *");
+        } else {
+          switch (settings.unit) {
+            case PERIODIC_TYPES.seconds:
+              cron = "".concat(settings.period > 1 ? '*/' + settings.period : '*', " * * * * *");
+              break;
+
+            case PERIODIC_TYPES.minutes:
+              cron = "".concat(settings.period > 1 ? '*/' + settings.period : '*', " * * * *");
+              break;
+
+            default:
+              break;
+          }
+        }
+      } else if (state.mode === PERIODIC.intervalBetween) {
+        var _settings = state.intervalBetween || {};
+
+        var 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 = "".concat(_settings.period > 1 ? '*/' + _settings.period : '*', " * ").concat(hours, " * * ").concat(this.periodArray2text(_settings.weekdays));
+            break;
+
+          case PERIODIC_TYPES.minutes:
+            cron = "".concat(_settings.period > 1 ? '*/' + _settings.period : '*', " ").concat(hours, " * * ").concat(this.periodArray2text(_settings.weekdays));
+            break;
+
+          default:
+            break;
+        }
+      } else if (state.mode === PERIODIC.specific) {
+        var _settings2 = state.specific || {};
+
+        var parts = (_settings2.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(_settings2.weekdays || []));
+      } else if (state.mode === PERIODIC.once) {
+        var _settings3 = state.once || {};
+
+        if (!_settings3.date) {
+          _settings3.date = new Date().getDate() + '.' + padding(new Date().getMonth() + 1);
+        }
+
+        var _parts2 = (_settings3.time || '00:00').split(':');
+
+        var partsDate = _settings3.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;
+    }
+  }]);
+
+  return SimpleCron;
+}(_react["default"].Component);
+
+SimpleCron.propTypes = {
+  cronExpression: _propTypes["default"].string,
+  onChange: _propTypes["default"].func,
+  language: _propTypes["default"].string
+};
+
+var _default = (0, _withStyles["default"])(styles)(SimpleCron);
+
+exports["default"] = _default;
+//# sourceMappingURL=index.js.map