@heycar/heycars-map 2.5.3 → 2.6.1

package/dist/v3/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/v3/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/v3/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/v3/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/v3/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/v3/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[]>;

package/dist/v3/utils/compatibleWalkingRoute.js

@@ -0,0 +1,81 @@
+import { apiGoogleDirections } from "../api/googleDirections.js";
+const isIgnoredAmapTimeoutError = (err) => err === "RETURN_TIMEOUT";
+function amapJsApiWalkingRoute(from, to, amapWalking) {
+  return new Promise((resolve, reject) => {
+    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 resolve([]);
+          }
+          const firstRoute = walkingResult.routes[0];
+          for (const step of firstRoute.steps) {
+            const stepPath = step.path.map(({ lng, lat }) => [lng, lat]);
+            path = path.concat(stepPath);
+          }
+          return resolve(path);
+        }
+        case "no_data":
+          return resolve([]);
+        default:
+          if (isIgnoredAmapTimeoutError(result)) {
+            console.warn(result);
+            return resolve([]);
+          }
+          return reject(result);
+      }
+    });
+  });
+}
+function gmapJsApiWalkingRoute(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.WALKING
+      },
+      (result, status) => {
+        switch (status) {
+          case "OK": {
+            const { overview_path } = result.routes[0];
+            const path = overview_path.map(({ lng, lat }) => [lng(), lat()]);
+            return resolve(path);
+          }
+          case "ZERO_RESULTS":
+          case "NOT_FOUND":
+            return resolve([]);
+          default:
+            return reject(new Error(status));
+        }
+      }
+    );
+  });
+}
+async function googleServiceApiWalkingRoute(from, to, proxyUrl) {
+  const { status, routes, error_message } = await apiGoogleDirections({
+    proxyUrl,
+    mode: "WALKING",
+    origin: from,
+    destination: to
+  });
+  switch (status) {
+    case "OK": {
+      const { overview_path } = routes[0];
+      const path = overview_path.map(({ lng, lat }) => [lng(), lat()]);
+      return path;
+    }
+    case "ZERO_RESULTS":
+    case "NOT_FOUND":
+      return [];
+    default:
+      throw Error(error_message != null ? error_message : status);
+  }
+}
+export {
+  amapJsApiWalkingRoute,
+  gmapJsApiWalkingRoute,
+  googleServiceApiWalkingRoute
+};

package/dist/v3/utils/log.js

@@ -1,6 +1,6 @@
 const availableLogKeys = /* @__PURE__ */ new Set();
 const pkgName = "@heycar/heycars-map";
-const pkgVersion = "2.5.2";
+const pkgVersion = "2.6.1";
 const isEnableLog = (name) => {
   const searchParam = new URLSearchParams(location.search);
   return searchParam.has(`log-${name}`);

package/dist/v3/utils/transform.d.ts

@@ -8,6 +8,7 @@ export declare const lnglat2point: ({ lng, lat }: {
     lng: number;
     lat: number;
 }) => Point;
+export declare const googlePointsStringify: (points: Point[]) => string;
 export interface AsteriskItem {
     type: "normal" | "emphasize";
     value: string;
@@ -27,7 +28,7 @@ export declare const isPointEqual: (p1: Point, p2?: Point) => boolean;
 export declare const isGeoPositionEqual: (p1: GeolocationPosition, p2?: GeolocationPosition) => boolean;
 export declare const isZoneEqual: (z1: Zone, z2?: Zone) => boolean;
 interface AmapPlaceName2DisplayNameOptions extends AMap.AddressComponent {
-    isChina: boolean;
+    isChinese: boolean;
 }
 export declare const amapPlaceName2DisplayName: (name: string, options: AmapPlaceName2DisplayNameOptions) => string;
 export declare function gmapPlaceName2DisplayName(name: string, addressComponents: google.maps.GeocoderAddressComponent[]): string;
@@ -42,4 +43,5 @@ export declare const businessCandidatesToAdsorptionPlace: (places: Place[]) => P
 type MaybeFunctionToFunction<T> = T extends (...args: any) => any ? T : () => T;
 export declare const maybeFunctionToFunction: <T>(value: T) => MaybeFunctionToFunction<T>;
 export declare const signal2promise: (signal?: AbortSignal) => Promise<any>;
+export declare const googleEncodedPolyline2googleLatLng: (value: string) => google.maps.LatLng[];
 export {};

package/dist/v3/utils/transform.js

@@ -1,10 +1,46 @@
 import { MIN_ANIMATION_DURATION, ANIMATION_DURATION_FOR_100VW, ANIMATION_DURATION_PER_ZOOM } from "../api/contants.js";
+import { GoogleLatLng } from "./compatibleGoogleTypes.js";
 import { BRWOSER_PLATFORM } from "./platform.js";
+var decode = function(encodedPath, precision) {
+  if (precision === void 0) {
+    precision = 5;
+  }
+  var factor = Math.pow(10, precision);
+  var len = encodedPath.length;
+  var path = new Array(Math.floor(encodedPath.length / 2));
+  var index = 0;
+  var lat = 0;
+  var lng = 0;
+  var pointIndex = 0;
+  for (; index < len; ++pointIndex) {
+    var result = 1;
+    var shift = 0;
+    var b = void 0;
+    do {
+      b = encodedPath.charCodeAt(index++) - 63 - 1;
+      result += b << shift;
+      shift += 5;
+    } while (b >= 31);
+    lat += result & 1 ? ~(result >> 1) : result >> 1;
+    result = 1;
+    shift = 0;
+    do {
+      b = encodedPath.charCodeAt(index++) - 63 - 1;
+      result += b << shift;
+      shift += 5;
+    } while (b >= 31);
+    lng += result & 1 ? ~(result >> 1) : result >> 1;
+    path[pointIndex] = [lat / factor, lng / factor];
+  }
+  path.length = pointIndex;
+  return path;
+};
 const vec2lnglat = ([lng, lat]) => ({
   lng: Number(lng),
   lat: Number(lat)
 });
 const lnglat2point = ({ lng, lat }) => [lng, lat];
+const googlePointsStringify = (points) => points.map(([lng, lat]) => `${lat},${lng}`).join("|");
 const decodeAsterisk = (encodedValue) => {
   const result = [];
   const tokens = encodedValue.split("*");
@@ -77,12 +113,12 @@ const isZoneEqual = (z1, z2) => {
   return z1.name === (z2 == null ? void 0 : z2.name) && z1.path.every((point, idx) => isPointEqual(point, z2 == null ? void 0 : z2.path[idx]));
 };
 const amapPlaceName2DisplayName = (name, options) => {
-  const { isChina } = options;
+  const { isChinese } = options;
   if (!name)
     return name;
-  return isChina ? amapPlaceName2DisplayNameInChina(name, options) : amapPlaceName2DisplayNameOutChina(name, options);
+  return isChinese ? amapPlaceName2DisplayNameInChinese(name, options) : amapPlaceName2DisplayNameOutChinese(name, options);
 };
-function amapPlaceName2DisplayNameInChina(name, options) {
+function amapPlaceName2DisplayNameInChinese(name, options) {
   const { province, city, district, township, building, neighborhood } = options;
   if (building)
     return building;
@@ -101,7 +137,7 @@ function amapPlaceName2DisplayNameInChina(name, options) {
   return replacedName.trim() ? replacedName : result;
 }
 const NOT_ONLY_NUMBERS_REGEX = /[^\d\s-]/;
-function amapPlaceName2DisplayNameOutChina(name, options) {
+function amapPlaceName2DisplayNameOutChinese(name, options) {
   const { adcode, province, city, district, township, street, streetNumber } = options;
   if (street === "Unnamed Road")
     return name;
@@ -183,7 +219,7 @@ const distanceVw2animationDuration = (distance) => {
   return Math.max(MIN_ANIMATION_DURATION, ANIMATION_DURATION_FOR_100VW * distance / 100);
 };
 const deltaZoom2animationDuration = (deltaZoom) => {
-  return Math.max(MIN_ANIMATION_DURATION * 4, Math.abs(deltaZoom) * ANIMATION_DURATION_PER_ZOOM);
+  return Math.max(MIN_ANIMATION_DURATION * 2, Math.abs(deltaZoom) * ANIMATION_DURATION_PER_ZOOM);
 };
 const wxGetLocationSuccessResponse2GeolocationPosition = (res) => {
   const { longitude, latitude, accuracy } = res;
@@ -248,6 +284,9 @@ const signal2promise = (signal) => {
     signal == null ? void 0 : signal.addEventListener("abort", () => reject(signal.reason));
   });
 };
+const googleEncodedPolyline2googleLatLng = (value) => {
+  return decode(value).map(([lat, lng]) => new GoogleLatLng({ lng, lat }));
+};
 export {
   alipayMyGetLocationError2GeolocationPositionErrorCode,
   alipayMyGetLocationSuccessResponse2GeolocationPosition,
@@ -259,6 +298,8 @@ export {
   distanceVw2animationDuration,
   geoPositionError2businessTimeout,
   gmapPlaceName2DisplayName,
+  googleEncodedPolyline2googleLatLng,
+  googlePointsStringify,
   isGeoPositionEqual,
   isPlaceEqual,
   isPointEqual,

package/dist/v3/utils/typeChecking.d.ts

@@ -1,4 +1,5 @@
-import type { CoordinatePlace, CoordinatePoint, CoordinateRecommendZonePlaces, CoordinateTrackPoint, CoordinateType, CoordinateZone, RecommendType } from "../types/interface";
+import type { CoordinatePlace, CoordinatePoint, CoordinateRecommendZonePlaces, CoordinateTrackPoint, CoordinateType, CoordinateZone, ProxyServiceError, RecommendType } from "../types/interface";
+export declare const createTypeError: (typeName: string, value: unknown, detail?: string) => Error;
 export declare function isCoordinateType(type: unknown): type is CoordinateType;
 export declare function isRecommendType(type: unknown): type is RecommendType;
 export declare function toRecommendType(type: unknown): RecommendType;
@@ -40,4 +41,5 @@ interface MaybeCoordinateTrackPoint {
     timestamp?: number | string;
 }
 export declare const toCoordinateTrackPoint: (value?: MaybeCoordinateTrackPoint) => CoordinateTrackPoint;
+export declare function isProxyServiceError(error: unknown): error is ProxyServiceError;
 export {};

package/dist/v3/utils/typeChecking.js

@@ -105,10 +105,15 @@ const toCoordinateTrackPoint = (value) => {
   }
   return { lng, lat, type, angle, speed, timestamp };
 };
+function isProxyServiceError(error) {
+  return !!error && typeof error === "object" && "msg" in error && "code" in error;
+}
 export {
   assertNoConflictTypeAndZone,
+  createTypeError,
   isCoordinatePoint,
   isCoordinateType,
+  isProxyServiceError,
   isRecommendType,
   toCoordinatePlaceType,
   toCoordinatePointType,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heycar/heycars-map",
-  "version": "2.5.3",
+  "version": "2.6.1",
   "type": "module",
   "bin": {
     "checkVersion": "./bin/checkVersion.js",
@@ -37,6 +37,7 @@
   "dependencies": {
     "@amap/amap-jsapi-types": "^0.0.13",
     "@googlemaps/js-api-loader": "1.16.6",
+    "@googlemaps/polyline-codec": "^1.0.28",
     "@googlemaps/typescript-guards": "^2.0.3",
     "@heycar/amap-jsapi-loader": "npm:@heycar/amap-jsapi-loader@1.0.1-fetchPriority",
     "@types/google.maps": "^3.54.10",