@progress/kendo-react-map 6.1.1 → 7.0.0-develop.2

package/index.mjs

@@ -0,0 +1,803 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the package root for more information
+*-------------------------------------------------------------------------------------------*/
+import * as i from "react";
+import { canUseDOM as A, validatePackage as _, IconsContext as D } from "@progress/kendo-react-common";
+import * as C from "prop-types";
+import { InstanceObserver as m, Map as N } from "@progress/kendo-charts";
+import { Extent as ke, Location as Le } from "@progress/kendo-charts";
+import { Popup as U } from "@progress/kendo-react-popup";
+import { mapMarkerTargetIcon as K, mapMarkerIcon as R, plusIcon as z, minusIcon as j, caretAltUpIcon as V, caretAltDownIcon as B, caretAltLeftIcon as $, caretAltRightIcon as F } from "@progress/kendo-svg-icons";
+const u = i.createContext(null);
+u.displayName = "MapContext";
+class b extends i.Component {
+  constructor(e, t) {
+    super(e, t), this.optionsStore = t.optionsStore;
+  }
+  renderChildren(e, t) {
+    const { children: s } = e.props, { _mapKey: r, _parentStore: a } = this.props, o = {
+      ...e.props,
+      _mapCollectionIdxKey: `${r}_${t}`,
+      _parentStore: a
+    };
+    return i.cloneElement(e, o, s);
+  }
+  render() {
+    const { _mapKey: e, _parentStore: t, children: s } = this.props;
+    return (t || this.optionsStore).dispatch({
+      mapKey: e,
+      payload: []
+    }), i.Children.map(s, (a, o) => i.isValidElement(a) ? this.renderChildren(a, o) : a);
+  }
+}
+b.contextType = u;
+const W = (n) => {
+  let e, t = [];
+  const s = () => e, r = (o) => {
+    e = n(e, o), A && t.forEach((p) => p());
+  }, a = (o) => (t.push(o), () => t = t.filter((p) => p !== o));
+  return r({}), { getState: s, dispatch: r, subscribe: a };
+}, y = W, M = (n, e) => e.mapCollectionIdxKey ? g.collectionConfigurationItem(n, e) : e.mapKey ? g.configurationItem(n, e) : {}, Z = (n, e) => {
+  if (e.type)
+    switch (e.type) {
+      case "add":
+        return [...n, e.payload];
+      case "remove":
+        return n.filter((t) => t !== e.payload);
+      default:
+        return n;
+    }
+  else
+    return [];
+}, g = {
+  configurationItem(n, e) {
+    return Object.assign(n, {
+      [e.mapKey]: e.payload
+    });
+  },
+  collectionConfigurationItem(n, e) {
+    let t = !1;
+    const [s, r] = e.mapCollectionIdxKey.split("_"), a = n[s].map((o, p) => parseInt(r, 10) === p ? (t = !0, e.payload) : o);
+    return t === !1 && a.splice(parseInt(r, 10), 0, e.payload), Object.assign(n, {
+      [s]: a
+    });
+  },
+  themeItem(n, e) {
+    let t = {}, s = Object.assign(t, n);
+    const { field: r, value: a } = e.payload, o = r.split(".");
+    let p = o.shift();
+    for (; o.length > 0; )
+      t = t[p] = t[p] || {}, p = o.shift();
+    return t[p] = a, s;
+  }
+};
+class h extends i.Component {
+  constructor(e, t) {
+    super(e, t), this.optionsStore = t.optionsStore, this.childStore = y(M);
+  }
+  render() {
+    const { children: e } = this.props;
+    return e !== void 0 ? i.Children.map(e, (t) => i.isValidElement(t) ? this.renderChildren(t) : t) : null;
+  }
+  componentDidMount() {
+    this.dispatch();
+  }
+  componentDidUpdate() {
+    this.dispatch();
+  }
+  dispatch() {
+    const { _mapKey: e, _mapCollectionIdxKey: t, _parentStore: s, children: r, ...a } = this.props;
+    (s || this.optionsStore).dispatch({
+      mapKey: e,
+      mapCollectionIdxKey: t,
+      payload: Object.assign({}, a, this.childStore.getState())
+    });
+  }
+  renderChildren(e) {
+    const { children: t } = e.props, s = {
+      ...e.props,
+      _parentStore: this.childStore
+    };
+    return i.cloneElement(e, s, t);
+  }
+}
+h.contextType = u;
+class c {
+  /**
+   * @hidden
+   */
+  constructor(e) {
+    this.target = e;
+  }
+}
+class H extends c {
+  /**
+   * @hidden
+   */
+  constructor(e, t) {
+    super(t);
+  }
+}
+class q extends c {
+  /**
+   * @hidden
+   */
+  constructor(e, t) {
+    super(t), this.location = e.location, this.originalEvent = e.originalEvent;
+  }
+}
+class G extends c {
+  /**
+   * @hidden
+   */
+  constructor(e, t) {
+    super(t), this.marker = e.marker, this.layer = e.layer;
+  }
+}
+class J extends c {
+  /**
+   * @hidden
+   */
+  constructor(e, t) {
+    super(t), this.marker = e.marker, this.layer = e.layer;
+  }
+}
+class x extends c {
+  constructor() {
+    super(...arguments), this.prevented = !1;
+  }
+  /* eslint-disable max-len */
+  /**
+   * Prevents the default action for a specified event. In this way, the source component suppresses the built-in behavior that follows the event.
+   */
+  preventDefault() {
+    this.prevented = !0;
+  }
+  /**
+   * Returns `true` if the event was prevented by any of its subscribers.
+   *
+   * @returns `true` if the default action was prevented.
+   * Otherwise, returns `false`.
+   */
+  isDefaultPrevented() {
+    return this.prevented;
+  }
+}
+class Q extends x {
+  /**
+   * @hidden
+   */
+  constructor(e, t) {
+    super(t), this.marker = e.marker, this.layer = e.layer;
+  }
+}
+class X extends c {
+  /**
+   * @hidden
+   */
+  constructor(e, t) {
+    super(t), this.origin = e.origin, this.center = e.center, this.originalEvent = e.originalEvent;
+  }
+}
+class Y extends c {
+  /**
+   * @hidden
+   */
+  constructor(e, t) {
+    super(t), this.origin = e.origin, this.center = e.center, this.originalEvent = e.originalEvent;
+  }
+}
+class ee extends c {
+  /**
+   * @hidden
+   */
+  constructor(e, t) {
+    super(t);
+  }
+}
+class te extends c {
+  /**
+   * @hidden
+   */
+  constructor(e, t) {
+    super(t), this.layer = e.layer, this.shape = e.shape, this.originalEvent = e.originalEvent;
+  }
+}
+class ne extends c {
+  /**
+   * @hidden
+   */
+  constructor(e, t) {
+    super(t), this.layer = e.layer, this.shape = e.shape, this.location = null, e.shape && (this.dataItem = e.shape.dataItem, this.location = e.shape.location);
+  }
+}
+class se extends c {
+  /**
+   * @hidden
+   */
+  constructor(e, t) {
+    super(t), this.dataItem = e.dataItem, this.layer = e.layer, this.group = e.group, this.properties = e.properties;
+  }
+}
+class re extends c {
+  /**
+   * @hidden
+   */
+  constructor(e, t) {
+    super(t), this.layer = e.layer, this.shape = e.shape, this.originalEvent = e.originalEvent;
+  }
+}
+class oe extends c {
+  /**
+   * @hidden
+   */
+  constructor(e, t) {
+    super(t), this.layer = e.layer, this.shape = e.shape, this.originalEvent = e.originalEvent;
+  }
+}
+class ae extends c {
+  /**
+   * @hidden
+   */
+  constructor(e, t) {
+    super(t), this.originalEvent = e.originalEvent;
+  }
+}
+class ie extends x {
+  /**
+   * @hidden
+   */
+  constructor(e, t) {
+    super(t), this.originalEvent = e.originalEvent;
+  }
+}
+const I = {
+  beforeReset: H,
+  mapClick: q,
+  markerActivate: G,
+  markerClick: J,
+  markerCreated: Q,
+  panEnd: X,
+  pan: Y,
+  reset: ee,
+  shapeClick: te,
+  shapeCreated: ne,
+  shapeFeatureCreated: se,
+  shapeMouseEnter: re,
+  shapeMouseLeave: oe,
+  zoomEnd: ae,
+  zoomStart: ie
+};
+function pe(n, e, t) {
+  if (I[n])
+    return new I[n](e, t);
+}
+function ce(n, e) {
+  let t = n;
+  for (; t && t !== e; )
+    t = t.parentNode;
+  return !!t;
+}
+function f(n, e, t, s) {
+  const r = n[e];
+  if (r && Array.isArray(r)) {
+    for (let a of r)
+      if (!a.type || a.type !== s)
+        return new Error(
+          `${t} children should be Array of type ${s.displayName}.`
+        );
+  }
+  return null;
+}
+const le = { horizontal: "fit", vertical: "fit" }, he = ["k-tooltip", "k-map-tooltip"], ue = "k-tooltip-wrapper";
+class T extends i.Component {
+  constructor(e, t) {
+    super(e, t), this.context = null, this.element = null, this.onMapMouseLeave = (s) => {
+      const { syntheticEvent: r } = s;
+      return !!ce(r.relatedTarget, this.element);
+    }, this.mapObserver = new m(this, {
+      onMouseLeave: "onMapMouseLeave"
+    }), t.observersStore.dispatch({
+      type: "add",
+      payload: this.mapObserver
+    });
+  }
+  render() {
+    const { popupShown: e, popupAlign: t, popupOffset: s, popupStyles: r, popupContent: a, className: o } = this.props, p = [...he, o].join(" ").trim();
+    return /* @__PURE__ */ i.createElement(
+      U,
+      {
+        animate: !0,
+        popupAlign: t,
+        offset: s,
+        show: e,
+        collision: le,
+        className: ue
+      },
+      /* @__PURE__ */ i.createElement(
+        "div",
+        {
+          className: p,
+          style: r,
+          ref: (d) => this.element = d
+        },
+        a()
+      )
+    );
+  }
+  componentWillUnmount() {
+    this.context.observersStore.dispatch({
+      type: "remove",
+      payload: this.mapObserver
+    });
+  }
+}
+T.contextType = u;
+class k extends i.Component {
+  constructor() {
+    super(...arguments), this.context = null, this.state = {
+      popupShown: !1
+    };
+  }
+  componentDidMount() {
+    this.mapObserver = new m(this, {
+      showTooltip: "onShowTooltip",
+      hideTooltip: "onHideTooltip"
+    }), this.context.observersStore.dispatch({
+      type: "add",
+      payload: this.mapObserver
+    });
+  }
+  render() {
+    const { popupContext: e, shared: t, className: s, ...r } = this.state;
+    if (!e || !this.state.popupShown)
+      return null;
+    const a = e.layerIndex, o = this.findRenderFunctionByLayer(a);
+    if (!o)
+      return null;
+    const p = () => /* @__PURE__ */ i.createElement("div", { className: "k-tooltip-content" }, o(e)), l = `k-map-${e.type}-tooltip`;
+    return /* @__PURE__ */ i.createElement(
+      T,
+      {
+        ...r,
+        popupContent: p,
+        className: l
+      }
+    );
+  }
+  componentWillUnmount() {
+    this.context.observersStore.dispatch({
+      type: "remove",
+      payload: this.mapObserver
+    });
+  }
+  onShowTooltip(e) {
+    const { anchor: t, className: s } = e;
+    let r = this.createTooltipContext(e);
+    this.setState({
+      popupShown: !0,
+      popupAlign: { vertical: "bottom", horizontal: "center" },
+      popupOffset: t,
+      popupContext: r,
+      popupStyles: { position: "relative" },
+      className: s
+    });
+  }
+  onHideTooltip() {
+    this.setState({
+      popupShown: !1,
+      popupStyles: {},
+      className: void 0
+    });
+  }
+  createTooltipContext(e) {
+    return e;
+  }
+  findRenderFunctionByLayer(e) {
+    const t = this.context.optionsStore.getState().layers;
+    return t !== void 0 && Array.isArray(t) && t[e] !== void 0 && t[e].hasOwnProperty("tooltip") && t[e].tooltip.hasOwnProperty("render") ? t[e].tooltip.render : null;
+  }
+}
+k.contextType = u;
+const me = {
+  name: "@progress/kendo-react-map",
+  productName: "KendoReact",
+  productCodes: ["KENDOUIREACT", "KENDOUICOMPLETE"],
+  publishDate: 1700573632,
+  version: "",
+  licensingDocsUrl: "https://www.telerik.com/kendo-react-ui/components/my-license/?utm_medium=product&utm_source=kendoreact&utm_campaign=kendo-ui-react-purchase-license-keys-warning"
+};
+class de {
+  /**
+   * @hidden
+   */
+  constructor(e, t) {
+    this.sender = e, this.syntheticEvent = t;
+  }
+}
+function ve(n, e) {
+  return new de(n, e);
+}
+const E = {
+  mapMarkerTargetIcon: K,
+  mapMarkerIcon: R,
+  plusIcon: z,
+  minusIcon: j,
+  caretAltUpIcon: V,
+  caretAltDownIcon: B,
+  caretAltLeftIcon: $,
+  caretAltRightIcon: F
+}, S = "svg";
+class L extends i.Component {
+  constructor(e) {
+    super(e), this.mapInstance = null, this._element = null, this.optionsStore = {}, this.optionsUnsubscriber = Function.prototype, this.observersStore = {}, this.iconsType = S, this.svgIcons = E, this.onInit = (t) => {
+      this.mapInstance = t.sender;
+    }, this.onRender = (t) => {
+      this.mapInstance !== null && this.trigger("render", t);
+    }, this.onMapMouseLeave = (t) => {
+      const s = ve(this, t);
+      this.triggerDomEvent("onMouseLeave", s) ? t.preventDefault() : this.mapInstance !== null && this.mapInstance.hideTooltip();
+    }, _(me), this.optionsStore = y(M), this.observersStore = y(Z), this.childrenObserver = new m(this, { onMouseLeave: "onChildMouseLeave" }), this.contextValue = {
+      optionsStore: this.optionsStore,
+      observersStore: this.observersStore,
+      childrenObserver: this.childrenObserver
+    }, this.mapObserver = new m(this, {
+      // render: 'onRender',
+      init: "onInit"
+    });
+  }
+  /**
+   * @hidden
+   */
+  get element() {
+    return this._element;
+  }
+  /**
+   * @hidden
+   */
+  componentDidMount() {
+    this.instantiateCoreMap(), this.optionsUnsubscriber = this.optionsStore.subscribe(this.refresh.bind(this));
+  }
+  /**
+   * @hidden
+   */
+  componentWillUnmount() {
+    this.optionsUnsubscriber(), this.mapInstance !== null && (this.mapInstance.destroy(), this.mapInstance = null);
+  }
+  /**
+   * @hidden
+   */
+  componentDidUpdate(e) {
+    const { dir: t, children: s, ...r } = this.props;
+    this.mapInstance !== null && (Object.entries(e).filter((o) => o[0] !== "dir" && o[0] !== "children").some((o) => {
+      const [p, l] = o;
+      return !(r.hasOwnProperty(p) && r[p] === l);
+    }) && this.refresh(), e.dir);
+  }
+  /**
+   * @hidden
+   */
+  render() {
+    const { style: e = {}, className: t, children: s } = this.props, r = Object.assign({}, e, { position: "relative" }), a = i.createElement(
+      "div",
+      {
+        className: t,
+        style: r,
+        key: "mapElement"
+      },
+      /* @__PURE__ */ i.createElement(
+        "div",
+        {
+          ref: (o) => this._element = o,
+          className: "k-map",
+          onMouseLeave: this.onMapMouseLeave
+        },
+        s
+      )
+    );
+    return /* @__PURE__ */ i.createElement(D.Consumer, null, (o) => /* @__PURE__ */ i.createElement(u.Provider, { value: this.contextValue }, /* @__PURE__ */ i.createElement(k, { key: "tooltip" }), a, this.setIcons(o)));
+  }
+  /**
+   * @hidden
+   */
+  getMapOptions() {
+    const {
+      center: e,
+      controls: t,
+      minZoom: s,
+      maxZoom: r,
+      minSize: a,
+      pannable: o,
+      wraparound: p,
+      zoom: l,
+      zoomable: d
+    } = this.props;
+    let v = {
+      center: e,
+      controls: t,
+      minZoom: s,
+      maxZoom: r,
+      minSize: a,
+      pannable: o,
+      wraparound: p,
+      zoom: l,
+      zoomable: d,
+      icons: {
+        type: this.iconsType,
+        svgIcons: this.svgIcons
+      }
+    };
+    return v = Object.assign(v, this.optionsStore.getState()), v;
+  }
+  /**
+   * The marker layers instances.
+   */
+  get layers() {
+    var e;
+    return (e = this.mapInstance) == null ? void 0 : e.layers;
+  }
+  /**
+   * Gets the extent (visible area) of the map.
+   */
+  get extent() {
+    var e;
+    return (e = this.mapInstance) == null ? void 0 : e.extent();
+  }
+  /**
+   * Sets the extent (visible area) of the map.
+   */
+  set extent(e) {
+    var t;
+    (t = this.mapInstance) == null || t.extent(e);
+  }
+  /**
+   * Detects the size of the container and redraws the Map.
+   * Resizing is automatic unless you set the `resizeRateLimit` option to `0`.
+   */
+  resize() {
+  }
+  /**
+   * Retrieves the size of the visible portion of the map.
+   *
+   * @returns The size (width and height) of the visible portion of the map.
+   */
+  viewSize() {
+    var e;
+    return (e = this.mapInstance) == null ? void 0 : e.viewSize();
+  }
+  /**
+   * Returns the event coordinates relative to the map element. Offset coordinates are not synchronized to a particular location on the map.
+   *
+   * @param e The mouse event.
+   * @returns The event coordinates relative to the map element.
+   */
+  eventOffset(e) {
+    var t;
+    return (t = this.mapInstance) == null ? void 0 : t.eventOffset(e);
+  }
+  /**
+   * Retrieves projected (layer) coordinates that correspond to this mouse event.
+   * Layer coordinates are absolute and change only when the zoom level is changed.
+   *
+   * @param e The mouse event.
+   * @returns The projected (layer) coordinates that correspond to this event.
+   */
+  eventToLayer(e) {
+    var t;
+    return (t = this.mapInstance) == null ? void 0 : t.eventToLayer(e);
+  }
+  /**
+   * Retrieves the geographic location that correspond to this mouse event.
+   *
+   * @param e The mouse event.
+   * @returns The geographic location that correspond to this mouse event.
+   */
+  eventToLocation(e) {
+    var t;
+    return (t = this.mapInstance) == null ? void 0 : t.eventToLocation(e);
+  }
+  /**
+   * Retrieves relative (view) coordinates that correspond to this mouse event.
+   * Layer elements positioned on these coordinates will appear under the mouse cursor.
+   * View coordinates are no longer valid after a map reset.
+   *
+   * @param e The mouse event.
+   * @returns The relative (view) coordinates that correspond to this mouse event.
+   */
+  eventToView(e) {
+    var t;
+    return (t = this.mapInstance) == null ? void 0 : t.eventToView(e);
+  }
+  /**
+   * Transforms layer (projected) coordinates to geographical location.
+   *
+   * @param point The layer (projected) coordinates. An array argument is assumed to be in x, y order.
+   * @param zoom Optional. Assumed zoom level. Defaults to the current zoom level.
+   * @returns The geographic location that corresponds to the layer coordinates.
+   */
+  layerToLocation(e, t) {
+    var s;
+    return (s = this.mapInstance) == null ? void 0 : s.layerToLocation(e, t);
+  }
+  /**
+   * Returns the layer (projected) coordinates that correspond to a geographical location.
+   *
+   * @param location The geographic location. An array argument is assumed to be in [Latitude, Longitude] order.
+   * @param zoom Optional. Assumed zoom level. Defaults to the current zoom level.
+   * @returns The layer (projected) coordinates.
+   */
+  locationToLayer(e, t) {
+    var s;
+    return (s = this.mapInstance) == null ? void 0 : s.locationToLayer(e, t);
+  }
+  /**
+   * Returns the view (relative) coordinates that correspond to a geographical location.
+   *
+   * @param location The geographic location. An array argument is assumed to be in [Latitude, Longitude] order.
+   * @returns The view coordinates that correspond to a geographical location.
+   */
+  locationToView(e) {
+    var t;
+    return (t = this.mapInstance) == null ? void 0 : t.locationToView(e);
+  }
+  /**
+   * Returns the geographical location that correspond to the view (relative) coordinates.
+   *
+   * @param point The view coordinates. An array argument is assumed to be in x, y order.
+   * @param zoom Optional. Assumed zoom level. Defaults to the current zoom level.
+   * @returns The geographic location that corresponds to the view coordinates.
+   */
+  viewToLocation(e, t) {
+    var s;
+    return (s = this.mapInstance) == null ? void 0 : s.viewToLocation(e, t);
+  }
+  /**
+   * Load markers in the Map. This method will clear the current markers and show the new ones.
+   *
+   * @param newMarkers An array of markers.
+   */
+  loadMarkers(e) {
+    const t = this.mapInstance.markers;
+    t && t._load(e);
+  }
+  /**
+   * @hidden
+   */
+  refresh() {
+    if (this.mapInstance !== null) {
+      const e = this.getMapOptions();
+      this.props.onRefresh ? this.props.onRefresh.call(void 0, e, this.mapInstance) : this.mapInstance.setOptions(e);
+    }
+  }
+  /**
+   * @hidden
+   */
+  instantiateCoreMap() {
+    const e = this.getMapOptions();
+    this.mapInstance = new N(
+      this.element,
+      e,
+      {},
+      {
+        // rtl: this.getDirection(dir),
+        observer: this.mapObserver,
+        sender: this
+      }
+    );
+  }
+  /* Triggers public dom event handlers */
+  /**
+   * @hidden
+   */
+  trigger(e, t) {
+    const s = e === "click" ? "mapClick" : e, r = pe(s, t, this), a = "on" + s.charAt(0).toUpperCase() + s.slice(1), o = this.observersStore.getState();
+    let p = !1;
+    for (let l = 0; l < o.length; l++)
+      o[l].trigger(s, t) && (p = !0);
+    return p === !1 && r && this.props.hasOwnProperty(a) ? (this.props[a].call(void 0, r), r.isDefaultPrevented && r.isDefaultPrevented()) : p;
+  }
+  /* Used by (event)InstanceObserver to check the wrapper for supported events */
+  /**
+   * @hidden
+   */
+  requiresHandlers(e) {
+    for (let t = 0; t < e.length; t++) {
+      const s = e[t], r = "on" + s.charAt(0).toUpperCase() + s.slice(1);
+      if (this.props.hasOwnProperty(r))
+        return !0;
+    }
+    return !1;
+  }
+  /**
+   * @hidden
+   */
+  triggerDomEvent(e, t) {
+    const s = this.observersStore.getState();
+    let r = !1;
+    for (let a = 0; a < s.length; a++)
+      s[a].trigger(e, t) && (r = !0);
+    return r;
+  }
+  setIcons(e) {
+    const { type: t, icons: s = {} } = e, r = { ...E }, a = {
+      mapMarkerTargetIcon: s.mapMarkerTargetIcon,
+      mapMarkerIcon: s.mapMarkerIcon,
+      plusIcon: s.plusIcon,
+      minusIcon: s.minusIcon,
+      caretAltUpIcon: s.caretAltUpIcon,
+      caretAltDownIcon: s.caretAltDownIcon,
+      caretAltLeftIcon: s.caretAltLeftIcon,
+      caretAltRightIcon: s.caretAltRightIcon
+    };
+    let o;
+    for (o in a)
+      if (a[o]) {
+        const p = a[o];
+        p && typeof p != "string" && (r[o] = p);
+      }
+    return this.svgIcons = r, this.iconsType = t || S, null;
+  }
+}
+L.propTypes = {
+  dir: C.string
+};
+L.defaultProps = {};
+const ye = (n) => /* @__PURE__ */ i.createElement(b, { ...n, _mapKey: "layers" });
+ye.propTypes = {
+  children: C.node
+};
+const fe = (n) => /* @__PURE__ */ i.createElement(h, { ...n, _mapKey: "tooltip" }), O = (n) => /* @__PURE__ */ i.createElement(h, { type: "shape", ...n });
+O.displayName = "MapShapeLayer";
+O.propTypes = {
+  children: function(n, e, t) {
+    return f(n, e, t, fe);
+  }
+};
+const ge = (n) => /* @__PURE__ */ i.createElement(h, { type: "tile", ...n });
+ge.displayName = "MapTileLayer";
+const Ie = (n) => /* @__PURE__ */ i.createElement(h, { ...n, _mapKey: "tooltip" }), w = (n) => /* @__PURE__ */ i.createElement(h, { type: "bubble", ...n });
+w.displayName = "MapBubbleLayer";
+w.propTypes = {
+  children: function(n, e, t) {
+    return f(n, e, t, Ie);
+  }
+};
+const Ee = (n) => /* @__PURE__ */ i.createElement(h, { ...n, _mapKey: "tooltip" }), P = (n) => /* @__PURE__ */ i.createElement(h, { type: "marker", ...n });
+P.displayName = "MapMarkerLayer";
+P.propTypes = {
+  children: function(n, e, t) {
+    return f(n, e, t, Ee);
+  }
+};
+export {
+  H as BeforeResetEvent,
+  b as CollectionConfigurationComponent,
+  h as ConfigurationComponent,
+  ke as Extent,
+  Le as Location,
+  L as Map,
+  w as MapBubbleLayer,
+  Ie as MapBubbleLayerTooltip,
+  q as MapClickEvent,
+  ye as MapLayers,
+  P as MapMarkerLayer,
+  Ee as MapMarkerLayerTooltip,
+  O as MapShapeLayer,
+  fe as MapShapeLayerTooltip,
+  ge as MapTileLayer,
+  k as MapTooltip,
+  G as MarkerActivateEvent,
+  J as MarkerClickEvent,
+  Q as MarkerCreatedEvent,
+  X as PanEndEvent,
+  Y as PanEvent,
+  ee as ResetEvent,
+  te as ShapeClickEvent,
+  ne as ShapeCreatedEvent,
+  se as ShapeFeatureCreatedEvent,
+  re as ShapeMouseEnterEvent,
+  oe as ShapeMouseLeaveEvent,
+  ae as ZoomEndEvent,
+  ie as ZoomStartEvent
+};