ele-admin-plus 1.0.0-beta.1

package/lib/ele-map-picker/components/map-view.js

@@ -0,0 +1,593 @@
+"use strict";
+const vue = require("vue");
+const AMapLoader = require("@amap/amap-jsapi-loader");
+const elementPlus = require("element-plus");
+const iconsVue = require("@element-plus/icons-vue");
+const EleLoading = require("../../ele-loading/index");
+const licenseUtil = require("../../utils/license-util");
+const props = require("../props");
+const ICON_CLASS = "ele-map-view-main-icon";
+const _sfc_main = vue.defineComponent({
+  name: "MapView",
+  components: {
+    EleLoading,
+    ElAutocomplete: elementPlus.ElAutocomplete,
+    ElInput: elementPlus.ElInput,
+    ElButton: elementPlus.ElButton,
+    ElIcon: elementPlus.ElIcon,
+    ElEmpty: elementPlus.ElEmpty,
+    Plus: iconsVue.Plus,
+    Location: iconsVue.Location,
+    CircleCheck: iconsVue.CircleCheck,
+    Search: iconsVue.Search
+  },
+  props: props.mapViewProps,
+  emits: {
+    done: (_result) => true,
+    mapDone: (_ins) => true
+  },
+  setup(props2, { emit }) {
+    const { authenticated } = licenseUtil.useLicense();
+    const mapRef = vue.ref(null);
+    const loading = vue.ref(true);
+    const poiLoading = vue.ref(false);
+    const confirmLoading = vue.ref(false);
+    const data = vue.ref([]);
+    const suggestionData = vue.ref([]);
+    const centerIconClass = vue.ref([ICON_CLASS]);
+    const keywords = vue.ref("");
+    const selected = vue.ref(null);
+    const disabled = vue.computed(() => props2.required && !selected.value);
+    const state = {
+      // 上次输入建议关键字
+      lastSuggestion: "",
+      // 选中的输入建议
+      selectedSuggestion: null,
+      // 是否是点击POI列表移动的地图
+      isItemClickMove: false,
+      // 地图实例
+      mapIns: null,
+      // POI检索实例
+      placeSearchIns: null,
+      // 输入建议实例
+      autoCompleteIns: null,
+      // 地图中心标记点
+      centerMarker: null
+    };
+    const renderMap = () => {
+      if (!props2.mapKey || state.mapIns) {
+        return;
+      }
+      AMapLoader.load({
+        key: props2.mapKey,
+        version: props2.mapVersion,
+        plugins: ["AMap.PlaceSearch", "AMap.AutoComplete"]
+      }).then((AMap) => {
+        destroyAll();
+        state.autoCompleteIns = new AMap.AutoComplete({
+          city: props2.suggestionCity
+        });
+        state.placeSearchIns = new AMap.PlaceSearch({
+          type: props2.poiType,
+          pageSize: props2.poiLimit,
+          pageIndex: 1
+        });
+        state.mapIns = new AMap.Map(mapRef.value, {
+          zoom: props2.zoom,
+          // 初缩放级别
+          center: props2.center,
+          // 初始中心点
+          resizeEnable: true,
+          // 监控地图容器尺寸变化
+          mapStyle: props2.mapStyle ? props2.mapStyle : props2.darkMode ? "amap://styles/dark" : void 0
+        });
+        state.mapIns.on("complete", () => {
+          loading.value = false;
+          const { lng, lat } = state.mapIns.getCenter();
+          searchPOI(lng, lat);
+        });
+        state.mapIns.on("moveend", () => {
+          if (state.isItemClickMove) {
+            state.isItemClickMove = false;
+          } else if (!props2.keywordMode) {
+            bounceIcon();
+            const { lng, lat } = state.mapIns.getCenter();
+            searchPOI(lng, lat);
+          }
+        });
+        state.centerMarker = new AMap.Marker({
+          icon: new AMap.Icon({
+            image: props2.markerSrc,
+            size: new AMap.Size(26, 36.5),
+            imageSize: new AMap.Size(26, 36.5)
+          }),
+          offset: new AMap.Pixel(-13, -36.5)
+        });
+        emit("mapDone", state.mapIns);
+      }).catch((e) => {
+        console.error(e);
+      });
+    };
+    const onSearch = (value, callback) => {
+      if (!value || state.lastSuggestion === value) {
+        callback && callback(suggestionData.value);
+        return;
+      }
+      state.lastSuggestion = value;
+      if (props2.keywordMode) {
+        poiLoading.value = true;
+      }
+      searchKeywords(value).then((result) => {
+        if (props2.keywordMode) {
+          data.value = result;
+          selected.value = null;
+          poiLoading.value = false;
+          removeCenterMarker();
+        } else {
+          suggestionData.value = result;
+          callback && callback(suggestionData.value);
+        }
+      }).catch((e) => {
+        console.error(e);
+        poiLoading.value = false;
+        callback && callback(suggestionData.value);
+      });
+    };
+    const onSearchSelect = (item) => {
+      if (!item || !item.location) {
+        return;
+      }
+      if (!data.value.length || data.value[0].name !== item.name) {
+        data.value = [item, ...data.value];
+        selected.value = item;
+      }
+      setMapCenter(item.location.lng, item.location.lat, props2.selectedZoom);
+      state.selectedSuggestion = item;
+    };
+    const onItemClick = (item) => {
+      state.isItemClickMove = true;
+      selected.value = item;
+      const { lng, lat } = item.location;
+      setMapCenter(lng, lat, props2.selectedZoom);
+      if (!props2.keywordMode) {
+        bounceIcon();
+      } else {
+        showCenterMarker(lng, lat);
+      }
+    };
+    const onConfirm = () => {
+      if (!authenticated.value) {
+        console.warn(licenseUtil.UNAUTHORIZED_TIP);
+        return;
+      }
+      if (!selected.value) {
+        confirmLoading.value = true;
+        getMapCenter(props2.returnRegions).then((result2) => {
+          confirmLoading.value = false;
+          emit("done", result2);
+        }).catch((e) => {
+          console.error(e);
+          confirmLoading.value = false;
+          emit("done", {});
+        });
+        return;
+      }
+      const result = {
+        ...selected.value.location,
+        name: selected.value.name,
+        address: selected.value.address || ""
+      };
+      if (props2.returnRegions) {
+        confirmLoading.value = true;
+        setMapCenter(result.lng, result.lat);
+        getMapCenter(true).then(({ city }) => {
+          confirmLoading.value = false;
+          result.city = city;
+          emit("done", result);
+        }).catch((e) => {
+          console.error(e);
+          confirmLoading.value = false;
+          emit("done", result);
+        });
+        return;
+      }
+      emit("done", result);
+    };
+    const searchKeywords = (value) => {
+      return new Promise((resolve, reject) => {
+        if (!state.autoCompleteIns) {
+          reject(new Error("AutoComplete instance is null"));
+          return;
+        }
+        state.autoCompleteIns.search(value, (status, result) => {
+          if (status === "error") {
+            reject(
+              new Error(status + " " + (result ? JSON.stringify(result) : ""))
+            );
+            return;
+          }
+          if (!(result == null ? void 0 : result.tips)) {
+            resolve([]);
+            return;
+          }
+          const data2 = result.tips.filter((d) => !!d.location).map((d) => {
+            const label = `${d.name}(${d.district})`;
+            return {
+              ...d,
+              label,
+              value: label,
+              key: d.id || label,
+              address: Array.isArray(d.address) ? d.address[0] : d.address
+            };
+          });
+          resolve(data2);
+        });
+      });
+    };
+    const searchPOI = (lng, lat) => {
+      poiLoading.value = true;
+      searchNearBy(lng, lat).then((result) => {
+        if (state.selectedSuggestion) {
+          if (result.length === 0 || result[0].name !== state.selectedSuggestion.name) {
+            data.value = [state.selectedSuggestion, ...result];
+            selected.value = state.selectedSuggestion;
+          } else {
+            data.value = result;
+            selected.value = result[0];
+          }
+        } else {
+          data.value = result;
+          selected.value = null;
+        }
+        poiLoading.value = false;
+      }).catch((e) => {
+        console.error(e);
+        data.value = [];
+        selected.value = null;
+        poiLoading.value = false;
+      });
+    };
+    const searchNearBy = (lng, lat) => {
+      return new Promise((resolve, reject) => {
+        if (!state.placeSearchIns) {
+          reject(new Error("PlaceSearch instance is null"));
+          return;
+        }
+        state.placeSearchIns.searchNearBy(
+          props2.poiKeywords,
+          [lng, lat],
+          props2.poiRadius,
+          (status, result) => {
+            var _a;
+            if (status === "complete" && ((_a = result == null ? void 0 : result.poiList) == null ? void 0 : _a.pois)) {
+              const data2 = result.poiList.pois.filter((d) => !!d.location).map((d, i) => {
+                return { ...d, key: d.id || `${d.name}-${i}` };
+              });
+              resolve(data2);
+            } else if (status === "no_data") {
+              resolve([]);
+            } else {
+              reject(
+                new Error(
+                  status + " " + (result ? JSON.stringify(result) : "")
+                )
+              );
+            }
+          }
+        );
+      });
+    };
+    const bounceIcon = () => {
+      centerIconClass.value = [ICON_CLASS];
+      vue.nextTick(() => {
+        setTimeout(() => {
+          centerIconClass.value = [ICON_CLASS, "ele-map-view-anim-bounce"];
+        }, 0);
+      });
+    };
+    const removeCenterMarker = () => {
+      if (state.centerMarker && state.mapIns) {
+        state.mapIns.remove(state.centerMarker);
+      }
+    };
+    const showCenterMarker = (lng, lat) => {
+      if (!state.centerMarker) {
+        console.error("centerMarker is null");
+        return;
+      }
+      if (!state.mapIns) {
+        console.error("map instance is null");
+        return;
+      }
+      if (lng != null && lat != null) {
+        state.centerMarker.setPosition([lng, lat]);
+        state.mapIns.add(state.centerMarker);
+      } else {
+        removeCenterMarker();
+      }
+    };
+    const setMapCenter = (lng, lat, zoom) => {
+      if (state.mapIns && lng != null && lat != null) {
+        if (zoom == null) {
+          state.mapIns.setCenter([lng, lat]);
+        } else {
+          state.mapIns.setZoomAndCenter(zoom, [lng, lat]);
+        }
+      }
+    };
+    const getMapCenter = (returnRegions) => {
+      return new Promise((resolve, reject) => {
+        if (!state.mapIns) {
+          reject(new Error("map instance is null"));
+          return;
+        }
+        const result = state.mapIns.getCenter();
+        if (returnRegions) {
+          state.mapIns.getCity((city) => {
+            result.city = city;
+            resolve(result);
+          });
+        } else {
+          resolve(result);
+        }
+      });
+    };
+    const changeMapStyle = (value) => {
+      if (state.mapIns) {
+        if (typeof value === "boolean") {
+          if (value) {
+            state.mapIns.setMapStyle("amap://styles/dark");
+          } else {
+            state.mapIns.setMapStyle("amap://styles/normal");
+          }
+        } else if (value) {
+          state.mapIns.setMapStyle(value);
+        }
+      }
+    };
+    const destroyMap = () => {
+      state.mapIns && state.mapIns.destroy();
+      state.centerMarker = null;
+      state.placeSearchIns = null;
+      state.autoCompleteIns = null;
+      state.mapIns = null;
+    };
+    const destroyAll = () => {
+      destroyMap();
+      data.value = [];
+      suggestionData.value = [];
+      selected.value = null;
+      keywords.value = "";
+      state.lastSuggestion = "";
+      state.selectedSuggestion = null;
+      state.isItemClickMove = false;
+    };
+    const getMapIns = () => {
+      return state.mapIns;
+    };
+    vue.watch(
+      () => props2.darkMode,
+      (darkMode) => {
+        if (!props2.mapStyle) {
+          changeMapStyle(darkMode);
+        }
+      }
+    );
+    vue.watch(
+      () => props2.mapStyle,
+      (mapStyle) => {
+        if (mapStyle) {
+          changeMapStyle(mapStyle);
+        }
+      }
+    );
+    vue.watch(
+      () => props2.keywordMode,
+      (keywordMode) => {
+        keywords.value = "";
+        suggestionData.value = [];
+        state.selectedSuggestion = null;
+        state.lastSuggestion = "";
+        removeCenterMarker();
+        if (keywordMode && selected.value) {
+          const { lng, lat } = selected.value.location;
+          showCenterMarker(lng, lat);
+        }
+      }
+    );
+    vue.watch(
+      () => props2.mapKey,
+      () => {
+        destroyAll();
+        renderMap();
+      }
+    );
+    vue.onMounted(() => {
+      renderMap();
+    });
+    vue.onBeforeUnmount(() => {
+      destroyAll();
+    });
+    return {
+      Check: iconsVue.Check,
+      mapRef,
+      loading,
+      poiLoading,
+      confirmLoading,
+      data,
+      suggestionData,
+      centerIconClass,
+      keywords,
+      selected,
+      disabled,
+      onSearch,
+      onSearchSelect,
+      onItemClick,
+      onConfirm,
+      getMapIns
+    };
+  }
+});
+const _export_sfc = (sfc, props2) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props2) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = { class: "ele-map-view-header" };
+const _hoisted_2 = { class: "ele-map-view-search" };
+const _hoisted_3 = { class: "ele-map-view-main" };
+const _hoisted_4 = ["src"];
+const _hoisted_5 = { class: "ele-map-view-side" };
+const _hoisted_6 = ["onClick"];
+const _hoisted_7 = { class: "ele-map-view-item-title" };
+const _hoisted_8 = {
+  key: 0,
+  class: "ele-map-view-item-text"
+};
+const _hoisted_9 = {
+  key: 0,
+  class: "ele-map-view-empty"
+};
+const _hoisted_10 = {
+  key: 0,
+  class: "ele-map-view-extra"
+};
+const _hoisted_11 = { class: "ele-map-view-message" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_Search = vue.resolveComponent("Search");
+  const _component_ElIcon = vue.resolveComponent("ElIcon");
+  const _component_ElInput = vue.resolveComponent("ElInput");
+  const _component_ElAutocomplete = vue.resolveComponent("ElAutocomplete");
+  const _component_ElButton = vue.resolveComponent("ElButton");
+  const _component_Plus = vue.resolveComponent("Plus");
+  const _component_Location = vue.resolveComponent("Location");
+  const _component_CircleCheck = vue.resolveComponent("CircleCheck");
+  const _component_ElEmpty = vue.resolveComponent("ElEmpty");
+  const _component_EleLoading = vue.resolveComponent("EleLoading");
+  return vue.openBlock(), vue.createBlock(_component_EleLoading, {
+    loading: _ctx.loading,
+    class: "ele-map-view"
+  }, {
+    default: vue.withCtx(() => [
+      vue.createElementVNode("div", _hoisted_1, [
+        vue.createElementVNode("div", _hoisted_2, [
+          _ctx.keywordMode ? (vue.openBlock(), vue.createBlock(_component_ElInput, {
+            key: 0,
+            clearable: "",
+            modelValue: _ctx.keywords,
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.keywords = $event),
+            placeholder: _ctx.searchPlaceholder,
+            onChange: _ctx.onSearch
+          }, {
+            prefix: vue.withCtx(() => [
+              vue.createVNode(_component_ElIcon, { class: "el-input__icon" }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_Search)
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          }, 8, ["modelValue", "placeholder", "onChange"])) : (vue.openBlock(), vue.createBlock(_component_ElAutocomplete, {
+            key: 1,
+            clearable: "",
+            modelValue: _ctx.keywords,
+            "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => _ctx.keywords = $event),
+            fetchSuggestions: _ctx.onSearch,
+            placeholder: _ctx.searchPlaceholder,
+            onSelect: _ctx.onSearchSelect
+          }, {
+            prefix: vue.withCtx(() => [
+              vue.createVNode(_component_ElIcon, { class: "el-input__icon" }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_Search)
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          }, 8, ["modelValue", "fetchSuggestions", "placeholder", "onSelect"]))
+        ]),
+        vue.createVNode(_component_ElButton, {
+          icon: _ctx.Check,
+          type: "primary",
+          disabled: _ctx.disabled,
+          loading: _ctx.confirmLoading,
+          class: "ele-map-view-btn-ok",
+          onClick: _ctx.onConfirm
+        }, {
+          default: vue.withCtx(() => [
+            vue.createTextVNode(vue.toDisplayString(_ctx.okText), 1)
+          ]),
+          _: 1
+        }, 8, ["icon", "disabled", "loading", "onClick"])
+      ]),
+      vue.createElementVNode("div", {
+        class: "ele-map-view-body",
+        style: vue.normalizeStyle({ height: _ctx.height })
+      }, [
+        vue.createElementVNode("div", _hoisted_3, [
+          vue.createElementVNode("div", {
+            ref: "mapRef",
+            style: vue.normalizeStyle({ height: _ctx.height })
+          }, null, 4),
+          !_ctx.keywordMode ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+            vue.createVNode(_component_ElIcon, { class: "ele-map-view-icon-plus" }, {
+              default: vue.withCtx(() => [
+                vue.createVNode(_component_Plus)
+              ]),
+              _: 1
+            }),
+            vue.createElementVNode("img", {
+              src: _ctx.markerSrc,
+              class: vue.normalizeClass(_ctx.centerIconClass)
+            }, null, 10, _hoisted_4)
+          ], 64)) : vue.createCommentVNode("", true)
+        ]),
+        vue.createElementVNode("div", _hoisted_5, [
+          vue.createVNode(_component_EleLoading, {
+            loading: _ctx.poiLoading,
+            class: "ele-map-view-list"
+          }, {
+            default: vue.withCtx(() => [
+              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.data, (item) => {
+                return vue.openBlock(), vue.createElementBlock("div", {
+                  key: item.key,
+                  class: vue.normalizeClass(["ele-map-view-item", { "is-active": item === _ctx.selected }]),
+                  onClick: ($event) => _ctx.onItemClick(item)
+                }, [
+                  vue.createVNode(_component_ElIcon, { class: "ele-map-view-item-icon" }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(_component_Location)
+                    ]),
+                    _: 1
+                  }),
+                  vue.createElementVNode("div", _hoisted_7, vue.toDisplayString(item.name), 1),
+                  item.address ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_8, vue.toDisplayString(item.address), 1)) : vue.createCommentVNode("", true),
+                  vue.createVNode(_component_ElIcon, { class: "ele-map-view-item-radio" }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(_component_CircleCheck)
+                    ]),
+                    _: 1
+                  })
+                ], 10, _hoisted_6);
+              }), 128)),
+              !_ctx.data || !_ctx.data.length ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_9, [
+                vue.createVNode(_component_ElEmpty, vue.mergeProps({ imageSize: 80 }, _ctx.emptyProps), null, 16)
+              ])) : vue.createCommentVNode("", true)
+            ]),
+            _: 1
+          }, 8, ["loading"]),
+          _ctx.disabled ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_10, [
+            vue.createElementVNode("div", _hoisted_11, vue.toDisplayString(_ctx.message), 1)
+          ])) : vue.createCommentVNode("", true)
+        ])
+      ], 4)
+    ]),
+    _: 1
+  }, 8, ["loading"]);
+}
+const mapView = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = mapView;