@heycar/heycars-map 0.1.0

package/src/business-components/StartEndPoint/index.ts

@@ -0,0 +1 @@
+export * from "./StartEndPoint";

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

@@ -0,0 +1,16 @@
+import { style } from "@vanilla-extract/css";
+
+export {
+  pointInfoBoxEmphasize,
+  pointLayout,
+  pointSingleInfoBox,
+} from "../StartEndPoint/StartEndPoint.css";
+
+export const taxiCarLayout = style({});
+
+export const carIcon = style({
+  marginTop: "1.87vw",
+  marginBottom: "-5.5vw",
+  width: "6vw",
+  height: "11vw",
+});

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

@@ -0,0 +1,77 @@
+import { computed } from "vue-demi";
+import imgTaxicar from "../../assets/icons/svg/taxi-car.svg";
+import { AmapMarker } from "../../components/AmapMarker";
+import { GmapAdvancedMarkerView } from "../../components/GmapAdvancedMarkerView/GmapAdvancedMarkerView";
+import { useMapSupplier } from "../../components/MapProvider/useMapSupplier";
+import { createElement, defineSetup } from "../../types/helper";
+import { createDom } from "../../utils/dom";
+import { decodeAsterisk, vec2lnglat } from "../../utils/transform";
+import * as css from "./TaxiCar.css";
+
+export interface TaxiCarProps {
+  position: [number, number];
+  angle?: number;
+  title?: string;
+}
+export const ATaxiCar = defineSetup(function ATaxiCar(props: TaxiCarProps) {
+  const contentRef = computed(() => {
+    const titleRow = !props.title
+      ? ""
+      : decodeAsterisk(props.title)
+          .map((item) =>
+            item.type === "normal"
+              ? item.value
+              : `<span class="${css.pointInfoBoxEmphasize}">${item.value}</span>`
+          )
+          .join("");
+    if (!props.title) return `<img src="${imgTaxicar}" class="${css.carIcon}">`;
+    const carStyle = `transform:rotate(${props.angle ?? 0}deg)`;
+    return `
+      <div class="${css.pointLayout}">
+        <div class="${css.pointSingleInfoBox}">${titleRow}</div>
+        <img src="${imgTaxicar}" class="${css.carIcon}" style="${carStyle}">
+      </div>
+      `;
+  });
+  return () => (
+    <AmapMarker position={props.position} content={contentRef.value} anchor={"bottom-center"} />
+  );
+});
+
+export const GTaxiCar = defineSetup(function GTaxiCar(props: TaxiCarProps) {
+  const contentRef = computed(() => {
+    const titleRow = !props.title
+      ? ""
+      : decodeAsterisk(props.title)
+          .map((item) =>
+            item.type === "normal"
+              ? item.value
+              : `<span class="${css.pointInfoBoxEmphasize}">${item.value}</span>`
+          )
+          .join("");
+    if (!props.title) return createDom("img", { class: css.carIcon, src: imgTaxicar });
+    const carStyle = `transform:rotate(${props.angle ?? 0}deg)`;
+    return createDom(
+      "div",
+      { class: css.pointLayout },
+      `
+        <div class="${css.pointSingleInfoBox}">${titleRow}</div>
+        <img src="${imgTaxicar}" class="${css.carIcon}" style="${carStyle}">
+      `
+    );
+  });
+  return () => {
+    return (
+      <GmapAdvancedMarkerView position={vec2lnglat(props.position)} content={contentRef.value} />
+    );
+  };
+});
+
+export const TaxiCar = defineSetup(function TaxiCar(props: TaxiCarProps) {
+  const payload = useMapSupplier();
+  return () => {
+    return createElement(payload.supplier === "gmap" ? GTaxiCar : ATaxiCar, {
+      attrs: props,
+    });
+  };
+});

package/src/business-components/TaxiCar/index.ts

@@ -0,0 +1 @@
+export * from "./TaxiCar";

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

@@ -0,0 +1,73 @@
+import { computed } from "vue-demi";
+import { AmapPolyline } from "../../components/AmapPolyline";
+import { GmapPolyline } from "../../components/GmapPolyline";
+import { useMapSupplier } from "../../components/MapProvider/useMapSupplier";
+import { createElement, defineSetup } from "../../types/helper";
+import { vec2lnglat } from "../../utils/transform";
+
+export interface WalkingLineProps {
+  path: [number, number][];
+}
+export const AWalkingLine = defineSetup(function AWalkingLine(props: WalkingLineProps) {
+  return () => {
+    const vw = window.innerWidth * 0.01;
+    const strokeWidth = 2 * vw;
+    return (
+      <AmapPolyline
+        path={props.path}
+        strokeWeight={strokeWidth}
+        strokeOpacity={1}
+        strokeColor={"#38A3FE"}
+        strokeStyle="dashed"
+        strokeDasharray={[strokeWidth, strokeWidth * 1.5]}
+        lineJoin={"round"}
+        lineCap={"round"}
+      />
+    );
+  };
+});
+
+export const GWalkingLine = defineSetup(function GWalkingLine(props: WalkingLineProps) {
+  const pathRef = computed(() => props.path.map(vec2lnglat));
+  return () => {
+    const vw = window.innerWidth * 0.01;
+    const strokeWidth = 2 * vw;
+    const r = strokeWidth / 4;
+    return (
+      <GmapPolyline
+        path={pathRef.value}
+        strokeWeight={strokeWidth}
+        strokeOpacity={1}
+        strokeColor={"transparent"}
+        icons={[
+          {
+            icon: {
+              path: `
+                M ${r}, ${r}
+                m -${r}, 0
+                a ${r},${r} 0 1,0 ${2 * r},0
+                a ${r},${r} 0 1,0 -${2 * r},0
+              `,
+              strokeColor: "#38A3FE",
+              fillColor: "#38A3FE",
+              fillOpacity: 1,
+              strokeOpacity: 1,
+              strokeWeight: strokeWidth / 2,
+              scale: 1,
+            },
+            repeat: `${strokeWidth * 2}px`,
+          },
+        ]}
+      />
+    );
+  };
+});
+
+export const WalkingLine = defineSetup(function WalkingLine(props: WalkingLineProps) {
+  const payload = useMapSupplier();
+  return () => {
+    return createElement(payload.supplier === "gmap" ? GWalkingLine : AWalkingLine, {
+      attrs: props,
+    });
+  };
+});

package/src/business-components/WalkingLine/index.ts

@@ -0,0 +1 @@
+export * from "./WalkingLine";

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

@@ -0,0 +1,54 @@
+import { keyframes, style } from "@vanilla-extract/css";
+
+export const waveAnimationFirst = keyframes({
+  "0%": {
+    transform: "scale(0)",
+    opacity: 1,
+  },
+  "33.33%": {
+    transform: "scale(0.5)",
+    opacity: 1,
+  },
+  "66.66%": {
+    transform: "scale(1)",
+    opacity: 0,
+  },
+  "100%": {
+    transform: "scale(1)",
+    opacity: 0,
+  },
+});
+
+export const waveAnimationSecond = keyframes({
+  "0%": {
+    transform: "scale(0)",
+    opacity: 0,
+  },
+  "33.33%": {
+    transform: "scale(0)",
+    opacity: 1,
+  },
+  "66.66%": {
+    transform: "scale(0.5)",
+    opacity: 1,
+  },
+  "100%": {
+    transform: "scale(1)",
+    opacity: 0,
+  },
+});
+
+export const waveCircle = style({
+  display: "flex",
+  marginBottom: "-30.935vw",
+  width: "61.87vw",
+  height: "61.87vw",
+  animationName: waveAnimationFirst,
+  animationDuration: "3s",
+  animationIterationCount: "infinite",
+  animationTimingFunction: "linear",
+});
+
+export const secondCircle = style({
+  animationName: waveAnimationSecond,
+});

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

@@ -0,0 +1,56 @@
+import { computed } from "vue-demi";
+import imgWaveCircle from "../../assets/icons/svg/wave-circle.svg";
+import { AmapMarker } from "../../components/AmapMarker";
+import { GmapAdvancedMarkerView } from "../../components/GmapAdvancedMarkerView";
+import { useMapSupplier } from "../../components/MapProvider/useMapSupplier";
+import { createElement, defineSetup } from "../../types/helper";
+import { createDom } from "../../utils/dom";
+import { vec2lnglat } from "../../utils/transform";
+import * as css from "./WaveCircle.css";
+
+export interface WaveCircleProps {
+  position: [number, number];
+}
+export const AWaveCircle = defineSetup(function AWaveCircle(props: WaveCircleProps) {
+  const contentRef = computed(() => `<img src="${imgWaveCircle}" class="${css.waveCircle}">`);
+  const contentAnotherRef = computed(
+    () => `<img src="${imgWaveCircle}" class="${css.waveCircle} ${css.secondCircle}">`
+  );
+  return () => (
+    <div>
+      <AmapMarker position={props.position} anchor="bottom-center" content={contentRef.value} />
+      <AmapMarker
+        position={props.position}
+        anchor="bottom-center"
+        content={contentAnotherRef.value}
+      />
+    </div>
+  );
+});
+
+export const GWaveCircle = defineSetup(function AWaveCircle(props: WaveCircleProps) {
+  const contentRef = computed(() =>
+    createDom("img", { class: css.waveCircle, src: imgWaveCircle })
+  );
+  const contentAnotherRef = computed(() =>
+    createDom("img", { class: `${css.waveCircle} ${css.secondCircle}`, src: imgWaveCircle })
+  );
+  return () => {
+    const position = vec2lnglat(props.position);
+    return (
+      <div>
+        <GmapAdvancedMarkerView position={position} content={contentRef.value} />
+        <GmapAdvancedMarkerView position={position} content={contentAnotherRef.value} />
+      </div>
+    );
+  };
+});
+
+export const WaveCircle = defineSetup(function WaveCircle(props: WaveCircleProps) {
+  const payload = useMapSupplier();
+  return () => {
+    return createElement(payload.supplier === "gmap" ? GWaveCircle : AWaveCircle, {
+      attrs: props,
+    });
+  };
+});

package/src/business-components/WaveCircle/index.ts

@@ -0,0 +1 @@
+export * from "./WaveCircle";

package/src/components/Amap/Amap.css.ts

@@ -0,0 +1,3 @@
+import { style } from "@vanilla-extract/css";
+
+export const amap = style({});

package/src/components/Amap/Amap.ts

@@ -0,0 +1,58 @@
+import { computed, h, shallowRef, watchPostEffect } from "vue-demi";
+import { defineSetup } from "../../types/helper";
+import {
+  watchNoneImmediatePostEffectForDeepOption,
+  watchNoneImmediatePostEffectForMapProperty,
+  watchPostEffectForAMapEvent,
+} from "../../utils/compare";
+import * as css from "./Amap.css";
+import { provideAmap } from "./useAmap";
+
+export interface AmapProps extends AMap.MapOptions {
+  onMapMove?: (e: { type: "mapmove"; target: AMap.Map }) => void;
+}
+
+export const Amap = defineSetup(function Amap(props: AmapProps, { slots, emit }) {
+  const { onMapMove, ...defaultOptions } = props;
+  const statusOptions = computed(() => {
+    return {
+      dragEnable: !!props.dragEnable,
+      zoomEnable: !!props.zoomEnable,
+      jogEnable: !!props.jogEnable,
+      pitchEnable: !!props.pitchEnable,
+      rotateEnable: !!props.rotateEnable,
+      animateEnable: !!props.animateEnable,
+      keyboardEnable: !!props.keyboardEnable,
+    };
+  });
+  const elementRef = shallowRef();
+  const mapRef = shallowRef<AMap.Map>();
+  provideAmap(mapRef);
+  watchPostEffect(() => {
+    // todo 这里是否会因为 mapRef 的赋值导致不停运行？
+    if (mapRef.value || !elementRef.value) return;
+    mapRef.value = new AMap.Map(elementRef.value, { ...defaultOptions });
+  });
+  watchNoneImmediatePostEffectForDeepOption(
+    () => statusOptions.value,
+    (statusOptions) => {
+      mapRef.value?.setStatus(statusOptions);
+    }
+  );
+  watchNoneImmediatePostEffectForMapProperty(mapRef, props, [
+    { name: "center", defaultValue: [0, 0] },
+    { name: "zooms", defaultValue: [0, 0] },
+    { name: "zoom", defaultValue: 0 },
+    { name: "layers", defaultValue: [] },
+    { name: "limitBounds", defaultValue: [] },
+    { name: "rotation", defaultValue: 0 },
+    { name: "defaultCursor", defaultValue: "" },
+    { name: "mapStyle", defaultValue: "" },
+    { name: "features", defaultValue: [] },
+    { name: "pitch", defaultValue: 0 },
+    { name: "mask", defaultValue: [] },
+    { name: "labelRejectMask", defaultValue: false },
+  ]);
+  watchPostEffectForAMapEvent(mapRef, props, emit, ["onMapMove"]);
+  return () => h("div", { ref: elementRef, class: css.amap }, slots.default?.());
+});

package/src/components/Amap/index.ts

@@ -0,0 +1 @@
+export * from "./Amap";

package/src/components/Amap/useAmap.ts

@@ -0,0 +1,9 @@
+import { inject, provide, ShallowRef } from "vue-demi";
+
+export const amapContext = Symbol();
+
+export const useAmap = () => {
+  return inject<ShallowRef<AMap.Map | undefined>>(amapContext);
+};
+export const provideAmap = (mapRef: ShallowRef<AMap.Map | undefined>) =>
+  provide(amapContext, mapRef);

package/src/components/AmapInfoWindow/AmapInfoWindow.ts

@@ -0,0 +1,45 @@
+import { computed, onMounted, onUnmounted, shallowRef, watchPostEffect } from "vue-demi";
+import { defineSetup } from "../../types/helper";
+import { watchNoneImmediatePostEffectForMapProperty } from "../../utils/compare";
+import { useAmap } from "../Amap/useAmap";
+
+export interface AmapInfoWindowProps extends AMap.InfoOptions {
+  visible: boolean;
+}
+
+export const AmapInfoWindow = defineSetup(function AmapInfoWindow(props: AmapInfoWindowProps) {
+  const options = computed(() => {
+    const { visible, ...options } = props;
+    return options;
+  });
+  const defaultOptions = options.value;
+  const infoWindowRef = shallowRef<AMap.InfoWindow>();
+  const mapRef = useAmap();
+  onMounted(() => {
+    infoWindowRef.value = new AMap.InfoWindow({ ...defaultOptions });
+  });
+  onUnmounted(() => {
+    infoWindowRef.value?.close();
+  });
+  watchPostEffect(() => {
+    const { visible } = props;
+    const infoWindow = infoWindowRef.value;
+    const map = mapRef?.value;
+    if (!map || !infoWindow) return;
+    const position = infoWindow.getPosition();
+    if (!position) return;
+    visible ? infoWindow.open(map, [position.lng, position.lat]) : infoWindow.close();
+  });
+  watchNoneImmediatePostEffectForMapProperty(infoWindowRef, props, [
+    { name: "anchor", defaultValue: undefined },
+    { name: "angle", defaultValue: undefined },
+    { name: "content", defaultValue: undefined },
+    { name: "extData", defaultValue: undefined },
+    { name: "offset", defaultValue: undefined },
+    { name: "orientation", defaultValue: undefined },
+    { name: "position", defaultValue: undefined },
+    { name: "size", defaultValue: undefined },
+    { name: "zIndex", defaultValue: undefined },
+  ]);
+  return () => null;
+});

package/src/components/AmapInfoWindow/index.ts

@@ -0,0 +1 @@
+export * from "./AmapInfoWindow";

package/src/components/AmapLoader/AmapLoader.ts

@@ -0,0 +1,68 @@
+import { load as loadAmap } from "@amap/amap-jsapi-loader";
+import { computed, shallowRef } from "vue-demi";
+import { defineSetup, VueNode } from "../../types/helper";
+import { watchPostEffectForDeepOption } from "../../utils/compare";
+import { GmapLoaderProps, Status } from "../GmapLoader";
+
+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 AmapLoader = defineSetup(function AmapLoader(props: AmapLoaderProps, { slots, emit }) {
+  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" };
+  });
+  watchPostEffectForDeepOption(
+    () => optionsRef.value,
+    (options) => {
+      const setStatusAndExecuteCallback = (status: Status) => {
+        emit("change", status);
+        statusRef.value = status;
+      };
+
+      setStatusAndExecuteCallback(Status.LOADING);
+
+      window._AMapSecurityConfig = props.apiServiceHost
+        ? {
+            serviceHost: props.apiServiceHost,
+          }
+        : { securityJsCode: props.apiSecret };
+
+      loadAmap(options).then(
+        () => setStatusAndExecuteCallback(Status.SUCCESS),
+        () => setStatusAndExecuteCallback(Status.FAILURE)
+      );
+    }
+  );
+  return () => {
+    switch (statusRef.value) {
+      case Status.SUCCESS:
+        return slots.default?.() as VueNode;
+      case Status.LOADING:
+        return slots.loading?.();
+      case Status.FAILURE:
+        return slots.fallback?.();
+      default:
+        throw new Error("MyError: unknown loader status");
+    }
+  };
+});

package/src/components/AmapLoader/index.ts

@@ -0,0 +1 @@
+export * from "./AmapLoader";

package/src/components/AmapMarker/AmapMarker.ts

@@ -0,0 +1,38 @@
+import { onMounted, onUnmounted, shallowRef, watchPostEffect } from "vue-demi";
+import { defineSetup } from "../../types/helper";
+import { watchNoneImmediatePostEffectForMapProperty } from "../../utils/compare";
+import { useAmap } from "../Amap/useAmap";
+
+export type AmapMarkerProps = AMap.MarkerOptions;
+
+export const AmapMarker = defineSetup(function AmapMarker(props: AmapMarkerProps) {
+  const markerRef = shallowRef<AMap.Marker>();
+  const mapRef = useAmap();
+  onMounted(() => {
+    markerRef.value = new AMap.Marker({ ...props });
+  });
+  onUnmounted(() => {
+    markerRef.value?.setMap(null);
+  });
+  watchPostEffect(() => {
+    const map = mapRef?.value;
+    if (!map) return;
+    markerRef.value?.setMap(map);
+  });
+  watchNoneImmediatePostEffectForMapProperty(markerRef, props, [
+    { name: "anchor", defaultValue: "" },
+    { name: "offset", defaultValue: [0, 0] },
+    { name: "clickable", defaultValue: false },
+    { name: "position", defaultValue: [0, 0] },
+    { name: "angle", defaultValue: 0 },
+    { name: "label", defaultValue: undefined },
+    { name: "zIndex", defaultValue: 0 },
+    { name: "icon", defaultValue: "" },
+    { name: "draggable", defaultValue: false },
+    { name: "cursor", defaultValue: "" },
+    { name: "content", defaultValue: "" },
+    { name: "title", defaultValue: "" },
+    { name: "extData", defaultValue: "" },
+  ]);
+  return () => null;
+});

package/src/components/AmapMarker/index.ts

@@ -0,0 +1 @@
+export * from "./AmapMarker";

package/src/components/AmapPolygon/AmapPolygon.ts

@@ -0,0 +1,41 @@
+import { onMounted, onUnmounted, shallowRef, watchPostEffect } from "vue-demi";
+import { defineSetup } from "../../types/helper";
+import {
+  watchNoneImmediatePostEffectForDeepOption,
+  watchNoneImmediatePostEffectForMapProperty,
+} from "../../utils/compare";
+import { useAmap } from "../Amap/useAmap";
+
+export type AmapPolygonProps = AMap.PolygonOptions;
+
+export const AmapPolygon = defineSetup(function AmapPolygon(props: AmapPolygonProps) {
+  const polygonRef = shallowRef<AMap.Polygon>();
+  const mapRef = useAmap();
+  onMounted(() => {
+    polygonRef.value = new AMap.Polygon();
+    polygonRef.value.setOptions(props);
+  });
+  onUnmounted(() => {
+    polygonRef.value?.setMap(null);
+  });
+  watchPostEffect(() => {
+    const map = mapRef?.value;
+    if (!map) return;
+    polygonRef.value?.setMap(map);
+  });
+  watchNoneImmediatePostEffectForMapProperty(polygonRef, props, [
+    { name: "path", defaultValue: [[0, 0]] },
+    { name: "extData", defaultValue: undefined },
+    { name: "draggable", defaultValue: false },
+  ]);
+  watchNoneImmediatePostEffectForDeepOption(
+    () => {
+      const { path, extData, draggable, ...otherOptions } = props;
+      return otherOptions;
+    },
+    (otherOptions) => {
+      polygonRef.value?.setOptions({ ...otherOptions });
+    }
+  );
+  return () => null;
+});

package/src/components/AmapPolygon/index.ts

@@ -0,0 +1 @@
+export * from "./AmapPolygon";

package/src/components/AmapPolyline/AmapPolyline.ts

@@ -0,0 +1,40 @@
+import { onMounted, onUnmounted, shallowRef, watchPostEffect } from "vue-demi";
+import { defineSetup } from "../../types/helper";
+import {
+  watchNoneImmediatePostEffectForDeepOption,
+  watchNoneImmediatePostEffectForMapProperty,
+} from "../../utils/compare";
+import { useAmap } from "../Amap/useAmap";
+
+export type AmapPolylineProps = AMap.PolylineOptions;
+
+export const AmapPolyline = defineSetup(function AmapPolyline(props: AmapPolylineProps) {
+  const polylineRef = shallowRef<AMap.Polyline>();
+  const mapRef = useAmap();
+  onMounted(() => {
+    polylineRef.value = new AMap.Polyline({ ...props });
+  });
+  onUnmounted(() => {
+    polylineRef.value?.setMap(null);
+  });
+  watchPostEffect(() => {
+    const map = mapRef?.value;
+    if (!map) return;
+    polylineRef.value?.setMap(map);
+  });
+  watchNoneImmediatePostEffectForMapProperty(polylineRef, props, [
+    { name: "path", defaultValue: [[0, 0]] },
+    { name: "extData", defaultValue: undefined },
+    { name: "draggable", defaultValue: false },
+  ]);
+  watchNoneImmediatePostEffectForDeepOption(
+    () => {
+      const { path, extData, draggable, ...otherOptions } = props;
+      return otherOptions;
+    },
+    (otherOptions) => {
+      polylineRef.value?.setOptions({ ...otherOptions });
+    }
+  );
+  return () => null;
+});

package/src/components/AmapPolyline/index.ts

@@ -0,0 +1 @@
+export * from "./AmapPolyline";

package/src/components/AmapText/AmapText.ts

@@ -0,0 +1,39 @@
+import { onMounted, onUnmounted, shallowRef, watchPostEffect } from "vue-demi";
+import { defineSetup } from "../../types/helper";
+import { watchNoneImmediatePostEffectForMapProperty } from "../../utils/compare";
+import { useAmap } from "../Amap/useAmap";
+
+export type AmapTextProps = AMap.TextOptions;
+
+export const AmapText = defineSetup(function AmapText(props: AmapTextProps) {
+  const textRef = shallowRef<AMap.Text>();
+  const mapRef = useAmap();
+  onMounted(() => {
+    textRef.value = new AMap.Text({ ...props });
+  });
+  onUnmounted(() => {
+    textRef.value?.setMap(null);
+  });
+  watchPostEffect(() => {
+    const map = mapRef?.value;
+    if (!map) return;
+    textRef.value?.setMap(map);
+  });
+  watchNoneImmediatePostEffectForMapProperty(textRef, props, [
+    { name: "anchor", defaultValue: "" },
+    { name: "offset", defaultValue: [0, 0] },
+    { name: "clickable", defaultValue: false },
+    { name: "position", defaultValue: [0, 0] },
+    { name: "angle", defaultValue: 0 },
+    { name: "label", defaultValue: undefined },
+    { name: "zIndex", defaultValue: 0 },
+    { name: "icon", defaultValue: "" },
+    { name: "draggable", defaultValue: false },
+    { name: "cursor", defaultValue: "" },
+    { name: "content", defaultValue: "" },
+    { name: "title", defaultValue: "" },
+    { name: "extData", defaultValue: "" },
+    { name: "style", defaultValue: undefined },
+  ]);
+  return () => null;
+});

package/src/components/AmapText/index.ts

@@ -0,0 +1 @@
+export * from "./AmapText";