@vtx/map 1.1.18 → 1.1.20

package/lib/VtxSearchCheckMap/VtxSearchCheckMap.js

@@ -0,0 +1,1182 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _button = _interopRequireDefault(require("antd/lib/button"));
+
+var _input = _interopRequireDefault(require("antd/lib/input"));
+
+var _message = _interopRequireDefault(require("antd/lib/message"));
+
+var _checkbox = _interopRequireDefault(require("antd/lib/checkbox"));
+
+var _radio = _interopRequireDefault(require("antd/lib/radio"));
+
+var _VtxModal = require("../VtxModal");
+
+var _VtxMap = require("../VtxMap");
+
+var _default2 = _interopRequireWildcard(require("../default"));
+
+var _mapping = require("./mapping");
+
+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 _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); }
+
+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 _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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? 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) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+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; }
+
+var styles = {
+  searchModal: "vtx-ui-searchmap-searchmodal",
+  searchMap: "vtx-ui-searchmap-searchmap",
+  top: "vtx-ui-searchmap-top",
+  bottom: "vtx-ui-searchmap-bottom",
+  content: "vtx-ui-searchmap-content",
+  show: "vtx-ui-searchmap-show",
+  hidden: "vtx-ui-searchmap-hidden",
+  w_l: "vtx-ui-searchmap-w_l",
+  content_left: "vtx-ui-searchmap-content_left",
+  listTitle: "vtx-ui-searchmap-listtitle",
+  title: "vtx-ui-searchmap-title",
+  btn: "vtx-ui-searchmap-btn",
+  lists: "vtx-ui-searchmap-lists",
+  select: "vtx-ui-searchmap-select",
+  scrollauto: "vtx-ui-searchmap-scrollauto",
+  content_right: "vtx-ui-searchmap-content_right",
+  showLabel: "vtx-ui-searchmap-showlabel",
+  hiddenLabel: "vtx-ui-searchmap-hiddenlabel",
+  otherModal: "vtx-ui-searchmap-othermodal"
+}; // message.config({
+//   top: document.getElementById('root').offsetHeight/3,
+//   duration: 5,
+// });
+
+var warning = function warning() {
+  _message["default"].warning("位置点查询失败,请缩小比例尺或切换关键字后再重新查询!");
+};
+
+function distinct(ary) {
+  var pts = _toConsumableArray(ary);
+
+  if (pts[0][0] == pts[pts.length - 1][0] && pts[0][1] == pts[pts.length - 1][1]) {
+    pts.pop();
+    return distinct(pts);
+  } else {
+    return pts;
+  }
+}
+
+var getIcon = function getIcon(type) {
+  return _default2.antdMajorVersion === "4" ? /*#__PURE__*/_react["default"].createElement(_default2.VtxMapIcon, {
+    type: "icon-".concat(_mapping.iconMapping[type])
+  }) : type;
+};
+
+var VtxSearchCheckMap = /*#__PURE__*/function (_React$Component) {
+  _inherits(VtxSearchCheckMap, _React$Component);
+
+  var _super = _createSuper(VtxSearchCheckMap);
+
+  function VtxSearchCheckMap(props) {
+    var _this;
+
+    _classCallCheck(this, VtxSearchCheckMap);
+
+    _this = _super.call(this, props);
+
+    _defineProperty(_assertThisInitialized(_this), "getMultiRes", function (graphicType) {
+      var resData = [];
+      var _this$state = _this.state,
+          graphicValue = _this$state.graphicValue,
+          editGraphic = _this$state.editGraphic;
+
+      switch (graphicType) {
+        case "polygon":
+          [].concat(_toConsumableArray(graphicValue || []), _toConsumableArray(editGraphic || [])).forEach(function (item) {
+            resData.push({
+              rings: distinct(item.rings || item.geometry.rings),
+              area: _this.map.getPolygonArea(distinct(item.rings || item.geometry.rings))
+            });
+          });
+          break;
+
+        default:
+          break;
+      }
+
+      return resData.length ? resData : null;
+    });
+
+    _this.map = null; //Map组件的ref对象
+
+    _this.mapLoaded = false;
+    _this.isDrawStatus = false;
+    _this.isClickMap = false;
+    _this.apid = []; //所有点id,除编辑点外
+
+    _this.loadExtent = null;
+    _this.mapId = "searchMap".concat(new Date().getTime());
+    _this.multiDraw = props.multiDraw && ["polygon"].includes(props.graphicType);
+    _this.clickable = false, // 多个面绘制时，是否可以点击面进行编辑
+    _this.state = {
+      //列表和地图宽度切换的动画需要
+      isShowList: false,
+      //可拖动用于定位的点
+      locationPoint: [],
+      //搜索框文字
+      searchValue: "",
+      //搜索出来的列表点位
+      listPoint: [],
+      //列表数据
+      listMess: [],
+      // 返回点位/图形
+      graphicType: props.graphicType || "point",
+      isDraw: props.graphicType !== "point",
+      parameter: props.drawParameter,
+      graphicValue: _this.multiDraw ? [] : null,
+      // 绘制图元id集合
+      drawGraphID: _this.multiDraw ? ["drawnGraph"] : "drawnGraph",
+
+      /*地图Api参数*/
+      mapCenter: props.mapCenter || "",
+      maxZoom: props.maxZoom,
+      minZoom: props.minZoom,
+      wkid: props.wkid,
+      mapType: props.mapType || "bmap",
+      mapStyle: props.mapStyle,
+      mapServer: props.mapServer,
+      setCenter: false,
+      mapVisiblePoints: {
+        fitView: [],
+        type: "all"
+      },
+      setVisiblePoints: false,
+      isDoEdit: false,
+      isEndEdit: false,
+      editGraphicId: "",
+      editGraphic: _this.multiDraw ? [] : null,
+      mapZoomLevel: props.mapZoomLevel || 11,
+      setZoomLevel: false,
+
+      /*modal参数*/
+      modal1Visible: props.modal1Visible || false,
+      isShowOther: props.isShowOther || false,
+      otherText: props.otherText || "显示服务区域",
+      isShowOtherGraph: props.isShowOther || false,
+      // openlayer
+      olProps: props.olProps,
+      // 坐标反查
+      checkValue: false
+    };
+    return _this;
+  } // 绘制多个图元时返回参数
+
+
+  _createClass(VtxSearchCheckMap, [{
+    key: "callback",
+    value: //经纬度回调
+    function callback() {
+      var fun = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "callback";
+
+      if (fun in this.props && typeof this.props[fun] === "function") {
+        var editGraphicId = this.state.editGraphicId;
+
+        switch (this.state.graphicType) {
+          case "point":
+            var locationPoint = this.state.locationPoint;
+
+            if (this.map.getGraphic("locationPoint")) {
+              var p = this.map.getGraphic(locationPoint[0].id).geometry;
+              this.props[fun]([p.x, p.y]);
+            } else {
+              return [];
+            }
+
+            break;
+
+          case "circle":
+            this.props[fun](this.state.graphicValue ? {
+              x: this.state.graphicValue.geometry.x,
+              y: this.state.graphicValue.geometry.y,
+              radius: this.state.graphicValue.geometry.radius,
+              area: this.state.graphicValue.area
+            } : null);
+            break;
+
+          case "polygon":
+            if (this.multiDraw) {
+              this.props[fun](this.getMultiRes("polygon"));
+              return;
+            }
+
+            if (this.map.getGraphic(editGraphicId)) {
+              var _p = this.map.getGraphic(editGraphicId);
+
+              this.props[fun]({
+                rings: distinct(_p.geometry.rings),
+                area: this.map.getPolygonArea(distinct(_p.geometry.rings))
+              });
+            } else {
+              this.props[fun](this.state.graphicValue ? {
+                rings: distinct(this.state.graphicValue.geometry.rings),
+                area: this.state.graphicValue.area
+              } : null);
+            }
+
+            break;
+
+          case "rectangle":
+            this.props[fun](this.state.graphicValue ? {
+              rings: distinct(this.state.graphicValue.geometry.rings),
+              area: this.state.graphicValue.area
+            } : null);
+            break;
+
+          case "polyline":
+            if (this.map.getGraphic(editGraphicId)) {
+              var _p2 = this.map.getGraphic(editGraphicId);
+
+              this.props[fun]({
+                paths: _p2.geometry.paths,
+                length: this.map.calculateDistance(_p2.geometry.paths)
+              });
+            } else {
+              this.props[fun](this.state.graphicValue ? {
+                paths: this.state.graphicValue.geometry.paths,
+                length: this.map.calculateDistance(this.state.graphicValue.geometry.paths)
+              } : null);
+            }
+
+            break;
+        }
+      }
+
+      if (this.props.clearDrawnGraph) {
+        this.clearDrawnGraph();
+      }
+    }
+  }, {
+    key: "showOrhidden",
+    value: function showOrhidden(bealoon) {
+      this.setState({
+        isShowList: bealoon
+      });
+    } //绘制定位点(以当前的中心点位参照 => 同时开启点位编辑)
+
+  }, {
+    key: "drawLocationPoint",
+    value: function drawLocationPoint() {
+      var t = this; //判断arcgis,是: 判断中心点是否已经确定,确定,继续走逻辑.不确认.轮询等待
+
+      if (this.props.mapType !== "gmap" || this.map.state.gis.extent && !!this.map.state.gis.extent.xmax) {
+        var lglt = this.map.getMapExtent(),
+            editGraphic = null,
+            editGraphicId = "locationPoint";
+
+        if (!this.multiDraw && this.props.editParam) {
+          // && (this.props.graphicType == 'polyline' || this.props.graphicType == 'polygon')
+          editGraphic = _objectSpread(_objectSpread({}, this.props.editParam), {}, {
+            id: "drawnGraph"
+          });
+          editGraphicId = "drawnGraph";
+        }
+
+        if (this.multiDraw && Array.isArray(this.props.editParam) && this.props.editParam.length) {
+          // && (this.props.graphicType == 'polyline' || this.props.graphicType == 'polygon')
+          editGraphic = this.props.editParam.map(function (item, index) {
+            return _objectSpread(_objectSpread({}, item), {}, {
+              id: "drawnGraph".concat(index)
+            });
+          });
+          editGraphicId = null;
+        }
+
+        this.isinit = false;
+        this.setState({
+          editGraphic: editGraphic,
+          locationPoint: [{
+            id: "locationPoint",
+            longitude: (t.props.mapCenter || [])[0] || lglt.nowCenter.lng,
+            latitude: (t.props.mapCenter || [])[1] || lglt.nowCenter.lat,
+            // url: `${configUrl.mapServerURL}/images/defaultMarker.png`,
+            url: require("../VtxMap/images/defaultMarker.png"),
+            config: {
+              zIndex: 1000
+            }
+          }]
+        }, function () {
+          t.setState({
+            isDoEdit: true,
+            editGraphicId: editGraphicId
+          }, function () {
+            setTimeout(function () {
+              t.setState({
+                isDoEdit: false
+              });
+            }, 500);
+          });
+        });
+      } else {
+        t.loadExtent = setTimeout(function () {
+          t.drawLocationPoint();
+        }, 50);
+      }
+    } //校正定位的点位位置到当前的中心点
+
+  }, {
+    key: "correction",
+    value: function correction() {
+      var t = this; //获取当前中心点经纬度
+
+      var lglt = this.map.getMapExtent();
+      var _t$state = t.state,
+          locationPoint = _t$state.locationPoint,
+          checkValue = _t$state.checkValue;
+      locationPoint = locationPoint.map(function (item, index) {
+        return _objectSpread(_objectSpread({}, item), {}, {
+          longitude: lglt.nowCenter.lng,
+          latitude: lglt.nowCenter.lat
+        });
+      });
+      this.map.updatePoint(locationPoint); // 若坐标反查选中，校正是需要更新输入框中的经纬度
+
+      if (checkValue) this.setState({
+        searchValue: "".concat(lglt.nowCenter.lng, ",").concat(lglt.nowCenter.lat)
+      });
+    } //搜索关键字切换
+
+  }, {
+    key: "changeValue",
+    value: function changeValue(e) {
+      this.setState({
+        searchValue: e.target.value
+      });
+    } //根据关键字搜索数据
+
+  }, {
+    key: "searchList",
+    value: function searchList() {
+      //因为antd组件问题,这边使用手动关键位,控制方法执行
+      var t = this;
+
+      if (!this.state.checkValue) {
+        // 非点位并且点位非坐标反查时
+        var searchPoints = t.map.searchPoints(this.state.searchValue);
+        searchPoints.then(function (results) {
+          if (results.length > 0) {
+            var lsp = [],
+                lsm = [];
+            t.apid = [];
+
+            for (var i = 0; i < results.length; i++) {
+              var r = results[i];
+              lsp.push(_objectSpread(_objectSpread({}, results[i]), {}, {
+                // url: `${configUrl.mapServerURL}/images/defaultMarker_selected.png`,
+                url: require("../VtxMap/images/defaultMarker_selected.png"),
+                labelClass: styles.hiddenLabel
+              }));
+              lsm.push({
+                id: r.id,
+                title: r.config.labelContent,
+                isSelect: false
+              });
+              t.apid.push(r.id);
+            }
+
+            t.setState({
+              listPoint: lsp,
+              listMess: lsm,
+              isShowList: true
+            });
+            t.setFitView();
+          } else {
+            warning();
+          }
+        });
+      } else {
+        var _this$state$searchVal;
+
+        // 点位弹框并坐标反查情况
+        var lnglats = (_this$state$searchVal = this.state.searchValue) === null || _this$state$searchVal === void 0 ? void 0 : _this$state$searchVal.split(","); // 英文逗号分割，若长度为不为2，表示数据格式错误
+
+        if ((lnglats === null || lnglats === void 0 ? void 0 : lnglats.length) !== 2) {
+          _message["default"].warning("请按正确的经纬度格式输入，经度在前，用英文逗号隔开！");
+
+          return;
+        } // 经纬度分别正则校验
+
+
+        if (!new RegExp(/^[\-\+]?(0(\.\d{1,15})?|([1-9](\d)?)(\.\d{1,15})?|1[0-7]\d{1}(\.\d{1,15})?|180\.0{1,15})$/).test(lnglats[0])) {
+          _message["default"].warning("请输入正确格式经度！");
+
+          return;
+        }
+
+        if (!new RegExp(/^[\-\+]?((0|([1-8]\d?))(\.\d{1,15})?|90(\.0{1,15})?)$/).test(lnglats[1])) {
+          _message["default"].warning("请输入正确格式纬度！");
+
+          return;
+        } // 正确的经纬度作为地图中心点
+
+
+        var centerPoint = [{
+          id: "locationPoint",
+          longitude: lnglats[0],
+          latitude: lnglats[1],
+          url: require("../VtxMap/images/defaultMarker.png"),
+          config: {
+            zIndex: 1000
+          }
+        }];
+        t.setState({
+          setCenter: true,
+          mapCenter: lnglats,
+          locationPoint: centerPoint
+        });
+        this.map.updatePoint(centerPoint);
+      }
+    } //返回最佳位置(zoom,center)
+
+  }, {
+    key: "setFitView",
+    value: function setFitView() {
+      var _this2 = this;
+
+      this.setState({
+        mapVisiblePoints: {
+          fitView: this.apid,
+          type: "all"
+        },
+        setVisiblePoints: true
+      }, function () {
+        _this2.setState({
+          setVisiblePoints: false
+        });
+      });
+    } //清空列表的所有数据(包括点位)
+
+  }, {
+    key: "clearList",
+    value: function clearList() {
+      this.apid = [];
+      this.setState({
+        searchValue: "",
+        listPoint: [],
+        listMess: [],
+        isShowList: false
+      });
+    } //列表选中地址
+
+  }, {
+    key: "chooseAddress",
+    value: function chooseAddress(id) {
+      var t = this;
+      var _this$state2 = this.state,
+          listPoint = _this$state2.listPoint,
+          listMess = _this$state2.listMess;
+      var mapCenter = [];
+      listPoint = listPoint.map(function (item, index) {
+        if (item.id === id) {
+          mapCenter = [item.longitude, item.latitude];
+          return _objectSpread(_objectSpread({}, item), {}, {
+            url: require("../VtxMap/images/defaultMarker.png"),
+            labelClass: styles.showLabel
+          });
+        } else {
+          return _objectSpread(_objectSpread({}, item), {}, {
+            url: require("../VtxMap/images/defaultMarker_selected.png"),
+            labelClass: styles.hiddenLabel
+          });
+        }
+      });
+      listMess = listMess.map(function (item, index) {
+        if (item.id === id) {
+          return _objectSpread(_objectSpread({}, item), {}, {
+            isSelect: true
+          });
+        } else {
+          return _objectSpread(_objectSpread({}, item), {}, {
+            isSelect: false
+          });
+        }
+      });
+      this.setState({
+        listPoint: listPoint,
+        listMess: listMess,
+        mapCenter: mapCenter,
+        setCenter: true
+      }, function () {
+        t.setState({
+          setCenter: false
+        });
+
+        if (t.state.graphicType == "point") {
+          t.correction();
+        }
+      });
+    }
+  }, {
+    key: "clickGraphic",
+    value: function clickGraphic(obj) {
+      var _this3 = this;
+
+      if (obj.type === "point" && obj.attributes.other === "search") {
+        this.chooseAddress(obj.attributes.id);
+      }
+
+      if (this.clickable && obj.type === "polygon") {
+        var _obj$param$attributes;
+
+        // 开启编辑
+        this.setState({
+          editGraphicId: obj.param.id || ((_obj$param$attributes = obj.param.attributes) === null || _obj$param$attributes === void 0 ? void 0 : _obj$param$attributes.id),
+          isDoEdit: false
+        }, function () {
+          _this3.setState({
+            isDoEdit: true
+          });
+        });
+      }
+    }
+  }, {
+    key: "closeModal",
+    value: function closeModal(e) {
+      if (this.isDrawStatus && this.isClickMap) {
+        _message["default"].warning("请双击结束图元编辑");
+      } else {
+        if ("closeModal" in this.props) {
+          this.props.closeModal();
+        } else {
+          this.setState({
+            modal1Visible: false
+          });
+        } // if(this.props.clearDrawnGraph){
+
+
+        this.clearDrawnGraph(); // }
+      }
+    }
+  }, {
+    key: "clearDrawnGraph",
+    value: function clearDrawnGraph() {
+      var _this4 = this;
+
+      this.isDrawStatus = true;
+      this.setState({
+        isDraw: this.state.graphicType !== "point",
+        graphicValue: this.multiDraw ? [] : null,
+        isEndEdit: this.state.graphicType !== "point"
+      }, function () {
+        _this4.setState({
+          isEndEdit: false
+        });
+      });
+    }
+  }, {
+    key: "continueDraw",
+    value: function continueDraw() {
+      var _this5 = this;
+
+      this.clickable = false;
+      this.setState({
+        isDraw: false,
+        isCloseDraw: true,
+        isEndEdit: false,
+        graphicValue: null
+      }, function () {
+        _this5.setState({
+          isDraw: true,
+          isCloseDraw: false,
+          isEndEdit: true
+        });
+      });
+    }
+  }, {
+    key: "editGraphic",
+    value: function editGraphic() {
+      var _this6 = this;
+
+      if (this.isDrawStatus && this.isClickMap) {
+        _message["default"].warning("请双击结束图元编辑");
+
+        return;
+      }
+
+      _message["default"].info("请点击图元进行编辑");
+
+      this.clickable = true;
+      this.isDrawStatus = false;
+      this.setState({
+        isDraw: true,
+        isCloseDraw: false,
+        isDoEdit: false
+      }, function () {
+        _this6.setState({
+          isDraw: false,
+          isCloseDraw: true,
+          isDoEdit: true
+        });
+      });
+    }
+  }, {
+    key: "editGraphicChange",
+    value: function editGraphicChange(obj) {
+      var checkValue = this.state.checkValue;
+      console.log(checkValue); // 若坐标反查选中
+
+      if (checkValue) {
+        this.setState({
+          searchValue: "".concat(obj.geometry.x, ",").concat(obj.geometry.y)
+        });
+      }
+
+      if (!this.multiDraw) return;
+      var _this$state3 = this.state,
+          graphicValue = _this$state3.graphicValue,
+          editGraphic = _this$state3.editGraphic;
+      this.setState({
+        graphicValue: (graphicValue || []).map(function (item) {
+          return item.id === obj.id ? obj : item;
+        }),
+        editGraphic: (editGraphic || []).map(function (item) {
+          return item.id === obj.id ? obj : item;
+        })
+      });
+    } // 点位反查
+
+  }, {
+    key: "counterCheck",
+    value: function counterCheck() {
+      var checkValue = this.state.checkValue;
+      this.setState({
+        checkValue: !checkValue
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this7 = this;
+
+      var t = this;
+      var _this$state4 = this.state,
+          isShowList = _this$state4.isShowList,
+          searchValue = _this$state4.searchValue,
+          locationPoint = _this$state4.locationPoint,
+          listPoint = _this$state4.listPoint,
+          listMess = _this$state4.listMess,
+          mapZoomLevel = _this$state4.mapZoomLevel,
+          setZoomLevel = _this$state4.setZoomLevel,
+          maxZoom = _this$state4.maxZoom,
+          minZoom = _this$state4.minZoom,
+          wkid = _this$state4.wkid,
+          mapServer = _this$state4.mapServer,
+          mapCenter = _this$state4.mapCenter,
+          setCenter = _this$state4.setCenter,
+          mapType = _this$state4.mapType,
+          mapStyle = _this$state4.mapStyle,
+          mapVisiblePoints = _this$state4.mapVisiblePoints,
+          setVisiblePoints = _this$state4.setVisiblePoints,
+          isDoEdit = _this$state4.isDoEdit,
+          editGraphicId = _this$state4.editGraphicId,
+          isEndEdit = _this$state4.isEndEdit,
+          modal1Visible = _this$state4.modal1Visible,
+          drawGraphID = _this$state4.drawGraphID,
+          isShowOther = _this$state4.isShowOther,
+          otherText = _this$state4.otherText,
+          isShowOtherGraph = _this$state4.isShowOtherGraph,
+          editGraphic = _this$state4.editGraphic,
+          graphicType = _this$state4.graphicType,
+          graphicValue = _this$state4.graphicValue,
+          olProps = _this$state4.olProps,
+          checkValue = _this$state4.checkValue;
+      var InputProps = {
+        style: {
+          width: "200px",
+          "margin-right": "10px"
+        },
+        placeholder: "输入关键字",
+        value: searchValue,
+        onChange: this.changeValue.bind(this),
+        onPressEnter: this.searchList.bind(this),
+        onKeyDown: this.changeValue.bind(this)
+      }; // 经纬度反查输入框
+
+      var checkInputProps = {
+        style: {
+          width: "200px",
+          "margin-right": "10px"
+        },
+        placeholder: "经度在前，英文逗号间隔",
+        value: searchValue,
+        onChange: this.changeValue.bind(this),
+        onPressEnter: this.searchList.bind(this),
+        onKeyDown: this.changeValue.bind(this)
+      };
+      var drawProps = this.state.graphicType == "point" || t.isinit ? {
+        isDraw: this.state.isDraw,
+        isCloseDraw: this.state.isCloseDraw
+      } : {
+        isDraw: this.state.isDraw,
+        isCloseDraw: this.state.isCloseDraw,
+        drawEnd: function drawEnd(obj) {
+          _this7.isDrawStatus = false;
+          _this7.isClickMap = false;
+          var objparam = {
+            graphicValue: _this7.multiDraw ? [].concat(_toConsumableArray(graphicValue || []), [obj]) : obj,
+            isDoEdit: !_this7.multiDraw,
+            isDraw: _this7.multiDraw
+          };
+
+          if (!_this7.multiDraw && (obj.geometryType == "polyline" || obj.geometryType == "polygon")) {
+            objparam.editGraphicId = obj.id;
+          }
+
+          _this7.setState(objparam);
+        },
+        mapDraw: {
+          geometryType: this.state.graphicType,
+          parameter: this.state.parameter || (this.state.graphicType == "polyline" ? {
+            color: "#108edf",
+            //线颜色,
+            pellucidity: 1,
+            //线透明度,
+            lineWidth: 3,
+            //线宽度
+            lineType: "solid"
+          } : this.state.graphicType == "polygon" || this.state.graphicType == "circle" || this.state.graphicType == "rectangle" ? {
+            color: "#ffffff",
+            //填充色,
+            lineColor: "#108edf",
+            //线颜色,
+            lineOpacity: 1,
+            //线透明度,
+            lineWidth: 3,
+            //线宽度,
+            pellucidity: 0.8,
+            //填充透明度
+            lineType: "solid"
+          } : {}),
+          data: this.multiDraw ? null : {
+            id: drawGraphID
+          }
+        }
+      };
+      var mapPoints = [],
+          mapLines = [],
+          mapPolygons = [],
+          mapCircles = [];
+
+      if (graphicType == "point") {
+        mapPoints = [].concat(_toConsumableArray(locationPoint), _toConsumableArray(listPoint));
+      } else {
+        mapPoints = _toConsumableArray(listPoint);
+      }
+
+      if (graphicType === "polygon") {
+        if (editGraphic) {
+          var _mapPolygons;
+
+          Array.isArray(editGraphic) ? (_mapPolygons = mapPolygons).push.apply(_mapPolygons, _toConsumableArray(editGraphic)) : mapPolygons.push(editGraphic);
+          !this.multiDraw && (drawProps = null);
+        }
+      }
+
+      if (graphicType === "polyline") {
+        if (editGraphic) {
+          mapLines.push(editGraphic);
+          drawProps = null;
+        }
+      }
+
+      if (graphicType === "rectangle") {
+        if (editGraphic) {
+          mapPolygons.push(editGraphic);
+          drawProps = null;
+        }
+      }
+
+      if (graphicType === "circle") {
+        if (editGraphic) {
+          mapCircles.push(editGraphic);
+          drawProps = null;
+        }
+      }
+
+      if (isShowOtherGraph) {
+        var otherGraph = this.props.otherGraph;
+
+        if (otherGraph) {
+          mapPoints = [].concat(_toConsumableArray(mapPoints), _toConsumableArray(otherGraph.point || []));
+          mapLines = [].concat(_toConsumableArray(mapLines), _toConsumableArray(otherGraph.polyline || []));
+          mapPolygons = [].concat(_toConsumableArray(mapPolygons), _toConsumableArray(otherGraph.polygon || []));
+          mapCircles = [].concat(_toConsumableArray(mapCircles), _toConsumableArray(otherGraph.circle || []));
+        }
+      }
+
+      return /*#__PURE__*/_react["default"].createElement(_VtxModal.VtxModal, {
+        title: this.state.graphicType == "point" ? "定位" : "绘制",
+        style: {
+          top: 50
+        },
+        visible: modal1Visible,
+        maximize: true,
+        isNotMoving: true,
+        wrapClassName: styles.searchModal,
+        bodyStyle: {
+          height: "".concat(window.innerHeight * 0.7, "px")
+        },
+        maskClosable: false,
+        onCancel: this.closeModal.bind(this),
+        footer: /*#__PURE__*/_react["default"].createElement("div", {
+          className: styles.bottom
+        }, /*#__PURE__*/_react["default"].createElement(_button["default"], {
+          type: "primary",
+          onClick: function onClick() {
+            _this7.callback();
+          },
+          icon: getIcon("check")
+        }, "\u786E\u5B9A"), /*#__PURE__*/_react["default"].createElement(_button["default"], {
+          onClick: this.closeModal.bind(this),
+          icon: getIcon("close")
+        }, "\u5173\u95ED"))
+      }, /*#__PURE__*/_react["default"].createElement("div", {
+        className: styles.searchMap
+      }, /*#__PURE__*/_react["default"].createElement("div", {
+        className: styles.top
+      }, mapType == "gmap" || mapType == "olmap" ? "" : [!checkValue ? /*#__PURE__*/_react["default"].createElement(_input["default"], _extends({
+        key: "1"
+      }, InputProps)) : /*#__PURE__*/_react["default"].createElement(_input["default"], _extends({
+        key: "1"
+      }, checkInputProps)), this.state.graphicType == "point" ? /*#__PURE__*/_react["default"].createElement(_radio["default"], {
+        onClick: this.counterCheck.bind(this),
+        checked: checkValue
+      }, "\u5750\u6807\u53CD\u67E5") : null, /*#__PURE__*/_react["default"].createElement(_button["default"], {
+        key: "2",
+        type: "primary",
+        onClick: this.searchList.bind(this),
+        icon: getIcon("search")
+      }, "\u67E5\u8BE2"), /*#__PURE__*/_react["default"].createElement(_button["default"], {
+        key: "3",
+        onClick: this.clearList.bind(this),
+        icon: getIcon("close")
+      }, "\u6E05\u7A7A")], this.state.graphicType == "point" ? /*#__PURE__*/_react["default"].createElement(_button["default"], {
+        onClick: this.correction.bind(this),
+        icon: getIcon("environment")
+      }, "\u6821\u6B63") : null, this.state.graphicType != "point" ? /*#__PURE__*/_react["default"].createElement(_button["default"], {
+        disabled: this.isDrawStatus,
+        onClick: function onClick() {
+          _this7.isDrawStatus = true;
+
+          if (_this7.multiDraw) {
+            _this7.clickable = false;
+            graphicValue === null || graphicValue === void 0 ? void 0 : graphicValue.forEach(function (item) {
+              return t.map.removeGraphic(item.id, "draw");
+            });
+            editGraphic === null || editGraphic === void 0 ? void 0 : editGraphic.forEach(function (item) {
+              return t.map.removeGraphic(item.id, "draw");
+            });
+
+            _this7.setState({
+              isDraw: false,
+              isCloseDraw: true,
+              isEndEdit: false,
+              graphicValue: null,
+              editGraphic: null
+            }, function () {
+              _this7.setState({
+                isDraw: true,
+                isCloseDraw: false,
+                isEndEdit: true
+              });
+            });
+          } else {
+            _this7.setState({
+              isDraw: true,
+              graphicValue: null,
+              editGraphic: null,
+              isEndEdit: true
+            }, function () {
+              t.map.removeGraphic("drawnGraph", "draw");
+              t.setState({
+                isEndEdit: false
+              });
+            });
+          }
+
+          _this7.callback("editDraw");
+        },
+        icon: getIcon("edit")
+      }, "\u91CD\u65B0\u7ED8\u5236") : null, this.multiDraw && /*#__PURE__*/_react["default"].createElement(_button["default"], {
+        onClick: this.continueDraw.bind(this),
+        icon: getIcon("edit")
+      }, "\u7EE7\u7EED\u7ED8\u5236"), this.multiDraw && /*#__PURE__*/_react["default"].createElement(_button["default"], {
+        onClick: this.editGraphic.bind(this),
+        icon: getIcon("edit")
+      }, "\u7F16\u8F91\u56FE\u5143"), mapType == "gmap" || mapType == "olmap" ? "" : /*#__PURE__*/_react["default"].createElement(_button["default"], {
+        onClick: this.setFitView.bind(this),
+        icon: getIcon("sync")
+      }, "\u8FD4\u56DE\u5168\u5C40\u5730\u56FE"), isShowOther ? /*#__PURE__*/_react["default"].createElement("div", {
+        className: styles.otherModal
+      }, /*#__PURE__*/_react["default"].createElement(_checkbox["default"], {
+        checked: isShowOtherGraph,
+        onChange: function onChange(e) {
+          _this7.setState({
+            isShowOtherGraph: e.target.checked
+          });
+        }
+      }, otherText)) : ""), /*#__PURE__*/_react["default"].createElement("div", {
+        className: styles.content,
+        style: {
+          paddingLeft: mapType == "gmap" || mapType == "olmap" ? "0px" : "25px"
+        }
+      }, mapType == "gmap" || mapType == "olmap" ? "" : /*#__PURE__*/_react["default"].createElement("div", {
+        className: "".concat(styles.content_left, " ").concat(isShowList ? styles.w_l : "")
+      }, /*#__PURE__*/_react["default"].createElement("div", {
+        className: "".concat(isShowList ? styles.show : styles.hidden)
+      }, /*#__PURE__*/_react["default"].createElement("div", {
+        className: styles.listTitle
+      }, /*#__PURE__*/_react["default"].createElement("div", {
+        className: styles.title
+      }, "\u67E5\u8BE2\u7ED3\u679C"), /*#__PURE__*/_react["default"].createElement("div", {
+        onClick: function onClick() {
+          return _this7.showOrhidden(false);
+        },
+        className: styles.btn
+      }, /*#__PURE__*/_react["default"].createElement(_default2.VtxMapIcon, {
+        type: "icon-doubleleft"
+      }))), /*#__PURE__*/_react["default"].createElement("div", {
+        className: styles.scrollauto
+      }, listMess.map(function (item, index) {
+        return /*#__PURE__*/_react["default"].createElement("div", {
+          key: index,
+          onClick: function onClick() {
+            return _this7.chooseAddress(item.id);
+          },
+          className: "".concat(styles.lists, " ").concat(item.isSelect ? styles.select : "")
+        }, item.title);
+      }))), /*#__PURE__*/_react["default"].createElement("div", {
+        onClick: function onClick() {
+          return _this7.showOrhidden(true);
+        },
+        className: "".concat(styles.btn, " ").concat(!isShowList ? styles.show : styles.hidden)
+      }, /*#__PURE__*/_react["default"].createElement(_default2.VtxMapIcon, {
+        type: "icon-doubleright"
+      }))), /*#__PURE__*/_react["default"].createElement("div", {
+        className: styles.content_right
+      }, /*#__PURE__*/_react["default"].createElement(_VtxMap.VtxMap, _extends({
+        getMapInstance: function getMapInstance(map) {
+          if (map) _this7.map = map;
+        },
+        mapType: mapType,
+        mapStyle: mapStyle,
+        mapServer: mapServer,
+        wkid: wkid,
+        mapId: t.mapId,
+        setCenter: setCenter,
+        mapCenter: mapCenter,
+        minZoom: minZoom,
+        maxZoom: maxZoom,
+        mapZoomLevel: mapZoomLevel,
+        setZoomLevel: setZoomLevel,
+        mapPoints: mapPoints,
+        mapLines: mapLines,
+        mapPolygons: mapPolygons,
+        mapCircles: mapCircles,
+        mapVisiblePoints: mapVisiblePoints,
+        setVisiblePoints: setVisiblePoints,
+        isDoEdit: isDoEdit,
+        isEndEdit: isEndEdit,
+        editGraphicId: editGraphicId,
+        editGraphicChange: this.editGraphicChange.bind(this),
+        clickGraphic: this.clickGraphic.bind(this),
+        clickMap: function clickMap() {
+          t.isClickMap = true;
+        },
+        olProps: olProps
+      }, drawProps))))));
+    }
+  }, {
+    key: "initSearchMap",
+    value: function initSearchMap() {
+      var _this8 = this;
+
+      if (this.props.modal1Visible
+      /*&& !this.state.locationPoint[0]*/
+      ) {
+        if (this.map) {
+          this.map.loadMapComplete.then(function () {
+            if (!_this8.mapLoaded) {
+              _this8.mapLoaded = true;
+
+              _this8.drawLocationPoint();
+            }
+          });
+        }
+      }
+    }
+  }, {
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      //绘制定位点(以当前的中心点位参照=>初始化好后才有ref可以获取中心点)
+      this.initSearchMap();
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps, prevState) {
+      //重新渲染结束
+      this.initSearchMap();
+    }
+  }, {
+    key: "componentWillReceiveProps",
+    value: function componentWillReceiveProps(nextProps) {
+      var _this9 = this;
+
+      var t = this;
+      this.isClickMap = false;
+
+      if (t.state.graphicType !== nextProps.graphicType && !!this.map) {
+        this.map.clearAll();
+        t.mapLoaded = false;
+        t.isinit = true;
+      }
+
+      if (nextProps.editParam) {
+        t.mapLoaded = false;
+      }
+
+      t.isDrawStatus = nextProps.graphicType !== "point" && !nextProps.editParam;
+      this.setState({
+        modal1Visible: nextProps.modal1Visible,
+        maxZoom: nextProps.maxZoom,
+        minZoom: nextProps.minZoom,
+        wkid: nextProps.wkid,
+        mapCenter: nextProps.mapCenter || "",
+        mapType: nextProps.mapType || "bmap",
+        mapStyle: nextProps.mapStyle,
+        mapServer: nextProps.mapServer,
+        graphicType: nextProps.graphicType || "point",
+        isDraw: nextProps.graphicType !== "point" && !nextProps.editParam,
+        isCloseDraw: !(nextProps.graphicType !== "point" && !nextProps.editParam),
+        editGraphicId: ""
+      }, function () {
+        t.setState({
+          isCloseDraw: false
+        });
+        t.initSearchMap();
+      });
+      setTimeout(function () {
+        //实现2+次进入时,清理数据
+        if (nextProps.modal1Visible) {
+          _this9.clearList();
+
+          _this9.setState({
+            setZoomLevel: true
+          }, function () {
+            _this9.setState({
+              setZoomLevel: false
+            });
+          });
+
+          if (!!_this9.map && !!_this9.state.locationPoint[0] && nextProps.mapCenter && !!nextProps.mapCenter[0]) {
+            if (_this9.map.getGraphic("locationPoint")) {
+              switch (nextProps.mapType) {
+                case "bmap":
+                  _this9.map.getGraphic("locationPoint").mapLayer.setPosition(new BMap.Point(nextProps.mapCenter[0], nextProps.mapCenter[1]));
+
+                  break;
+
+                case "amap":
+                  _this9.map.getGraphic("locationPoint").mapLayer.setPosition(new AMap.LngLat(nextProps.mapCenter[0], nextProps.mapCenter[1]));
+
+                  break;
+
+                case "tmap":
+                  _this9.map.getGraphic("locationPoint").mapLayer.setLngLat(new T.LngLat(nextProps.mapCenter[0], nextProps.mapCenter[1]));
+
+                  break;
+
+                case "gmap":
+                  _this9.map.getGraphic("locationPoint").mapLayer.geometry.setLatitude(nextProps.mapCenter[1]);
+
+                  _this9.map.getGraphic("locationPoint").mapLayer.geometry.setLongitude(nextProps.mapCenter[0]);
+
+                  _this9.map.state.gis.graphics.refresh();
+
+                case "olMap":
+                  _this9.map.getGraphic("locationPoint").mapLayer.setGeometry(new ol.geom.Point(nextProps.mapCenter));
+
+                  break;
+              }
+            }
+
+            _this9.map.setCenter(nextProps.mapCenter);
+          }
+        }
+      }, 100);
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      //关闭moveTo定时
+      var t = this;
+
+      if (t.loadExtent) {
+        clearInterval(t.loadExtent);
+      }
+    }
+  }]);
+
+  return VtxSearchCheckMap;
+}(_react["default"].Component);
+
+var _default = VtxSearchCheckMap;
+exports["default"] = _default;
+module.exports = exports["default"];
+//# sourceMappingURL=VtxSearchCheckMap.js.map