jky-component-lib 0.0.80 → 0.0.94

package/dist/es/add-input/AddInput.vue.js

@@ -18,7 +18,7 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 import { defineComponent, useModel, ref, watch, openBlock, createElementBlock, Fragment, renderList, createVNode, unref, createElementVNode, createBlock, withCtx, createTextVNode, toDisplayString, mergeModels } from "vue";
-import { Plus as plus_default, Delete as delete_default } from "../node_modules/@element-plus/icons-vue/dist/index.js";
+import { Plus, Delete } from "@element-plus/icons-vue";
 import { ElInput, ElButton } from "element-plus";
 const _hoisted_1 = { class: "jky-add-input" };
 const _hoisted_2 = { class: "jky-add-input__actions" };
@@ -120,7 +120,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues({
                 key: 0,
                 type: "primary",
                 disabled: __props.disabled || __props.readonly,
-                icon: unref(plus_default),
+                icon: unref(Plus),
                 onClick: handleAdd
               }, {
                 default: withCtx(() => [
@@ -131,7 +131,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues({
                 key: 1,
                 type: "danger",
                 disabled: __props.disabled || __props.readonly,
-                icon: unref(delete_default),
+                icon: unref(Delete),
                 onClick: ($event) => handleDelete(index)
               }, {
                 default: withCtx(() => [

package/dist/es/amap/AMap.vue.d.ts

@@ -0,0 +1,61 @@
+import { AMapProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        mapRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<AMapProps, {
+    getMapInstance: () => any;
+    addMarker: (options: any) => any;
+    removeMarker: (marker: any) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    click: (data: any) => any;
+    moveend: (center: {
+        lng: number;
+        lat: number;
+    }) => any;
+    zoomend: (zoom: number) => any;
+    ready: (map: any) => any;
+}, string, import('vue').PublicProps, Readonly<AMapProps> & Readonly<{
+    onClick?: ((data: any) => any) | undefined;
+    onMoveend?: ((center: {
+        lng: number;
+        lat: number;
+    }) => any) | undefined;
+    onZoomend?: ((zoom: number) => any) | undefined;
+    onReady?: ((map: any) => any) | undefined;
+}>, {
+    width: string;
+    height: string;
+    token: string;
+    zoom: number;
+    viewMode: import('./types').MapViewMode;
+    showScale: boolean;
+    showHawkEye: boolean;
+    showToolbar: boolean;
+    showControlBar: boolean;
+    showGeolocation: boolean;
+    scalePosition: import('./types').ControlPosition;
+    hawkEyePosition: import('./types').ControlPosition;
+    toolbarPosition: import('./types').ControlPosition;
+    controlBarPosition: import('./types').ControlBarPosition;
+    geolocationPosition: import('./types').ControlPosition;
+    enableHighAccuracy: boolean;
+    timeout: number;
+    zoomToAccuracy: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    mapRef: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/es/amap/AMap.vue.js

@@ -0,0 +1,292 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { defineComponent, ref, computed, watch, provide, onMounted, openBlock, createElementBlock, createElementVNode, normalizeStyle, renderSlot, createCommentVNode, nextTick, unref } from "vue";
+import { ElMessage } from "element-plus";
+const _hoisted_1 = { class: "jky-amap-wrapper" };
+const _sfc_main = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues({}, {
+  name: "JkyAMap"
+}), {
+  __name: "AMap",
+  props: {
+    token: { default: "75f62fbef756459563f042e5a2a1fd7c" },
+    zoom: { default: 11 },
+    center: {},
+    viewMode: { default: "3D" },
+    width: { default: "100%" },
+    height: { default: "100%" },
+    showScale: { type: Boolean, default: false },
+    showHawkEye: { type: Boolean, default: false },
+    showToolbar: { type: Boolean, default: false },
+    showControlBar: { type: Boolean, default: false },
+    showGeolocation: { type: Boolean, default: false },
+    scalePosition: { default: "LB" },
+    hawkEyePosition: { default: "RB" },
+    toolbarPosition: { default: "LT" },
+    controlBarPosition: { default: () => ({
+      top: "10px",
+      left: "50%",
+      transform: "translateX(-50%)"
+    }) },
+    geolocationPosition: { default: "RB" },
+    enableHighAccuracy: { type: Boolean, default: true },
+    timeout: { default: 1e4 },
+    zoomToAccuracy: { type: Boolean, default: true }
+  },
+  emits: ["moveend", "zoomend", "click", "ready"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const mapRef = ref(null);
+    const mapInstance = ref(null);
+    const isMapLoaded = ref(false);
+    const controls = ref({});
+    const getMapUrl = computed(() => {
+      const plugins = [];
+      if (props.showScale)
+        plugins.push("AMap.Scale");
+      if (props.showHawkEye)
+        plugins.push("AMap.HawkEye");
+      if (props.showToolbar)
+        plugins.push("AMap.ToolBar");
+      if (props.showControlBar)
+        plugins.push("AMap.ControlBar");
+      if (props.showGeolocation)
+        plugins.push("AMap.Geolocation");
+      const pluginStr = plugins.length > 0 ? `&plugin=${plugins.join(",")}` : "";
+      return `https://webapi.amap.com/maps?v=2.0&key=${props.token}${pluginStr}`;
+    });
+    function loadMapScript() {
+      return new Promise((resolve, reject) => {
+        if (window.AMap) {
+          resolve();
+          return;
+        }
+        const script = document.createElement("script");
+        script.type = "text/javascript";
+        script.src = getMapUrl.value;
+        script.onload = () => resolve();
+        script.onerror = () => reject(new Error("Failed to load AMap script"));
+        document.head.appendChild(script);
+      });
+    }
+    function initMap() {
+      return __async(this, null, function* () {
+        if (!props.token) {
+          console.error("AMap token is required");
+          return;
+        }
+        try {
+          yield loadMapScript();
+          yield nextTick();
+          const wrapEl = unref(mapRef);
+          if (!wrapEl)
+            return;
+          const AMap = window.AMap;
+          const map = new AMap.Map(wrapEl, {
+            zoom: props.zoom,
+            center: props.center,
+            viewMode: props.viewMode
+          });
+          mapInstance.value = map;
+          isMapLoaded.value = true;
+          addControls(map, AMap);
+          map.on("moveend", () => {
+            const center = map.getCenter();
+            emit("moveend", { lng: center.lng, lat: center.lat });
+          });
+          map.on("zoomend", () => {
+            const zoom = map.getZoom();
+            emit("zoomend", zoom);
+          });
+          map.on("click", (e) => {
+            emit("click", e);
+          });
+          emit("ready", map);
+        } catch (error) {
+          console.error("Failed to initialize AMap:", error);
+        }
+      });
+    }
+    function addControls(map, AMap) {
+      if (props.showScale) {
+        const scaleControl = new AMap.Scale({
+          position: props.scalePosition
+        });
+        map.addControl(scaleControl);
+        controls.value.scale = scaleControl;
+      }
+      if (props.showHawkEye) {
+        const hawkEyeControl = new AMap.HawkEye({
+          position: props.hawkEyePosition
+        });
+        map.addControl(hawkEyeControl);
+        controls.value.hawkEye = hawkEyeControl;
+      }
+      if (props.showToolbar) {
+        const toolbarControl = new AMap.ToolBar({
+          position: props.toolbarPosition
+        });
+        map.addControl(toolbarControl);
+        controls.value.toolbar = toolbarControl;
+      }
+      if (props.showControlBar) {
+        const controlBar = new AMap.ControlBar({
+          position: props.controlBarPosition
+        });
+        map.addControl(controlBar);
+        controls.value.controlBar = controlBar;
+      }
+      if (props.showGeolocation) {
+        AMap.plugin("AMap.Geolocation", () => {
+          const geolocation = new AMap.Geolocation({
+            enableHighAccuracy: props.enableHighAccuracy,
+            timeout: props.timeout,
+            position: props.geolocationPosition,
+            offset: [10, 20],
+            zoomToAccuracy: props.zoomToAccuracy
+          });
+          map.addControl(geolocation);
+          controls.value.geolocation = geolocation;
+        });
+      }
+    }
+    function removeControls() {
+      if (!mapInstance.value)
+        return;
+      const map = mapInstance.value;
+      Object.values(controls.value).forEach((control) => {
+        if (control) {
+          map.removeControl(control);
+        }
+      });
+      controls.value = {};
+    }
+    function updateControls() {
+      if (!mapInstance.value || !isMapLoaded.value)
+        return;
+      removeControls();
+      const AMap = window.AMap;
+      addControls(mapInstance.value, AMap);
+    }
+    watch(
+      () => props.token,
+      () => {
+        if (isMapLoaded.value && props.token) {
+          initMap();
+        }
+      }
+    );
+    watch(
+      [
+        () => props.showScale,
+        () => props.showHawkEye,
+        () => props.showToolbar,
+        () => props.showControlBar,
+        () => props.showGeolocation
+      ],
+      () => {
+        if (isMapLoaded.value && mapInstance.value) {
+          updateControls();
+        }
+      }
+    );
+    watch(
+      () => props.viewMode,
+      (newMode) => {
+        if (isMapLoaded.value && mapInstance.value) {
+          mapInstance.value.setMapStyle(newMode === "3D" ? "amap://styles/dark" : "amap://styles/normal");
+          ElMessage.info(`切换到${newMode}模式`);
+        }
+      }
+    );
+    const context = {
+      get map() {
+        return mapInstance.value;
+      },
+      isMapLoaded: computed(() => {
+        return isMapLoaded.value;
+      }),
+      addMarker: (options) => {
+        if (mapInstance.value) {
+          return new window.AMap.Marker(options);
+        }
+      },
+      removeMarker: (marker) => {
+        if (mapInstance.value && marker) {
+          mapInstance.value.remove(marker);
+        }
+      },
+      getMapInstance: () => mapInstance.value
+    };
+    provide("amapContext", context);
+    __expose({
+      getMapInstance: () => mapInstance.value,
+      addMarker: (options) => {
+        if (mapInstance.value) {
+          return new window.AMap.Marker(options);
+        }
+      },
+      removeMarker: (marker) => {
+        if (mapInstance.value && marker) {
+          mapInstance.value.remove(marker);
+        }
+      }
+    });
+    onMounted(() => {
+      if (props.token) {
+        initMap();
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createElementVNode("div", {
+          ref_key: "mapRef",
+          ref: mapRef,
+          class: "jky-amap-container",
+          style: normalizeStyle({ width: __props.width, height: __props.height })
+        }, null, 4),
+        isMapLoaded.value && mapInstance.value ? renderSlot(_ctx.$slots, "default", { key: 0 }) : createCommentVNode("", true)
+      ]);
+    };
+  }
+}));
+export {
+  _sfc_main as default
+};

package/dist/es/amap/AMap.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./AMap.vue.js";
+/* empty css          */
+export {
+  _sfc_main as default
+};

package/dist/es/amap/AMarker.vue.d.ts

@@ -0,0 +1,38 @@
+import { AMapMarkerProps, MarkerData } from './types';
+declare function removeMarkers(): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<AMapMarkerProps, {
+    getMarkers: () => any[];
+    clearMarkers: typeof removeMarkers;
+    addMarker: (data: MarkerData) => any;
+    removeMarker: (marker: any) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    click: (marker: any, data: MarkerData) => any;
+    dragend: (marker: any, data: MarkerData) => any;
+    mouseout: (marker: any, data: MarkerData) => any;
+    mouseover: (marker: any, data: MarkerData) => any;
+}, string, import('vue').PublicProps, Readonly<AMapMarkerProps> & Readonly<{
+    onClick?: ((marker: any, data: MarkerData) => any) | undefined;
+    onDragend?: ((marker: any, data: MarkerData) => any) | undefined;
+    onMouseout?: ((marker: any, data: MarkerData) => any) | undefined;
+    onMouseover?: ((marker: any, data: MarkerData) => any) | undefined;
+}>, {
+    draggable: boolean;
+    visible: boolean;
+    updateMode: "incremental" | "full";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/es/amap/AMarker.vue.js

@@ -0,0 +1,253 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { defineComponent, ref, inject, onMounted, onUnmounted, watch, renderSlot, render, h } from "vue";
+const _sfc_main = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues({}, {
+  name: "JkyAMarker"
+}), {
+  __name: "AMarker",
+  props: {
+    markers: {},
+    position: {},
+    title: {},
+    content: {},
+    draggable: { type: Boolean, default: false },
+    icon: {},
+    offset: {},
+    visible: { type: Boolean, default: true },
+    updateMode: { default: "full" }
+  },
+  emits: ["click", "dragend", "mouseover", "mouseout"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const markers = ref([]);
+    const amapContext = inject("amapContext", null);
+    const mapInstance = (amapContext == null ? void 0 : amapContext.getMapInstance()) || null;
+    const contentCleanupFns = /* @__PURE__ */ new WeakMap();
+    function renderVueComponent(component, props2) {
+      const container = document.createElement("div");
+      const vnode = h(component, props2);
+      render(vnode, container);
+      return container.firstElementChild || container;
+    }
+    function createMarker(data) {
+      const AMap = window.AMap;
+      if (!AMap || !mapInstance) {
+        console.error("AMap map instance is required");
+        return null;
+      }
+      const markerOptions = {
+        position: data.position,
+        title: data.title,
+        draggable: data.draggable,
+        visible: data.visible !== false,
+        extData: data
+      };
+      if (data.content) {
+        if (data.content instanceof HTMLElement || data.content === "string") {
+          markerOptions.content = data.content;
+        } else if (typeof data.content === "object" && data.content !== null) {
+          const isVueComponent = data.content.render || data.content.template || data.content.setup;
+          if (isVueComponent) {
+            const contentElement = renderVueComponent(data.content);
+            markerOptions.content = contentElement;
+            contentCleanupFns.set(markerOptions, () => {
+              if (contentElement.parentElement) {
+                render(null, contentElement.parentElement);
+              }
+            });
+          }
+        }
+        markerOptions.offset = data.offset ? new AMap.Pixel(data.offset[0], data.offset[1]) : new AMap.Pixel(-13, -34);
+      } else if (data.icon) {
+        if (typeof data.icon === "string") {
+          markerOptions.icon = data.icon;
+        } else {
+          const iconConfig = data.icon;
+          markerOptions.icon = new AMap.Icon({
+            // 图标尺寸
+            size: iconConfig.size ? new AMap.Size(iconConfig.size[0], iconConfig.size[1]) : new AMap.Size(25, 34),
+            // 图标的取图地址
+            image: iconConfig.image,
+            // 图标所用图片大小
+            imageSize: iconConfig.imageSize ? new AMap.Size(iconConfig.imageSize[0], iconConfig.imageSize[1]) : new AMap.Size(25, 34),
+            // 图标取图偏移量
+            imageOffset: iconConfig.imageOffset ? new AMap.Pixel(iconConfig.imageOffset[0], iconConfig.imageOffset[1]) : void 0
+          });
+        }
+        markerOptions.offset = data.offset ? new AMap.Pixel(data.offset[0], data.offset[1]) : new AMap.Pixel(-13, -34);
+      }
+      const marker = new AMap.Marker(markerOptions);
+      marker.on("click", (e) => {
+        emit("click", e, data);
+      });
+      marker.on("dragend", (e) => {
+        emit("dragend", e, data);
+      });
+      marker.on("mouseover", (e) => {
+        emit("mouseover", e, data);
+      });
+      marker.on("mouseout", (e) => {
+        emit("mouseout", e, data);
+      });
+      return marker;
+    }
+    function incrementalUpdate(newMarkers) {
+      if (!mapInstance)
+        return;
+      const existingMarkerIds = new Set(markers.value.map((marker) => {
+        var _a;
+        return (_a = marker.getExtData()) == null ? void 0 : _a.id;
+      }));
+      const newMarkerIds = new Set(newMarkers.map((m) => m.id));
+      markers.value.forEach((marker) => {
+        var _a;
+        const markerId = (_a = marker.getExtData()) == null ? void 0 : _a.id;
+        if (!newMarkerIds.has(markerId)) {
+          const cleanupFn = contentCleanupFns.get(marker);
+          if (cleanupFn) {
+            cleanupFn();
+            contentCleanupFns.delete(marker);
+          }
+          mapInstance == null ? void 0 : mapInstance.remove(marker);
+        }
+      });
+      const markersToAdd = newMarkers.filter((data) => {
+        return !existingMarkerIds.has(data.id);
+      });
+      if (markersToAdd.length > 0) {
+        const newMarkersList = [];
+        markersToAdd.forEach((data) => {
+          const marker = createMarker(data);
+          if (marker) {
+            newMarkersList.push(marker);
+            mapInstance == null ? void 0 : mapInstance.add(marker);
+          }
+        });
+        markers.value.push(...newMarkersList);
+      }
+    }
+    function fullUpdate(newMarkers) {
+      if (!mapInstance)
+        return;
+      removeMarkers();
+      if (newMarkers && newMarkers.length > 0) {
+        newMarkers.forEach((data) => {
+          const marker = createMarker(data);
+          if (marker) {
+            markers.value.push(marker);
+            mapInstance == null ? void 0 : mapInstance.add(marker);
+          }
+        });
+      }
+    }
+    function addMarkers() {
+      if (!mapInstance)
+        return;
+      if (props.markers && props.markers.length > 0) {
+        if (props.updateMode === "full") {
+          fullUpdate(props.markers);
+        } else {
+          incrementalUpdate(props.markers);
+        }
+      } else if (props.position) {
+        const singleMarker = {
+          position: props.position,
+          title: props.title,
+          draggable: props.draggable,
+          icon: props.icon,
+          visible: props.visible
+        };
+        const marker = createMarker(singleMarker);
+        if (marker) {
+          markers.value.push(marker);
+          mapInstance == null ? void 0 : mapInstance.add(marker);
+        }
+      }
+    }
+    function removeMarkers() {
+      if (!mapInstance || markers.value.length === 0)
+        return;
+      markers.value.forEach((marker) => {
+        const cleanupFn = contentCleanupFns.get(marker);
+        if (cleanupFn) {
+          cleanupFn();
+          contentCleanupFns.delete(marker);
+        }
+        mapInstance == null ? void 0 : mapInstance.remove(marker);
+      });
+      markers.value = [];
+    }
+    __expose({
+      getMarkers: () => markers.value,
+      clearMarkers: removeMarkers,
+      addMarker: (data) => {
+        const marker = createMarker(data);
+        if (marker && mapInstance) {
+          markers.value.push(marker);
+          mapInstance == null ? void 0 : mapInstance.add(marker);
+        }
+        return marker;
+      },
+      removeMarker: (marker) => {
+        if (mapInstance && marker) {
+          mapInstance == null ? void 0 : mapInstance.remove(marker);
+          const index = markers.value.indexOf(marker);
+          if (index > -1) {
+            markers.value.splice(index, 1);
+          }
+        }
+      }
+    });
+    onMounted(() => {
+      if (amapContext) {
+        if (mapInstance) {
+          addMarkers();
+        }
+      }
+    });
+    onUnmounted(() => {
+      removeMarkers();
+    });
+    watch(
+      () => props.markers,
+      (newMarkers, _oldMarkers) => {
+        if (!mapInstance)
+          return;
+        if (!newMarkers) {
+          removeMarkers();
+          return;
+        }
+        if (props.updateMode === "full") {
+          fullUpdate(newMarkers);
+        } else {
+          incrementalUpdate(newMarkers);
+        }
+      },
+      { immediate: true }
+    );
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
+  }
+}));
+export {
+  _sfc_main as default
+};

package/dist/es/amap/AMarker.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./AMarker.vue.js";
+/* empty css             */
+export {
+  _sfc_main as default
+};

package/dist/es/amap/index.d.ts

@@ -0,0 +1,7 @@
+import { InstallWithSFC } from '../utils';
+import { default as AMap } from './AMap.vue';
+import { default as AMarker } from './AMarker.vue';
+export declare const JkyAMap: InstallWithSFC<typeof AMap>;
+export declare const JkyAMarker: InstallWithSFC<typeof AMarker>;
+export default JkyAMap;
+export { AMarker };