@configuratorware/configurator-admingui 1.28.3 → 1.29.1

package/Components/ListColumnFilter.js

@@ -0,0 +1,258 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _InputHelpers = require("../Components/InputHelpers");
+
+var _i18n = require("../App/i18n");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _SearchIcon = _interopRequireDefault(require("../UIComponents/icons/SearchIcon"));
+
+var _Tooltip = _interopRequireDefault(require("../UIComponents/Tooltip"));
+
+var _TableSortLabel = _interopRequireDefault(require("../UIComponents/TableSortLabel"));
+
+var _withStyles = _interopRequireDefault(require("@material-ui/core/styles/withStyles"));
+
+var _Input = _interopRequireDefault(require("../UIComponents/Input"));
+
+var _FormControl = _interopRequireDefault(require("../UIComponents/FormControl"));
+
+var _InputLabel = _interopRequireDefault(require("../UIComponents/InputLabel"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": 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); 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 } }); 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; } 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); }
+
+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; }
+
+var styles = function styles() {
+  return {
+    sortLabelIcon: {
+      opacity: 0.5
+    },
+    columnFilterButton: {
+      opacity: 0.5
+    },
+    columnFilterButtonActive: {
+      opacity: 1
+    },
+    formControlRoot: {
+      verticalAlign: 'middle',
+      top: -8,
+      maxWidth: 'calc(100% - 56px)',
+      minWidth: 50
+    },
+    columnText: {
+      display: 'inline-block',
+      maxWidth: 'calc(100% - 56px)',
+      overflow: 'hidden',
+      textOverflow: 'ellipsis',
+      verticalAlign: 'middle'
+    },
+    inputLabelRoot: {
+      maxWidth: '100%',
+      minWidth: 50,
+      overflow: 'hidden',
+      textOverflow: 'ellipsis'
+    },
+    inputLabelShrink: {
+      textOverflow: 'unset',
+      overflow: 'visible'
+    }
+  };
+};
+
+var ListColumnFilter = /*#__PURE__*/function (_React$Component) {
+  _inherits(ListColumnFilter, _React$Component);
+
+  var _super = _createSuper(ListColumnFilter);
+
+  function ListColumnFilter(props) {
+    var _this;
+
+    _classCallCheck(this, ListColumnFilter);
+
+    _this = _super.call(this, props);
+
+    _defineProperty(_assertThisInitialized(_this), "onToggleFilter", function () {
+      _this.setState({
+        open: !_this.state.open,
+        value: null
+      }, function () {
+        if (_this.state.open) {
+          _this.inputRef.current.focus();
+        } else {
+          _this.props.onFilterChange(_this.props.name, _this.state.value, _this.props.filterKey);
+        }
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "onChange", (0, _InputHelpers.delay)(function (value) {
+      return _this.setState({
+        value: value
+      }, function () {
+        return _this.props.onFilterChange(_this.props.name, _this.state.value, _this.props.filterKey);
+      });
+    }));
+
+    _defineProperty(_assertThisInitialized(_this), "onBlur", function () {
+      return setTimeout(function () {
+        return !_this.state.value && _this.setState({
+          open: false
+        });
+      }, 500);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "onToggleSort", function () {
+      return _this.setState({
+        sort: _this.state.sort ? {
+          asc: 'desc',
+          desc: null
+        }[_this.state.sort] : 'asc'
+      }, function () {
+        return _this.props.onSortChange(_this.props.name, _this.state.sort, _this.props.sortKey);
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "inputRef", /*#__PURE__*/_react["default"].createRef());
+
+    _defineProperty(_assertThisInitialized(_this), "renderField", function () {
+      var label = (0, _i18n.T)(_this.props.label);
+      var _this$props = _this.props,
+          filterable = _this$props.filterable,
+          sortable = _this$props.sortable,
+          name = _this$props.name,
+          classes = _this$props.classes;
+
+      if (!_this.state.open) {
+        var className = '';
+
+        if (sortable && filterable) {
+          className = classes.columnText;
+        }
+
+        return /*#__PURE__*/_react["default"].createElement("span", {
+          className: className,
+          onClick: filterable ? _this.onToggleFilter : undefined
+        }, label);
+      }
+
+      var id = "filter-".concat(name);
+
+      switch (_lodash["default"].isObject(filterable) ? filterable.type : true) {
+        case 'select':
+          throw new Error('Select type not implemented yet');
+
+        default:
+          return /*#__PURE__*/_react["default"].createElement(_FormControl["default"], {
+            classes: {
+              root: classes.formControlRoot
+            }
+          }, /*#__PURE__*/_react["default"].createElement(_InputLabel["default"], {
+            htmlFor: id,
+            classes: {
+              root: classes.inputLabelRoot,
+              shrink: classes.inputLabelShrink
+            }
+          }, label), /*#__PURE__*/_react["default"].createElement(_Input["default"], {
+            id: id,
+            inputRef: _this.inputRef,
+            placeholder: 'Filter',
+            onChange: function onChange(evt) {
+              return _this.onChange(evt.target.value);
+            },
+            onBlur: _this.onBlur,
+            disableUnderline: true
+          }));
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "renderSort", function () {
+      var sort = _this.state.sort;
+      var classes = _this.props.classes;
+      return /*#__PURE__*/_react["default"].createElement(_Tooltip["default"], {
+        title: "Sort",
+        enterDelay: 300
+      }, /*#__PURE__*/_react["default"].createElement(_TableSortLabel["default"], {
+        active: sort !== null,
+        direction: sort || 'asc',
+        onClick: _this.onToggleSort,
+        classes: {
+          icon: classes.sortLabelIcon
+        }
+      }));
+    });
+
+    _this.state = {
+      open: false,
+      value: null,
+      sort: props.sort || null
+    };
+    return _this;
+  }
+
+  _createClass(ListColumnFilter, [{
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      if (!this.props.sort && prevProps.sort !== this.props.sort) {
+        this.setState({
+          sort: null
+        });
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props2 = this.props,
+          filterable = _this$props2.filterable,
+          sortable = _this$props2.sortable,
+          classes = _this$props2.classes;
+      var open = this.state.open;
+      return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, filterable && /*#__PURE__*/_react["default"].createElement(_Tooltip["default"], {
+        title: "Filter",
+        enterDelay: 300
+      }, /*#__PURE__*/_react["default"].createElement(_TableSortLabel["default"], {
+        active: open,
+        onClick: this.onToggleFilter,
+        classes: {
+          icon: classes.sortLabelIcon
+        },
+        IconComponent: _SearchIcon["default"]
+      })), this.renderField(), sortable && this.renderSort());
+    }
+  }]);
+
+  return ListColumnFilter;
+}(_react["default"].Component);
+
+var _default = (0, _withStyles["default"])(styles)(ListColumnFilter);
+
+exports["default"] = _default;

package/Components/LocaleSwitch.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.LocaleSwitch = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _reactRedux = require("react-redux");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _IconMenu = _interopRequireDefault(require("../UIComponents/IconMenu"));
+
+var _LanguageIcon = _interopRequireDefault(require("../UIComponents/icons/LanguageIcon"));
+
+var _app = require("../App/Config/app");
+
+var _i18n = require("../App/i18n");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var LocaleSwitch = function LocaleSwitch(props) {
+  var locale = props.locale,
+      updateLocale = props.updateLocale;
+  return /*#__PURE__*/_react["default"].createElement(_IconMenu["default"], {
+    buttonText: locale.label,
+    iconComponent: _LanguageIcon["default"],
+    source: _app.locales.filter(function (l) {
+      return l !== locale;
+    }),
+    renderLabel: "label",
+    onSelect: function onSelect(localeObj) {
+      (0, _i18n.changeLocale)(localeObj.code);
+      updateLocale(localeObj.code);
+    },
+    disablePortal: true
+  });
+};
+
+exports.LocaleSwitch = LocaleSwitch;
+LocaleSwitch.muiName = 'FlatButton';
+
+var mapStateToProps = function mapStateToProps(state) {
+  return {
+    code: state.i18n.locale,
+    locale: _lodash["default"].find(_app.locales, {
+      code: state.i18n.locale
+    })
+  };
+};
+
+exports.LocaleSwitch = LocaleSwitch = (0, _reactRedux.connect)(mapStateToProps)(LocaleSwitch);
+var _default = LocaleSwitch;
+exports["default"] = _default;

package/Components/LocalizedPriceTextField.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LocalizedPriceTextField = void 0;
+
+var _reactRedux = require("react-redux");
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+var _Text = _interopRequireDefault(require("./FormFragments/Text"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _Utils = require("../App/Utils");
+
+var _excluded = ["value", "label", "name", "helperText", "emptyValue", "multiLine", "readOnly", "rows", "error", "inputProps"];
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+var LocalizedPriceTextField = function LocalizedPriceTextField(_ref) {
+  var value = _ref.value,
+      label = _ref.label,
+      name = _ref.name,
+      helperText = _ref.helperText,
+      emptyValue = _ref.emptyValue,
+      multiLine = _ref.multiLine,
+      readOnly = _ref.readOnly,
+      rows = _ref.rows,
+      error = _ref.error,
+      inputProps = _ref.inputProps,
+      props = _objectWithoutProperties(_ref, _excluded);
+
+  var _useSelector = (0, _reactRedux.useSelector)(function (_ref2) {
+    var language = _ref2.i18n.locale,
+        _ref2$language = _ref2.language,
+        decimalSeparatorsByLangIso = _ref2$language.decimalSeparatorsByLangIso,
+        altSeparator = _ref2$language.altSeparator,
+        defaultSeparator = _ref2$language.defaultSeparator;
+    var localeSeparator = (0, _get["default"])(decimalSeparatorsByLangIso, language, defaultSeparator);
+    return {
+      localeSeparator: localeSeparator,
+      altSeparator: altSeparator,
+      defaultSeparator: defaultSeparator
+    };
+  }),
+      localeSeparator = _useSelector.localeSeparator,
+      altSeparator = _useSelector.altSeparator,
+      defaultSeparator = _useSelector.defaultSeparator;
+
+  var onChange = function onChange(name, value) {
+    // replace occurrences of (localized) decimal separator
+    var localizedValue = value.replace(new RegExp(altSeparator, 'g'), defaultSeparator); //  remove all letters etc.
+
+    localizedValue = localizedValue.replace(new RegExp("[^0-9\\".concat(defaultSeparator, "]"), 'g'), ''); // remove all separators but the first one
+
+    localizedValue = (0, _Utils.removeDuplicateRegexMatchesExceptFirst)(localizedValue, new RegExp("\\".concat(defaultSeparator), 'g'));
+    props.onChange(name, localizedValue);
+  };
+
+  var displayValue = localeSeparator === altSeparator ? (value || '').replace(defaultSeparator, localeSeparator) : localeSeparator === defaultSeparator ? (value || '').replace(altSeparator, localeSeparator) : value;
+  return /*#__PURE__*/_react["default"].createElement(_Text["default"], {
+    type: "text",
+    value: displayValue,
+    onChange: onChange,
+    label: label,
+    name: name,
+    helperText: helperText,
+    emptyValue: emptyValue,
+    multiline: multiLine,
+    readOnly: readOnly,
+    rows: rows,
+    error: error,
+    inputProps: inputProps
+  });
+};
+
+exports.LocalizedPriceTextField = LocalizedPriceTextField;

package/Components/LocalizedPriceValue.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _reactRedux = require("react-redux");
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var LocalizedPriceValue = function LocalizedPriceValue(_ref) {
+  var _ref$data = _ref.data,
+      data = _ref$data === void 0 ? '' : _ref$data,
+      decimalSeparators = _ref.decimalSeparators,
+      language = _ref.language,
+      defaultSeparator = _ref.defaultSeparator;
+  var localeSeparator = (0, _get["default"])(decimalSeparators, language, defaultSeparator);
+  return data && localeSeparator !== defaultSeparator ? data.replace(defaultSeparator, localeSeparator) : data;
+};
+
+var mapStateToProps = function mapStateToProps(_ref2) {
+  var i18n = _ref2.i18n,
+      language = _ref2.language;
+  return {
+    language: i18n.locale,
+    decimalSeparators: language.decimalSeparatorsByLangIso,
+    defaultSeparator: language.defaultSeparator
+  };
+};
+
+LocalizedPriceValue = (0, _reactRedux.connect)(mapStateToProps)(LocalizedPriceValue);
+var _default = LocalizedPriceValue;
+exports["default"] = _default;

package/Components/Menu.js

@@ -0,0 +1,202 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _reactRouter = require("react-router");
+
+var _Drawer = _interopRequireDefault(require("../UIComponents/Drawer"));
+
+var _FontIcon = _interopRequireDefault(require("../UIComponents/FontIcon"));
+
+var _ExpandMoreIcon = _interopRequireDefault(require("../UIComponents/icons/ExpandMoreIcon"));
+
+var _ExpandLessIcon = _interopRequireDefault(require("../UIComponents/icons/ExpandLessIcon"));
+
+var _withStyles = _interopRequireDefault(require("@material-ui/core/styles/withStyles"));
+
+var _ListItemText = _interopRequireDefault(require("../UIComponents/ListItemText"));
+
+var _ListItemIcon = _interopRequireDefault(require("../UIComponents/ListItemIcon"));
+
+var _Collapse = _interopRequireDefault(require("../UIComponents/Collapse"));
+
+var _ListItem = _interopRequireDefault(require("../UIComponents/ListItem"));
+
+var _List = _interopRequireDefault(require("../UIComponents/List"));
+
+var _VersionBadge = _interopRequireDefault(require("./VersionBadge"));
+
+var _VersionUpdateChip = _interopRequireDefault(require("./VersionUpdateChip"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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); 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 } }); 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; } 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); }
+
+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; }
+
+var drawerWidth = 256;
+
+var styles = function styles(theme) {
+  return {
+    drawer: {
+      width: drawerWidth,
+      flexShrink: 0
+    },
+    drawerPaper: {
+      top: 64,
+      width: drawerWidth,
+      '&.license-error': {
+        top: 95
+      },
+      bottom: 0,
+      height: 'auto',
+      display: 'flex',
+      justifyContent: 'space-between'
+    },
+    nested: {
+      paddingLeft: theme.spacing.unit * 2
+    },
+    submenuWrapper: {
+      paddingLeft: '20px'
+    },
+    icon: {},
+    menuItem: {
+      lineHeight: '16px',
+      paddingTop: '16px',
+      paddingBottom: '16px',
+      whiteSpace: 'normal',
+      wordWrap: 'break-word'
+    }
+  };
+};
+
+var Menu = /*#__PURE__*/function (_Component) {
+  _inherits(Menu, _Component);
+
+  var _super = _createSuper(Menu);
+
+  function Menu() {
+    var _this;
+
+    _classCallCheck(this, Menu);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+
+    _defineProperty(_assertThisInitialized(_this), "renderMenuItem", function (menuItem, i) {
+      var classes = _this.props.classes;
+      var menuItemClick;
+      var menuItemIcon;
+      var hasSubmenu = menuItem.data instanceof Array;
+
+      if (menuItem.icon) {
+        menuItemIcon = /*#__PURE__*/_react["default"].createElement(_ListItemIcon["default"], null, /*#__PURE__*/_react["default"].createElement(_FontIcon["default"], null, menuItem.icon));
+      }
+
+      var expandIcon;
+
+      if (hasSubmenu) {
+        menuItemClick = _this.toggleSubmenu.bind(_assertThisInitialized(_this), menuItem);
+        expandIcon = menuItem.submenuOpen ? /*#__PURE__*/_react["default"].createElement(_ExpandLessIcon["default"], null) : /*#__PURE__*/_react["default"].createElement(_ExpandMoreIcon["default"], null);
+      } else {
+        menuItemClick = function menuItemClick() {
+          if (menuItem.link) {
+            _reactRouter.browserHistory.push(window.basePath + '/' + menuItem.link);
+          }
+        };
+      }
+
+      return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, {
+        key: "menu-item-".concat(i)
+      }, /*#__PURE__*/_react["default"].createElement(_ListItem["default"], {
+        onClick: menuItemClick,
+        button: true
+      }, menuItemIcon, /*#__PURE__*/_react["default"].createElement(_ListItemText["default"], {
+        primary: menuItem.text
+      }), expandIcon), hasSubmenu && /*#__PURE__*/_react["default"].createElement(_Collapse["default"], {
+        "in": menuItem.submenuOpen,
+        timeout: "auto",
+        unmountOnExit: true
+      }, /*#__PURE__*/_react["default"].createElement(_List["default"], {
+        component: "div",
+        disablePadding: true,
+        className: classes.nested
+      }, menuItem.data.map(_this.renderMenuItem))));
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "toggleSubmenu", function (menuItem) {
+      menuItem.submenuOpen = !menuItem.submenuOpen;
+
+      _this.forceUpdate();
+    });
+
+    return _this;
+  }
+
+  _createClass(Menu, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+          classes = _this$props.classes,
+          open = _this$props.open,
+          data = _this$props.data,
+          showLicenseError = _this$props.showLicenseError,
+          version = _this$props.version,
+          latestReleasedVersion = _this$props.latestReleasedVersion,
+          showVersionUpdateBadge = _this$props.showVersionUpdateBadge;
+      return /*#__PURE__*/_react["default"].createElement(_Drawer["default"], {
+        variant: "persistent",
+        open: open,
+        anchor: "left",
+        className: classes.drawer,
+        classes: {
+          paper: classes.drawerPaper + (showLicenseError ? ' license-error' : '')
+        }
+      }, /*#__PURE__*/_react["default"].createElement(_List["default"], {
+        component: "nav"
+      }, data.map(this.renderMenuItem)), showVersionUpdateBadge && latestReleasedVersion !== version && /*#__PURE__*/_react["default"].createElement(_VersionUpdateChip["default"], {
+        latestReleasedVersion: latestReleasedVersion
+      }), /*#__PURE__*/_react["default"].createElement(_VersionBadge["default"], {
+        version: version
+      }));
+    }
+  }]);
+
+  return Menu;
+}(_react.Component);
+
+var _default = (0, _withStyles["default"])(styles)(Menu);
+
+exports["default"] = _default;