/******/ (function() { // webpackBootstrap
/******/ 	"use strict";
/******/ 	// The require scope
/******/ 	var __webpack_require__ = {};
/******/ 	
/************************************************************************/
/******/ 	/* webpack/runtime/compat get default export */
/******/ 	!function() {
/******/ 		// getDefaultExport function for compatibility with non-harmony modules
/******/ 		__webpack_require__.n = function(module) {
/******/ 			var getter = module && module.__esModule ?
/******/ 				function() { return module['default']; } :
/******/ 				function() { return module; };
/******/ 			__webpack_require__.d(getter, { a: getter });
/******/ 			return getter;
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/define property getters */
/******/ 	!function() {
/******/ 		// define getter functions for harmony exports
/******/ 		__webpack_require__.d = function(exports, definition) {
/******/ 			for(var key in definition) {
/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ 				}
/******/ 			}
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
/******/ 	!function() {
/******/ 		__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/make namespace object */
/******/ 	!function() {
/******/ 		// define __esModule on exports
/******/ 		__webpack_require__.r = function(exports) {
/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 			}
/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
/******/ 		};
/******/ 	}();
/******/ 	
/************************************************************************/
var __webpack_exports__ = {};
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);

// EXPORTS
__webpack_require__.d(__webpack_exports__, {
  "mapDrawUtils": function() { return /* binding */ mapDrawUtils; },
  "mapLayerUtils": function() { return /* binding */ mapLayerUtils; },
  "mapViewUtils": function() { return /* binding */ mapViewUtils; },
  "utils": function() { return /* binding */ utils; }
});

;// CONCATENATED MODULE: external "@zpc_npm/vue-iclient-leaflet/_types/global-event"
var global_event_namespaceObject = require("@zpc_npm/vue-iclient-leaflet/_types/global-event");
var global_event_default = /*#__PURE__*/__webpack_require__.n(global_event_namespaceObject);
;// CONCATENATED MODULE: ./src/common/_utils/gis-utils.js
/**
 * zl 20220815
 * 地图视图操作通用中转类
 * 通用组件为适配不同地图框架的视图的操作，
 * 不同的视图状态mapType,不同的地图对象mapTarget做方法的参数来区分转发的对象
 * 包括视图的操作方法绘图、获取图层数据、图层操作等
 * 都在该对象做中转操作，不同的视图状态，调用对应视图的方法。通用组件和视图相关的操作调用这个中间类
 * 该类暂时提供给通用组件使用，特定的组件直接用view的方法
 */

const utils = {
  // 添加map切换监听
  bindChangeMapEvents(fn) {
    global_event_default().on("changeMapType", fn);
  },

  // 移除map切换监听
  offChangeMapEvents(fn) {
    global_event_default().off("changeMapType", fn);
  },

  // getTargetName(mapType, callFun) {
  //   if (mapType === "leaflet") {
  //     mapGetter_leaflet.getTargetName(callFun);
  //   } else if (mapType === "cesium") {
  //     mapGetter_cesium.getTargetName(callFun);
  //   }
  // },
  // _getWebMap(mapType, callFun, targetName) {
  //   if (mapType === "leaflet") {
  //     mapGetter_leaflet.getWebMap(callFun, targetName);
  //   } else if (mapType === "cesium") {
  //     mapGetter_cesium.getWebMap(callFun);
  //   }
  // },
  getWebMap(mapTarget, callFun) {
    global_event_default().getWebMapByMapTarget(mapTarget, callFun);
  },

  getMapTypeByMapTarget(mapTarget) {
    return global_event_default().getMapTypeByMapTarget(mapTarget);
  }

}; // map相关、图层数据相关操作

const mapViewUtils = {
  /**
   * 给mapview绑定事件
   * 如果没有找到对应的view对象，说明view还不存在，就添加load-map事件监听
   */
  bindViewEvents(type, fn, mapTarget) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapInfo = global_event_default().getMapInfoByMapTarget(mapTarget);

    if (!mapInfo) {
      console.error("组件未找到绑定地图");
      return;
    }

    let _webmap = mapInfo.webMap;

    if (_webmap) {
      // 如果是mounted，这个事件表示监听view初始化完成事件，
      // 这里能获取到view已经能获取到，表示事件已经过时，不会执行到，就不需要监听
      if (type === "mounted" && _webmap.map) {
        return;
      }

      _webmap.on(type, fn);
    } else {
      const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);

      if (mapType === "leaflet") {
        global_event_default().once("load-map", e => {
          // 判断是否同一个地图对象的key
          if (e.eventTarget === mapTarget) {
            _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

            if (_webmap) {
              _webmap.on(type, fn);
            }
          }
        });
      } else if (mapType === "cesium") {
        global_event_default().once("load-viewer", e => {
          if (e.eventTarget === mapTarget) {
            _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

            if (_webmap) {
              _webmap.on(type, fn);
            }
          }
        });
      }
    }
  },

  bindViewOnceEvents(type, fn, mapTarget) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapInfo = global_event_default().getMapInfoByMapTarget(mapTarget);

    if (!mapInfo) {
      console.error("组件未找到绑定地图");
      return;
    }

    let _webmap = mapInfo.webMap;

    if (_webmap) {
      // 如果是mounted，这个事件表示监听view初始化完成事件，
      // 这里能获取到view已经能获取到，表示事件已经过时，不会执行到，就不需要监听
      if (type === "mounted" && _webmap.map) {
        return;
      }

      _webmap.once(type, fn);
    } else {
      const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);

      if (mapType === "leaflet") {
        global_event_default().once("load-map", e => {
          // 判断是否同一个地图对象的key
          if (e.eventTarget === mapTarget) {
            _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

            if (_webmap) {
              _webmap.once(type, fn);
            }
          }
        });
      } else if (mapType === "cesium") {
        global_event_default().once("load-viewer", e => {
          if (e.eventTarget === mapTarget) {
            _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

            if (_webmap) {
              _webmap.once(type, fn);
            }
          }
        });
      }
    }
  },

  // _bindViewEvents(type, fn, mapTarget, mapType) {
  //   if (mapType === "leaflet") {
  //     let _webmap = mapEvent_leaflet.getWebMap(mapTarget);
  //     if (_webmap) {
  //       // 如果是mounted，这个事件表示监听view初始化完成事件，
  //       // 这里能获取到view已经能获取到，表示事件已经过时，不会执行到，就不需要监听
  //       if (type === "mounted" && _webmap.map) {
  //         return;
  //       }
  //
  //       _webmap.on(type, fn);
  //     } else {
  //       mapEvent_leaflet.mitt.on("load-map", e => {
  //         if (e.eventTarget === mapTarget) {
  //           _webmap = mapEvent_leaflet.getWebMap(mapTarget);
  //           if (_webmap) {
  //             _webmap.on(type, fn);
  //           }
  //         }
  //       });
  //     }
  //   } else if (mapType === "cesium") {
  //     let _scenceview = mapEvent_cesium.getScenceView();
  //     if (_scenceview) {
  //       _scenceview.on(type, fn);
  //     } else {
  //       mapEvent_cesium.mitt.on("load-viewer", e => {
  //         _scenceview = mapEvent_cesium.getScenceView();
  //         if (_scenceview) {
  //           _scenceview.on(type, fn);
  //         }
  //       });
  //     }
  //   }
  // },
  // _offViewEvents(type, fn, mapTarget, mapType) {
  //   if (mapType === "leaflet") {
  //     let _webmap = mapEvent_leaflet.getWebMap(mapTarget);
  //     if (_webmap) {
  //       _webmap.off(type, fn);
  //     }
  //   } else if (mapType === "cesium") {
  //     let _scenceview = mapEvent_cesium.getScenceView();
  //     if (_scenceview) {
  //       _scenceview.off(type, fn);
  //     }
  //   }
  // },
  offViewEvents(type, fn, mapTarget) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      if (_webmap) {
        _webmap.off(type, fn);
      }
    }
  },

  /**
   * 给map绑定事件
   * 如果没有找到对应的view对象，说明view还不存在，就添加load-map事件监听
   */
  bindMapEvents(type, fn, mapTarget) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      if (_webmap) {
        // 如果是mounted，这个事件表示监听view初始化完成事件，
        // 这里能获取到view已经能获取到，表示事件已经过时，不会执行到，就不需要监听
        if (type === "mounted" && _webmap.map) {
          return;
        }

        _webmap.on(type, fn);
      } else {
        global_event_default().once("load-map", e => {
          // 判断是否同一个地图对象的key
          if (e.eventTarget === mapTarget) {
            _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

            if (_webmap) {
              _webmap.once(type, fn);
            }
          }
        });
      }
    } else if (this._viewState === "cesium") {// return this._scenceView.asdasdasd();
    }
  },

  offMapEvents(type, fn, mapTarget) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      if (_webmap) {
        _webmap.map.off(type, fn);
      }
    }
  },

  fitBounds(mapTarget, rect84) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      let bounds84 = [[rect84[1], rect84[0]], [rect84[3], rect84[2]]];

      _webmap.map.fitBounds(bounds84);
    } else if (mapType === "cesium") {
      _webmap._layerManager.flyToBounds(rect84);
    }
  },

  // _fitBounds(mapTarget, mapType, rect84) {
  //   if (mapType === "leaflet") {
  //     const _webmap = mapEvent_leaflet.getWebMap(mapTarget);
  //     if (_webmap) {
  //       let bounds84 = [
  //         [rect84[1], rect84[0]],
  //         [rect84[3], rect84[2]]
  //       ];
  //       _webmap.map.fitBounds(bounds84);
  //     }
  //   } else if (mapType === "cesium") {
  //     const _scenceview = mapEvent_cesium.getScenceView();
  //     if (_scenceview) {
  //       _scenceview._layerManager.flyToBounds(rect84);
  //     }
  //   }
  // },
  setLayerBringToFrontById(mapTarget, guid, isFront) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      _webmap.setLayerBringToFrontById(guid, isFront);
    } else if (mapType === "cesium") {
      _webmap._layerManager.setLayerBringToFrontById(guid, isFront);
    }
  },

  raiseLayerByTreeId(mapTarget, guid, isFront) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      _webmap.raiseLayerByTreeId(guid, isFront);
    } else if (mapType === "cesium") {
      _webmap._layerManager.raiseLayerById(guid);
    }
  },

  lowerLayerByTreeId(mapTarget, guid) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      _webmap.lowerLayerByTreeId(guid);
    } else if (mapType === "cesium") {
      _webmap._layerManager.lowerLayerById(guid);
    }
  },

  resetLayerZIndex(mapTarget) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      _webmap.resetLayerZIndex();
    } else if (mapType === "cesium") {
      _webmap._layerManager.resetLayerIndex();
    }
  },

  /**
   * 获取视图中心
   * @param {*} mapType
   * @returns 数组。 二维：经度(x)、纬度(y);  三维：经度(x)、纬度(y)、高度(z)、指向、视角、滚动
   */
  getViewPosition(mapTarget) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      let center = _webmap.map.getCenter();

      let scalelevel = _webmap.map.getZoom();

      return {
        position: [center.lng, center.lat],
        scalelevel: scalelevel
      };
    } else if (mapType === "cesium") {}
  },

  /**
   * 设置视图中心
   * @param {*} position 数组 二维：经度(x)、纬度(y);  三维：经度(x)、纬度(y)、高度(z)、指向、视角、滚动
   * @param {*} zoom  级别 二维参数
   * @param {*} mapType
   */
  setViewPosition(mapTarget, position, zoom) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      _webmap.map.setView([position[1], position[0]], zoom);
    } else {}
  },

  getDefaultStyle(mapTarget) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      return _webmap ? _webmap.mapDraw.drawStyle : null;
    } else if (mapType === "cesium") {
      return _webmap ? _webmap._drawManager._defaultStyle : null;
    }
  },

  getBaseLayerInfo(mapTarget) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      return _webmap ? _webmap.getBaseLayerInfo() : null;
    }
  },

  getMapBaseLayerData(mapTarget) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      return _webmap ? _webmap.getMapBaseLayerData() : null;
    }
  },

  showBaseLayer(mapTarget, layerName, visible) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      if (_webmap) {
        _webmap.showBaseLayer(layerName, visible);
      }
    }
  },

  panByrefesh(mapTarget) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      if (_webmap) {
        _webmap.map.panBy([1, 0]);
      }
    }
  }

}; // layer相关操作

const mapLayerUtils = {
  removeLayer(mapTarget, layer) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      if (_webmap) {
        if (_webmap.map.hasLayer(layer)) {
          _webmap.map.removeLayer(layer);
        }
      }
    }
  },

  addTo(mapTarget, layer) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      if (_webmap) {
        layer.addTo(_webmap.map);
      }
    }
  },

  setLayerOpacityStateById(mapTarget, guid, opacity) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      if (_webmap) _webmap.setLayerOpacityStateById(guid, opacity);
    } else if (mapType === "cesium") {
      if (_webmap) _webmap._layerManager.setLayerOpacityById(guid, opacity);
    }
  },

  getLayerTreeData(mapTarget) {
    // mapTarget为空了 获取当前操作状态mapTarget
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();

      if (mapTarget === "") {
        console.log("请设置默认地图状态。");
        return null;
      }
    } // 类型


    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget); // 地图视图的viewmodel

    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      return _webmap ? _webmap.getLayerTreeData() : null;
    } else if (mapType === "cesium") {
      return _webmap ? _webmap._layerManager.getLayerTreeData() : null;
    }
  },

  // _getLayerTreeData(mapTarget, mapType) {
  //   if (mapType === "leaflet") {
  //     const _webmap = mapEvent_leaflet.getWebMap(mapTarget);
  //     return _webmap ? _webmap.getLayerTreeData() : null;
  //   } else if (mapType === "cesium") {
  //     const _scenceview = mapEvent_cesium.getScenceView();
  //     return _scenceview ? _scenceview._layerManager.getLayerTreeData() : null;
  //   }
  // },
  // _setLayerVisibleStateByIds(mapTarget, mapType, ids, visible, eventTarget) {
  //   if (mapType === "leaflet") {
  //     const _webmap = mapEvent_leaflet.getWebMap(mapTarget);
  //     if (_webmap) _webmap.setLayerVisibleStateByIds(ids, visible, eventTarget);
  //   } else if (mapType === "cesium") {
  //     const _scenceview = mapEvent_cesium.getScenceView();
  //     if (_scenceview) _scenceview._layerManager.setLayerVisibleStateByIds(ids, visible);
  //   }
  // },
  setLayerVisibleStateByIds(mapTarget, ids, visible, eventTarget) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      if (_webmap) _webmap.setLayerVisibleStateByIds(ids, visible, eventTarget);
    } else if (mapType === "cesium") {
      if (_webmap) _webmap._layerManager.setLayerVisibleStateByIds(ids, visible);
    }
  },

  getLayerCheckedListKey(mapTarget) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      return _webmap ? _webmap.getLayerCheckedListKey() : null;
    } else if (mapType === "cesium") {
      return _webmap ? _webmap._layerManager.getLayerCheckedListKey() : [];
    }
  },

  // _getLayerCheckedListKey(mapTarget, mapType) {
  //   if (mapType === "leaflet") {
  //     const _webmap = mapEvent_leaflet.getWebMap(mapTarget);
  //     return _webmap ? _webmap.getLayerCheckedListKey() : null;
  //   } else if (mapType === "cesium") {
  //     const _scenceview = mapEvent_cesium.getScenceView();
  //     return _scenceview ? _scenceview._layerManager.getLayerCheckedListKey() : [];
  //   }
  // },
  getLayerCheckedList(mapTarget) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      return _webmap ? _webmap.getLayerCheckedList() : null;
    } else if (mapType === "cesium") {
      return _webmap ? _webmap._layerManager.getLayerCheckedList() : [];
    }
  },

  getLayerDataKey(mapTarget) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      return _webmap ? _webmap.getLayerDataKey() : null;
    } else if (mapType === "cesium") {
      return _webmap ? _webmap._layerManager.getLayerDataKey() : null;
    }
  },

  getLayerData(mapTarget) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      return _webmap ? _webmap.getLayerData() : null;
    } else if (mapType === "cesium") {
      return _webmap ? _webmap._layerManager.getLayerData() : null;
    }
  },

  getDefaultShowLayerNames(mapTarget) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      return _webmap ? _webmap._defaultShowLayerNames : null;
    } else if (mapType === "cesium") {}
  },

  setLayerStyle(mapTarget, layer, style) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      layer.setStyle(style);
    } else if (mapType === "cesium") {}
  }

}; // 绘制相关操作

const mapDrawUtils = {
  startDrawRectPoint(mapTarget, callbackFun, isMultiple, isPoint, imgUrl, drawStyle) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      const mapdraw = _webmap.mapDraw;
      return mapdraw.startDrawRectPoint(callbackFun, isMultiple, isPoint, imgUrl, drawStyle);
    }
  },

  // 定位生成point layer
  setLocationPoint(mapTarget, coordinate, drawStyle, callback) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      var options = drawStyle || {
        color: "#fb030f",
        dashArray: "1",
        fillColor: "#000000",
        fillOpacity: 0.5,
        weight: 2
      };
      const _geoJSON = {
        type: "Feature",
        properties: {},
        geometry: {
          type: "Point",
          coordinates: [coordinate[0], coordinate[1]]
        }
      };

      const location = _webmap.mapDraw.creareGeometryByGeoJson(_geoJSON, options);

      _webmap.map.setView([coordinate[1], coordinate[0]], _webmap.map.getZoom());

      location.addTo(_webmap.map);
      callback && callback(location);
    } else if (mapType === "webgl") {}
  },

  stopDrawRectPoint(mapTarget) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      const mapdraw = _webmap.mapDraw;
      return mapdraw.stopDrawRectPoint();
    }
  },

  stopDrawState(mapTarget) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      if (_webmap) {
        _webmap.map.stop();

        _webmap.mapDraw.stopDrawState();
      }
    } else if (mapType === "cesium") {
      if (_webmap) {
        _webmap._drawManager.stopDraw();
      }
    }
  },

  removeGeometryByIdCustom(mapTarget, idCustom) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      if (_webmap) _webmap.mapDraw.removeGeometryByIdCustom(idCustom);
    } else if (mapType === "cesium") {
      if (_webmap) {
        _webmap._drawManager.clearAll();
      }
    }
  },

  drawAndFlytoGeometry(mapTarget, feature, idCustom, callFun, drawStyle, fillStyle) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      if (_webmap) _webmap.mapDraw.drawAndFlytoGeometry(feature, idCustom, callFun, drawStyle, fillStyle);
    }
  },

  startDraw(mapTarget, callbackFun, geometryType, idCustom, geometryOptions) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      if (_webmap) _webmap.mapDraw.startDraw(callbackFun, geometryType, idCustom, geometryOptions, mapTarget);
    } else if (mapType === "cesium") {
      if (_webmap) _webmap._drawManager.startDraw(geometryType, geometryOptions, callbackFun);
    }
  },

  enableEdit(mapTarget, layer, isEnable, callbackFun) {
    if (!mapTarget || mapTarget === "") {
      mapTarget = global_event_default().getCurrentMapTarget();
    }

    const mapType = global_event_default().getMapTypeByMapTarget(mapTarget);
    let _webmap = global_event_default().getMapInfoByMapTarget(mapTarget).webMap;

    if (mapType === "leaflet") {
      if (_webmap) {
        _webmap.mapDraw.enableEdit(layer, isEnable, callbackFun);
      }
    }
  }

};
module.exports = __webpack_exports__;
/******/ })()
;