@patientos/website-kit 0.2.1 → 0.2.2

package/dist/{checkout-block-CrO7OxI9.d.ts → checkout-block-Cog4H4I4.d.ts}

@@ -12,6 +12,7 @@ interface FunnelPublicApi {
     turnstileSiteKey?: string;
     portalUrl?: string;
     portalOrigin?: string;
+    portalApiOrigin?: string;
 }
 /** JSON-safe island configuration. Crosses the build→runtime boundary — see `./islands`. */
 type CertificateFunnelProps = {

package/dist/{chunk-BW7YKCKH.js → chunk-BHVDY6SC.js}

@@ -3,101 +3,176 @@ import * as React4 from "react";
 
 // src/portal-shared.client.tsx
 import * as React from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
-var apiOrigin = "";
-var apiOriginLocked = false;
+
+// src/portal-client.ts
+var PORTAL_WHOAMI_PATH = "/portal/api/whoami";
+var PORTAL_MAGIC_LINK_PATH = "/portal/api/magic-link";
+var PORTAL_PREFILL_PATH = "/portal/api/prefill";
+var PORTAL_PUBLIC_CLAIM_PATH = "/portal/api/public-claim";
+var PORTAL_RETURN_PATH = "/portal/return";
+var BRIDGE_TIMEOUT_MS = 15e3;
+var BRIDGE_PROBE_TIMEOUT_MS = 8e3;
+var PORTAL_REQUEST_INIT = {
+  credentials: "include",
+  cache: "no-store"
+};
 function normalizePortalApiOrigin(raw) {
-  let u;
+  let url;
   try {
-    u = new URL(raw.trim());
+    url = new URL(raw.trim());
   } catch {
     return null;
   }
-  const loopback = u.hostname === "localhost" || u.hostname === "127.0.0.1";
-  if (u.protocol !== "https:" && !(u.protocol === "http:" && loopback)) return null;
-  if (u.username || u.password || u.search || u.hash) return null;
-  if (u.pathname !== "/" && u.pathname !== "") return null;
-  return u.origin;
-}
-function configurePortalApiOrigin(raw) {
-  const wanted = raw?.trim();
-  if (!wanted) return;
-  const origin = normalizePortalApiOrigin(wanted);
-  if (!origin) {
-    console.error("[portal] ignoring a malformed portal API origin", wanted);
-    return;
-  }
-  if (apiOriginLocked) {
-    if (origin !== apiOrigin) {
-      console.error("[portal] refusing to re-point the portal API origin", {
-        configured: apiOrigin,
-        rejected: origin
-      });
-    }
-    return;
-  }
-  apiOrigin = origin;
-  apiOriginLocked = true;
+  const loopback = url.hostname === "localhost" || url.hostname === "127.0.0.1";
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) return null;
+  if (url.username || url.password || url.search || url.hash) return null;
+  if (url.pathname !== "/" && url.pathname !== "") return null;
+  return url.origin;
 }
-function portalApiUrl(path) {
-  return apiOrigin && path.startsWith("/") ? apiOrigin + path : path;
+function encodePortalReturnTarget(url) {
+  const bytes = new TextEncoder().encode(url);
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 }
-var PORTAL_MAGIC_LINK_URL = "/portal/api/magic-link";
-var PORTAL_SIGN_OUT_URL = "/portal/api/sign-out";
-var PORTAL_REQUEST_INIT = { credentials: "include", cache: "no-store" };
-function portalFetch(fetchImpl) {
-  return fetchImpl ?? ((input, init) => fetch(input, init));
+function sameOriginAvailable(portalOrigin) {
+  if (typeof window === "undefined") return false;
+  if (portalOrigin == null) {
+    return true;
+  }
+  const normalizedOrigin = portalOrigin.trim().replace(/\/+$/, "");
+  return normalizedOrigin !== "" && window.location.origin === normalizedOrigin;
 }
-async function readPortalResult(res) {
-  if (!res.ok) {
+async function readPortalResult(response) {
+  if (!response.ok) {
     let error = null;
     let body;
     try {
-      const parsed = await res.json();
+      const parsed = await response.json();
       if (typeof parsed?.error === "string") error = parsed.error;
       body = parsed;
     } catch {
     }
-    return { ok: false, status: res.status, error, body };
+    return { ok: false, status: response.status, error, body };
   }
   try {
-    return { ok: true, data: await res.json() };
+    return { ok: true, data: await response.json() };
   } catch {
     return { ok: false, status: null, error: null };
   }
 }
-async function portalGet(url, fetchImpl) {
-  try {
-    return await readPortalResult(
-      await portalFetch(fetchImpl)(portalApiUrl(url), PORTAL_REQUEST_INIT)
-    );
-  } catch {
-    return { ok: false, status: null, error: null };
+function createPortalClient(config = {}) {
+  const rawOrigin = config.apiOrigin?.trim() ?? "";
+  const normalizedOrigin = rawOrigin ? normalizePortalApiOrigin(rawOrigin) : "";
+  if (rawOrigin && !normalizedOrigin) {
+    console.error("[portal] ignoring a malformed portal API origin", rawOrigin);
+  }
+  const apiOrigin = normalizedOrigin ?? "";
+  const portalHref = config.portalUrl?.trim() ?? "";
+  const available = apiOrigin !== "" || sameOriginAvailable(config.portalOrigin);
+  const fetchImpl = config.fetchImpl ?? ((input, init) => globalThis.fetch(input, init));
+  const url = (path) => apiOrigin && path.startsWith("/") ? apiOrigin + path : path;
+  async function request(path, init, timeoutMs = BRIDGE_TIMEOUT_MS) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetchImpl(url(path), {
+        ...PORTAL_REQUEST_INIT,
+        ...init,
+        signal: controller.signal
+      });
+      return await readPortalResult(response);
+    } catch {
+      return { ok: false, status: null, error: null };
+    } finally {
+      clearTimeout(timer);
+    }
   }
+  const get = (path) => request(path, { headers: { accept: "application/json" } });
+  const send = (path, method, body) => request(path, {
+    method,
+    headers: { accept: "application/json", "content-type": "application/json" },
+    body: JSON.stringify(body ?? {})
+  });
+  const del = (path) => request(path, { method: "DELETE", headers: { accept: "application/json" } });
+  const returnPath = () => {
+    if (typeof window === "undefined") return "/";
+    const path = `${window.location.pathname || "/"}${window.location.search}${window.location.hash}`;
+    if (!apiOrigin) return path;
+    return `${PORTAL_RETURN_PATH}?to=${encodePortalReturnTarget(window.location.origin + path)}`;
+  };
+  return {
+    available,
+    apiOrigin,
+    portalHref,
+    url,
+    fetch: fetchImpl,
+    async whoAmI() {
+      if (!available) return { signedIn: false };
+      const result = await request(
+        PORTAL_WHOAMI_PATH,
+        { headers: { accept: "application/json" } },
+        BRIDGE_PROBE_TIMEOUT_MS
+      );
+      return result.ok && result.data?.signedIn === true ? result.data : { signedIn: false };
+    },
+    async requestMagicLink(email, redirect) {
+      if (!available) return false;
+      const result = await send(PORTAL_MAGIC_LINK_PATH, "POST", {
+        email,
+        redirect: redirect ?? returnPath()
+      });
+      return result.ok && result.data?.ok === true;
+    },
+    async prefill() {
+      if (!available) return null;
+      const result = await get(PORTAL_PREFILL_PATH);
+      return result.ok ? result.data : null;
+    },
+    async mintPublicClaim() {
+      if (!available) return null;
+      const result = await send(PORTAL_PUBLIC_CLAIM_PATH, "POST", {});
+      return result.ok ? result.data : null;
+    },
+    returnPath,
+    get,
+    send,
+    delete: del
+  };
+}
+
+// src/portal-shared.client.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var defaultPortalClient = createPortalClient();
+var PORTAL_SIGN_OUT_URL = "/portal/api/sign-out";
+function portalFetch(fetchImpl) {
+  return fetchImpl ?? ((input, init) => fetch(input, init));
+}
+var BOUND_PORTAL_CLIENT = /* @__PURE__ */ Symbol("boundPortalClient");
+function portalFetchForClient(client2, fetchImpl) {
+  const fetcher = portalFetch(fetchImpl);
+  const bound = (input, init) => fetcher(client2.url(input), init);
+  bound[BOUND_PORTAL_CLIENT] = client2;
+  return bound;
+}
+function defaultClientWith(fetchImpl) {
+  const boundClient = fetchImpl?.[BOUND_PORTAL_CLIENT];
+  if (boundClient) return boundClient;
+  if (!fetchImpl) return defaultPortalClient;
+  return createPortalClient({
+    apiOrigin: defaultPortalClient.apiOrigin,
+    portalUrl: defaultPortalClient.portalHref,
+    fetchImpl
+  });
+}
+async function portalGet(url, fetchImpl) {
+  return defaultClientWith(fetchImpl).get(url);
 }
 async function portalSend(url, method, body, fetchImpl) {
-  try {
-    const res = await portalFetch(fetchImpl)(portalApiUrl(url), {
-      ...PORTAL_REQUEST_INIT,
-      method,
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify(body ?? {})
-    });
-    return await readPortalResult(res);
-  } catch {
-    return { ok: false, status: null, error: null };
-  }
+  return defaultClientWith(fetchImpl).send(url, method, body);
 }
 async function portalDelete(url, fetchImpl) {
-  try {
-    const res = await portalFetch(fetchImpl)(portalApiUrl(url), {
-      ...PORTAL_REQUEST_INIT,
-      method: "DELETE"
-    });
-    return await readPortalResult(res);
-  } catch {
-    return { ok: false, status: null, error: null };
-  }
+  return defaultClientWith(fetchImpl).delete(url);
 }
 function hasPortalIdentity(body) {
   return typeof body?.signedIn === "boolean";
@@ -119,32 +194,10 @@ function writePortalSignedInHint(signedIn) {
   } catch {
   }
 }
-async function requestPortalSignInLink(email, redirect, fetchImpl) {
-  const res = await portalSend(
-    PORTAL_MAGIC_LINK_URL,
-    "POST",
-    { email, redirect },
-    fetchImpl
-  );
-  return { ok: res.ok };
-}
 async function signOutOfPortal(fetchImpl) {
   const res = await portalSend(PORTAL_SIGN_OUT_URL, "POST", {}, fetchImpl);
   return { ok: res.ok };
 }
-var PORTAL_RETURN_PATH = "/portal/return";
-function encodeReturnTarget(url) {
-  const bytes = new TextEncoder().encode(url);
-  let binary = "";
-  for (const b of bytes) binary += String.fromCharCode(b);
-  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-function currentPagePath() {
-  if (typeof window === "undefined") return "/";
-  const path = `${window.location.pathname || "/"}${window.location.search}${window.location.hash}`;
-  if (!apiOrigin) return path;
-  return `${PORTAL_RETURN_PATH}?to=${encodeReturnTarget(window.location.origin + path)}`;
-}
 var LOCALE = "en-AU";
 function parseInstant(iso) {
   if (!iso) return null;
@@ -1224,6 +1277,7 @@ export {
   FlowErrorSummary,
   focusField,
   FlowLoading,
+  createPortalClient,
   PatientOSApiError,
   patientos,
   persistClaimToken,
@@ -1250,18 +1304,14 @@ export {
   formatSlotTime,
   zoneAbbr,
   SlotPicker,
-  configurePortalApiOrigin,
-  portalApiUrl,
-  PORTAL_REQUEST_INIT,
+  portalFetchForClient,
   portalGet,
   portalSend,
   portalDelete,
   hasPortalIdentity,
   readPortalSignedInHint,
   writePortalSignedInHint,
-  requestPortalSignInLink,
   signOutOfPortal,
-  currentPagePath,
   formatPortalDate,
   formatPortalDateTime,
   formatPortalTime,

package/dist/{chunk-CRYD7EXD.js → chunk-N6IGS47W.js}

@@ -6,7 +6,7 @@ import {
   PortalAccountClient,
   PortalPanelClient,
   StoreClient
-} from "./chunk-EO64UB5F.js";
+} from "./chunk-UTCKIWE7.js";
 import {
   mountIslandsWith
 } from "./chunk-THMT43MV.js";