@widergy/energy-ui 1.136.0 → 1.136.2

package/dist/components/UTMap/index.js

@@ -15,130 +15,104 @@ var _withGoogleMapScript = _interopRequireDefault(require("./withGoogleMapScript
 var _constants = require("./constants");
 var _stylesModule = _interopRequireDefault(require("./styles.module.scss"));
 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 _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-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, _toPropertyKey(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 ? Object.setPrototypeOf.bind() : 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.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-var UTMap = /*#__PURE__*/function (_PureComponent) {
-  _inherits(UTMap, _PureComponent);
-  var _super = _createSuper(UTMap);
-  function UTMap(props) {
-    var _this;
-    _classCallCheck(this, UTMap);
-    _this = _super.call(this, props);
-    _defineProperty(_assertThisInitialized(_this), "handleSearchChange", function (event) {
-      return _this.setState({
-        searchValue: event.target.value
-      });
-    });
-    _defineProperty(_assertThisInitialized(_this), "updateAddress", function (latLng, forcedAddress, changeValue) {
-      _this.setState({
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+class UTMap extends _react.PureComponent {
+  constructor(props) {
+    super(props);
+    _defineProperty(this, "handleSearchChange", event => this.setState({
+      searchValue: event.target.value
+    }));
+    _defineProperty(this, "updateAddress", (latLng, forcedAddress, changeValue) => {
+      this.setState({
         searchValue: ''
       });
       // Update address on search box and complete field value on store
       (0, _utils.retrieveAddressByCoords)({
         address: forcedAddress,
         location: latLng
-      }, function (address) {
-        _this.setState({
+      }, address => {
+        this.setState({
           searchValue: address.formatted_address
-        }, function () {
-          var _this$props = _this.props,
-            field = _this$props.field,
-            onChange = _this$props.onChange;
-          var addressComponents = field.configuration.address_components;
-          var addressValue = {};
-          Object.keys(addressComponents).map(function (key) {
-            return addressValue[addressComponents[key]] = (0, _utils.getValue)(address, latLng, key);
-          });
+        }, () => {
+          const {
+            field,
+            onChange
+          } = this.props;
+          const addressComponents = field.configuration.address_components;
+          const addressValue = {};
+          Object.keys(addressComponents).map(key => addressValue[addressComponents[key]] = (0, _utils.getValue)(address, latLng, key));
           if (changeValue) onChange(addressValue);
         });
       });
     });
-    _defineProperty(_assertThisInitialized(_this), "updateMarker", function (latLng) {
+    _defineProperty(this, "updateMarker", latLng => {
       // Add marker on screen
-      var newMarker = {
+      const newMarker = {
         position: latLng,
         defaultAnimation: 2,
         key: Date.now()
       };
-      var markers = [].concat(_toConsumableArray(_this.props.singleMarker ? [] : _toConsumableArray(_this.state.markers)), [newMarker]);
-      _this.setState({
-        markers: markers
+      const markers = [...(this.props.singleMarker ? [] : [...this.state.markers]), newMarker];
+      this.setState({
+        markers
       });
     });
-    _defineProperty(_assertThisInitialized(_this), "handleMapClick", function (event) {
+    _defineProperty(this, "handleMapClick", event => {
       // When user click on any place inside map
-      if (_this.props.disabled) return;
-      if ((0, _utils.checkAddressIsValid)(event.latLng, _this.state.usePolygon, _this.props.polygonPath)) {
-        _this.props.onChange(null);
-        _this.updateMarker(event.latLng);
-        _this.updateAddress(event.latLng, null, true);
-      } else if (_this.props.onLocationOutOfBoundsCallback) {
-        _this.setState({
-          mapZoom: _this.props.zoomAddressInvalid || 10
+      if (this.props.disabled) return;
+      if ((0, _utils.checkAddressIsValid)(event.latLng, this.state.usePolygon, this.props.polygonPath)) {
+        this.props.onChange(null);
+        this.updateMarker(event.latLng);
+        this.updateAddress(event.latLng, null, true);
+      } else if (this.props.onLocationOutOfBoundsCallback) {
+        this.setState({
+          mapZoom: this.props.zoomAddressInvalid || 10
         });
-        _this.props.onLocationOutOfBoundsCallback();
+        this.props.onLocationOutOfBoundsCallback();
       }
     });
-    _defineProperty(_assertThisInitialized(_this), "centerMap", function (latLng) {
-      return _this.setState({
-        center: latLng,
-        mapZoom: _this.props.zoomAddressValid || _constants.ZOOM_ADDRESS_VALID
-      });
-    });
-    _defineProperty(_assertThisInitialized(_this), "handleMarkerRightClick", function (targetMarker) {
-      var nextMarkers = _this.state.markers.filter(function (marker) {
-        return marker.position !== targetMarker.latLng && marker.position.lat !== targetMarker.latLng.lat() && marker.position.lng !== targetMarker.latLng.lng();
-      });
-      _this.setState({
+    _defineProperty(this, "centerMap", latLng => this.setState({
+      center: latLng,
+      mapZoom: this.props.zoomAddressValid || _constants.ZOOM_ADDRESS_VALID
+    }));
+    _defineProperty(this, "handleMarkerRightClick", targetMarker => {
+      const nextMarkers = this.state.markers.filter(marker => marker.position !== targetMarker.latLng && marker.position.lat !== targetMarker.latLng.lat() && marker.position.lng !== targetMarker.latLng.lng());
+      this.setState({
         markers: nextMarkers
       });
     });
-    _defineProperty(_assertThisInitialized(_this), "handleMapMounted", function (mapRef) {
+    _defineProperty(this, "handleMapMounted", mapRef => {
       // When map is mounted on screen
-      _this.map = mapRef;
-      var _this$props2 = _this.props,
-        input = _this$props2.input,
-        field = _this$props2.field;
+      this.map = mapRef;
+      const {
+        input,
+        field
+      } = this.props;
       if (input.value) {
-        var addressComponents = field.configuration.address_components;
-        var latLng = new window.google.maps.LatLng(input.value[addressComponents[_constants.GMAP_PARAMS.latitude]], input.value[addressComponents[_constants.GMAP_PARAMS.longitude]]);
-        _this.updateAddress(latLng, input.value[addressComponents[_constants.GMAP_PARAMS.formattedAddress]]);
+        const addressComponents = field.configuration.address_components;
+        const latLng = new window.google.maps.LatLng(input.value[addressComponents[_constants.GMAP_PARAMS.latitude]], input.value[addressComponents[_constants.GMAP_PARAMS.longitude]]);
+        this.updateAddress(latLng, input.value[addressComponents[_constants.GMAP_PARAMS.formattedAddress]]);
         return;
       }
-      if (_this.props.useGeolocation) {
+      if (this.props.useGeolocation) {
         // We try to recover user actual position with navigator geolocation
-        (0, _utils.geolocation)(_this.props.errors.retrieveLocationError).getCurrentPosition(function (userPosition) {
+        (0, _utils.geolocation)(this.props.errors.retrieveLocationError).getCurrentPosition(userPosition => {
           // If we can retrieve user position...
-          var _userPosition$coords = userPosition.coords,
-            userLatitude = _userPosition$coords.latitude,
-            userLongitude = _userPosition$coords.longitude;
-          var userLatLng = new window.google.maps.LatLng(userLatitude, userLongitude);
-          if ((0, _utils.checkAddressIsValid)(userLatLng, _this.state.usePolygon, _this.props.polygonPath)) {
-            var actualPosition = {
+          const {
+            latitude: userLatitude,
+            longitude: userLongitude
+          } = userPosition.coords;
+          const userLatLng = new window.google.maps.LatLng(userLatitude, userLongitude);
+          if ((0, _utils.checkAddressIsValid)(userLatLng, this.state.usePolygon, this.props.polygonPath)) {
+            const actualPosition = {
               lat: userLatitude,
               lng: userLongitude
             };
-            _this.setState({
+            this.setState({
               center: actualPosition,
               markers: [{
                 position: actualPosition,
@@ -146,133 +120,125 @@ var UTMap = /*#__PURE__*/function (_PureComponent) {
                 defaultAnimation: 2
               }],
               mapLoading: false
-            }, function () {
-              var latlng = new window.google.maps.LatLng(userLatitude, userLongitude);
-              _this.updateAddress(latlng, null, true);
+            }, () => {
+              const latlng = new window.google.maps.LatLng(userLatitude, userLongitude);
+              this.updateAddress(latlng, null, true);
             });
           } else {
             // In other case we set map on startLocation
-            var latlng = new window.google.maps.LatLng(_this.state.center.lat, _this.state.center.lng);
-            _this.updateAddress(latlng, null, true);
+            const latlng = new window.google.maps.LatLng(this.state.center.lat, this.state.center.lng);
+            this.updateAddress(latlng, null, true);
           }
         },
         // If we can't retrieve user position we set map on startLocation
-        function () {
-          var latlng = new window.google.maps.LatLng(_this.state.center.lat, _this.state.center.lng);
-          _this.updateAddress(latlng, null, true);
+        () => {
+          const latlng = new window.google.maps.LatLng(this.state.center.lat, this.state.center.lng);
+          this.updateAddress(latlng, null, true);
         });
       }
     });
-    _defineProperty(_assertThisInitialized(_this), "handleBoundsChanged", function () {
-      return _this.setState({
-        center: _this.map.getCenter()
-      });
-    });
-    _defineProperty(_assertThisInitialized(_this), "handleSearchBoxMounted", function (searchBoxRef) {
-      return _this.searchBox = searchBoxRef;
-    });
-    _defineProperty(_assertThisInitialized(_this), "handlePlacesChanged", function () {
-      if (_this.props.disabled) return;
-      var places = _this.searchBox.getPlaces();
-      var place = !(0, _array.isEmpty)(places) && (0, _utils.checkAddressIsValid)(places[0].geometry.location, _this.state.usePolygon, _this.props.polygonPath) && places[0];
+    _defineProperty(this, "handleBoundsChanged", () => this.setState({
+      center: this.map.getCenter()
+    }));
+    _defineProperty(this, "handleSearchBoxMounted", searchBoxRef => this.searchBox = searchBoxRef);
+    _defineProperty(this, "handlePlacesChanged", () => {
+      if (this.props.disabled) return;
+      const places = this.searchBox.getPlaces();
+      const place = !(0, _array.isEmpty)(places) && (0, _utils.checkAddressIsValid)(places[0].geometry.location, this.state.usePolygon, this.props.polygonPath) && places[0];
       if (place) {
-        _this.props.onChange(null);
-        _this.updateMarker(place.geometry.location);
-        _this.updateAddress(place.geometry.location, place.formatted_address, true);
-        _this.centerMap(place.geometry.location);
-      } else if (_this.props.onLocationOutOfBoundsCallback) _this.props.onLocationOutOfBoundsCallback();
+        this.props.onChange(null);
+        this.updateMarker(place.geometry.location);
+        this.updateAddress(place.geometry.location, place.formatted_address, true);
+        this.centerMap(place.geometry.location);
+      } else if (this.props.onLocationOutOfBoundsCallback) this.props.onLocationOutOfBoundsCallback();
     });
-    _this.state = {
+    this.state = {
       markers: [],
       mapLoading: true,
       searchValue: '',
-      mapZoom: _this.props.zoomInitial || _constants.ZOOM_INITIAL,
-      usePolygon: _this.props.usePolygon && !(0, _array.isEmpty)(_this.props.polygonPath),
+      mapZoom: this.props.zoomInitial || _constants.ZOOM_INITIAL,
+      usePolygon: this.props.usePolygon && !(0, _array.isEmpty)(this.props.polygonPath),
       invalidConfiguration: false
     };
-    return _this;
   }
-  _createClass(UTMap, [{
-    key: "componentDidMount",
-    value: function componentDidMount() {
-      var startPosition = {
-        position: {
-          lat: null,
-          lng: null
-        }
-      };
-      var _this$props3 = this.props,
-        input = _this$props3.input,
-        startLocation = _this$props3.startLocation,
-        field = _this$props3.field;
-      if (!(0, _utils.isValidConfiguration)(field)) {
-        this.setState({
-          invalidConfiguration: true,
-          mapLoading: false
-        });
-        return;
-      }
-      if (input.value) {
-        startPosition.position.lat = input.value[field.configuration.address_components[_constants.GMAP_PARAMS.latitude]];
-        startPosition.position.lng = input.value[field.configuration.address_components[_constants.GMAP_PARAMS.longitude]];
-        this.setState({
-          center: startPosition.position,
-          markers: [startPosition],
-          mapLoading: false
-        });
-        return;
-      }
-      if (startLocation && startLocation.position.lat && startLocation.position.lng) {
-        this.setState({
-          center: startLocation.position,
-          markers: [startLocation],
-          mapLoading: false
-        });
+  componentDidMount() {
+    const startPosition = {
+      position: {
+        lat: null,
+        lng: null
       }
+    };
+    const {
+      input,
+      startLocation,
+      field
+    } = this.props;
+    if (!(0, _utils.isValidConfiguration)(field)) {
+      this.setState({
+        invalidConfiguration: true,
+        mapLoading: false
+      });
+      return;
     }
-  }, {
-    key: "render",
-    value: function render() {
-      var showOnlyMap = this.props.field.configuration.showOnlyMap;
-      return /*#__PURE__*/_react.default.createElement("div", null, this.state.center ? /*#__PURE__*/_react.default.createElement("div", null, /*#__PURE__*/_react.default.createElement(_GoogleMaps.default, {
-        containerElement: /*#__PURE__*/_react.default.createElement("div", {
-          className: this.props.className
-        }),
-        mapElement: /*#__PURE__*/_react.default.createElement("div", {
-          className: this.props.className
-        }),
-        onMapClick: this.handleMapClick,
-        onMarkerRightClick: this.handleMarkerRightClick,
-        onMapMounted: this.handleMapMounted,
-        onSearchBoxMounted: this.handleSearchBoxMounted,
-        onPlacesChanged: this.handlePlacesChanged,
-        markers: this.state.markers,
-        center: this.state.center,
-        searchValue: this.state.searchValue,
-        onSearchChange: this.handleSearchChange,
-        zoom: this.state.mapZoom,
-        polygonPath: this.props.polygonPath,
-        usePolygon: this.state.usePolygon,
-        placeholder: this.props.placeholder,
-        disabled: this.props.disabled,
-        showOnlyMap: showOnlyMap,
-        colorPolygon: this.props.colorPolygon,
-        colorBorderPolygon: this.props.colorBorderPolygon
-      })) : this.state.mapLoading ? /*#__PURE__*/_react.default.createElement(_UTLabel.default, {
-        black: true
-      }, this.props.errors.retrievingLocation) : this.state.invalidConfiguration ? /*#__PURE__*/_react.default.createElement(_UTLabel.default, {
-        error: true
-      }, this.props.errors.invalidConfig) : /*#__PURE__*/_react.default.createElement(_UTLabel.default, {
-        error: true
-      }, this.props.errors.retrieveLocationError), !showOnlyMap && /*#__PURE__*/_react.default.createElement(_UTLabel.default, {
-        error: true,
-        small: true,
-        className: _stylesModule.default.error
-      }, (0, _form.shouldShowErrors)(this.props.meta) ? this.props.meta.error : ''));
+    if (input.value) {
+      startPosition.position.lat = input.value[field.configuration.address_components[_constants.GMAP_PARAMS.latitude]];
+      startPosition.position.lng = input.value[field.configuration.address_components[_constants.GMAP_PARAMS.longitude]];
+      this.setState({
+        center: startPosition.position,
+        markers: [startPosition],
+        mapLoading: false
+      });
+      return;
     }
-  }]);
-  return UTMap;
-}(_react.PureComponent);
+    if (startLocation && startLocation.position.lat && startLocation.position.lng) {
+      this.setState({
+        center: startLocation.position,
+        markers: [startLocation],
+        mapLoading: false
+      });
+    }
+  }
+  render() {
+    const {
+      showOnlyMap
+    } = this.props.field.configuration;
+    return /*#__PURE__*/_react.default.createElement("div", null, this.state.center ? /*#__PURE__*/_react.default.createElement("div", null, /*#__PURE__*/_react.default.createElement(_GoogleMaps.default, {
+      containerElement: /*#__PURE__*/_react.default.createElement("div", {
+        className: this.props.className
+      }),
+      mapElement: /*#__PURE__*/_react.default.createElement("div", {
+        className: this.props.className
+      }),
+      onMapClick: this.handleMapClick,
+      onMarkerRightClick: this.handleMarkerRightClick,
+      onMapMounted: this.handleMapMounted,
+      onSearchBoxMounted: this.handleSearchBoxMounted,
+      onPlacesChanged: this.handlePlacesChanged,
+      markers: this.state.markers,
+      center: this.state.center,
+      searchValue: this.state.searchValue,
+      onSearchChange: this.handleSearchChange,
+      zoom: this.state.mapZoom,
+      polygonPath: this.props.polygonPath,
+      usePolygon: this.state.usePolygon,
+      placeholder: this.props.placeholder,
+      disabled: this.props.disabled,
+      showOnlyMap: showOnlyMap,
+      colorPolygon: this.props.colorPolygon,
+      colorBorderPolygon: this.props.colorBorderPolygon
+    })) : this.state.mapLoading ? /*#__PURE__*/_react.default.createElement(_UTLabel.default, {
+      black: true
+    }, this.props.errors.retrievingLocation) : this.state.invalidConfiguration ? /*#__PURE__*/_react.default.createElement(_UTLabel.default, {
+      error: true
+    }, this.props.errors.invalidConfig) : /*#__PURE__*/_react.default.createElement(_UTLabel.default, {
+      error: true
+    }, this.props.errors.retrieveLocationError), !showOnlyMap && /*#__PURE__*/_react.default.createElement(_UTLabel.default, {
+      error: true,
+      small: true,
+      className: _stylesModule.default.error
+    }, (0, _form.shouldShowErrors)(this.props.meta) ? this.props.meta.error : ''));
+  }
+}
 UTMap.propTypes = _types.UTMapPropTypes;
 UTMap.defaultProps = {
   errors: {
@@ -287,5 +253,4 @@ UTMap.defaultProps = {
     }
   }
 };
-var _default = (0, _withGoogleMapScript.default)()(UTMap);
-exports.default = _default;
+var _default = exports.default = (0, _withGoogleMapScript.default)()(UTMap);

package/dist/components/UTMap/types.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.UTMapPropTypes = exports.GoogleMapsPropTypes = void 0;
 var _propTypes = require("prop-types");
 var _formTypes = require("../../types/formTypes");
-var coordinatePropType = (0, _propTypes.oneOfType)([_propTypes.number, _propTypes.func]);
-var UTMapPropTypes = {
+const coordinatePropType = (0, _propTypes.oneOfType)([_propTypes.number, _propTypes.func]);
+const UTMapPropTypes = exports.UTMapPropTypes = {
   onChange: _propTypes.func.isRequired,
   singleMarker: _propTypes.bool,
   startLocation: (0, _propTypes.shape)({
@@ -36,8 +36,7 @@ var UTMapPropTypes = {
   input: _formTypes.inputPropTypes,
   disabled: _propTypes.bool
 };
-exports.UTMapPropTypes = UTMapPropTypes;
-var GoogleMapsPropTypes = {
+const GoogleMapsPropTypes = exports.GoogleMapsPropTypes = {
   onMapClick: _propTypes.func.isRequired,
   onMarkerRightClick: _propTypes.func.isRequired,
   center: (0, _propTypes.shape)({
@@ -65,5 +64,4 @@ var GoogleMapsPropTypes = {
   searchValue: _propTypes.any,
   zoom: _propTypes.number,
   showOnlyMap: _propTypes.bool
-};
-exports.GoogleMapsPropTypes = GoogleMapsPropTypes;
+};

package/dist/components/UTMap/utils.js

@@ -6,72 +6,57 @@ Object.defineProperty(exports, "__esModule", {
 exports.retrieveAddressByCoords = exports.isValidConfiguration = exports.getValue = exports.geolocation = exports.findAddressComponent = exports.checkAddressIsValid = void 0;
 var _array = require("@widergy/web-utils/lib/array");
 var _constants = require("./constants");
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-var geolocation = function geolocation(message) {
-  return navigator.geolocation ? navigator.geolocation : {
-    getCurrentPosition: function getCurrentPosition(success, failure) {
-      failure(message);
-    }
-  };
+const geolocation = message => navigator.geolocation ? navigator.geolocation : {
+  getCurrentPosition(success, failure) {
+    failure(message);
+  }
 };
 exports.geolocation = geolocation;
-var checkAddressIsValid = function checkAddressIsValid(latLng, usePolygon, polygon) {
+const checkAddressIsValid = (latLng, usePolygon, polygon) => {
   // Check if a position is included on Utility polygon or if utility hasn't setted a polygon
   // To set map in this position
-  var utilityPolygon = new window.google.maps.Polygon({
+  const utilityPolygon = new window.google.maps.Polygon({
     paths: polygon
   });
   return !usePolygon || window.google.maps.geometry.poly.containsLocation(latLng, utilityPolygon);
 };
 exports.checkAddressIsValid = checkAddressIsValid;
-var retrieveAddressByCoords = function retrieveAddressByCoords(_ref, onAddressFoundCallback) {
-  var location = _ref.location,
-    address = _ref.address;
-  var geocoder = new window.google.maps.Geocoder();
-  var parameters = address ? {
-    address: address
+const retrieveAddressByCoords = (_ref, onAddressFoundCallback) => {
+  let {
+    location,
+    address
+  } = _ref;
+  const geocoder = new window.google.maps.Geocoder();
+  const parameters = address ? {
+    address
   } : {
-    location: location
+    location
   };
-  geocoder.geocode(parameters, function (results, status) {
+  geocoder.geocode(parameters, (results, status) => {
     if (status === 'OK') {
-      var addressResults = results.filter(function (result) {
-        return result.types.some(function (type) {
-          return type === _constants.ADDRESS_TYPES.street || type === _constants.ADDRESS_TYPES.route;
-        });
-      });
-      var finalAddress;
+      const addressResults = results.filter(result => result.types.some(type => type === _constants.ADDRESS_TYPES.street || type === _constants.ADDRESS_TYPES.route));
+      let finalAddress;
       if (!(0, _array.isEmpty)(addressResults)) {
-        finalAddress = addressResults.find(function (elem) {
-          return elem.geometry.location_type === _constants.LOCATION_TYPES.rooftop;
-        }) || addressResults.find(function (elem) {
-          return elem.geometry.location_type === _constants.LOCATION_TYPES.rangeInterpolated;
-        }) || addressResults.find(function (elem) {
-          return elem.geometry.location_type === _constants.LOCATION_TYPES.geometricCenter;
-        });
+        finalAddress = addressResults.find(elem => elem.geometry.location_type === _constants.LOCATION_TYPES.rooftop) || addressResults.find(elem => elem.geometry.location_type === _constants.LOCATION_TYPES.rangeInterpolated) || addressResults.find(elem => elem.geometry.location_type === _constants.LOCATION_TYPES.geometricCenter);
       } else if (!(0, _array.isEmpty)(results)) {
-        finalAddress = _objectSpread(_objectSpread({}, results[0]), address ? {
-          formatted_address: address
-        } : {});
+        finalAddress = {
+          ...results[0],
+          ...(address ? {
+            formatted_address: address
+          } : {})
+        };
       }
       if (finalAddress) onAddressFoundCallback(finalAddress);
     }
   });
 };
 exports.retrieveAddressByCoords = retrieveAddressByCoords;
-var findAddressComponent = function findAddressComponent(address, component) {
-  var addrComponent = address.address_components.find(function (attribute) {
-    return attribute.types.includes(component);
-  });
+const findAddressComponent = (address, component) => {
+  const addrComponent = address.address_components.find(attribute => attribute.types.includes(component));
   return addrComponent && addrComponent.long_name;
 };
 exports.findAddressComponent = findAddressComponent;
-var getValue = function getValue(address, latLng, paramName) {
+const getValue = (address, latLng, paramName) => {
   switch (paramName) {
     case _constants.GMAP_PARAMS.latitude:
       return latLng.lat();
@@ -85,7 +70,5 @@ var getValue = function getValue(address, latLng, paramName) {
 };
 // configuration.address_components
 exports.getValue = getValue;
-var isValidConfiguration = function isValidConfiguration(field) {
-  return field && field.configuration && field.configuration.address_components && field.configuration.address_components[_constants.GMAP_PARAMS.latitude] && field.configuration.address_components[_constants.GMAP_PARAMS.longitude] && field.configuration.address_components[_constants.GMAP_PARAMS.formattedAddress];
-};
+const isValidConfiguration = field => field && field.configuration && field.configuration.address_components && field.configuration.address_components[_constants.GMAP_PARAMS.latitude] && field.configuration.address_components[_constants.GMAP_PARAMS.longitude] && field.configuration.address_components[_constants.GMAP_PARAMS.formattedAddress];
 exports.isValidConfiguration = isValidConfiguration;

package/dist/components/UTMap/withGoogleMapScript.js

@@ -8,21 +8,16 @@ var _react = _interopRequireDefault(require("react"));
 var _withScriptjs = _interopRequireDefault(require("react-google-maps/lib/withScriptjs"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 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); }
-var WithGoogleMapScript = function WithGoogleMapScript() {
-  return function (WrappedComponent) {
-    var Component = (0, _withScriptjs.default)(WrappedComponent);
-    var WithGoogleMap = function WithGoogleMap(props) {
-      return /*#__PURE__*/_react.default.createElement(Component, _extends({
-        googleMapURL: "https://maps.googleapis.com/maps/api/js?libraries=places,geometry&key=".concat(process.env.REACT_APP_GMAPS_API_KEY),
-        loadingElement: /*#__PURE__*/_react.default.createElement("div", {
-          style: {
-            height: "100%"
-          }
-        })
-      }, props));
-    };
-    return WithGoogleMap;
-  };
+const WithGoogleMapScript = () => WrappedComponent => {
+  const Component = (0, _withScriptjs.default)(WrappedComponent);
+  const WithGoogleMap = props => /*#__PURE__*/_react.default.createElement(Component, _extends({
+    googleMapURL: "https://maps.googleapis.com/maps/api/js?libraries=places,geometry&key=".concat(process.env.REACT_APP_GMAPS_API_KEY),
+    loadingElement: /*#__PURE__*/_react.default.createElement("div", {
+      style: {
+        height: "100%"
+      }
+    })
+  }, props));
+  return WithGoogleMap;
 };
-var _default = WithGoogleMapScript;
-exports.default = _default;
+var _default = exports.default = WithGoogleMapScript;