tg-map-vue3 4.1.5 → 4.1.7

package/dist/tg-map.js

@@ -0,0 +1,1440 @@
+import { noop as S, typed as L, lateinit as l, path as Y, throwError as w, Arrays as Q, deepEqual as ee } from "tg-commons";
+import { Strings as F, TgMapType as D, unwrapStringEnumValue as d, loadCachedMap as te, TgMapFactory as se, BuildInMapTypeId as z, GestureHandlingOptions as W, bindEvents as v, MapType as re, Objects as oe, InfoWindowModeValues as ie, LatLng as y, dimen as ae, ControlPosition as c, CustomControl as ne, MapTypeControlType as le, TrafficLayer as he, MapPane as x, ElementOverlay as de, BaiduMarker as G, setTgMapConfig as pe } from "tg-map-core";
+export * from "tg-map-core";
+import { createCommentVNode as Z, computed as q, defineComponent as n, markRaw as ce, watch as k, createElementBlock as $, openBlock as C, mergeProps as I, createElementVNode as me, renderSlot as f, normalizeClass as A, normalizeStyle as ue, getCurrentInstance as fe, inject as ye, onBeforeUnmount as ve, onMounted as ge, toRaw as B, withDirectives as be, vShow as $e } from "vue";
+import "tg-map-core/dist/tg-map-core.css";
+function u(e, t) {
+  return {
+    type: String,
+    default: t,
+    validator: (r) => Object.values(e).includes(r)
+  };
+}
+function Ce(e, t) {
+  return {
+    type: String,
+    default: t,
+    validator: (r) => e.includes(r)
+  };
+}
+function m(e) {
+  return {
+    type: e,
+    required: !0
+  };
+}
+function s(e, t) {
+  return {
+    type: e,
+    default: t
+  };
+}
+function Qe(e) {
+  const t = {};
+  return Object.entries(e).forEach(([r, o]) => {
+    const i = `__${r}`;
+    t[r] = {
+      get() {
+        const a = this[i];
+        return a === void 0 ? o : a;
+      },
+      set(a) {
+        this[i] = a;
+      }
+      // Vue3已经不支持该属性
+      // cache: false
+    };
+  }), t;
+}
+const T = {
+  enumerable: !0,
+  configurable: !0,
+  get: S,
+  set: S
+};
+function _e(e) {
+  return Object.keys(e).forEach((t) => {
+    const r = e[t];
+    let o = !1;
+    typeof r == "function" ? (T.get = r, T.set = S, o = !0) : typeof r == "object" && typeof r.get == "function" && (T.get = r.get, T.set = r.set, o = !0), o && (e[t] = Object.defineProperty(e, t, T));
+  }), e;
+}
+function et(e) {
+  return _e(e);
+}
+function E() {
+  return Z();
+}
+function M(e, t) {
+  const r = e.$options[t];
+  if (r)
+    for (const o of r)
+      o.call(e);
+}
+function tt(e, t) {
+  for (const r of e)
+    if (r.$options.name === t.name)
+      return r;
+}
+function st(e, t) {
+  if (!e.default) return;
+  const r = e.default();
+  for (const o of r)
+    if ((o == null ? void 0 : o.type).name === t.name)
+      return o;
+}
+function ke(e, t) {
+  const r = {}, o = {}, i = {};
+  return Object.keys(e).forEach((a) => {
+    a.startsWith("on") ? r[F.pascal2kebab(a.substring(2))] = e[a] : o[a] = e[a];
+  }), t && Object.keys(t).forEach((a) => {
+    a.startsWith("on") && (i[F.pascal2kebab(a.substring(2))] = t[a]);
+  }), {
+    /** class/style/未声明的属性 等 */
+    binds: o,
+    /** 未声明的事件 */
+    listeners: r,
+    /** 声明在`props`中的事件 */
+    listenerProps: i
+  };
+}
+function g(e, t) {
+  return q(() => ke(e, t));
+}
+function h() {
+  return Function;
+}
+const rt = () => {
+  let e, t;
+  function r(i) {
+    console.log(i), e = i && i.type, t = Date.now();
+  }
+  function o(i) {
+    ((i && i.type) !== e || Date.now() - (t ?? 0) > 1e3) && r(i);
+  }
+  return { eventLog: r, eventLogLess: o };
+};
+function R(e, t) {
+  return (e == null ? void 0 : e.$options.name) === t.name;
+}
+function X(e, t) {
+  return R(e, t) ? e : void 0;
+}
+function U(e, t, r) {
+  let o = t;
+  for (; o; ) {
+    if (R(o, e))
+      return o;
+    if (r && R(o, r))
+      return;
+    o = o.$parent;
+  }
+}
+const j = "$map", O = "onCreate", P = "onDestroy", p = n({
+  inject: [j],
+  mounted() {
+    M(this, O);
+  },
+  beforeUnmount() {
+    M(this, P);
+  },
+  methods: {
+    recreate() {
+      M(this, P), M(this, O);
+    }
+  },
+  render() {
+    return E();
+  }
+}), Te = {
+  /** type没做响应式, 但外部可以把type作为tg-map的key, 让type修改时完全重建tg-map */
+  type: u(D, D.google),
+  /**
+   * 当对该属性使用双向绑定时, 改变center将触发update:center又反过来触发center改变, 最终导致无限循环...
+   * 当前通过setCenter()时判断center是否有改变来避免该问题, 但为了避免可能存在的问题, 另外设计了如下机制:
+   * - :center-sync-delay="300": 延时同步center, 防止center的值更新过快
+   * - :current-center.sync="currentCenter": 实时获取center的值
+   * - :last-center.sync="center": 获取tg-map销毁时的最后的center的值, 使用这种方式可以做到type切换时保留中心点位置
+   * @see AbstractMapEventMap.center-changed
+   */
+  center: m(y),
+  /**
+   * 同步center的延时
+   * @default 300
+   * @see center
+   */
+  centerSyncDelay: s(Number, 300),
+  /**
+   * 仅用来获取center的值, 需要设置center的值请使用`center`属性
+   * @see center
+   * @deprecated 用的太少, 故maptalks未实现该属性, 要实时获取中心点, 请将{@link centerSyncDelay}设为0
+   */
+  currentCenter: s(y),
+  /**
+   * 仅用于获取tg-map销毁时的最后的center的值
+   * @see center
+   * @deprecated 用的太少, 故maptalks未实现该属性
+   */
+  lastCenter: s(y),
+  zoom: m(Number),
+  /**
+   * 该属性不会响应式更新, 要让它立即生效, 请参考{@link file://./../views/map/InfoDemo.vue#L3}
+   * @see MapOptions.infoWindowMode
+   */
+  infoWindowMode: Ce(ie),
+  gestureHandling: u(W),
+  fractionalZoom: s(Boolean),
+  minZoom: s(Number),
+  maxZoom: s(Number),
+  mapStyle: s(Object),
+  mapTypeId: u(z),
+  /** 地图类型对象, 优先级比mapTypeId高 */
+  mapType: s(Object),
+  hideLogo: s(Boolean),
+  onLoad: h(),
+  "onUpdate:center": h(),
+  "onUpdate:current-center": h(),
+  "onUpdate:last-center": h(),
+  "onUpdate:map-type": h(),
+  "onUpdate:map-type-id": h(),
+  "onUpdate:zoom": h(),
+  onError: h()
+}, Oe = n({
+  name: "tg-map",
+  provide() {
+    return {
+      [j]: q(() => this.map)
+    };
+  },
+  inheritAttrs: !1,
+  props: Te,
+  /** 声明事件的类型信息, 详见: {@link splitAttrs} */
+  emits: void 0,
+  setup(e, { attrs: t }) {
+    return {
+      attrs: g(t, e),
+      centerSyncTimeoutId: void 0
+    };
+  },
+  data() {
+    return {
+      map: L(),
+      isDestroyed: !1
+    };
+  },
+  computed: {
+    propsJson() {
+      return oe.toJsonSafely(this.$props);
+    }
+  },
+  watch: {
+    gestureHandling(e) {
+      var t;
+      e && ((t = this.map) == null || t.setGestureHandling(d(e, W)));
+    },
+    minZoom(e) {
+      var t;
+      (t = this.map) == null || t.setMinZoom(e);
+    },
+    maxZoom(e) {
+      var t;
+      (t = this.map) == null || t.setMaxZoom(e);
+    },
+    mapStyle(e) {
+      var t;
+      (t = this.map) == null || t.setMapStyle(e);
+    },
+    mapTypeId(e) {
+      var t;
+      e && ((t = this.map) == null || t.setBuildInMapTypeId(d(e, z)));
+    },
+    mapType(e) {
+      var t;
+      (t = this.map) == null || t.setMapType(e ?? re.NORMAL);
+    },
+    hideLogo(e) {
+      var t;
+      (t = this.map) == null || t.setHideLogo(e ?? !1);
+    },
+    fractionalZoom(e) {
+      var t;
+      (t = this.map) == null || t.setFractionalZoom(e ?? !1);
+    }
+  },
+  async mounted() {
+    const e = d(this.type, D);
+    try {
+      await te(e);
+    } catch (i) {
+      this.$emit("error", i);
+      return;
+    }
+    if (this.isDestroyed) {
+      console.warn(`tg-map(type=${e})已销毁, 不需要继续执行`);
+      return;
+    }
+    const t = se.createMap(
+      e,
+      this.$refs.map,
+      /* options: */
+      {
+        center: this.center,
+        zoom: this.zoom,
+        infoWindowMode: this.infoWindowMode,
+        gestureHandling: d(this.gestureHandling, W),
+        minZoom: this.minZoom,
+        maxZoom: this.maxZoom,
+        mapStyle: this.mapStyle,
+        buildInMapTypeId: d(this.mapTypeId, z),
+        hideLogo: this.hideLogo,
+        fractionalZoom: this.fractionalZoom
+      }
+    );
+    if (this.map = ce(t), this.mapType && t.setMapType(this.mapType), "ready" in this.attrs.listeners && console.error("地图载入完成的事件已经从ready改为了load, 请手动修改"), v(
+      this.attrs.listeners,
+      t,
+      /* excludes: */
+      ["load"]
+    ), this.$emit("load", t), k([
+      () => this.zoom,
+      () => this.center
+      //
+    ], ([i, a], [_, J]) => {
+      i !== _ && t.setZoom(i), a !== J && (t.getCenter().equals(a) || t.setCenter(a));
+    }), this.attrs.listenerProps["update:center"]) {
+      const i = () => this.$emit("update:center", t.getCenter());
+      t.addEventListener("center-changed", () => {
+        this.centerSyncDelay > 0 ? (clearTimeout(this.centerSyncTimeoutId), this.centerSyncTimeoutId = setTimeout(i, this.centerSyncDelay)) : i();
+      });
+    }
+    this.attrs.listenerProps["update:current-center"] && (this.$emit("update:current-center", this.center), t.addEventListener("center-changed", () => {
+      this.$emit("update:current-center", t.getCenter());
+    })), this.attrs.listenerProps["update:zoom"] && t.addEventListener("zoom-changed", () => {
+      this.$emit("update:zoom", t.getZoom());
+    });
+    const r = this.attrs.listenerProps["update:map-type"], o = this.attrs.listenerProps["update:map-type-id"];
+    (r || o) && t.addEventListener("map-type-changed", () => {
+      const i = t.getMapType();
+      r && this.$emit("update:map-type", i), o && this.$emit("update:map-type-id", i.id);
+    });
+  },
+  unmounted() {
+    this.isDestroyed = !0, this.map && (this.attrs.listenerProps["update:last-center"] && this.$emit("update:last-center", this.map.getCenter()), this.attrs.listenerProps["update:center"] && (clearTimeout(this.centerSyncTimeoutId), this.$emit("update:center", this.map.getCenter())));
+  },
+  methods: {}
+}), b = (e, t) => {
+  const r = e.__vccOpts || e;
+  for (const [o, i] of t)
+    r[o] = i;
+  return r;
+};
+function Pe(e, t, r, o, i, a) {
+  return C(), $("div", I({ class: "tg-map" }, e.attrs.binds), [
+    me("div", {
+      ref: "map",
+      class: A({
+        "tg-map__map": !0,
+        [`tg-map__map--hide-logo-${e.type}`]: e.hideLogo
+      })
+    }, null, 2),
+    Z("", !0),
+    e.map ? f(e.$slots, "default", { key: 1 }) : Z("", !0),
+    f(e.$slots, "overlay")
+  ], 16);
+}
+const N = /* @__PURE__ */ b(Oe, [["render", Pe]]), Ie = n({
+  name: "tg-map-widget",
+  props: {
+    left: {
+      type: [Number, String],
+      default: null
+    },
+    top: {
+      type: [Number, String],
+      default: null
+    },
+    right: {
+      type: [Number, String],
+      default: null
+    },
+    bottom: {
+      type: [Number, String],
+      default: null
+    }
+  },
+  computed: {
+    topValue() {
+      return this.top == null && this.bottom == null ? 0 : this.top;
+    }
+  },
+  methods: {
+    dimen: ae
+  }
+});
+function we(e, t, r, o, i, a) {
+  return C(), $("div", {
+    class: A(e.$options.name),
+    style: ue({ left: e.dimen(e.left), top: e.dimen(e.topValue), right: e.dimen(e.right), bottom: e.dimen(e.bottom) })
+  }, [
+    f(e.$slots, "default")
+  ], 6);
+}
+const ot = /* @__PURE__ */ b(Ie, [["render", we]]), Me = n({
+  name: "tg-custom-control",
+  mixins: [p],
+  props: {
+    position: u(c, c.RIGHT_BOTTOM)
+  },
+  setup() {
+    return {
+      control: l()
+    };
+  },
+  watch: {
+    position() {
+      this.recreate();
+    }
+  },
+  onCreate() {
+    X(this.$parent, N) || console.warn("请将tg-custom-control放到tg-map中");
+    const { $el: e } = this, t = class extends ne {
+      onCreateElement() {
+        return e;
+      }
+    };
+    this.control = new t(d(this.position, c)), this.$map.addCustomControl(this.control);
+  },
+  onDestroy() {
+    this.$map.removeCustomControl(this.control);
+  }
+});
+function Se(e, t, r, o, i, a) {
+  return C(), $("div", {
+    class: A(e.$options.name)
+  }, [
+    f(e.$slots, "default")
+  ], 2);
+}
+const it = /* @__PURE__ */ b(Me, [["render", Se]]), at = n({
+  name: "tg-map-type-control",
+  mixins: [p],
+  props: {
+    position: u(c, c.TOP_LEFT),
+    type: u(le),
+    mapTypes: s(Array)
+  },
+  setup() {
+    return {
+      control: l()
+    };
+  },
+  watch: {
+    position(e) {
+      this.control.setPosition(e);
+    },
+    type() {
+      this.recreate();
+    },
+    mapTypes: {
+      handler() {
+        this.recreate();
+      },
+      deep: !0
+    }
+  },
+  onCreate() {
+    this.control = this.$map.createMapTypeControl(d(this)), this.$map.addControl(this.control);
+  },
+  onDestroy() {
+    this.$map.removeControl(this.control);
+  }
+}), nt = n({
+  name: "tg-scale-control",
+  mixins: [p],
+  props: {
+    position: u(c, c.BOTTOM_RIGHT)
+  },
+  setup() {
+    return {
+      control: l()
+    };
+  },
+  watch: {
+    position(e) {
+      this.control.setPosition(e);
+    }
+  },
+  onCreate() {
+    this.control = this.$map.createScaleControl(d(this)), this.$map.addControl(this.control);
+  },
+  onDestroy() {
+    this.$map.removeControl(this.control);
+  }
+});
+function K() {
+  var r;
+  const e = (r = fe()) == null ? void 0 : r.type;
+  let t = (e == null ? void 0 : e.name) ?? (e == null ? void 0 : e.__name);
+  if (!t) {
+    const o = e == null ? void 0 : e.__file;
+    o && (t = Y.basename(o, ".vue"));
+  }
+  return t;
+}
+function H() {
+  const e = ye(j);
+  let t, r;
+  return e == null && w(`<${K() || "unknown"}>必须作为<tg-map>的子代组件`), {
+    mapRef: e,
+    /** 读取map对象, 只要放在<tg-map>里面的组件(除#overlay插槽外)都能够立即读取到map对象 */
+    get map() {
+      return e.value ?? w("map尚未初始化");
+    },
+    /** 地图元素创建回调 */
+    [O](o) {
+      ge(o), t && w(`${O}只能调用一次`), t = o;
+    },
+    /** 地图元素销毁回调 */
+    [P](o) {
+      ve(o), r && w(`${P}只能调用一次`), r = o;
+    },
+    /** 重新创建地图元素 */
+    recreate() {
+      r == null || r(), t == null || t();
+    }
+  };
+}
+const lt = n({
+  name: "tg-street-view-control",
+  props: {
+    position: u(c, c.RIGHT_BOTTOM)
+  },
+  setup(e) {
+    let t = l();
+    const { map: r, onCreate: o, onDestroy: i } = H();
+    return o(() => {
+      t = r.createStreetViewControl(d(e)), r.addControl(t);
+    }), i(() => {
+      r.removeControl(t);
+    }), k(() => e.position, (a) => {
+      t.setPosition(d(a, c));
+    }), E;
+  }
+}), ht = n({
+  name: "tg-zoom-control",
+  props: {
+    position: u(c, c.RIGHT_BOTTOM),
+    showZoomLevel: s(Boolean)
+  },
+  setup(e) {
+    let t = l();
+    const { map: r, onCreate: o, onDestroy: i } = H();
+    return o(() => {
+      t = r.createZoomControl(d(e)), r.addControl(t);
+    }), i(() => {
+      r.removeControl(t);
+    }), k(() => e.position, (a) => {
+      t.setPosition(d(a, c));
+    }), k(() => e.showZoomLevel, (a) => {
+      t.setShowZoomLevel(a ?? !0);
+    }), E;
+  }
+}), dt = n({
+  name: "tg-heatmap",
+  props: {
+    maxIntensity: s(Number),
+    gradient: s(Object),
+    opacity: s(Number),
+    radius: s(Number),
+    data: m(Array)
+  },
+  setup(e) {
+    const { map: t, onCreate: r, onDestroy: o } = H();
+    let i = l();
+    return r(() => {
+      i = t.createHeatmap(e);
+    }), o(() => {
+      i.remove();
+    }), k(() => e.data, (a) => i.setData(a)), k(
+      [() => e.maxIntensity, () => e.gradient, () => e.opacity, () => e.radius],
+      () => i.setOptions(e)
+    ), E;
+  }
+}), Le = n({
+  name: "tg-marker-clusterer",
+  mixins: [p],
+  // markers从this.$children中读取, 故需要省略(Omit)
+  props: {
+    gridSize: s(Number),
+    maxZoom: s(Number),
+    minClusterSize: s(Number),
+    averageCenter: s(Boolean),
+    styles: s(Array),
+    stylesIndexCalculator: s(Function),
+    zIndex: s(Number)
+  },
+  setup() {
+    return {
+      clusterer: l(),
+      markers: L([])
+    };
+  },
+  watch: {
+    gridSize() {
+      this.recreate();
+    },
+    maxZoom() {
+      this.recreate();
+    },
+    minClusterSize() {
+      this.recreate();
+    },
+    averageCenter() {
+      this.recreate();
+    },
+    styles: {
+      handler() {
+        this.recreate();
+      },
+      deep: !0
+    },
+    stylesIndexCalculator() {
+      this.recreate();
+    },
+    zIndex() {
+      this.recreate();
+    }
+  },
+  onCreate() {
+    this.clusterer = this.$map.createMarkerClusterer(this);
+  },
+  onDestroy() {
+    this.clusterer.clearMarkers(!0);
+  },
+  methods: {
+    /** TgMarker有可能在该组件未初始化之前调用, 需要通过该方法判断 */
+    isInitiated() {
+      return this.clusterer != null;
+    },
+    onAddMarker(e) {
+      this.markers.push(e), this.isInitiated() && this.clusterer.addMarker(e);
+    },
+    onRemoveMarker(e) {
+      this.isInitiated() && this.clusterer.removeMarker(e), Q.remove(this.markers, e);
+    }
+  }
+});
+function xe(e, t, r, o, i, a) {
+  return C(), $("div", {
+    class: A(e.$options.name)
+  }, [
+    f(e.$slots, "default")
+  ], 2);
+}
+const Ae = /* @__PURE__ */ b(Le, [["render", xe]]), pt = n({
+  name: "tg-traffic-layer",
+  mixins: [p],
+  // 请直接使用v-if来控制它的显隐
+  // 没有属性时, 写`{}`类型推断会有问题, 故注释掉
+  // props: {} satisfies Props<{}>,
+  setup() {
+    return {
+      layer: l()
+    };
+  },
+  watch: {},
+  onCreate() {
+    this.layer = new he(), this.$map.addLayer(this.layer);
+  },
+  onDestroy() {
+    this.$map.removeLayer(this.layer);
+  }
+}), ct = n({
+  name: "tg-circle",
+  mixins: [p],
+  inheritAttrs: !1,
+  props: {
+    center: m(y),
+    radius: m(Number),
+    clickable: s(Boolean),
+    editable: s(Boolean),
+    strokeColor: s(String),
+    strokeOpacity: s(Number),
+    strokeWeight: s(Number),
+    visible: s(Boolean),
+    zIndex: s(Number),
+    fillColor: s(String),
+    fillOpacity: s(Number),
+    "onUpdate:center": h(),
+    "onUpdate:radius": h()
+  },
+  emits: void 0,
+  setup(e, { attrs: t }) {
+    return {
+      attrs: g(t, e),
+      overlay: l(),
+      emittedRadius: void 0,
+      emittedCenter: void 0
+    };
+  },
+  watch: {
+    center(e) {
+      if (this.emittedCenter != null) {
+        const t = this.emittedCenter;
+        if (this.emittedCenter = void 0, t === B(e))
+          return;
+      }
+      this.overlay.setCenter(e);
+    },
+    radius(e) {
+      if (this.emittedRadius != null) {
+        const t = this.emittedRadius;
+        if (this.emittedRadius = void 0, t === e)
+          return;
+      }
+      this.overlay.setRadius(e);
+    },
+    clickable() {
+      this.recreate();
+    },
+    editable(e) {
+      this.overlay.setEditable(e);
+    },
+    strokeColor(e) {
+      this.overlay.setStrokeColor(e);
+    },
+    strokeOpacity(e) {
+      this.overlay.setStrokeOpacity(e);
+    },
+    strokeWeight(e) {
+      this.overlay.setStrokeWeight(e);
+    },
+    fillColor(e) {
+      this.overlay.setFillColor(e);
+    },
+    fillOpacity(e) {
+      this.overlay.setFillOpacity(e);
+    },
+    visible(e) {
+      this.overlay.setVisible(e);
+    },
+    zIndex(e) {
+      this.overlay.setZIndex(e);
+    }
+  },
+  onCreate() {
+    this.overlay = this.$map.createCircle(this), this.$map.addOverlay(this.overlay), v(this.attrs.listeners, this.overlay), this.attrs.listenerProps["update:center"] && this.overlay.addEventListener("center-changed", () => {
+      this.$emit("update:center", this.emittedCenter = this.overlay.getCenter());
+    }), this.attrs.listenerProps["update:radius"] && this.overlay.addEventListener("radius-changed", () => {
+      this.$emit("update:radius", this.emittedRadius = this.overlay.getRadius());
+    });
+  },
+  onDestroy() {
+    this.$map.removeOverlay(this.overlay);
+  }
+});
+class Be extends de {
+  constructor(t, r, o, i) {
+    super(t, r), this.content = o, this.position = i;
+  }
+  onCreate() {
+    return this.content;
+  }
+  onDraw(t) {
+    const r = t.fromLatLngToOverlayPoint(this.position);
+    this.content.style.left = r.x + "px", this.content.style.top = r.y + "px";
+  }
+  setPosition(t) {
+    this.position = t, this.draw();
+  }
+}
+const Ee = n({
+  name: "tg-element-overlay",
+  mixins: [p],
+  props: {
+    mapPane: u(x, x.overlayMouseTarget),
+    position: m(y)
+  },
+  setup() {
+    return {
+      overlay: l()
+    };
+  },
+  watch: {
+    position(e) {
+      this.overlay.setPosition(e);
+    },
+    mapPane() {
+      this.recreate();
+    }
+  },
+  methods: {
+    content() {
+      return this.$el;
+    }
+  },
+  onCreate() {
+    this.overlay = new Be(this.$map, d(this), this.content(), this.position), this.$map.addElementOverlay(this.overlay);
+  },
+  onDestroy() {
+    this.$map.removeElementOverlay(this.overlay);
+  }
+});
+function Ne(e, t, r, o, i, a) {
+  return C(), $("div", I({
+    class: e.$options.name
+  }, e.$attrs), [
+    f(e.$slots, "default")
+  ], 16);
+}
+const mt = /* @__PURE__ */ b(Ee, [["render", Ne]]), De = {
+  position: m(y),
+  title: s(String),
+  label: s(Object),
+  icon: s(Object),
+  clickable: s(Boolean),
+  draggable: s(Boolean),
+  crossOnDrag: s(Boolean),
+  cursor: s(String),
+  zIndex: s(Number),
+  visible: s(Boolean),
+  normalizePositionForBaidu: s(Boolean),
+  /**
+     * 是否自动添加到TgMarkerClusterer中去
+     * @default true
+     */
+  autoAddToClusterer: s(Boolean, !0),
+  "onUpdate:position": h()
+}, ze = n({
+  name: "tg-marker",
+  mixins: [p],
+  inheritAttrs: !1,
+  props: De,
+  emits: void 0,
+  setup(e, { attrs: t }) {
+    return {
+      attrs: g(t, e),
+      marker: l(),
+      labelOverlay: L(),
+      info: L(),
+      emittedPosition: void 0,
+      autoAddToClustererWhenCreate: e.autoAddToClusterer
+    };
+  },
+  watch: {
+    position(e) {
+      if (this.emittedPosition != null) {
+        const t = this.emittedPosition;
+        if (this.emittedPosition = void 0, t === B(e))
+          return;
+      }
+      this.marker.setPosition(e);
+    },
+    title(e) {
+      this.marker.setTitle(e);
+    },
+    label(e, t) {
+      ee(e, t) || (e ? this.marker.setLabel(e) : this.recreate());
+    },
+    icon(e) {
+      e ? this.marker.setIcon(e) : this.recreate();
+    },
+    clickable(e) {
+      this.marker instanceof G ? this.recreate() : this.marker.setClickable(e);
+    },
+    draggable(e) {
+      this.marker.setDraggable(e);
+    },
+    crossOnDrag() {
+      this.recreate();
+    },
+    cursor() {
+      this.recreate();
+    },
+    zIndex(e) {
+      this.marker instanceof G ? this.recreate() : this.marker.setZIndex(e);
+    },
+    visible(e) {
+      this.marker.setVisible(e);
+    },
+    normalizePositionForBaidu() {
+      this.recreate();
+    },
+    autoAddToClusterer() {
+      this.recreate();
+    }
+  },
+  onCreate() {
+    this.marker = this.$map.createMarker(this), this.labelOverlay && this.marker.attachLabelOverlay(this.labelOverlay.overlay), this.$clusterer() && this.autoAddToClusterer ? this.$clusterer().onAddMarker(this.marker) : this.$map.addOverlay(this.marker), this.autoAddToClustererWhenCreate = this.autoAddToClusterer, this.info && this.info.show && this.info.overlay.open(this.marker), v(this.attrs.listeners, this.marker), this.attrs.listenerProps["update:position"] && this.marker.addEventListener("dragend", (e) => {
+      this.$emit("update:position", this.emittedPosition = e.position);
+    });
+  },
+  onDestroy() {
+    this.$clusterer() && this.autoAddToClustererWhenCreate ? this.$clusterer().onRemoveMarker(this.marker) : this.$map.removeOverlay(this.marker);
+  },
+  methods: {
+    $clusterer() {
+      return X(this.$parent, Ae);
+    },
+    onAddLabel(e) {
+      this.labelOverlay = e, this.marker && this.marker.attachLabelOverlay(e.overlay);
+    },
+    onRemoveLabel(e) {
+      this.marker.attachLabelOverlay(void 0), this.labelOverlay = void 0;
+    },
+    onAddInfo(e) {
+      this.info = e, this.marker && e.show && e.overlay.open(this.marker);
+    },
+    onRemoveInfo(e) {
+      e.overlay.close(), this.info = void 0;
+    },
+    onInfoShowChanged(e, t) {
+      t ? e.overlay.open(this.marker) : e.overlay.close();
+    }
+  }
+});
+function We(e, t, r, o, i, a) {
+  return f(e.$slots, "default");
+}
+const V = /* @__PURE__ */ b(ze, [["render", We]]), Ze = n({
+  name: "tg-info-box",
+  mixins: [p],
+  inheritAttrs: !1,
+  props: {
+    show: m(Boolean),
+    position: s(y),
+    offset: s(Object),
+    maxWidth: s(Number),
+    borderClass: s(String),
+    zIndex: s(Number),
+    disableAutoPan: s(Boolean),
+    "onUpdate:show": h()
+  },
+  emits: void 0,
+  setup(e, { attrs: t }) {
+    return {
+      attrs: g(t, e),
+      overlay: l()
+    };
+  },
+  watch: {
+    show(e) {
+      this.$marker() ? this.$marker().onInfoShowChanged(this, e) : e ? this.overlay.open() : this.overlay.close();
+    },
+    position(e) {
+      this.overlay.setPosition(e);
+    },
+    offset() {
+      this.recreate();
+    },
+    maxWidth(e) {
+      this.overlay.setMaxWidth(e);
+    },
+    borderClass() {
+      this.recreate();
+    },
+    zIndex(e) {
+      this.overlay.setZIndex(e);
+    },
+    disableAutoPan() {
+      this.recreate();
+    }
+  },
+  onCreate() {
+    this.overlay = this.$map.createInfoBox(this.getOptions()), this.$marker() ? this.$marker().onAddInfo(this) : this.show && this.overlay.open(), this.attrs.listenerProps["update:show"] && this.overlay.addEventListener("closeclick", () => {
+      this.$emit("update:show", !1);
+    }), v(this.attrs.listeners, this.overlay);
+  },
+  onDestroy() {
+    this.$marker() ? this.$marker().onRemoveInfo(this) : this.overlay.close();
+  },
+  methods: {
+    getOptions() {
+      return {
+        content: this.content(),
+        position: this.position,
+        offset: this.offset,
+        zIndex: this.zIndex,
+        maxWidth: this.maxWidth,
+        borderClass: this.borderClass,
+        disableAutoPan: this.disableAutoPan
+      };
+    },
+    content() {
+      return this.$el;
+    },
+    $marker() {
+      return U(V, this.$parent, N);
+    },
+    open(e) {
+      this.overlay.open(e);
+    },
+    close() {
+      this.overlay.close();
+    }
+  }
+});
+function Re(e, t, r, o, i, a) {
+  return C(), $("div", I({
+    class: e.$options.name
+  }, e.attrs.binds), [
+    f(e.$slots, "default")
+  ], 16);
+}
+const ut = /* @__PURE__ */ b(Ze, [["render", Re]]), Ue = n({
+  name: "tg-info-window",
+  mixins: [p],
+  inheritAttrs: !1,
+  props: {
+    show: m(Boolean),
+    position: s(y),
+    maxWidth: s(Number),
+    offset: s(Object),
+    disableAutoPan: s(Boolean),
+    "onUpdate:show": h()
+  },
+  emits: void 0,
+  setup(e, { attrs: t }) {
+    return {
+      attrs: g(t, e),
+      overlay: l()
+    };
+  },
+  watch: {
+    show(e) {
+      this.$marker() ? this.$marker().onInfoShowChanged(this, e) : e ? this.overlay.open() : this.overlay.close();
+    },
+    position(e) {
+      this.overlay.setPosition(e);
+    },
+    maxWidth() {
+      this.recreate();
+    },
+    offset() {
+      this.recreate();
+    },
+    disableAutoPan() {
+      this.recreate();
+    }
+  },
+  methods: {
+    content() {
+      return this.$el;
+    },
+    $marker() {
+      return U(V, this.$parent, N);
+    },
+    getOptions() {
+      return {
+        content: this.content(),
+        position: this.position,
+        maxWidth: this.maxWidth,
+        offset: this.offset,
+        disableAutoPan: this.disableAutoPan
+      };
+    }
+  },
+  onCreate() {
+    this.overlay = this.$map.createInfoWindow(this.getOptions()), this.$marker() ? this.$marker().onAddInfo(this) : this.show && this.overlay.open(), this.overlay.addEventListener("open", () => {
+      this.$emit("update:show", !0);
+    }), this.overlay.addEventListener("close", () => {
+      this.$emit("update:show", !1);
+    }), v(this.attrs.listeners, this.overlay);
+  },
+  onDestroy() {
+    this.$marker() ? this.$marker().onRemoveInfo(this) : this.overlay.close();
+  }
+});
+function je(e, t, r, o, i, a) {
+  return be((C(), $("div", I({
+    class: e.$options.name
+  }, e.attrs.binds), [
+    f(e.$slots, "default")
+  ], 16)), [
+    [$e, e.show]
+  ]);
+}
+const ft = /* @__PURE__ */ b(Ue, [["render", je]]), He = n({
+  name: "tg-label",
+  mixins: [p],
+  inheritAttrs: !1,
+  props: {
+    position: s(y),
+    offset: s(Object),
+    zIndex: s(Number),
+    mapPane: u(x)
+  },
+  emits: void 0,
+  setup(e, { attrs: t }) {
+    return {
+      attrs: g(t),
+      overlay: l()
+    };
+  },
+  watch: {
+    position(e) {
+      this.overlay.setPosition(e);
+    },
+    offset(e) {
+      this.overlay.setOffset(e);
+    },
+    zIndex(e) {
+      this.overlay.setZIndex(e);
+    },
+    visible(e) {
+      this.overlay.setVisible(e);
+    },
+    mapPane() {
+      this.recreate();
+    }
+  },
+  methods: {
+    content() {
+      return this.$el;
+    },
+    marker() {
+      var e;
+      return (e = this.$marker()) == null ? void 0 : e.marker;
+    },
+    $marker() {
+      return U(V, this.$parent, N);
+    },
+    getOptions() {
+      return {
+        content: this.content(),
+        position: this.position,
+        offset: this.offset,
+        zIndex: this.zIndex,
+        mapPane: d(this.mapPane, x)
+      };
+    }
+  },
+  onCreate() {
+    this.overlay = this.$map.createLabel(this.getOptions()), this.$marker() ? this.$marker().onAddLabel(this) : this.$map.addOverlay(this.overlay), v(this.attrs.listeners, this.overlay);
+  },
+  onDestroy() {
+    this.$marker() ? this.$marker().onRemoveLabel(this) : this.$map.removeOverlay(this.overlay);
+  }
+});
+function Ve(e, t, r, o, i, a) {
+  return C(), $("div", I({
+    class: e.$options.name
+  }, e.attrs.binds), [
+    f(e.$slots, "default")
+  ], 16);
+}
+const yt = /* @__PURE__ */ b(He, [["render", Ve]]), Fe = {
+  paths: m(Array),
+  clickable: s(Boolean),
+  editable: s(Boolean),
+  strokeColor: s(String),
+  strokeOpacity: s(Number),
+  strokeWeight: s(Number),
+  visible: s(Boolean),
+  zIndex: s(Number),
+  fillColor: s(String),
+  fillOpacity: s(Number),
+  "onUpdate:paths": h()
+}, vt = n({
+  name: "tg-polygon",
+  mixins: [p],
+  inheritAttrs: !1,
+  props: Fe,
+  emits: void 0,
+  setup(e, { attrs: t }) {
+    return {
+      attrs: g(t, e),
+      overlay: l(),
+      emittedPaths: void 0
+    };
+  },
+  watch: {
+    paths: {
+      handler(e) {
+        if (this.emittedPaths != null) {
+          const t = this.emittedPaths;
+          if (this.emittedPaths = void 0, t.length === e.length && t.every((r, o) => r === B(e[o])))
+            return;
+        }
+        this.overlay.setPaths(e);
+      },
+      deep: !0
+    },
+    clickable() {
+      this.recreate();
+    },
+    editable(e) {
+      this.overlay.setEditable(e);
+    },
+    strokeColor(e) {
+      this.overlay.setStrokeColor(e);
+    },
+    strokeOpacity(e) {
+      this.overlay.setStrokeOpacity(e);
+    },
+    strokeWeight(e) {
+      this.overlay.setStrokeWeight(e);
+    },
+    fillColor(e) {
+      this.overlay.setFillColor(e);
+    },
+    fillOpacity(e) {
+      this.overlay.setFillOpacity(e);
+    },
+    visible(e) {
+      this.overlay.setVisible(e);
+    },
+    zIndex(e) {
+      this.overlay.setZIndex(e);
+    }
+  },
+  onCreate() {
+    this.overlay = this.$map.createPolygon(this), this.$map.addOverlay(this.overlay), v(this.attrs.listeners, this.overlay), this.attrs.listenerProps["update:paths"] && this.overlay.addEventListener("paths-edited", () => {
+      this.$emit("update:paths", this.emittedPaths = this.overlay.getPaths());
+    });
+  },
+  onDestroy() {
+    this.$map.removeOverlay(this.overlay);
+  }
+}), gt = n({
+  name: "tg-polyline",
+  mixins: [p],
+  inheritAttrs: !1,
+  props: {
+    path: m(Array),
+    icons: s(Array),
+    clickable: s(Boolean),
+    editable: s(Boolean),
+    strokeColor: s(String),
+    strokeOpacity: s(Number),
+    strokeWeight: s(Number),
+    visible: s(Boolean),
+    zIndex: s(Number),
+    "onUpdate:path": h()
+  },
+  emits: void 0,
+  setup(e, { attrs: t }) {
+    return {
+      attrs: g(t, e),
+      overlay: l(),
+      emittedPath: void 0
+    };
+  },
+  watch: {
+    path: {
+      handler(e) {
+        if (this.emittedPath != null) {
+          const t = this.emittedPath;
+          if (this.emittedPath = void 0, t === B(e))
+            return;
+        }
+        this.overlay.setPath(e);
+      },
+      deep: !0
+    },
+    icons: {
+      handler() {
+        this.recreate();
+      },
+      deep: !0
+    },
+    clickable() {
+      this.recreate();
+    },
+    editable(e) {
+      this.overlay.setEditable(e);
+    },
+    strokeColor(e) {
+      this.overlay.setStrokeColor(e);
+    },
+    strokeOpacity(e) {
+      this.overlay.setStrokeOpacity(e);
+    },
+    strokeWeight(e) {
+      this.overlay.setStrokeWeight(e);
+    },
+    visible(e) {
+      this.overlay.setVisible(e);
+    },
+    zIndex(e) {
+      this.overlay.setZIndex(e);
+    }
+  },
+  onCreate() {
+    this.overlay = this.$map.createPolyline(this), this.$map.addOverlay(this.overlay), v(this.attrs.listeners, this.overlay), this.attrs.listenerProps["update:path"] && this.overlay.addEventListener("path-edited", () => {
+      this.$emit("update:path", this.emittedPath = this.overlay.getPath());
+    });
+  },
+  onDestroy() {
+    this.overlay.remove();
+  }
+}), bt = n({
+  name: "tg-rectangle",
+  mixins: [p],
+  inheritAttrs: !1,
+  props: {
+    bounds: m(Object),
+    clickable: s(Boolean),
+    editable: s(Boolean),
+    strokeColor: s(String),
+    strokeOpacity: s(Number),
+    strokeWeight: s(Number),
+    visible: s(Boolean),
+    zIndex: s(Number),
+    fillColor: s(String),
+    fillOpacity: s(Number),
+    "onUpdate:bounds": h()
+  },
+  emits: void 0,
+  setup(e, { attrs: t }) {
+    return {
+      attrs: g(t, e),
+      overlay: l(),
+      emittedBounds: void 0
+    };
+  },
+  watch: {
+    bounds(e) {
+      if (this.emittedBounds != null) {
+        const t = this.emittedBounds;
+        if (this.emittedBounds = void 0, t.equals(e))
+          return;
+      }
+      this.overlay.setBounds(e);
+    },
+    clickable() {
+      this.recreate();
+    },
+    editable(e) {
+      this.overlay.setEditable(e);
+    },
+    strokeColor(e) {
+      this.overlay.setStrokeColor(e);
+    },
+    strokeOpacity(e) {
+      this.overlay.setStrokeOpacity(e);
+    },
+    strokeWeight(e) {
+      this.overlay.setStrokeWeight(e);
+    },
+    fillColor(e) {
+      this.overlay.setFillColor(e);
+    },
+    fillOpacity(e) {
+      this.overlay.setFillOpacity(e);
+    },
+    visible(e) {
+      this.overlay.setVisible(e);
+    },
+    zIndex(e) {
+      this.overlay.setZIndex(e);
+    }
+  },
+  onCreate() {
+    this.overlay = this.$map.createRectangle(this), this.$map.addOverlay(this.overlay), v(this.attrs.listeners, this.overlay), this.attrs.listenerProps["update:bounds"] && this.overlay.addEventListener("bounds-changed", () => {
+      this.$emit("update:bounds", this.emittedBounds = this.overlay.getBounds());
+    });
+  },
+  onDestroy() {
+    this.$map.removeOverlay(this.overlay);
+  }
+}), Ge = ["beforeUpdate", "updated"], $t = {
+  install(e, t = {}) {
+    if (t.enable !== !1) {
+      const r = n({
+        beforeCreate() {
+          const o = K() ?? "", a = (t.nameRegex || /^[A-Z]/).test(o) ? (_) => {
+            t.hookNames ? t.hookNames.includes(_) && console.debug("[lifecycle]", o, _) : Ge.includes(_) || console.debug("[lifecycle]", o, _);
+          } : S;
+          a("beforeCreate"), this.__life_impl = a;
+        },
+        created() {
+          this.__life("created");
+        },
+        beforeMount() {
+          this.__life("beforeMount");
+        },
+        mounted() {
+          this.__life("mounted");
+        },
+        beforeUpdate() {
+          this.__life("beforeUpdate");
+        },
+        updated() {
+          this.__life("updated");
+        },
+        beforeUnmount() {
+          this.__life("beforeUnmount");
+        },
+        unmounted() {
+          this.__life("unmounted");
+        },
+        methods: {
+          __life(o) {
+            this.__life_impl(o);
+          }
+        },
+        onCreate() {
+          this.__life("onCreate");
+        },
+        onDestroy() {
+          this.__life("onDestroy");
+        }
+      });
+      e.mixin(r);
+    }
+  }
+}, Ct = {
+  install(e, t) {
+    pe(t);
+    const r = e.config.optionMergeStrategies;
+    r[O] = r[P] = (o, i) => o ? [...new Set([].concat(o, i))] : Array.isArray(i) ? i : [i];
+  }
+};
+export {
+  $t as LifecycleLogPlugin,
+  O as MIXIN_HOOK_CREATE,
+  P as MIXIN_HOOK_DESTROY,
+  j as MIXIN_MAP_NAME,
+  p as MapMixin,
+  ct as TgCircle,
+  it as TgCustomControl,
+  mt as TgElementOverlay,
+  dt as TgHeatmap,
+  ut as TgInfoBox,
+  ft as TgInfoWindow,
+  yt as TgLabel,
+  N as TgMap,
+  at as TgMapTypeControl,
+  ot as TgMapWidget,
+  V as TgMarker,
+  Ae as TgMarkerClusterer,
+  vt as TgPolygon,
+  gt as TgPolyline,
+  bt as TgRectangle,
+  nt as TgScaleControl,
+  lt as TgStreetViewControl,
+  pt as TgTrafficLayer,
+  ht as TgZoomControl,
+  M as callHook,
+  Qe as computedSaveOnThis,
+  E as createEmptyVNode,
+  _e as createPropertyObject,
+  et as createPropertyObjectTyped,
+  Ct as default,
+  h as eventProp,
+  st as extractVNodeFromSlotsByComponent,
+  U as findAncestorComponentByType,
+  tt as findByComponentType,
+  R as isComponentByType,
+  s as optionalProp,
+  m as requiredProp,
+  X as safeAsComponent,
+  ke as splitAttrs,
+  u as stringEnumProp,
+  Ce as stringUnionPropFromValues,
+  rt as useEventLogMethods,
+  g as useSplittedAttrs,
+  H as useTgMapInner
+};
+//# sourceMappingURL=tg-map.js.map