@riverbankcms/sdk 0.72.0 → 0.75.0

package/dist/client/chunk-3PEDD5KJ.mjs

@@ -0,0 +1,146 @@
+import * as React from 'react';
+import { createPortal } from 'react-dom';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+// ../blocks/src/system/runtime/shared/components/ModalShell.tsx
+var modalBodyScrollLockCount = 0;
+var modalBodyOriginalOverflow = null;
+function lockBodyScroll() {
+  if (typeof document === "undefined") {
+    return;
+  }
+  if (modalBodyScrollLockCount === 0) {
+    modalBodyOriginalOverflow = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+  }
+  modalBodyScrollLockCount += 1;
+}
+function unlockBodyScroll() {
+  if (typeof document === "undefined" || modalBodyScrollLockCount === 0) {
+    return;
+  }
+  modalBodyScrollLockCount -= 1;
+  if (modalBodyScrollLockCount === 0) {
+    document.body.style.overflow = modalBodyOriginalOverflow ?? "";
+    modalBodyOriginalOverflow = null;
+  }
+}
+function ModalShell({
+  title,
+  titleId,
+  onClose,
+  children,
+  portalRoot,
+  portal = false,
+  overlayClassName,
+  modalClassName,
+  renderSrOnlyTitle = false,
+  renderHeader,
+  headerClassName,
+  titleClassName,
+  closeButtonClassName,
+  closeIcon
+}) {
+  const closeButtonRef = React.useRef(null);
+  const onCloseRef = React.useRef(onClose);
+  onCloseRef.current = onClose;
+  React.useEffect(() => {
+    closeButtonRef.current?.focus();
+    const onKeyDown = (event) => {
+      if (event.key === "Escape") {
+        onCloseRef.current();
+      }
+    };
+    document.addEventListener("keydown", onKeyDown);
+    lockBodyScroll();
+    return () => {
+      document.removeEventListener("keydown", onKeyDown);
+      unlockBodyScroll();
+    };
+  }, []);
+  const srOnlyTitle = renderSrOnlyTitle ? /* @__PURE__ */ jsx(
+    "h2",
+    {
+      id: titleId,
+      style: {
+        position: "absolute",
+        width: 1,
+        height: 1,
+        padding: 0,
+        margin: -1,
+        overflow: "hidden",
+        clip: "rect(0,0,0,0)",
+        whiteSpace: "nowrap",
+        border: 0
+      },
+      children: title
+    }
+  ) : null;
+  const header = renderHeader ? renderHeader({ title, titleId, onClose, closeButtonRef }) : /* @__PURE__ */ jsxs("div", { className: headerClassName, children: [
+    !renderSrOnlyTitle ? /* @__PURE__ */ jsx("h3", { className: titleClassName, id: titleId, children: title }) : null,
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        ref: closeButtonRef,
+        type: "button",
+        className: closeButtonClassName,
+        onClick: onClose,
+        "aria-label": "Close",
+        children: closeIcon ?? "\xD7"
+      }
+    )
+  ] });
+  const modal = /* @__PURE__ */ jsx("div", { className: overlayClassName, onClick: onClose, children: /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: modalClassName,
+      onClick: (event) => event.stopPropagation(),
+      role: "dialog",
+      "aria-modal": "true",
+      "aria-labelledby": titleId,
+      children: [
+        srOnlyTitle,
+        header,
+        children
+      ]
+    }
+  ) });
+  if (!portal) {
+    return modal;
+  }
+  if (typeof document === "undefined") {
+    return null;
+  }
+  if (!portalRoot) {
+    return null;
+  }
+  return createPortal(modal, portalRoot);
+}
+
+// ../blocks/src/system/runtime/shared/utils/checkoutRoute.ts
+function resolveDedicatedCheckoutTarget(pathname) {
+  const internalPublishedMatch = pathname.match(
+    /^\/internal-sites\/([^/]+)\/([^/]+)\/published(?:\/.*)?$/
+  );
+  if (internalPublishedMatch) {
+    const hostKey = internalPublishedMatch[1];
+    const siteIdentifier = internalPublishedMatch[2];
+    if (hostKey && siteIdentifier) {
+      return {
+        kind: "internal_published_preview",
+        hostKey,
+        siteIdentifier
+      };
+    }
+  }
+  return { kind: "public" };
+}
+function resolveDedicatedCheckoutPath(pathname) {
+  const target = resolveDedicatedCheckoutTarget(pathname);
+  if (target.kind === "internal_published_preview") {
+    return `/internal-sites/${target.hostKey}/${target.siteIdentifier}/published/checkout`;
+  }
+  return "/checkout";
+}
+
+export { ModalShell, resolveDedicatedCheckoutPath };

package/dist/client/chunk-CY2ZTSE5.mjs

@@ -0,0 +1,204 @@
+"use client";
+import { useBlockApi, BlockApiError } from './chunk-M3L3KYYR.mjs';
+import { themeButtonClassName } from './chunk-FU2QRZMX.mjs';
+import { useState, useSyncExternalStore, useEffect } from 'react';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+function MagicLinkForm({
+  initialEmail = "",
+  title,
+  subtitle,
+  buttonText = "Send login link",
+  successMessage = "Check your email for a login link to sign in.",
+  onSuccess,
+  classPrefix = "er",
+  compact = false
+}) {
+  const api = useBlockApi();
+  const [email, setEmail] = useState(initialEmail);
+  const [loading, setLoading] = useState(false);
+  const [success, setSuccess] = useState(false);
+  const [error, setError] = useState(null);
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    const normalizedEmail = email.trim().toLowerCase();
+    if (!normalizedEmail || loading) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const redirectTo = `${window.location.pathname}${window.location.search}${window.location.hash}`;
+      await api.sendMagicLink({
+        email: normalizedEmail,
+        redirectUrl: `${window.location.origin}/api/portal/callback?redirect_to=${encodeURIComponent(redirectTo)}`
+      });
+      setSuccess(true);
+      onSuccess?.();
+    } catch (err) {
+      console.error("Magic link error:", err);
+      setError(err instanceof Error ? err.message : "Failed to send. Please try again.");
+    } finally {
+      setLoading(false);
+    }
+  };
+  const handleReset = () => {
+    setSuccess(false);
+    setEmail("");
+    setError(null);
+  };
+  if (success) {
+    return /* @__PURE__ */ jsxs("div", { className: `${classPrefix}-magic-link-success`, children: [
+      /* @__PURE__ */ jsx("p", { className: `${classPrefix}-portal-auth-text ${classPrefix}-portal-auth-text--success`, children: successMessage }),
+      !compact && /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          className: classPrefix === "cp" ? themeButtonClassName({ variant: "secondary", size: "md" }) : `${classPrefix}-modal-btn ${classPrefix}-modal-btn--secondary`,
+          onClick: handleReset,
+          children: "Try a different email"
+        }
+      )
+    ] });
+  }
+  return /* @__PURE__ */ jsxs("form", { onSubmit: handleSubmit, className: `${classPrefix}-magic-link-form`, children: [
+    title && /* @__PURE__ */ jsx("h3", { className: `${classPrefix}-magic-link-title`, children: title }),
+    subtitle && /* @__PURE__ */ jsx("p", { className: `${classPrefix}-portal-auth-text`, children: subtitle }),
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        type: "email",
+        className: classPrefix === "cp" ? "cp-input" : `${classPrefix}-form__input`,
+        placeholder: "your@email.com",
+        value: email,
+        onChange: (e) => setEmail(e.target.value),
+        autoFocus: !compact,
+        required: true,
+        disabled: loading
+      }
+    ),
+    error && /* @__PURE__ */ jsx("p", { className: `${classPrefix}-portal-auth-text ${classPrefix}-portal-auth-text--error`, children: error }),
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "submit",
+        className: classPrefix === "cp" ? themeButtonClassName({ variant: "primary", size: "md" }) : `${classPrefix}-modal-btn`,
+        disabled: !email.trim() || loading,
+        children: loading ? "Sending..." : buttonText
+      }
+    )
+  ] });
+}
+var WAITLIST_CLAIM_LOCATION_EVENT = "riverbank:waitlist-claim-location-change";
+var historyPatched = false;
+function emitWaitlistClaimLocationChange() {
+  if (typeof window === "undefined") return;
+  window.dispatchEvent(new Event(WAITLIST_CLAIM_LOCATION_EVENT));
+}
+function ensureWaitlistClaimLocationTracking() {
+  if (typeof window === "undefined" || historyPatched) {
+    return;
+  }
+  historyPatched = true;
+  const history = window.history;
+  if (history.__riverbankWaitlistClaimPatched__) {
+    return;
+  }
+  const wrapHistoryMethod = (method) => {
+    return function patched(...args) {
+      method.apply(this, args);
+      emitWaitlistClaimLocationChange();
+    };
+  };
+  try {
+    history.pushState = wrapHistoryMethod(history.pushState);
+    history.replaceState = wrapHistoryMethod(history.replaceState);
+    history.__riverbankWaitlistClaimPatched__ = true;
+  } catch {
+  }
+  window.addEventListener("popstate", emitWaitlistClaimLocationChange);
+}
+function getWaitlistClaimTokenFromUrl() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  const token = new URLSearchParams(window.location.search).get("waitlist_claim")?.trim() ?? "";
+  return token.length > 0 ? token : null;
+}
+function subscribeToWaitlistClaimToken(callback) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  ensureWaitlistClaimLocationTracking();
+  window.addEventListener(WAITLIST_CLAIM_LOCATION_EVENT, callback);
+  return () => {
+    window.removeEventListener(WAITLIST_CLAIM_LOCATION_EVENT, callback);
+  };
+}
+function getWaitlistClaimTokenSnapshot() {
+  return getWaitlistClaimTokenFromUrl();
+}
+function useWaitlistClaim() {
+  const api = useBlockApi();
+  const token = useSyncExternalStore(
+    subscribeToWaitlistClaimToken,
+    getWaitlistClaimTokenSnapshot,
+    () => null
+  );
+  const [claim, setClaim] = useState(null);
+  const [error, setError] = useState(null);
+  const [loginMessage, setLoginMessage] = useState(null);
+  const [requiresPortalLogin, setRequiresPortalLogin] = useState(false);
+  const [isLoading, setIsLoading] = useState(() => Boolean(token));
+  useEffect(() => {
+    let cancelled = false;
+    async function resolveClaim() {
+      if (!token) {
+        setClaim(null);
+        setError(null);
+        setLoginMessage(null);
+        setRequiresPortalLogin(false);
+        setIsLoading(false);
+        return;
+      }
+      setIsLoading(true);
+      setClaim(null);
+      setError(null);
+      setLoginMessage(null);
+      setRequiresPortalLogin(false);
+      try {
+        const result = await api.resolveWaitlistClaim({ claimToken: token });
+        if (cancelled) return;
+        setClaim(result);
+      } catch (claimError) {
+        if (cancelled) return;
+        const message = claimError instanceof Error ? claimError.message : "Failed to resolve waitlist claim";
+        setClaim(null);
+        if (claimError instanceof BlockApiError && claimError.status === 401) {
+          setRequiresPortalLogin(true);
+          setLoginMessage(message);
+          setError(null);
+        } else {
+          setError(message);
+        }
+      } finally {
+        if (!cancelled) {
+          setIsLoading(false);
+        }
+      }
+    }
+    resolveClaim();
+    return () => {
+      cancelled = true;
+    };
+  }, [api, token]);
+  return {
+    token,
+    claim,
+    error,
+    loginMessage,
+    requiresPortalLogin,
+    isLoading
+  };
+}
+
+export { MagicLinkForm, useWaitlistClaim };

package/dist/client/chunk-F7LHOKEH.mjs

@@ -0,0 +1,146 @@
+"use client";
+import { isRecord } from './chunk-I2MMZO53.mjs';
+import { useRef, useState, useEffect } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+var LEAFLET_CSS = "https://unpkg.com/leaflet@1.9.4/dist/leaflet.css";
+var LEAFLET_CSS_INTEGRITY = "sha256-p4NxAoJBhIIN+hmNHrzRCf9tD/miZyoHS5obTRR9BMY=";
+var LEAFLET_JS = "https://unpkg.com/leaflet@1.9.4/dist/leaflet.js";
+var LEAFLET_JS_INTEGRITY = "sha256-20nQCchB9co0qIjJZRGuk2/Z9VM+kNiyxNV1lvTlZBo=";
+var leafletLoaded = false;
+var leafletLoadPromise = null;
+function isLeafletApi(value) {
+  if (!isRecord(value)) return false;
+  return typeof value.map === "function" && typeof value.tileLayer === "function" && typeof value.marker === "function";
+}
+function loadLeaflet() {
+  if (leafletLoaded) return Promise.resolve();
+  if (leafletLoadPromise) return leafletLoadPromise;
+  leafletLoadPromise = new Promise((resolve, reject) => {
+    if (typeof window !== "undefined" && isLeafletApi(Reflect.get(window, "L"))) {
+      leafletLoaded = true;
+      resolve();
+      return;
+    }
+    const link = document.createElement("link");
+    link.rel = "stylesheet";
+    link.href = LEAFLET_CSS;
+    link.integrity = LEAFLET_CSS_INTEGRITY;
+    link.crossOrigin = "anonymous";
+    document.head.appendChild(link);
+    const script = document.createElement("script");
+    script.src = LEAFLET_JS;
+    script.integrity = LEAFLET_JS_INTEGRITY;
+    script.crossOrigin = "anonymous";
+    script.async = true;
+    script.onload = () => {
+      leafletLoaded = true;
+      resolve();
+    };
+    script.onerror = () => {
+      leafletLoadPromise = null;
+      reject(new Error("Failed to load Leaflet"));
+    };
+    document.head.appendChild(script);
+  });
+  return leafletLoadPromise;
+}
+var LeafletStaticMap = ({
+  location,
+  label,
+  className = "",
+  height = 200,
+  zoom = 15
+}) => {
+  const mapContainerRef = useRef(null);
+  const mapRef = useRef(null);
+  const markerRef = useRef(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    let mounted = true;
+    async function initMap() {
+      try {
+        await loadLeaflet();
+        if (!mounted || !mapContainerRef.current) return;
+        const L = Reflect.get(window, "L");
+        if (!isLeafletApi(L)) {
+          throw new Error("Leaflet not available");
+        }
+        if (!mapRef.current) {
+          const map = L.map(mapContainerRef.current, {
+            scrollWheelZoom: false,
+            dragging: true,
+            zoomControl: true
+          });
+          const tileLayer = L.tileLayer("https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png", {
+            attribution: '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a>'
+          });
+          tileLayer.addTo(map);
+          const marker = L.marker([location.lat, location.lng]);
+          marker.addTo(map);
+          map.setView([location.lat, location.lng], zoom);
+          if (label) {
+            marker.bindPopup(label);
+          }
+          mapRef.current = map;
+          markerRef.current = {
+            bindPopup(content) {
+              marker.bindPopup(content);
+              return this;
+            },
+            setLatLng(latlng) {
+              marker.setLatLng(latlng);
+              return this;
+            }
+          };
+        }
+        setLoading(false);
+      } catch (err) {
+        if (mounted) {
+          setError(err instanceof Error ? err.message : "Failed to load map");
+          setLoading(false);
+        }
+      }
+    }
+    initMap();
+    return () => {
+      mounted = false;
+      if (mapRef.current) {
+        mapRef.current.remove();
+        mapRef.current = null;
+        markerRef.current = null;
+      }
+    };
+  }, []);
+  useEffect(() => {
+    if (!mapRef.current || !markerRef.current) {
+      return;
+    }
+    mapRef.current.setView([location.lat, location.lng], zoom);
+    markerRef.current.setLatLng([location.lat, location.lng]);
+    if (label) {
+      markerRef.current.bindPopup(label);
+    }
+  }, [location.lat, location.lng, label, zoom]);
+  if (error) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref: mapContainerRef,
+      className: `leaflet-static-map ${className}`,
+      style: {
+        height,
+        width: "100%",
+        borderRadius: "0.5rem",
+        overflow: "hidden",
+        backgroundColor: loading ? "rgb(var(--tb-surface))" : void 0
+      },
+      "aria-label": label ? `Map showing ${label}` : "Location map"
+    }
+  );
+};
+
+export { LeafletStaticMap };