@patientos/website-kit 0.1.0

package/dist/chunk-G3U6EXJM.js

@@ -0,0 +1,1240 @@
+// src/portal-booking.client.tsx
+import * as React4 from "react";
+
+// src/portal-shared.client.tsx
+import * as React from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+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));
+}
+async function readPortalResult(res) {
+  if (!res.ok) {
+    let error = null;
+    let body;
+    try {
+      const parsed = await res.json();
+      if (typeof parsed?.error === "string") error = parsed.error;
+      body = parsed;
+    } catch {
+    }
+    return { ok: false, status: res.status, error, body };
+  }
+  try {
+    return { ok: true, data: await res.json() };
+  } catch {
+    return { ok: false, status: null, error: null };
+  }
+}
+async function portalGet(url, fetchImpl) {
+  try {
+    return await readPortalResult(await portalFetch(fetchImpl)(url, PORTAL_REQUEST_INIT));
+  } catch {
+    return { ok: false, status: null, error: null };
+  }
+}
+async function portalSend(url, method, body, fetchImpl) {
+  try {
+    const res = await portalFetch(fetchImpl)(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 };
+  }
+}
+async function portalDelete(url, fetchImpl) {
+  try {
+    const res = await portalFetch(fetchImpl)(url, { ...PORTAL_REQUEST_INIT, method: "DELETE" });
+    return await readPortalResult(res);
+  } catch {
+    return { ok: false, status: null, error: null };
+  }
+}
+function hasPortalIdentity(body) {
+  return typeof body?.signedIn === "boolean";
+}
+var SIGNED_IN_HINT_KEY = "patientos.portal.signedIn";
+function readPortalSignedInHint() {
+  try {
+    return globalThis.sessionStorage?.getItem(SIGNED_IN_HINT_KEY) === "1";
+  } catch {
+    return false;
+  }
+}
+function writePortalSignedInHint(signedIn) {
+  try {
+    const store = globalThis.sessionStorage;
+    if (!store) return;
+    if (signedIn) store.setItem(SIGNED_IN_HINT_KEY, "1");
+    else store.removeItem(SIGNED_IN_HINT_KEY);
+  } 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 };
+}
+function currentPagePath() {
+  if (typeof window === "undefined") return "/";
+  return window.location.pathname || "/";
+}
+var LOCALE = "en-AU";
+function parseInstant(iso) {
+  if (!iso) return null;
+  const d = new Date(iso);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+function formatPortalDate(iso, timeZone) {
+  const d = parseInstant(iso);
+  if (!d) return null;
+  const opts = { day: "numeric", month: "short", year: "numeric" };
+  try {
+    return new Intl.DateTimeFormat(LOCALE, { ...opts, timeZone: timeZone ?? void 0 }).format(d);
+  } catch {
+    return new Intl.DateTimeFormat(LOCALE, opts).format(d);
+  }
+}
+function formatPortalDateTime(iso, timeZone) {
+  const d = parseInstant(iso);
+  if (!d) return null;
+  const opts = {
+    weekday: "short",
+    day: "numeric",
+    month: "short",
+    year: "numeric",
+    hour: "numeric",
+    minute: "2-digit"
+  };
+  try {
+    return new Intl.DateTimeFormat(LOCALE, { ...opts, timeZone: timeZone ?? void 0 }).format(d);
+  } catch {
+    return new Intl.DateTimeFormat(LOCALE, opts).format(d);
+  }
+}
+function formatPortalTime(iso, timeZone) {
+  const d = parseInstant(iso);
+  if (!d) return null;
+  const opts = { hour: "numeric", minute: "2-digit" };
+  try {
+    return new Intl.DateTimeFormat(LOCALE, { ...opts, timeZone: timeZone ?? void 0 }).format(d);
+  } catch {
+    return new Intl.DateTimeFormat(LOCALE, opts).format(d);
+  }
+}
+function formatPortalMoney(total, currency) {
+  if (total === null || total === void 0 || total === "") return null;
+  const n = Number(total);
+  if (!Number.isFinite(n)) return String(total);
+  const code = (currency ?? "AUD").toUpperCase();
+  try {
+    return new Intl.NumberFormat(LOCALE, { style: "currency", currency: code }).format(n);
+  } catch {
+    return `${code} ${n.toFixed(2)}`;
+  }
+}
+function PortalSignInRamp({
+  idSuffix,
+  submit,
+  onResult,
+  intro,
+  submitLabel
+}) {
+  const [email, setEmail] = React.useState("");
+  const [busy, setBusy] = React.useState(false);
+  const inputId = `sk-portal-email-${idSuffix}`;
+  async function onSubmit(e) {
+    e.preventDefault();
+    if (!email || busy) return;
+    setBusy(true);
+    const { ok } = await submit(email);
+    setBusy(false);
+    onResult({ ok, email });
+  }
+  return /* @__PURE__ */ jsxs("form", { className: "sk-portal-ramp", onSubmit: (e) => void onSubmit(e), children: [
+    /* @__PURE__ */ jsx("p", { className: "sk-portal-ramp__intro", children: intro ?? "Enter your email and we'll send you a sign-in link." }),
+    /* @__PURE__ */ jsx("label", { className: "sk-portal-label", htmlFor: inputId, children: "Email" }),
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        id: inputId,
+        className: "sk-portal-input",
+        type: "email",
+        name: "email",
+        required: true,
+        autoComplete: "email",
+        value: email,
+        onChange: (e) => setEmail(e.target.value)
+      }
+    ),
+    /* @__PURE__ */ jsx("button", { className: "sk-portal-button", type: "submit", disabled: busy, children: busy ? "Sending\u2026" : submitLabel ?? "Email me a sign-in link" })
+  ] });
+}
+function PortalLinkSentNotice({ email }) {
+  return /* @__PURE__ */ jsxs("p", { className: "sk-portal-ramp__sent", role: "status", children: [
+    "If ",
+    email,
+    " is on file with us, a sign-in link is on its way. It expires in a few minutes."
+  ] });
+}
+
+// src/slot-picker.tsx
+import * as React3 from "react";
+
+// src/flow-shell.tsx
+import * as React2 from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var FlowRailContext = React2.createContext(null);
+function FlowShell({
+  eyebrow,
+  heading,
+  subheading,
+  stepKey,
+  stepNumber,
+  totalSteps,
+  onBack,
+  documentTitle,
+  footer,
+  children,
+  className
+}) {
+  const rail = React2.useContext(FlowRailContext);
+  const headingRef = React2.useRef(null);
+  const mounted = React2.useRef(false);
+  React2.useEffect(() => {
+    if (!mounted.current) {
+      mounted.current = true;
+      return;
+    }
+    headingRef.current?.focus();
+  }, [stepKey]);
+  React2.useEffect(() => {
+    if (documentTitle && typeof document !== "undefined") document.title = documentTitle;
+  }, [documentTitle]);
+  const [rootEl, setRootEl] = React2.useState(null);
+  useResolvedSurface(rootEl);
+  const place = Boolean(eyebrow) || Boolean(stepNumber && totalSteps);
+  return /* @__PURE__ */ jsxs2(
+    "div",
+    {
+      ref: setRootEl,
+      className: ["sk-flow", rail ? "sk-flow--railed" : null, className].filter(Boolean).join(" "),
+      "data-sk-step": stepKey,
+      children: [
+        /* @__PURE__ */ jsxs2("header", { className: "sk-flow__bar", children: [
+          onBack ? /* @__PURE__ */ jsxs2("button", { type: "button", className: "sk-flow__back", onClick: onBack, "data-sk-flow-back": "", children: [
+            /* @__PURE__ */ jsx2("span", { "aria-hidden": "true", children: "\u2190" }),
+            " Back"
+          ] }) : place ? (
+            // Only earns its 36px when there IS something on the right to push over.
+            /* @__PURE__ */ jsx2("span", { className: "sk-flow__back-spacer", "aria-hidden": "true" })
+          ) : null,
+          place ? /* @__PURE__ */ jsxs2("div", { className: "sk-flow__place", children: [
+            eyebrow && /* @__PURE__ */ jsx2("p", { className: "sk-flow__eyebrow", children: eyebrow }),
+            stepNumber && totalSteps ? /* @__PURE__ */ jsx2(Progress, { current: stepNumber, total: totalSteps }) : null
+          ] }) : null
+        ] }),
+        /* @__PURE__ */ jsxs2("main", { className: "sk-flow__body", children: [
+          (heading || subheading) && /* @__PURE__ */ jsxs2("div", { className: "sk-flow__head", children: [
+            heading && // tabIndex -1 makes a non-interactive heading programmatically focusable.
+            /* @__PURE__ */ jsx2("h2", { ref: headingRef, tabIndex: -1, className: "sk-flow__heading", children: heading }),
+            subheading && /* @__PURE__ */ jsx2("div", { className: "sk-flow__sub", children: subheading })
+          ] }),
+          /* @__PURE__ */ jsx2("p", { className: "sk-flow__status", role: "status", "aria-live": "polite", children: eyebrow ?? "" }),
+          children
+        ] }),
+        footer && /* @__PURE__ */ jsx2("footer", { className: "sk-flow__footer", children: footer }),
+        rail ? (
+          // Named, or a screen reader announces a bare "complementary" landmark and the
+          // patient has to enter it to find out whether it is worth reading.
+          /* @__PURE__ */ jsx2("aside", { className: "sk-flow__rail", "aria-label": "About this clinic", children: rail })
+        ) : null
+      ]
+    }
+  );
+}
+function useResolvedSurface(el) {
+  React2.useEffect(() => {
+    if (!el || typeof window === "undefined") return;
+    const apply = () => {
+      const ink = window.getComputedStyle(el).color;
+      if (ink) el.style.setProperty("--sk-flow-ink", ink);
+      el.style.setProperty("--sk-flow-canvas", opaqueBackdrop(el));
+    };
+    apply();
+    const mq = window.matchMedia?.("(prefers-color-scheme: dark)");
+    mq?.addEventListener?.("change", apply);
+    return () => mq?.removeEventListener?.("change", apply);
+  }, [el]);
+}
+function opaqueBackdrop(el, read = (e) => window.getComputedStyle(e).backgroundColor) {
+  for (let node = el; node; node = node.parentElement) {
+    const bg = read(node);
+    if (bg && alphaOf(bg) === 1) return bg;
+  }
+  return "white";
+}
+function alphaOf(bg) {
+  if (bg === "transparent") return 0;
+  const inner = /^rgba?\(([^)]*)\)$/.exec(bg)?.[1];
+  if (inner === void 0) return 1;
+  const parts = inner.split(/[,/]/).map((s) => s.trim());
+  if (parts.length < 4) return 1;
+  const raw = parts[3];
+  const n = raw.endsWith("%") ? Number.parseFloat(raw) / 100 : Number.parseFloat(raw);
+  return Number.isFinite(n) ? n : 1;
+}
+function Progress({ current, total }) {
+  return /* @__PURE__ */ jsx2(
+    "div",
+    {
+      className: "sk-flow__progress",
+      role: "progressbar",
+      "aria-label": "Progress",
+      "aria-valuemin": 1,
+      "aria-valuemax": total,
+      "aria-valuenow": current,
+      "aria-valuetext": `Step ${current} of ${total}`,
+      children: Array.from({ length: total }, (_, i) => /* @__PURE__ */ jsx2(
+        "span",
+        {
+          "aria-hidden": "true",
+          className: [
+            "sk-flow__dot",
+            i + 1 === current ? "sk-flow__dot--current" : "",
+            i + 1 < current ? "sk-flow__dot--done" : ""
+          ].filter(Boolean).join(" ")
+        },
+        i
+      ))
+    }
+  );
+}
+function FlowButton({
+  variant = "primary",
+  busy,
+  children,
+  className,
+  ...rest
+}) {
+  return /* @__PURE__ */ jsx2(
+    "button",
+    {
+      ...rest,
+      className: ["sk-flow__btn", `sk-flow__btn--${variant}`, className].filter(Boolean).join(" "),
+      "aria-busy": busy || void 0,
+      disabled: rest.disabled || busy,
+      children
+    }
+  );
+}
+var SummarisedErrorsContext = React2.createContext(false);
+function SummarisedFieldErrors({
+  children
+}) {
+  return /* @__PURE__ */ jsx2(SummarisedErrorsContext.Provider, { value: true, children });
+}
+function FlowError({
+  children,
+  id
+}) {
+  const summarised = React2.useContext(SummarisedErrorsContext);
+  if (!children) return null;
+  return /* @__PURE__ */ jsx2("p", { className: "sk-flow__error", id, role: summarised ? void 0 : "alert", children });
+}
+function FlowFieldError({
+  id,
+  children
+}) {
+  if (!children) return null;
+  return /* @__PURE__ */ jsx2("p", { className: "sk-flow__error", id, children });
+}
+function describedBy(...ids) {
+  return ids.filter(Boolean).join(" ") || void 0;
+}
+function invalidFields(fields, errors) {
+  return fields.filter((f) => Boolean(errors[f.key]));
+}
+function FlowErrorSummary({
+  fields
+}) {
+  if (fields.length === 0) return null;
+  const names = fields.map((f) => f.label);
+  const list = names.length === 1 ? names[0] : `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
+  return /* @__PURE__ */ jsx2("p", { className: "sk-flow__error", role: "alert", children: fields.length === 1 ? `Please check one field: ${list}.` : `Please check ${fields.length} fields: ${list}.` });
+}
+function focusField(id) {
+  if (typeof document === "undefined") return false;
+  const el = document.getElementById(id);
+  if (!el || typeof el.focus !== "function") return false;
+  el.focus();
+  return true;
+}
+function FlowLoading({ message = "One moment\u2026" }) {
+  return /* @__PURE__ */ jsx2("p", { className: "sk-flow__loading", role: "status", "aria-live": "polite", children: message });
+}
+
+// src/public-client.ts
+import {
+  createPatientOSClient,
+  PatientOSApiError
+} from "@patientos/public-sdk";
+var CLAIM_STORAGE_KEY = "pos:claim-token";
+function session() {
+  try {
+    return typeof window === "undefined" ? null : window.sessionStorage;
+  } catch {
+    return null;
+  }
+}
+function readClaim() {
+  try {
+    return session()?.getItem(CLAIM_STORAGE_KEY) ?? null;
+  } catch {
+    return null;
+  }
+}
+function writeClaim(token) {
+  try {
+    const store = session();
+    if (!store) return;
+    if (token) store.setItem(CLAIM_STORAGE_KEY, token);
+    else store.removeItem(CLAIM_STORAGE_KEY);
+  } catch {
+  }
+}
+var client = null;
+var clientKey = "";
+var REQUEST_TIMEOUT_MS = 3e4;
+function boundedFetch(input, init) {
+  const controller = new AbortController();
+  const upstreamSignal = init?.signal;
+  const abortFromUpstream = () => controller.abort();
+  if (upstreamSignal?.aborted) controller.abort();
+  else upstreamSignal?.addEventListener("abort", abortFromUpstream, { once: true });
+  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  return globalThis.fetch(input, { ...init, signal: controller.signal }).finally(() => {
+    clearTimeout(timer);
+    upstreamSignal?.removeEventListener("abort", abortFromUpstream);
+  });
+}
+function patientos(config) {
+  const key = `${config.publishableKey}|${config.apiBase}`;
+  if (!client || clientKey !== key) {
+    client = createPatientOSClient({
+      baseUrl: config.apiBase,
+      publishableKey: config.publishableKey,
+      claimToken: readClaim(),
+      fetch: boundedFetch
+    });
+    clientKey = key;
+  }
+  return client;
+}
+function persistClaimToken(c) {
+  writeClaim(c.getClaimToken());
+}
+function adoptClaimToken(c, token) {
+  c.setClaimToken(token);
+  writeClaim(token);
+}
+function resetSession() {
+  writeClaim(null);
+  client = null;
+  clientKey = "";
+}
+var flowKey = (requestId) => `pos:flow:${requestId}`;
+function saveFlowRecord(requestId, record) {
+  try {
+    session()?.setItem(flowKey(requestId), JSON.stringify(record));
+  } catch {
+  }
+}
+function loadFlowRecord(requestId) {
+  try {
+    const raw = session()?.getItem(flowKey(requestId));
+    return raw ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+function once(subscribe) {
+  return new Promise((resolve) => {
+    const unsubscribe = subscribe((rows) => {
+      unsubscribe();
+      resolve(rows);
+    });
+  });
+}
+async function findServiceByKey(c, key) {
+  const services = await c.listServices();
+  return services.find((s) => s.key === key) ?? null;
+}
+function pickDeliveryOption(options, serviceId) {
+  const mine = options.filter((o) => o.serviceId === serviceId);
+  if (mine.length === 0) return null;
+  return mine.find((o) => o.isDefault) ?? [...mine].sort((a, b) => a.sortOrder - b.sortOrder)[0];
+}
+async function findDeliveryOption(c, serviceId) {
+  return pickDeliveryOption(await once(c.subscribeDeliveryOptions), serviceId);
+}
+function effectiveFee(svc, option) {
+  return { amount: option?.feeOverride ?? svc.feeAmount, requiresPayment: svc.requiresPayment };
+}
+function flowIsFree(flow) {
+  if (!flow) return null;
+  if (typeof flow.requiresPayment === "boolean") return !flow.requiresPayment;
+  return flow.feeAmount == null || flow.feeAmount === "";
+}
+function formatFee(amount) {
+  if (amount == null || amount === "") return "";
+  const n = Number(amount);
+  if (Number.isNaN(n)) return "";
+  return Number.isInteger(n) ? `$${n}` : `$${n.toFixed(2)}`;
+}
+function feeNote(fee) {
+  if (!fee) return "";
+  if (!fee.requiresPayment || !fee.amount) return "Bulk billed \u2014 no cost to you";
+  const text = formatFee(fee.amount);
+  return text ? `${text} \u2014 held on your card, charged only if what you asked for is issued` : "";
+}
+function feeRowNote(fee) {
+  if (!fee) return "";
+  if (!fee.requiresPayment || !fee.amount) return "Bulk billed \u2014 no cost to you";
+  return formatFee(fee.amount);
+}
+function gateToExit(gate) {
+  if (!gate) return null;
+  if (gate.verdict === "escalate") return { kind: "escalate", message: gate.message };
+  return { kind: "block", ruleId: gate.ruleId, message: gate.message };
+}
+function errorMessage(err, fallback) {
+  if (err instanceof PatientOSApiError && (err.code === "missing_claim" || err.code === "invalid_claim" || err.code === "claim_mismatch")) {
+    return fallback;
+  }
+  if (isLocalMissingClaim(err)) return fallback;
+  if (err instanceof PatientOSApiError) return err.message || fallback;
+  if (err instanceof Error && err.message) return err.message;
+  return fallback;
+}
+function errorCode(err) {
+  return err instanceof PatientOSApiError ? err.code : null;
+}
+function isSessionExpired(err) {
+  const code = errorCode(err);
+  return code === "missing_claim" || code === "invalid_claim" || isLocalMissingClaim(err);
+}
+function isLocalMissingClaim(err) {
+  return err instanceof Error && err.message.startsWith("No active session \u2014");
+}
+function isClaimRejected(err) {
+  return isSessionExpired(err) || errorCode(err) === "claim_mismatch";
+}
+function observeSessionExpiry(c, onExpired) {
+  return new Proxy(c, {
+    get(target, property, receiver) {
+      const value = Reflect.get(target, property, receiver);
+      if (typeof value !== "function") return value;
+      return (...args) => {
+        try {
+          const result = value.apply(target, args);
+          if (result && typeof result.then === "function") {
+            return Promise.resolve(result).catch((err) => {
+              if (isClaimRejected(err)) onExpired();
+              throw err;
+            });
+          }
+          return result;
+        } catch (err) {
+          if (isClaimRejected(err)) onExpired();
+          throw err;
+        }
+      };
+    }
+  });
+}
+
+// src/slot-picker.tsx
+import { Fragment, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var SLOT_TAKEN_CODES = ["slot_taken", "slot_unavailable", "slot_full", "hold_conflict"];
+function isSlotTakenError(err) {
+  const code = errorCode(err);
+  return code !== null && SLOT_TAKEN_CODES.includes(code);
+}
+function groupByTime(slots) {
+  const byStart = /* @__PURE__ */ new Map();
+  for (const s of slots) {
+    const existing = byStart.get(s.start);
+    if (existing) existing.count += 1;
+    else byStart.set(s.start, { start: s.start, practitionerId: s.practitionerId, count: 1 });
+  }
+  return [...byStart.values()].sort((a, b) => a.start.localeCompare(b.start));
+}
+function dayKeyOf(iso, tz) {
+  return new Intl.DateTimeFormat("en-CA", {
+    timeZone: tz,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).format(new Date(iso));
+}
+function formatSlotTime(iso, tz) {
+  return new Intl.DateTimeFormat("en-AU", {
+    timeZone: tz,
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  }).format(new Date(iso));
+}
+function zoneAbbr(iso, tz) {
+  const abbr = new Intl.DateTimeFormat("en-AU", { timeZone: tz, timeZoneName: "short" }).formatToParts(new Date(iso)).find((p) => p.type === "timeZoneName")?.value;
+  return abbr && !/^(GMT|UTC)/.test(abbr) ? abbr : null;
+}
+function zoneLabel(iso, tz) {
+  const city = (tz.split("/").pop() ?? tz).replace(/_/g, " ");
+  const abbr = zoneAbbr(iso, tz);
+  return abbr ? `${city} time (${abbr})` : `${city} time`;
+}
+function groupByDay(slots, tz) {
+  const byDay = /* @__PURE__ */ new Map();
+  for (const slot of slots) {
+    const key = dayKeyOf(slot.start, tz);
+    const existing = byDay.get(key);
+    if (existing) {
+      existing.slots.push(slot);
+      continue;
+    }
+    byDay.set(key, {
+      key,
+      tabLabel: new Intl.DateTimeFormat("en-AU", {
+        timeZone: tz,
+        weekday: "short",
+        day: "numeric"
+      }).format(new Date(slot.start)),
+      heading: new Intl.DateTimeFormat("en-AU", {
+        timeZone: tz,
+        weekday: "long",
+        day: "numeric",
+        month: "long"
+      }).format(new Date(slot.start)),
+      zone: zoneLabel(slot.start, tz),
+      slots: [slot]
+    });
+  }
+  return [...byDay.values()].sort((a, b) => a.key.localeCompare(b.key));
+}
+function heldStarts(holds, now = Date.now()) {
+  const out = /* @__PURE__ */ new Set();
+  for (const h of holds) {
+    if (Date.parse(h.expiresAt) <= now) continue;
+    out.add(h.slotStart);
+  }
+  return out;
+}
+function SlotBoard({
+  slots,
+  tz,
+  held,
+  selected,
+  onSelect,
+  mode,
+  className
+}) {
+  const [dayKey, setDayKey] = React3.useState(null);
+  const days = React3.useMemo(() => groupByDay(slots, tz), [slots, tz]);
+  const activeDay = days.find((d) => d.key === dayKey) ?? days[0] ?? null;
+  if (!activeDay) return /* @__PURE__ */ jsx3(Fragment, {});
+  return /* @__PURE__ */ jsxs3("div", { className: ["sk-slots", className].filter(Boolean).join(" "), "data-sk-slot-mode": mode, children: [
+    /* @__PURE__ */ jsx3("div", { className: "sk-slots__days", role: "group", "aria-label": "Choose a day", children: days.map((day) => {
+      const isActive = day.key === activeDay.key;
+      return /* @__PURE__ */ jsx3(
+        "button",
+        {
+          type: "button",
+          className: ["sk-slots__day", isActive ? "sk-slots__day--active" : ""].filter(Boolean).join(" "),
+          "aria-pressed": isActive,
+          onClick: () => {
+            setDayKey(day.key);
+            onSelect(null);
+          },
+          children: day.tabLabel
+        },
+        day.key
+      );
+    }) }),
+    /* @__PURE__ */ jsxs3("p", { className: "sk-slots__heading", children: [
+      activeDay.heading,
+      " ",
+      /* @__PURE__ */ jsxs3("span", { className: "sk-slots__heading-tz", children: [
+        "\xB7 ",
+        activeDay.zone
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx3(
+      "div",
+      {
+        className: "sk-slots__grid",
+        role: "group",
+        "aria-label": `Times on ${activeDay.heading}, ${activeDay.zone}`,
+        children: activeDay.slots.map((slot) => {
+          const isSelected = selected?.start === slot.start;
+          const isHeld = (held?.has(slot.start) ?? false) && slot.count === 1;
+          return /* @__PURE__ */ jsxs3(
+            "button",
+            {
+              type: "button",
+              className: [
+                "sk-slots__time",
+                isSelected ? "sk-slots__time--selected" : "",
+                isHeld ? "sk-slots__time--held" : ""
+              ].filter(Boolean).join(" "),
+              "aria-pressed": isSelected,
+              onClick: () => onSelect(slot),
+              children: [
+                /* @__PURE__ */ jsx3("span", { className: "sk-slots__time-label", children: formatSlotTime(slot.start, tz) }),
+                isHeld && /* @__PURE__ */ jsx3("span", { className: "sk-slots__time-note", children: "Being booked" }),
+                !isHeld && slot.count === 1 && /* @__PURE__ */ jsx3("span", { className: "sk-slots__time-note", children: "1 left" })
+              ]
+            },
+            slot.start
+          );
+        })
+      }
+    )
+  ] });
+}
+function SlotPicker({
+  client: client2,
+  appointmentTypeId,
+  mode,
+  onConfirm,
+  confirmLabel
+}) {
+  const [slots, setSlots] = React3.useState(null);
+  const [tz, setTz] = React3.useState("Australia/Sydney");
+  const [held, setHeld] = React3.useState(() => /* @__PURE__ */ new Set());
+  const [loadError, setLoadError] = React3.useState(null);
+  const [bookError, setBookError] = React3.useState(null);
+  const [selected, setSelected] = React3.useState(null);
+  const [booking, setBooking] = React3.useState(false);
+  const aliveRef = React3.useRef(true);
+  const load = React3.useCallback(async () => {
+    setLoadError(null);
+    try {
+      const availability = await client2.getAvailability({ appointmentTypeId });
+      if (!aliveRef.current) return;
+      const grouped = groupByTime(availability.slots);
+      setTz(availability.timezone);
+      setSlots(grouped);
+      setSelected((prev) => prev && grouped.some((s) => s.start === prev.start) ? prev : null);
+    } catch (e) {
+      if (!aliveRef.current) return;
+      setLoadError(errorMessage(e, "We could not load available times."));
+    }
+  }, [client2, appointmentTypeId]);
+  React3.useEffect(() => {
+    aliveRef.current = true;
+    void load();
+    return () => {
+      aliveRef.current = false;
+    };
+  }, [load]);
+  React3.useEffect(() => {
+    let stop = null;
+    try {
+      stop = client2.subscribeHolds((rows) => {
+        if (aliveRef.current) setHeld(heldStarts(rows));
+      });
+    } catch {
+    }
+    return () => stop?.();
+  }, [client2]);
+  async function handleConfirm() {
+    if (!selected || booking) return;
+    setBooking(true);
+    setBookError(null);
+    try {
+      await onConfirm(selected, tz);
+    } catch (e) {
+      if (isSlotTakenError(e)) {
+        setBookError("That time just filled up. Please choose another.");
+        setSelected(null);
+        await load();
+      } else {
+        setBookError(errorMessage(e, "We could not book that time. Please try again."));
+      }
+    } finally {
+      if (aliveRef.current) setBooking(false);
+    }
+  }
+  if (loadError) {
+    return /* @__PURE__ */ jsxs3("div", { className: "sk-slots", children: [
+      /* @__PURE__ */ jsx3(FlowError, { children: loadError }),
+      /* @__PURE__ */ jsx3(FlowButton, { type: "button", variant: "secondary", onClick: () => void load(), children: "Try again" })
+    ] });
+  }
+  if (slots === null) return /* @__PURE__ */ jsx3(FlowLoading, { message: "Loading available times\u2026" });
+  if (slots.length === 0) {
+    return /* @__PURE__ */ jsxs3("div", { className: "sk-slots sk-slots--empty", children: [
+      /* @__PURE__ */ jsx3("p", { className: "sk-slots__empty-title", children: "No times available right now" }),
+      /* @__PURE__ */ jsx3("p", { className: "sk-slots__empty-body", children: "Every time is either booked or outside the booking window." }),
+      /* @__PURE__ */ jsx3("div", { className: "sk-slots__empty-actions", children: /* @__PURE__ */ jsx3(FlowButton, { type: "button", variant: "secondary", onClick: () => void load(), children: "Check for times again" }) })
+    ] });
+  }
+  const timeText = selected ? formatSlotTime(selected.start, tz) : "";
+  const label = selected ? confirmLabel?.(timeText) ?? (mode === "request" ? `Book ${timeText}` : `Confirm ${timeText}`) : "Select a time";
+  return /* @__PURE__ */ jsxs3(Fragment, { children: [
+    /* @__PURE__ */ jsx3(SlotBoard, { slots, tz, held, selected, onSelect: setSelected, mode }),
+    /* @__PURE__ */ jsx3(FlowError, { children: bookError }),
+    /* @__PURE__ */ jsx3("div", { className: "sk-slots__confirm", children: /* @__PURE__ */ jsx3(
+      FlowButton,
+      {
+        type: "button",
+        variant: "primary",
+        busy: booking,
+        disabled: !selected,
+        onClick: () => void handleConfirm(),
+        children: booking ? "Booking\u2026" : label
+      }
+    ) })
+  ] });
+}
+
+// src/portal-booking.client.tsx
+import { Fragment as Fragment2, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function rescheduleContextTypeId(ctx) {
+  return ctx.appointmentTypeId ?? ctx.appointment?.appointmentType?.id ?? null;
+}
+var BOOKING_TYPES_URL = "/portal/api/booking/types";
+var AVAILABILITY_URL = "/portal/api/booking/availability";
+var HOLDS_URL = "/portal/api/booking/holds";
+var BOOK_URL = "/portal/api/booking/book";
+var APPOINTMENTS_URL = "/portal/api/appointments";
+var PORTAL_BOOKING_TYPES_URL = BOOKING_TYPES_URL;
+function portalRescheduleContextUrl(id) {
+  return `${APPOINTMENTS_URL}/${encodeURIComponent(id)}/reschedule-context`;
+}
+var SLOT_TAKEN_COPY = "That time just filled up. Please choose another.";
+var BOOK_FAILED_COPY = "We couldn't book that time just now. Please try again.";
+var AVAILABILITY_FAILED_COPY = "We could not load available times.";
+var RESCHEDULE_CUTOFF_COPY = "It's too close to your appointment to change it online. Please call the clinic and we'll sort it out.";
+var RESCHEDULE_FAILED_COPY = "We couldn't move that appointment just now. Please try again.";
+function readPortalBookingTypes(body) {
+  const b = body ?? {};
+  return { types: Array.isArray(b.types) ? b.types : [] };
+}
+function readPortalAvailability(body) {
+  const b = body ?? {};
+  const slots = Array.isArray(b.slots) ? b.slots.filter((s) => typeof s?.start === "string") : [];
+  const timezone = typeof b.timezone === "string" && b.timezone ? b.timezone : slots.find((s) => typeof s.timezone === "string" && s.timezone)?.timezone ?? "Australia/Sydney";
+  return { slots, timezone };
+}
+function portalTimeSlots(slots) {
+  const byStart = /* @__PURE__ */ new Map();
+  for (const s of slots) {
+    const existing = byStart.get(s.start);
+    if (existing) existing.count += 1;
+    else byStart.set(s.start, { start: s.start, practitionerId: s.practitionerId ?? "", count: 1 });
+  }
+  return [...byStart.values()].sort((a, b) => a.start.localeCompare(b.start));
+}
+function portalSlotAt(slots, start) {
+  if (!start) return null;
+  return slots.find((s) => s.start === start) ?? null;
+}
+function portalAvailabilityWindow(now = Date.now(), days = 14) {
+  return {
+    from: toYmd(now),
+    to: toYmd(now + days * 24 * 60 * 60 * 1e3)
+  };
+}
+function toYmd(ms) {
+  return new Date(ms).toISOString().slice(0, 10);
+}
+function portalAvailabilityUrl(typeId, window2 = portalAvailabilityWindow()) {
+  const q = new URLSearchParams({ typeId, from: window2.from, to: window2.to });
+  return `${AVAILABILITY_URL}?${q.toString()}`;
+}
+async function loadPortalBookingTypes(fetchImpl) {
+  const res = await portalGet(BOOKING_TYPES_URL, fetchImpl);
+  return res.ok ? { ok: true, data: readPortalBookingTypes(res.data) } : res;
+}
+async function loadPortalAvailability(typeId, fetchImpl, window2) {
+  const res = await portalGet(portalAvailabilityUrl(typeId, window2), fetchImpl);
+  return res.ok ? { ok: true, data: readPortalAvailability(res.data) } : res;
+}
+async function createPortalHold(input, fetchImpl) {
+  const res = await portalSend(
+    HOLDS_URL,
+    "POST",
+    {
+      // Wire names are the server's (PAT-789 canonical contract): `slotStart`, with
+      // `typeId` accepted as the documented alias of `appointmentTypeId`.
+      typeId: input.typeId,
+      slotStart: input.start,
+      practitionerId: input.practitionerId || void 0
+    },
+    fetchImpl
+  );
+  if (!res.ok || typeof res.data?.holdId !== "string" || res.data.holdId === "") return null;
+  return { holdId: res.data.holdId, expiresAt: res.data.expiresAt ?? null };
+}
+async function releasePortalHold(holdId, fetchImpl) {
+  const res = await portalDelete(
+    `${HOLDS_URL}/${encodeURIComponent(holdId)}`,
+    fetchImpl
+  );
+  return { ok: res.ok };
+}
+async function bookPortalAppointment(input, fetchImpl) {
+  const res = await portalSend(
+    BOOK_URL,
+    "POST",
+    {
+      typeId: input.typeId,
+      slotStart: input.start,
+      practitionerId: input.practitionerId || void 0,
+      holdId: input.holdId || void 0
+    },
+    fetchImpl
+  );
+  if (!res.ok) {
+    return {
+      ok: false,
+      slotTaken: res.status === 409,
+      error: res.status === 409 ? SLOT_TAKEN_COPY : BOOK_FAILED_COPY
+    };
+  }
+  return {
+    ok: true,
+    appointmentId: typeof res.data?.appointmentId === "string" ? res.data.appointmentId : null
+  };
+}
+async function loadPortalRescheduleContext(id, fetchImpl) {
+  const res = await portalGet(portalRescheduleContextUrl(id), fetchImpl);
+  if (!res.ok) {
+    const cutoff = res.status === 409;
+    return { ok: false, cutoff, error: cutoff ? RESCHEDULE_CUTOFF_COPY : RESCHEDULE_FAILED_COPY };
+  }
+  return { ok: true, context: res.data ?? {} };
+}
+async function reschedulePortalAppointmentAndReload(id, input, fetchImpl) {
+  const res = await portalSend(
+    `${APPOINTMENTS_URL}/${encodeURIComponent(id)}/reschedule`,
+    "POST",
+    { slotStart: input.start, practitionerId: input.practitionerId || void 0 },
+    fetchImpl
+  );
+  if (!res.ok) {
+    const cutoff = res.status === 409 && res.error === "cutoff";
+    const slotTaken = res.status === 409 && !cutoff;
+    return {
+      ok: false,
+      cutoff,
+      slotTaken,
+      error: cutoff ? RESCHEDULE_CUTOFF_COPY : slotTaken ? SLOT_TAKEN_COPY : RESCHEDULE_FAILED_COPY
+    };
+  }
+  const next = await portalGet(APPOINTMENTS_URL, fetchImpl);
+  const body = (next.ok ? next.data : null) ?? { upcoming: [], past: [] };
+  return {
+    ok: true,
+    data: {
+      upcoming: Array.isArray(body.upcoming) ? body.upcoming : [],
+      past: Array.isArray(body.past) ? body.past : []
+    }
+  };
+}
+function PortalSlotSummary({
+  start,
+  slot,
+  tz,
+  typeLabel
+}) {
+  const meta = [slot?.practitionerName, slot?.locationName].filter(Boolean).join(" \xB7 ");
+  return /* @__PURE__ */ jsxs4("dl", { className: "sk-portal-account__fields", children: [
+    typeLabel ? /* @__PURE__ */ jsxs4("div", { className: "sk-portal-account__field", children: [
+      /* @__PURE__ */ jsx4("dt", { className: "sk-portal-account__field-label", children: "Appointment" }),
+      /* @__PURE__ */ jsx4("dd", { className: "sk-portal-account__field-value", children: typeLabel })
+    ] }) : null,
+    /* @__PURE__ */ jsxs4("div", { className: "sk-portal-account__field", children: [
+      /* @__PURE__ */ jsx4("dt", { className: "sk-portal-account__field-label", children: "Time" }),
+      /* @__PURE__ */ jsx4("dd", { className: "sk-portal-account__field-value", children: formatPortalDateTime(start, tz) ?? formatSlotTime(start, tz) })
+    ] }),
+    meta ? /* @__PURE__ */ jsxs4("div", { className: "sk-portal-account__field", children: [
+      /* @__PURE__ */ jsx4("dt", { className: "sk-portal-account__field-label", children: "With" }),
+      /* @__PURE__ */ jsx4("dd", { className: "sk-portal-account__field-value", children: meta })
+    ] }) : null
+  ] });
+}
+function ErrorNote({ message }) {
+  if (!message) return null;
+  return /* @__PURE__ */ jsx4("p", { className: "sk-portal-error", role: "alert", children: message });
+}
+function NoTimes() {
+  return /* @__PURE__ */ jsxs4("div", { className: "sk-portal-account__note-card", children: [
+    /* @__PURE__ */ jsx4("p", { className: "sk-portal-account__confirm-title", children: "No times available right now" }),
+    /* @__PURE__ */ jsx4("p", { className: "sk-portal-account__empty", children: "Every time is either booked or outside the booking window. Please try again shortly, or call the clinic." })
+  ] });
+}
+function PortalRescheduleInline({
+  appointment,
+  fetchImpl,
+  onRescheduled,
+  onClose,
+  initialUi
+}) {
+  const [context, setContext] = React4.useState(
+    initialUi?.context ?? null
+  );
+  const [slots, setSlots] = React4.useState(
+    initialUi?.slots ?? null
+  );
+  const [tz, setTz] = React4.useState(initialUi?.tz ?? appointment.timezone ?? "Australia/Sydney");
+  const [selected, setSelected] = React4.useState(initialUi?.selected ?? null);
+  const [confirming, setConfirming] = React4.useState(initialUi?.confirming ?? false);
+  const [error, setError] = React4.useState(initialUi?.error ?? null);
+  const [blocked, setBlocked] = React4.useState(initialUi?.blocked ?? null);
+  const [busy, setBusy] = React4.useState(false);
+  const seeded = initialUi !== void 0;
+  const timeSlots = React4.useMemo(() => slots ? portalTimeSlots(slots) : [], [slots]);
+  React4.useEffect(() => {
+    if (seeded) return;
+    let live = true;
+    void (async () => {
+      const res = await loadPortalRescheduleContext(appointment.id, fetchImpl);
+      if (!live) return;
+      if (!res.ok) {
+        setBlocked(res.error);
+        setSlots([]);
+        return;
+      }
+      setContext(res.context);
+      const inline = res.context.slots;
+      if (Array.isArray(inline)) {
+        const read = readPortalAvailability({ slots: inline, timezone: res.context.timezone });
+        setSlots(read.slots);
+        setTz(read.timezone);
+        return;
+      }
+      const typeId = rescheduleContextTypeId(res.context);
+      if (!typeId) {
+        setSlots([]);
+        return;
+      }
+      const avail = await loadPortalAvailability(typeId, fetchImpl);
+      if (!live) return;
+      if (!avail.ok) {
+        setSlots([]);
+        setError(AVAILABILITY_FAILED_COPY);
+        return;
+      }
+      setSlots(avail.data.slots);
+      setTz(avail.data.timezone);
+    })();
+    return () => {
+      live = false;
+    };
+  }, [appointment.id, fetchImpl, seeded]);
+  async function refetch() {
+    const typeId = context ? rescheduleContextTypeId(context) : null;
+    if (!typeId) return;
+    const avail = await loadPortalAvailability(typeId, fetchImpl);
+    if (!avail.ok) return;
+    setSlots(avail.data.slots);
+    setTz(avail.data.timezone);
+  }
+  async function move() {
+    if (!selected || busy) return;
+    setBusy(true);
+    setError(null);
+    const res = await reschedulePortalAppointmentAndReload(
+      appointment.id,
+      { start: selected.start, practitionerId: selected.practitionerId },
+      fetchImpl
+    );
+    setBusy(false);
+    if (res.ok) {
+      onRescheduled(res.data);
+      return;
+    }
+    if (res.cutoff) {
+      setBlocked(res.error);
+      setConfirming(false);
+      return;
+    }
+    setError(res.error);
+    if (res.slotTaken) {
+      setSelected(null);
+      setConfirming(false);
+      await refetch();
+    }
+  }
+  const typeLabel = context?.typeLabel ?? appointment.title ?? null;
+  return /* @__PURE__ */ jsxs4("div", { className: "sk-portal-account__confirm sk-portal-account__confirm--neutral", children: [
+    /* @__PURE__ */ jsx4("p", { className: "sk-portal-account__confirm-title", children: "Move this appointment" }),
+    /* @__PURE__ */ jsxs4("p", { className: "sk-portal-account__item-meta", children: [
+      "Currently ",
+      formatPortalDateTime(appointment.start, appointment.timezone) ?? "unscheduled"
+    ] }),
+    blocked ? /* @__PURE__ */ jsx4("p", { className: "sk-portal-account__note", role: "note", children: blocked }) : slots === null ? /* @__PURE__ */ jsx4("p", { className: "sk-portal-account__placeholder", role: "status", children: "Loading available times\u2026" }) : confirming && selected ? /* @__PURE__ */ jsxs4(Fragment2, { children: [
+      /* @__PURE__ */ jsx4(
+        PortalSlotSummary,
+        {
+          start: selected.start,
+          slot: portalSlotAt(slots, selected.start),
+          tz,
+          typeLabel
+        }
+      ),
+      /* @__PURE__ */ jsx4(ErrorNote, { message: error }),
+      /* @__PURE__ */ jsxs4("div", { className: "sk-portal-account__confirm-actions", children: [
+        /* @__PURE__ */ jsx4(
+          "button",
+          {
+            type: "button",
+            className: "sk-portal-button",
+            onClick: () => void move(),
+            disabled: busy,
+            children: busy ? "Moving\u2026" : "Move appointment"
+          }
+        ),
+        /* @__PURE__ */ jsx4(
+          "button",
+          {
+            type: "button",
+            className: "sk-portal-button sk-portal-button--ghost",
+            onClick: () => setConfirming(false),
+            disabled: busy,
+            children: "Choose another time"
+          }
+        )
+      ] })
+    ] }) : timeSlots.length === 0 ? /* @__PURE__ */ jsx4(NoTimes, {}) : /* @__PURE__ */ jsxs4(Fragment2, { children: [
+      /* @__PURE__ */ jsx4(ErrorNote, { message: error }),
+      /* @__PURE__ */ jsx4(
+        SlotBoard,
+        {
+          slots: timeSlots,
+          tz,
+          selected,
+          onSelect: setSelected,
+          mode: "portal-reschedule"
+        }
+      ),
+      /* @__PURE__ */ jsx4("div", { className: "sk-portal-account__confirm-actions", children: /* @__PURE__ */ jsx4(
+        "button",
+        {
+          type: "button",
+          className: "sk-portal-button",
+          onClick: () => setConfirming(true),
+          disabled: !selected,
+          children: selected ? `Continue with ${formatSlotTime(selected.start, tz)}` : "Select a time"
+        }
+      ) })
+    ] }),
+    /* @__PURE__ */ jsx4("div", { className: "sk-portal-account__confirm-actions", children: /* @__PURE__ */ jsx4(
+      "button",
+      {
+        type: "button",
+        className: "sk-portal-button sk-portal-button--ghost",
+        onClick: onClose,
+        disabled: busy,
+        children: "Keep the current time"
+      }
+    ) })
+  ] });
+}
+
+export {
+  FlowRailContext,
+  FlowShell,
+  FlowButton,
+  SummarisedFieldErrors,
+  FlowError,
+  FlowFieldError,
+  describedBy,
+  invalidFields,
+  FlowErrorSummary,
+  focusField,
+  FlowLoading,
+  PatientOSApiError,
+  patientos,
+  persistClaimToken,
+  adoptClaimToken,
+  resetSession,
+  saveFlowRecord,
+  loadFlowRecord,
+  once,
+  findServiceByKey,
+  pickDeliveryOption,
+  findDeliveryOption,
+  effectiveFee,
+  flowIsFree,
+  formatFee,
+  feeNote,
+  feeRowNote,
+  gateToExit,
+  errorMessage,
+  errorCode,
+  isSessionExpired,
+  isClaimRejected,
+  observeSessionExpiry,
+  isSlotTakenError,
+  formatSlotTime,
+  zoneAbbr,
+  SlotPicker,
+  PORTAL_REQUEST_INIT,
+  portalGet,
+  portalSend,
+  portalDelete,
+  hasPortalIdentity,
+  readPortalSignedInHint,
+  writePortalSignedInHint,
+  requestPortalSignInLink,
+  signOutOfPortal,
+  currentPagePath,
+  formatPortalDate,
+  formatPortalDateTime,
+  formatPortalTime,
+  formatPortalMoney,
+  PortalSignInRamp,
+  PortalLinkSentNotice,
+  rescheduleContextTypeId,
+  PORTAL_BOOKING_TYPES_URL,
+  portalRescheduleContextUrl,
+  SLOT_TAKEN_COPY,
+  BOOK_FAILED_COPY,
+  AVAILABILITY_FAILED_COPY,
+  RESCHEDULE_CUTOFF_COPY,
+  RESCHEDULE_FAILED_COPY,
+  readPortalBookingTypes,
+  readPortalAvailability,
+  portalTimeSlots,
+  portalSlotAt,
+  portalAvailabilityWindow,
+  portalAvailabilityUrl,
+  loadPortalBookingTypes,
+  loadPortalAvailability,
+  createPortalHold,
+  releasePortalHold,
+  bookPortalAppointment,
+  loadPortalRescheduleContext,
+  reschedulePortalAppointmentAndReload,
+  PortalSlotSummary,
+  PortalRescheduleInline
+};