@heycar/heycars-map 2.5.3 → 2.6.0

package/dist/v2/hooks/useMapGraspRoad.js

@@ -1,45 +1,18 @@
 import { ref } from "vue-demi";
-import { apiGoogleSnapRoad } from "../api/googleSnapRoad.js";
 import { watchEffectForDeepOption } from "../utils/compare.js";
-import { lnglat2point, trackPoints2amapGraspRoadPoints } from "../utils/transform.js";
+import { googleServiceApiGraspRoad, amapJsApiGraspRoad } from "../utils/compatibleGraspRoad.js";
+import { lnglat2point } from "../utils/transform.js";
 import { useMapAngle } from "./useMapAngle.js";
-import { inChina } from "./useMapInChina.js";
+import { inTaiwan } from "./useMapInChina.js";
 import { useMapSupplier } from "./useMapSupplier.js";
-const GRASP_ROAD_INPUT_MIN_AMOUNT = 2;
-const GRASP_ROAD_INPUT_MAX_AMOUNT = 500;
 const useAmapGraspRoad = (props) => {
-  const amapGraspRoad = new AMap.GraspRoad();
   const pathRef = ref([]);
   const angleRef = ref(0);
+  const { googleSnapRoadProxyUrl } = useMapSupplier();
   const { apiMapComputeHeading } = useMapAngle();
+  const amapGraspRoad = new AMap.GraspRoad();
   const apiMapToGraspRoadPath = (tracks) => {
-    return new Promise((resolve) => {
-      var _a, _b, _c;
-      if (tracks.length < GRASP_ROAD_INPUT_MIN_AMOUNT) {
-        const path = tracks.map(lnglat2point);
-        const angle = (_b = (_a = tracks[tracks.length - 1]) == null ? void 0 : _a.angle) != null ? _b : 0;
-        return resolve({ path, angle });
-      }
-      if (!inChina(lnglat2point(tracks[tracks.length - 1]))) {
-        const path = tracks.map(lnglat2point);
-        const angle = (_c = apiMapComputeHeading(path[path.length - 2], path[path.length - 1])) != null ? _c : 0;
-        return resolve({ path, angle });
-      }
-      const amount = Math.min(GRASP_ROAD_INPUT_MAX_AMOUNT, tracks.length);
-      const graspRoadPoints = trackPoints2amapGraspRoadPoints(tracks.slice(-amount));
-      amapGraspRoad.driving(graspRoadPoints, (error, result) => {
-        var _a2, _b2;
-        if (error) {
-          console.error("高德地图路线纠偏失败！原因如下：\n", error);
-          const path2 = tracks.map(lnglat2point);
-          const angle2 = (_a2 = apiMapComputeHeading(path2[0], path2[1])) != null ? _a2 : 0;
-          return resolve({ path: path2, angle: angle2 });
-        }
-        const path = result.data.points.map(({ x, y }) => [x, y]);
-        const angle = (_b2 = apiMapComputeHeading(path[path.length - 2], path[path.length - 1])) != null ? _b2 : 0;
-        resolve({ path, angle });
-      });
-    });
+    return googleSnapRoadProxyUrl && inTaiwan(lnglat2point(tracks[tracks.length - 1])) ? googleServiceApiGraspRoad(tracks, apiMapComputeHeading, googleSnapRoadProxyUrl) : amapJsApiGraspRoad(tracks, amapGraspRoad, apiMapComputeHeading);
   };
   watchEffectForDeepOption(
     () => props ? [...props.tracks] : void 0,
@@ -56,34 +29,10 @@ const useAmapGraspRoad = (props) => {
 const useGmapGraspRoad = (props) => {
   const pathRef = ref([]);
   const angleRef = ref(0);
+  const { googleSnapRoadProxyUrl } = useMapSupplier();
   const { apiMapComputeHeading } = useMapAngle();
-  const apiMapToGraspRoadPath = async (tracks) => {
-    var _a, _b, _c, _d;
-    let result;
-    if (tracks.length < GRASP_ROAD_INPUT_MIN_AMOUNT) {
-      const path2 = tracks.map(lnglat2point);
-      const angle2 = (_b = (_a = tracks[tracks.length - 1]) == null ? void 0 : _a.angle) != null ? _b : 0;
-      return { path: path2, angle: angle2 };
-    }
-    const amount = Math.min(GRASP_ROAD_INPUT_MAX_AMOUNT, tracks.length);
-    const snapRoadPath = tracks.slice(-amount).map(lnglat2point);
-    try {
-      result = await apiGoogleSnapRoad({ path: snapRoadPath });
-    } catch (error) {
-      console.error("谷歌地图路线纠偏失败！原因如下：\n", error);
-      const path2 = tracks.map(lnglat2point);
-      const angle2 = (_c = apiMapComputeHeading(path2[0], path2[1])) != null ? _c : 0;
-      return { path: path2, angle: angle2 };
-    }
-    const { snappedPoints, warningMessage } = result;
-    if (warningMessage)
-      console.warn("apiGoogleSnapRoad warning: ", warningMessage);
-    const path = snappedPoints.map((item) => [
-      item.location.longitude,
-      item.location.latitude
-    ]);
-    const angle = (_d = apiMapComputeHeading(path[path.length - 2], path[path.length - 1])) != null ? _d : 0;
-    return { path, angle };
+  const apiMapToGraspRoadPath = (tracks) => {
+    return googleServiceApiGraspRoad(tracks, apiMapComputeHeading, googleSnapRoadProxyUrl);
   };
   watchEffectForDeepOption(
     () => props ? [...props.tracks] : void 0,

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

@@ -2,3 +2,4 @@ import { type Point } from "../types/interface";
 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;

package/dist/v2/hooks/useMapInChina.js

@@ -2593,8 +2593,30 @@ const macauBounds = [
     22.19885
   ]
 ];
+const taiwanBounds = [
+  [
+    119.252093,
+    23.561995
+  ],
+  [
+    121.031616,
+    25.517889
+  ],
+  [
+    122.394777,
+    25.20866
+  ],
+  [
+    121.835824,
+    21.645481
+  ],
+  [
+    120.358592,
+    21.58185
+  ]
+];
 const inChina = (point) => {
-  return pointInPolygon(point, chinaBounds) >= 0;
+  return pointInPolygon(point, chinaBounds) >= 0 && !inTaiwan(point);
 };
 const inHongkong = (point) => {
   return pointInPolygon(point, hongkongBounds) >= 0;
@@ -2602,8 +2624,12 @@ const inHongkong = (point) => {
 const inMacau = (point) => {
   return pointInPolygon(point, macauBounds) >= 0;
 };
+const inTaiwan = (point) => {
+  return pointInPolygon(point, taiwanBounds) >= 0;
+};
 export {
   inChina,
   inHongkong,
-  inMacau
+  inMacau,
+  inTaiwan
 };

package/dist/v2/hooks/useMapPlace.js

@@ -3,7 +3,7 @@ import { REGEO_TIMEOUT } from "../api/contants.js";
 import { createPipeTw } from "../utils/cn2tw.js";
 import { equalAssign, AbortSignalAny } from "../utils/helper.js";
 import { amapPlaceName2DisplayName, signal2promise, gmapPlaceName2DisplayName } from "../utils/transform.js";
-import { inChina } from "./useMapInChina.js";
+import { inChina, inTaiwan } from "./useMapInChina.js";
 import { useMapSupplier } from "./useMapSupplier.js";
 import { useUpdate } from "./useUdate.js";
 const useAmapPlace = (props) => {
@@ -39,7 +39,7 @@ const useAmapPlace = (props) => {
       readyPromise.then(() => {
         const geocoder = new AMap.Geocoder({ lang: language === "en" ? "en" : "zh_cn" });
         const pipeTw = createPipeTw(language === "zh-TW");
-        const isChina = inChina([lng, lat]);
+        const isChinese = inChina([lng, lat]) || inTaiwan([lng, lat]);
         geocoder.getAddress(new AMap.LngLat(lng, lat), (status, result) => {
           clearTimeout(timer);
           switch (status) {
@@ -47,7 +47,7 @@ const useAmapPlace = (props) => {
               const { formattedAddress, addressComponent } = result.regeocode;
               const name = formattedAddress ? formattedAddress : emptyPlaceName;
               const displayName = amapPlaceName2DisplayName(name, {
-                isChina,
+                isChinese,
                 ...addressComponent
               });
               resolve({ lng, lat, name: pipeTw(name), displayName: pipeTw(displayName) });

package/dist/v2/hooks/useMapRecomendPlace.js

@@ -258,7 +258,8 @@ const useMapRecomendPlace = (props) => {
       inputPlace: { ...place },
       type,
       zone,
-      isSameZone
+      isSameZone,
+      noAnimation: true
     });
   };
   const setPlaceCandidatesAndZone = ({

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

@@ -7,6 +7,8 @@ export interface MapSupplierPayolad extends UseMapLoaderProps {
     readyPromise: UseMapLoaderOutput["readyPromise"];
     status: Status;
     pingStatus: ConnectionStatus;
+    googleDirectionsProxyUrl?: string;
+    googleSnapRoadProxyUrl?: string;
     renderLoadFailedTitle?: (status: Status) => string | undefined;
     renderLoadFailedDescription?: (status: Status) => string | undefined;
 }

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

@@ -1,5 +1,6 @@
 import { type ShallowRef } from "vue-demi";
 export interface UseResizeObserverProps {
+    shouldSkip?: () => boolean;
     elementRef: ShallowRef<HTMLDivElement | undefined>;
     onChange?: (props: {
         width: number;

package/dist/v2/hooks/useResizeObserver.js

@@ -1,8 +1,10 @@
 import { watchPostEffect } from "vue-demi";
 const useResizeObserver = (props) => {
-  const { elementRef, onChange } = props;
+  const { elementRef, shouldSkip, onChange } = props;
   const resizeObserver = new ResizeObserver(([entry]) => {
     var _a, _b;
+    if (shouldSkip == null ? void 0 : shouldSkip())
+      return;
     const { contentBoxSize, contentRect } = entry;
     const width = (_a = contentBoxSize == null ? void 0 : contentBoxSize[0].inlineSize) != null ? _a : contentRect.width;
     const height = (_b = contentBoxSize == null ? void 0 : contentBoxSize[0].blockSize) != null ? _b : contentRect.height;

package/dist/v2/hooks/useWalkingRoute.js

@@ -1,44 +1,24 @@
 import { shallowRef } from "vue-demi";
 import { watchPostEffectForDeepOption } from "../utils/compare.js";
+import { googleServiceApiWalkingRoute, amapJsApiWalkingRoute, gmapJsApiWalkingRoute } from "../utils/compatibleWalkingRoute.js";
+import { inTaiwan } from "./useMapInChina.js";
 import { useMapSupplier } from "./useMapSupplier.js";
-const isIgnoredAmapWalkingRouteError = (err) => err === "RETURN_TIMEOUT";
 const useAWalkingRoute = (props) => {
+  const { googleDirectionsProxyUrl } = useMapSupplier();
   const pathRef = shallowRef([]);
   const amapWalking = new AMap.Walking({});
+  const apiMapWalkingRoute = (from, to) => {
+    return googleDirectionsProxyUrl && inTaiwan(from) ? googleServiceApiWalkingRoute(from, to, googleDirectionsProxyUrl) : amapJsApiWalkingRoute(from, to, amapWalking);
+  };
   watchPostEffectForDeepOption(
     () => {
       const { from, to } = props;
       return { from, to };
     },
-    ({ from, to }) => {
-      amapWalking.search(AMap.LngLat.from(from), AMap.LngLat.from(to), (status, result) => {
-        switch (status) {
-          case "complete": {
-            let path = [];
-            const walkingResult = result;
-            if (!walkingResult.routes) {
-              return;
-            }
-            const firstRoute = walkingResult.routes[0];
-            for (const step of firstRoute.steps) {
-              const stepPath = step.path.map(({ lng, lat }) => [lng, lat]);
-              path = path.concat(stepPath);
-            }
-            pathRef.value = path;
-            return;
-          }
-          case "no_data":
-            pathRef.value = [];
-            return;
-          default:
-            if (isIgnoredAmapWalkingRouteError(result)) {
-              console.warn(result);
-              pathRef.value = [];
-              return;
-            }
-            throw result;
-        }
-      });
+    async ({ from, to }) => {
+      if (!from || !to)
+        return;
+      pathRef.value = await apiMapWalkingRoute(from, to);
     }
   );
   return pathRef;
@@ -46,37 +26,18 @@ const useAWalkingRoute = (props) => {
 const useGWalkingRoute = (props) => {
   const pathRef = shallowRef([]);
   const gmapDirectionsService = new google.maps.DirectionsService();
+  const apiMapWalkingRoute = (from, to) => {
+    return gmapJsApiWalkingRoute(from, to, gmapDirectionsService);
+  };
   watchPostEffectForDeepOption(
-    () => ({ ...props }),
-    ({ from, to }) => {
-      gmapDirectionsService.route(
-        {
-          origin: { lng: from[0], lat: from[1] },
-          destination: { lng: to[0], lat: to[1] },
-          travelMode: google.maps.TravelMode.WALKING
-        },
-        (result, status) => {
-          switch (status) {
-            case google.maps.DirectionsStatus.OK: {
-              let path = [];
-              const firstRoute = result.routes[0];
-              const stepPath = firstRoute.overview_path.map((item) => [
-                item.lng(),
-                item.lat()
-              ]);
-              path = path.concat(stepPath);
-              pathRef.value = path;
-              return;
-            }
-            case google.maps.DirectionsStatus.ZERO_RESULTS:
-            case google.maps.DirectionsStatus.NOT_FOUND:
-              pathRef.value = [];
-              return;
-            default:
-              throw new Error(status);
-          }
-        }
-      );
+    () => {
+      const { from, to } = props;
+      return { from, to };
+    },
+    async ({ from, to }) => {
+      if (!from || !to)
+        return;
+      pathRef.value = await apiMapWalkingRoute(from, to);
     }
   );
   return pathRef;

package/dist/v2/hooks-business/useBusinessRecomendPlaceMap.js

@@ -1,5 +1,5 @@
 import { reactive, ref, readonly } from "vue-demi";
-import { E as EMPTY_PLACE } from "../chunks/BusinessRecomendPlaceMap.824002ef.js";
+import { E as EMPTY_PLACE } from "../chunks/BusinessRecomendPlaceMap.7b67c30c.js";
 import { CenterPlaceStatus } from "../types/interface.js";
 import { proxyFunctionalProperty, assertAssingedBeforeUsed } from "../utils/helper.js";
 const useBusinessRecomendPlaceMap = () => {

package/dist/v2/index.js

@@ -3,7 +3,7 @@ import { isCoordinatePointEqual } from "./api/geometry.js";
 import { AbsoluteAddressBox } from "./business-components/AbsoluteAddressBox/AbsoluteAddressBox.js";
 import { AddressBox } from "./business-components/AddressBox/AddressBox.js";
 import { BusinessQuotingMap } from "./business-components/BusinessQuotingMap/BusinessQuotingMap.js";
-import { B } from "./chunks/BusinessRecomendPlaceMap.824002ef.js";
+import { B } from "./chunks/BusinessRecomendPlaceMap.7b67c30c.js";
 import { BusinessReselectPlaceMap } from "./business-components/BusinessReselectPlaceMap/BusinessReselectPlaceMap.js";
 import { BusinessTaxiEndMap } from "./business-components/BusinessTaxiEndMap/BusinessTaxiEndMap.js";
 import { BusinessTaxiServiceMap } from "./business-components/BusinessTaxiServiceMap/BusinessTaxiServiceMap.js";

package/dist/v2/types/interface.d.ts

@@ -48,6 +48,7 @@ export interface ValueOfOnChangeRecommendPlace {
     inputPlace: Place;
     zone?: Zone;
     isSameZone: boolean;
+    noAnimation?: boolean;
 }
 export interface CoordinateValueOfOnChangeRecommendPlace extends Omit<ValueOfOnChangeRecommendPlace, "place" | "inputPlace" | "zone"> {
     place: CoordinatePlace;
@@ -100,3 +101,7 @@ export type ConnectionStatus = "pending" | "connected" | "unconnected";
 export interface BusinessGeolocationPositionError extends GeolocationPositionError {
     isBusinessTimeout: boolean;
 }
+export type ProxyServiceError = {
+    code: number;
+    msg: string;
+};

package/dist/v2/utils/compatibleDrivingRoute.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="google.maps" />
+import type { Point, Route } from "../types/interface";
+export declare function amapJsApiDrivingRoute(from: Point, to: Point, amapDriving: AMap.Driving): Promise<Route>;
+export declare function gmapJsApiDrivingRoute(from: Point, to: Point, gmapDirectionsService: google.maps.DirectionsService): Promise<Route>;
+export declare function googleServiceApiDrivingRoute(from: Point, to: Point, proxyUrl: string): Promise<Route>;

package/dist/v2/utils/compatibleDrivingRoute.js

@@ -0,0 +1,130 @@
+import { apiGoogleDirections } from "../api/googleDirections.js";
+function amapJsApiDrivingRoute(from, to, amapDriving) {
+  return new Promise((resolve, reject) => {
+    amapDriving.search(
+      AMap.LngLat.from(from),
+      AMap.LngLat.from(to),
+      { waypoints: [] },
+      (status, result) => {
+        switch (status) {
+          case "complete": {
+            let path = [];
+            const drivingResult = result;
+            const routeSteps = [];
+            const firstRoute = drivingResult.routes[0];
+            if (!firstRoute)
+              return resolve({ path: [], distance: 0, duration: 0, steps: [] });
+            for (const step of firstRoute.steps) {
+              const basicStep = step;
+              const stepPath = basicStep.path.map(({ lng, lat }) => [lng, lat]);
+              path = path.concat(stepPath);
+              routeSteps.push({
+                path: basicStep.path.map(({ lng, lat }) => [lng, lat]),
+                duration: basicStep.time,
+                distance: basicStep.distance
+              });
+            }
+            return resolve({
+              path,
+              distance: firstRoute.distance,
+              duration: firstRoute.time,
+              tolls: firstRoute.tolls,
+              steps: routeSteps
+            });
+          }
+          case "no_data":
+            return resolve({ path: [], distance: 0, duration: 0, steps: [] });
+          default:
+            return reject(result);
+        }
+      }
+    );
+  });
+}
+function gmapJsApiDrivingRoute(from, to, gmapDirectionsService) {
+  return new Promise((resolve, reject) => {
+    gmapDirectionsService.route(
+      {
+        origin: { lng: from[0], lat: from[1] },
+        destination: { lng: to[0], lat: to[1] },
+        travelMode: google.maps.TravelMode.DRIVING
+      },
+      (result, status) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        switch (status) {
+          case "OK": {
+            let path = [];
+            let distance = 0;
+            let duration = 0;
+            const routeSteps = [];
+            const firstRoute = result.routes[0];
+            if (!firstRoute)
+              return resolve({ path: [], distance: 0, duration: 0, steps: [] });
+            for (const leg of firstRoute.legs) {
+              distance += (_b = (_a = leg.distance) == null ? void 0 : _a.value) != null ? _b : 0;
+              duration += (_d = (_c = leg.duration) == null ? void 0 : _c.value) != null ? _d : 0;
+              for (const step of leg.steps) {
+                const stepPath = step.path.map(({ lng, lat }) => [lng(), lat()]);
+                path = path.concat(stepPath);
+                routeSteps.push({
+                  path: stepPath,
+                  distance: (_f = (_e = step.distance) == null ? void 0 : _e.value) != null ? _f : 0,
+                  duration: (_h = (_g = step.duration) == null ? void 0 : _g.value) != null ? _h : 0
+                });
+              }
+            }
+            return resolve({ path, distance, duration, steps: routeSteps });
+          }
+          case "ZERO_RESULTS":
+          case "NOT_FOUND":
+            return resolve({ path: [], distance: 0, duration: 0, steps: [] });
+          default:
+            return reject(new Error(status));
+        }
+      }
+    );
+  });
+}
+async function googleServiceApiDrivingRoute(from, to, proxyUrl) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const { status, routes, error_message } = await apiGoogleDirections({
+    proxyUrl,
+    origin: from,
+    destination: to
+  });
+  switch (status) {
+    case "OK": {
+      let path = [];
+      let distance = 0;
+      let duration = 0;
+      const routeSteps = [];
+      const firstRoute = routes[0];
+      if (!firstRoute)
+        return { path: [], distance: 0, duration: 0, steps: [] };
+      for (const leg of firstRoute.legs) {
+        distance += (_b = (_a = leg.distance) == null ? void 0 : _a.value) != null ? _b : 0;
+        duration += (_d = (_c = leg.duration) == null ? void 0 : _c.value) != null ? _d : 0;
+        for (const step of leg.steps) {
+          const stepPath = step.path.map(({ lng, lat }) => [lng(), lat()]);
+          path = path.concat(stepPath);
+          routeSteps.push({
+            path: stepPath,
+            distance: (_f = (_e = step.distance) == null ? void 0 : _e.value) != null ? _f : 0,
+            duration: (_h = (_g = step.duration) == null ? void 0 : _g.value) != null ? _h : 0
+          });
+        }
+      }
+      return { path, distance, duration, steps: routeSteps };
+    }
+    case "ZERO_RESULTS":
+    case "NOT_FOUND":
+      return { path: [], distance: 0, duration: 0, steps: [] };
+    default:
+      throw Error(error_message != null ? error_message : status);
+  }
+}
+export {
+  amapJsApiDrivingRoute,
+  gmapJsApiDrivingRoute,
+  googleServiceApiDrivingRoute
+};

package/dist/v2/utils/compatibleGoogleTypes.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="google.maps" />
+export declare class GoogleLatLng implements google.maps.LatLng {
+    private json;
+    constructor(value: google.maps.LatLngLiteral);
+    lng(): number;
+    lat(): number;
+    equals(other: google.maps.LatLng | null): boolean;
+    toJSON(): google.maps.LatLngLiteral;
+    toString(): string;
+    toUrlValue(precision?: number | undefined): string;
+}

package/dist/v2/utils/compatibleGoogleTypes.js

@@ -0,0 +1,38 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class GoogleLatLng {
+  constructor(value) {
+    __publicField(this, "json");
+    this.json = value;
+    this.lng = this.lng.bind(this);
+    this.lat = this.lat.bind(this);
+  }
+  lng() {
+    return this.json.lng;
+  }
+  lat() {
+    return this.json.lat;
+  }
+  equals(other) {
+    const { lng, lat } = this.json;
+    return lng === (other == null ? void 0 : other.lng()) && lat === other.lat();
+  }
+  toJSON() {
+    return { ...this.json };
+  }
+  toString() {
+    const { lng, lat } = this.json;
+    return `(${lat}, ${lng})`;
+  }
+  toUrlValue(precision = 7) {
+    const { lng, lat } = this.json;
+    return `${lat.toPrecision(precision)},${lng.toPrecision(precision)}`;
+  }
+}
+export {
+  GoogleLatLng
+};

package/dist/v2/utils/compatibleGraspRoad.d.ts

@@ -0,0 +1,8 @@
+import type { ApiMapComputeHeading } from "../hooks/useMapAngle";
+import type { Point, TrackPoint } from "../types/interface";
+export interface ApiGraspRoadOutput {
+    path: Point[];
+    angle: number;
+}
+export declare function amapJsApiGraspRoad(tracks: TrackPoint[], amapGraspRoad: AMap.GraspRoad, apiMapComputeHeading: ApiMapComputeHeading): Promise<ApiGraspRoadOutput>;
+export declare function googleServiceApiGraspRoad(tracks: TrackPoint[], apiMapComputeHeading: ApiMapComputeHeading, proxyUrl?: string): Promise<ApiGraspRoadOutput>;

package/dist/v2/utils/compatibleGraspRoad.js

@@ -0,0 +1,67 @@
+import { apiGoogleSnapRoad } from "../api/googleSnapRoad.js";
+import { inChina } from "../hooks/useMapInChina.js";
+import { lnglat2point, trackPoints2amapGraspRoadPoints } from "./transform.js";
+const GRASP_ROAD_INPUT_MIN_AMOUNT = 2;
+const GRASP_ROAD_INPUT_MAX_AMOUNT = 500;
+function amapJsApiGraspRoad(tracks, amapGraspRoad, apiMapComputeHeading) {
+  return new Promise((resolve) => {
+    var _a, _b, _c;
+    if (tracks.length < GRASP_ROAD_INPUT_MIN_AMOUNT) {
+      const path = tracks.map(lnglat2point);
+      const angle = (_b = (_a = tracks[tracks.length - 1]) == null ? void 0 : _a.angle) != null ? _b : 0;
+      return resolve({ path, angle });
+    }
+    const lastPoint = lnglat2point(tracks[tracks.length - 1]);
+    if (!inChina(lastPoint)) {
+      const path = tracks.map(lnglat2point);
+      const angle = (_c = apiMapComputeHeading(path[path.length - 2], path[path.length - 1])) != null ? _c : 0;
+      return resolve({ path, angle });
+    }
+    const amount = Math.min(GRASP_ROAD_INPUT_MAX_AMOUNT, tracks.length);
+    const graspRoadPoints = trackPoints2amapGraspRoadPoints(tracks.slice(-amount));
+    amapGraspRoad.driving(graspRoadPoints, (error, result) => {
+      var _a2, _b2;
+      if (error) {
+        console.error("高德地图路线纠偏失败！原因如下：\n", error);
+        const path2 = tracks.map(lnglat2point);
+        const angle2 = (_a2 = apiMapComputeHeading(path2[0], path2[1])) != null ? _a2 : 0;
+        return resolve({ path: path2, angle: angle2 });
+      }
+      const path = result.data.points.map(({ x, y }) => [x, y]);
+      const angle = (_b2 = apiMapComputeHeading(path[path.length - 2], path[path.length - 1])) != null ? _b2 : 0;
+      resolve({ path, angle });
+    });
+  });
+}
+async function googleServiceApiGraspRoad(tracks, apiMapComputeHeading, proxyUrl) {
+  var _a, _b, _c, _d;
+  let result;
+  if (tracks.length < GRASP_ROAD_INPUT_MIN_AMOUNT) {
+    const path2 = tracks.map(lnglat2point);
+    const angle2 = (_b = (_a = tracks[tracks.length - 1]) == null ? void 0 : _a.angle) != null ? _b : 0;
+    return { path: path2, angle: angle2 };
+  }
+  const amount = Math.min(GRASP_ROAD_INPUT_MAX_AMOUNT, tracks.length);
+  const snapRoadPath = tracks.slice(-amount).map(lnglat2point);
+  try {
+    result = await apiGoogleSnapRoad({ path: snapRoadPath, proxyUrl });
+  } catch (error) {
+    console.error("谷歌地图路线纠偏失败！原因如下：\n", error);
+    const path2 = tracks.map(lnglat2point);
+    const angle2 = (_c = apiMapComputeHeading(path2[0], path2[1])) != null ? _c : 0;
+    return { path: path2, angle: angle2 };
+  }
+  const { snappedPoints, warningMessage } = result;
+  if (warningMessage)
+    console.warn("apiGoogleSnapRoad warning: ", warningMessage);
+  const path = snappedPoints.map((item) => [
+    item.location.longitude,
+    item.location.latitude
+  ]);
+  const angle = (_d = apiMapComputeHeading(path[path.length - 2], path[path.length - 1])) != null ? _d : 0;
+  return { path, angle };
+}
+export {
+  amapJsApiGraspRoad,
+  googleServiceApiGraspRoad
+};

package/dist/v2/utils/compatibleWalkingRoute.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="google.maps" />
+import type { Point } from "../types/interface";
+export declare function amapJsApiWalkingRoute(from: Point, to: Point, amapWalking: AMap.Walking): Promise<Point[]>;
+export declare function gmapJsApiWalkingRoute(from: Point, to: Point, gmapDirectionsService: google.maps.DirectionsService): Promise<Point[]>;
+export declare function googleServiceApiWalkingRoute(from: Point, to: Point, proxyUrl: string): Promise<Point[]>;