@heycar/heycars-map 2.4.0 → 2.4.2

package/README.md

@@ -655,3 +655,15 @@ enableAuxiliaryGraspRoad 模式适用场景：
 3. 会将供应商提供的司机位置显示为蓝色标记，辅助观察供应商提供的司机位置。
 4. 会显示一条黑色的路径，表示将供应商提供的位置纠偏以后的路径。
 5. enableAuxiliaryGraspRoad 模式下，为了方便测试，取消了屏幕 15 秒自动调整功能。
+
+#### 下面是地图导出的一些基本工具
+
+```ts
+import { isCoordinatePointEqual } from "@heycar/heycars-map";
+
+// 比较两个带有坐标类型的点是否为同一个点
+isCoordinatePointEqual(
+  { type: "gcj02", lng: 114.215114, lat: 22.215972 },
+  { type: "wgs84", lng: 114.21016180538568, lat: 22.219570659901557 },
+) === true;
+```

package/dist/v2/api/geometry.d.ts

@@ -0,0 +1,2 @@
+import type { CoordinatePoint } from "../types/interface";
+export declare function isCoordinatePointEqual(p1: CoordinatePoint, p2?: CoordinatePoint): boolean;

package/dist/v2/api/geometry.js

@@ -0,0 +1,16 @@
+import { e as exported } from "../chunks/gcoord.esm-bundler.3f2f1369.js";
+const GCOORD_ACCURCY_RANGE = 1e-6;
+function isCoordinatePointEqual(p1, p2) {
+  if (!p2)
+    return false;
+  if (p1.type === p2.type)
+    return p1.lng === p2.lng && p1.lat === p2.lat;
+  const { lng: x1, lat: y1 } = p1.type === "gcj02" ? p1 : p2;
+  const wgsPoint = p1.type === "gcj02" ? p2 : p1;
+  const { lng, lat } = wgsPoint;
+  const [x2, y2] = exported.transform([lng, lat], exported.WGS84, exported.GCJ02);
+  return Math.abs(x1 - x2) <= GCOORD_ACCURCY_RANGE && Math.abs(y1 - y2) <= GCOORD_ACCURCY_RANGE;
+}
+export {
+  isCoordinatePointEqual
+};

package/dist/v2/business-components/BusinessRecomendPlaceMap/useCacheCenterPlace.d.ts

@@ -14,7 +14,6 @@ export declare const useCacheCenterPlace: (props: UseDefaultCenterPlaceProps) =>
     };
     geoDefaultPosition: Point;
     defaultCenterPlace: {
-        type?: import("../../types/interface").CoordinateType | undefined;
         lng: number;
         lat: number;
         name: string;

package/dist/v2/business-components/BusinessRecomendPlaceMap/useCacheCenterPlace.js

@@ -1,18 +1,21 @@
 import { reactive } from "vue-demi";
 import { apiGetCenterPlaceFromCache } from "../../api/browser.js";
 import { apiMemoryShouldSkipByKey } from "../../api/memory.js";
+import { useMapCoordinatify } from "../../hooks/useMapCoordinatify.js";
 import { maybeFunctionToFunction, lnglat2point } from "../../utils/transform.js";
 const IS_FIRST_LOAD_KEY = "IS_FIRST_LOAD_KEY";
 const useCacheCenterPlace = (props) => {
   const { geoLoadingTitle, emptyTitle } = props;
   const isFirstLoad = !apiMemoryShouldSkipByKey(IS_FIRST_LOAD_KEY);
   const getDefaultCenterPlace = maybeFunctionToFunction(props.defaultCenterPlace);
+  const { unCoordinatifyPlace } = useMapCoordinatify();
+  const inputDefaultCenterPlace = getDefaultCenterPlace == null ? void 0 : getDefaultCenterPlace(apiGetCenterPlaceFromCache());
   const defaultCenterPlace = {
     lng: 0,
     lat: 0,
     name: emptyTitle,
     displayName: emptyTitle,
-    ...getDefaultCenterPlace == null ? void 0 : getDefaultCenterPlace(apiGetCenterPlaceFromCache())
+    ...inputDefaultCenterPlace ? unCoordinatifyPlace(inputDefaultCenterPlace) : void 0
   };
   const geoDefaultPosition = defaultCenterPlace ? lnglat2point(defaultCenterPlace) : [0, 0];
   const centerPlace = reactive({

package/dist/v2/chunks/gcoord.esm-bundler.3f2f1369.js

@@ -0,0 +1,514 @@
+/**
+ * @preserve
+ * gcoord 1.0.5, geographic coordinate library
+ * Copyright (c) 2023 Jiulong Hu <me@hujiulong.com>
+ */
+const { sin: sin$1, cos: cos$1, sqrt: sqrt$1, abs: abs$1, PI: PI$1 } = Math;
+const a = 6378245;
+const ee = 0.006693421622965823;
+function isInChinaBbox(lon, lat) {
+  return lon >= 72.004 && lon <= 137.8347 && lat >= 0.8293 && lat <= 55.8271;
+}
+function transformLat(x, y) {
+  let ret = -100 + 2 * x + 3 * y + 0.2 * y * y + 0.1 * x * y + 0.2 * sqrt$1(abs$1(x));
+  ret += (20 * sin$1(6 * x * PI$1) + 20 * sin$1(2 * x * PI$1)) * 2 / 3;
+  ret += (20 * sin$1(y * PI$1) + 40 * sin$1(y / 3 * PI$1)) * 2 / 3;
+  ret += (160 * sin$1(y / 12 * PI$1) + 320 * sin$1(y * PI$1 / 30)) * 2 / 3;
+  return ret;
+}
+function transformLon(x, y) {
+  let ret = 300 + x + 2 * y + 0.1 * x * x + 0.1 * x * y + 0.1 * sqrt$1(abs$1(x));
+  ret += (20 * sin$1(6 * x * PI$1) + 20 * sin$1(2 * x * PI$1)) * 2 / 3;
+  ret += (20 * sin$1(x * PI$1) + 40 * sin$1(x / 3 * PI$1)) * 2 / 3;
+  ret += (150 * sin$1(x / 12 * PI$1) + 300 * sin$1(x / 30 * PI$1)) * 2 / 3;
+  return ret;
+}
+function delta(lon, lat) {
+  let dLon = transformLon(lon - 105, lat - 35);
+  let dLat = transformLat(lon - 105, lat - 35);
+  const radLat = lat / 180 * PI$1;
+  let magic = sin$1(radLat);
+  magic = 1 - ee * magic * magic;
+  const sqrtMagic = sqrt$1(magic);
+  dLon = dLon * 180 / (a / sqrtMagic * cos$1(radLat) * PI$1);
+  dLat = dLat * 180 / (a * (1 - ee) / (magic * sqrtMagic) * PI$1);
+  return [dLon, dLat];
+}
+function WGS84ToGCJ02(coord) {
+  const [lon, lat] = coord;
+  if (!isInChinaBbox(lon, lat))
+    return [lon, lat];
+  const d = delta(lon, lat);
+  return [lon + d[0], lat + d[1]];
+}
+function GCJ02ToWGS84(coord) {
+  const [lon, lat] = coord;
+  if (!isInChinaBbox(lon, lat))
+    return [lon, lat];
+  let [wgsLon, wgsLat] = [lon, lat];
+  let tempPoint = WGS84ToGCJ02([wgsLon, wgsLat]);
+  let dx = tempPoint[0] - lon;
+  let dy = tempPoint[1] - lat;
+  while (abs$1(dx) > 1e-6 || abs$1(dy) > 1e-6) {
+    wgsLon -= dx;
+    wgsLat -= dy;
+    tempPoint = WGS84ToGCJ02([wgsLon, wgsLat]);
+    dx = tempPoint[0] - lon;
+    dy = tempPoint[1] - lat;
+  }
+  return [wgsLon, wgsLat];
+}
+const { sin, cos, atan2, sqrt, PI } = Math;
+const baiduFactor = PI * 3e3 / 180;
+function BD09ToGCJ02(coord) {
+  const [lon, lat] = coord;
+  const x = lon - 65e-4;
+  const y = lat - 6e-3;
+  const z = sqrt(x * x + y * y) - 2e-5 * sin(y * baiduFactor);
+  const theta = atan2(y, x) - 3e-6 * cos(x * baiduFactor);
+  const newLon = z * cos(theta);
+  const newLat = z * sin(theta);
+  return [newLon, newLat];
+}
+function GCJ02ToBD09(coord) {
+  const [lon, lat] = coord;
+  const x = lon;
+  const y = lat;
+  const z = sqrt(x * x + y * y) + 2e-5 * sin(y * baiduFactor);
+  const theta = atan2(y, x) + 3e-6 * cos(x * baiduFactor);
+  const newLon = z * cos(theta) + 65e-4;
+  const newLat = z * sin(theta) + 6e-3;
+  return [newLon, newLat];
+}
+const R2D = 180 / Math.PI;
+const D2R = Math.PI / 180;
+const A = 6378137;
+const MAXEXTENT = 20037508342789244e-9;
+function ESPG3857ToWGS84(xy) {
+  return [
+    xy[0] * R2D / A,
+    (Math.PI * 0.5 - 2 * Math.atan(Math.exp(-xy[1] / A))) * R2D
+  ];
+}
+function WGS84ToEPSG3857(lonLat) {
+  const adjusted = Math.abs(lonLat[0]) <= 180 ? lonLat[0] : lonLat[0] - (lonLat[0] < 0 ? -1 : 1) * 360;
+  const xy = [
+    A * adjusted * D2R,
+    A * Math.log(Math.tan(Math.PI * 0.25 + 0.5 * lonLat[1] * D2R))
+  ];
+  if (xy[0] > MAXEXTENT)
+    xy[0] = MAXEXTENT;
+  if (xy[0] < -MAXEXTENT)
+    xy[0] = -MAXEXTENT;
+  if (xy[1] > MAXEXTENT)
+    xy[1] = MAXEXTENT;
+  if (xy[1] < -MAXEXTENT)
+    xy[1] = -MAXEXTENT;
+  return xy;
+}
+const { abs } = Math;
+const MCBAND = [1289059486e-2, 836237787e-2, 5591021, 348198983e-2, 167804312e-2, 0];
+const LLBAND = [75, 60, 45, 30, 15, 0];
+const MC2LL = [
+  [
+    1410526172116255e-23,
+    898305509648872e-20,
+    -1.9939833816331,
+    200.9824383106796,
+    -187.2403703815547,
+    91.6087516669843,
+    -23.38765649603339,
+    2.57121317296198,
+    -0.03801003308653,
+    173379812e-1
+  ],
+  [
+    -7435856389565537e-24,
+    8983055097726239e-21,
+    -0.78625201886289,
+    96.32687599759846,
+    -1.85204757529826,
+    -59.36935905485877,
+    47.40033549296737,
+    -16.50741931063887,
+    2.28786674699375,
+    1026014486e-2
+  ],
+  [
+    -3030883460898826e-23,
+    898305509983578e-20,
+    0.30071316287616,
+    59.74293618442277,
+    7.357984074871,
+    -25.38371002664745,
+    13.45380521110908,
+    -3.29883767235584,
+    0.32710905363475,
+    685681737e-2
+  ],
+  [
+    -1981981304930552e-23,
+    8983055099779535e-21,
+    0.03278182852591,
+    40.31678527705744,
+    0.65659298677277,
+    -4.44255534477492,
+    0.85341911805263,
+    0.12923347998204,
+    -0.04625736007561,
+    448277706e-2
+  ],
+  [
+    309191371068437e-23,
+    8983055096812155e-21,
+    6995724062e-14,
+    23.10934304144901,
+    -23663490511e-14,
+    -0.6321817810242,
+    -0.00663494467273,
+    0.03430082397953,
+    -0.00466043876332,
+    25551644e-1
+  ],
+  [
+    2890871144776878e-24,
+    8983055095805407e-21,
+    -3068298e-14,
+    7.47137025468032,
+    -353937994e-14,
+    -0.02145144861037,
+    -1234426596e-14,
+    10322952773e-14,
+    -323890364e-14,
+    826088.5
+  ]
+];
+const LL2MC = [
+  [
+    -0.0015702102444,
+    111320.7020616939,
+    1704480524535203,
+    -10338987376042340,
+    26112667856603880,
+    -35149669176653700,
+    26595700718403920,
+    -10725012454188240,
+    1800819912950474,
+    82.5
+  ],
+  [
+    8277824516172526e-19,
+    111320.7020463578,
+    6477955746671607e-7,
+    -4082003173641316e-6,
+    1077490566351142e-5,
+    -1517187553151559e-5,
+    1205306533862167e-5,
+    -5124939663577472e-6,
+    9133119359512032e-7,
+    67.5
+  ],
+  [
+    0.00337398766765,
+    111320.7020202162,
+    4481351045890365e-9,
+    -2339375119931662e-8,
+    7968221547186455e-8,
+    -1159649932797253e-7,
+    9723671115602145e-8,
+    -4366194633752821e-8,
+    8477230501135234e-9,
+    52.5
+  ],
+  [
+    0.00220636496208,
+    111320.7020209128,
+    51751.86112841131,
+    3796837749470245e-9,
+    992013.7397791013,
+    -122195221711287e-8,
+    1340652697009075e-9,
+    -620943.6990984312,
+    144416.9293806241,
+    37.5
+  ],
+  [
+    -3441963504368392e-19,
+    111320.7020576856,
+    278.2353980772752,
+    2485758690035394e-9,
+    6070.750963243378,
+    54821.18345352118,
+    9540.606633304236,
+    -2710.55326746645,
+    1405.483844121726,
+    22.5
+  ],
+  [
+    -3218135878613132e-19,
+    111320.7020701615,
+    0.00369383431289,
+    823725.6402795718,
+    0.46104986909093,
+    2351.343141331292,
+    1.58060784298199,
+    8.77738589078284,
+    0.37238884252424,
+    7.45
+  ]
+];
+function transform$1(x, y, factors) {
+  const cc = abs(y) / factors[9];
+  let xt = factors[0] + factors[1] * abs(x);
+  let yt = factors[2] + factors[3] * cc + factors[4] * Math.pow(cc, 2) + factors[5] * Math.pow(cc, 3) + factors[6] * Math.pow(cc, 4) + factors[7] * Math.pow(cc, 5) + factors[8] * Math.pow(cc, 6);
+  xt *= x < 0 ? -1 : 1;
+  yt *= y < 0 ? -1 : 1;
+  return [xt, yt];
+}
+function BD09toBD09MC(coord) {
+  const [lng, lat] = coord;
+  let factors = [];
+  for (let i = 0; i < LLBAND.length; i++) {
+    if (abs(lat) > LLBAND[i]) {
+      factors = LL2MC[i];
+      break;
+    }
+  }
+  return transform$1(lng, lat, factors);
+}
+function BD09MCtoBD09(coord) {
+  const [x, y] = coord;
+  let factors = [];
+  for (let i = 0; i < MCBAND.length; i++) {
+    if (y >= MCBAND[i]) {
+      factors = MC2LL[i];
+      break;
+    }
+  }
+  return transform$1(x, y, factors);
+}
+function assert(condition, msg) {
+  if (!condition)
+    throw new Error(msg);
+}
+function isArray(input) {
+  return !!input && Object.prototype.toString.call(input) === "[object Array]";
+}
+function isNumber(input) {
+  return !isNaN(Number(input)) && input !== null && !isArray(input);
+}
+function compose(...funcs) {
+  const start = funcs.length - 1;
+  return function(...args) {
+    let i = start;
+    let result = funcs[start].apply(null, args);
+    while (i--)
+      result = funcs[i].call(null, result);
+    return result;
+  };
+}
+function coordEach(geojson, callback, excludeWrapCoord = false) {
+  if (geojson === null)
+    return;
+  let j;
+  let k;
+  let l;
+  let geometry;
+  let coords;
+  let stopG;
+  let wrapShrink = 0;
+  let coordIndex = 0;
+  let geometryMaybeCollection;
+  let isGeometryCollection;
+  const { type } = geojson;
+  const isFeatureCollection = type === "FeatureCollection";
+  const isFeature = type === "Feature";
+  const stop = isFeatureCollection ? geojson.features.length : 1;
+  for (let featureIndex = 0; featureIndex < stop; featureIndex++) {
+    geometryMaybeCollection = isFeatureCollection ? geojson.features[featureIndex].geometry : isFeature ? geojson.geometry : geojson;
+    isGeometryCollection = geometryMaybeCollection ? geometryMaybeCollection.type === "GeometryCollection" : false;
+    stopG = isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;
+    for (let geomIndex = 0; geomIndex < stopG; geomIndex++) {
+      let multiFeatureIndex = 0;
+      let geometryIndex = 0;
+      geometry = isGeometryCollection ? geometryMaybeCollection.geometries[geomIndex] : geometryMaybeCollection;
+      if (geometry === null)
+        continue;
+      const geomType = geometry.type;
+      wrapShrink = excludeWrapCoord && (geomType === "Polygon" || geomType === "MultiPolygon") ? 1 : 0;
+      switch (geomType) {
+        case null:
+          break;
+        case "Point":
+          coords = geometry.coordinates;
+          if (callback(coords, coordIndex, featureIndex, multiFeatureIndex, geometryIndex) === false)
+            return false;
+          coordIndex++;
+          multiFeatureIndex++;
+          break;
+        case "LineString":
+        case "MultiPoint":
+          coords = geometry.coordinates;
+          for (j = 0; j < coords.length; j++) {
+            if (callback(coords[j], coordIndex, featureIndex, multiFeatureIndex, geometryIndex) === false)
+              return false;
+            coordIndex++;
+            if (geomType === "MultiPoint")
+              multiFeatureIndex++;
+          }
+          if (geomType === "LineString")
+            multiFeatureIndex++;
+          break;
+        case "Polygon":
+        case "MultiLineString":
+          coords = geometry.coordinates;
+          for (j = 0; j < coords.length; j++) {
+            for (k = 0; k < coords[j].length - wrapShrink; k++) {
+              if (callback(coords[j][k], coordIndex, featureIndex, multiFeatureIndex, geometryIndex) === false)
+                return false;
+              coordIndex++;
+            }
+            if (geomType === "MultiLineString")
+              multiFeatureIndex++;
+            if (geomType === "Polygon")
+              geometryIndex++;
+          }
+          if (geomType === "Polygon")
+            multiFeatureIndex++;
+          break;
+        case "MultiPolygon":
+          coords = geometry.coordinates;
+          for (j = 0; j < coords.length; j++) {
+            geometryIndex = 0;
+            for (k = 0; k < coords[j].length; k++) {
+              for (l = 0; l < coords[j][k].length - wrapShrink; l++) {
+                if (callback(coords[j][k][l], coordIndex, featureIndex, multiFeatureIndex, geometryIndex) === false)
+                  return false;
+                coordIndex++;
+              }
+              geometryIndex++;
+            }
+            multiFeatureIndex++;
+          }
+          break;
+        case "GeometryCollection":
+          for (j = 0; j < geometry.geometries.length; j++) {
+            if (coordEach(geometry.geometries[j], callback, excludeWrapCoord) === false)
+              return false;
+          }
+          break;
+        default:
+          throw new Error("Unknown Geometry Type");
+      }
+    }
+  }
+}
+var CRSTypes;
+(function(CRSTypes2) {
+  CRSTypes2["WGS84"] = "WGS84";
+  CRSTypes2["WGS1984"] = "WGS84";
+  CRSTypes2["EPSG4326"] = "WGS84";
+  CRSTypes2["GCJ02"] = "GCJ02";
+  CRSTypes2["AMap"] = "GCJ02";
+  CRSTypes2["BD09"] = "BD09";
+  CRSTypes2["BD09LL"] = "BD09";
+  CRSTypes2["Baidu"] = "BD09";
+  CRSTypes2["BMap"] = "BD09";
+  CRSTypes2["BD09MC"] = "BD09MC";
+  CRSTypes2["BD09Meter"] = "BD09MC";
+  CRSTypes2["EPSG3857"] = "EPSG3857";
+  CRSTypes2["EPSG900913"] = "EPSG3857";
+  CRSTypes2["EPSG102100"] = "EPSG3857";
+  CRSTypes2["WebMercator"] = "EPSG3857";
+  CRSTypes2["WM"] = "EPSG3857";
+})(CRSTypes || (CRSTypes = {}));
+const WGS84 = {
+  to: {
+    [CRSTypes.GCJ02]: WGS84ToGCJ02,
+    [CRSTypes.BD09]: compose(GCJ02ToBD09, WGS84ToGCJ02),
+    [CRSTypes.BD09MC]: compose(BD09toBD09MC, GCJ02ToBD09, WGS84ToGCJ02),
+    [CRSTypes.EPSG3857]: WGS84ToEPSG3857
+  }
+};
+const GCJ02 = {
+  to: {
+    [CRSTypes.WGS84]: GCJ02ToWGS84,
+    [CRSTypes.BD09]: GCJ02ToBD09,
+    [CRSTypes.BD09MC]: compose(BD09toBD09MC, GCJ02ToBD09),
+    [CRSTypes.EPSG3857]: compose(WGS84ToEPSG3857, GCJ02ToWGS84)
+  }
+};
+const BD09 = {
+  to: {
+    [CRSTypes.WGS84]: compose(GCJ02ToWGS84, BD09ToGCJ02),
+    [CRSTypes.GCJ02]: BD09ToGCJ02,
+    [CRSTypes.EPSG3857]: compose(WGS84ToEPSG3857, GCJ02ToWGS84, BD09ToGCJ02),
+    [CRSTypes.BD09MC]: BD09toBD09MC
+  }
+};
+const EPSG3857 = {
+  to: {
+    [CRSTypes.WGS84]: ESPG3857ToWGS84,
+    [CRSTypes.GCJ02]: compose(WGS84ToGCJ02, ESPG3857ToWGS84),
+    [CRSTypes.BD09]: compose(GCJ02ToBD09, WGS84ToGCJ02, ESPG3857ToWGS84),
+    [CRSTypes.BD09MC]: compose(BD09toBD09MC, GCJ02ToBD09, WGS84ToGCJ02, ESPG3857ToWGS84)
+  }
+};
+const BD09MC = {
+  to: {
+    [CRSTypes.WGS84]: compose(GCJ02ToWGS84, BD09ToGCJ02, BD09MCtoBD09),
+    [CRSTypes.GCJ02]: compose(BD09ToGCJ02, BD09MCtoBD09),
+    [CRSTypes.EPSG3857]: compose(WGS84ToEPSG3857, GCJ02ToWGS84, BD09ToGCJ02, BD09MCtoBD09),
+    [CRSTypes.BD09]: BD09MCtoBD09
+  }
+};
+const crsMap = {
+  WGS84,
+  GCJ02,
+  BD09,
+  EPSG3857,
+  BD09MC
+};
+var crsMap$1 = crsMap;
+function transform(input, crsFrom, crsTo) {
+  assert(!!input, "The args[0] input coordinate is required");
+  assert(!!crsFrom, "The args[1] original coordinate system is required");
+  assert(!!crsTo, "The args[2] target coordinate system is required");
+  if (crsFrom === crsTo)
+    return input;
+  const from = crsMap$1[crsFrom];
+  assert(!!from, `Invalid original coordinate system: ${crsFrom}`);
+  const to = from.to[crsTo];
+  assert(!!to, `Invalid target coordinate system: ${crsTo}`);
+  const type = typeof input;
+  assert(type === "string" || type === "object", `Invalid input coordinate type: ${type}`);
+  if (type === "string") {
+    try {
+      input = JSON.parse(input);
+    } catch (e) {
+      throw new Error(`Invalid input coordinate: ${input}`);
+    }
+  }
+  let isPosition = false;
+  if (isArray(input)) {
+    assert(input.length >= 2, `Invalid input coordinate: ${input}`);
+    assert(isNumber(input[0]) && isNumber(input[1]), `Invalid input coordinate: ${input}`);
+    input = input.map(Number);
+    isPosition = true;
+  }
+  const convert = to;
+  if (isPosition)
+    return convert(input);
+  coordEach(input, (coord) => {
+    [coord[0], coord[1]] = convert(coord);
+  });
+  return input;
+}
+const exported = Object.assign(Object.assign({}, CRSTypes), {
+  // 兼容原来gcoord.WGS84的使用方式
+  CRSTypes,
+  transform
+});
+export {
+  exported as e
+};

package/dist/v2/components/Gmap/Gmap.js

@@ -4,13 +4,11 @@ import { createElement } from "../../demi-polyfill/demi-polyfill.js";
 import { provideGmap } from "../../hooks/useMap.js";
 import { useMapEventSource } from "../../hooks/useMapEventSource.js";
 import { useGmapGestureZoomCenter } from "../../hooks/useMapGestureZoomCenter.js";
-import { useGmapTouchStartCenter } from "../../hooks/useMapTouchStartCenter.js";
 import { useGmapWheelZoomCenter } from "../../hooks/useMapWheelZoomCenter.js";
 import { useResizeObserver } from "../../hooks/useResizeObserver.js";
 import { defineSetup } from "../../types/helper.js";
 import { watchNoneImmediatePostEffectForDeepOption, watchPostEffectForGMapEvent } from "../../utils/compare.js";
 import { OS_PLATFORM, detectOSPlatform } from "../../utils/platform.js";
-import { vec2lnglat } from "../../utils/transform.js";
 const Gmap_css_ts_vanilla = "";
 var gmap = "_7anfuo0";
 const Gmap = defineSetup("Gmap", function(props, { slots, emit, attrs }) {
@@ -42,16 +40,11 @@ const Gmap = defineSetup("Gmap", function(props, { slots, emit, attrs }) {
   const elementRef = shallowRef();
   const mapRef = shallowRef();
   const { executeMapApi } = useMapEventSource();
-  const { touchstartCenterRef } = useGmapTouchStartCenter({ mapRef, elementRef });
   const handleDrag = (name) => {
     emit(name, { target: mapRef.value });
   };
   const handleZoom = (name) => {
-    var _a;
     emit(name, { target: mapRef.value });
-    const center = touchstartCenterRef.value;
-    if (center)
-      (_a = mapRef.value) == null ? void 0 : _a.setCenter(vec2lnglat(center));
   };
   provideGmap(mapRef);
   useGmapWheelZoomCenter({ mapRef, enableRef });

package/dist/v2/hooks/useMapCoordinatify.js

@@ -1,6 +1,7 @@
 import { useMapGCJ02 } from "./useMapGCJ02.js";
+import { inChina } from "./useMapInChina.js";
 function useMapCoordinatify() {
-  const { toCoordinateType, toLocalGcj02 } = useMapGCJ02();
+  const { toCoordinateType, toLocalGcj02, toLocalWgs84 } = useMapGCJ02();
   const coordinatifyPoint = (value) => {
     const [lng, lat] = value;
     return { lng, lat, type: toCoordinateType(value) };
@@ -11,7 +12,9 @@ function useMapCoordinatify() {
     if (type === inputType)
       return [lng, lat];
     if (type === "wgs84") {
-      throw new Error(`国外经纬度收到火星坐标系数据: ${JSON.stringify(value)}`);
+      if (!inChina([lng, lat]))
+        throw new Error(`国外经纬度收到火星坐标系数据: ${JSON.stringify(value)}`);
+      return toLocalWgs84([lng, lat]);
     }
     return toLocalGcj02([lng, lat]);
   };

package/dist/v2/hooks/useMapGCJ02.d.ts

@@ -5,6 +5,7 @@ export declare const useAmapGCJ02: () => {
     toGcj02Points: (points: Point[]) => Promise<Point[]>;
     toLocalGcj02: (point: Point) => Point;
     toLocalGcj02Points: (points: Point[]) => Point[];
+    toLocalWgs84: (point: Point) => Point;
 };
 export declare const useGmapGCJ02: () => {
     toCoordinateType: (p: Point) => CoordinateType;
@@ -12,6 +13,7 @@ export declare const useGmapGCJ02: () => {
     toGcj02Points: (points: Point[]) => Promise<Point[]>;
     toLocalGcj02: (point: Point) => Point;
     toLocalGcj02Points: (points: Point[]) => Point[];
+    toLocalWgs84: (point: Point) => Point;
 };
 export declare const useMapGCJ02: () => {
     toCoordinateType: (p: Point) => CoordinateType;
@@ -19,4 +21,5 @@ export declare const useMapGCJ02: () => {
     toGcj02Points: (points: Point[]) => Promise<Point[]>;
     toLocalGcj02: (point: Point) => Point;
     toLocalGcj02Points: (points: Point[]) => Point[];
+    toLocalWgs84: (point: Point) => Point;
 };