@alfadocs/ui-kit-debug 1.112.2 → 1.114.0

package/dist/_chunks/map-view-Bny79cWa.js

@@ -0,0 +1,856 @@
+import { jsx as l, jsxs as T } from "react/jsx-runtime";
+import { forwardRef as xe, useMemo as V, useRef as k, useId as Ce, useState as N, useEffect as x, useCallback as _, useImperativeHandle as Le, useLayoutEffect as Ee } from "react";
+import { createPortal as Ve } from "react-dom";
+import { c as S } from "./index-D2ZczOXr.js";
+import { useTranslation as q } from "react-i18next";
+import { M as Ie, A as Pe, a as _e, b as Te, P as oe, c as Ne, u as Se, d as ie, e as $ } from "./maps-core-gate-DkNqGkm3.js";
+import { B as Ge } from "./button-DohK_Ak_.js";
+import { S as Re } from "./skeleton-tTWJpvAq.js";
+import { V as Ae } from "./visually-hidden-BHxEUGyT.js";
+import { E as Ze } from "./error-boundary-tAn_GuCu.js";
+import { u as Oe } from "./registry-DvAUVLHh.js";
+import { l as je } from "./length-token-DwMnGEYT.js";
+import { M as De } from "./map-pin-BaY37-Km.js";
+import { E as He } from "./external-link-CY6zAXXU.js";
+const $e = {
+  id: "map-view",
+  // pan → scroll (viewport move); set_zoom → set_value; select_marker → pick
+  // (NON-persisting marker focus, no value state slot).
+  capabilities: ["scroll", "set_value", "pick"],
+  // Every action routes through the imperative bridge, which only exists
+  // once the map has loaded: consent granted (the default is
+  // `consentGranted={false}`) and Google Maps finished loading. Until then
+  // all three actions are silent no-ops. `consentGranted` says whether the
+  // gate is passed, and a null `center` after it means the map is still
+  // loading. `center` / `zoom` are read off the live
+  // map because Google clamps zoom and animates pans, so requested is not
+  // applied; `selectedMarkerId` is the only confirmation the host accepted
+  // a `select_marker` proposal.
+  //
+  // A9: marker ids only (`MapMarker.id` is a stable opaque id). Never
+  // `MapMarker.label`, never the `address` prop (consumer-supplied free
+  // text, PII in any patient-address deployment), never `apiKey`.
+  state: {
+    consentGranted: {
+      type: "boolean",
+      descriptionKey: "ui.agent.mapView.state.consentGranted",
+      description: "True when the GDPR consent gate has been passed. Read this FIRST: while it is false every action is a silent no-op against a placeholder, and nothing else in the surface says so. When it is true but `center` is still null, Google Maps is loading; wait for `center` before acting.",
+      read: (e) => e.isConsentGranted()
+    },
+    markerCount: {
+      type: "number",
+      descriptionKey: "ui.agent.mapView.state.markerCount",
+      description: "Number of markers the consumer passed. Zero means there is nothing for `select_marker` to select. A count only — no ids, labels or positions.",
+      read: (e) => e.getMarkerCount()
+    },
+    selectedMarkerId: {
+      type: "string | null",
+      descriptionKey: "ui.agent.mapView.state.selectedMarkerId",
+      description: "Id of the marker the host currently holds as selected, or null. Selection is fully controlled by the consumer, so `select_marker` only proposes — this slot is the only way to see whether the proposal was accepted.",
+      read: (e) => e.getSelectedMarkerId()
+    },
+    center: {
+      type: "{ lat: number; lng: number } | null",
+      descriptionKey: "ui.agent.mapView.state.center",
+      description: "Live map centre in lat/lng, or null until the map has loaded (consent not granted, or Google Maps still loading). The read-back for `pan_to`, and the sign that the map is ready.",
+      read: (e) => e.getCenter()
+    },
+    zoom: {
+      type: "number | null",
+      descriptionKey: "ui.agent.mapView.state.zoom",
+      description: "Live zoom level, or null until the map has loaded. Google clamps zoom to the map type's range, so this is not necessarily the value last passed to `set_zoom`.",
+      read: (e) => e.getZoom()
+    }
+  },
+  actions: {
+    pan_to: {
+      // Ephemeral viewport move, no data loss → read.
+      safety: "read",
+      argsType: "{ position: { lat: number; lng: number } }",
+      argsSchema: {
+        type: "object",
+        properties: {
+          position: {
+            type: "object",
+            properties: {
+              lat: { type: "number", description: "Latitude in degrees." },
+              lng: { type: "number", description: "Longitude in degrees." }
+            },
+            required: ["lat", "lng"]
+          }
+        },
+        required: ["position"]
+      },
+      idempotent: !0,
+      descriptionKey: "ui.agent.mapView.actions.panTo",
+      description: "Pan the map to a new centre without changing zoom. Read the `center` slot back to confirm — Google animates the pan, so the applied centre settles after the call.",
+      errors: [
+        "Silent no-op until the map has loaded: while `consentGranted` is false (only the consent placeholder shows) or while `center` is still null (Google Maps is loading)."
+      ],
+      invoke: (e, o) => {
+        e.panTo(o.position);
+      }
+    },
+    set_zoom: {
+      // Ephemeral viewport zoom, no data loss → read.
+      safety: "read",
+      argsType: "{ zoom: number }",
+      argsSchema: {
+        type: "object",
+        properties: {
+          zoom: {
+            type: "number",
+            description: "Zoom level, typical range 1–20."
+          }
+        },
+        required: ["zoom"]
+      },
+      idempotent: !0,
+      descriptionKey: "ui.agent.mapView.actions.setZoom",
+      description: "Set the map zoom level (typical range 1–20). Read the `zoom` slot back — Google clamps the request to the map type’s supported range, so requested and applied can differ.",
+      errors: [
+        "Silent no-op until the map has loaded: while `consentGranted` is false (only the consent placeholder shows) or while `center` is still null (Google Maps is loading).",
+        "Requested zoom is clamped to the map type's range; `zoom` reports what was actually applied."
+      ],
+      invoke: (e, o) => {
+        e.setZoom(o.zoom);
+      }
+    },
+    select_marker: {
+      // Ephemeral marker focus, no data loss → read.
+      safety: "read",
+      argsType: "{ id: string | null }",
+      argsSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: ["string", "null"],
+            description: "Marker id to select, or null to clear the selection."
+          }
+        },
+        required: ["id"]
+      },
+      idempotent: !0,
+      descriptionKey: "ui.agent.mapView.actions.selectMarker",
+      description: "Propose a marker selection by id, or pass null to clear it. Fires the host's `onMarkerClick`; selection is controlled by the host, so read the `selectedMarkerId` slot back to see whether it accepted.",
+      errors: [
+        "Silent no-op until the map has loaded: while `consentGranted` is false (only the consent placeholder shows) or while `center` is still null (Google Maps is loading).",
+        "The host owns `selectedMarkerId` and may ignore the proposal; `selectedMarkerId` is unchanged when it does."
+      ],
+      invoke: (e, o) => {
+        e.selectMarker(o.id);
+      }
+    }
+  },
+  domHooks: {
+    root: {
+      attr: "data-component",
+      value: "map-view",
+      description: "Marks the element as a kit MapView."
+    },
+    instanceId: {
+      attr: "data-component-id",
+      sourceProp: "id",
+      description: "Sourced from the id prop."
+    }
+  }
+}, Ke = S(
+  ["ds:relative ds:overflow-hidden ds:block", "ds:bg-[var(--muted)]"].join(" "),
+  {
+    variants: {
+      size: {
+        sm: "ds:[--map-block-size:14rem]",
+        md: "ds:[--map-block-size:20rem]",
+        lg: "ds:[--map-block-size:28rem]",
+        // `fill` defers sizing to the parent. The outer takes
+        // `block-size: 100%` so the inner (also 100%) has something
+        // to inherit from. Use inside a viewport-locked column —
+        // `<PracticeResults variant="map-first">` wires this through
+        // automatically; standalone consumers must give the parent
+        // a constrained block-size or the map collapses to 0.
+        fill: "ds:[block-size:100%]"
+      },
+      surface: {
+        bordered: "ds:rounded-[var(--radius-md)] ds:border ds:border-[color:var(--border)]",
+        elevated: "ds:rounded-[var(--radius-md)] ds:shadow-[var(--shadow-card)] ds:[:where(&)]:border-[length:var(--surface-border-width,var(--border-width-sm))] ds:border-[color:var(--card-border)]",
+        bare: "ds:rounded-none ds:border-0"
+      }
+    },
+    defaultVariants: { size: "md", surface: "bordered" }
+  }
+), We = S("ds:block ds:w-full", {
+  variants: {
+    size: {
+      sm: "ds:[block-size:var(--map-block-size)]",
+      md: "ds:[block-size:var(--map-block-size)]",
+      lg: "ds:[block-size:var(--map-block-size)]",
+      fill: "ds:[block-size:100%]"
+    }
+  },
+  defaultVariants: { size: "md" }
+}), qe = S(
+  [
+    "ds:absolute ds:inset-0",
+    "ds:flex ds:flex-col ds:items-center ds:justify-center",
+    "ds:gap-[var(--spacing-sm)]",
+    "ds:p-[var(--spacing-md)]",
+    "ds:bg-[var(--muted)] ds:text-[var(--foreground)]",
+    "ds:text-center"
+  ].join(" ")
+), Be = S("type-heading-3 ds:m-0"), se = S(
+  "type-body-sm ds:text-[var(--muted-foreground)] ds:[max-inline-size:28rem] ds:m-0"
+);
+function Fe({
+  onHandleReady: e,
+  onMarkerSelect: o,
+  onCameraMove: r
+}) {
+  const a = $();
+  return x(() => {
+    if (a)
+      return e({
+        panTo: (t) => {
+          r(), a.panTo(t);
+        },
+        setZoom: (t) => {
+          r(), a.setZoom(t);
+        },
+        jumpTo: (t, i) => {
+          r(), a.moveCamera({ center: t, zoom: i });
+        },
+        selectMarker: (t) => o(t),
+        // Read straight off the live map: Google clamps `setZoom` to the
+        // map type's range and animates `panTo`, so requested and applied
+        // are not the same value.
+        getCenter: () => {
+          var t;
+          return ((t = a.getCenter()) == null ? void 0 : t.toJSON()) ?? null;
+        },
+        getZoom: () => a.getZoom() ?? null
+      }), () => e(null);
+  }, [a, e, o, r]), null;
+}
+function Je({
+  onBoundsChange: e,
+  userInteraction: o
+}) {
+  const r = $(), a = k(e);
+  return a.current = e, x(() => {
+    if (!r) return;
+    const t = r.getDiv();
+    let i = null;
+    const d = () => {
+      o.current = {
+        pendingInput: !1,
+        moved: !1,
+        programmatic: !1
+      };
+    };
+    d();
+    let h;
+    const u = /* @__PURE__ */ new Set(), m = (n) => {
+      if (n instanceof PointerEvent && n.pointerType === "touch" && (n.type === "pointerdown" && u.add(n.pointerId), n.type === "pointerup" || n.type === "pointercancel")) {
+        u.delete(n.pointerId);
+        return;
+      }
+      if (n instanceof PointerEvent && n.type === "pointermove" && n.buttons === 0 && n.pointerType !== "touch" || n instanceof KeyboardEvent && ![
+        "ArrowUp",
+        "ArrowDown",
+        "ArrowLeft",
+        "ArrowRight",
+        "+",
+        "=",
+        "-",
+        "_",
+        "Enter",
+        " ",
+        "PageUp",
+        "PageDown"
+      ].includes(n.key))
+        return;
+      const p = document.fullscreenElement, v = !!(p && (p.contains(t) || t.contains(p)));
+      let b = n.type === "dblclick";
+      n instanceof PointerEvent && n.type === "pointermove" && (b = n.pointerType !== "touch" || u.size >= 2 || v), n.type === "touchmove" && (b = n.touches.length >= 2 || v), n instanceof KeyboardEvent && (b = n.key !== "Enter" && n.key !== " "), n instanceof WheelEvent && (b = n.ctrlKey || n.metaKey || v), n.type === "click" && (b = n.target instanceof Element && n.target.closest('button, [role="button"]') != null), b && (o.current.programmatic = !1), o.current.pendingInput = !0, clearTimeout(h), h = setTimeout(() => {
+        o.current.pendingInput = !1;
+      }, 250);
+    }, f = () => {
+      o.current.pendingInput && !o.current.programmatic && (o.current.moved = !0);
+    }, g = () => {
+      var E, P;
+      const n = (E = r.getBounds()) == null ? void 0 : E.toJSON(), p = (P = r.getCenter()) == null ? void 0 : P.toJSON(), v = r.getZoom(), b = o.current.moved;
+      if (d(), clearTimeout(h), !n || !p || v == null) return;
+      const z = !i || Object.keys(n).some(
+        (G) => n[G] !== i.bounds[G]
+      ), I = i != null && (v !== i.zoom || p.lat !== i.center.lat || p.lng !== i.center.lng);
+      i = { bounds: n, center: p, zoom: v }, z && a.current(n, { userInteraction: b && I });
+    }, c = [
+      "pointerdown",
+      "pointermove",
+      "pointerup",
+      "pointercancel",
+      "touchstart",
+      "touchmove",
+      "click",
+      "dblclick",
+      "wheel",
+      "keydown"
+    ];
+    c.forEach(
+      (n) => t.addEventListener(n, m, { capture: !0, passive: !0 })
+    );
+    const w = [
+      r.addListener("dragstart", () => {
+        o.current.programmatic = !1, o.current.moved = !0;
+      }),
+      r.addListener("center_changed", f),
+      r.addListener("zoom_changed", f),
+      r.addListener("idle", g)
+    ];
+    return g(), () => {
+      w.forEach((n) => n.remove()), c.forEach(
+        (n) => t.removeEventListener(n, m, !0)
+      ), clearTimeout(h), d();
+    };
+  }, [r, o]), null;
+}
+function Ue(e, o) {
+  const r = $(), [a, t] = N(null), { lat: i, lng: d } = o;
+  return x(() => {
+    if (!r || typeof r.getCenter != "function") return;
+    const h = () => {
+      var p, v;
+      const m = (p = r.getCenter()) == null ? void 0 : p.toJSON(), f = r.getZoom(), g = (v = r.getDiv) == null ? void 0 : v.call(r);
+      if (!m || f == null || !g) {
+        t(null);
+        return;
+      }
+      const c = g.clientWidth, w = g.clientHeight, n = le * 2 ** f;
+      t({
+        id: e,
+        width: c,
+        height: w,
+        x: c / 2 + (d - m.lng) / 360 * n,
+        y: w / 2 - (H(i) - H(m.lat)) * n / (2 * Math.PI)
+      });
+    };
+    h();
+    const u = ["bounds_changed", "zoom_changed", "center_changed", "idle"].flatMap(
+      (m) => typeof r.addListener == "function" ? [r.addListener(m, h)] : []
+    );
+    return () => u.forEach((m) => m.remove());
+  }, [r, e, i, d]), (a == null ? void 0 : a.id) === e ? a : null;
+}
+function Xe({
+  marker: e,
+  frame: o,
+  direction: r,
+  children: a
+}) {
+  const t = Ue(e.id, e.position);
+  return !t || !o ? null : Ve(
+    /* @__PURE__ */ l(et, { anchor: t, direction: r, children: a }),
+    o
+  );
+}
+const Ye = 52, Qe = 12, D = 8;
+function et({
+  anchor: e,
+  children: o,
+  direction: r
+}) {
+  const a = k(null), [t, i] = N(
+    null
+  );
+  if (Ee(() => {
+    const n = a.current;
+    n && i(
+      (p) => (p == null ? void 0 : p.width) === n.offsetWidth && p.height === n.offsetHeight ? p : { width: n.offsetWidth, height: n.offsetHeight }
+    );
+  }, [o, e.id]), !(e.x >= 0 && e.x <= e.width && e.y >= 0 && e.y <= e.height)) return null;
+  const h = (t == null ? void 0 : t.width) ?? 0, u = (t == null ? void 0 : t.height) ?? 0, m = Math.max(D, e.width - h - D), f = Math.min(Math.max(e.x - h / 2, D), m), g = e.y - Ye - u, c = g < D, w = c ? e.y + Qe : g;
+  return (
+    // The layer is `ltr` because the map is geographic: x is always measured
+    // from the physical left. The card inside takes the page direction.
+    /* @__PURE__ */ l(
+      "div",
+      {
+        dir: "ltr",
+        "aria-hidden": "true",
+        "data-component": "map-view-marker-card-layer",
+        className: "ds:pointer-events-none ds:absolute ds:inset-0 ds:overflow-hidden",
+        children: /* @__PURE__ */ l(
+          "div",
+          {
+            ref: a,
+            "data-component": "map-view-marker-card",
+            "data-marker-id": e.id,
+            "data-placement": c ? "below" : "above",
+            style: {
+              "--marker-card-x": `${f}px`,
+              "--marker-card-y": `${w}px`
+            },
+            "data-measured": t ? "true" : "false",
+            className: "ds:absolute ds:[inset-inline-start:var(--marker-card-x)] ds:[inset-block-start:var(--marker-card-y)] ds:[inline-size:max-content] ds:[max-inline-size:calc(100%-var(--spacing-md))] ds:data-[measured=false]:invisible",
+            children: /* @__PURE__ */ l("div", { dir: r, children: o })
+          }
+        )
+      }
+    )
+  );
+}
+const le = 256, tt = (e) => e * Math.PI / 180;
+function H(e) {
+  const o = Math.min(Math.max(Math.sin(tt(e)), -0.9999), 0.9999);
+  return Math.log((1 + o) / (1 - o)) / 2;
+}
+const nt = (e) => Math.atan(Math.sinh(e)) * 180 / Math.PI;
+function rt(e) {
+  let o = -90, r = 90, a = -180, t = 180;
+  for (const { lat: i, lng: d } of e)
+    o = Math.max(o, i), r = Math.min(r, i), a = Math.max(a, d), t = Math.min(t, d);
+  return { north: o, south: r, east: a, west: t };
+}
+function ot(e, o, r, a, t) {
+  const { north: i, south: d, east: h, west: u } = rt(e);
+  if (i === d && h === u)
+    return { center: { lat: i, lng: h }, zoom: t };
+  const m = H(i), f = H(d), g = {
+    lat: nt((m + f) / 2),
+    lng: (h + u) / 2
+  }, c = (n, p) => p > 0 ? Math.log2(Math.max(n, 1) / le / p) : t, w = Math.min(
+    c(o - 2 * a, (h - u) / 360),
+    c(r - 2 * a, (m - f) / (2 * Math.PI)),
+    t
+  );
+  return { center: g, zoom: Math.max(0, Math.floor(w)) };
+}
+const ce = ({ id: e, lat: o, lng: r }) => e != null ? `id:${e}` : `at:${o},${r}`;
+function st({
+  points: e,
+  fitKey: o,
+  maxZoom: r,
+  onCameraMove: a
+}) {
+  const t = $(), i = k(null), d = k(!1), h = k(null);
+  return x(() => {
+    if (!t) return;
+    const u = () => {
+      var n;
+      const f = h.current, g = (n = t.getCenter()) == null ? void 0 : n.toJSON(), c = t.getZoom();
+      f != null && c === f.zoom && g != null && Math.abs(g.lat - f.center.lat) < 1e-6 && Math.abs(g.lng - f.center.lng) < 1e-6 || (d.current = !0);
+    }, m = [
+      t.addListener("dragstart", () => {
+        d.current = !0;
+      }),
+      t.addListener("center_changed", u),
+      t.addListener("zoom_changed", u)
+    ];
+    return () => m.forEach((f) => f.remove());
+  }, [t]), x(() => {
+    var v;
+    if (!t) return;
+    const u = ((v = i.current) == null ? void 0 : v.map) === t ? i.current : null;
+    if ((u == null ? void 0 : u.key) === o) return;
+    const m = new Set(e.map(ce)), f = (b, z) => {
+      h.current = { center: b, zoom: z }, a(), t.moveCamera({ center: b, zoom: z }), d.current = !1;
+    };
+    if (e.length === 0) {
+      i.current = { map: t, key: o, points: m };
+      return;
+    }
+    if (u != null && u.points.size > 0 && [...u.points].every((b) => m.has(b)) && d.current) {
+      i.current = { map: t, key: o, points: m };
+      return;
+    }
+    const c = t.getDiv();
+    if (!(c instanceof Element)) return;
+    const w = () => {
+      i.current = { map: t, key: o, points: m };
+      const b = Math.min(
+        je("--spacing-2xl", c, 48),
+        c.clientWidth / 4,
+        c.clientHeight / 4
+      ), { center: z, zoom: I } = ot(
+        e,
+        c.clientWidth,
+        c.clientHeight,
+        b,
+        r
+      );
+      f(z, I);
+    }, n = () => c.clientWidth > 0 && c.clientHeight > 0;
+    if (n() || typeof ResizeObserver > "u") {
+      w();
+      return;
+    }
+    const p = new ResizeObserver(() => {
+      n() && (p.disconnect(), w());
+    });
+    return p.observe(c), () => p.disconnect();
+  }, [t, o, e, r, a]), null;
+}
+const de = (e) => {
+  var o, r;
+  return typeof ((r = (o = globalThis.google) == null ? void 0 : o.maps) == null ? void 0 : r[e]) == "function";
+};
+function ue() {
+  const { t: e } = q("ui");
+  return /* @__PURE__ */ T(
+    "div",
+    {
+      role: "status",
+      "data-testid": "map-view-loading",
+      className: "ds:[inline-size:100%] ds:[block-size:100%]",
+      children: [
+        /* @__PURE__ */ l(Re, { variant: "rectangular", width: "100%", height: "100%" }),
+        /* @__PURE__ */ l(Ae, { children: e("common.loading") })
+      ]
+    }
+  );
+}
+function at({ children: e }) {
+  const o = Se();
+  return ie("maps") || !o || de("Map") ? e : /* @__PURE__ */ l(ue, {});
+}
+function it({ children: e }) {
+  return ie("marker") || de("Marker") ? e : null;
+}
+function ae({
+  address: e,
+  contentLang: o,
+  description: r,
+  onLoadMap: a,
+  openInGoogleMapsHref: t,
+  consentCta: i
+}) {
+  const { t: d } = q("ui");
+  return /* @__PURE__ */ T("div", { className: qe(), "data-testid": "map-view-consent", children: [
+    /* @__PURE__ */ l(
+      De,
+      {
+        "aria-hidden": "true",
+        className: "ds:size-6 ds:text-[var(--muted-foreground)]"
+      }
+    ),
+    /* @__PURE__ */ l("p", { className: Be(), children: d("mapView.consentTitle") }),
+    e ? /* @__PURE__ */ l(
+      "p",
+      {
+        className: se(),
+        "data-testid": "map-view-address",
+        lang: o,
+        children: e
+      }
+    ) : null,
+    /* @__PURE__ */ l("p", { className: se(), children: r }),
+    /* @__PURE__ */ T("div", { className: "ds:flex ds:gap-[var(--spacing-sm)] ds:flex-wrap ds:items-center ds:justify-center", children: [
+      i ?? /* @__PURE__ */ l(
+        Ge,
+        {
+          type: "button",
+          intent: "primary",
+          size: "sm",
+          onClick: a,
+          "data-testid": "map-view-load-cta",
+          children: d("mapView.consentCta")
+        }
+      ),
+      /* @__PURE__ */ T(
+        "a",
+        {
+          href: t,
+          target: "_blank",
+          rel: "noopener noreferrer",
+          className: "ds:inline-flex ds:items-center ds:gap-[var(--spacing-2xs)] ds:text-[var(--primary-readable)] ds:underline ds:underline-offset-2",
+          children: [
+            d("mapView.openInGoogleMaps"),
+            /* @__PURE__ */ l(He, { "aria-hidden": "true", className: "ds:size-3" })
+          ]
+        }
+      )
+    ] })
+  ] });
+}
+const lt = xe(
+  ({
+    id: e,
+    apiKey: o,
+    center: r,
+    zoom: a = 15,
+    markers: t,
+    selectedMarkerId: i,
+    hoveredMarkerId: d,
+    renderMarkerCard: h,
+    onMarkerClick: u,
+    onBoundsChange: m,
+    consentGranted: f = !1,
+    onConsentRequest: g,
+    address: c,
+    contentLang: w,
+    consentDescription: n,
+    consentCta: p,
+    mapId: v,
+    size: b,
+    surface: z,
+    ariaLabel: I,
+    fitToPoints: E,
+    fitKey: P,
+    fitMaxZoom: G = 15,
+    className: pe,
+    ...me
+  }, he) => {
+    const { t: R, i18n: B } = q("ui"), A = V(() => E ?? [], [E]), fe = V(
+      () => P ?? A.map((s) => `${ce(s)}@${s.lat},${s.lng}`).sort().join("|"),
+      [P, A]
+    ), C = A.length > 0, F = k(C), J = Ce(), ge = V(
+      () => `map-${J.replace(/[^a-zA-Z0-9-_]/g, "")}`,
+      [J]
+    ), [U, ye] = N(!1);
+    x(() => {
+      if (typeof window > "u") return;
+      const s = window.matchMedia("(prefers-reduced-motion: reduce)"), y = () => ye(s.matches);
+      return y(), s.addEventListener("change", y), () => s.removeEventListener("change", y);
+    }, []);
+    const X = V(() => `https://www.google.com/maps/search/?api=1&query=${c ? encodeURIComponent(c) : `${r.lat},${r.lng}`}`, [c, r.lat, r.lng]), M = k(null), Y = k({
+      pendingInput: !1,
+      moved: !1,
+      programmatic: !1
+    }), Z = _(() => {
+      Y.current = {
+        pendingInput: !1,
+        moved: !1,
+        programmatic: !0
+      };
+    }, []), O = _(
+      (s) => {
+        Z(), u == null || u(s);
+      },
+      [Z, u]
+    ), [be, ve] = N(null), K = V(
+      () => d != null && h ? (t ?? []).find((s) => s.id === d) ?? null : null,
+      [d, h, t]
+    ), we = _((s) => {
+      M.current = s;
+    }, []), Q = k(!1), ee = k(null), te = k(0), j = _(
+      () => ({
+        panTo: (s) => {
+          var y;
+          return (y = M.current) == null ? void 0 : y.panTo(s);
+        },
+        setZoom: (s) => {
+          var y;
+          return (y = M.current) == null ? void 0 : y.setZoom(s);
+        },
+        selectMarker: (s) => {
+          var y;
+          return (y = M.current) == null ? void 0 : y.selectMarker(s);
+        },
+        // Without `isConsentGranted` an agent has no way to learn that
+        // its pan / zoom / select was swallowed by the GDPR gate rather
+        // than applied: under the default (`consentGranted={false}`) the
+        // whole Maps subtree is unmounted and every action optional-chains
+        // into nothing.
+        isConsentGranted: () => Q.current,
+        getCenter: () => {
+          var s;
+          return ((s = M.current) == null ? void 0 : s.getCenter()) ?? null;
+        },
+        getZoom: () => {
+          var s;
+          return ((s = M.current) == null ? void 0 : s.getZoom()) ?? null;
+        },
+        getSelectedMarkerId: () => ee.current,
+        getMarkerCount: () => te.current
+      }),
+      []
+    );
+    Le(he, j, [j]);
+    const ke = V(
+      () => j(),
+      [j]
+    );
+    Oe($e, ke, e), x(() => {
+      var y, L;
+      const s = F.current && !C;
+      if (F.current = C, !C) {
+        if (s) {
+          (y = M.current) == null || y.jumpTo(r, a);
+          return;
+        }
+        U || (L = M.current) == null || L.panTo(r);
+      }
+    }, [r.lat, r.lng, U, C]), x(() => {
+      var s;
+      C || (s = M.current) == null || s.setZoom(a);
+    }, [a, C]);
+    const [Me, ne] = N(!1), re = f || Me;
+    Q.current = re, ee.current = i ?? null, te.current = (t ?? []).length;
+    const ze = _(() => {
+      if (g) {
+        g(), ne(!0);
+        return;
+      }
+      ne(!0);
+    }, [g]);
+    return /* @__PURE__ */ l(
+      "div",
+      {
+        className: Ke({ size: b, surface: z, className: pe }),
+        "data-component": "map-view",
+        "data-component-id": e ?? ge,
+        role: "region",
+        "aria-label": I ?? R("mapView.label"),
+        ...me,
+        children: /* @__PURE__ */ l(
+          "div",
+          {
+            ref: ve,
+            className: We({ size: b, className: "ds:relative" }),
+            children: re ? (
+              // A provider failure shows the consent placeholder (its "Open in
+              // Google Maps" link needs no script) with "Load map" as the
+              // retry, instead of unmounting the host's React tree. The gate
+              // starts the provider only once Google's `core` and `maps`
+              // libraries have arrived.
+              /* @__PURE__ */ l(
+                Ze,
+                {
+                  fallback: ({ reset: s }) => /* @__PURE__ */ l(
+                    ae,
+                    {
+                      address: c,
+                      contentLang: w,
+                      description: n ?? R("mapView.consentDescription"),
+                      onLoadMap: s,
+                      consentCta: void 0,
+                      openInGoogleMapsHref: X
+                    }
+                  ),
+                  children: /* @__PURE__ */ l(Ie, { libraries: ["maps"], pending: /* @__PURE__ */ l(ue, {}), children: /* @__PURE__ */ l(
+                    Pe,
+                    {
+                      apiKey: o,
+                      language: B.language,
+                      children: /* @__PURE__ */ l(at, { children: /* @__PURE__ */ T(
+                        _e,
+                        {
+                          defaultCenter: r,
+                          defaultZoom: a,
+                          mapId: v,
+                          gestureHandling: "cooperative",
+                          disableDefaultUI: !1,
+                          onClick: () => O(null),
+                          className: "ds:[inline-size:100%] ds:[block-size:100%]",
+                          children: [
+                            /* @__PURE__ */ l(
+                              Fe,
+                              {
+                                onHandleReady: we,
+                                onMarkerSelect: O,
+                                onCameraMove: Z
+                              }
+                            ),
+                            m ? /* @__PURE__ */ l(
+                              Je,
+                              {
+                                onBoundsChange: m,
+                                userInteraction: Y
+                              }
+                            ) : null,
+                            E ? /* @__PURE__ */ l(
+                              st,
+                              {
+                                points: A,
+                                fitKey: fe,
+                                maxZoom: G,
+                                onCameraMove: Z
+                              }
+                            ) : null,
+                            K && h ? /* @__PURE__ */ l(
+                              Xe,
+                              {
+                                marker: K,
+                                frame: be,
+                                direction: B.dir(),
+                                children: h(K.id)
+                              }
+                            ) : null,
+                            /* @__PURE__ */ l(it, { children: (t ?? []).map((s) => {
+                              const y = i != null && i === s.id, L = d != null && d === s.id, W = R("mapView.markerLabel", {
+                                label: s.label ?? s.id
+                              });
+                              return v ? /* @__PURE__ */ l(
+                                Te,
+                                {
+                                  position: s.position,
+                                  title: W,
+                                  "aria-label": W,
+                                  "data-selected": y ? "true" : "false",
+                                  "data-hovered": L ? "true" : "false",
+                                  zIndex: L ? 1e3 : y ? 500 : void 0,
+                                  onClick: () => O(s.id),
+                                  children: L ? (
+                                    // Hovered pin: larger, deep ink body with a
+                                    // white ring. Theme-invariant, because the
+                                    // tiles do not follow the kit theme: one of
+                                    // body and ring clears 3:1 on any map style.
+                                    // Not `--accent`, which failed contrast.
+                                    /* @__PURE__ */ l(
+                                      oe,
+                                      {
+                                        scale: 1.4,
+                                        background: "var(--map-marker-hover-color)",
+                                        borderColor: "var(--map-marker-hover-ring)",
+                                        glyphColor: "var(--map-marker-hover-ring)"
+                                      }
+                                    )
+                                  ) : /* @__PURE__ */ l(
+                                    oe,
+                                    {
+                                      background: "var(--primary)",
+                                      borderColor: "var(--primary)",
+                                      glyphColor: "var(--primary-foreground)"
+                                    }
+                                  )
+                                },
+                                s.id
+                              ) : /* @__PURE__ */ l(
+                                Ne,
+                                {
+                                  position: s.position,
+                                  title: W,
+                                  zIndex: L ? 1e3 : y ? 500 : void 0,
+                                  onClick: () => O(s.id)
+                                },
+                                s.id
+                              );
+                            }) })
+                          ]
+                        }
+                      ) })
+                    }
+                  ) })
+                }
+              )
+            ) : /* @__PURE__ */ l(
+              ae,
+              {
+                address: c,
+                contentLang: w,
+                description: n ?? R("mapView.consentDescription"),
+                onLoadMap: ze,
+                consentCta: p,
+                openInGoogleMapsHref: X
+              }
+            )
+          }
+        )
+      }
+    );
+  }
+);
+lt.displayName = "MapView";
+export {
+  lt as M
+};
+//# sourceMappingURL=map-view-Bny79cWa.js.map