@heycar/heycars-map 2.4.6 → 2.5.1

package/dist/v3/hooks/useMapRecomendPlace.js

@@ -1,10 +1,12 @@
 import { ref, reactive } from "vue-demi";
 import { GET_RECOMMEND_PLACE_TIMEOUT } from "../api/contants.js";
-import { logNoneManualAbortError } from "../utils/ManualAbortError.js";
+import { recoverablyIgnoreManualAbortReject, logNoneManualAbortError } from "../utils/ManualAbortError.js";
 import { createAbortableOneConcurrent, AbortSignalAny, equalAssign, isPlacesInclude, createAbortable } from "../utils/helper.js";
 import { isZoneEqual, place2point, isPlaceEqual, businessCandidatesToAdsorptionPlace } from "../utils/transform.js";
+import { assertNoConflictTypeAndZone } from "../utils/typeChecking.js";
 import { useMapGeometry, apiLocalIsPointInRing } from "./useMapGeometry.js";
 import { useMapPlace } from "./useMapPlace.js";
+const DEFAULT_RECOMMEND_TYPE = "Recommend";
 function mergeGetRecommendPlaceAndGetAvailable(getRecomendPlace, getAvailable, timeout) {
   return function mergedGetRecommendPlace(place, context) {
     const available = true;
@@ -49,7 +51,7 @@ const useMapRecomendPlace = (props) => {
     onChangePlace
   } = props;
   const availableRef = ref(true);
-  const forceRef = ref(false);
+  const recommendTypeRef = ref(DEFAULT_RECOMMEND_TYPE);
   const placeCandidatesRef = ref([]);
   const zoneRef = ref();
   const abortable = createAbortable(inputSignal);
@@ -77,16 +79,16 @@ const useMapRecomendPlace = (props) => {
       places: placeCandidates,
       zone,
       available = false,
-      force = false,
+      type = DEFAULT_RECOMMEND_TYPE,
       adsorption = false
     } = await getRecomendPlaceNoFail({ ...place }, context);
     (_a = opt == null ? void 0 : opt.signal) == null ? void 0 : _a.throwIfAborted();
-    if (!available || !placeCandidates) {
-      return { place: { ...place }, zone, candidates: [], available, force };
+    if (!available || !placeCandidates || placeCandidates.length === 0) {
+      return { place: { ...place }, zone, candidates: [], available, type };
     }
     if (!zone) {
       const resultPlace2 = adsorption ? businessCandidatesToAdsorptionPlace(placeCandidates) : place;
-      return { place: { ...resultPlace2 }, zone, candidates: placeCandidates, available, force };
+      return { place: { ...resultPlace2 }, zone, candidates: placeCandidates, available, type };
     }
     const { shortestPlace, shortestDistance } = findNearestPlace(
       place,
@@ -95,42 +97,43 @@ const useMapRecomendPlace = (props) => {
     );
     const limit = getLimit(context);
     const resultPlace = zone || shortestDistance <= limit ? shortestPlace : place;
-    return { place: { ...resultPlace }, zone, candidates: placeCandidates, available, force };
+    return { place: { ...resultPlace }, zone, candidates: placeCandidates, available, type };
   };
   const getRecommendPlaceZoneState = async (point, prevState, opt) => {
     const [lng, lat] = point;
-    const zone = zoneRef.value;
+    const { type, zone, available, candidates } = prevState;
     if (!zone || !apiLocalIsPointInRing(point, zone.path)) {
-      const reGeoPlacePromise = getPlaceByRegeo(point, opt);
+      const reGeoPlacePromiseIgnored = recoverablyIgnoreManualAbortReject(
+        getPlaceByRegeo(point, opt)
+      );
       const {
         place: closestPlace,
-        candidates,
-        available,
-        force,
+        candidates: candidates2,
+        available: available2,
+        type: type2,
         zone: zone2
       } = await findAttachedPlace({ lng, lat, name: "", displayName: "" }, opt);
-      if (isPlacesInclude(candidates, closestPlace)) {
-        return { place: { ...closestPlace }, zone: zone2, available, candidates, force };
+      if (isPlacesInclude(candidates2, closestPlace)) {
+        return { place: { ...closestPlace }, zone: zone2, available: available2, candidates: candidates2, type: type2 };
       }
-      const regeoPlace = await reGeoPlacePromise;
-      return { place: { ...regeoPlace }, zone: zone2, available, candidates, force };
+      const regeoPlace = await reGeoPlacePromiseIgnored.recover();
+      return { place: { ...regeoPlace }, zone: zone2, available: available2, candidates: candidates2, type: type2 };
+    }
+    if (type === "Forbidden") {
+      const regeoPlace = await getPlaceByRegeo(point, opt);
+      return { place: { ...regeoPlace }, zone, available, candidates, type };
     }
     const { shortestPlace: resultPlace } = findNearestPlace(
       { lng, lat, name: "", displayName: "" },
-      prevState.candidates,
+      candidates,
       apiMapDistance
     );
-    return {
-      place: { ...resultPlace },
-      zone,
-      available: prevState.available,
-      force: prevState.force,
-      candidates: prevState.candidates
-    };
+    return { place: { ...resultPlace }, zone, type, available, candidates };
   };
   const updateIntermediateQueryingState = (point) => {
+    const type = recommendTypeRef.value;
     const zone = zoneRef.value;
-    if (zone && apiLocalIsPointInRing(point, zone.path))
+    if (type === "Restricted" && zone && apiLocalIsPointInRing(point, zone.path))
       return;
     const [lng, lat] = point;
     const intermediateQueryingPlace = {
@@ -141,8 +144,10 @@ const useMapRecomendPlace = (props) => {
     };
     isQueryingRef.value = true;
     availableRef.value = true;
-    if (zone)
+    if (type === "Restricted" || type === "Forbidden" && (!zone || !apiLocalIsPointInRing(point, zone.path))) {
       zoneRef.value = void 0;
+      recommendTypeRef.value = "Recommend";
+    }
     placeCandidatesRef.value = [];
     equalAssign(recomendPlace, { ...intermediateQueryingPlace });
     onQueryingPlace == null ? void 0 : onQueryingPlace({ ...intermediateQueryingPlace });
@@ -156,13 +161,13 @@ const useMapRecomendPlace = (props) => {
         candidates,
         zone,
         available,
-        force
+        type
       } = await getRecommendPlaceZoneState(
         point,
         {
           place: recomendPlace,
           available: availableRef.value,
-          force: forceRef.value,
+          type: recommendTypeRef.value,
           candidates: placeCandidatesRef.value,
           zone: zoneRef.value
         },
@@ -171,13 +176,13 @@ const useMapRecomendPlace = (props) => {
       const isSameZone = !!zone && isZoneEqual(zone, zoneRef.value);
       isQueryingRef.value = false;
       availableRef.value = available;
-      forceRef.value = force;
+      recommendTypeRef.value = type;
       zoneRef.value = zone;
       placeCandidatesRef.value = candidates;
       equalAssign(recomendPlace, { ...resultPlace });
       onChangePlace == null ? void 0 : onChangePlace({ ...resultPlace });
       const inputPlace = { name: "", displayName: "", lng: point[0], lat: point[1] };
-      onChange == null ? void 0 : onChange({ place: { ...resultPlace }, inputPlace, isInZone: !!zone, isSameZone });
+      onChange == null ? void 0 : onChange({ place: { ...resultPlace }, inputPlace, type, zone, isSameZone });
     },
     { silent: true }
   );
@@ -188,19 +193,19 @@ const useMapRecomendPlace = (props) => {
       places: placeCandidates,
       zone,
       available = false,
-      force = false
+      type = DEFAULT_RECOMMEND_TYPE
     } = await getRecomendPlaceNoFail({ ...place }, context);
     signal.throwIfAborted();
     const isSameZone = !!zone && isZoneEqual(zone, zoneRef.value);
     isQueryingRef.value = false;
     availableRef.value = !!available;
-    forceRef.value = !!force;
+    recommendTypeRef.value = type;
     zoneRef.value = zone;
     placeCandidatesRef.value = placeCandidates != null ? placeCandidates : [];
     return {
       inputPlace: { ...place },
-      isInZone: !!zone,
       place: { ...place },
+      type,
       isSameZone
     };
   };
@@ -210,13 +215,13 @@ const useMapRecomendPlace = (props) => {
       place: resultPlace,
       candidates,
       available,
-      force,
+      type,
       zone
     } = await findAttachedPlace(place, opt);
     const isSameZone = !!zone && isZoneEqual(zone, zoneRef.value);
     isQueryingRef.value = false;
     availableRef.value = available;
-    forceRef.value = force;
+    recommendTypeRef.value = type;
     zoneRef.value = zone;
     placeCandidatesRef.value = candidates;
     equalAssign(recomendPlace, { ...resultPlace });
@@ -224,7 +229,8 @@ const useMapRecomendPlace = (props) => {
     onChange == null ? void 0 : onChange({
       place: { ...resultPlace },
       inputPlace: { ...place },
-      isInZone: !!zone,
+      type,
+      zone,
       isSameZone
     });
   };
@@ -235,14 +241,14 @@ const useMapRecomendPlace = (props) => {
       place: foundPlace,
       candidates,
       available,
-      force,
+      type,
       zone
     } = await findAttachedPlace(place, opt);
-    const resultPlace = zone ? foundPlace : (_a = candidates.find((p) => isPlaceEqual(p, place))) != null ? _a : place;
+    const resultPlace = type === "Restricted" ? foundPlace : (_a = candidates.find((p) => isPlaceEqual(p, place))) != null ? _a : place;
     const isSameZone = !!zone && isZoneEqual(zone, zoneRef.value);
     isQueryingRef.value = false;
     availableRef.value = available;
-    forceRef.value = force;
+    recommendTypeRef.value = type;
     zoneRef.value = zone;
     placeCandidatesRef.value = candidates;
     equalAssign(recomendPlace, { ...resultPlace });
@@ -250,13 +256,19 @@ const useMapRecomendPlace = (props) => {
     onChange == null ? void 0 : onChange({
       place: { ...resultPlace },
       inputPlace: { ...place },
-      isInZone: !!zone,
+      type,
+      zone,
       isSameZone
     });
   };
-  const setPlaceCandidatesAndZone = ({ zone, places: placeCandidates }) => {
+  const setPlaceCandidatesAndZone = ({
+    type = DEFAULT_RECOMMEND_TYPE,
+    zone,
+    places: placeCandidates
+  }) => {
+    assertNoConflictTypeAndZone(type, zone);
     availableRef.value = true;
-    forceRef.value = !!zone;
+    recommendTypeRef.value = type;
     zoneRef.value = zone ? zone : void 0;
     placeCandidatesRef.value = placeCandidates != null ? placeCandidates : [];
   };
@@ -265,7 +277,7 @@ const useMapRecomendPlace = (props) => {
     recomendPlace,
     placeCandidates: placeCandidatesRef,
     availableRef,
-    forceRef,
+    recommendTypeRef,
     isQueryingRef,
     updateRecommendPlace,
     updateRecommendPlaceOnlyInZone,

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

@@ -2,7 +2,7 @@ import type { AnyFn } from "@vueuse/core";
 import type { ConnectionStatus } from "../types/interface";
 import type { Status, UseMapLoaderOutput, UseMapLoaderProps } from "./useMapLoader";
 export interface MapSupplierPayolad extends UseMapLoaderProps {
-    gmapRasterId: string;
+    gmapRasterId?: string;
     gmapId: string;
     readyPromise: UseMapLoaderOutput["readyPromise"];
     status: Status;

package/dist/v3/hooks/useMapSupplier.js

@@ -12,7 +12,6 @@ const useMapAssertSupplier = () => {
   const instanceSupplier = payload.supplier;
   function assertSupplier(fn) {
     return function fnWithAssertSupplier(...args) {
-      console.log("instanceSupplier, payload.supplier = ", instanceSupplier, payload.supplier);
       if (instanceSupplier === payload.supplier)
         return fn(...args);
       throw Error(

package/dist/v3/hooks/useWalkingRoute.js

@@ -1,6 +1,7 @@
 import { shallowRef } from "vue-demi";
 import { watchPostEffectForDeepOption } from "../utils/compare.js";
 import { useMapSupplier } from "./useMapSupplier.js";
+const isIgnoredAmapWalkingRouteError = (err) => err === "RETURN_TIMEOUT";
 const useAWalkingRoute = (props) => {
   const pathRef = shallowRef([]);
   const amapWalking = new AMap.Walking({});
@@ -30,6 +31,11 @@ const useAWalkingRoute = (props) => {
             pathRef.value = [];
             return;
           default:
+            if (isIgnoredAmapWalkingRouteError(result)) {
+              console.warn(result);
+              pathRef.value = [];
+              return;
+            }
             throw result;
         }
       });

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

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

package/dist/v3/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.7133beea.js";
+import { B } from "./chunks/BusinessRecomendPlaceMap.4c38b1fb.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/v3/types/gmap.d.ts

@@ -1 +1,11 @@
+/// <reference types="google.maps" />
+declare global {
+    namespace google.maps {
+        interface MapOptions {
+            headingInteractionEnabled?: boolean;
+            tiltInteractionEnabled?: boolean;
+            renderingType?: RenderingType;
+        }
+    }
+}
 export type GmapGeocoderAddressComponentType = "street_number" | "street_address" | "route" | "intersection" | "political" | "country" | "administrative_area_level_1" | "administrative_area_level_2" | "administrative_area_level_3" | "administrative_area_level_4" | "administrative_area_level_5" | "administrative_area_level_6" | "administrative_area_level_7" | "colloquial_area" | "locality" | "sublocality" | "neighborhood" | "premise" | "subpremise" | "plus_code" | "postal_code" | "natural_feature" | "airport" | "park" | "point_of_interest";

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

@@ -33,7 +33,7 @@ export interface CoordinateZone extends Omit<Zone, "path"> {
 }
 export interface RecommendZonePlaces {
     adsorption?: boolean;
-    force?: boolean;
+    type?: RecommendType;
     available?: boolean;
     zone?: Zone;
     places?: Place[];
@@ -43,14 +43,16 @@ export interface CoordinateRecommendZonePlaces extends Omit<RecommendZonePlaces,
     places?: CoordinatePlace[];
 }
 export interface ValueOfOnChangeRecommendPlace {
+    type: RecommendType;
     place: Place;
     inputPlace: Place;
-    isInZone: boolean;
+    zone?: Zone;
     isSameZone: boolean;
 }
-export interface CoordinateValueOfOnChangeRecommendPlace extends Omit<ValueOfOnChangeRecommendPlace, "place" | "inputPlace"> {
+export interface CoordinateValueOfOnChangeRecommendPlace extends Omit<ValueOfOnChangeRecommendPlace, "place" | "inputPlace" | "zone"> {
     place: CoordinatePlace;
     inputPlace: CoordinatePlace;
+    zone?: CoordinateZone;
 }
 export interface GeoPosition {
     position: Point;
@@ -86,6 +88,7 @@ export interface TrackPoint {
 export interface CoordinateTrackPoint extends TrackPoint {
     type: CoordinateType;
 }
+export type RecommendType = "Restricted" | "Forbidden" | "Recommend";
 export type DriverStatus = "dispatching" | "book-dispatching" | "dispatched" | "driverStartService" | "book-driverStartService" | "book-dispatched" | "driverArrived" | "inService" | "canceled" | "endService" | "completed" | "canceling" | "banlanceRefund" | "waitBanlanceRefund" | "rechargePayed" | "waitRechargePay" | "payed" | "waitpay" | "refund" | "confirmed" | "assign" | "orderReassigned";
 export declare enum CenterPlaceStatus {
     GEO_LOADING = "GEO_LOADING",

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

@@ -1,3 +1,6 @@
 export declare const MANUAL_ABORT_MESSAGE = "MANUAL_ABORT_MESSAGE";
 export declare const throwNoneManualAbortError: (e: unknown) => void;
 export declare const logNoneManualAbortError: (e: unknown) => void;
+export declare const recoverablyIgnoreManualAbortReject: <T>(promise: Promise<T>) => {
+    recover: () => Promise<T>;
+};

package/dist/v3/utils/ManualAbortError.js

@@ -7,8 +7,30 @@ const logNoneManualAbortError = (e) => {
   if (e !== MANUAL_ABORT_MESSAGE)
     console.error(e);
 };
+function recoverablyIgnoreReject(promise, ignoreFilter) {
+  let isValid = true;
+  let error;
+  const ignoredPromise = promise.catch((err) => {
+    if (!isValid || !ignoreFilter(err))
+      throw err;
+    isValid = false;
+    error = err;
+    return void 0;
+  });
+  const recover = () => {
+    if (!isValid)
+      return Promise.reject(error);
+    isValid = false;
+    return ignoredPromise;
+  };
+  return { recover };
+}
+const recoverablyIgnoreManualAbortReject = (promise) => {
+  return recoverablyIgnoreReject(promise, (e) => e === MANUAL_ABORT_MESSAGE);
+};
 export {
   MANUAL_ABORT_MESSAGE,
   logNoneManualAbortError,
+  recoverablyIgnoreManualAbortReject,
   throwNoneManualAbortError
 };

package/dist/v3/utils/log.js

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

package/dist/v3/utils/transform.js

@@ -74,7 +74,7 @@ const isGeoPositionEqual = (p1, p2) => {
   return p1.coords.longitude === p2.coords.longitude && p1.coords.latitude === p2.coords.latitude;
 };
 const isZoneEqual = (z1, z2) => {
-  return z1.path.every((point, idx) => isPointEqual(point, z2 == null ? void 0 : z2.path[idx]));
+  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;

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

@@ -1,5 +1,7 @@
-import type { CoordinatePlace, CoordinatePoint, CoordinateRecommendZonePlaces, CoordinateTrackPoint, CoordinateType, CoordinateZone } from "../types/interface";
+import type { CoordinatePlace, CoordinatePoint, CoordinateRecommendZonePlaces, CoordinateTrackPoint, CoordinateType, CoordinateZone, RecommendType } from "../types/interface";
 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;
 interface MaybeCoordinatePlace {
     displayName?: string;
     name: string;
@@ -20,9 +22,10 @@ interface MaybeCoordinateZone {
     path: MaybeCoordinatePoint[];
 }
 export declare const toCoordinateZoneType: (value?: MaybeCoordinateZone) => CoordinateZone;
+export declare const assertNoConflictTypeAndZone: (type: unknown, zone: unknown) => void;
 interface MaybeCoordinateRecomendZonePlaces {
     adsorption?: boolean;
-    force?: boolean;
+    type?: string;
     available?: boolean;
     zone?: MaybeCoordinateZone;
     places?: MaybeCoordinatePlace[];

package/dist/v3/utils/typeChecking.js

@@ -11,6 +11,16 @@ const createTypeError = (typeName, value, detail) => {
 function isCoordinateType(type) {
   return type === "wgs84" || type === "gcj02" || type === "bd09";
 }
+function isRecommendType(type) {
+  return type === "Recommend" || type === "Restricted" || type === "Forbidden";
+}
+function toRecommendType(type) {
+  if (type === void 0)
+    return "Recommend";
+  if (isRecommendType(type))
+    return type;
+  throw createTypeError("RecommendType", type);
+}
 const toCoordinatePlaceType = (value) => {
   var _a;
   try {
@@ -48,16 +58,31 @@ const toCoordinateZoneType = (value) => {
     const { name = "", path } = value;
     if (!Array.isArray(path))
       throw Error();
-    return { name, path: path.map(toCoordinatePointType) };
+    return { ...value, name, path: path.map(toCoordinatePointType) };
   } catch (err) {
     throw createTypeError("CoordinateZone", value, err == null ? void 0 : err.message);
   }
 };
+const assertNoConflictTypeAndZone = (type, zone) => {
+  if (!!zone && type !== "Restricted" && type !== "Forbidden") {
+    throw Error(
+      `MyTypeError: zone exist, so expected type: Restricted | Forbidden, but received: ${JSON.stringify(
+        type
+      )}`
+    );
+  }
+  if (!zone && (type === "Restricted" || type === "Forbidden")) {
+    throw Error(
+      `MyTypeError: zone not exist, so expected type: Recommend | undefined, but received: ${type}`
+    );
+  }
+};
 const toCoordinateRecommendZonePlacesType = (value) => {
   try {
-    const { force, available, zone, places, adsorption } = value;
+    const { type, available, zone, places, adsorption } = value;
+    assertNoConflictTypeAndZone(type, zone);
     return {
-      force: !!force,
+      type: toRecommendType(type),
       available: !!available,
       zone: zone === void 0 ? void 0 : toCoordinateZoneType(zone),
       places: places === void 0 ? void 0 : places.map(toCoordinatePlaceType),
@@ -81,11 +106,14 @@ const toCoordinateTrackPoint = (value) => {
   return { lng, lat, type, angle, speed, timestamp };
 };
 export {
+  assertNoConflictTypeAndZone,
   isCoordinatePoint,
   isCoordinateType,
+  isRecommendType,
   toCoordinatePlaceType,
   toCoordinatePointType,
   toCoordinateRecommendZonePlacesType,
   toCoordinateTrackPoint,
-  toCoordinateZoneType
+  toCoordinateZoneType,
+  toRecommendType
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heycar/heycars-map",
-  "version": "2.4.6",
+  "version": "2.5.1",
   "type": "module",
   "bin": {
     "checkVersion": "./bin/checkVersion.js",