@heycar/heycars-map 0.3.0 → 0.3.2

package/src/business-components/AbsoluteAddressBox/AbsoluteAddressBox.css.ts

@@ -1,6 +1,7 @@
 import { style } from "@vanilla-extract/css";
 
 export const absoluteAddressBoxLayout = style({
+  pointerEvents: "none",
   position: "absolute",
   bottom: "50%",
   left: 0,
@@ -14,6 +15,7 @@ export const absoluteAddressBoxLayout = style({
 });
 
 export const absoluteAddressBox = style({
+  pointerEvents: "auto",
   padding: "2.67vw 4.27vw",
   background: "linear-gradient(90deg, #79AFFF 0%, #5C8DFF 32%, #507FFF 75%, #4471FF 100%)",
   borderRadius: "3.2vw",

package/src/business-components/AbsoluteAddressBox/AbsoluteAddressBox.tsx

@@ -25,12 +25,14 @@ export const AbsoluteAddressBox = defineSetup(function AbsoluteAddressBox(
       );
     return (
       <div class={css.absoluteAddressBoxLayout}>
-        <div class={css.absoluteAddressBox} onClick={handleClick}>
+        <div class={css.absoluteAddressBox}>
           <div class={css.boxTextLayout}>
-            <div class={css.boxTitle}>{title}</div>
+            <div class={css.boxTitle} onClick={handleClick}>
+              {title}
+            </div>
             {description && <div class={css.boxDescription}>{description}</div>}
           </div>
-          <img class={css.arrowRight} src={imgArrowRight} />
+          <img class={css.arrowRight} src={imgArrowRight} onClick={handleClick} />
         </div>
         <i class={css.straightLine} />
       </div>

package/src/business-components/BusinessRecomendPlaceMap/BusinessRecomendPlaceMap.tsx

@@ -23,6 +23,7 @@ export interface BusinessRecomendPlaceMapProps
   extends Omit<HeycarMapProps, "center" | "zoom" | "mapRef">,
     Pick<UseMapRecomendPlaceProps<CenterPlaceSource>, "getRecomendPlace">,
     MapLogProps {
+  geoLoadingTitle: string;
   unavailableTitle: string;
   recomendDescription: string;
   noRecomendDescription: string;
@@ -33,6 +34,7 @@ export interface BusinessRecomendPlaceMapProps
   onChangeByDrag?: UseMapDragProps["onChange"];
   onChangeGeoLocation?: UseGeoLocationProps["onChange"];
   onChangePlace?: UseMapPlaceProps["onChange"];
+  onChangeCity?: UseMapPlaceProps["onChangeCity"];
   onChangeRecomandPlace?: UseMapRecomendPlaceProps["onChange"];
   onGeoError?: UseGeoLocationProps["onError"];
   onClickLocator?: AbsoluteAddressBoxProps["onClick"];
@@ -47,15 +49,17 @@ export const BusinessRecomendPlaceMap = defineLagecySetup(
       lng: geoDefaultPosition?.[0] ?? 0,
       lat: geoDefaultPosition?.[1] ?? 0,
       name: "",
-      cityName: undefined,
     });
     const centerPoint = computed<Point>(() => [centerPlace.lng, centerPlace.lat]);
     const centerSource: CenterPlaceSource = { source: "geo" };
     const setCenterPlaceByRecomand = (point: Point) => {
       centerSource.source = "api";
-      centerPlace.lng = point[0];
-      centerPlace.lat = point[1];
-      updatePlace();
+      updatePlace(point);
+    };
+    const setCenterPlaceByUserSpecified = (place: Place) => {
+      centerSource.source = "api";
+      setPlace(place);
+      updateRecomandPlace();
     };
     const setCenterByPlace = (place: Place) => {
       centerSource.source = "api";
@@ -64,30 +68,26 @@ export const BusinessRecomendPlaceMap = defineLagecySetup(
       centerPlace.name = place.name;
     };
 
-    const { geoPosition, geoError } = useGeoLocation({
+    const { geoPosition, geoError, geoLoading } = useGeoLocation({
       geoDefaultPosition,
       onLoad: async (value) => {
         // geo 主入口
         await readyPromise;
         centerSource.source = "geo";
-        centerPlace.lng = value.position[0];
-        centerPlace.lat = value.position[1];
-        updatePlace();
+        updatePlace(value.position);
         emit("loadGeoLocation", value);
       },
       onLoadDefault: async (value) => {
         // geo default position 主入口
         await readyPromise;
         centerSource.source = "geo";
-        centerPlace.lng = value.position[0];
-        centerPlace.lat = value.position[1];
-        updatePlace();
+        updatePlace(value.position);
         emit("loadDefaultGeoLocation", value);
       },
       onChange: (v) => emit("changeGeoLocation", v),
       onError: (e) => emit("geoError", e),
     });
-    mapContext.setCenterPlaceByRecomand = setCenterPlaceByRecomand;
+    mapContext.setCenterPlaceByUserSpecified = setCenterPlaceByUserSpecified;
     mapContext.panToGeoPositionByRecomend = () => {
       if (geoError.value) return false;
       setCenterPlaceByRecomand(geoPosition.value);
@@ -97,14 +97,12 @@ export const BusinessRecomendPlaceMap = defineLagecySetup(
       mapRef,
       onChange: (point) => {
         centerSource.source = "drag";
-        centerPlace.lng = point[0];
-        centerPlace.lat = point[1];
-        updatePlace();
+        updatePlace(point);
         emit("changeByDrag", point);
       },
     });
-    const { updatePlace, updateRecomandPlace, placeCandidates, availableRef } = useMapRecomendPlace(
-      {
+    const { updatePlace, setPlace, updateRecomandPlace, placeCandidates, availableRef } =
+      useMapRecomendPlace({
         pointRef: centerPoint,
         context: centerSource,
         getRecomendPlace,
@@ -122,7 +120,6 @@ export const BusinessRecomendPlaceMap = defineLagecySetup(
           }
         },
         onChangePlace: (place) => {
-          Object.assign(centerPlace, { ...place });
           if (centerSource.source !== "recomend") {
             updateRecomandPlace();
           }
@@ -131,11 +128,12 @@ export const BusinessRecomendPlaceMap = defineLagecySetup(
         onChange: (place) => {
           centerSource.source = "recomend";
           Object.assign(centerPlace, { ...place });
-          updatePlace();
           emit("changeRecomandPlace", place);
         },
-      }
-    );
+        onChangeCity: (value) => {
+          emit("changeCity", value);
+        },
+      });
     watchEffect(() => {
       mapContext.onChangeCenterPlace({ ...centerPlace });
     });
@@ -143,6 +141,11 @@ export const BusinessRecomendPlaceMap = defineLagecySetup(
       mapContext.onChangeRecomendPlaces([...placeCandidates.value]);
     });
     return () => {
+      const title = geoLoading.value
+        ? props.geoLoadingTitle
+        : availableRef.value
+        ? centerPlace.name
+        : props.unavailableTitle;
       const description = !availableRef.value
         ? undefined
         : placeCandidates.value.length > 0
@@ -153,7 +156,7 @@ export const BusinessRecomendPlaceMap = defineLagecySetup(
           <PassengerCircle position={geoPosition.value} />
           <PickupPoints places={placeCandidates.value} onClick={setCenterByPlace} log={props.log} />
           <AbsoluteAddressBox
-            title={availableRef.value ? centerPlace.name : props.unavailableTitle}
+            title={title}
             description={description}
             type={isDragging.value ? "locator" : "box"}
             log={props.log}
@@ -165,6 +168,7 @@ export const BusinessRecomendPlaceMap = defineLagecySetup(
   }
 ).props([
   "log",
+  "geoLoadingTitle",
   "unavailableTitle",
   "recomendDescription",
   "noRecomendDescription",

package/src/hooks/useGeoLocation.ts

@@ -10,6 +10,7 @@ export interface UseGeoLocationProps {
 }
 export const useGeoLocation = (props?: UseGeoLocationProps) => {
   const { onChange, onLoad, onLoadDefault, onError, geoDefaultPosition } = props ?? {};
+  let isOnLoadDefaultTriggered = false;
   const loading = ref(false);
   const readyRef = ref(false);
   const errorRef = ref<GeolocationPositionError>();
@@ -44,12 +45,15 @@ export const useGeoLocation = (props?: UseGeoLocationProps) => {
           loading.value = false;
           errorRef.value = error;
           const position = props?.geoDefaultPosition;
-          if (position) onLoadDefault?.({ position });
+          if (position && !isOnLoadDefaultTriggered) {
+            isOnLoadDefaultTriggered = true;
+            onLoadDefault?.({ position });
+          }
           onError?.(error);
           console.log("errorRef = ", errorRef);
         },
         // todo 要不要 timeout
-        { timeout: 5000, maximumAge: 0, enableHighAccuracy: true }
+        { timeout: 3000, maximumAge: 0, enableHighAccuracy: false }
       );
       onCleanup(() => navigator.geolocation.clearWatch(watchId));
     },

package/src/hooks/useMapAutoComplete.ts

@@ -1,20 +1,22 @@
 import { ref, watch } from "vue-demi";
-import type { AutoCompletePlace, City } from "../types/interface";
+import type { AutoCompletePlace, Region } from "../types/interface";
+import { MapLogProps, useMapLogVariable } from "./useMapLog";
 import { useMapSupplier } from "./useMapSupplier";
 import { useUpdate } from "./useUdate";
 
-export interface UseMapAutoCompleteProps {
-  city: City;
+export interface UseMapAutoCompleteProps extends MapLogProps {
+  city: Region;
 }
 
 export const useAmapAutoComplete = (props: UseMapAutoCompleteProps) => {
   const { city } = props;
   const cityRef = ref(city);
+  useMapLogVariable(props, "useAmapAutoComplete", cityRef, "cityRef");
   const { readyPromise } = useMapSupplier();
   const keywordRef = ref("");
   const autoCompletePlacesRef = ref<AutoCompletePlace[]>([]);
   const { update, idx: updateKey } = useUpdate();
-  const setCity = (value: City) => {
+  const setCity = (value: Region) => {
     cityRef.value = value;
     update();
   };
@@ -63,7 +65,7 @@ export const useGmapAutoComplete = (props: UseMapAutoCompleteProps) => {
   const keywordRef = ref("");
   const autoCompletePlacesRef = ref<AutoCompletePlace[]>([]);
   const { update, idx: updateKey } = useUpdate();
-  const setCity = (value: City) => {
+  const setCity = (value: Region) => {
     cityRef.value = value;
     update();
   };

package/src/hooks/useMapCityBound.ts

@@ -1,13 +1,13 @@
 import { reactive, Ref, watch, watchEffect } from "vue-demi";
 import { LANGUAGE } from "../types/helper";
-import type { City } from "../types/interface";
+import type { Region } from "../types/interface";
 import { useMapSupplier } from "./useMapSupplier";
 
 export interface UseMapCityBoundProps {
   cityNameRef: Ref<string | undefined>;
-  onChange?: (value: City) => any;
+  onChange?: (value: Region) => any;
 }
-export const useAmapBoundCity = (props: UseMapCityBoundProps): City => {
+export const useAmapBoundCity = (props: UseMapCityBoundProps): Region => {
   const { cityNameRef, onChange } = props;
   const city = reactive({ name: cityNameRef.value ?? "" });
   watch(
@@ -21,10 +21,10 @@ export const useAmapBoundCity = (props: UseMapCityBoundProps): City => {
   return city;
 };
 
-export const useGmapBoundCity = (props: UseMapCityBoundProps): City => {
+export const useGmapBoundCity = (props: UseMapCityBoundProps): Region => {
   const { cityNameRef, onChange } = props;
   const { readyPromise } = useMapSupplier();
-  const city = reactive<City>({
+  const city = reactive<Region>({
     name: cityNameRef.value ?? "",
     bound: {
       east: 0,

package/src/hooks/useMapDrag.ts

@@ -18,9 +18,12 @@ export const useAmapDrag = (props: UseMapDragProps<AMap.Map>) => {
   const centerRef = ref<Point>([0, 0]);
   const isDragging = ref(false);
   const emitDragStart: SetupContextEmitHandler<Pick<AmapProps, "onDragStart">> = () => {
-    Promise.resolve().then(() => (isDragging.value = true));
+    pipeAsync(() => {
+      isDragging.value = true;
+    });
   };
   const emitDragEnd: SetupContextEmitHandler<Pick<AmapProps, "onDragEnd">> = (_, { target }) => {
+    console.log("on DragEnd ------");
     isDragging.value = false;
     const { lng, lat } = target.getCenter();
     centerRef.value = [lng, lat];
@@ -40,7 +43,9 @@ export const useGmapDrag = (props: UseMapDragProps<google.maps.Map>) => {
   const centerRef = ref<Point>([0, 0]);
   const isDragging = ref(false);
   const emitDragStart: SetupContextEmitHandler<Pick<GmapProps, "onDragStart">> = () => {
-    Promise.resolve().then(() => (isDragging.value = true));
+    pipeAsync(() => {
+      isDragging.value = true;
+    });
   };
   const emitDragEnd: SetupContextEmitHandler<Pick<GmapProps, "onDragEnd">> = async () => {
     isDragging.value = false;

package/src/hooks/useMapLog.ts

@@ -4,9 +4,21 @@ export interface MapLogProps {
   log?: boolean;
 }
 
-export const useMapLog = <P extends MapLogProps>(props: P, name: string) => {
+export const useMapLog = <P extends MapLogProps>(props: P, prefix: string) => {
   watchEffect(() => {
     if (!props.log) return;
-    console.log(`log ${name} props = `, { ...props });
+    console.log(`log ${prefix} props = `, { ...props });
+  });
+};
+
+export const useMapLogVariable = <P extends MapLogProps>(
+  props: P,
+  prefix: string,
+  variable: any,
+  name: string
+) => {
+  watchEffect(() => {
+    if (!props.log) return;
+    console.log(`log ${prefix} ${name} = `, { ...variable });
   });
 };

package/src/hooks/useMapPlace.ts

@@ -1,24 +1,39 @@
-import { reactive, Ref, watch } from "vue-demi";
+import { reactive, ref, Ref, watch } from "vue-demi";
 import { LANGUAGE } from "../types/helper";
 import type { Place, Point } from "../types/interface";
 import { geocoderResult2cityName } from "../utils/transform";
 import { useMapSupplier } from "./useMapSupplier";
 import { useUpdate } from "./useUdate";
 
+export interface UseMapPlaceOnChangeCityProps {
+  cityName?: string;
+  cityParentName?: string;
+}
 export interface UseMapPlaceProps {
   pointRef: Ref<Point>;
   onChange?: (value: Place) => any;
+  onChangeCity?: (value: UseMapPlaceOnChangeCityProps) => any;
 }
 export const useAmapPlace = (props: UseMapPlaceProps) => {
-  const { pointRef, onChange } = props;
+  const { onChange, onChangeCity } = props;
+  const defaultPoint: Point = [...props.pointRef.value];
+  const pointRef = ref<Point>(defaultPoint);
   const { readyPromise } = useMapSupplier();
-  const { idx: placeKey, update: updatePlace } = useUpdate();
   const place = reactive<Place>({
     lng: pointRef.value[0],
     lat: pointRef.value[1],
     name: "",
-    cityName: undefined,
   });
+  const { idx: placeKey, update } = useUpdate();
+  const updatePlace = (value: Point) => {
+    pointRef.value = value;
+    update();
+  };
+  const setPlace = (value: Place) => {
+    place.lng = value.lng;
+    place.lat = value.lat;
+    place.name = value.name;
+  };
   watch(
     () => placeKey.value,
     async () => {
@@ -33,13 +48,12 @@ export const useAmapPlace = (props: UseMapPlaceProps) => {
             const cityName = addressComponent.city
               ? addressComponent.city
               : addressComponent.province;
-            const countryName = addressComponent.country;
+            const cityParentName = addressComponent.province;
             place.name = name;
             place.lng = lng;
             place.lat = lat;
-            place.cityName = cityName;
-            place.countryName = countryName;
-            onChange?.({ lng, lat, name, cityName, countryName });
+            onChange?.({ lng, lat, name });
+            onChangeCity?.({ cityName, cityParentName });
             return;
           }
 
@@ -53,14 +67,23 @@ export const useAmapPlace = (props: UseMapPlaceProps) => {
       });
     }
   );
-  return { place, updatePlace };
+  return { place, updatePlace, setPlace };
 };
 
 export const useGmapPlace = (props: UseMapPlaceProps) => {
-  const { pointRef, onChange } = props;
+  const { pointRef, onChange, onChangeCity } = props;
   const { readyPromise } = useMapSupplier();
   const { idx: placeKey, update: updatePlace } = useUpdate();
-  const place = reactive<Place>({ lng: pointRef.value[0], lat: pointRef.value[1], name: "" });
+  const place = reactive<Place>({
+    lng: pointRef.value[0],
+    lat: pointRef.value[1],
+    name: "",
+  });
+  const setPlace = (value: Place) => {
+    place.lng = value.lng;
+    place.lat = value.lat;
+    place.name = value.name;
+  };
   watch(
     () => placeKey.value,
     async () => {
@@ -70,16 +93,16 @@ export const useGmapPlace = (props: UseMapPlaceProps) => {
       const { results } = await geocoder.geocode({ language: LANGUAGE, location: { lng, lat } });
       const name = results[0].formatted_address;
       const cityName = geocoderResult2cityName(results[0]);
-      const countryName = results.slice(-1)[0].address_components[0].long_name;
+      const cityParentName = results.slice(-2)[0].address_components[0].long_name;
+      // const countryName = results.slice(-1)[0].address_components[0].long_name;
       place.lng = lng;
       place.lat = lat;
       place.name = name;
-      place.cityName = cityName;
-      place.countryName = countryName;
-      onChange?.({ lng, lat, name, cityName, countryName });
+      onChange?.({ lng, lat, name });
+      onChangeCity?.({ cityName, cityParentName });
     }
   );
-  return { place, updatePlace };
+  return { place, updatePlace, setPlace };
 };
 
 export const useMapPlace = (props: UseMapPlaceProps) => {

package/src/hooks/useMapRecomendPlace.ts

@@ -35,16 +35,22 @@ export interface UseMapRecomendPlaceProps<C = Record<string, any>> {
   getLimit: (context?: C) => number;
   // 如果返回 undefined, 表示当前位置无服务可提供
   getRecomendPlace: (place: Place, context?: C) => Promise<Place[] | undefined>;
+  onChangeCity?: UseMapPlaceProps["onChangeCity"];
   onChangePlace?: UseMapPlaceProps["onChange"];
   onChange?: (place: Place) => any;
 }
 export const useAmapRecomendPlace = <C>(props: UseMapRecomendPlaceProps<C>) => {
-  const { pointRef, getRecomendPlace, getLimit, context, onChange, onChangePlace } = props;
+  const { pointRef, getRecomendPlace, getLimit, context, onChange, onChangePlace, onChangeCity } =
+    props;
   const availableRef = ref(true);
   const placeCandidatesRef = ref<Place[]>([]);
   const { idx: recomendPlaceKey, update: updateRecomandPlace } = useUpdate();
   const { readyPromise } = useMapSupplier();
-  const { place, updatePlace } = useAmapPlace({ pointRef, onChange: onChangePlace });
+  const { place, updatePlace, setPlace } = useAmapPlace({
+    pointRef,
+    onChange: onChangePlace,
+    onChangeCity,
+  });
   const recomendPlace = reactive<Place>({ ...place });
   watch(
     () => recomendPlaceKey.value,
@@ -73,16 +79,22 @@ export const useAmapRecomendPlace = <C>(props: UseMapRecomendPlaceProps<C>) => {
     availableRef,
     updateRecomandPlace,
     updatePlace,
+    setPlace,
   };
 };
 
 export const useGmapRecomendPlace = <C>(props: UseMapRecomendPlaceProps<C>) => {
-  const { pointRef, getRecomendPlace, getLimit, context, onChange, onChangePlace } = props;
+  const { pointRef, getRecomendPlace, getLimit, context, onChange, onChangePlace, onChangeCity } =
+    props;
   const availableRef = ref(true);
   const placeCandidatesRef = ref<Place[]>([]);
   const { idx: recomendPlaceKey, update: updateRecomandPlace } = useUpdate();
   const { readyPromise } = useMapSupplier();
-  const { place, updatePlace } = useGmapPlace({ pointRef, onChange: onChangePlace });
+  const { place, updatePlace, setPlace } = useGmapPlace({
+    pointRef,
+    onChange: onChangePlace,
+    onChangeCity,
+  });
   const recomendPlace = reactive<Place>({ ...place });
   watch(
     () => recomendPlaceKey.value,
@@ -111,6 +123,7 @@ export const useGmapRecomendPlace = <C>(props: UseMapRecomendPlaceProps<C>) => {
     availableRef,
     updateRecomandPlace,
     updatePlace,
+    setPlace,
   };
 };
 

package/src/hooks-business/useBusinessMapAutoComplete.ts

@@ -1,8 +1,9 @@
 import type { Ref } from "vue-demi";
 import { useMapAutoComplete } from "../hooks/useMapAutoComplete";
 import { useMapBoundCity } from "../hooks/useMapCityBound";
+import type { MapLogProps } from "../hooks/useMapLog";
 
-export interface UseBusinessMapAutoCompleteProps {
+export interface UseBusinessMapAutoCompleteProps extends MapLogProps {
   cityNameRef: Ref<string>;
 }
 
@@ -12,7 +13,7 @@ export const useBusinessMapAutoComplete = (props: UseBusinessMapAutoCompleteProp
     cityNameRef,
     onChange: (v) => setCity(v),
   });
-  const { autoCompletePlaces, setKeyword, setCity } = useMapAutoComplete({ city });
+  const { autoCompletePlaces, setKeyword, setCity } = useMapAutoComplete({ city, log: props.log });
   const handleKeywordInput = (e: Event) => {
     const target = e.target as HTMLInputElement;
     setKeyword(target.value);

package/src/hooks-business/useBusinessRecomendPlaceMap.ts

@@ -4,7 +4,7 @@ import type { Place, Point } from "../types/interface";
 
 export interface BusinessRecomendPlaceContext {
   panToGeoPositionByRecomend: (value: Point) => void;
-  setCenterPlaceByRecomand: (value: Point) => void;
+  setCenterPlaceByUserSpecified: (value: Place) => void;
   onChangeCenterPlace: (value: Place) => void;
   onChangeRecomendPlaces: (value: Place[]) => void;
 }
@@ -14,17 +14,17 @@ export const useBusinessRecomendPlaceMap = () => {
     lng: 0,
     lat: 0,
     name: "",
-    cityName: undefined,
   });
   const placeCandidates = ref<Place[]>([]);
   const { apiMapDistance } = useMapGeometry();
   const panToGeoPositionByRecomend = (value: Point) => mapContext.panToGeoPositionByRecomend(value);
-  const setCenterPlaceByRecomand = (value: Point) => mapContext.setCenterPlaceByRecomand(value);
+  const setCenterPlaceByUserSpecified = (value: Place) =>
+    mapContext.setCenterPlaceByUserSpecified(value);
   const mapContext: BusinessRecomendPlaceContext = {
     panToGeoPositionByRecomend: () => {
       throw new Error("MyError: panToGeoPositionByRecomend used before assigned");
     },
-    setCenterPlaceByRecomand: () => {
+    setCenterPlaceByUserSpecified: () => {
       throw new Error("MyError: setCenterPlaceByRecomand used before assigned");
     },
     onChangeCenterPlace: (place: Place) => {
@@ -39,7 +39,7 @@ export const useBusinessRecomendPlaceMap = () => {
     centerPlace,
     placeCandidates,
     panToGeoPositionByRecomend,
-    setCenterPlaceByRecomand,
+    setCenterPlaceByUserSpecified,
     apiMapDistance,
   };
 };

package/src/types/interface.ts

@@ -7,6 +7,7 @@ export type Place = {
   lat: number;
   name: string;
   cityName?: string;
+  cityParentName?: string;
   countryName?: string;
 };
 
@@ -15,7 +16,7 @@ export interface AutoCompletePlace extends Place {
   description: string;
 }
 
-export type City = {
+export type Region = {
   bound?: {
     east: number;
     north: number;

package/dist/hooks-business/useLagecyMapRecomendPlace.d.ts

@@ -1,55 +0,0 @@
-import { UseGeoLocationProps } from "../hooks/useGeoLocation";
-import { UseMapDragProps } from "../hooks/useMapDrag";
-import type { UseMapPlaceProps } from "../hooks/useMapPlace";
-import { UseMapRecomendPlaceProps } from "../hooks/useMapRecomendPlace";
-import type { MapShallowRef, Place, Point } from "../types/interface";
-interface CenterPlaceSource {
-    source: "default" | "geo" | "drag" | "recomend" | "api";
-}
-export interface UseLagecyMapRecomendPlace extends Pick<UseMapRecomendPlaceProps<CenterPlaceSource>, "getRecomendPlace"> {
-    mapRef: MapShallowRef;
-    defaultCenterPoint?: Point;
-    geoDefaultPosition?: Point;
-    recomendPlaceGeoLimit: number;
-    recomendPlaceDragLimit: number;
-    onLoadGeoLocation?: UseGeoLocationProps["onLoad"];
-    onLoadDefaultGeoLocation?: UseGeoLocationProps["onLoadDefault"];
-    onChangeByDrag?: UseMapDragProps["onChange"];
-    onChangeGeoLocation?: UseGeoLocationProps["onChange"];
-    onChangePlace?: UseMapPlaceProps["onChange"];
-    onChangeRecomandPlace?: UseMapRecomendPlaceProps["onChange"];
-}
-export declare const useLagecyMapRecomendPlace: (props: UseLagecyMapRecomendPlace) => {
-    isDragging: import("vue-demi").Ref<boolean>;
-    geoLoading: import("vue-demi").Ref<boolean>;
-    geoError: import("vue-demi").Ref<GeolocationPositionError | undefined>;
-    geoPosition: import("vue-demi").Ref<[number, number]>;
-    geoCoordinate: import("vue-demi").Ref<{
-        readonly accuracy: number;
-        readonly altitude: number | null;
-        readonly altitudeAccuracy: number | null;
-        readonly heading: number | null;
-        readonly latitude: number;
-        readonly longitude: number;
-        readonly speed: number | null;
-    }>;
-    geoReady: import("vue-demi").Ref<boolean>;
-    centerPlace: {
-        lng: number;
-        lat: number;
-        name: string;
-        cityName?: string | undefined;
-        countryName?: string | undefined;
-    };
-    centerPoint: import("vue-demi").ComputedRef<Point>;
-    placeCandidates: import("vue-demi").Ref<{
-        lng: number;
-        lat: number;
-        name: string;
-        cityName?: string | undefined;
-        countryName?: string | undefined;
-    }[]>;
-    setCenterPlaceByRecomand: (point: Point) => void;
-    setCenterByPlace: (place: Place) => void;
-};
-export {};