@uni-sw/u-design 2.0.4

package/es/components/UMap/map/components/MapServerPointManage/Layers/layer.less

@@ -0,0 +1,119 @@
+@import '../../../../../../style/global.less';
+
+.map-point-right-menu {
+    padding: 0px;
+    margin: 0px;
+    list-style: none;
+    position: absolute;
+    width: 160px;
+    font-size: 14px;
+
+    .map-menu-item {
+        padding: 0 10px;
+        width: 160px;
+        height: 34px;
+        line-height: 34px;
+        text-align: left;
+        cursor: pointer;
+        position: relative;
+
+        &.menu-item-noHover {
+            cursor: auto;
+        }
+
+        ul {
+            width: 160px;
+            position: absolute;
+            left: 160px;
+            top: 0px;
+            display: none;
+            margin: 0;
+            list-style: none;
+        }
+
+        p {
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+            margin: 0;
+        }
+
+        &:hover {
+
+            &>ul {
+                display: block;
+                padding: 0px;
+            }
+        }
+    }
+}
+
+.map-tree-div-inner {
+    max-height: 400px;
+    overflow-y: auto;
+    min-width: 200px;
+    max-width: 300px;
+    padding: 10px;
+    text-align: left;
+
+    .@{ud-prefix}-tree-title {
+        white-space: nowrap;
+    }
+
+    &::-webkit-scrollbar {
+        width: 4px;
+        height: 4px;
+    }
+
+    &::-webkit-scrollbar-thumb {
+        border-radius: 2px;
+    }
+
+    &::-webkit-scrollbar-track {
+        border-radius: 0;
+    }
+
+    &::-webkit-scrollbar-button {
+        width: 4px;
+        height: 4px;
+    }
+
+    .@{ud-prefix}-tree-node-content-wrapper {
+        font-size: 12px;
+        width: 100%;
+        white-space: nowrap;
+        text-overflow: ellipsis;
+        overflow: hidden;
+
+        &.@{ud-prefix}-tree-node-selected, &:hover {
+            background: none !important;
+        }
+    }
+
+    .@{ud-prefix}-tree-checkbox-inner {
+        border-radius: 0;
+    }
+
+    .@{ud-prefix}-tree-iconEle {
+        width: auto;
+    }
+
+    .@{ud-prefix}-tree-treenode {
+        width: 100%;
+    }
+
+    .@{ud-prefix}-tree-node-content-wrapper.@{ud-prefix}-tree-node-selected {
+        background: none;
+    }
+
+    .@{ud-prefix}-tree {
+        background-color: transparent;
+    }
+}
+
+.reserve-icon {
+    display: inline-block;
+    width: 24px;
+    height: 24px;
+    background: url('../Image/rotate.png') no-repeat center;
+}

package/es/components/UMap/map/components/MapServerPointManage/MapLayer.js

@@ -0,0 +1,541 @@
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+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 _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _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(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+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 _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : 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); }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
+function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
+function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+import React, { Component } from 'react';
+import Camera from "./Layers/Camera/Camera";
+import Tollgate from "./Layers/Tollgate/Tollgate";
+import Customer from "./Layers/Customer/Customer";
+import Gps from "./Layers/Gps/Gps";
+import Defence from "./Layers/Defence/Defence";
+import ArchivesCamera from "./Layers/ArchivesCamera/ArchivesCamera";
+import LayerTree from "./Layers/LayerTree";
+import { getCustomImage } from "./RequestFunc";
+import { LayerType, ToolTipType } from "./Enum";
+import "./style/index.less";
+import "./Layers/layer.less";
+/**
+ * 地图图层点位数据加载
+ * props {
+ *  @param {String} className 图层筛选气泡卡片样式
+ *  @param {Object} mapDom map组件ref
+ *  @param {Array} onlyShowLayerType 限制展示的图层分类类型编码
+ *  @param {Array} defaultShow 默认展示的图层分类类型编码
+ *  @param {Function} getAllStatus GPS组件各类型总数获取回调
+ *  @param {Function} getGpsRef GPS组件ref获取回调
+ *  @param {Function} getMapLayer layer图层获取获取回调
+ * }
+ */
+var MapLayer = /*#__PURE__*/function (_Component) {
+  function MapLayer(_props) {
+    var _this;
+    _classCallCheck(this, MapLayer);
+    _this = _callSuper(this, MapLayer, [_props]);
+    /**
+     * 组装需要加载的菜单
+     */
+    _this._getShowMenu = function () {
+      var showMenuItems = _this.props.showMenuItems;
+      // 根据需要展示的菜单项  获取各类点位需要展示的菜单项
+      // props传入格式为：[{ layerType: 0, menuKeys: [] }, ...]
+      if (showMenuItems instanceof Array) {
+        Object.keys(_this.needShowMenuList).forEach(function (layerType) {
+          var menuInfo = showMenuItems.find(function (item) {
+            return item && _typeof(item) === 'object' && item.layerType + '' === layerType;
+          });
+          if (menuInfo) {
+            //如果没有传入具体的menuKeys  说明该点位所有的菜单都显示
+            if (!(menuInfo.menuKeys instanceof Array)) {
+              return;
+            }
+            _this.needShowMenuList[layerType] = menuInfo.menuKeys;
+          }
+        });
+      } else {
+        if (undefined !== showMenuItems) {
+          console.error('showMenuItems传入有误，请按照[{ layerType: *, menuKeys: [] }, ...]格式传入');
+        }
+        _this.needShowMenuList = {};
+      }
+    };
+    /**
+     * 获取默认加载的点位
+     */
+    _this._getDefaultShow = function (props) {
+      var onlyShowLayerType = props.onlyShowLayerType,
+        defaultShow = props.defaultShow,
+        textLocale = props.textLocale;
+      var loadLayerType = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, LayerType.Camera, {
+        ifLoad: false,
+        name: textLocale.cameraLayer
+      }), LayerType.Tollagte, {
+        ifLoad: false,
+        name: textLocale.tollegateLayer
+      }), LayerType.Defence, {
+        ifLoad: false,
+        name: textLocale.defenceLayer
+      }), LayerType.Panorama, {
+        ifLoad: false,
+        name: textLocale.ponoramaLayer
+      }), LayerType.GPS, {
+        ifLoad: false,
+        name: textLocale.mobilePoliceLayer
+      }), LayerType.Customer, {
+        ifLoad: false,
+        name: textLocale.customerLayer
+      }), LayerType.Other, {
+        ifLoad: false,
+        name: textLocale.otherLayer
+      }), LayerType.FaceCameraUsed, {
+        ifLoad: false,
+        name: textLocale.covergingLayer
+      });
+      //根据默认展示  设置对应的点位组件 加载
+      if (onlyShowLayerType instanceof Array && onlyShowLayerType.length > 0 && defaultShow instanceof Array) {
+        defaultShow.forEach(function (item) {
+          if (loadLayerType[item]) {
+            loadLayerType[item].ifLoad = true;
+          }
+        });
+      }
+      return loadLayerType;
+    };
+    /**
+     * 图层筛选后，根据图层code判断是否加载该图层分类的组件
+     * @param {Array} choosedCode 图层code
+     */
+    _this.getChoosedCode = function (choosedCode) {
+      var _this$state = _this.state,
+        mapLayersObj = _this$state.mapLayersObj,
+        loadLayerType = _this$state.loadLayerType;
+      var _this$props = _this.props,
+        getChoosedLayerId = _this$props.getChoosedLayerId,
+        getToolCallBack = _this$props.getToolCallBack;
+      //遍历确认是否需要加载对应点位组件
+      Object.keys(mapLayersObj).forEach(function (type) {
+        // item   layerType
+        Object.keys(mapLayersObj[type]).forEach(function (code) {
+          //item1 layerCode
+          if (choosedCode.includes(code) && loadLayerType[type] && false === loadLayerType[type].ifLoad) {
+            loadLayerType[type].ifLoad = true;
+          }
+        });
+      });
+      _this.setState({
+        loadLayerType: loadLayerType
+      }, function () {
+        _this.setState({
+          checkedLayers: choosedCode
+        });
+        getToolCallBack && getToolCallBack('layer', choosedCode);
+        if (typeof getChoosedLayerId === 'function') {
+          getChoosedLayerId(choosedCode);
+        }
+      });
+    };
+    /**
+     * 获取图层后，组装成所需的图层数据结构  { type: { code: layer } }
+     * @param {Array} mapLayersAry 组装的layer信息
+     * @param {Array} layersOfInterface 接口返回的所有layer信息
+     */
+    _this.getLayers = function (mapLayersAry, layersOfInterface, initShowLayers) {
+      var _this$props2 = _this.props,
+        defaultShow = _this$props2.defaultShow,
+        onlyShowLayerType = _this$props2.onlyShowLayerType,
+        getChoosedLayerId = _this$props2.getChoosedLayerId;
+      //根据接口获取的图层数据组装所需的IconName信息 { type: { code: IconName } }
+      if (layersOfInterface instanceof Array) {
+        layersOfInterface.forEach(function (item) {
+          if (!_this.iconNameObj[item.LayerType]) {
+            _this.iconNameObj[item.LayerType] = {};
+          }
+          if (item.LayerImageInfo) {
+            _this.iconNameObj[item.LayerType][item.LayerCode] = {
+              name: item.LayerImageInfo.IconName,
+              code: item.LayerImageInfo.Code
+            };
+          }
+        });
+      }
+      //获取自定义的图标base64
+      getCustomImage(onlyShowLayerType || Object.keys(_this.iconNameObj)).then(function (customImages) {
+        _this.setState({
+          customImages: customImages
+        });
+      }).catch(function () {});
+      var typeObj = {};
+      mapLayersAry.forEach(function (item) {
+        if (!typeObj[item.type]) {
+          typeObj[item.type] = {};
+        }
+        typeObj[item.type][item.code] = item.name;
+      });
+      //初始化勾选
+      var choosedCode = [];
+      if (defaultShow instanceof Array) {
+        choosedCode = mapLayersAry.filter(function (item) {
+          return defaultShow.includes(item.type);
+        }).map(function (item) {
+          return item.code + '';
+        });
+      }
+      _this.setState({
+        mapLayersObj: typeObj,
+        checkedLayers: choosedCode
+      });
+      //所有图层信息回调
+      if (_this.props.getMapLayer) {
+        _this.props.getMapLayer(initShowLayers, mapLayersAry);
+      }
+      //选中图层回调
+      if (typeof getChoosedLayerId === 'function') {
+        getChoosedLayerId(choosedCode);
+      }
+    };
+    /**
+     * 根据type编码获取对应图层分类名称
+     * @param {Array} ary type数组
+     */
+    _this._getTypeName = function (ary) {
+      var loadLayerType = _this.state.loadLayerType;
+      return ary instanceof Array ? ary.map(function (item) {
+        return loadLayerType[item].name;
+      }) : [];
+    };
+    /**
+     * 加载点位组件
+     */
+    _this._loadPointComponent = function () {
+      var _this$state2 = _this.state,
+        mapLayersObj = _this$state2.mapLayersObj,
+        loadLayerType = _this$state2.loadLayerType,
+        customImages = _this$state2.customImages;
+      var _this$props3 = _this.props,
+        mapClassName = _this$props3.mapClassName,
+        toolTipMode = _this$props3.toolTipMode;
+      if (!customImages) {
+        return null;
+      }
+      return /*#__PURE__*/React.createElement(React.Fragment, null, Object.keys(_this.layer).map(function (type) {
+        if ('function' !== typeof _this.layer[type]) {
+          return null;
+        }
+        var ifLoad = false;
+        var layers = {};
+        var showMenuKeys = [];
+        var cameraMenuKeys = [];
+        //自定义、其他 点位共用一个组件
+        if (LayerType.Customer + '' === type || LayerType.Other + '' === type) {
+          //自定义点位、其他点位有其中一个需要加载  即加载Customer组件
+          ifLoad = loadLayerType[LayerType.Customer] && loadLayerType[LayerType.Customer].ifLoad || loadLayerType[LayerType.Other] && loadLayerType[LayerType.Other].ifLoad;
+          if (Object.keys(_this.needShowMenuList).length > 0) {
+            showMenuKeys = [].concat(_toConsumableArray(_this.needShowMenuList[LayerType.Customer] || {}), _toConsumableArray(_this.needShowMenuList[LayerType.Other] || {}));
+            cameraMenuKeys = _toConsumableArray(_this.needShowMenuList[LayerType.Camera] || {});
+          }
+          layers = _objectSpread(_objectSpread({}, mapLayersObj[LayerType.Customer] || {}), mapLayersObj[LayerType.Other] || {});
+        } else {
+          ifLoad = loadLayerType[type] && loadLayerType[type].ifLoad;
+          showMenuKeys = _this.needShowMenuList[type];
+          layers = mapLayersObj[type];
+        }
+        if (!ifLoad || !layers || 0 === Object.keys(layers).length) {
+          return null;
+        }
+        return _this.layer[type](_objectSpread(_objectSpread({}, _this.props), {
+          mapClassName: mapClassName || 'map-dom-2d',
+          showMenuKeys: showMenuKeys || [],
+          cameraMenuKeys: cameraMenuKeys || [],
+          layers: layers || {},
+          customImages: customImages[type] || {},
+          iconName: _this.iconNameObj[type] || {},
+          toolTipMode: toolTipMode || ToolTipType.ALLWAYS
+        }));
+      }));
+    };
+    _this.state = {
+      mapLayersObj: {},
+      //地图图层  { type: { code: layer } }
+      customImages: null,
+      //自定义图标 { type: imageCode: base64 }
+      loadLayerType: _this._getDefaultShow(_props),
+      //图层分类合集(是否加载该类组件、图层分类名称)
+      checkedLayers: [] // 地图引擎不能存 本地保存
+    };
+    //各图层分类对应组件
+    _this.layer = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, LayerType.Camera, function (_ref) {
+      var mapGuid = _ref.mapGuid,
+        mapDom = _ref.mapDom,
+        layers = _ref.layers,
+        iconName = _ref.iconName,
+        customImages = _ref.customImages,
+        menuClick = _ref.menuClick,
+        showMenuKeys = _ref.showMenuKeys,
+        toolTipMode = _ref.toolTipMode,
+        mapOperation = _ref.mapOperation,
+        markerDragEnable = _ref.markerDragEnable,
+        pointEvent = _ref.pointEvent,
+        mapClassName = _ref.mapClassName,
+        upRightEnable = _ref.upRightEnable,
+        clusterZoom = _ref.clusterZoom,
+        userCode = _ref.userCode,
+        hidePointNameTips = _ref.hidePointNameTips,
+        pointShowFunc = _ref.pointShowFunc,
+        pointRefresh = _ref.pointRefresh,
+        textLocale = _ref.textLocale,
+        visualViewProps = _ref.visualViewProps;
+      return /*#__PURE__*/React.createElement(Camera, {
+        key: "camera",
+        mapGuid: mapGuid,
+        userCode: userCode,
+        pointEvent: pointEvent,
+        mapClassName: mapClassName,
+        mapDom: mapDom,
+        layers: layers,
+        iconName: iconName,
+        customImages: customImages,
+        checkedLayers: _this.state.checkedLayers,
+        menuClick: menuClick,
+        showMenuKeys: showMenuKeys,
+        toolTipMode: toolTipMode,
+        mapOperation: mapOperation //菜单操作
+        ,
+        markerDragEnable: markerDragEnable //是否可拖动
+        ,
+        clusterZoom: clusterZoom //聚合层级
+        ,
+        upRightEnable: upRightEnable //是否显示立杆
+        ,
+        textLocale: textLocale,
+        pointShowFunc: pointShowFunc //点位显隐控制
+        ,
+        pointRefresh: pointRefresh //点位强制刷新
+        ,
+        hidePointNameTips: hidePointNameTips //隐藏名称提示框
+        ,
+        visualViewProps: visualViewProps //可视域配置
+      });
+    }), LayerType.Tollagte, function (_ref2) {
+      var mapGuid = _ref2.mapGuid,
+        mapDom = _ref2.mapDom,
+        layers = _ref2.layers,
+        iconName = _ref2.iconName,
+        customImages = _ref2.customImages,
+        showMenuKeys = _ref2.showMenuKeys,
+        toolTipMode = _ref2.toolTipMode,
+        menuClick = _ref2.menuClick,
+        mapOperation = _ref2.mapOperation,
+        markerDragEnable = _ref2.markerDragEnable,
+        pointEvent = _ref2.pointEvent,
+        mapClassName = _ref2.mapClassName,
+        clusterZoom = _ref2.clusterZoom,
+        userCode = _ref2.userCode,
+        hidePointNameTips = _ref2.hidePointNameTips,
+        textLocale = _ref2.textLocale;
+      return /*#__PURE__*/React.createElement(Tollgate, {
+        key: "tollgate",
+        mapGuid: mapGuid,
+        userCode: userCode,
+        pointEvent: pointEvent,
+        mapClassName: mapClassName,
+        mapDom: mapDom,
+        layers: layers,
+        iconName: iconName,
+        customImages: customImages,
+        checkedLayers: _this.state.checkedLayers,
+        menuClick: menuClick,
+        showMenuKeys: showMenuKeys,
+        toolTipMode: toolTipMode,
+        mapOperation: mapOperation,
+        markerDragEnable: markerDragEnable,
+        clusterZoom: clusterZoom,
+        textLocale: textLocale,
+        hidePointNameTips: hidePointNameTips
+      });
+    }), LayerType.Defence, function (_ref3) {
+      var mapGuid = _ref3.mapGuid,
+        mapDom = _ref3.mapDom,
+        layers = _ref3.layers,
+        pointEvent = _ref3.pointEvent,
+        iconName = _ref3.iconName,
+        customImages = _ref3.customImages,
+        mapOperation = _ref3.mapOperation,
+        showMenuKeys = _ref3.showMenuKeys,
+        menuClick = _ref3.menuClick,
+        mapClassName = _ref3.mapClassName,
+        textLocale = _ref3.textLocale;
+      return /*#__PURE__*/React.createElement(Defence, {
+        key: "defence",
+        mapGuid: mapGuid,
+        pointEvent: pointEvent,
+        mapClassName: mapClassName,
+        mapDom: mapDom,
+        layers: layers,
+        iconName: iconName,
+        customImages: customImages,
+        checkedLayers: _this.state.checkedLayers,
+        menuClick: menuClick,
+        showMenuKeys: showMenuKeys,
+        mapOperation: mapOperation,
+        textLocale: textLocale
+      });
+    }), LayerType.Panorama, ''), LayerType.GPS, function (_ref4) {
+      var mapGuid = _ref4.mapGuid,
+        mapDom = _ref4.mapDom,
+        getGpsRef = _ref4.getGpsRef,
+        getGpsImg = _ref4.getGpsImg,
+        showDefaultGpsIcon = _ref4.showDefaultGpsIcon,
+        getWebSocketMessage = _ref4.getWebSocketMessage,
+        getAllStatus = _ref4.getAllStatus,
+        layers = _ref4.layers,
+        showMenuKeys = _ref4.showMenuKeys,
+        toolTipMode = _ref4.toolTipMode,
+        menuClick = _ref4.menuClick,
+        checkGpsInfo = _ref4.checkGpsInfo,
+        pointEvent = _ref4.pointEvent,
+        clusterZoom = _ref4.clusterZoom,
+        mapClassName = _ref4.mapClassName,
+        textLocale = _ref4.textLocale;
+      return /*#__PURE__*/React.createElement(Gps, {
+        key: "monitorgps",
+        mapGuid: mapGuid,
+        pointEvent: pointEvent,
+        mapClassName: mapClassName,
+        mapDom: mapDom,
+        ref: getGpsRef,
+        getGpsImg: getGpsImg,
+        showDefaultGpsIcon: showDefaultGpsIcon,
+        getWebSocketMessage: getWebSocketMessage,
+        getAllStatus: getAllStatus,
+        layers: layers,
+        showMenuKeys: showMenuKeys,
+        toolTipMode: toolTipMode,
+        checkedLayers: _this.state.checkedLayers,
+        menuClick: menuClick,
+        checkGpsInfo: checkGpsInfo,
+        clusterZoom: clusterZoom,
+        textLocale: textLocale
+      });
+    }), LayerType.Customer, function (_ref5) {
+      var mapGuid = _ref5.mapGuid,
+        mapDom = _ref5.mapDom,
+        layers = _ref5.layers,
+        iconName = _ref5.iconName,
+        customImages = _ref5.customImages,
+        showMenuKeys = _ref5.showMenuKeys,
+        cameraMenuKeys = _ref5.cameraMenuKeys,
+        toolTipMode = _ref5.toolTipMode,
+        menuClick = _ref5.menuClick,
+        mapOperation = _ref5.mapOperation,
+        markerDragEnable = _ref5.markerDragEnable,
+        theme = _ref5.theme,
+        pointEvent = _ref5.pointEvent,
+        mapClassName = _ref5.mapClassName,
+        reloadResourceType = _ref5.reloadResourceType,
+        resTypeChange = _ref5.resTypeChange,
+        upRightEnable = _ref5.upRightEnable,
+        clusterZoom = _ref5.clusterZoom,
+        hidePointNameTips = _ref5.hidePointNameTips,
+        pointRefresh = _ref5.pointRefresh,
+        textLocale = _ref5.textLocale;
+      return /*#__PURE__*/React.createElement(Customer, {
+        key: "customer",
+        mapGuid: mapGuid,
+        theme: theme,
+        pointEvent: pointEvent,
+        mapClassName: mapClassName,
+        mapDom: mapDom,
+        layers: layers,
+        iconName: iconName,
+        customImages: customImages,
+        checkedLayers: _this.state.checkedLayers,
+        menuClick: menuClick,
+        showMenuKeys: showMenuKeys,
+        cameraMenuKeys: cameraMenuKeys,
+        toolTipMode: toolTipMode,
+        mapOperation: mapOperation,
+        markerDragEnable: markerDragEnable,
+        reloadResourceType: reloadResourceType,
+        resTypeChange: resTypeChange,
+        upRightEnable: upRightEnable,
+        clusterZoom: clusterZoom,
+        hidePointNameTips: hidePointNameTips,
+        textLocale: textLocale,
+        pointRefresh: pointRefresh
+      });
+    }), LayerType.Other, ''), LayerType.FaceCameraUsed, function (_ref6) {
+      var mapDom = _ref6.mapDom,
+        mapGuid = _ref6.mapGuid,
+        layers = _ref6.layers,
+        toolTipMode = _ref6.toolTipMode,
+        clusterZoom = _ref6.clusterZoom;
+      return /*#__PURE__*/React.createElement(ArchivesCamera, {
+        key: "archivesCamera",
+        mapGuid: mapGuid,
+        mapDom: mapDom,
+        layers: layers,
+        iconName: _this.iconNameObj[0],
+        customImages: _this.state.customImages[0],
+        checkedLayers: _this.state.checkedLayers,
+        toolTipMode: toolTipMode,
+        clusterZoom: clusterZoom
+      });
+    });
+    //默认记录所有点位的菜单项  { layerType: [] }
+    //根据props.showMenuItems 更新对应点位实际所需的菜单
+    _this.needShowMenuList = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, LayerType.Camera, []), LayerType.Tollagte, []), LayerType.Defence, []), LayerType.Panorama, []), LayerType.GPS, []), LayerType.Customer, []), LayerType.Other, []), LayerType.FaceCameraUsed, []);
+    _this.iconNameObj = {}; //图层对应点位IconName  { type: { code: { name: LayerImageInfo.IconName, code: LayerImageInfo.Code } } }
+    return _this;
+  }
+  _inherits(MapLayer, _Component);
+  return _createClass(MapLayer, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this._getShowMenu();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props4 = this.props,
+        mapDom = _this$props4.mapDom,
+        onlyShowLayerType = _this$props4.onlyShowLayerType,
+        children = _this$props4.children,
+        className = _this$props4.className,
+        showLayerTree = _this$props4.showLayerTree,
+        theme = _this$props4.theme;
+      if (!mapDom) {
+        return;
+      }
+      return /*#__PURE__*/React.createElement(React.Fragment, null, onlyShowLayerType instanceof Array && onlyShowLayerType.length > 0 && /*#__PURE__*/React.createElement(LayerTree, _extends({}, this.props, {
+        theme: theme,
+        mapDom: mapDom,
+        onlyShow: this._getTypeName(onlyShowLayerType),
+        defaultCheckedKeys: this.state.checkedLayers,
+        getLayers: this.getLayers,
+        getChoosedCode: this.getChoosedCode,
+        className: className,
+        children: children,
+        showLayerTree: showLayerTree
+      })), this._loadPointComponent());
+    }
+  }]);
+}(Component);
+export { MapLayer as default };