@heycar/heycars-map 2.6.1 → 2.7.1

package/README.md

@@ -130,6 +130,10 @@ export type RecommendType = "Restricted" | "Forbidden" | "Recommend";
   gmapKey={gmapApiKey}
   // 使用哪个地图供应商，目前两个供应商： amap 高德 / gmap 谷歌
   supplier={"amap"}
+  // 可选，高德驾车路线规划代理地址
+  gaodeDirectionDrivingProxyUrl="/overseas/amap/driveGuide"
+  // 可选，高德步行路线规划代理地址
+  gaodeDirectionWalkingProxyUrl="/overseas/amap/walkingGuide"
   // 可选，谷歌路线纠偏代理地址
   googleSnapRoadProxyUrl="/overseas/maps/snapToRoads"
   // 可选，谷歌路线规划代理地址

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

@@ -0,0 +1,50 @@
+import type { Point } from "../types/interface";
+type GaodeMaybeEmpty<T> = T | [];
+export declare enum GaodeDirectionStatus {
+    SUCCESS = "1",
+    FAIL = "0"
+}
+export interface GaodeMeasurableObject {
+    distance: GaodeMaybeEmpty<`${number}`>;
+    duration: GaodeMaybeEmpty<`${number}`>;
+}
+export interface GaodeDirectionBasicStep extends GaodeMeasurableObject {
+    polyline: GaodeMaybeEmpty<string>;
+}
+export type GaodeDirectionResponse = {
+    status: GaodeDirectionStatus;
+    info: string;
+};
+export declare const gaodeDirectionStatus2amapDirectionCallbackStatus: (status: GaodeDirectionStatus) => AMap.DirectionCallbackStatus;
+export declare function isGaodeDirectionResponse(value: unknown): value is GaodeDirectionResponse;
+export declare function isGaodeDirectionStatus(value: unknown): value is GaodeDirectionStatus;
+export declare function assertGaodeDirectionStatus(value: unknown): asserts value is GaodeDirectionStatus;
+export declare function isGaodeNumberableString(value: unknown): value is GaodeMaybeEmpty<`${number}`>;
+export declare function isGaodeDirectionPolyline(value: unknown): value is GaodeMaybeEmpty<string>;
+export declare function isGaodeMeasurableObject(value: unknown): value is GaodeMeasurableObject;
+export declare function isGaodeDirectionBasicStep(value: unknown): value is GaodeDirectionBasicStep;
+export interface ApiGaodeDirectionDrivingOutput {
+    status: AMap.DirectionCallbackStatus;
+    error_message: string;
+    routes: AMap.DrivingRoute[];
+}
+interface ApiGaodeDirectionDrivingProps {
+    proxyUrl?: string;
+    origin: Point[];
+    destination: Point;
+    extensions?: "base" | "all";
+    destinationid?: string;
+    destinationtype?: string;
+    strategy?: AMap.DrivingOptions["policy"];
+    waypoints?: Point[];
+    avoidpolygons?: string;
+    province?: AMap.DrivingOptions["province"];
+    number?: AMap.DrivingOptions["number"];
+    cartype?: 0 | 1 | 2;
+    ferry?: AMap.DrivingOptions["ferry"];
+    roadaggregation?: boolean;
+    nosteps?: 0 | 1;
+    output?: "JSON" | "XML";
+}
+export declare function apiGaodeDirectionDriving(props: ApiGaodeDirectionDrivingProps): Promise<ApiGaodeDirectionDrivingOutput>;
+export {};

package/dist/v2/api/gaodeDirectionDriving.js

@@ -0,0 +1,157 @@
+import { gaodePointsStringify, gaodePolyline2amapLngLat } from "../utils/transform.js";
+import { createTypeError, isProxyServiceError } from "../utils/typeChecking.js";
+const GAODE_POLYLINE_REGEX = /^(?:\d*\.\d+,\d*\.\d+)?(?:;\d*\.\d+,\d*\.\d+)*$/;
+var GaodeDirectionStatus = /* @__PURE__ */ ((GaodeDirectionStatus2) => {
+  GaodeDirectionStatus2["SUCCESS"] = "1";
+  GaodeDirectionStatus2["FAIL"] = "0";
+  return GaodeDirectionStatus2;
+})(GaodeDirectionStatus || {});
+const gaodeDirectionStatus2amapDirectionCallbackStatus = (status) => {
+  return status === "1" ? "complete" : "error";
+};
+function isGaodeDirectionResponse(value) {
+  return typeof value === "object" && value !== null && "status" in value && isGaodeDirectionStatus(value.status) && "info" in value && typeof value.info === "string";
+}
+function isGaodeDirectionStatus(value) {
+  return value === "1" || value === "0";
+}
+function assertGaodeDirectionStatus(value) {
+  if (isGaodeDirectionStatus(value))
+    return;
+  throw createTypeError("GaodeDirectionStatus", value);
+}
+function isGaodeNumberableString(value) {
+  return typeof value === "string" && !isNaN(parseFloat(value)) || isGaodeEmptyValue(value);
+}
+function isGaodeDirectionPolyline(value) {
+  return typeof value === "string" && GAODE_POLYLINE_REGEX.test(value) || isGaodeEmptyValue(value);
+}
+function isGaodeMeasurableObject(value) {
+  return typeof value === "object" && value !== null && "distance" in value && isGaodeNumberableString(value.distance) && "duration" in value && isGaodeNumberableString(value.duration);
+}
+function isGaodeDirectionBasicStep(value) {
+  return isGaodeMeasurableObject(value) && "polyline" in value && isGaodeDirectionPolyline(value.polyline);
+}
+function isGaodeEmptyValue(value) {
+  return Array.isArray(value) && value.length === 0;
+}
+function assertGaodoDirectionDrivingStep(value) {
+  if (isGaodeDirectionBasicStep(value))
+    return;
+  throw createTypeError("GaodeDirectionDrivingStep", value);
+}
+function assertGaodeDirectionDrivingRoutePath(value) {
+  if (!isGaodeMeasurableObject(value) || !("tolls" in value) || !isGaodeNumberableString(value.tolls) || !("steps" in value) || !Array.isArray(value.steps)) {
+    throw createTypeError("GaodeDirectionDrivingRoutePath", value);
+  }
+  value.steps.forEach(assertGaodoDirectionDrivingStep);
+}
+function assertGaodeDirectionDrivingRoute(value) {
+  if (typeof value !== "object" || value === null || !("paths" in value) || !Array.isArray(value.paths)) {
+    throw createTypeError("GaodeDirectionDrivingRoute", value);
+  }
+  value.paths.forEach(assertGaodeDirectionDrivingRoutePath);
+}
+function assertGaodeDirectionDrivingResponse(value) {
+  if (!isGaodeDirectionResponse(value) || !("route" in value)) {
+    throw createTypeError("GaodeDirectionDrivingResponse", value);
+  }
+  try {
+    assertGaodeDirectionDrivingRoute(value.route);
+  } catch (error) {
+    const { message: detail } = error;
+    throw createTypeError("GaodeDirectionDrivingResponse", value, detail);
+  }
+}
+function gaodeDirectionDrivingRoute2amapDrivingRoute(gaodeRoute) {
+  return gaodeRoute.paths.map((routePath) => {
+    const { distance, duration, tolls, steps: godeDirectionSteps } = routePath;
+    const steps = godeDirectionSteps.map((directionStep) => {
+      const { distance: distance2, duration: duration2, polyline } = directionStep;
+      return {
+        distance: Number(distance2),
+        time: Number(duration2),
+        path: gaodePolyline2amapLngLat(String(polyline))
+      };
+    });
+    return {
+      distance: Number(distance),
+      time: Number(duration),
+      tolls: Number(tolls),
+      steps
+    };
+  });
+}
+async function apiGaodeDirectionDriving(props) {
+  const { proxyUrl, origin, destination, waypoints, extensions = "all" } = props;
+  if (!proxyUrl) {
+    const error_message = "Warning: gaode direction driving service is bypassed due to proxyUrl is not provided!";
+    console.warn(error_message);
+    return { status: "no_data", routes: [], error_message };
+  }
+  const { protocol, host } = location;
+  const baseUrl = proxyUrl.startsWith(protocol) ? void 0 : `${protocol}//${host}`;
+  const url = new URL(proxyUrl, baseUrl);
+  url.searchParams.set("origin", gaodePointsStringify(origin));
+  url.searchParams.set("destination", gaodePointsStringify([destination]));
+  url.searchParams.set("extensions", extensions);
+  if (waypoints && waypoints.length > 0)
+    url.searchParams.set("waypoints", gaodePointsStringify(waypoints));
+  for (const key of [
+    "destinationid",
+    "destinationtype",
+    "strategy",
+    "waypoints",
+    "avoidpolygons",
+    "province",
+    "number",
+    "cartype",
+    "ferry",
+    "roadaggregation",
+    "nosteps",
+    "output"
+  ]) {
+    if (props[key] !== void 0)
+      url.searchParams.set(key, String(props[key]));
+  }
+  const response = await fetch(url);
+  if (response.ok) {
+    const result = await response.json();
+    assertGaodeDirectionDrivingResponse(result);
+    const { status, info: error_message, route } = result;
+    return {
+      status: gaodeDirectionStatus2amapDirectionCallbackStatus(status),
+      error_message,
+      routes: gaodeDirectionDrivingRoute2amapDrivingRoute(route)
+    };
+  }
+  const error = await response.json();
+  if (isProxyServiceError(error)) {
+    const { code, msg } = error;
+    throw new Error(`apiGaodeDirectionDriving proxy failed code: ${code}, msg: 
+${msg}`);
+  }
+  if (isGaodeDirectionResponse(error)) {
+    const { status: serviceStatus, info: error_message } = error;
+    const status = gaodeDirectionStatus2amapDirectionCallbackStatus(serviceStatus);
+    throw new Error(
+      `apiGaodeDirectionDriving failed status: ${status}, message: 
+${error_message}`
+    );
+  }
+  throw new Error(
+    `apiGaodeDirectionDriving failed with unrecognized server response: ${JSON.stringify(error)}`
+  );
+}
+export {
+  GaodeDirectionStatus,
+  apiGaodeDirectionDriving,
+  assertGaodeDirectionStatus,
+  gaodeDirectionStatus2amapDirectionCallbackStatus,
+  isGaodeDirectionBasicStep,
+  isGaodeDirectionPolyline,
+  isGaodeDirectionResponse,
+  isGaodeDirectionStatus,
+  isGaodeMeasurableObject,
+  isGaodeNumberableString
+};

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

@@ -0,0 +1,15 @@
+import type { Point } from "../types/interface";
+import { type ApiGaodeDirectionDrivingOutput } from "./gaodeDirectionDriving";
+export interface ApiGaodeDirectionWalkingProps {
+    proxyUrl?: string;
+    origin: Point;
+    destination: Point;
+    origin_id?: string;
+    destination_id?: string;
+    output?: "JSON" | "XML";
+}
+interface ApiGaodeDirectionWalkingOutput extends Omit<ApiGaodeDirectionDrivingOutput, "routes"> {
+    routes: AMap.WalkRoute[];
+}
+export declare function apiGaodeDirectionWalking(props: ApiGaodeDirectionWalkingProps): Promise<ApiGaodeDirectionWalkingOutput>;
+export {};

package/dist/v2/api/gaodeDirectionWalking.js

@@ -0,0 +1,105 @@
+import { gaodePointsStringify, gaodePolyline2amapLngLat } from "../utils/transform.js";
+import { isProxyServiceError, createTypeError } from "../utils/typeChecking.js";
+import { gaodeDirectionStatus2amapDirectionCallbackStatus, isGaodeDirectionResponse, isGaodeMeasurableObject, isGaodeDirectionBasicStep } from "./gaodeDirectionDriving.js";
+function assertGaodoDirectionWalkingStep(value) {
+  if (isGaodeDirectionBasicStep(value))
+    return;
+  throw createTypeError("GaodeDirectionWalkingStep", value);
+}
+function assertGaodeDirectionWalkingRoutePath(value) {
+  if (!isGaodeMeasurableObject(value) || !("steps" in value) || !Array.isArray(value.steps)) {
+    throw createTypeError("GaodeDirectionWalkingRoutePath", value);
+  }
+  value.steps.forEach(assertGaodoDirectionWalkingStep);
+}
+function assertGaodeDirectionWalkingRoute(value) {
+  if (typeof value !== "object" || value === null || !("paths" in value) || !Array.isArray(value.paths)) {
+    throw createTypeError("GaodeDirectionRoute", value);
+  }
+  value.paths.forEach(assertGaodeDirectionWalkingRoutePath);
+}
+function assertGaodeDirectionWalkingResponse(value) {
+  if (!isGaodeDirectionResponse(value) || !("route" in value)) {
+    throw createTypeError("GaodeDirectionWalkingResponse", value);
+  }
+  try {
+    assertGaodeDirectionWalkingRoute(value.route);
+  } catch (error) {
+    const { message: detail } = error;
+    throw createTypeError("GaodeDirectionWalkingResponse", value, detail);
+  }
+}
+function gaodeDirectionWalkingRoute2amapWalkRoute(gaodeRoute) {
+  return gaodeRoute.paths.map((routePath) => {
+    const { distance, duration, steps: godeDirectionSteps } = routePath;
+    const steps = godeDirectionSteps.map((directionStep) => {
+      const { distance: distance2, duration: duration2, polyline } = directionStep;
+      return {
+        distance: Number(distance2),
+        time: Number(duration2),
+        path: gaodePolyline2amapLngLat(String(polyline))
+      };
+    });
+    return {
+      distance: Number(distance),
+      time: Number(duration),
+      steps
+    };
+  });
+}
+async function apiGaodeDirectionWalking(props) {
+  const { proxyUrl, origin, destination } = props;
+  if (!proxyUrl) {
+    const error_message = "Warning: gaode direction walking service is bypassed due to proxyUrl is not provided!";
+    console.warn(error_message);
+    return {
+      status: "no_data",
+      routes: [],
+      error_message
+    };
+  }
+  const { protocol, host } = location;
+  const baseUrl = proxyUrl.startsWith(protocol) ? void 0 : `${protocol}//${host}`;
+  const url = new URL(proxyUrl, baseUrl);
+  url.searchParams.set("origin", gaodePointsStringify([origin]));
+  url.searchParams.set("destination", gaodePointsStringify([destination]));
+  for (const key of [
+    "origin_id",
+    "destination_id",
+    "output"
+  ]) {
+    if (props[key] !== void 0)
+      url.searchParams.set(key, String(props[key]));
+  }
+  const response = await fetch(url);
+  if (response.ok) {
+    const result = await response.json();
+    assertGaodeDirectionWalkingResponse(result);
+    const { status, info: error_message, route } = result;
+    return {
+      status: gaodeDirectionStatus2amapDirectionCallbackStatus(status),
+      error_message,
+      routes: gaodeDirectionWalkingRoute2amapWalkRoute(route)
+    };
+  }
+  const error = await response.json();
+  if (isProxyServiceError(error)) {
+    const { code, msg } = error;
+    throw new Error(`apiGaodeDirectionWalking proxy failed code: ${code}, msg: 
+${msg}`);
+  }
+  if (isGaodeDirectionResponse(error)) {
+    const { status: serviceStatus, info: error_message } = error;
+    const status = gaodeDirectionStatus2amapDirectionCallbackStatus(serviceStatus);
+    throw new Error(
+      `apiGaodeDirectionWalking failed status: ${status}, message: 
+${error_message}`
+    );
+  }
+  throw new Error(
+    `apiGaodeDirectionWalking failed with unrecognized server response: ${JSON.stringify(error)}`
+  );
+}
+export {
+  apiGaodeDirectionWalking
+};

package/dist/v2/api/geometry.js

@@ -1,18 +1,18 @@
 import { e as exported } from "../chunks/gcoord.esm-bundler.3f2f1369.js";
+import { isAccuryEqual } from "../utils/transform.js";
 import { toCoordinatePointType } from "../utils/typeChecking.js";
-const GCOORD_ACCURCY_RANGE = 1e-6;
 function isCoordinatePointEqual(input1, input2) {
   if (!input2)
     return false;
   const p1 = toCoordinatePointType(input1);
   const p2 = toCoordinatePointType(input2);
   if (p1.type === p2.type)
-    return p1.lng === p2.lng && p1.lat === p2.lat;
+    return isAccuryEqual(p1.lng, p2.lng) && isAccuryEqual(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;
+  return isAccuryEqual(x1, x2) && isAccuryEqual(y1, y2);
 }
 export {
   isCoordinatePointEqual

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

@@ -1,8 +1,8 @@
 /// <reference types="google.maps" />
 import type { Point } from "../types/interface";
-type DirectionsStatus = `${google.maps.DirectionsStatus}`;
+type GoogleDirectionsStatus = `${google.maps.DirectionsStatus}`;
 export interface GoogleDirectionsResponse extends Pick<google.maps.DirectionsResult, "routes" | "geocoded_waypoints" | "available_travel_modes"> {
-    status: DirectionsStatus;
+    status: GoogleDirectionsStatus;
     error_message?: string;
 }
 export interface ApiGoogleDirectionsProps {

package/dist/v2/api/googleDirections.js

@@ -19,12 +19,12 @@ function isGoogleDuration(value) {
 function isGoogleDirectionsPolyline(value) {
   return typeof value === "object" && value !== null && "points" in value && typeof value.points === "string";
 }
-function isMeasurableObject(value) {
+function isGoogleMeasurableObject(value) {
   return typeof value === "object" && value !== null && (!("distance" in value) || value.distance === void 0 || isGoogleDistance(value.distance)) && (!("duration" in value) || value.duration === void 0 || isGoogleDuration(value.duration));
 }
 function assertGoogleDirectionsStep(value) {
   const error = createTypeError("google.maps.DirectionsStep", value);
-  if (!isMeasurableObject(value))
+  if (!isGoogleMeasurableObject(value))
     throw error;
   if (!("polyline" in value)) {
     value.path = [];
@@ -37,7 +37,7 @@ function assertGoogleDirectionsStep(value) {
   );
 }
 function assertGoogleDirectionsLeg(value) {
-  if (!isMeasurableObject(value) || !("steps" in value) || !Array.isArray(value.steps))
+  if (!isGoogleMeasurableObject(value) || !("steps" in value) || !Array.isArray(value.steps))
     throw createTypeError("google.maps.DirectionsLeg", value);
   try {
     for (const step of value.steps) {
@@ -83,12 +83,15 @@ function isGoogleDirectionsError(error) {
 }
 async function apiGoogleDirections(props) {
   const { proxyUrl, origin, destination, waypoints, avoid } = props;
-  if (!proxyUrl)
+  if (!proxyUrl) {
+    const error_message = "Warning: google directions service is bypassed due to proxyUrl is not provided!";
+    console.warn(error_message);
     return {
       status: "ZERO_RESULTS",
       routes: [],
-      error_message: "Warning: google directions service is bypassed due to proxyUrl is not provided!"
+      error_message
     };
+  }
   const { protocol, host } = location;
   const baseUrl = proxyUrl.startsWith(protocol) ? void 0 : `${protocol}//${host}`;
   const url = new URL(proxyUrl, baseUrl);
@@ -111,7 +114,7 @@ async function apiGoogleDirections(props) {
     "transit_routing_preference"
   ]) {
     if (props[key] !== void 0)
-      url.searchParams.set(key, String(key));
+      url.searchParams.set(key, String(props[key]));
   }
   const response = await fetch(url);
   if (response.ok) {

package/dist/v2/components/MapProvider/MapProvider.d.ts

@@ -5,7 +5,7 @@ import { type GmapLoaderProps, type UseMapLoaderProps } from "../../hooks/useMap
 import { type MapSupplierPayolad } from "../../hooks/useMapSupplier";
 import type { AmapMap } from "../../types/interface";
 import { type AmapProps } from "../Amap";
-export type MapProviderProps = UseMapLoaderProps & Pick<MapSupplierPayolad, "gmapId" | "gmapRasterId" | "googleDirectionsProxyUrl" | "googleSnapRoadProxyUrl" | "renderLoadFailedTitle" | "renderLoadFailedDescription">;
+export type MapProviderProps = UseMapLoaderProps & Pick<MapSupplierPayolad, "gmapId" | "gmapRasterId" | "gaodeDirectionDrivingProxyUrl" | "gaodeDirectionWalkingProxyUrl" | "googleDirectionsProxyUrl" | "googleSnapRoadProxyUrl" | "renderLoadFailedTitle" | "renderLoadFailedDescription">;
 export declare const MapProvider: import("vue-demi").DefineComponent<import("vue3").ComponentObjectPropsOptions<MapProviderProps>, import("../../types/helper").Empty, import("../../types/helper").Empty, import("../../types/helper").Empty, import("../../types/helper").Empty, import("../../types/helper").Empty, import("../../types/helper").Empty, import("../../types/helper").EmitByProps<MapProviderProps, Required<MapProviderProps>>, "success" | "fail" | "downloadOptimizeEnd", MapProviderProps>;
 export interface HeycarMapProps extends Pick<GmapLoaderProps, "fallback" | "loading">, Pick<AmapProps, "center" | "zoom"> {
     mapRef?: SetMap<AmapMap> | SetMap<google.maps.Map>;

package/dist/v2/components/MapProvider/MapProvider.js

@@ -50,7 +50,7 @@ const MapProvider = defineLagecySetup("MapProvider", function(props, {
     var _a;
     return h("div", [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
   };
-}).props(["amapKey", "amapSecret", "amapServiceHost", "gmapId", "gmapRasterId", "gmapKey", "supplier", "language", "googleDirectionsProxyUrl", "googleSnapRoadProxyUrl", "renderLoadFailedTitle", "renderLoadFailedDescription"]);
+}).props(["amapKey", "amapSecret", "amapServiceHost", "gmapId", "gmapRasterId", "gmapKey", "supplier", "language", "gaodeDirectionDrivingProxyUrl", "gaodeDirectionWalkingProxyUrl", "googleDirectionsProxyUrl", "googleSnapRoadProxyUrl", "renderLoadFailedTitle", "renderLoadFailedDescription"]);
 const HeycarMap = defineLagecySetup("HeycarMap", function(props, {
   slots,
   emit,

package/dist/v2/hooks/useDrivingRoute.js

@@ -1,7 +1,7 @@
 import { reactive } from "vue-demi";
 import { watchPostEffectForDeepOption } from "../utils/compare.js";
-import { googleServiceApiDrivingRoute, amapJsApiDrivingRoute, gmapJsApiDrivingRoute } from "../utils/compatibleDrivingRoute.js";
-import { inTaiwan } from "./useMapInChina.js";
+import { googleServiceApiDrivingRoute, amapJsApiDrivingRoute, gaodeServiceApiDrivingRoute, gmapJsApiDrivingRoute } from "../utils/compatibleDrivingRoute.js";
+import { inTaiwan, inKorean } from "./useMapInChina.js";
 import { useMapSupplier } from "./useMapSupplier.js";
 const useADrivingRoute = (props) => {
   const { googleDirectionsProxyUrl } = useMapSupplier();
@@ -30,10 +30,11 @@ const useADrivingRoute = (props) => {
   return { route: outputRoute, apiMapDrivingRoute };
 };
 const useGDrivingRoute = (props) => {
+  const { gaodeDirectionDrivingProxyUrl } = useMapSupplier();
   const outputRoute = reactive({ path: [], distance: 0, duration: 0, steps: [] });
   const gmapDirectionsService = new google.maps.DirectionsService();
   const apiMapDrivingRoute = (from, to) => {
-    return gmapJsApiDrivingRoute(from, to, gmapDirectionsService);
+    return gaodeDirectionDrivingProxyUrl && inKorean(from) ? gaodeServiceApiDrivingRoute(from, to, gaodeDirectionDrivingProxyUrl) : gmapJsApiDrivingRoute(from, to, gmapDirectionsService);
   };
   watchPostEffectForDeepOption(
     () => {

package/dist/v2/hooks/useMapCoordinatify.js

@@ -13,7 +13,7 @@ function useMapCoordinatify() {
       return [lng, lat];
     if (type === "wgs84") {
       if (!inChina([lng, lat]))
-        throw new Error(`国外（或台湾）经纬度收到火星坐标系数据: ${JSON.stringify(value)}`);
+        console.error(`国外（或台湾）经纬度收到火星坐标系数据: ${JSON.stringify(value)}`);
       return toLocalWgs84([lng, lat]);
     }
     return toLocalGcj02([lng, lat]);

package/dist/v2/hooks/useMapGCJ02.js

@@ -19,7 +19,17 @@ const useAmapGCJ02 = () => {
   };
   const toLocalGcj02Points = (points) => points.map(toLocalGcj02);
   const toLocalWgs84 = (point) => {
-    throw new Error(`高德地图为什么要转 wgs84: ${JSON.stringify(point)}`);
+    console.error(`高德地图为什么要转 wgs84: ${JSON.stringify(point)}`);
+    try {
+      if (inChina(point))
+        return point;
+      return exported.transform(point, exported.GCJ02, exported.WGS1984);
+    } catch (err) {
+      const error = err;
+      console.error(`本地转换WGS84失败: ${error.message} 
+ ${error.stack}`);
+      return point;
+    }
   };
   const toGcj02Points = async (points) => {
     return toLocalGcj02Points(points);

package/dist/v2/hooks/useMapGraspRoad.js

@@ -1,9 +1,9 @@
 import { ref } from "vue-demi";
 import { watchEffectForDeepOption } from "../utils/compare.js";
-import { googleServiceApiGraspRoad, amapJsApiGraspRoad } from "../utils/compatibleGraspRoad.js";
+import { googleServiceApiGraspRoad, amapJsApiGraspRoad, bypassGraspRoad } from "../utils/compatibleGraspRoad.js";
 import { lnglat2point } from "../utils/transform.js";
 import { useMapAngle } from "./useMapAngle.js";
-import { inTaiwan } from "./useMapInChina.js";
+import { inTaiwan, inKorean } from "./useMapInChina.js";
 import { useMapSupplier } from "./useMapSupplier.js";
 const useAmapGraspRoad = (props) => {
   const pathRef = ref([]);
@@ -32,7 +32,7 @@ const useGmapGraspRoad = (props) => {
   const { googleSnapRoadProxyUrl } = useMapSupplier();
   const { apiMapComputeHeading } = useMapAngle();
   const apiMapToGraspRoadPath = (tracks) => {
-    return googleServiceApiGraspRoad(tracks, apiMapComputeHeading, googleSnapRoadProxyUrl);
+    return inKorean(lnglat2point(tracks[tracks.length - 1])) ? bypassGraspRoad(tracks, apiMapComputeHeading) : googleServiceApiGraspRoad(tracks, apiMapComputeHeading, googleSnapRoadProxyUrl);
   };
   watchEffectForDeepOption(
     () => props ? [...props.tracks] : void 0,

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

@@ -3,3 +3,4 @@ export declare const inChina: (point: Point) => boolean;
 export declare const inHongkong: (point: Point) => boolean;
 export declare const inMacau: (point: Point) => boolean;
 export declare const inTaiwan: (point: Point) => boolean;
+export declare const inKorean: (point: Point) => boolean;