@heycar/heycars-map 0.3.7 → 0.3.8

package/src/hooks/useMapAutoComplete.ts

@@ -1,130 +0,0 @@
-import { ref, watch } from "vue-demi";
-import type { AutoCompletePlace, Region } from "../types/interface";
-import { useGeoLocation } from "./useGeoLocation";
-import { useMapGeometry } from "./useMapGeometry";
-import { MapLogProps, useMapLogVariable } from "./useMapLog";
-import { useMapSupplier } from "./useMapSupplier";
-import { useUpdate } from "./useUdate";
-
-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 { apiMapDistance } = useMapGeometry();
-  const { geoPosition } = useGeoLocation();
-  const keywordRef = ref("");
-  const autoCompletePlacesRef = ref<AutoCompletePlace[]>([]);
-  const { update, idx: updateKey } = useUpdate();
-  const setCity = (value: Region) => {
-    cityRef.value = value;
-    update();
-  };
-  const setKeyword = (value: string) => {
-    keywordRef.value = value;
-    update();
-  };
-  watch(
-    () => updateKey.value,
-    async () => {
-      if (!keywordRef.value) return;
-      await readyPromise;
-      const amapPlaceSearch = new AMap.PlaceSearch({ city: cityRef.value.name });
-      amapPlaceSearch.search(keywordRef.value, (status, result) => {
-        const from = geoPosition.value;
-        switch (status) {
-          case "complete": {
-            autoCompletePlacesRef.value = (result as AMap.PlaceSearchResult).poiList.pois.map(
-              (poi) => {
-                const { lat, lng } = poi.location;
-                return {
-                  lat,
-                  lng,
-                  name: poi.name,
-                  description: poi.address,
-                  distance: from ? apiMapDistance(from, [lng, lat]) : undefined,
-                };
-              }
-            );
-            return;
-          }
-          case "no_data":
-            autoCompletePlacesRef.value = [];
-            return;
-          default:
-            throw result;
-        }
-      });
-    },
-    {
-      immediate: true,
-    }
-  );
-  return { setKeyword, setCity, autoCompletePlaces: autoCompletePlacesRef };
-};
-
-export const useGmapAutoComplete = (props: UseMapAutoCompleteProps) => {
-  const { city } = props;
-  const cityRef = ref({ ...city });
-  const { readyPromise } = useMapSupplier();
-  const { apiMapDistance } = useMapGeometry();
-  const { geoPosition } = useGeoLocation();
-  const keywordRef = ref("");
-  const autoCompletePlacesRef = ref<AutoCompletePlace[]>([]);
-  const { update, idx: updateKey } = useUpdate();
-  const setCity = (value: Region) => {
-    cityRef.value = value;
-    update();
-  };
-  const setKeyword = (value: string) => {
-    keywordRef.value = value;
-    update();
-  };
-  const div = document.createElement("div");
-  watch(
-    () => updateKey.value,
-    async () => {
-      if (!keywordRef.value) return;
-      await readyPromise;
-      const gmapPlacesService = new google.maps.places.PlacesService(div);
-      gmapPlacesService.textSearch(
-        {
-          query: keywordRef.value,
-          bounds: cityRef.value.bound,
-        },
-        (result, status) => {
-          const from = geoPosition.value;
-          switch (status) {
-            case google.maps.places.PlacesServiceStatus.OK:
-              autoCompletePlacesRef.value = result!.map(({ geometry, name, formatted_address }) => {
-                const lng = geometry?.location?.lng() ?? 0;
-                const lat = geometry?.location?.lat() ?? 0;
-                return {
-                  lng,
-                  lat,
-                  name: name ?? "",
-                  description: formatted_address ?? "",
-                  distance: from ? apiMapDistance(from, [lng, lat]) : undefined,
-                };
-              });
-              return;
-            case google.maps.places.PlacesServiceStatus.ZERO_RESULTS:
-            case google.maps.places.PlacesServiceStatus.NOT_FOUND:
-              autoCompletePlacesRef.value = [];
-              return;
-          }
-        }
-      );
-    }
-  );
-  return { setKeyword, setCity, autoCompletePlaces: autoCompletePlacesRef };
-};
-
-export const useMapAutoComplete = (props: UseMapAutoCompleteProps) => {
-  const { supplier } = useMapSupplier();
-  return supplier === "gmap" ? useGmapAutoComplete(props) : useAmapAutoComplete(props);
-};

package/src/hooks/useMapCityBound.ts

@@ -1,64 +0,0 @@
-import { reactive, Ref, watch, watchEffect } from "vue-demi";
-import { LANGUAGE } from "../types/helper";
-import type { Region } from "../types/interface";
-import { useMapSupplier } from "./useMapSupplier";
-
-export interface UseMapCityBoundProps {
-  cityNameRef: Ref<string | undefined>;
-  onChange?: (value: Region) => any;
-}
-export const useAmapBoundCity = (props: UseMapCityBoundProps): Region => {
-  const { cityNameRef, onChange } = props;
-  const city = reactive({ name: cityNameRef.value ?? "" });
-  watch(
-    () => cityNameRef.value,
-    (cityName) => {
-      const name = cityName ?? "";
-      city.name = name;
-      onChange?.({ name });
-    }
-  );
-  return city;
-};
-
-export const useGmapBoundCity = (props: UseMapCityBoundProps): Region => {
-  const { cityNameRef, onChange } = props;
-  const { readyPromise } = useMapSupplier();
-  const city = reactive<Region>({
-    name: cityNameRef.value ?? "",
-    bound: {
-      east: 0,
-      north: 0,
-      south: 0,
-      west: 0,
-    },
-  });
-  watchEffect(async () => {
-    const cityName = cityNameRef.value;
-    if (!cityName) return;
-    await readyPromise;
-    const geocoder = new google.maps.Geocoder();
-    // todo 这里不是唯一的
-    const { results } = await geocoder.geocode({
-      address: cityName,
-      componentRestrictions: {
-        administrativeArea: "administrative_area_level_1",
-      },
-      language: LANGUAGE,
-    });
-    if (results.length !== 1) {
-      throw new Error("MyError: multiple city found");
-    }
-    const { geometry } = results[0];
-    const cityBound = geometry.bounds?.toJSON() ?? geometry.viewport.toJSON();
-    city.name = cityName;
-    city.bound = cityBound;
-    onChange?.({ name: cityName, bound: cityBound });
-  });
-  return city;
-};
-
-export const useMapBoundCity = (props: UseMapCityBoundProps) => {
-  const { supplier } = useMapSupplier();
-  return supplier === "gmap" ? useGmapBoundCity(props) : useAmapBoundCity(props);
-};

package/src/hooks/useMapDrag.ts

@@ -1,72 +0,0 @@
-import { ref, type ShallowRef } from "vue-demi";
-import type { AmapProps } from "../components/Amap";
-import type { GmapProps } from "../components/Gmap";
-import type { SetupContextEmitHandler } from "../types/helper";
-import type { Point } from "../types/interface";
-import { watchPostEffectForAMapEvent, watchPostEffectForGMapEvent } from "../utils/compare";
-import { pipeAsync } from "../utils/transform";
-import { useMapSupplier } from "./useMapSupplier";
-
-export const ON_CHANGE_CENTER_INTERVAL = 200;
-
-export interface UseMapDragProps<M = AMap.Map | google.maps.Map> {
-  mapRef: ShallowRef<M | undefined>;
-  onChange?: (value: Point) => any;
-}
-export const useAmapDrag = (props: UseMapDragProps<AMap.Map>) => {
-  const { mapRef, onChange } = props;
-  const centerRef = ref<Point>([0, 0]);
-  const isDragging = ref(false);
-  const emitDragStart: SetupContextEmitHandler<Pick<AmapProps, "onDragStart">> = () => {
-    pipeAsync(() => {
-      isDragging.value = true;
-    });
-  };
-  const emitDragEnd: SetupContextEmitHandler<Pick<AmapProps, "onDragEnd">> = (_, { target }) => {
-    isDragging.value = false;
-    const { lng, lat } = target.getCenter();
-    centerRef.value = [lng, lat];
-    pipeAsync(onChange)?.([lng, lat]);
-  };
-  watchPostEffectForAMapEvent(mapRef, {} as Pick<AmapProps, "onDragStart">, emitDragStart, [
-    "onDragStart",
-  ]);
-  watchPostEffectForAMapEvent(mapRef, {} as Pick<AmapProps, "onDragEnd">, emitDragEnd, [
-    "onDragEnd",
-  ]);
-  return { centerRef, isDragging };
-};
-
-export const useGmapDrag = (props: UseMapDragProps<google.maps.Map>) => {
-  const { mapRef, onChange } = props;
-  const centerRef = ref<Point>([0, 0]);
-  const isDragging = ref(false);
-  const emitDragStart: SetupContextEmitHandler<Pick<GmapProps, "onDragStart">> = () => {
-    pipeAsync(() => {
-      isDragging.value = true;
-    });
-  };
-  const emitDragEnd: SetupContextEmitHandler<Pick<GmapProps, "onDragEnd">> = async () => {
-    isDragging.value = false;
-    const center = mapRef.value?.getCenter();
-    const lng = center?.lng() as number;
-    const lat = center?.lat() as number;
-    centerRef.value = [lng, lat];
-    pipeAsync(onChange)?.([lng, lat]);
-  };
-  watchPostEffectForGMapEvent(mapRef!, {} as Pick<GmapProps, "onDragStart">, emitDragStart, [
-    "onDragStart",
-  ]);
-  watchPostEffectForGMapEvent(mapRef!, {} as Pick<GmapProps, "onDragEnd">, emitDragEnd, [
-    "onDragEnd",
-  ]);
-  return { centerRef, isDragging };
-};
-
-export const useMapDrag = (props: UseMapDragProps) => {
-  const { supplier } = useMapSupplier();
-  // todo: 这里违反 react hook 规则，但 react 版本应该可以同时调用 useAmap 和 useGmap
-  return supplier === "gmap"
-    ? useGmapDrag(props as UseMapDragProps<google.maps.Map>)
-    : useAmapDrag(props as UseMapDragProps<AMap.Map>);
-};

package/src/hooks/useMapEventSource.ts

@@ -1,20 +0,0 @@
-export type MapEventSource = "api" | "user";
-let mapEventSource: MapEventSource = "user";
-
-export const getMapEvnetSource = () => mapEventSource;
-
-export const useMapEventSource = () => {
-  const executeMapApi = (fn: () => void) => {
-    mapEventSource = "api";
-    try {
-      fn();
-      setTimeout(() => {
-        mapEventSource = "user";
-      }, 100);
-    } catch (err) {
-      mapEventSource = "user";
-      throw err;
-    }
-  };
-  return { executeMapApi };
-};

package/src/hooks/useMapFitView.ts

@@ -1,135 +0,0 @@
-import { debounce } from "lodash-es";
-import type { MapShallowRef, RegisterOverlay } from "../types/interface";
-import type { MapEventHandler } from "../types/mapHelper";
-import { watchPostEffectForAMapEvent, watchPostEffectForGMapEvent } from "../utils/compare";
-import { getMapEvnetSource, useMapEventSource } from "./useMapEventSource";
-import { useMapSupplier } from "./useMapSupplier";
-import type { AmapOverlay, GmapOverlay } from "./useOverlay";
-
-const GOOGLE_MAP_ZOOM_CHANGE_DEBOUNCE_TIMEOUT = 20;
-
-type UseAmapFitViewPropsForListeners = {
-  onDragEnd?: MapEventHandler<AMap.Map>;
-  // onZoomEnd?: MapEventHandler<AMap.Map>;
-};
-
-export interface UseMapFitViewOutput<L> {
-  setFitView: () => void;
-  registerFitVeiw: RegisterOverlay<L>;
-}
-
-export interface UseMapFitViewProps<M = AMap.Map | google.maps.Map> {
-  mapRef: MapShallowRef<M>;
-  padding?: [number, number, number, number];
-  autoFitTimeout?: number;
-}
-export const useAmapFitView = (props: UseMapFitViewProps<AMap.Map>) => {
-  const { mapRef, autoFitTimeout } = props;
-  const overlayGroup: Set<AmapOverlay> = new Set();
-  let timer: number | undefined = undefined;
-  const setFitView = () => {
-    const map = mapRef.value;
-    if (!map) return;
-    const vw = window.innerWidth / 100;
-    const [top, right, bottom, left] = props.padding ?? [0, 0, 0, 0];
-    map.setFitView([...overlayGroup], false, [top * vw, bottom * vw, left * vw, right * vw]);
-  };
-  const registerFitVeiw: RegisterOverlay<AmapOverlay> = {
-    add: (overlay: AmapOverlay) => {
-      overlayGroup.add(overlay);
-    },
-    remove: (overlay: AmapOverlay) => {
-      overlayGroup.delete(overlay);
-    },
-    setFitView,
-  };
-  const handleMoveEndOrZomEnd = () => {
-    if (!autoFitTimeout) return;
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(() => {
-      timer = undefined;
-      setFitView();
-    }, autoFitTimeout);
-  };
-  watchPostEffectForAMapEvent(
-    mapRef,
-    {} as UseAmapFitViewPropsForListeners,
-    handleMoveEndOrZomEnd,
-    ["onDragEnd"]
-  );
-  return { registerFitVeiw, setFitView };
-};
-
-// 目前需求暂时只需要 marker
-class SimpleGmapOverLayerGroup extends Set<GmapOverlay> {
-  getBound() {
-    const bound = new google.maps.LatLngBounds();
-    for (const overlay of this.values()) {
-      const position =
-        overlay instanceof google.maps.Marker ? overlay.getPosition() : overlay.position;
-      if (position) bound.extend(position);
-    }
-    return bound;
-  }
-}
-
-type UseGmapFitViewPropsForListeners = {
-  onDragEnd?: MapEventHandler<AMap.Map>;
-  onZoom_changed?: MapEventHandler<AMap.Map>;
-};
-export const useGmapFitView = (props: UseMapFitViewProps<google.maps.Map>) => {
-  const { mapRef, autoFitTimeout } = props;
-  const { executeMapApi } = useMapEventSource();
-  const overlayGroup = new SimpleGmapOverLayerGroup();
-  let timer: number | undefined = undefined;
-  const setFitView = () => {
-    const map = mapRef.value;
-    if (!map) return;
-    const vw = window.innerWidth / 100;
-    const [top, right, bottom, left] = props.padding ?? [0, 0, 0, 0];
-    executeMapApi(() =>
-      map.fitBounds(overlayGroup.getBound(), {
-        top: top * vw,
-        right: right * vw,
-        bottom: bottom * vw,
-        left: left * vw,
-      })
-    );
-  };
-  const registerFitVeiw: RegisterOverlay<GmapOverlay> = {
-    add: (overlay: GmapOverlay) => {
-      overlayGroup.add(overlay);
-    },
-    remove: (overlay: GmapOverlay) => {
-      overlayGroup.delete(overlay);
-    },
-    setFitView,
-  };
-  const handleMoveEnd = (name: string) => {
-    const eventSource = getMapEvnetSource();
-    console.log("handleMoveEndOrZomEnd name, eventSource = ", name, eventSource);
-    if (!autoFitTimeout || eventSource !== "user") return;
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(() => {
-      timer = undefined;
-      setFitView();
-    }, autoFitTimeout);
-  };
-  const handleZoomChange = debounce(handleMoveEnd, GOOGLE_MAP_ZOOM_CHANGE_DEBOUNCE_TIMEOUT);
-  watchPostEffectForGMapEvent(mapRef, {} as UseGmapFitViewPropsForListeners, handleMoveEnd, [
-    "onDragEnd",
-  ]);
-  watchPostEffectForGMapEvent(mapRef, {} as UseGmapFitViewPropsForListeners, handleZoomChange, [
-    "onZoom_changed",
-  ]);
-  return { registerFitVeiw, setFitView };
-};
-
-export const useMapFitView = (
-  props: UseMapFitViewProps
-): UseMapFitViewOutput<AmapOverlay> | UseMapFitViewOutput<GmapOverlay> => {
-  const { supplier } = useMapSupplier();
-  return supplier === "gmap"
-    ? useGmapFitView(props as UseMapFitViewProps<google.maps.Map>)
-    : useAmapFitView(props as UseMapFitViewProps<AMap.Map>);
-};

package/src/hooks/useMapGeometry.ts

@@ -1,27 +0,0 @@
-import type { Point } from "../types/interface";
-import { vec2lnglat } from "../utils/transform";
-import { Status } from "./useMapLoader";
-import { useMapSupplier } from "./useMapSupplier";
-
-export const useAmapGeometry = () => {
-  const payload = useMapSupplier();
-  const apiMapDistance = (from: Point, to: Point) => {
-    if (payload.status !== Status.SUCCESS) return undefined;
-    return AMap.GeometryUtil.distance(from, to);
-  };
-  return { apiMapDistance };
-};
-
-export const useGmapGeometry = () => {
-  const payload = useMapSupplier();
-  const apiMapDistance = (from: Point, to: Point) => {
-    if (payload.status !== Status.SUCCESS) return undefined;
-    return google.maps.geometry.spherical.computeDistanceBetween(vec2lnglat(from), vec2lnglat(to));
-  };
-  return { apiMapDistance };
-};
-
-export const useMapGeometry = () => {
-  const { supplier } = useMapSupplier();
-  return supplier === "gmap" ? useGmapGeometry() : useAmapGeometry();
-};

package/src/hooks/useMapLngLatToVw.ts

@@ -1,31 +0,0 @@
-import type { Point } from "../types/interface";
-import { useAmap, useGmap } from "./useMap";
-import { useMapSupplier } from "./useMapSupplier";
-
-export const useAmapLngLatToVw = () => {
-  const amap = useAmap();
-  const apiMapLngLatToVw = (point: Point) => {
-    return amap?.value?.lngLatToContainer(point).toArray() as [number, number];
-  };
-  return { apiMapLngLatToVw };
-};
-
-export const useGmapLngLatToVw = () => {
-  const gmap = useGmap();
-  const apiMapLngLatToVw = (point: Point) => {
-    const [lng, lat] = point;
-    const projection = gmap?.value?.getProjection();
-    const worldCoordinate = projection?.fromLatLngToPoint({ lng, lat });
-    const x = worldCoordinate?.x ?? 0;
-    const y = worldCoordinate?.y ?? 0;
-    const zoom = gmap?.value?.getZoom() ?? 0;
-    const scale = 2 ** zoom;
-    return [x * scale, y * scale] as [number, number];
-  };
-  return { apiMapLngLatToVw };
-};
-
-export const useMapLngLatToVw = () => {
-  const { supplier } = useMapSupplier();
-  return supplier === "gmap" ? useGmapLngLatToVw() : useAmapLngLatToVw();
-};

package/src/hooks/useMapLoader.ts

@@ -1,164 +0,0 @@
-import { load as loadAmap } from "@amap/amap-jsapi-loader";
-import { Loader, LoaderOptions } from "@googlemaps/js-api-loader";
-import { computed, Ref, shallowRef } from "vue-demi";
-import type { VueNode } from "../types/helper";
-import { watchPostEffectForDeepOption } from "../utils/compare";
-
-export const DEFAULT_AMAP_PLUGINS: AmapLoaderProps["plugins"] = [
-  "AMap.Geolocation",
-  "AMap.Geocoder",
-  "AMap.PlaceSearch",
-  "AMap.Driving",
-  "AMap.Walking",
-];
-export const DEFAULT_GMAP_LIBRARIES: LoaderOptions["libraries"] = ["marker", "places", "geometry"];
-
-export enum Status {
-  LOADING = "LOADING",
-  FAILURE = "FAILURE",
-  SUCCESS = "SUCCESS",
-}
-type AMapLoaderOptions = Parameters<typeof loadAmap>[0];
-declare global {
-  interface Window {
-    _AMapSecurityConfig: {
-      securityJsCode?: string;
-      serviceHost?: string;
-    };
-  }
-}
-export interface AmapLoaderProps
-  extends Pick<GmapLoaderProps, "fallback" | "loading" | "onChange">,
-    Omit<AMapLoaderOptions, "key" | "version" | "plugins"> {
-  apiKey: string;
-  apiSecret?: string;
-  apiServiceHost?: string;
-  version?: string;
-  plugins?: `AMap.${AMap.PluginName}`[];
-}
-
-export const useAmapLoader = (props: AmapLoaderProps) => {
-  const { onChange } = props;
-  let resolveLoader: () => void;
-  let rejectLoader: () => void;
-  const readyPromise = new Promise<undefined>((resolve, reject) => {
-    resolveLoader = resolve as () => void;
-    rejectLoader = reject;
-  });
-  const statusRef = shallowRef(Status.LOADING);
-  const optionsRef = computed(() => {
-    const { onChange, loading, fallback, apiKey, apiSecret, apiServiceHost, version, ...options } =
-      props;
-    return { ...options, key: apiKey, version: version ?? "2.0.5.16" };
-  });
-  watchPostEffectForDeepOption(
-    () => optionsRef.value,
-    (options) => {
-      const setStatusAndExecuteCallback = (status: Status) => {
-        statusRef.value = status;
-        if (status === Status.SUCCESS) resolveLoader();
-        if (status === Status.FAILURE) rejectLoader();
-        onChange?.(statusRef.value);
-      };
-      setStatusAndExecuteCallback(Status.LOADING);
-
-      window._AMapSecurityConfig = props.apiServiceHost
-        ? {
-            serviceHost: props.apiServiceHost,
-          }
-        : { securityJsCode: props.apiSecret };
-
-      loadAmap(options).then(
-        () => setStatusAndExecuteCallback(Status.SUCCESS),
-        () => setStatusAndExecuteCallback(Status.FAILURE)
-      );
-    }
-  );
-  return { statusRef, readyPromise };
-};
-
-export interface GmapLoaderProps extends LoaderOptions {
-  /**
-   * Render prop used to switch to loading component.
-   */
-  loading?: () => VueNode;
-  /**
-   * Render prop used to switch to error fallback component.
-   */
-  fallback?: () => VueNode;
-  /**
-   * Callback prop used to access `@googlemaps/js-api-loader` and `Status`.
-   *
-   * Note: The callback be executed multiple times in the lifecycle of the component.
-   */
-  onChange?: (status: Status) => void;
-}
-
-export const useGmapLoader = (props: GmapLoaderProps) => {
-  const { onChange } = props;
-  let resolveLoader: () => void;
-  let rejectLoader: () => void;
-  const readyPromise = new Promise<undefined>((resolve, reject) => {
-    resolveLoader = resolve as () => void;
-    rejectLoader = reject;
-  });
-  const statusRef = shallowRef(Status.LOADING);
-  const options = computed(() => {
-    const { onChange, fallback, loading, ...options } = props;
-    return options;
-  });
-  watchPostEffectForDeepOption(
-    () => options.value,
-    (options) => {
-      const loader = new Loader(options);
-
-      const setStatusAndExecuteCallback = (status: Status) => {
-        statusRef.value = status;
-        if (status === Status.SUCCESS) resolveLoader();
-        if (status === Status.FAILURE) rejectLoader();
-        onChange?.(statusRef.value);
-      };
-
-      setStatusAndExecuteCallback(Status.LOADING);
-
-      loader.load().then(
-        () => setStatusAndExecuteCallback(Status.SUCCESS),
-        () => setStatusAndExecuteCallback(Status.FAILURE)
-      );
-    }
-  );
-  return { statusRef, readyPromise };
-};
-
-export type MapSupplier = "gmap" | "amap";
-export interface UseMapLoaderOutput {
-  statusRef: Ref<Status>;
-  readyPromise: Promise<undefined>;
-}
-export interface UseMapLoaderProps {
-  gmapKey: string;
-  amapKey: string;
-  amapSecret?: string;
-  amapServiceHost?: string;
-  supplier: MapSupplier;
-  language?: "en" | "zh";
-  onChange?: (status: Status) => any;
-}
-export const useMapLoader = (props: UseMapLoaderProps): UseMapLoaderOutput => {
-  const { gmapKey, amapKey, amapSecret, amapServiceHost, supplier, language, onChange } = props;
-  return supplier === "gmap"
-    ? useGmapLoader({
-        apiKey: gmapKey,
-        language,
-        version: "beta",
-        libraries: DEFAULT_GMAP_LIBRARIES,
-        onChange,
-      })
-    : useAmapLoader({
-        apiKey: amapKey,
-        apiSecret: amapSecret,
-        apiServiceHost: amapServiceHost,
-        plugins: DEFAULT_AMAP_PLUGINS,
-        onChange,
-      });
-};

package/src/hooks/useMapLog.ts

@@ -1,24 +0,0 @@
-import { watchEffect } from "vue-demi";
-
-export interface MapLogProps {
-  log?: boolean;
-}
-
-export const useMapLog = <P extends MapLogProps>(props: P, prefix: string) => {
-  watchEffect(() => {
-    if (!props.log) return;
-    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 });
-  });
-};