@heycar/heycars-map 2.6.1 → 2.7.1

package/dist/v2/hooks/useMapInChina.js

@@ -2399,6 +2399,168 @@ const hongkongBounds = [
     22.504768
   ]
 ];
+const koreanBounds = [
+  [
+    125.637366,
+    37.690714
+  ],
+  [
+    125.694873,
+    37.699096
+  ],
+  [
+    126.005108,
+    37.687121
+  ],
+  [
+    126.076236,
+    37.713464
+  ],
+  [
+    126.174603,
+    37.717055
+  ],
+  [
+    126.20033,
+    37.742191
+  ],
+  [
+    126.185196,
+    37.802002
+  ],
+  [
+    126.21849,
+    37.828304
+  ],
+  [
+    126.409171,
+    37.846231
+  ],
+  [
+    126.447005,
+    37.835475
+  ],
+  [
+    126.468192,
+    37.812763
+  ],
+  [
+    126.584719,
+    37.762532
+  ],
+  [
+    126.659196,
+    37.782212
+  ],
+  [
+    126.672837,
+    37.831992
+  ],
+  [
+    126.688926,
+    37.841344
+  ],
+  [
+    126.673713,
+    37.953188
+  ],
+  [
+    126.713155,
+    37.954484
+  ],
+  [
+    126.813404,
+    38.002414
+  ],
+  [
+    126.861063,
+    38.048372
+  ],
+  [
+    126.881335,
+    38.103823
+  ],
+  [
+    126.956105,
+    38.136251
+  ],
+  [
+    126.98678,
+    38.212363
+  ],
+  [
+    127.137287,
+    38.314008
+  ],
+  [
+    127.395491,
+    38.336596
+  ],
+  [
+    127.510661,
+    38.301619
+  ],
+  [
+    127.575676,
+    38.336596
+  ],
+  [
+    127.793013,
+    38.338053
+  ],
+  [
+    127.825612,
+    38.308727
+  ],
+  [
+    127.890403,
+    38.334143
+  ],
+  [
+    128.054781,
+    38.307786
+  ],
+  [
+    128.20836,
+    38.374602
+  ],
+  [
+    128.280817,
+    38.444051
+  ],
+  [
+    128.302796,
+    38.480152
+  ],
+  [
+    128.306013,
+    38.59379
+  ],
+  [
+    128.35855,
+    38.618926
+  ],
+  [
+    131.378464,
+    37.526365
+  ],
+  [
+    129.520972,
+    35.161674
+  ],
+  [
+    127.276802,
+    33.309556
+  ],
+  [
+    125.675231,
+    32.793646
+  ],
+  [
+    124.454296,
+    34.226423
+  ]
+];
 const macauBounds = [
   [
     113.540194,
@@ -2627,9 +2789,13 @@ const inMacau = (point) => {
 const inTaiwan = (point) => {
   return pointInPolygon(point, taiwanBounds) >= 0;
 };
+const inKorean = (point) => {
+  return pointInPolygon(point, koreanBounds) >= 0;
+};
 export {
   inChina,
   inHongkong,
+  inKorean,
   inMacau,
   inTaiwan
 };

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

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

package/dist/v2/hooks/useWalkingRoute.js

@@ -1,7 +1,7 @@
 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 { googleServiceApiWalkingRoute, amapJsApiWalkingRoute, gaodeServiceApiWalkingRoute, gmapJsApiWalkingRoute } from "../utils/compatibleWalkingRoute.js";
+import { inTaiwan, inKorean } from "./useMapInChina.js";
 import { useMapSupplier } from "./useMapSupplier.js";
 const useAWalkingRoute = (props) => {
   const { googleDirectionsProxyUrl } = useMapSupplier();
@@ -24,10 +24,13 @@ const useAWalkingRoute = (props) => {
   return pathRef;
 };
 const useGWalkingRoute = (props) => {
+  const { gaodeDirectionWalkingProxyUrl } = useMapSupplier();
   const pathRef = shallowRef([]);
   const gmapDirectionsService = new google.maps.DirectionsService();
   const apiMapWalkingRoute = (from, to) => {
-    return gmapJsApiWalkingRoute(from, to, gmapDirectionsService);
+    if (inKorean(from))
+      return Promise.resolve([]);
+    return gaodeDirectionWalkingProxyUrl && inKorean(from) ? gaodeServiceApiWalkingRoute(from, to, gaodeDirectionWalkingProxyUrl) : gmapJsApiWalkingRoute(from, to, gmapDirectionsService);
   };
   watchPostEffectForDeepOption(
     () => {

package/dist/v2/types/amap/driving.d.ts

@@ -22,7 +22,7 @@ declare global {
             tolls: number;
             tolls_distance: number;
             restriction: number;
-            steps: (DriveStepBasic | DriveStepDetail)[];
+            steps: (DriveStepBasic & DriveStepDetail)[];
         }
         interface DriveStepBasic {
             start_location: LngLat;
@@ -68,7 +68,8 @@ declare global {
             taxi_cost: number;
             routes: DrivingRoute[];
         }
-        type DrivingCallback = (status: "complete" | "error" | "no_data", result: DrivingResult | Error | 0) => void;
+        type DirectionCallbackStatus = "complete" | "error" | "no_data";
+        type DrivingCallback = (status: DirectionCallbackStatus, result: DrivingResult | Error | 0) => void;
         class Driving {
             constructor(option: DrivingOptions);
             search(origin: LngLat, destination: LngLat, opts: {

package/dist/v2/types/amap/walking.d.ts

@@ -32,7 +32,7 @@ declare global {
             count: number;
             routes: WalkRoute[];
         }
-        type WalkingCallback = (status: "complete" | "error" | "no_data", result: WalkingResult | Error | 0) => void;
+        type WalkingCallback = (status: DirectionCallbackStatus, result: WalkingResult | Error | 0) => void;
         class Walking {
             constructor(option: WalkingOptions);
             search(origin: LngLat, destination: LngLat, callback: WalkingCallback): void;

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

@@ -1,5 +1,6 @@
 /// <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 gaodeServiceApiDrivingRoute(from: Point, to: Point, proxyUrl: string): 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

@@ -1,3 +1,4 @@
+import { apiGaodeDirectionDriving } from "../api/gaodeDirectionDriving.js";
 import { apiGoogleDirections } from "../api/googleDirections.js";
 function amapJsApiDrivingRoute(from, to, amapDriving) {
   return new Promise((resolve, reject) => {
@@ -41,6 +42,43 @@ function amapJsApiDrivingRoute(from, to, amapDriving) {
     );
   });
 }
+async function gaodeServiceApiDrivingRoute(from, to, proxyUrl) {
+  const { status, routes, error_message } = await apiGaodeDirectionDriving({
+    proxyUrl,
+    origin: [from],
+    destination: to
+  });
+  switch (status) {
+    case "complete": {
+      let path = [];
+      const routeSteps = [];
+      const firstRoute = routes[0];
+      if (!firstRoute)
+        return { 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 {
+        path,
+        distance: firstRoute.distance,
+        duration: firstRoute.time,
+        tolls: firstRoute.tolls,
+        steps: routeSteps
+      };
+    }
+    case "no_data":
+      return { path: [], distance: 0, duration: 0, steps: [] };
+    default:
+      throw Error(error_message);
+  }
+}
 function gmapJsApiDrivingRoute(from, to, gmapDirectionsService) {
   return new Promise((resolve, reject) => {
     gmapDirectionsService.route(
@@ -125,6 +163,7 @@ async function googleServiceApiDrivingRoute(from, to, proxyUrl) {
 }
 export {
   amapJsApiDrivingRoute,
+  gaodeServiceApiDrivingRoute,
   gmapJsApiDrivingRoute,
   googleServiceApiDrivingRoute
 };

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

@@ -6,3 +6,4 @@ export interface ApiGraspRoadOutput {
 }
 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>;
+export declare function bypassGraspRoad(tracks: TrackPoint[], apiMapComputeHeading: ApiMapComputeHeading): Promise<ApiGraspRoadOutput>;

package/dist/v2/utils/compatibleGraspRoad.js

@@ -61,7 +61,14 @@ async function googleServiceApiGraspRoad(tracks, apiMapComputeHeading, proxyUrl)
   const angle = (_d = apiMapComputeHeading(path[path.length - 2], path[path.length - 1])) != null ? _d : 0;
   return { path, angle };
 }
+async function bypassGraspRoad(tracks, apiMapComputeHeading) {
+  var _a;
+  const path = tracks.map(lnglat2point);
+  const angle = (_a = apiMapComputeHeading(path[0], path[1])) != null ? _a : 0;
+  return { path, angle };
+}
 export {
   amapJsApiGraspRoad,
+  bypassGraspRoad,
   googleServiceApiGraspRoad
 };

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

@@ -1,5 +1,6 @@
 /// <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 gaodeServiceApiWalkingRoute(from: Point, to: Point, proxyUrl: string): 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/v2/utils/compatibleWalkingRoute.js

@@ -1,3 +1,4 @@
+import { apiGaodeDirectionWalking } from "../api/gaodeDirectionWalking.js";
 import { apiGoogleDirections } from "../api/googleDirections.js";
 const isIgnoredAmapTimeoutError = (err) => err === "RETURN_TIMEOUT";
 function amapJsApiWalkingRoute(from, to, amapWalking) {
@@ -29,6 +30,30 @@ function amapJsApiWalkingRoute(from, to, amapWalking) {
     });
   });
 }
+async function gaodeServiceApiWalkingRoute(from, to, proxyUrl) {
+  const { status, routes, error_message } = await apiGaodeDirectionWalking({
+    proxyUrl,
+    origin: from,
+    destination: to
+  });
+  switch (status) {
+    case "complete": {
+      let path = [];
+      if (!routes)
+        return [];
+      const firstRoute = routes[0];
+      for (const step of firstRoute.steps) {
+        const stepPath = step.path.map(({ lng, lat }) => [lng, lat]);
+        path = path.concat(stepPath);
+      }
+      return path;
+    }
+    case "no_data":
+      return [];
+    default:
+      throw Error(error_message);
+  }
+}
 function gmapJsApiWalkingRoute(from, to, gmapDirectionsService) {
   return new Promise((resolve, reject) => {
     gmapDirectionsService.route(
@@ -76,6 +101,7 @@ async function googleServiceApiWalkingRoute(from, to, proxyUrl) {
 }
 export {
   amapJsApiWalkingRoute,
+  gaodeServiceApiWalkingRoute,
   gmapJsApiWalkingRoute,
   googleServiceApiWalkingRoute
 };

package/dist/v2/utils/log.js

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

package/dist/v2/utils/platform.js

@@ -50,7 +50,7 @@ const detectOSPlatform = () => {
   if (typeof navigator === "undefined")
     return "OTHER";
   const userAgent = navigator.userAgent || navigator.vendor;
-  if (/android/i.test(userAgent)) {
+  if (/android/i.test(userAgent) || /OpenHarmony/i.test(userAgent)) {
     return "ANDROID";
   }
   if (/iPad|iPhone|iPod/.test(userAgent) && !globalThis.MSStream) {

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

@@ -3,12 +3,14 @@ import type { Language, LngLatLiterial, Place, Point, TrackPoint, Zone } from ".
 import type { AlipayMyGetLocationSuccessResponse } from "../types/my";
 import type { WxGetLocationSuccessResponse } from "../types/wx";
 import { BRWOSER_PLATFORM } from "./platform";
+export declare const isAccuryEqual: (x: number, y?: number) => boolean;
 export declare const vec2lnglat: ([lng, lat]: [number, number]) => LngLatLiterial;
 export declare const lnglat2point: ({ lng, lat }: {
     lng: number;
     lat: number;
 }) => Point;
 export declare const googlePointsStringify: (points: Point[]) => string;
+export declare const gaodePointsStringify: (points: Point[]) => string;
 export interface AsteriskItem {
     type: "normal" | "emphasize";
     value: string;
@@ -44,4 +46,5 @@ 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 declare const gaodePolyline2amapLngLat: (value: string) => AMap.LngLat[];
 export {};

package/dist/v2/utils/transform.js

@@ -35,12 +35,15 @@ var decode = function(encodedPath, precision) {
   path.length = pointIndex;
   return path;
 };
+const GCOORD_ACCURCY_RANGE = 1e-6;
+const isAccuryEqual = (x, y) => y === void 0 ? false : Math.abs(x - y) <= GCOORD_ACCURCY_RANGE;
 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 gaodePointsStringify = (points) => points.map(([lng, lat]) => `${lng},${lat}`).join(";");
 const decodeAsterisk = (encodedValue) => {
   const result = [];
   const tokens = encodedValue.split("*");
@@ -99,10 +102,10 @@ const pipeOnlyLastEffect = (fn) => {
   };
 };
 const isPlaceEqual = (p1, p2) => {
-  return p1.lng === (p2 == null ? void 0 : p2.lng) && p1.lat === (p2 == null ? void 0 : p2.lat);
+  return isAccuryEqual(p1.lng, p2 == null ? void 0 : p2.lng) && isAccuryEqual(p1.lat, p2 == null ? void 0 : p2.lat);
 };
 const isPointEqual = (p1, p2) => {
-  return p1[0] === (p2 == null ? void 0 : p2[0]) && p1[1] === (p2 == null ? void 0 : p2[1]);
+  return isAccuryEqual(p1[0], p2 == null ? void 0 : p2[0]) && isAccuryEqual(p1[1], p2 == null ? void 0 : p2[1]);
 };
 const isGeoPositionEqual = (p1, p2) => {
   if (!p2)
@@ -287,6 +290,12 @@ const signal2promise = (signal) => {
 const googleEncodedPolyline2googleLatLng = (value) => {
   return decode(value).map(([lat, lng]) => new GoogleLatLng({ lng, lat }));
 };
+const gaodePolyline2amapLngLat = (value) => {
+  return value.split(";").map((lnglatString) => {
+    const [lng, lat] = lnglatString.split(",").map(Number);
+    return { lng, lat };
+  });
+};
 export {
   alipayMyGetLocationError2GeolocationPositionErrorCode,
   alipayMyGetLocationSuccessResponse2GeolocationPosition,
@@ -296,10 +305,13 @@ export {
   decodeAsterisk,
   deltaZoom2animationDuration,
   distanceVw2animationDuration,
+  gaodePointsStringify,
+  gaodePolyline2amapLngLat,
   geoPositionError2businessTimeout,
   gmapPlaceName2DisplayName,
   googleEncodedPolyline2googleLatLng,
   googlePointsStringify,
+  isAccuryEqual,
   isGeoPositionEqual,
   isPlaceEqual,
   isPointEqual,

package/dist/v2/utils/typeChecking.js

@@ -4,6 +4,7 @@ const createTypeError = (typeName, value, detail) => {
       `MyTypeError: expect type: ${typeName}, but received: ${JSON.stringify(
         value
       )}
+
  Type Error Details: ${detail}`
     );
   return new Error(`MyTypeError: expect type: ${typeName}, but received: ${JSON.stringify(value)}`);

package/dist/v3/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 {};