@local-logic/maps 0.0.12 → 0.0.14

package/dist/index-Bp1bWq9c.js

@@ -0,0 +1,690 @@
+import { jsx as T } from "react/jsx-runtime";
+import * as U from "react";
+import it, { useContext as at, useState as v, useMemo as P, lazy as w, useRef as V, useEffect as ct } from "react";
+const tt = it.createContext({}), R = () => at(tt), I = {
+  zoom: 14,
+  pitch: 0,
+  bearing: 0,
+  cooperativeGestures: !1
+}, H = {
+  maptiler: "600d69cb-288d-445e-9839-3dfe4d76b31a",
+  mapbox: "locallogic/cmb9nz9kb011501ru8drq8fqf",
+  google: "a7ff20eb973126bb"
+}, Y = 13, ut = 22, Ht = 12.5, ht = 30, pt = 60, lt = "w-full h-full relative overflow-hidden", ft = w(() => import("./index-S5SfktvB.js")), dt = w(() => import("./index-CUpaKIZP.js")), gt = w(() => import("./index-BGoTpJjt.js")), mt = w(() => import("./index-qqbvBkdn.js")), yt = ({ padding: r = 1e-3, children: t }) => {
+  const {
+    mapProvider: e,
+    center: n,
+    zoom: o = I.zoom,
+    pitch: i = I.pitch,
+    bearing: a = I.bearing,
+    cooperativeGestures: c = I.cooperativeGestures,
+    zoomPosition: s
+  } = R(), [h] = v(o), p = P(() => {
+    switch (e == null ? void 0 : e.name) {
+      case "maptiler":
+        return ft;
+      case "google":
+        return dt;
+      case "mapbox":
+        return gt;
+      default:
+        return mt;
+    }
+  }, [e]);
+  return /* @__PURE__ */ T(
+    "div",
+    {
+      className: lt,
+      "data-testid": "base-map",
+      "data-map-provider-name": e == null ? void 0 : e.name,
+      "data-map-provider-theme": (e == null ? void 0 : e.theme) || H[e == null ? void 0 : e.name] || H.maptiler,
+      "data-initial-zoom": h,
+      "data-pitch": i,
+      "data-bearing": a,
+      "data-cooperative-gestures": c,
+      "data-zoom-position": s,
+      "data-center-latitude": n.latitude,
+      "data-center-longitude": n.longitude,
+      children: /* @__PURE__ */ T(p, { padding: r, children: t })
+    }
+  );
+}, wt = w(() => import("./index-Do_dW76Q.js")), Mt = w(() => import("./index-BCa658u4.js")), _t = w(() => import("./index-CNxLnZ8O.js"));
+function At(r) {
+  const { mapProvider: t } = R(), e = P(() => {
+    switch (t == null ? void 0 : t.name) {
+      case "maptiler":
+        return wt;
+      case "google":
+        return Mt;
+      case "mapbox":
+        return _t;
+      default:
+        return null;
+    }
+  }, [t]);
+  return e ? /* @__PURE__ */ T(e, { ...r }) : null;
+}
+function et(r, t, e = {}) {
+  const n = { type: "Feature" };
+  return (e.id === 0 || e.id) && (n.id = e.id), e.bbox && (n.bbox = e.bbox), n.properties = t || {}, n.geometry = r, n;
+}
+function xt(r, t, e = {}) {
+  if (!r)
+    throw new Error("coordinates is required");
+  if (!Array.isArray(r))
+    throw new Error("coordinates must be an Array");
+  if (r.length < 2)
+    throw new Error("coordinates must be at least 2 numbers long");
+  if (!J(r[0]) || !J(r[1]))
+    throw new Error("coordinates must contain numbers");
+  return et({
+    type: "Point",
+    coordinates: r
+  }, t, e);
+}
+function Yt(r, t, e = {}) {
+  return et({
+    type: "MultiPoint",
+    coordinates: r
+  }, t, e);
+}
+function J(r) {
+  return !isNaN(r) && r !== null && !Array.isArray(r);
+}
+const K = [
+  Int8Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array
+], F = 1, S = 8;
+class j {
+  /**
+   * Creates an index from raw `ArrayBuffer` data.
+   * @param {ArrayBuffer} data
+   */
+  static from(t) {
+    if (!(t instanceof ArrayBuffer))
+      throw new Error("Data must be an instance of ArrayBuffer.");
+    const [e, n] = new Uint8Array(t, 0, 2);
+    if (e !== 219)
+      throw new Error("Data does not appear to be in a KDBush format.");
+    const o = n >> 4;
+    if (o !== F)
+      throw new Error(`Got v${o} data when expected v${F}.`);
+    const i = K[n & 15];
+    if (!i)
+      throw new Error("Unrecognized array type.");
+    const [a] = new Uint16Array(t, 2, 1), [c] = new Uint32Array(t, 4, 1);
+    return new j(c, a, i, t);
+  }
+  /**
+   * Creates an index that will hold a given number of items.
+   * @param {number} numItems
+   * @param {number} [nodeSize=64] Size of the KD-tree node (64 by default).
+   * @param {TypedArrayConstructor} [ArrayType=Float64Array] The array type used for coordinates storage (`Float64Array` by default).
+   * @param {ArrayBuffer} [data] (For internal use only)
+   */
+  constructor(t, e = 64, n = Float64Array, o) {
+    if (isNaN(t) || t < 0) throw new Error(`Unpexpected numItems value: ${t}.`);
+    this.numItems = +t, this.nodeSize = Math.min(Math.max(+e, 2), 65535), this.ArrayType = n, this.IndexArrayType = t < 65536 ? Uint16Array : Uint32Array;
+    const i = K.indexOf(this.ArrayType), a = t * 2 * this.ArrayType.BYTES_PER_ELEMENT, c = t * this.IndexArrayType.BYTES_PER_ELEMENT, s = (8 - c % 8) % 8;
+    if (i < 0)
+      throw new Error(`Unexpected typed array class: ${n}.`);
+    o && o instanceof ArrayBuffer ? (this.data = o, this.ids = new this.IndexArrayType(this.data, S, t), this.coords = new this.ArrayType(this.data, S + c + s, t * 2), this._pos = t * 2, this._finished = !0) : (this.data = new ArrayBuffer(S + a + c + s), this.ids = new this.IndexArrayType(this.data, S, t), this.coords = new this.ArrayType(this.data, S + c + s, t * 2), this._pos = 0, this._finished = !1, new Uint8Array(this.data, 0, 2).set([219, (F << 4) + i]), new Uint16Array(this.data, 2, 1)[0] = e, new Uint32Array(this.data, 4, 1)[0] = t);
+  }
+  /**
+   * Add a point to the index.
+   * @param {number} x
+   * @param {number} y
+   * @returns {number} An incremental index associated with the added item (starting from `0`).
+   */
+  add(t, e) {
+    const n = this._pos >> 1;
+    return this.ids[n] = n, this.coords[this._pos++] = t, this.coords[this._pos++] = e, n;
+  }
+  /**
+   * Perform indexing of the added points.
+   */
+  finish() {
+    const t = this._pos >> 1;
+    if (t !== this.numItems)
+      throw new Error(`Added ${t} items when expected ${this.numItems}.`);
+    return N(this.ids, this.coords, this.nodeSize, 0, this.numItems - 1, 0), this._finished = !0, this;
+  }
+  /**
+   * Search the index for items within a given bounding box.
+   * @param {number} minX
+   * @param {number} minY
+   * @param {number} maxX
+   * @param {number} maxY
+   * @returns {number[]} An array of indices correponding to the found items.
+   */
+  range(t, e, n, o) {
+    if (!this._finished) throw new Error("Data not yet indexed - call index.finish().");
+    const { ids: i, coords: a, nodeSize: c } = this, s = [0, i.length - 1, 0], h = [];
+    for (; s.length; ) {
+      const p = s.pop() || 0, u = s.pop() || 0, f = s.pop() || 0;
+      if (u - f <= c) {
+        for (let d = f; d <= u; d++) {
+          const y = a[2 * d], M = a[2 * d + 1];
+          y >= t && y <= n && M >= e && M <= o && h.push(i[d]);
+        }
+        continue;
+      }
+      const g = f + u >> 1, m = a[2 * g], l = a[2 * g + 1];
+      m >= t && m <= n && l >= e && l <= o && h.push(i[g]), (p === 0 ? t <= m : e <= l) && (s.push(f), s.push(g - 1), s.push(1 - p)), (p === 0 ? n >= m : o >= l) && (s.push(g + 1), s.push(u), s.push(1 - p));
+    }
+    return h;
+  }
+  /**
+   * Search the index for items within a given radius.
+   * @param {number} qx
+   * @param {number} qy
+   * @param {number} r Query radius.
+   * @returns {number[]} An array of indices correponding to the found items.
+   */
+  within(t, e, n) {
+    if (!this._finished) throw new Error("Data not yet indexed - call index.finish().");
+    const { ids: o, coords: i, nodeSize: a } = this, c = [0, o.length - 1, 0], s = [], h = n * n;
+    for (; c.length; ) {
+      const p = c.pop() || 0, u = c.pop() || 0, f = c.pop() || 0;
+      if (u - f <= a) {
+        for (let d = f; d <= u; d++)
+          q(i[2 * d], i[2 * d + 1], t, e) <= h && s.push(o[d]);
+        continue;
+      }
+      const g = f + u >> 1, m = i[2 * g], l = i[2 * g + 1];
+      q(m, l, t, e) <= h && s.push(o[g]), (p === 0 ? t - n <= m : e - n <= l) && (c.push(f), c.push(g - 1), c.push(1 - p)), (p === 0 ? t + n >= m : e + n >= l) && (c.push(g + 1), c.push(u), c.push(1 - p));
+    }
+    return s;
+  }
+}
+function N(r, t, e, n, o, i) {
+  if (o - n <= e) return;
+  const a = n + o >> 1;
+  nt(r, t, a, n, o, i), N(r, t, e, n, a - 1, 1 - i), N(r, t, e, a + 1, o, 1 - i);
+}
+function nt(r, t, e, n, o, i) {
+  for (; o > n; ) {
+    if (o - n > 600) {
+      const h = o - n + 1, p = e - n + 1, u = Math.log(h), f = 0.5 * Math.exp(2 * u / 3), g = 0.5 * Math.sqrt(u * f * (h - f) / h) * (p - h / 2 < 0 ? -1 : 1), m = Math.max(n, Math.floor(e - p * f / h + g)), l = Math.min(o, Math.floor(e + (h - p) * f / h + g));
+      nt(r, t, e, m, l, i);
+    }
+    const a = t[2 * e + i];
+    let c = n, s = o;
+    for (L(r, t, n, e), t[2 * o + i] > a && L(r, t, n, o); c < s; ) {
+      for (L(r, t, c, s), c++, s--; t[2 * c + i] < a; ) c++;
+      for (; t[2 * s + i] > a; ) s--;
+    }
+    t[2 * n + i] === a ? L(r, t, n, s) : (s++, L(r, t, s, o)), s <= e && (n = s + 1), e <= s && (o = s - 1);
+  }
+}
+function L(r, t, e, n) {
+  z(r, e, n), z(t, 2 * e, 2 * n), z(t, 2 * e + 1, 2 * n + 1);
+}
+function z(r, t, e) {
+  const n = r[t];
+  r[t] = r[e], r[e] = n;
+}
+function q(r, t, e, n) {
+  const o = r - e, i = t - n;
+  return o * o + i * i;
+}
+const Et = {
+  minZoom: 0,
+  // min zoom to generate clusters on
+  maxZoom: 16,
+  // max zoom level to cluster the points on
+  minPoints: 2,
+  // minimum points to form a cluster
+  radius: 40,
+  // cluster radius in pixels
+  extent: 512,
+  // tile extent (radius is calculated relative to it)
+  nodeSize: 64,
+  // size of the KD-tree leaf node, affects performance
+  log: !1,
+  // whether to log timing info
+  // whether to generate numeric ids for input features (in vector tiles)
+  generateId: !1,
+  // a reduce function for calculating custom cluster properties
+  reduce: null,
+  // (accumulated, props) => { accumulated.sum += props.sum; }
+  // properties to use for individual points when running the reducer
+  map: (r) => r
+  // props => ({sum: props.my_value})
+}, Q = Math.fround || /* @__PURE__ */ ((r) => (t) => (r[0] = +t, r[0]))(new Float32Array(1)), O = 2, x = 3, D = 4, A = 5, rt = 6;
+class Ot {
+  constructor(t) {
+    this.options = Object.assign(Object.create(Et), t), this.trees = new Array(this.options.maxZoom + 1), this.stride = this.options.reduce ? 7 : 6, this.clusterProps = [];
+  }
+  load(t) {
+    const { log: e, minZoom: n, maxZoom: o } = this.options;
+    e && console.time("total time");
+    const i = `prepare ${t.length} points`;
+    e && console.time(i), this.points = t;
+    const a = [];
+    for (let s = 0; s < t.length; s++) {
+      const h = t[s];
+      if (!h.geometry) continue;
+      const [p, u] = h.geometry.coordinates, f = Q(Z(p)), g = Q(C(u));
+      a.push(
+        f,
+        g,
+        // projected point coordinates
+        1 / 0,
+        // the last zoom the point was processed at
+        s,
+        // index of the source feature in the original input array
+        -1,
+        // parent cluster id
+        1
+        // number of points in a cluster
+      ), this.options.reduce && a.push(0);
+    }
+    let c = this.trees[o + 1] = this._createTree(a);
+    e && console.timeEnd(i);
+    for (let s = o; s >= n; s--) {
+      const h = +Date.now();
+      c = this.trees[s] = this._createTree(this._cluster(c, s)), e && console.log("z%d: %d clusters in %dms", s, c.numItems, +Date.now() - h);
+    }
+    return e && console.timeEnd("total time"), this;
+  }
+  getClusters(t, e) {
+    let n = ((t[0] + 180) % 360 + 360) % 360 - 180;
+    const o = Math.max(-90, Math.min(90, t[1]));
+    let i = t[2] === 180 ? 180 : ((t[2] + 180) % 360 + 360) % 360 - 180;
+    const a = Math.max(-90, Math.min(90, t[3]));
+    if (t[2] - t[0] >= 360)
+      n = -180, i = 180;
+    else if (n > i) {
+      const u = this.getClusters([n, o, 180, a], e), f = this.getClusters([-180, o, i, a], e);
+      return u.concat(f);
+    }
+    const c = this.trees[this._limitZoom(e)], s = c.range(Z(n), C(a), Z(i), C(o)), h = c.data, p = [];
+    for (const u of s) {
+      const f = this.stride * u;
+      p.push(h[f + A] > 1 ? W(h, f, this.clusterProps) : this.points[h[f + x]]);
+    }
+    return p;
+  }
+  getChildren(t) {
+    const e = this._getOriginId(t), n = this._getOriginZoom(t), o = "No cluster with the specified id.", i = this.trees[n];
+    if (!i) throw new Error(o);
+    const a = i.data;
+    if (e * this.stride >= a.length) throw new Error(o);
+    const c = this.options.radius / (this.options.extent * Math.pow(2, n - 1)), s = a[e * this.stride], h = a[e * this.stride + 1], p = i.within(s, h, c), u = [];
+    for (const f of p) {
+      const g = f * this.stride;
+      a[g + D] === t && u.push(a[g + A] > 1 ? W(a, g, this.clusterProps) : this.points[a[g + x]]);
+    }
+    if (u.length === 0) throw new Error(o);
+    return u;
+  }
+  getLeaves(t, e, n) {
+    e = e || 10, n = n || 0;
+    const o = [];
+    return this._appendLeaves(o, t, e, n, 0), o;
+  }
+  getTile(t, e, n) {
+    const o = this.trees[this._limitZoom(t)], i = Math.pow(2, t), { extent: a, radius: c } = this.options, s = c / a, h = (n - s) / i, p = (n + 1 + s) / i, u = {
+      features: []
+    };
+    return this._addTileFeatures(
+      o.range((e - s) / i, h, (e + 1 + s) / i, p),
+      o.data,
+      e,
+      n,
+      i,
+      u
+    ), e === 0 && this._addTileFeatures(
+      o.range(1 - s / i, h, 1, p),
+      o.data,
+      i,
+      n,
+      i,
+      u
+    ), e === i - 1 && this._addTileFeatures(
+      o.range(0, h, s / i, p),
+      o.data,
+      -1,
+      n,
+      i,
+      u
+    ), u.features.length ? u : null;
+  }
+  getClusterExpansionZoom(t) {
+    let e = this._getOriginZoom(t) - 1;
+    for (; e <= this.options.maxZoom; ) {
+      const n = this.getChildren(t);
+      if (e++, n.length !== 1) break;
+      t = n[0].properties.cluster_id;
+    }
+    return e;
+  }
+  _appendLeaves(t, e, n, o, i) {
+    const a = this.getChildren(e);
+    for (const c of a) {
+      const s = c.properties;
+      if (s && s.cluster ? i + s.point_count <= o ? i += s.point_count : i = this._appendLeaves(t, s.cluster_id, n, o, i) : i < o ? i++ : t.push(c), t.length === n) break;
+    }
+    return i;
+  }
+  _createTree(t) {
+    const e = new j(t.length / this.stride | 0, this.options.nodeSize, Float32Array);
+    for (let n = 0; n < t.length; n += this.stride) e.add(t[n], t[n + 1]);
+    return e.finish(), e.data = t, e;
+  }
+  _addTileFeatures(t, e, n, o, i, a) {
+    for (const c of t) {
+      const s = c * this.stride, h = e[s + A] > 1;
+      let p, u, f;
+      if (h)
+        p = st(e, s, this.clusterProps), u = e[s], f = e[s + 1];
+      else {
+        const l = this.points[e[s + x]];
+        p = l.properties;
+        const [d, y] = l.geometry.coordinates;
+        u = Z(d), f = C(y);
+      }
+      const g = {
+        type: 1,
+        geometry: [[
+          Math.round(this.options.extent * (u * i - n)),
+          Math.round(this.options.extent * (f * i - o))
+        ]],
+        tags: p
+      };
+      let m;
+      h || this.options.generateId ? m = e[s + x] : m = this.points[e[s + x]].id, m !== void 0 && (g.id = m), a.features.push(g);
+    }
+  }
+  _limitZoom(t) {
+    return Math.max(this.options.minZoom, Math.min(Math.floor(+t), this.options.maxZoom + 1));
+  }
+  _cluster(t, e) {
+    const { radius: n, extent: o, reduce: i, minPoints: a } = this.options, c = n / (o * Math.pow(2, e)), s = t.data, h = [], p = this.stride;
+    for (let u = 0; u < s.length; u += p) {
+      if (s[u + O] <= e) continue;
+      s[u + O] = e;
+      const f = s[u], g = s[u + 1], m = t.within(s[u], s[u + 1], c), l = s[u + A];
+      let d = l;
+      for (const y of m) {
+        const M = y * p;
+        s[M + O] > e && (d += s[M + A]);
+      }
+      if (d > l && d >= a) {
+        let y = f * l, M = g * l, _, G = -1;
+        const B = ((u / p | 0) << 5) + (e + 1) + this.points.length;
+        for (const ot of m) {
+          const E = ot * p;
+          if (s[E + O] <= e) continue;
+          s[E + O] = e;
+          const $ = s[E + A];
+          y += s[E] * $, M += s[E + 1] * $, s[E + D] = B, i && (_ || (_ = this._map(s, u, !0), G = this.clusterProps.length, this.clusterProps.push(_)), i(_, this._map(s, E)));
+        }
+        s[u + D] = B, h.push(y / d, M / d, 1 / 0, B, -1, d), i && h.push(G);
+      } else {
+        for (let y = 0; y < p; y++) h.push(s[u + y]);
+        if (d > 1)
+          for (const y of m) {
+            const M = y * p;
+            if (!(s[M + O] <= e)) {
+              s[M + O] = e;
+              for (let _ = 0; _ < p; _++) h.push(s[M + _]);
+            }
+          }
+      }
+    }
+    return h;
+  }
+  // get index of the point from which the cluster originated
+  _getOriginId(t) {
+    return t - this.points.length >> 5;
+  }
+  // get zoom of the point from which the cluster originated
+  _getOriginZoom(t) {
+    return (t - this.points.length) % 32;
+  }
+  _map(t, e, n) {
+    if (t[e + A] > 1) {
+      const a = this.clusterProps[t[e + rt]];
+      return n ? Object.assign({}, a) : a;
+    }
+    const o = this.points[t[e + x]].properties, i = this.options.map(o);
+    return n && i === o ? Object.assign({}, i) : i;
+  }
+}
+function W(r, t, e) {
+  return {
+    type: "Feature",
+    id: r[t + x],
+    properties: st(r, t, e),
+    geometry: {
+      type: "Point",
+      coordinates: [bt(r[t]), Tt(r[t + 1])]
+    }
+  };
+}
+function st(r, t, e) {
+  const n = r[t + A], o = n >= 1e4 ? `${Math.round(n / 1e3)}k` : n >= 1e3 ? `${Math.round(n / 100) / 10}k` : n, i = r[t + rt], a = i === -1 ? {} : Object.assign({}, e[i]);
+  return Object.assign(a, {
+    cluster: !0,
+    cluster_id: r[t + x],
+    point_count: n,
+    point_count_abbreviated: o
+  });
+}
+function Z(r) {
+  return r / 360 + 0.5;
+}
+function C(r) {
+  const t = Math.sin(r * Math.PI / 180), e = 0.5 - 0.25 * Math.log((1 + t) / (1 - t)) / Math.PI;
+  return e < 0 ? 0 : e > 1 ? 1 : e;
+}
+function bt(r) {
+  return (r - 0.5) * 360;
+}
+function Tt(r) {
+  const t = (180 - r * 360) * Math.PI / 180;
+  return 360 * Math.atan(Math.exp(t)) / Math.PI - 90;
+}
+var k = Object.prototype.hasOwnProperty;
+function X(r, t, e) {
+  for (e of r.keys())
+    if (b(e, t)) return e;
+}
+function b(r, t) {
+  var e, n, o;
+  if (r === t) return !0;
+  if (r && t && (e = r.constructor) === t.constructor) {
+    if (e === Date) return r.getTime() === t.getTime();
+    if (e === RegExp) return r.toString() === t.toString();
+    if (e === Array) {
+      if ((n = r.length) === t.length)
+        for (; n-- && b(r[n], t[n]); ) ;
+      return n === -1;
+    }
+    if (e === Set) {
+      if (r.size !== t.size)
+        return !1;
+      for (n of r)
+        if (o = n, o && typeof o == "object" && (o = X(t, o), !o) || !t.has(o)) return !1;
+      return !0;
+    }
+    if (e === Map) {
+      if (r.size !== t.size)
+        return !1;
+      for (n of r)
+        if (o = n[0], o && typeof o == "object" && (o = X(t, o), !o) || !b(n[1], t.get(o)))
+          return !1;
+      return !0;
+    }
+    if (e === ArrayBuffer)
+      r = new Uint8Array(r), t = new Uint8Array(t);
+    else if (e === DataView) {
+      if ((n = r.byteLength) === t.byteLength)
+        for (; n-- && r.getInt8(n) === t.getInt8(n); ) ;
+      return n === -1;
+    }
+    if (ArrayBuffer.isView(r)) {
+      if ((n = r.byteLength) === t.byteLength)
+        for (; n-- && r[n] === t[n]; ) ;
+      return n === -1;
+    }
+    if (!e || typeof r == "object") {
+      n = 0;
+      for (e in r)
+        if (k.call(r, e) && ++n && !k.call(t, e) || !(e in t) || !b(r[e], t[e])) return !1;
+      return Object.keys(t).length === n;
+    }
+  }
+  return r !== r && t !== t;
+}
+function Pt(r) {
+  var t = U.useRef(r), e = U.useRef(0);
+  return b(r, t.current) || (t.current = r, e.current += 1), U.useMemo(function() {
+    return t.current;
+  }, [e.current]);
+}
+function St(r, t) {
+  return U.useEffect(r, Pt(t));
+}
+var Lt = function(t) {
+  var e = t.points, n = t.bounds, o = t.zoom, i = t.options, a = t.disableRefresh, c = V(), s = V(), h = v([]), p = h[0], u = h[1], f = Math.round(o);
+  return St(function() {
+    a !== !0 && ((!c.current || !b(s.current, e) || !b(c.current.options, i)) && (c.current = new Ot(i), c.current.load(e)), n && u(c.current.getClusters(n, f)), s.current = e);
+  }, [e, n, f, i, a]), {
+    clusters: p,
+    supercluster: c.current
+  };
+};
+const It = w(() => import("./index-CCtDJ-mV.js")), vt = w(() => import("./index-CXTsUiSS.js")), Rt = w(() => import("./index-58w3Qwxr.js"));
+function Zt({ markers: r, onClick: t, ...e }) {
+  const { mapProvider: n, activeMarker: o, center: i, bounds: a, zoom: c, setMarkerPoints: s } = R();
+  ct(() => {
+    let l = [[i.latitude, i.longitude]];
+    r.length > 0 && (l = l.concat(
+      r.map((d) => [d.latitude, d.longitude])
+    )), s(l);
+  }, [r, i]);
+  const h = P(
+    () => ({
+      points: r.map((l) => xt([l.longitude, l.latitude], l)),
+      bounds: a,
+      zoom: c,
+      options: {
+        radius: n.name === "google" && c > Y ? pt : ht,
+        minZoom: Y,
+        maxZoom: ut
+      }
+    }),
+    [r, n, a, c]
+  ), { clusters: p, supercluster: u } = Lt(h), f = (l) => {
+    var d, y, M;
+    if (!("properties" in l))
+      throw new Error("Cluster does not have properties");
+    if ((d = l.properties) != null && d.cluster && typeof ((y = l.properties) == null ? void 0 : y.cluster_id) == "number") {
+      t == null || t({
+        id: `${l.properties.cluster_id}`,
+        latitude: l.geometry.coordinates[1],
+        longitude: l.geometry.coordinates[0],
+        markers: ((M = u == null ? void 0 : u.getLeaves(l.properties.cluster_id)) == null ? void 0 : M.map((_) => _.properties)) ?? []
+      });
+      return;
+    }
+    t == null || t({
+      id: l.properties.id,
+      latitude: l.properties.latitude,
+      longitude: l.properties.longitude,
+      markers: [l.properties]
+    });
+  }, g = (l) => {
+    var d;
+    return !u || !o ? !1 : o.id === `${l}` ? !0 : ((d = u.getLeaves(l)) == null ? void 0 : d.find((y) => y.properties.id === o.id)) !== void 0;
+  }, m = P(() => {
+    switch (n == null ? void 0 : n.name) {
+      case "maptiler":
+        return It;
+      case "google":
+        return vt;
+      case "mapbox":
+        return Rt;
+      default:
+        return null;
+    }
+  }, [n]);
+  return m ? /* @__PURE__ */ T(
+    m,
+    {
+      clusters: p,
+      onClick: f,
+      doesSuperclusterContainActiveMarker: g,
+      ...e
+    }
+  ) : null;
+}
+const Ct = w(() => import("./index-CXUQoF5Q.js")), Ut = w(() => import("./index-DY5pY-zk.js")), Bt = w(() => import("./index-C36u5N_F.js"));
+function Ft({ children: r, anchor: t = "bottom", ...e }) {
+  const { mapProvider: n } = R(), o = P(() => {
+    switch (n == null ? void 0 : n.name) {
+      case "maptiler":
+        return Ct;
+      case "google":
+        return Ut;
+      case "mapbox":
+        return Bt;
+      default:
+        return null;
+    }
+  }, [n]);
+  return o ? /* @__PURE__ */ T(o, { ...e, anchor: t, children: r }) : null;
+}
+const zt = w(() => import("./index-CTk5bvm9.js")), Dt = w(() => import("./index-UEadmVww.js")), Nt = w(() => import("./index-DVitM43i.js"));
+function jt(r) {
+  const { mapProvider: t } = R(), e = P(() => {
+    switch (t == null ? void 0 : t.name) {
+      case "maptiler":
+        return zt;
+      case "google":
+        return Dt;
+      case "mapbox":
+        return Nt;
+      default:
+        return null;
+    }
+  }, [t]);
+  return e ? /* @__PURE__ */ T(e, { ...r }) : null;
+}
+function Gt(r) {
+  const [t, e] = v([]), [n, o] = v(r.zoom || I.zoom), [i, a] = v();
+  return /* @__PURE__ */ T(
+    tt.Provider,
+    {
+      value: { ...r, markerPoints: t, setMarkerPoints: e, bounds: i, setBounds: a, zoom: n, setZoom: o },
+      children: r.children
+    }
+  );
+}
+const Jt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BaseMap: yt,
+  CenterPin: At,
+  Layers: jt,
+  Markers: Zt,
+  Popup: Ft,
+  Root: Gt
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  Ht as M,
+  H as a,
+  I as d,
+  Jt as i,
+  Yt as m,
+  R as u
+};

package/dist/{index-DFdfOz0d.js → index-C36u5N_F.js}

@@ -1,7 +1,7 @@
 import { jsx as e } from "react/jsx-runtime";
 import { useEffect as a } from "react";
 import { P as c } from "./scale-control-CyJd4u6j.js";
-import { u as i } from "./index-Bd7meO8V.js";
+import { u as i } from "./index-Bp1bWq9c.js";
 import { c as n } from "./styles-ChFj97uV.js";
 function l({
   latitude: p,