@widergy/energy-ui 2.12.1 → 2.12.2

package/dist/components/UTMap/index.js

@@ -15,104 +15,130 @@ 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(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 _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 _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(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-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({
+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({
         searchValue: ''
       });
       // Update address on search box and complete field value on store
       (0, _utils.retrieveAddressByCoords)({
         address: forcedAddress,
         location: latLng
-      }, address => {
-        this.setState({
+      }, function (address) {
+        _this.setState({
           searchValue: address.formatted_address
-        }, () => {
-          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));
+        }, 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);
+          });
           if (changeValue) onChange(addressValue);
         });
       });
     });
-    _defineProperty(this, "updateMarker", latLng => {
+    _defineProperty(_assertThisInitialized(_this), "updateMarker", function (latLng) {
       // Add marker on screen
-      const newMarker = {
+      var newMarker = {
         position: latLng,
         defaultAnimation: 2,
         key: Date.now()
       };
-      const markers = [...(this.props.singleMarker ? [] : [...this.state.markers]), newMarker];
-      this.setState({
-        markers
+      var markers = [].concat(_toConsumableArray(_this.props.singleMarker ? [] : _toConsumableArray(_this.state.markers)), [newMarker]);
+      _this.setState({
+        markers: markers
       });
     });
-    _defineProperty(this, "handleMapClick", event => {
+    _defineProperty(_assertThisInitialized(_this), "handleMapClick", function (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(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({
+    _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({
         markers: nextMarkers
       });
     });
-    _defineProperty(this, "handleMapMounted", mapRef => {
+    _defineProperty(_assertThisInitialized(_this), "handleMapMounted", function (mapRef) {
       // When map is mounted on screen
-      this.map = mapRef;
-      const {
-        input,
-        field
-      } = this.props;
+      _this.map = mapRef;
+      var _this$props2 = _this.props,
+        input = _this$props2.input,
+        field = _this$props2.field;
       if (input.value) {
-        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]]);
+        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]]);
         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(userPosition => {
+        (0, _utils.geolocation)(_this.props.errors.retrieveLocationError).getCurrentPosition(function (userPosition) {
           // If we can retrieve user position...
-          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 = {
+          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 = {
               lat: userLatitude,
               lng: userLongitude
             };
-            this.setState({
+            _this.setState({
               center: actualPosition,
               markers: [{
                 position: actualPosition,
@@ -120,125 +146,133 @@ class UTMap extends _react.PureComponent {
                 defaultAnimation: 2
               }],
               mapLoading: false
-            }, () => {
-              const latlng = new window.google.maps.LatLng(userLatitude, userLongitude);
-              this.updateAddress(latlng, null, true);
+            }, function () {
+              var latlng = new window.google.maps.LatLng(userLatitude, userLongitude);
+              _this.updateAddress(latlng, null, true);
             });
           } else {
             // In other case we set map on startLocation
-            const latlng = new window.google.maps.LatLng(this.state.center.lat, this.state.center.lng);
-            this.updateAddress(latlng, null, true);
+            var 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
-        () => {
-          const latlng = new window.google.maps.LatLng(this.state.center.lat, this.state.center.lng);
-          this.updateAddress(latlng, null, true);
+        function () {
+          var latlng = new window.google.maps.LatLng(_this.state.center.lat, _this.state.center.lng);
+          _this.updateAddress(latlng, null, true);
         });
       }
     });
-    _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];
+    _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];
       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;
   }
-  componentDidMount() {
-    const startPosition = {
-      position: {
-        lat: null,
-        lng: null
+  _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
+        });
       }
-    };
-    const {
-      input,
-      startLocation,
-      field
-    } = this.props;
-    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
-      });
+  }, {
+    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, null, this.props.errors.retrievingLocation) : this.state.invalidConfiguration ? /*#__PURE__*/_react.default.createElement(_UTLabel.default, {
+        colorTheme: "error",
+        variant: "small"
+      }, this.props.errors.invalidConfig) : /*#__PURE__*/_react.default.createElement(_UTLabel.default, {
+        colorTheme: "error",
+        variant: "small"
+      }, this.props.errors.retrieveLocationError), !showOnlyMap && /*#__PURE__*/_react.default.createElement(_UTLabel.default, {
+        colorTheme: "error",
+        variant: "small",
+        className: _stylesModule.default.error
+      }, (0, _form.shouldShowErrors)(this.props.meta) ? this.props.meta.error : ''));
     }
-  }
-  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, null, this.props.errors.retrievingLocation) : this.state.invalidConfiguration ? /*#__PURE__*/_react.default.createElement(_UTLabel.default, {
-      colorTheme: "error",
-      variant: "small"
-    }, this.props.errors.invalidConfig) : /*#__PURE__*/_react.default.createElement(_UTLabel.default, {
-      colorTheme: "error",
-      variant: "small"
-    }, this.props.errors.retrieveLocationError), !showOnlyMap && /*#__PURE__*/_react.default.createElement(_UTLabel.default, {
-      colorTheme: "error",
-      variant: "small",
-      className: _stylesModule.default.error
-    }, (0, _form.shouldShowErrors)(this.props.meta) ? this.props.meta.error : ''));
-  }
-}
+  }]);
+  return UTMap;
+}(_react.PureComponent);
 UTMap.propTypes = _types.UTMapPropTypes;
 UTMap.defaultProps = {
   errors: {
@@ -253,4 +287,5 @@ UTMap.defaultProps = {
     }
   }
 };
-var _default = exports.default = (0, _withGoogleMapScript.default)()(UTMap);
+var _default = (0, _withGoogleMapScript.default)()(UTMap);
+exports.default = _default;

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");
-const coordinatePropType = (0, _propTypes.oneOfType)([_propTypes.number, _propTypes.func]);
-const UTMapPropTypes = exports.UTMapPropTypes = {
+var coordinatePropType = (0, _propTypes.oneOfType)([_propTypes.number, _propTypes.func]);
+var UTMapPropTypes = {
   onChange: _propTypes.func.isRequired,
   singleMarker: _propTypes.bool,
   startLocation: (0, _propTypes.shape)({
@@ -37,7 +37,8 @@ const UTMapPropTypes = exports.UTMapPropTypes = {
   apiKey: _propTypes.string,
   disabled: _propTypes.bool
 };
-const GoogleMapsPropTypes = exports.GoogleMapsPropTypes = {
+exports.UTMapPropTypes = UTMapPropTypes;
+var GoogleMapsPropTypes = {
   onMapClick: _propTypes.func.isRequired,
   onMarkerRightClick: _propTypes.func.isRequired,
   center: (0, _propTypes.shape)({
@@ -65,4 +66,5 @@ const GoogleMapsPropTypes = exports.GoogleMapsPropTypes = {
   searchValue: _propTypes.any,
   zoom: _propTypes.number,
   showOnlyMap: _propTypes.bool
-};
+};
+exports.GoogleMapsPropTypes = GoogleMapsPropTypes;

package/dist/components/UTMap/utils.js

@@ -6,57 +6,72 @@ 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");
-const geolocation = message => navigator.geolocation ? navigator.geolocation : {
-  getCurrentPosition(success, failure) {
-    failure(message);
-  }
+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);
+    }
+  };
 };
 exports.geolocation = geolocation;
-const checkAddressIsValid = (latLng, usePolygon, polygon) => {
+var checkAddressIsValid = function 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
-  const utilityPolygon = new window.google.maps.Polygon({
+  var utilityPolygon = new window.google.maps.Polygon({
     paths: polygon
   });
   return !usePolygon || window.google.maps.geometry.poly.containsLocation(latLng, utilityPolygon);
 };
 exports.checkAddressIsValid = checkAddressIsValid;
-const retrieveAddressByCoords = (_ref, onAddressFoundCallback) => {
-  let {
-    location,
-    address
-  } = _ref;
-  const geocoder = new window.google.maps.Geocoder();
-  const parameters = address ? {
-    address
+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
   } : {
-    location
+    location: location
   };
-  geocoder.geocode(parameters, (results, status) => {
+  geocoder.geocode(parameters, function (results, status) {
     if (status === 'OK') {
-      const addressResults = results.filter(result => result.types.some(type => type === _constants.ADDRESS_TYPES.street || type === _constants.ADDRESS_TYPES.route));
-      let finalAddress;
+      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;
       if (!(0, _array.isEmpty)(addressResults)) {
-        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);
+        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;
+        });
       } else if (!(0, _array.isEmpty)(results)) {
-        finalAddress = {
-          ...results[0],
-          ...(address ? {
-            formatted_address: address
-          } : {})
-        };
+        finalAddress = _objectSpread(_objectSpread({}, results[0]), address ? {
+          formatted_address: address
+        } : {});
       }
       if (finalAddress) onAddressFoundCallback(finalAddress);
     }
   });
 };
 exports.retrieveAddressByCoords = retrieveAddressByCoords;
-const findAddressComponent = (address, component) => {
-  const addrComponent = address.address_components.find(attribute => attribute.types.includes(component));
+var findAddressComponent = function findAddressComponent(address, component) {
+  var addrComponent = address.address_components.find(function (attribute) {
+    return attribute.types.includes(component);
+  });
   return addrComponent && addrComponent.long_name;
 };
 exports.findAddressComponent = findAddressComponent;
-const getValue = (address, latLng, paramName) => {
+var getValue = function getValue(address, latLng, paramName) {
   switch (paramName) {
     case _constants.GMAP_PARAMS.latitude:
       return latLng.lat();
@@ -70,5 +85,7 @@ const getValue = (address, latLng, paramName) => {
 };
 // configuration.address_components
 exports.getValue = getValue;
-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];
+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];
+};
 exports.isValidConfiguration = isValidConfiguration;

package/dist/components/UTMap/withGoogleMapScript.js

@@ -7,25 +7,29 @@ exports.default = void 0;
 var _react = _interopRequireDefault(require("react"));
 var _withScriptjs = _interopRequireDefault(require("react-google-maps/lib/withScriptjs"));
 var _types = require("./types");
+var _excluded = ["apiKey"];
 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); }
-const WithGoogleMapScript = () => WrappedComponent => {
-  const Component = (0, _withScriptjs.default)(WrappedComponent);
-  const WithGoogleMap = _ref => {
-    let {
-      apiKey,
-      ...props
-    } = _ref;
-    return /*#__PURE__*/_react.default.createElement(Component, _extends({
-      googleMapURL: "https://maps.googleapis.com/maps/api/js?libraries=places,geometry&key=".concat(apiKey),
-      loadingElement: /*#__PURE__*/_react.default.createElement("div", {
-        style: {
-          height: "100%"
-        }
-      })
-    }, props));
+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 WithGoogleMapScript = function WithGoogleMapScript() {
+  return function (WrappedComponent) {
+    var Component = (0, _withScriptjs.default)(WrappedComponent);
+    var WithGoogleMap = function WithGoogleMap(_ref) {
+      var apiKey = _ref.apiKey,
+        props = _objectWithoutProperties(_ref, _excluded);
+      return /*#__PURE__*/_react.default.createElement(Component, _extends({
+        googleMapURL: "https://maps.googleapis.com/maps/api/js?libraries=places,geometry&key=".concat(apiKey),
+        loadingElement: /*#__PURE__*/_react.default.createElement("div", {
+          style: {
+            height: "100%"
+          }
+        })
+      }, props));
+    };
+    WithGoogleMap.propTypes = _types.UTMapPropTypes.propTypes;
+    return WithGoogleMap;
   };
-  WithGoogleMap.propTypes = _types.UTMapPropTypes.propTypes;
-  return WithGoogleMap;
 };
-var _default = exports.default = WithGoogleMapScript;
+var _default = WithGoogleMapScript;
+exports.default = _default;