@heycar/heycars-map 2.5.3 → 2.6.0

package/dist/v2/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/v2/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.0";
 const isEnableLog = (name) => {
   const searchParam = new URLSearchParams(location.search);
   return searchParam.has(`log-${name}`);

package/dist/v2/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/v2/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/v2/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/v2/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/dist/v3/Demo/DemoBusinessRecomendPlace.js

@@ -1,5 +1,5 @@
 import { createVNode } from "vue";
-import { B as BusinessRecomendPlaceMap } from "../chunks/BusinessRecomendPlaceMap.d14dbe4e.js";
+import { B as BusinessRecomendPlaceMap } from "../chunks/BusinessRecomendPlaceMap.8ce05cf5.js";
 import { useBusinessRecomendPlaceMap } from "../hooks-business/useBusinessRecomendPlaceMap.js";
 import { defineSetup } from "../types/helper.js";
 import { d as demo } from "../chunks/Demo.css.e921a2f6.js";

package/dist/v3/api/contants.d.ts

@@ -1,8 +1,8 @@
 import type { Point } from "../types/interface";
 export declare const MAX_ANIMATION_DISTANCE_VW = 300;
-export declare const MIN_ANIMATION_DURATION = 300;
-export declare const ANIMATION_DURATION_FOR_100VW = 200;
-export declare const ANIMATION_DURATION_PER_ZOOM = 400;
+export declare const MIN_ANIMATION_DURATION = 200;
+export declare const ANIMATION_DURATION_FOR_100VW = 100;
+export declare const ANIMATION_DURATION_PER_ZOOM = 200;
 export declare const BEIJIN_POINT: Point;
 export declare const MAX_DEVIATION_DISTANCE = 30;
 export declare const CAR_DISTANCE_MIN = 100;

package/dist/v3/api/contants.js

@@ -1,7 +1,7 @@
 const MAX_ANIMATION_DISTANCE_VW = 300;
-const MIN_ANIMATION_DURATION = 300;
-const ANIMATION_DURATION_FOR_100VW = 200;
-const ANIMATION_DURATION_PER_ZOOM = 400;
+const MIN_ANIMATION_DURATION = 200;
+const ANIMATION_DURATION_FOR_100VW = 100;
+const ANIMATION_DURATION_PER_ZOOM = 200;
 const BEIJIN_POINT = [116.2317, 39.5427];
 const MAX_DEVIATION_DISTANCE = 30;
 const CAR_DISTANCE_MIN = 100;

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

@@ -0,0 +1,26 @@
+/// <reference types="google.maps" />
+import type { Point } from "../types/interface";
+type DirectionsStatus = `${google.maps.DirectionsStatus}`;
+export interface GoogleDirectionsResponse extends Pick<google.maps.DirectionsResult, "routes" | "geocoded_waypoints" | "available_travel_modes"> {
+    status: DirectionsStatus;
+    error_message?: string;
+}
+export interface ApiGoogleDirectionsProps {
+    proxyUrl?: string;
+    origin: Point;
+    destination: Point;
+    waypoints?: Point[];
+    mode?: `${google.maps.TravelMode}`;
+    traffic_model?: `${google.maps.TrafficModel}`;
+    alternatives?: boolean;
+    arrival_time?: number;
+    departure_time?: number;
+    avoid?: ("tolls" | "highways" | "ferries" | "indoor")[];
+    language?: string;
+    region?: string;
+    units?: "metric" | "imperial";
+    transit_mode?: `${google.maps.TransitMode}`;
+    transit_routing_preference?: `${google.maps.TransitRoutePreference}`;
+}
+export declare function apiGoogleDirections(props: ApiGoogleDirectionsProps): Promise<GoogleDirectionsResponse>;
+export {};

package/dist/v3/api/googleDirections.js

@@ -0,0 +1,139 @@
+import { googlePointsStringify, googleEncodedPolyline2googleLatLng } from "../utils/transform.js";
+import { isProxyServiceError, createTypeError } from "../utils/typeChecking.js";
+const ALL_DIRECTIONS_STATUS = [
+  "INVALID_REQUEST",
+  "MAX_WAYPOINTS_EXCEEDED",
+  "NOT_FOUND",
+  "OK",
+  "OVER_QUERY_LIMIT",
+  "REQUEST_DENIED",
+  "UNKNOWN_ERROR",
+  "ZERO_RESULTS"
+];
+function isGoogleDistance(value) {
+  return typeof value === "object" && value !== null && "text" in value && typeof value.text === "string" && "value" in value && typeof value.value === "number";
+}
+function isGoogleDuration(value) {
+  return typeof value === "object" && value !== null && "text" in value && typeof value.text === "string" && "value" in value && typeof value.value === "number";
+}
+function isGoogleDirectionsPolyline(value) {
+  return typeof value === "object" && value !== null && "points" in value && typeof value.points === "string";
+}
+function isMeasurableObject(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))
+    throw error;
+  if (!("polyline" in value)) {
+    value.path = [];
+    return;
+  }
+  if (!isGoogleDirectionsPolyline(value.polyline))
+    throw error;
+  value.path = googleEncodedPolyline2googleLatLng(
+    value.polyline.points
+  );
+}
+function assertGoogleDirectionsLeg(value) {
+  if (!isMeasurableObject(value) || !("steps" in value) || !Array.isArray(value.steps))
+    throw createTypeError("google.maps.DirectionsLeg", value);
+  try {
+    for (const step of value.steps) {
+      assertGoogleDirectionsStep(step);
+    }
+  } catch (error) {
+    const { message: detail } = error;
+    throw createTypeError("google.maps.DirectionsLeg", value, detail);
+  }
+}
+function assertGoogleDirectionsRoute(value) {
+  if (typeof value !== "object" || value === null || !("legs" in value) || !Array.isArray(value.legs) || !("overview_polyline" in value) || !isGoogleDirectionsPolyline(value.overview_polyline))
+    throw createTypeError("google.maps.DirectionsRoute", value);
+  value.overview_path = googleEncodedPolyline2googleLatLng(
+    value.overview_polyline.points
+  );
+  try {
+    for (const leg of value.legs) {
+      assertGoogleDirectionsLeg(leg);
+    }
+  } catch (error) {
+    const { message: detail } = error;
+    throw createTypeError("google.maps.DirectionsRoute", value, detail);
+  }
+}
+function assertGoogleDirectionsResponse(value) {
+  if (typeof value !== "object" || value === null || !("status" in value) || !("routes" in value) || !isGoogleDirectionsStatus(value.status) || !Array.isArray(value.routes))
+    throw createTypeError("GoogleDirectionsResponse", value);
+  try {
+    for (const route of value.routes) {
+      assertGoogleDirectionsRoute(route);
+    }
+  } catch (error) {
+    const { message: detail } = error;
+    throw createTypeError("GoogleDirectionsResponse", value, detail);
+  }
+}
+function isGoogleDirectionsStatus(value) {
+  return typeof value === "string" && ALL_DIRECTIONS_STATUS.includes(value);
+}
+function isGoogleDirectionsError(error) {
+  return typeof error === "object" && !!error && "status" in error && isGoogleDirectionsStatus(error.status) && "error_message" in error;
+}
+async function apiGoogleDirections(props) {
+  const { proxyUrl, origin, destination, waypoints, avoid } = props;
+  if (!proxyUrl)
+    return {
+      status: "ZERO_RESULTS",
+      routes: [],
+      error_message: "Warning: google directions service is bypassed due to proxyUrl is not provided!"
+    };
+  const { protocol, host } = location;
+  const baseUrl = proxyUrl.startsWith(protocol) ? void 0 : `${protocol}//${host}`;
+  const url = new URL(proxyUrl, baseUrl);
+  url.searchParams.set("origin", googlePointsStringify([origin]));
+  url.searchParams.set("destination", googlePointsStringify([destination]));
+  if (waypoints && waypoints.length > 0)
+    url.searchParams.set("waypoints", googlePointsStringify(waypoints));
+  if (avoid && avoid.length > 0)
+    url.searchParams.set("avoid", avoid.join("|"));
+  for (const key of [
+    "mode",
+    "traffic_model",
+    "alternatives",
+    "arrival_time",
+    "departure_time",
+    "language",
+    "region",
+    "units",
+    "transit_mode",
+    "transit_routing_preference"
+  ]) {
+    if (props[key] !== void 0)
+      url.searchParams.set(key, String(key));
+  }
+  const response = await fetch(url);
+  if (response.ok) {
+    const result = await response.json();
+    assertGoogleDirectionsResponse(result);
+    return result;
+  }
+  const error = await response.json();
+  if (isProxyServiceError(error)) {
+    const { code, msg } = error;
+    throw new Error(`apiGoogleDirections proxy failed code: ${code}, msg: 
+${msg}`);
+  }
+  if (isGoogleDirectionsError(error)) {
+    const { status, error_message } = error;
+    throw new Error(`apiGoogleDirections failed status: ${status}, message: 
+${error_message}`);
+  }
+  throw new Error(
+    `apiGoogleSnapRoad failed with unrecognized server response: ${JSON.stringify(error)}`
+  );
+}
+export {
+  apiGoogleDirections
+};

package/dist/v3/api/googleSnapRoad.d.ts

@@ -18,5 +18,4 @@ export interface ApiGoogleSnapRoadProps {
     proxyUrl?: string;
 }
 export declare function apiGoogleSnapRoad(props: ApiGoogleSnapRoadProps): Promise<SnapToRoadsResponse>;
-export declare const setGlobalGoogleSnapRoadProxyUrl: (url?: string) => void;
 export {};

package/dist/v3/api/googleSnapRoad.js

@@ -1,8 +1,5 @@
-let googleSnapRoadProxyUrl = void 0;
-const googleSnapRoadPointsStringify = (points) => points.map(([lng, lat]) => `${lat},${lng}`).join("|");
-function isProxyError(error) {
-  return !!error && typeof error === "object" && "msg" in error && "code" in error;
-}
+import { googlePointsStringify } from "../utils/transform.js";
+import { isProxyServiceError } from "../utils/typeChecking.js";
 const point2snappedPoint = (point) => {
   const [longitude, latitude] = point;
   return { location: { longitude, latitude }, placeId: "" };
@@ -34,7 +31,7 @@ function assertSnapToRoadsResponse(value) {
   value.snappedPoints.forEach(assertSnappedPoint);
 }
 async function apiGoogleSnapRoad(props) {
-  const { interpolate, path, proxyUrl = googleSnapRoadProxyUrl } = props;
+  const { interpolate, path, proxyUrl } = props;
   if (!proxyUrl)
     return {
       snappedPoints: path.map(point2snappedPoint),
@@ -45,7 +42,7 @@ async function apiGoogleSnapRoad(props) {
   const url = new URL(proxyUrl, baseUrl);
   if (interpolate !== void 0)
     url.searchParams.set("interpolate", String(interpolate));
-  url.searchParams.set("path", googleSnapRoadPointsStringify(path));
+  url.searchParams.set("path", googlePointsStringify(path));
   const response = await fetch(url);
   if (response.ok) {
     const result = await response.json();
@@ -53,7 +50,7 @@ async function apiGoogleSnapRoad(props) {
     return result;
   }
   const error = await response.json();
-  if (isProxyError(error)) {
+  if (isProxyServiceError(error)) {
     const { code: code2, msg } = error;
     throw new Error(`apiGoogleSnapRoad proxy failed code: ${code2}, msg: 
 ${msg}`);
@@ -64,11 +61,6 @@ ${msg}`);
 ${message}`
   );
 }
-const setGlobalGoogleSnapRoadProxyUrl = (url) => {
-  if (url)
-    googleSnapRoadProxyUrl = url;
-};
 export {
-  apiGoogleSnapRoad,
-  setGlobalGoogleSnapRoadProxyUrl
+  apiGoogleSnapRoad
 };

package/dist/v3/business-components/BusinessRecomendPlaceMap/BusinessRecomendPlaceMap.js

@@ -27,7 +27,7 @@ import "../GreenZone/GreenZone.js";
 import "../PassengerCircle/PassengerCircle.js";
 import "../PickupPoints/PickupPoints.js";
 import "./useCacheCenterPlace.js";
-import { B, f, D, E, R, c, a, e, b, d, Z } from "../../chunks/BusinessRecomendPlaceMap.d14dbe4e.js";
+import { B, f, D, E, R, c, a, e, b, d, Z } from "../../chunks/BusinessRecomendPlaceMap.8ce05cf5.js";
 export {
   B as BusinessRecomendPlaceMap,
   f as BusinessRecomendPlaceMapInner,

package/dist/v3/business-components/BusinessRecomendPlaceMap/index.js

@@ -1,4 +1,4 @@
-import { B, f, D, E, R, c, a, e, b, d, Z } from "../../chunks/BusinessRecomendPlaceMap.d14dbe4e.js";
+import { B, f, D, E, R, c, a, e, b, d, Z } from "../../chunks/BusinessRecomendPlaceMap.8ce05cf5.js";
 export {
   B as BusinessRecomendPlaceMap,
   f as BusinessRecomendPlaceMapInner,

package/dist/v3/business-components/BusinessReselectPlaceMap/BusinessReselectPlaceMap.js

@@ -21,7 +21,7 @@ import { detectBrowserPlatform } from "../../utils/platform.js";
 import { place2point, isPlaceEqual, isZoneEqual, geoPositionError2businessTimeout, pipeDefer } from "../../utils/transform.js";
 import { toCoordinatePlaceType, toCoordinatePointType, toCoordinateRecommendZonePlacesType } from "../../utils/typeChecking.js";
 import { AbsoluteAddressBox } from "../AbsoluteAddressBox/AbsoluteAddressBox.js";
-import { E as EMPTY_PLACE, m as memoize, R as RECOMMEND_PLACE_DRAG_LIMIT, a as RECOMMEND_PLACE_LARGE_LIMIT, b as RECOMMEND_PLACE_ZONE_ICON_MIN, c as RECOMMEND_PLACE_ICON_ZOOM_MIN, d as RECOMMEND_PLACE_ZONE_TEXT_MIN, e as RECOMMEND_PLACE_TEXT_ZOOM_MIN, D as DEFAULT_ZOOM, Z as ZONE_FITVIEW_PANDING } from "../../chunks/BusinessRecomendPlaceMap.d14dbe4e.js";
+import { E as EMPTY_PLACE, m as memoize, R as RECOMMEND_PLACE_DRAG_LIMIT, a as RECOMMEND_PLACE_LARGE_LIMIT, b as RECOMMEND_PLACE_ZONE_ICON_MIN, c as RECOMMEND_PLACE_ICON_ZOOM_MIN, d as RECOMMEND_PLACE_ZONE_TEXT_MIN, e as RECOMMEND_PLACE_TEXT_ZOOM_MIN, D as DEFAULT_ZOOM, Z as ZONE_FITVIEW_PANDING } from "../../chunks/BusinessRecomendPlaceMap.8ce05cf5.js";
 import { DeviceOrientation } from "../DeviceOrientation/DeviceOrientation.js";
 import { GreenZone } from "../GreenZone/GreenZone.js";
 import { PassengerCircle } from "../PassengerCircle/PassengerCircle.js";
@@ -228,7 +228,8 @@ const BusinessReselectPlaceMapInner = defineSetup("BusinessReselectPlaceMapInner
       inputPlace,
       type,
       zone,
-      isSameZone
+      isSameZone,
+      noAnimation
     }) => {
       var _a;
       centerSource.source = "recomend";
@@ -238,7 +239,7 @@ const BusinessReselectPlaceMapInner = defineSetup("BusinessReselectPlaceMapInner
         ...place
       });
       if ((type === "Restricted" || type === "Forbidden") && !isSameZone)
-        setFitZoom((_a = zoneRef.value) == null ? void 0 : _a.path);
+        setFitZoom((_a = zoneRef.value) == null ? void 0 : _a.path, place2point(place), noAnimation);
       emit("changeRecomandPlace", coordinatifyValueOfOnChangeRecommendPlace({
         place,
         inputPlace,

package/dist/v3/business-components/BusinessTaxiServiceMap/BusinessTaxiServiceMap.d.ts

@@ -12,7 +12,6 @@ export type BusinessTaxiServiceMapProps = CoordinatifyProps<Omit<HeycarMapProps,
     driverStatus: DriverStatus;
     interval: number;
     disablePassenger?: boolean;
-    googleSnapRoadProxyUrl?: string;
     mapContext: CoordinatifyProps<BusinessTaxiServiceContext>;
     renderStartSerivceTitle: (titleProps: {
         distance: number;

package/dist/v3/business-components/BusinessTaxiServiceMap/BusinessTaxiServiceMap.js

@@ -1,7 +1,6 @@
 import { createVNode } from "vue";
 import { ref, watch, onUnmounted } from "vue-demi";
 import { apiGetAuxiliaryGrapStatus } from "../../api/browser.js";
-import { setGlobalGoogleSnapRoadProxyUrl } from "../../api/googleSnapRoad.js";
 import { HeycarMap } from "../../components/MapProvider/MapProvider.js";
 import { createElement } from "../../demi-polyfill/demi-polyfill.js";
 import { useGeoLocation } from "../../hooks/useGeoLocation.js";
@@ -30,7 +29,6 @@ const BusinessTaxiServiceMapInner = defineSetup("BusinessTaxiServiceMapInner", f
     renderStartSerivceTitle,
     renderInServiceTitle
   } = props;
-  setGlobalGoogleSnapRoadProxyUrl(props.googleSnapRoadProxyUrl);
   const {
     mapRef,
     setMap,
@@ -210,7 +208,7 @@ const BusinessTaxiServiceMap = defineLagecySetup("BusinessTaxiServiceMap", funct
     attrs: props,
     key: `${payload.supplier}${instanceNo}`
   });
-}).props(["bookDispatchingTitle", "dispatchingTitle", "driverArrivedTitle", "driverStatus", "googleSnapRoadProxyUrl", "fallback", "from", "getDriverPositionTrack", "interval", "disablePassenger", "loading", "mapContext", "renderInServiceTitle", "renderStartSerivceTitle", "to"]);
+}).props(["bookDispatchingTitle", "dispatchingTitle", "driverArrivedTitle", "driverStatus", "fallback", "from", "getDriverPositionTrack", "interval", "disablePassenger", "loading", "mapContext", "renderInServiceTitle", "renderStartSerivceTitle", "to"]);
 export {
   BusinessTaxiServiceMap,
   BusinessTaxiServiceMapInner

package/dist/v3/chunks/{BusinessRecomendPlaceMap.d14dbe4e.js → BusinessRecomendPlaceMap.8ce05cf5.js}

@@ -502,7 +502,8 @@ const BusinessRecomendPlaceMapInner = defineSetup("BusinessRecomendPlaceMapInner
       inputPlace,
       type,
       zone,
-      isSameZone
+      isSameZone,
+      noAnimation
     }) => {
       var _a;
       centerSource.source = "recomend";
@@ -512,7 +513,7 @@ const BusinessRecomendPlaceMapInner = defineSetup("BusinessRecomendPlaceMapInner
         ...place
       });
       if ((type === "Restricted" || type === "Forbidden") && !isSameZone)
-        setFitZoom((_a = zoneRef.value) == null ? void 0 : _a.path, place2point(place));
+        setFitZoom((_a = zoneRef.value) == null ? void 0 : _a.path, place2point(place), noAnimation);
       emit("changeRecomandPlace", coordinatifyValueOfOnChangeRecommendPlace({
         place,
         inputPlace,

package/dist/v3/components/Gmap/Gmap.js

@@ -13,7 +13,6 @@ const Gmap_css_ts_vanilla = "";
 var gmap = "_7anfuo0";
 const Gmap = defineSetup("Gmap", function(props, { slots, emit, attrs }) {
   const setMap = props.mapRef;
-  const { onResize } = props;
   const os = detectOSPlatform();
   const options = computed(() => {
     const {
@@ -49,7 +48,14 @@ const Gmap = defineSetup("Gmap", function(props, { slots, emit, attrs }) {
   provideGmap(mapRef);
   useGmapWheelZoomCenter({ mapRef, enableRef });
   useGmapGestureZoomCenter({ mapRef, elementRef, enableRef });
-  useResizeObserver({ elementRef, onChange: onResize });
+  useResizeObserver({
+    elementRef,
+    shouldSkip: () => {
+      var _a;
+      return !((_a = mapRef.value) == null ? void 0 : _a.getProjection());
+    },
+    onChange: (e) => emit("resize", e)
+  });
   watchPostEffect(() => {
     const element = elementRef.value;
     if (mapRef.value || !element)

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

@@ -5,7 +5,7 @@ import { Status, type GmapLoaderProps, type UseMapLoaderProps } from "../../hook
 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" | "renderLoadFailedTitle" | "renderLoadFailedDescription">;
+export type MapProviderProps = UseMapLoaderProps & Pick<MapSupplierPayolad, "gmapId" | "gmapRasterId" | "googleDirectionsProxyUrl" | "googleSnapRoadProxyUrl" | "renderLoadFailedTitle" | "renderLoadFailedDescription">;
 export declare const MapProvider: import("vue-demi").DefineComponent<import("vue-demi").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", import("vue-demi").PublicProps, MapProviderProps, MapProviderProps, import("vue-demi").SlotsType<{
     renderLoadFailedTitle?: ((status: Status) => string | undefined) | undefined;
     renderLoadFailedDescription?: ((status: Status) => string | undefined) | undefined;