@heycar/heycars-map 0.3.6 → 0.3.8

package/src/hooks/useMapPlace.ts

@@ -1,130 +0,0 @@
-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 { onChange, onChangeCity } = props;
-  const defaultPoint: Point = [...props.pointRef.value];
-  const pointRef = ref<Point>(defaultPoint);
-  const { readyPromise } = useMapSupplier();
-  const place = reactive<Place>({
-    lng: pointRef.value[0],
-    lat: pointRef.value[1],
-    name: "",
-  });
-  const { idx: placeKey, update } = useUpdate();
-  const updateCity = (value: Place) => {
-    const geocoder = new AMap.Geocoder({ lang: LANGUAGE });
-    const { lng, lat } = value;
-    geocoder.getAddress(new AMap.LngLat(lng, lat), (status, result) => {
-      if (status !== "complete") return;
-      const { addressComponent } = (result as AMap.ReGeocoderResult).regeocode;
-      const cityName = addressComponent.city ? addressComponent.city : addressComponent.province;
-      const cityParentName = addressComponent.province;
-      onChangeCity?.({ cityName, cityParentName });
-    });
-  };
-  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 () => {
-      await readyPromise;
-      const geocoder = new AMap.Geocoder({ lang: LANGUAGE });
-      const [lng, lat] = pointRef.value;
-      geocoder.getAddress(new AMap.LngLat(lng, lat), (status, result) => {
-        switch (status) {
-          case "complete": {
-            const { formattedAddress: name, addressComponent } = (result as AMap.ReGeocoderResult)
-              .regeocode;
-            const cityName = addressComponent.city
-              ? addressComponent.city
-              : addressComponent.province;
-            const cityParentName = addressComponent.province;
-            place.name = name;
-            place.lng = lng;
-            place.lat = lat;
-            onChange?.({ lng, lat, name });
-            onChangeCity?.({ cityName, cityParentName });
-            return;
-          }
-
-          case "no_data":
-            place.name = "";
-            onChange?.({ lng, lat, name: "" });
-            return;
-          case "error":
-            throw result;
-        }
-      });
-    }
-  );
-  return { place, updatePlace, setPlace, updateCity };
-};
-
-export const useGmapPlace = (props: UseMapPlaceProps) => {
-  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 setPlace = (value: Place) => {
-    place.lng = value.lng;
-    place.lat = value.lat;
-    place.name = value.name;
-  };
-  const updateCity = async (value: Place) => {
-    const geocoder = new google.maps.Geocoder();
-    const { lng, lat } = value;
-    const { results } = await geocoder.geocode({ language: LANGUAGE, location: { lng, lat } });
-    const cityName = geocoderResult2cityName(results[0]);
-    const cityParentName = results.slice(-2)[0].address_components[0].long_name;
-    onChangeCity?.({ cityName, cityParentName });
-  };
-  watch(
-    () => placeKey.value,
-    async () => {
-      await readyPromise;
-      const geocoder = new google.maps.Geocoder();
-      const [lng, lat] = pointRef.value;
-      const { results } = await geocoder.geocode({ language: LANGUAGE, location: { lng, lat } });
-      const name = results[0].formatted_address;
-      const cityName = geocoderResult2cityName(results[0]);
-      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;
-      onChange?.({ lng, lat, name });
-      onChangeCity?.({ cityName, cityParentName });
-    }
-  );
-  return { place, updatePlace, setPlace, updateCity };
-};
-
-export const useMapPlace = (props: UseMapPlaceProps) => {
-  const { supplier } = useMapSupplier();
-  return supplier === "gmap" ? useGmapPlace(props) : useAmapPlace(props);
-};

package/src/hooks/useMapRecomendPlace.ts

@@ -1,150 +0,0 @@
-import { computed, reactive, ref, Ref, watch } from "vue-demi";
-import type { Place, Point } from "../types/interface";
-
-import { isPointEqual, place2point } from "../utils/transform";
-import { useAmapPlace, useGmapPlace, UseMapPlaceProps } from "./useMapPlace";
-import { useMapSupplier } from "./useMapSupplier";
-import { useUpdate } from "./useUdate";
-
-const findAmapNearestPlace = (place: Place, candidates: Place[]) => {
-  let shortestDistance = Infinity;
-  let shortestPlace = place;
-  for (const candidate of candidates) {
-    const distance = AMap.GeometryUtil.distance(place2point(place), place2point(candidate));
-    if (distance >= shortestDistance) continue;
-    shortestPlace = candidate;
-    shortestDistance = distance;
-  }
-  return { shortestPlace, shortestDistance };
-};
-
-const findGmapNearestPlace = (place: Place, candidates: Place[]) => {
-  let shortestDistance = Infinity;
-  let shortestPlace = place;
-  for (const candidate of candidates) {
-    const distance = google.maps.geometry.spherical.computeDistanceBetween(place, candidate);
-    if (distance >= shortestDistance) continue;
-    shortestPlace = candidate;
-    shortestDistance = distance;
-  }
-  return { shortestPlace, shortestDistance };
-};
-
-export interface UseMapRecomendPlaceProps<C = Record<string, any>> {
-  pointRef: Ref<Point>;
-  context?: C;
-  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, onChangeCity } =
-    props;
-  const availableRef = ref(true);
-  const placeCandidatesRef = ref<Place[]>([]);
-  const { idx: recomendPlaceKey, update: updateRecomandPlace } = useUpdate();
-  const { readyPromise } = useMapSupplier();
-  const { place, updatePlace, setPlace, updateCity } = useAmapPlace({
-    pointRef,
-    onChange: onChangePlace,
-    onChangeCity,
-  });
-  const recomendPlace = reactive<Place>({ ...place });
-  const isElectedRef = computed(() => {
-    const point = pointRef.value;
-    return placeCandidatesRef.value.some((candidate) =>
-      isPointEqual(place2point(candidate), point)
-    );
-  });
-  watch(
-    () => recomendPlaceKey.value,
-    async () => {
-      await readyPromise;
-      const placeCandidates = await getRecomendPlace({ ...place }, context);
-      if (placeCandidates === undefined) {
-        availableRef.value = false;
-        placeCandidatesRef.value = [];
-        Object.assign(recomendPlace, { ...place });
-        onChange?.({ ...place });
-        return;
-      }
-      const { shortestPlace, shortestDistance } = findAmapNearestPlace(place, placeCandidates);
-      const limit = getLimit(context);
-      const resultPlace = shortestDistance > limit ? place : shortestPlace;
-      availableRef.value = true;
-      placeCandidatesRef.value = placeCandidates;
-      Object.assign(recomendPlace, { ...resultPlace });
-      onChange?.({ ...resultPlace });
-    }
-  );
-  return {
-    recomendPlace,
-    placeCandidates: placeCandidatesRef,
-    availableRef,
-    isElectedRef,
-    updateRecomandPlace,
-    updatePlace,
-    setPlace,
-    updateCity,
-  };
-};
-
-export const useGmapRecomendPlace = <C>(props: UseMapRecomendPlaceProps<C>) => {
-  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, setPlace, updateCity } = useGmapPlace({
-    pointRef,
-    onChange: onChangePlace,
-    onChangeCity,
-  });
-  const recomendPlace = reactive<Place>({ ...place });
-  const isElectedRef = computed(() => {
-    const point = pointRef.value;
-    return placeCandidatesRef.value.some((candidate) =>
-      isPointEqual(place2point(candidate), point)
-    );
-  });
-  watch(
-    () => recomendPlaceKey.value,
-    async () => {
-      await readyPromise;
-      const placeCandidates = await getRecomendPlace({ ...place }, context);
-      if (placeCandidates === undefined) {
-        availableRef.value = false;
-        placeCandidatesRef.value = [];
-        Object.assign(recomendPlace, { ...place });
-        onChange?.({ ...place });
-        return;
-      }
-      const { shortestPlace, shortestDistance } = findGmapNearestPlace(place, placeCandidates);
-      const limit = getLimit(context);
-      const resultPlace = shortestDistance > limit ? place : shortestPlace;
-      availableRef.value = true;
-      placeCandidatesRef.value = placeCandidates;
-      Object.assign(recomendPlace, { ...resultPlace });
-      onChange?.({ ...resultPlace });
-    }
-  );
-  return {
-    recomendPlace,
-    placeCandidates: placeCandidatesRef,
-    availableRef,
-    isElectedRef,
-    updateRecomandPlace,
-    updatePlace,
-    setPlace,
-    updateCity,
-  };
-};
-
-export const useMapRecomendPlace = <C>(props: UseMapRecomendPlaceProps<C>) => {
-  const { supplier } = useMapSupplier();
-  return supplier === "gmap" ? useGmapRecomendPlace(props) : useAmapRecomendPlace(props);
-};

package/src/hooks/useMapSupplier.ts

@@ -1,16 +0,0 @@
-import { inject, provide } from "vue-demi";
-import type { Status, UseMapLoaderOutput, UseMapLoaderProps } from "./useMapLoader";
-
-export interface MapSupplierPayolad extends UseMapLoaderProps {
-  gmapId: string;
-  readyPromise: UseMapLoaderOutput["readyPromise"];
-  status: Status;
-}
-const context = Symbol();
-
-export const useMapSupplier = () => {
-  const payload = inject<MapSupplierPayolad>(context);
-  if (!payload) throw new Error("MyError: useMapSupplier should be under MapProvider");
-  return payload;
-};
-export const provideMapSupplier = (payload: MapSupplierPayolad) => provide(context, payload);

package/src/hooks/useOverlay.ts

@@ -1,23 +0,0 @@
-import { ShallowRef, watch } from "vue-demi";
-import type { RegisterOverlay } from "../types/interface";
-
-export type MROP = MapRegisterOverlayProps<AmapOverlay> | MapRegisterOverlayProps<GmapOverlay>;
-export interface MapRegisterOverlayProps<T> {
-  registerOverlay?: RegisterOverlay<T>;
-}
-export type AmapOverlay = Parameters<AMap.OverlayGroup["addOverlay"]>[0];
-export type GmapOverlay = google.maps.Marker | google.maps.marker.AdvancedMarkerView;
-export interface UseMapOverlayProps<T> extends MapRegisterOverlayProps<T> {
-  overlayRef: ShallowRef<T | undefined>;
-}
-export const useMapOverlay = <T>(props: UseMapOverlayProps<T>) => {
-  const { registerOverlay, overlayRef } = props;
-  watch(
-    () => overlayRef.value,
-    (overlay, prevOverlay) => {
-      if (!registerOverlay) return;
-      if (prevOverlay) registerOverlay.remove(prevOverlay);
-      if (overlay) registerOverlay.add(overlay);
-    }
-  );
-};

package/src/hooks/usePlacesLabelDirection.ts

@@ -1,61 +0,0 @@
-import { ref } from "vue-demi";
-import type { Place, Point } from "../types/interface";
-import { watchEffectForDeepOption } from "../utils/compare";
-import { place2point } from "../utils/transform";
-import { useMapLngLatToVw } from "./useMapLngLatToVw";
-
-type LabelDirection = "left" | "right";
-const reverse = (direction: LabelDirection) => (direction === "left" ? "right" : "left");
-
-export interface UsePointsLabelDirectionProps {
-  places: Place[];
-  widthLimit: number;
-  heightLimit: number;
-}
-export const usePointsLabelDirection = (props: UsePointsLabelDirectionProps) => {
-  const { widthLimit, heightLimit } = props;
-  const { apiMapLngLatToVw } = useMapLngLatToVw();
-  const diffVw = (from: Point, to: Point) => {
-    const vw = 100 / window.innerWidth;
-    const [x1, y1] = apiMapLngLatToVw(from);
-    const [x2, y2] = apiMapLngLatToVw(to);
-    return [(x2 - x1) * vw, (y2 - y1) * vw];
-  };
-  const directionsRef = ref<LabelDirection[]>(Array(props.places.length).fill("right"));
-  watchEffectForDeepOption(
-    () => props.places.map(place2point),
-    (points) => {
-      const sortedPoints = points
-        .map((point, index) => ({ point, index }))
-        .sort(({ point: [, lat1] }, { point: [, lat2] }) =>
-          lat1 < lat2 ? 1 : lat1 > lat2 ? -1 : 0
-        );
-      const len = points.length;
-      const result: LabelDirection[] = Array(len);
-      let prevDirection: LabelDirection = "right";
-      let isLimited = false;
-      for (let idx = 0; idx < len; idx++) {
-        const { index } = sortedPoints[idx];
-        if (idx === len - 1) {
-          result[index] = isLimited ? reverse(prevDirection) : "right";
-          continue;
-        }
-        if (idx === 0) {
-          const [dx, dy] = diffVw(sortedPoints[idx].point, sortedPoints[idx + 1].point);
-          isLimited = dx > -widthLimit && dx < widthLimit && dy > -heightLimit && dy < heightLimit;
-          const direction: LabelDirection = !isLimited ? "right" : dx > 0 ? "left" : "right";
-          result[index] = direction;
-          prevDirection = direction;
-          continue;
-        }
-        const [dx, dy] = diffVw(sortedPoints[idx].point, sortedPoints[idx + 1].point);
-        const direction: LabelDirection = isLimited ? reverse(prevDirection) : "right";
-        result[index] = direction;
-        prevDirection = direction;
-        isLimited = dx > -widthLimit && dx < widthLimit && dy > -heightLimit && dy < heightLimit;
-      }
-      directionsRef.value = result;
-    }
-  );
-  return directionsRef;
-};

package/src/hooks/useUdate.ts

@@ -1,9 +0,0 @@
-import { ref } from "vue-demi";
-
-export const useUpdate = () => {
-  const idx = ref(0);
-  const update = () => {
-    idx.value += 1;
-  };
-  return { idx, update };
-};

package/src/hooks/useWaitTimer.ts

@@ -1,25 +0,0 @@
-interface TimerStop {
-  promise: Promise<void>;
-  resolve?: () => void;
-}
-
-export interface UseWaitTimerProps {
-  interval: number;
-}
-export const useWaitTimer = (props: UseWaitTimerProps) => {
-  const { interval } = props;
-  let timer: number | undefined = undefined;
-  const timerStop: TimerStop = {
-    promise: Promise.resolve(),
-    resolve: undefined,
-  };
-  const timerStart = () => {
-    if (timer) clearTimeout(timer);
-    timerStop.resolve?.();
-    timerStop.promise = new Promise((resolve) => {
-      timerStop.resolve = resolve;
-      timer = setTimeout(resolve, interval);
-    });
-  };
-  return { timerStart, timerStop };
-};

package/src/hooks/useWalkingRoute.ts

@@ -1,87 +0,0 @@
-import { ShallowRef, shallowRef } from "vue-demi";
-import type { Point } from "../types/interface";
-import { watchPostEffectForDeepOption } from "../utils/compare";
-import { useMapSupplier } from "./useMapSupplier";
-
-export interface UseWalkingRouteProps {
-  from: Point;
-  to: Point;
-}
-
-export const useAWalkingRoute = (props: UseWalkingRouteProps) => {
-  const pathRef = shallowRef<Point[]>([]);
-  const amapWalking = new AMap.Walking({});
-  watchPostEffectForDeepOption(
-    () => ({ ...props }),
-    ({ from, to }) => {
-      amapWalking.search(AMap.LngLat.from(from), AMap.LngLat.from(to), (status, result) => {
-        switch (status) {
-          case "complete": {
-            let path: Point[] = [];
-            const walkingResult = result as AMap.WalkingResult;
-            if (!walkingResult.routes) {
-              return;
-            }
-            const firstRoute = walkingResult.routes[0];
-            for (const step of firstRoute.steps) {
-              const stepPath = step.path.map<Point>(({ lng, lat }) => [lng, lat]);
-              path = path.concat(stepPath);
-            }
-            pathRef.value = path;
-            return;
-          }
-          case "no_data":
-            pathRef.value = [];
-            return;
-          default:
-            throw result;
-        }
-      });
-    }
-  );
-  return pathRef;
-};
-
-export const useGWalkingRoute = (props: UseWalkingRouteProps) => {
-  const pathRef = shallowRef<Point[]>([]);
-  const gmapDirectionsService = new google.maps.DirectionsService();
-  watchPostEffectForDeepOption(
-    () => ({ ...props }),
-    ({ from, to }) => {
-      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 google.maps.DirectionsStatus.OK: {
-              let path: Point[] = [];
-              const firstRoute = result!.routes[0];
-              const stepPath = firstRoute.overview_path.map<Point>((item) => [
-                item.lng(),
-                item.lat(),
-              ]);
-              path = path.concat(stepPath);
-              pathRef.value = path;
-              return;
-            }
-            case google.maps.DirectionsStatus.ZERO_RESULTS:
-            case google.maps.DirectionsStatus.NOT_FOUND:
-              pathRef.value = [];
-              return;
-            default:
-              throw new Error(status);
-          }
-        }
-      );
-    }
-  );
-  return pathRef;
-};
-
-export const useWalkingRoute = (props: UseWalkingRouteProps): ShallowRef<Point[]> => {
-  const { supplier } = useMapSupplier();
-  return supplier === "gmap" ? useGWalkingRoute(props) : useAWalkingRoute(props);
-};

package/src/hooks-business/useBusinessMapAutoComplete.ts

@@ -1,22 +0,0 @@
-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 extends MapLogProps {
-  cityNameRef: Ref<string>;
-}
-
-export const useBusinessMapAutoComplete = (props: UseBusinessMapAutoCompleteProps) => {
-  const { cityNameRef } = props;
-  const city = useMapBoundCity({
-    cityNameRef,
-    onChange: (v) => setCity(v),
-  });
-  const { autoCompletePlaces, setKeyword, setCity } = useMapAutoComplete({ city, log: props.log });
-  const handleKeywordInput = (e: Event) => {
-    const target = e.target as HTMLInputElement;
-    setKeyword(target.value);
-  };
-  return { autoCompletePlaces, setKeyword, setCity, handleKeywordInput };
-};

package/src/hooks-business/useBusinessQuotingMap.ts

@@ -1,11 +0,0 @@
-import { useHeycarMap } from "../hooks/useHeycarMap";
-import { useMapFitView } from "../hooks/useMapFitView";
-
-export const useBusinessQuotingMap = () => {
-  const { setMap, mapRef } = useHeycarMap();
-  const { registerFitVeiw, setFitView } = useMapFitView({
-    mapRef,
-    padding: [25, 20, 15, 15],
-  });
-  return { setMap, registerFitVeiw, setFitView };
-};

package/src/hooks-business/useBusinessRecomendPlaceMap.ts

@@ -1,45 +0,0 @@
-import { reactive, ref } from "vue-demi";
-import { useMapGeometry } from "../hooks/useMapGeometry";
-import type { Place, Point } from "../types/interface";
-
-export interface BusinessRecomendPlaceContext {
-  panToGeoPositionByRecomend: (value: Point) => void;
-  setCenterPlaceByUserSpecified: (value: Place) => void;
-  onChangeCenterPlace: (value: Place) => void;
-  onChangeRecomendPlaces: (value: Place[]) => void;
-}
-
-export const useBusinessRecomendPlaceMap = () => {
-  const centerPlace = reactive<Place>({
-    lng: 0,
-    lat: 0,
-    name: "",
-  });
-  const placeCandidates = ref<Place[]>([]);
-  const { apiMapDistance } = useMapGeometry();
-  const panToGeoPositionByRecomend = (value: Point) => mapContext.panToGeoPositionByRecomend(value);
-  const setCenterPlaceByUserSpecified = (value: Place) =>
-    mapContext.setCenterPlaceByUserSpecified(value);
-  const mapContext: BusinessRecomendPlaceContext = {
-    panToGeoPositionByRecomend: () => {
-      throw new Error("MyError: panToGeoPositionByRecomend used before assigned");
-    },
-    setCenterPlaceByUserSpecified: () => {
-      throw new Error("MyError: setCenterPlaceByRecomand used before assigned");
-    },
-    onChangeCenterPlace: (place: Place) => {
-      Object.assign(centerPlace, { ...place });
-    },
-    onChangeRecomendPlaces: (places: Place[]) => {
-      placeCandidates.value = [...places];
-    },
-  };
-  return {
-    mapContext,
-    centerPlace,
-    placeCandidates,
-    panToGeoPositionByRecomend,
-    setCenterPlaceByUserSpecified,
-    apiMapDistance,
-  };
-};

package/src/hooks-business/useBusinessTaxiServiceMap.ts

@@ -1,12 +0,0 @@
-import { useHeycarMap } from "../hooks/useHeycarMap";
-import { useMapFitView } from "../hooks/useMapFitView";
-
-export const useBusinessTaxiServiceMap = () => {
-  const { mapRef, setMap } = useHeycarMap();
-  const { registerFitVeiw, setFitView } = useMapFitView({
-    mapRef,
-    autoFitTimeout: 5000,
-    padding: [25, 20, 15, 15],
-  });
-  return { setMap, registerFitVeiw, setFitView };
-};

package/src/index.ts

@@ -1,33 +0,0 @@
-import "./style.css";
-export { AbsoluteAddressBox } from "./business-components/AbsoluteAddressBox";
-export { AddressBox } from "./business-components/AddressBox";
-export { BusinessQuotingMap } from "./business-components/BusinessQuotingMap";
-export { BusinessRecomendPlaceMap } from "./business-components/BusinessRecomendPlaceMap";
-export { BusinessTaxiEndMap } from "./business-components/BusinessTaxiEndMap";
-export { BusinessTaxiServiceMap } from "./business-components/BusinessTaxiServiceMap";
-export { DrivingLine } from "./business-components/DrivingLine";
-export { DrivingRoute } from "./business-components/DrivingRoute";
-export { PassengerCircle } from "./business-components/PassengerCircle";
-export { PickupPoints } from "./business-components/PickupPoints";
-export { PlaceCircle } from "./business-components/PlaceCircle";
-export { StartEndPoint } from "./business-components/StartEndPoint";
-export { TaxiCar } from "./business-components/TaxiCar";
-export { WalkingLine } from "./business-components/WalkingLine";
-export { WalkingRoute } from "./business-components/WalkingRoute";
-export { WaveCircle } from "./business-components/WaveCircle";
-export * from "./components/MapProvider";
-export * from "./hooks-business/useBusinessMapAutoComplete";
-export * from "./hooks-business/useBusinessQuotingMap";
-export * from "./hooks-business/useBusinessRecomendPlaceMap";
-export * from "./hooks-business/useBusinessTaxiServiceMap";
-export { useDrivingRoute } from "./hooks/useDrivingRoute";
-export { useGeoLocation } from "./hooks/useGeoLocation";
-export { useHeycarMap } from "./hooks/useHeycarMap";
-export { useMapAngle } from "./hooks/useMapAngle";
-export { useMapDrag } from "./hooks/useMapDrag";
-export { useMapFitView } from "./hooks/useMapFitView";
-export { useMapGeometry } from "./hooks/useMapGeometry";
-export { useMapPlace } from "./hooks/useMapPlace";
-export { useMapRecomendPlace } from "./hooks/useMapRecomendPlace";
-export { useWalkingRoute } from "./hooks/useWalkingRoute";
-export * from "./types/interface";

package/src/main.ts

@@ -1,6 +0,0 @@
-import { createApp } from "vue-demi";
-
-import { App } from "./App";
-import "./style.css";
-
-createApp(App).mount("#app");