cnhis-design-vue 3.1.14-beta.11.2 → 3.1.14-beta.14

package/es/packages/map/src/Map.js

@@ -1,4 +1,338 @@
-import script from './Map.vue_vue_type_script_setup_true_lang.js';
-export { default } from './Map.vue_vue_type_script_setup_true_lang.js';
+import { defineComponent, reactive, computed, onMounted, openBlock, createElementBlock, createElementVNode, createVNode, unref, withCtx, createTextVNode, toDisplayString, Fragment, renderList, createCommentVNode } from 'vue';
+import { useMessage, NInput, NButton } from 'naive-ui';
+import _export_sfc from '../../../_virtual/plugin-vue_export-helper.js';
 
-script.__file = "packages/map/src/Map.vue";
+const _hoisted_1 = { class: "c-map" };
+const _hoisted_2 = { class: "search-container" };
+const _hoisted_3 = { class: "map-input-search" };
+const _hoisted_4 = { class: "input-addon" };
+const _hoisted_5 = /* @__PURE__ */ createTextVNode("\u68C0\u7D22");
+const _hoisted_6 = /* @__PURE__ */ createElementVNode("div", { id: "map-core" }, null, -1);
+const _hoisted_7 = {
+  key: 0,
+  class: "address-list"
+};
+const _hoisted_8 = /* @__PURE__ */ createTextVNode("\u786E\u5B9A");
+const _hoisted_9 = ["onClick"];
+const _hoisted_10 = { class: "title" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "Map",
+  props: {
+    locationProp: { type: String, default: "" },
+    ak: {
+      type: String,
+      default: "KP3BZ-OAC3W-PY6RY-OJ6DV-JYKN3-H6F72"
+    }
+  },
+  emits: ["selectLocation"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const state = reactive({
+      qq: null,
+      searchKey: "",
+      centrePoint: {},
+      location: { lng: "", lat: "" },
+      localObj: {},
+      map: null,
+      ac: null,
+      addressList: [],
+      markers: [],
+      timeout: null,
+      searchService: null,
+      geocoder: {}
+    });
+    const defAdress = computed(() => {
+      var _a, _b;
+      return (_b = (_a = state.addressList) == null ? void 0 : _a[0]) == null ? void 0 : _b.name;
+    });
+    const calculateLocationProp = computed(() => {
+      return props.locationProp && JSON.parse(props.locationProp) || null;
+    });
+    const message = useMessage();
+    const showPosition = (r) => {
+      if (r && r.module == "geolocation") {
+        state.location.lng = r.lng;
+        state.location.lat = r.lat;
+        let qq = state.qq;
+        const new_opint = new qq.maps.LatLng(r.lat, r.lng);
+        handleGeocoder({ latLng: new_opint });
+        hdnelSetMapcenter({ lat: r.lat, lng: r.lng });
+      } else {
+        console.log("\u7528\u6237\u4E0D\u5141\u8BB8\u83B7\u53D6\u5730\u7406\u4F4D\u7F6E");
+        state.location.lng = 113.275;
+        state.location.lat = 23.117;
+      }
+    };
+    const getLocation = () => {
+      const qq = state.qq;
+      const geolocation = new qq.maps.Geolocation(props.ak, "qqmap");
+      const options = { timeout: 9e3 };
+      const showErr = function(err) {
+        console.log(err);
+      };
+      geolocation.getLocation(showPosition, showErr, options);
+    };
+    const hdnelSetMapcenter = (location) => {
+      const qq = state.qq;
+      var new_opint = new qq.maps.LatLng(location.lat, location.lng);
+      state.centrePoint = new_opint;
+      state.map.panTo(new_opint);
+      const mk = new qq.maps.Marker({
+        position: new_opint,
+        map: state.map
+      });
+      state.markers.push(mk);
+    };
+    const initSearch = () => {
+      const qq = state.qq;
+      state.searchService = new qq.maps.SearchService({
+        complete: function(results) {
+          var pois = results.detail.pois || [];
+          var latlngBounds = new qq.maps.LatLngBounds();
+          if (results.type === "CITY_LIST") {
+            state.searchService.setLocation(results.detail.cities[0].cityName);
+            state.searchService.search(state.searchKey);
+            return;
+          }
+          state.addressList = pois || [];
+          handleClearOverLays();
+          if (results.type === "POI_LIST") {
+            for (var i = 0, l = pois.length; i < l; i++) {
+              var poi = pois[i];
+              latlngBounds.extend(poi.latLng);
+              (function(n) {
+                var marker = new qq.maps.Marker({
+                  map: state.map
+                });
+                marker.setPosition(pois[n].latLng);
+                marker.setTitle(i + 1);
+                state.markers.push(marker);
+              })(i);
+            }
+          }
+          state.map.fitBounds(latlngBounds);
+        },
+        error: function(e) {
+          console.log(e);
+          if (e === "NO_RESULTS") {
+            message.warning("\u67E5\u65E0\u7ED3\u679C\uFF01");
+            return;
+          }
+          message.warning("\u5730\u5740\u68C0\u7D22\u5148\u8F93\u5165\u57CE\u5E02\u540D\u79F0");
+        },
+        autoExtend: true
+      });
+    };
+    const clearOverlays = (overlays) => {
+      var overlay;
+      while (overlay = overlays.pop()) {
+        overlay.setMap(null);
+      }
+    };
+    const handleClearOverLays = () => {
+      if (state.markers && state.markers.length) {
+        clearOverlays(state.markers);
+      }
+      state.markers = [];
+    };
+    const handleGeocoder = (config = {}) => {
+      const qq = state.qq;
+      const latLng = config.latLng;
+      const geocoder = new qq.maps.Geocoder();
+      geocoder.setComplete((result) => {
+        if (result.type === "GEO_INFO") {
+          var latlngBounds = new qq.maps.LatLngBounds();
+          var nearPois = result.detail.nearPois || [];
+          handleClearOverLays();
+          state.addressList = nearPois || [];
+          for (let index = 0; index < nearPois.length; index++) {
+            const pois = nearPois[index];
+            var marker = new qq.maps.Marker({
+              map: state.map
+            });
+            marker.setPosition(pois.latLng);
+            marker.setTitle(index + 1);
+            state.markers.push(marker);
+            latlngBounds.extend(pois.latLng);
+          }
+          state.map.fitBounds(latlngBounds);
+        }
+        var location = result.detail.location || {};
+        hdnelSetMapcenter(location);
+      });
+      geocoder.setError(function() {
+        alert("\u51FA\u9519\u4E86\uFF0C\u8BF7\u8F93\u5165\u6B63\u786E\u7684\u7ECF\u7EAC\u5EA6\uFF01\uFF01\uFF01");
+      });
+      geocoder.getAddress(latLng);
+    };
+    const init = () => {
+      const qq = state.qq;
+      qq.maps.event.addDomListener(state.map, "click", function(event) {
+        handleGeocoder({ latLng: event.latLng });
+      });
+    };
+    const searchKeyword = () => {
+      let value = state.searchKey;
+      if (!value)
+        return;
+      if (state.markers && state.markers.length) {
+        clearOverlays(state.markers);
+      }
+      state.searchService.setLocation("");
+      state.searchService.setPageCapacity(50);
+      state.searchService.search(value);
+    };
+    const selectLocation = (item, tag) => {
+      const qq = state.qq;
+      const { name, address, latLng } = item;
+      const { lat, lng } = latLng;
+      const geocoder = new qq.maps.Geocoder();
+      geocoder.setComplete(function(result) {
+        if (result.type === "GEO_INFO") {
+          const {
+            addressComponents: { province, city, district, country }
+          } = result.detail;
+          const emitData = JSON.stringify({
+            name,
+            address,
+            province,
+            city,
+            district,
+            country,
+            lat,
+            lng
+          });
+          emit("selectLocation", {
+            locationProp: emitData,
+            isInit: false
+          });
+        }
+      });
+      geocoder.setError(function() {
+        alert("\u51FA\u9519\u4E86\uFF0C\u8BF7\u8F93\u5165\u6B63\u786E\u7684\u7ECF\u7EAC\u5EA6\uFF01\uFF01\uFF01");
+      });
+      geocoder.getAddress(latLng);
+    };
+    const setMap = (qq) => {
+      var myLatlng = new qq.maps.LatLng(39.916527, 116.397128);
+      var myOptions = {
+        zoom: 12,
+        center: myLatlng,
+        mapTypeId: qq.maps.MapTypeId.ROADMAP
+      };
+      state.map = new qq.maps.Map(document.getElementById("map-core"), myOptions);
+      const { lat, lng, address } = calculateLocationProp.value || {};
+      if (lat && lng) {
+        const new_opint = new qq.maps.LatLng(lat, lng);
+        handleGeocoder({ latLng: new_opint });
+      } else if (address) {
+        setTimeout(() => {
+          searchKeyword();
+        }, 300);
+      } else {
+        getLocation();
+      }
+      init();
+    };
+    const initMap = (qq) => {
+      state.qq = qq;
+      setTimeout(() => {
+        setMap(qq);
+        initSearch();
+      }, 0);
+    };
+    const getMapScript = () => {
+      var _a, _b;
+      let _win = window;
+      if (!_win.qq) {
+        const ak = props.ak || ((_b = (_a = _win._qq) == null ? void 0 : _a.call(_win)) == null ? void 0 : _b.ak);
+        _win.qq = {};
+        _win.qq._preloader = new Promise((resolve) => {
+          _win._initBaiduMap = function() {
+            resolve(_win.qq);
+            _win.document.body.removeChild($script);
+            _win.qq._preloader = null;
+            _win._initBaiduMap = null;
+          };
+          const $script = document.createElement("script");
+          window.document.body.appendChild($script);
+          $script.src = `https://map.qq.com/api/js?v=2.exp&key=${ak}&callback=_initBaiduMap`;
+          const $script1 = document.createElement("script");
+          window.document.body.appendChild($script1);
+          $script1.src = `https://3gimg.qq.com/lightmap/components/geolocation/geolocation.min.js`;
+        });
+        return _win.qq._preloader;
+      } else if (!_win.qq._preloader) {
+        return Promise.resolve(_win.qq);
+      } else {
+        return _win.qq._preloader;
+      }
+    };
+    const reset = () => {
+      getMapScript().then(initMap);
+    };
+    onMounted(() => {
+      setTimeout(() => {
+        reset();
+      }, 200);
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createElementVNode("div", _hoisted_2, [
+          createElementVNode("div", _hoisted_3, [
+            createVNode(unref(NInput), {
+              value: state.searchKey,
+              "onUpdate:value": _cache[0] || (_cache[0] = ($event) => state.searchKey = $event),
+              placeholder: "\u8BF7\u8F93\u5165\u5730\u5740",
+              "enter-button": "\u68C0\u7D22"
+            }, null, 8, ["value"]),
+            createElementVNode("span", _hoisted_4, [
+              createVNode(unref(NButton), {
+                type: "primary",
+                size: "small",
+                onClick: searchKeyword
+              }, {
+                default: withCtx(() => [
+                  _hoisted_5
+                ]),
+                _: 1
+              })
+            ])
+          ])
+        ]),
+        _hoisted_6,
+        state.addressList && state.addressList.length ? (openBlock(), createElementBlock("ul", _hoisted_7, [
+          createElementVNode("li", null, [
+            createTextVNode(" \u5730\u5740:" + toDisplayString(unref(defAdress)) + " ", 1),
+            createVNode(unref(NButton), {
+              type: "primary",
+              size: "small",
+              onClick: _cache[1] || (_cache[1] = ($event) => selectLocation(state.addressList[0]))
+            }, {
+              default: withCtx(() => [
+                _hoisted_8
+              ]),
+              _: 1
+            })
+          ]),
+          (openBlock(true), createElementBlock(Fragment, null, renderList(state.addressList, (item, index) => {
+            return openBlock(), createElementBlock("li", {
+              class: "address-item",
+              key: index
+            }, [
+              createElementVNode("div", {
+                onClick: ($event) => selectLocation(item)
+              }, [
+                createElementVNode("div", _hoisted_10, toDisplayString(item.name), 1),
+                createElementVNode("span", null, toDisplayString(item.address), 1)
+              ], 8, _hoisted_9)
+            ]);
+          }), 128))
+        ])) : createCommentVNode("v-if", true)
+      ]);
+    };
+  }
+});
+var script = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "Map.vue"]]);
+
+export { script as default };

package/es/packages/scale-view/index.js

@@ -2,12 +2,11 @@ import { COMPONENT_NAMESPACE } from '../../src/global/variable';
 import { safeComponentRegister } from '../../src/utils';
 import { loadViewer } from '../../src/utils/loadViewer';
 import { expandXEUtils } from '../../src/utils/utilExpand';
-import './src/ScaleView.js';
+import script from './src/ScaleView.js';
 import scriptRadio from './src/components/formitem/r-radio.js';
 import scriptCheckbox from './src/components/formitem/r-checkbox.js';
 import scriptSelect from './src/components/formitem/r-select.js';
 import scriptDatetime from './src/components/formitem/r-datetime.js';
-import script from './src/ScaleView.vue_vue_type_script_setup_true_lang.js';
 
 const CScaleView = script;
 const CRadio = scriptRadio;