@patientos/website-kit 0.2.6 → 0.2.8

package/dist/chunk-FZ4WKWIE.js

@@ -0,0 +1,310 @@
+// 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_APPLICATION_HANDOFF_PATH = "/portal/api/application-run-handoffs";
+var PORTAL_SESSION_EXCHANGE_PATH = "/portal/api/session-exchange";
+var PORTAL_RETURN_PATH = "/portal/return";
+var PORTAL_HANDOFF_FRAGMENT_PREFIX = "#patientos-handoff=";
+var BRIDGE_TIMEOUT_MS = 15e3;
+var BRIDGE_PROBE_TIMEOUT_MS = 8e3;
+var PORTAL_BEARER_STORAGE_PREFIX = "patientos.portal.bearer:";
+var parkedHandoffPayload = null;
+var pendingHandoffTokens = /* @__PURE__ */ new Map();
+var pendingHandoffExchanges = /* @__PURE__ */ new Map();
+var memoryBearers = /* @__PURE__ */ new Map();
+function onLocalhostDevPage() {
+  if (typeof window === "undefined") return false;
+  return window.location.protocol === "http:" && window.location.hostname === "localhost" && window.location.port !== "";
+}
+function localhostHandoffEnabled(apiOrigin) {
+  return apiOrigin !== "" && onLocalhostDevPage();
+}
+function bearerStorage() {
+  try {
+    return typeof window === "undefined" ? null : window.sessionStorage;
+  } catch {
+    return null;
+  }
+}
+function bearerStorageKey(apiOrigin) {
+  return `${PORTAL_BEARER_STORAGE_PREFIX}${apiOrigin}`;
+}
+function readBearer(apiOrigin) {
+  const memory = memoryBearers.get(apiOrigin);
+  if (memory) return memory;
+  try {
+    const stored = bearerStorage()?.getItem(bearerStorageKey(apiOrigin)) ?? null;
+    if (!stored || stored.length > 4096) {
+      clearBearer(apiOrigin);
+      return null;
+    }
+    memoryBearers.set(apiOrigin, stored);
+    return stored;
+  } catch {
+    return null;
+  }
+}
+function writeBearer(apiOrigin, token) {
+  memoryBearers.set(apiOrigin, token);
+  try {
+    bearerStorage()?.setItem(bearerStorageKey(apiOrigin), token);
+  } catch {
+  }
+}
+function clearBearer(apiOrigin) {
+  memoryBearers.delete(apiOrigin);
+  try {
+    bearerStorage()?.removeItem(bearerStorageKey(apiOrigin));
+  } catch {
+  }
+}
+function decodeBase64UrlJson(raw) {
+  const b64 = raw.replace(/-/g, "+").replace(/_/g, "/");
+  const binary = atob(b64.padEnd(Math.ceil(b64.length / 4) * 4, "="));
+  const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+  return JSON.parse(new TextDecoder().decode(bytes));
+}
+function consumePortalHandoffFragment() {
+  if (!onLocalhostDevPage()) return;
+  const raw = window.location.hash;
+  if (!raw.startsWith(PORTAL_HANDOFF_FRAGMENT_PREFIX)) return;
+  let payload = null;
+  try {
+    const decoded = decodeBase64UrlJson(raw.slice(PORTAL_HANDOFF_FRAGMENT_PREFIX.length));
+    const candidate = decoded;
+    if (typeof candidate?.token === "string" && candidate.token.length > 0 && candidate.token.length <= 512 && typeof candidate.returnHash === "string") {
+      payload = { token: candidate.token, returnHash: candidate.returnHash };
+    }
+  } catch {
+  }
+  const restoredHash = payload?.returnHash ? `#${payload.returnHash}` : "";
+  window.history.replaceState(
+    window.history.state,
+    "",
+    `${window.location.pathname}${window.location.search}${restoredHash}`
+  );
+  if (payload) parkedHandoffPayload = payload;
+}
+function adoptParkedHandoff(apiOrigin) {
+  const payload = parkedHandoffPayload;
+  if (!payload || !localhostHandoffEnabled(apiOrigin)) return;
+  parkedHandoffPayload = null;
+  clearBearer(apiOrigin);
+  pendingHandoffTokens.set(apiOrigin, payload.token);
+}
+async function exchangePortalHandoff(apiOrigin, fetchImpl) {
+  const pending = pendingHandoffExchanges.get(apiOrigin);
+  if (pending) return pending;
+  const oneTimeToken = pendingHandoffTokens.get(apiOrigin);
+  if (!oneTimeToken) return readBearer(apiOrigin);
+  pendingHandoffTokens.delete(apiOrigin);
+  const exchange = (async () => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), BRIDGE_PROBE_TIMEOUT_MS);
+    try {
+      const response = await fetchImpl(`${apiOrigin}${PORTAL_SESSION_EXCHANGE_PATH}`, {
+        ...PORTAL_REQUEST_INIT,
+        method: "POST",
+        headers: { accept: "application/json", "content-type": "application/json" },
+        body: JSON.stringify({ token: oneTimeToken }),
+        signal: controller.signal
+      });
+      const result = await readPortalResult(response);
+      const bearer = result.ok && typeof result.data?.token === "string" ? result.data.token : null;
+      if (!bearer) return null;
+      writeBearer(apiOrigin, bearer);
+      return bearer;
+    } catch {
+      pendingHandoffTokens.set(apiOrigin, oneTimeToken);
+      return null;
+    } finally {
+      clearTimeout(timer);
+    }
+  })();
+  pendingHandoffExchanges.set(apiOrigin, exchange);
+  try {
+    return await exchange;
+  } finally {
+    if (pendingHandoffExchanges.get(apiOrigin) === exchange) {
+      pendingHandoffExchanges.delete(apiOrigin);
+    }
+  }
+}
+var PORTAL_REQUEST_INIT = {
+  credentials: "include",
+  cache: "no-store"
+};
+function normalizePortalApiOrigin(raw) {
+  let url;
+  try {
+    url = new URL(raw.trim());
+  } catch {
+    return null;
+  }
+  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 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(/=+$/, "");
+}
+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(response) {
+  if (!response.ok) {
+    let error = null;
+    let body;
+    try {
+      const parsed = await response.json();
+      if (typeof parsed?.error === "string") error = parsed.error;
+      body = parsed;
+    } catch {
+    }
+    return { ok: false, status: response.status, error, body };
+  }
+  try {
+    return { ok: true, data: await response.json() };
+  } 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 handoffEnabled = localhostHandoffEnabled(apiOrigin);
+  consumePortalHandoffFragment();
+  adoptParkedHandoff(apiOrigin);
+  const url = (path) => apiOrigin && path.startsWith("/") ? apiOrigin + path : path;
+  const fetchWithSession = async (input, init) => {
+    let belongsToApiOrigin = false;
+    if (handoffEnabled) {
+      try {
+        belongsToApiOrigin = new URL(input, window.location.href).origin === apiOrigin;
+      } catch {
+      }
+    }
+    const bearer = belongsToApiOrigin ? await exchangePortalHandoff(apiOrigin, fetchImpl) : null;
+    if (!bearer) return fetchImpl(input, init);
+    const headers = new Headers(init?.headers);
+    headers.set("authorization", `Bearer ${bearer}`);
+    return fetchImpl(input, { ...init, headers });
+  };
+  async function request(path, init, timeoutMs = BRIDGE_TIMEOUT_MS) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetchWithSession(url(path), {
+        ...PORTAL_REQUEST_INIT,
+        ...init,
+        signal: controller.signal
+      });
+      const result = await readPortalResult(response);
+      if (handoffEnabled) {
+        const body = result.ok ? result.data : null;
+        if (path === "/portal/api/sign-out" && result.ok || !result.ok && result.status === 401 || body?.signedIn === false) {
+          clearBearer(apiOrigin);
+        }
+      }
+      return result;
+    } 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 = (targetUrl) => {
+    if (typeof window === "undefined") return "/";
+    let target = targetUrl ?? window.location.href;
+    try {
+      const parsed2 = new URL(target, window.location.href);
+      if (parsed2.origin !== window.location.origin) target = window.location.href;
+      else target = parsed2.href;
+    } catch {
+      target = window.location.href;
+    }
+    const parsed = new URL(target);
+    const path = `${parsed.pathname || "/"}${parsed.search}${parsed.hash}`;
+    if (!apiOrigin && !targetUrl) return path;
+    return `${PORTAL_RETURN_PATH}?to=${encodePortalReturnTarget(target)}`;
+  };
+  return {
+    available,
+    apiOrigin,
+    portalHref,
+    url,
+    fetch: fetchWithSession,
+    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;
+    },
+    async redeemApplicationRunHandoff(handoffId) {
+      if (!available) return null;
+      const result = await send(
+        `${PORTAL_APPLICATION_HANDOFF_PATH}/${encodeURIComponent(handoffId)}/redeem`,
+        "POST",
+        {}
+      );
+      return result.ok ? result.data : null;
+    },
+    returnPath,
+    get,
+    send,
+    delete: del
+  };
+}
+
+export {
+  normalizePortalApiOrigin,
+  encodePortalReturnTarget,
+  createPortalClient
+};

package/dist/{chunk-ZZFBTLR4.js → chunk-HTVKKLWI.js}

@@ -1,15 +1,24 @@
 import {
   BookingBlockClient,
-  CartClient,
   CertificateFunnelClient,
-  CheckoutClient,
   PortalAccountClient,
-  PortalPanelClient,
-  StoreClient
-} from "./chunk-7ZOQ6UKG.js";
+  PortalPanelClient
+} from "./chunk-4GKSSM5N.js";
 import {
   mountIslandsWith
 } from "./chunk-THMT43MV.js";
+import {
+  CartClient
+} from "./chunk-2CZFJOKK.js";
+import {
+  CartButtonClient
+} from "./chunk-ZNH6TSYP.js";
+import {
+  CheckoutClient
+} from "./chunk-S3ZQQOQT.js";
+import {
+  StoreClient
+} from "./chunk-UTAMB2SK.js";
 
 // src/islands-registry.tsx
 var ISLANDS = {
@@ -24,6 +33,12 @@ var ISLANDS = {
   "portal-account": PortalAccountClient,
   store: StoreClient,
   cart: CartClient,
+  // PAT-944 — the header cart. Admitted because it adds NO new reach: it reads the cart
+  // already in this browser (`cart-storage`) and, only once a shopper opens the drawer,
+  // posts those same stored lines to the `/api/store/quote` the cart island already
+  // calls. It makes no request on mount and renders no count on the server, so a header
+  // carrying it stays edge-cacheable.
+  "cart-button": CartButtonClient,
   checkout: CheckoutClient
 };
 function mountIslands(root, createRoot) {

package/dist/chunk-IOC6QLB7.js

@@ -0,0 +1,159 @@
+import {
+  formatMoney
+} from "./chunk-7BUDUYXN.js";
+import {
+  adjustCartQuantity,
+  cartToWireLines,
+  removeFromCart
+} from "./chunk-4NF7SSIX.js";
+
+// src/cart-lines.tsx
+import * as React from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function quoteSourceQuantities(quoteSourceCart) {
+  return new Map(
+    quoteSourceCart?.lines.filter((line) => line.kind === "retail").map((line) => [line.variantId, line.quantity]) ?? []
+  );
+}
+function stepperBaseline(sourceQuantities, line) {
+  return (sourceQuantities.get(line.variantId) ?? 0) > line.quantity ? line.quantity : void 0;
+}
+function CartProblemList({
+  problems
+}) {
+  if (problems.length === 0) return null;
+  return /* @__PURE__ */ jsx("ul", { className: "sk-cart__problems", role: "status", children: problems.map((p, i) => /* @__PURE__ */ jsx("li", { children: p.message }, `${p.code}-${p.variantId ?? i}`)) });
+}
+function UnsupportedCartLineList({
+  lines,
+  onMutate
+}) {
+  if (lines.length === 0) return null;
+  return /* @__PURE__ */ jsx("ul", { className: "sk-cart__lines", children: lines.map((line) => /* @__PURE__ */ jsxs("li", { className: "sk-cart__line", children: [
+    /* @__PURE__ */ jsx("span", { className: "sk-cart__line-title", children: line.kind === "fill" ? "Prescription item" : "Unavailable item" }),
+    /* @__PURE__ */ jsx("span", { className: "sk-cart__line-unit", children: "Not supported by retail checkout" }),
+    /* @__PURE__ */ jsxs("span", { className: "sk-cart__qty", children: [
+      "Quantity ",
+      line.quantity
+    ] }),
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        className: "sk-cart__remove",
+        onClick: () => void onMutate(removeFromCart(line.variantId, line.kind)),
+        children: "Remove"
+      }
+    )
+  ] }, `${line.kind}-${line.variantId}`)) });
+}
+function CartLineList({
+  lines,
+  sourceQuantities,
+  onMutate
+}) {
+  return /* @__PURE__ */ jsx("ul", { className: "sk-cart__lines", children: lines.map((line) => /* @__PURE__ */ jsxs("li", { className: "sk-cart__line", children: [
+    /* @__PURE__ */ jsx("a", { className: "sk-cart__line-title", href: `/store/${line.productHandle}`, children: line.title }),
+    /* @__PURE__ */ jsxs("span", { className: "sk-cart__line-unit", children: [
+      formatMoney(line.unitPrice),
+      " each"
+    ] }),
+    /* @__PURE__ */ jsxs("span", { className: "sk-cart__qty", children: [
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          "aria-label": `Decrease quantity of ${line.title}`,
+          onClick: () => void onMutate(
+            adjustCartQuantity(
+              "retail",
+              line.variantId,
+              -1,
+              stepperBaseline(sourceQuantities, line)
+            )
+          ),
+          children: "\u2212"
+        }
+      ),
+      /* @__PURE__ */ jsx("span", { "aria-live": "polite", children: line.quantity }),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          "aria-label": `Increase quantity of ${line.title}`,
+          onClick: () => void onMutate(
+            adjustCartQuantity(
+              "retail",
+              line.variantId,
+              1,
+              stepperBaseline(sourceQuantities, line)
+            )
+          ),
+          children: "+"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx("span", { className: "sk-cart__line-total", children: formatMoney(line.lineTotal) }),
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        className: "sk-cart__remove",
+        onClick: () => void onMutate(removeFromCart(line.variantId, "retail")),
+        children: "Remove"
+      }
+    )
+  ] }, line.variantId)) });
+}
+function CartTotals({ quote }) {
+  return /* @__PURE__ */ jsxs("dl", { className: "sk-cart__totals", children: [
+    /* @__PURE__ */ jsxs("div", { children: [
+      /* @__PURE__ */ jsx("dt", { children: "Subtotal" }),
+      /* @__PURE__ */ jsx("dd", { children: formatMoney(quote.subtotal) })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "sk-cart__gst-row", children: [
+      /* @__PURE__ */ jsx("dt", { children: "GST included" }),
+      /* @__PURE__ */ jsx("dd", { children: formatMoney(quote.taxTotal) })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "sk-cart__total-row", children: [
+      /* @__PURE__ */ jsx("dt", { children: "Total" }),
+      /* @__PURE__ */ jsx("dd", { children: formatMoney(quote.total) })
+    ] })
+  ] });
+}
+function useCartQuote(client, cart, enabled = true) {
+  const [state, setState] = React.useState({
+    quote: null,
+    quoteSourceCart: null,
+    failed: false
+  });
+  React.useEffect(() => {
+    if (!enabled || cart.lines.length === 0) {
+      setState({ quote: null, quoteSourceCart: null, failed: false });
+      return;
+    }
+    let alive = true;
+    setState({ quote: null, quoteSourceCart: null, failed: false });
+    void client.post("/api/store/quote", { lines: cartToWireLines(cart) }).then((result) => {
+      if (!alive) return;
+      if (!result.ok) {
+        setState({ quote: null, quoteSourceCart: null, failed: true });
+        return;
+      }
+      setState({ quote: result.data, quoteSourceCart: cart, failed: false });
+    });
+    return () => {
+      alive = false;
+    };
+  }, [cart, client, enabled]);
+  return state;
+}
+
+export {
+  quoteSourceQuantities,
+  CartProblemList,
+  UnsupportedCartLineList,
+  CartLineList,
+  CartTotals,
+  useCartQuote
+};