guestbell-forms 2.0.298 → 2.0.300

package/build/components/base/input/BaseInput.js

@@ -1,11 +1,9 @@
 "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 = exports.BaseInput = exports.defaultBaseTranslations = void 0;
+exports.defaultBaseTranslations = exports.default = exports.BaseInput = void 0;
 
 var React = _interopRequireWildcard(require("react"));
 
@@ -21,68 +19,38 @@ var _classnames = _interopRequireDefault(require("classnames"));
 
 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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
-
-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 _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-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 _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 _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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
-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 _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
 
 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 defaultBaseTranslations = {
+const defaultBaseTranslations = {
   required: 'Required'
 };
 exports.defaultBaseTranslations = defaultBaseTranslations;
 
-var BaseInput = /*#__PURE__*/function (_React$Component) {
-  _inherits(BaseInput, _React$Component);
-
-  var _super = _createSuper(BaseInput);
-
-  function BaseInput(props) {
-    var _this;
-
-    var subscribe = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-
-    _classCallCheck(this, BaseInput);
+class BaseInput extends React.Component {
+  constructor(props) {
+    let subscribe = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    super(props);
 
-    _this = _super.call(this, props);
+    _defineProperty(this, "componentId", (0, _Guid.default)());
 
-    _defineProperty(_assertThisInitialized(_this), "componentId", (0, _Guid.default)());
+    _defineProperty(this, "inputRef", void 0);
 
-    _defineProperty(_assertThisInitialized(_this), "inputRef", void 0);
+    _defineProperty(this, "containerRef", void 0);
 
-    _defineProperty(_assertThisInitialized(_this), "containerRef", void 0);
+    _defineProperty(this, "lastValidation", void 0);
 
-    _defineProperty(_assertThisInitialized(_this), "lastValidation", void 0);
-
-    var res = _this.handleValueChange(_this.props.value, true, [], props, true);
-
-    _this.state = {
+    const res = this.handleValueChange(this.props.value, true, [], props, true);
+    this.state = {
       isValid: res.isValid,
       errors: res.errors,
       value: props.value ? props.value : '',
@@ -91,191 +59,187 @@ var BaseInput = /*#__PURE__*/function (_React$Component) {
       focused: false,
       handleValueChangeEnabled: true
     };
-    _this.containerRef = /*#__PURE__*/React.createRef();
-    _this.inputRef = /*#__PURE__*/React.createRef();
-    _this.handleChange = _this.handleChange.bind(_assertThisInitialized(_this));
-    _this.handleBlur = _this.handleBlur.bind(_assertThisInitialized(_this));
-    _this.handleFocus = _this.handleFocus.bind(_assertThisInitialized(_this));
-    _this.setValid = _this.setValid.bind(_assertThisInitialized(_this));
-    _this.focus = _this.focus.bind(_assertThisInitialized(_this));
-    _this.scrollTo = _this.scrollTo.bind(_assertThisInitialized(_this));
-    _this.setInvalid = _this.setInvalid.bind(_assertThisInitialized(_this));
-    _this.disableComponent = _this.disableComponent.bind(_assertThisInitialized(_this));
-    _this.enableComponent = _this.enableComponent.bind(_assertThisInitialized(_this));
-    _this.touch = _this.touch.bind(_assertThisInitialized(_this));
-    _this.unTouch = _this.unTouch.bind(_assertThisInitialized(_this));
+    this.containerRef = /*#__PURE__*/React.createRef();
+    this.inputRef = /*#__PURE__*/React.createRef();
+    this.handleChange = this.handleChange.bind(this);
+    this.handleBlur = this.handleBlur.bind(this);
+    this.handleFocus = this.handleFocus.bind(this);
+    this.setValid = this.setValid.bind(this);
+    this.focus = this.focus.bind(this);
+    this.scrollTo = this.scrollTo.bind(this);
+    this.setInvalid = this.setInvalid.bind(this);
+    this.disableComponent = this.disableComponent.bind(this);
+    this.enableComponent = this.enableComponent.bind(this);
+    this.touch = this.touch.bind(this);
+    this.unTouch = this.unTouch.bind(this);
 
     if (subscribe) {
-      _this.subscribeSelf(props);
+      this.subscribeSelf(props);
     }
-
-    return _this;
   }
 
-  _createClass(BaseInput, [{
-    key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      if (!this.props.ignoreContext) {
-        this.props.formContext && this.props.formContext.unSubscribe(this.componentId);
-      }
+  componentWillUnmount() {
+    if (!this.props.ignoreContext) {
+      this.props.formContext && this.props.formContext.unSubscribe(this.componentId);
     }
-  }, {
-    key: "componentDidUpdate",
-    value: function componentDidUpdate(oldProps, oldState) {
-      if (oldProps.value !== this.props.value || oldProps.validators !== this.props.validators || oldProps.customValidators !== this.props.customValidators || oldProps.required !== this.props.required) {
-        this.handleValueChange(this.props.value, true, [], this.props);
-      }
-    }
-  }, {
-    key: "scrollTo",
-    value: function scrollTo() {
-      var domNode = ReactDOM.findDOMNode(this.containerRef.current);
-      domNode && domNode.scrollIntoView({
-        behavior: 'smooth'
-      });
+  }
+
+  componentDidUpdate(oldProps, oldState) {
+    if (oldProps.value !== this.props.value || oldProps.validators !== this.props.validators || oldProps.customValidators !== this.props.customValidators || oldProps.required !== this.props.required) {
+      this.handleValueChange(this.props.value, true, [], this.props);
     }
-  }, {
-    key: "touch",
-    value: function touch() {
-      this.setState({
-        touched: true
-      });
-      this.handleValueChange(this.state.value || '');
+  }
+
+  scrollTo() {
+    const domNode = ReactDOM.findDOMNode(this.containerRef.current);
+    domNode && domNode.scrollIntoView({
+      behavior: 'smooth'
+    });
+  }
+
+  touch() {
+    this.setState({
+      touched: true
+    });
+    this.handleValueChange(this.state.value || '');
+  }
+
+  unTouch() {
+    this.setState({
+      touched: false
+    });
+  }
+
+  disableComponent() {
+    this.setState({
+      disabled: true
+    });
+  }
+
+  enableComponent() {
+    this.setState({
+      disabled: false
+    });
+  }
+
+  focus() {
+    if (this.inputRef) {
+      const domNode = ReactDOM.findDOMNode(this.inputRef.current);
+      domNode && domNode.focus();
     }
-  }, {
-    key: "unTouch",
-    value: function unTouch() {
-      this.setState({
-        touched: false
-      });
+
+    this.touch();
+  }
+
+  shouldComponentUpdate(nextProps, nextState) {
+    let shouldUpdate = !(0, _ShallowEqual.shallowEqual)(this.props, nextProps, !this.props.reRendersWhenContextChanges ? 'formContext' : undefined) || !(0, _ShallowEqual.shallowEqual)(this.state, nextState);
+    return shouldUpdate;
+  }
+
+  getValidationClass(extraErrors) {
+    if (!this.props.showValidation || !this.state.touched) {
+      return 'validation__success';
     }
-  }, {
-    key: "disableComponent",
-    value: function disableComponent() {
-      this.setState({
-        disabled: true
-      });
+
+    return this.state.isValid && (!this.props.errors || this.props.errors.length === 0) && (!this.state.errors || this.state.errors.length === 0) && (!extraErrors || extraErrors.length === 0) ? 'validation__success' : 'validation__error';
+  }
+
+  renderDefaultValidation(extraErrors) {
+    if (this.props.disabled) {
+      return null;
     }
-  }, {
-    key: "enableComponent",
-    value: function enableComponent() {
-      this.setState({
-        disabled: false
-      });
+
+    if (!this.props.showValidation) {
+      return null;
     }
-  }, {
-    key: "focus",
-    value: function focus() {
-      if (this.inputRef) {
-        var domNode = ReactDOM.findDOMNode(this.inputRef.current);
-        domNode && domNode.focus();
-      }
 
-      this.touch();
+    let finalErrors = this.state.errors;
+
+    if (!finalErrors) {
+      finalErrors = [];
     }
-  }, {
-    key: "shouldComponentUpdate",
-    value: function shouldComponentUpdate(nextProps, nextState) {
-      var shouldUpdate = !(0, _ShallowEqual.shallowEqual)(this.props, nextProps, !this.props.reRendersWhenContextChanges ? 'formContext' : undefined) || !(0, _ShallowEqual.shallowEqual)(this.state, nextState);
-      return shouldUpdate;
+
+    if (extraErrors) {
+      finalErrors = finalErrors.concat(extraErrors);
     }
-  }, {
-    key: "getValidationClass",
-    value: function getValidationClass(extraErrors) {
-      if (!this.props.showValidation || !this.state.touched) {
-        return 'validation__success';
-      }
 
-      return this.state.isValid && (!this.props.errors || this.props.errors.length === 0) && (!this.state.errors || this.state.errors.length === 0) && (!extraErrors || extraErrors.length === 0) ? 'validation__success' : 'validation__error';
+    if (this.props.errors) {
+      finalErrors = finalErrors.concat(this.props.errors);
     }
-  }, {
-    key: "renderDefaultValidation",
-    value: function renderDefaultValidation(extraErrors) {
-      if (this.props.disabled) {
-        return null;
-      }
 
-      if (!this.props.showValidation) {
-        return null;
-      }
+    finalErrors = finalErrors.filter(i => i);
 
-      var finalErrors = this.state.errors;
+    if (finalErrors.length > 0) {
+      this.lastValidation = finalErrors.map((item, index) => /*#__PURE__*/React.createElement("li", {
+        key: index,
+        className: "validation__item"
+      }, item));
+    }
 
-      if (!finalErrors) {
-        finalErrors = [];
-      }
+    return /*#__PURE__*/React.createElement("div", {
+      className: "validation__container"
+    }, /*#__PURE__*/React.createElement("ul", {
+      className: "validation__ul"
+    }, this.lastValidation));
+  }
 
-      if (extraErrors) {
-        finalErrors = finalErrors.concat(extraErrors);
-      }
+  handleChange(event, isValid) {
+    let errors = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+    let value = event.target.value;
 
-      if (this.props.errors) {
-        finalErrors = finalErrors.concat(this.props.errors);
+    if (!this.props.onTheFlightValidate || this.props.onTheFlightValidate && this.props.onTheFlightValidate(value)) {
+      const res = this.handleValueChange(value, isValid, errors);
+
+      if (this.props.onChange) {
+        this.props.onChange(event, res.isValid);
       }
+    }
+  }
 
-      finalErrors = finalErrors.filter(function (i) {
-        return i;
+  subscribeSelf(props) {
+    if (!props.ignoreContext && props.formContext) {
+      props.formContext.subscribe(this.componentId, {
+        componentApi: {
+          disableComponent: this.disableComponent,
+          enableComponent: this.enableComponent,
+          touch: this.touch,
+          unTouch: this.unTouch,
+          scrollTo: this.scrollTo,
+          focus: this.focus
+        },
+        validation: {
+          isValid: this.state.isValid,
+          errors: this.state.errors,
+          name: this.props.validationName ? this.props.validationName : this.props.title ? this.props.title : this.props.label
+        }
       });
+    }
+  }
 
-      if (finalErrors.length > 0) {
-        this.lastValidation = finalErrors.map(function (item, index) {
-          return /*#__PURE__*/React.createElement("li", {
-            key: index,
-            className: "validation__item"
-          }, item);
-        });
-      }
+  handleBlur(e) {
+    this.props.onBlur && this.props.onBlur();
+    let state = {
+      focused: false
+    };
 
-      return /*#__PURE__*/React.createElement("div", {
-        className: "validation__container"
-      }, /*#__PURE__*/React.createElement("ul", {
-        className: "validation__ul"
-      }, this.lastValidation));
+    if (!this.state.touched && this.props.touchOn === 'blur') {
+      state = Object.assign(state, {
+        touched: true
+      });
+      this.handleValueChange(this.state.value);
     }
-  }, {
-    key: "handleChange",
-    value: function handleChange(event, isValid) {
-      var errors = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-      var value = event.target.value;
 
-      if (!this.props.onTheFlightValidate || this.props.onTheFlightValidate && this.props.onTheFlightValidate(value)) {
-        var res = this.handleValueChange(value, isValid, errors);
+    this.setState(state);
+  }
 
-        if (this.props.onChange) {
-          this.props.onChange(event, res.isValid);
-        }
-      }
-    }
-  }, {
-    key: "subscribeSelf",
-    value: function subscribeSelf(props) {
-      if (!props.ignoreContext && props.formContext) {
-        props.formContext.subscribe(this.componentId, {
-          componentApi: {
-            disableComponent: this.disableComponent,
-            enableComponent: this.enableComponent,
-            touch: this.touch,
-            unTouch: this.unTouch,
-            scrollTo: this.scrollTo,
-            focus: this.focus
-          },
-          validation: {
-            isValid: this.state.isValid,
-            errors: this.state.errors,
-            name: this.props.validationName ? this.props.validationName : this.props.title ? this.props.title : this.props.label
-          }
-        });
-      }
-    }
-  }, {
-    key: "handleBlur",
-    value: function handleBlur(e) {
-      this.props.onBlur && this.props.onBlur();
-      var state = {
-        focused: false
+  handleFocus(e) {
+    if (!this.props.disabled) {
+      this.props.onFocus && this.props.onFocus(e);
+      let state = {
+        focused: true
       };
 
-      if (!this.state.touched && this.props.touchOn === 'blur') {
+      if (!this.state.touched && this.props.touchOn === 'focus') {
         state = Object.assign(state, {
           touched: true
         });
@@ -284,244 +248,196 @@ var BaseInput = /*#__PURE__*/function (_React$Component) {
 
       this.setState(state);
     }
-  }, {
-    key: "handleFocus",
-    value: function handleFocus(e) {
-      if (!this.props.disabled) {
-        this.props.onFocus && this.props.onFocus(e);
-        var state = {
-          focused: true
-        };
-
-        if (!this.state.touched && this.props.touchOn === 'focus') {
-          state = Object.assign(state, {
-            touched: true
-          });
-          this.handleValueChange(this.state.value);
-        }
+  }
+
+  getDisabled() {
+    return this.state.disabled ? this.state.disabled : this.props.disabled;
+  }
 
-        this.setState(state);
+  setValid() {
+    this.setState(() => ({
+      isValid: true,
+      errors: []
+    }), () => {
+      if (!this.props.ignoreContext) {
+        this.props.formContext && this.props.formContext.updateCallback(this.componentId, {
+          validation: {
+            isValid: true,
+            errors: []
+          }
+        });
       }
-    }
-  }, {
-    key: "getDisabled",
-    value: function getDisabled() {
-      return this.state.disabled ? this.state.disabled : this.props.disabled;
-    }
-  }, {
-    key: "setValid",
-    value: function setValid() {
-      var _this2 = this;
-
-      this.setState(function () {
-        return {
-          isValid: true,
-          errors: []
-        };
-      }, function () {
-        if (!_this2.props.ignoreContext) {
-          _this2.props.formContext && _this2.props.formContext.updateCallback(_this2.componentId, {
-            validation: {
-              isValid: true,
-              errors: []
-            }
-          });
-        }
-      });
-    }
-  }, {
-    key: "setInvalid",
-    value: function setInvalid() {
-      var _this3 = this;
-
-      var errors = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-      this.setState(function () {
-        return {
-          isValid: false,
-          errors: errors
-        };
-      }, function () {
-        if (!_this3.props.ignoreContext) {
-          _this3.props.formContext && _this3.props.formContext.updateCallback(_this3.componentId, {
-            validation: {
-              isValid: false,
-              errors: errors
-            }
-          });
-        }
-      });
-    }
-  }, {
-    key: "renderLabel",
-    value: function renderLabel() {
-      var touchable = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-
-      if (!this.props.tooltip || this.props.tooltip && this.props.title) {
-        return /*#__PURE__*/React.createElement("span", {
-          className: (0, _classnames.default)('w-100', {
-            'label--no-touch': !touchable
-          })
-        }, this.props.label);
+    });
+  }
+
+  setInvalid() {
+    let errors = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    this.setState(() => ({
+      isValid: false,
+      errors
+    }), () => {
+      if (!this.props.ignoreContext) {
+        this.props.formContext && this.props.formContext.updateCallback(this.componentId, {
+          validation: {
+            isValid: false,
+            errors: errors
+          }
+        });
       }
+    });
+  }
 
-      return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("span", {
-        className: touchable ? '' : 'label--no-touch'
-      }, this.props.label), this.renderTooltip());
+  renderLabel() {
+    let touchable = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+
+    if (!this.props.tooltip || this.props.tooltip && this.props.title) {
+      return /*#__PURE__*/React.createElement("span", {
+        className: (0, _classnames.default)('w-100', {
+          'label--no-touch': !touchable
+        })
+      }, this.props.label);
     }
-  }, {
-    key: "renderTitle",
-    value: function renderTitle() {
-      if (!this.props.tooltip) {
-        return this.props.title;
-      }
 
-      return /*#__PURE__*/React.createElement(React.Fragment, null, this.props.title, this.renderTooltip());
+    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("span", {
+      className: touchable ? '' : 'label--no-touch'
+    }, this.props.label), this.renderTooltip());
+  }
+
+  renderTitle() {
+    if (!this.props.tooltip) {
+      return this.props.title;
     }
-  }, {
-    key: "handleValueChange",
-    value: function handleValueChange(value) {
-      var isValid = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-      var errors = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-      var props = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : this.props;
-      var initializing = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
-
-      if (!initializing && !this.state.handleValueChangeEnabled) {
-        return {
-          isValid: isValid,
-          errors: []
-        };
-      }
 
-      if (props.required && !value) {
-        var translations = this.getTranslations(defaultBaseTranslations);
-        errors.push(translations.required);
-        isValid = false;
+    return /*#__PURE__*/React.createElement(React.Fragment, null, this.props.title, this.renderTooltip());
+  }
+
+  handleValueChange(value) {
+    let isValid = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    let errors = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+    let props = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : this.props;
+    let initializing = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+
+    if (!initializing && !this.state.handleValueChangeEnabled) {
+      return {
+        isValid,
+        errors: []
+      };
+    }
+
+    if (props.required && !value) {
+      const translations = this.getTranslations(defaultBaseTranslations);
+      errors.push(translations.required);
+      isValid = false;
+    } else {
+      if (!props.required && !value) {
+        isValid = true;
       } else {
-        if (!props.required && !value) {
+        if (props.validators) {
           isValid = true;
-        } else {
-          if (props.validators) {
-            isValid = true;
-            props.validators.forEach(function (validator) {
-              var validInner = false;
-
-              switch (validator) {
-                case 'email':
-                  validInner = new Validators.EmailValidator().Validate(value, props.required, function (error) {
-                    return errors.push(error);
-                  });
-                  break;
-
-                case 'number':
-                  validInner = new Validators.NumberValidator().Validate(value, props.required, function (error) {
-                    return errors.push(error);
-                  });
-                  break;
-
-                case 'latitude':
-                  validInner = new Validators.LatitudeValidator().Validate(value, props.required, function (error) {
-                    return errors.push(error);
-                  });
-                  break;
-
-                case 'longitude':
-                  validInner = new Validators.LongitudeValidator().Validate(value, props.required, function (error) {
-                    return errors.push(error);
-                  });
-                  break;
-
-                case 'url':
-                  validInner = new Validators.UrlValidator().Validate(value, props.required, function (error) {
-                    return errors.push(error);
-                  });
-                  break;
-
-                default:
-                  throw new Error("Validator ".concat(validator, " not implemented"));
-              }
-
-              if (isValid && !validInner) {
-                isValid = validInner;
-              }
-            });
-          }
+          props.validators.forEach(validator => {
+            let validInner = false;
 
-          if (props.customValidators) {
-            props.customValidators.forEach(function (customValidator) {
-              var validInner = false;
-              validInner = customValidator.Validate(value, props.required, function (error) {
-                return errors.push(error);
-              });
-
-              if (isValid && !validInner) {
-                isValid = validInner;
-              }
-            });
-          }
-        }
-      }
+            switch (validator) {
+              case 'email':
+                validInner = new Validators.EmailValidator().Validate(value, props.required, error => errors.push(error));
+                break;
 
-      props.onErrorsChanged && props.onErrorsChanged(errors);
+              case 'number':
+                validInner = new Validators.NumberValidator().Validate(value, props.required, error => errors.push(error));
+                break;
 
-      if (!initializing) {
-        this.setState({
-          value: value,
-          isValid: isValid,
-          errors: errors
-        });
+              case 'latitude':
+                validInner = new Validators.LatitudeValidator().Validate(value, props.required, error => errors.push(error));
+                break;
 
-        if (!props.ignoreContext) {
-          props.formContext && props.formContext.updateCallback(this.componentId, {
-            validation: {
-              isValid: isValid,
-              errors: errors
+              case 'longitude':
+                validInner = new Validators.LongitudeValidator().Validate(value, props.required, error => errors.push(error));
+                break;
+
+              case 'url':
+                validInner = new Validators.UrlValidator().Validate(value, props.required, error => errors.push(error));
+                break;
+
+              default:
+                throw new Error(`Validator ${validator} not implemented`);
+            }
+
+            if (isValid && !validInner) {
+              isValid = validInner;
             }
           });
         }
-      }
 
-      return {
-        isValid: isValid,
-        errors: errors
-      };
-    }
-  }, {
-    key: "renderTooltip",
-    value: function renderTooltip() {
-      var content = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : /*#__PURE__*/React.createElement("span", {
-        className: "label--help-icon"
-      }, "?");
-
-      if (this.props.tooltip) {
-        var _document;
-
-        var Tippy = require('@tippy.js/react').default;
-
-        return /*#__PURE__*/React.createElement(Tippy, _extends({
-          content: this.props.tooltip,
-          placement: "bottom",
-          animation: "scale-subtle",
-          arrow: false,
-          duration: 200,
-          delay: [75, 0],
-          distance: 8,
-          interactive: true,
-          appendTo: (_document = document) === null || _document === void 0 ? void 0 : _document.body,
-          trigger: "mouseenter focus"
-        }, this.props.tooltipProps), content);
+        if (props.customValidators) {
+          props.customValidators.forEach(customValidator => {
+            let validInner = false;
+            validInner = customValidator.Validate(value, props.required, error => errors.push(error));
+
+            if (isValid && !validInner) {
+              isValid = validInner;
+            }
+          });
+        }
       }
+    }
+
+    props.onErrorsChanged && props.onErrorsChanged(errors);
+
+    if (!initializing) {
+      this.setState({
+        value,
+        isValid,
+        errors
+      });
 
-      return content;
+      if (!props.ignoreContext) {
+        props.formContext && props.formContext.updateCallback(this.componentId, {
+          validation: {
+            isValid: isValid,
+            errors: errors
+          }
+        });
+      }
     }
-  }, {
-    key: "getTranslations",
-    value: function getTranslations(_defaultTranslations) {
-      return _objectSpread(_objectSpread({}, _defaultTranslations), this.props.translations);
+
+    return {
+      isValid,
+      errors
+    };
+  }
+
+  renderTooltip() {
+    let content = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : /*#__PURE__*/React.createElement("span", {
+      className: "label--help-icon"
+    }, "?");
+
+    if (this.props.tooltip) {
+      var _document;
+
+      const Tippy = require('@tippy.js/react').default;
+
+      return /*#__PURE__*/React.createElement(Tippy, _extends({
+        content: this.props.tooltip,
+        placement: "bottom",
+        animation: "scale-subtle",
+        arrow: false,
+        duration: 200,
+        delay: [75, 0],
+        distance: 8,
+        interactive: true,
+        appendTo: (_document = document) === null || _document === void 0 ? void 0 : _document.body,
+        trigger: "mouseenter focus"
+      }, this.props.tooltipProps), content);
     }
-  }]);
 
-  return BaseInput;
-}(React.Component);
+    return content;
+  }
+
+  getTranslations(_defaultTranslations) {
+    return _objectSpread(_objectSpread({}, _defaultTranslations), this.props.translations);
+  }
+
+}
 
 exports.BaseInput = BaseInput;