@patientos/website-kit 0.2.6 → 0.2.7

package/dist/chunk-4NF7SSIX.js

@@ -0,0 +1,367 @@
+// src/cart-storage.ts
+var CART_STORAGE_KEY = "patientos.cart.v1";
+var MAX_LINES = 50;
+var MAX_QUANTITY = 99;
+function emptyCart() {
+  return { v: 1, lines: [] };
+}
+var EMPTY_CART = Object.freeze({
+  v: 1,
+  lines: Object.freeze([])
+});
+function cartLineId(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  return normalized.length > 0 && normalized.length <= 128 ? normalized : null;
+}
+function legacyCartLineId(kind, variantId) {
+  const input = `${kind}\0${variantId}`;
+  let first = 2166136261;
+  let second = 2246822507;
+  for (let index = 0; index < input.length; index += 1) {
+    const code = input.charCodeAt(index);
+    first = Math.imul(first ^ code, 16777619);
+    second = Math.imul(second ^ code, 3266489909);
+  }
+  return `legacy-${(first >>> 0).toString(16).padStart(8, "0")}${(second >>> 0).toString(16).padStart(8, "0")}`;
+}
+function newCartLineId() {
+  return crypto.randomUUID();
+}
+function storage() {
+  try {
+    if (typeof window === "undefined" || !window.localStorage) return null;
+    return window.localStorage;
+  } catch {
+    return null;
+  }
+}
+function parseLine(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const line = raw;
+  const variantId = typeof line.variantId === "string" ? line.variantId.trim() : "";
+  if (!variantId) return null;
+  const kind = line.kind === "retail" ? "retail" : "fill";
+  const n = typeof line.quantity === "number" ? line.quantity : Number(line.quantity);
+  if (!Number.isFinite(n)) return null;
+  const quantity = Math.min(Math.max(Math.floor(n), 1), MAX_QUANTITY);
+  const lineId = cartLineId(line.lineId) ?? legacyCartLineId(kind, variantId);
+  return { lineId, kind, variantId, quantity };
+}
+function normalizeCartLines(entries) {
+  const lines = [];
+  const byIdentity = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const line = parseLine(entry);
+    if (!line) continue;
+    const identity = `${line.kind}\0${line.variantId}`;
+    const existing = byIdentity.get(identity);
+    if (existing) {
+      existing.quantity = Math.min(
+        existing.quantity + line.quantity,
+        MAX_QUANTITY
+      );
+      continue;
+    }
+    if (lines.length >= MAX_LINES) continue;
+    lines.push(line);
+    byIdentity.set(identity, line);
+  }
+  return lines;
+}
+function normalizeSettledAttemptTokens(entries) {
+  if (!Array.isArray(entries)) return [];
+  return Array.from(
+    new Set(
+      entries.filter(
+        (entry) => typeof entry === "string" && entry.length > 0 && entry.length <= 128
+      )
+    )
+  ).slice(-32);
+}
+function readCart() {
+  const store = storage();
+  if (!store) return emptyCart();
+  let raw;
+  try {
+    raw = store.getItem(CART_STORAGE_KEY);
+  } catch {
+    return emptyCart();
+  }
+  if (!raw) return emptyCart();
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return emptyCart();
+    const bag = parsed;
+    if (bag.v !== 1 || !Array.isArray(bag.lines)) return emptyCart();
+    const settledAttemptTokens = normalizeSettledAttemptTokens(
+      bag.settledAttemptTokens
+    );
+    return {
+      v: 1,
+      lines: normalizeCartLines(bag.lines),
+      ...settledAttemptTokens.length > 0 ? { settledAttemptTokens } : {}
+    };
+  } catch {
+    return emptyCart();
+  }
+}
+var CART_MUTATION_LOCK = "patientos-cart-mutation-v1";
+var CART_MUTATION_VALIDATION_TIMEOUT_MS = 5e3;
+function persistCart(cart) {
+  const settledAttemptTokens = normalizeSettledAttemptTokens(
+    cart.settledAttemptTokens
+  );
+  const normalised = {
+    v: 1,
+    lines: normalizeCartLines(cart.lines),
+    ...settledAttemptTokens.length > 0 ? { settledAttemptTokens } : {}
+  };
+  const store = storage();
+  if (!store)
+    return {
+      cart: readCart(),
+      persisted: false,
+      status: "cart_storage_unavailable"
+    };
+  try {
+    store.setItem(CART_STORAGE_KEY, JSON.stringify(normalised));
+  } catch {
+    return {
+      cart: readCart(),
+      persisted: false,
+      status: "cart_storage_unavailable"
+    };
+  }
+  notify(normalised);
+  return { cart: normalised, persisted: true, status: "updated" };
+}
+function unavailableMutation() {
+  return {
+    cart: readCart(),
+    persisted: false,
+    status: "cart_storage_unavailable"
+  };
+}
+async function mutateCart(mutation, beforePersist) {
+  const locks = typeof navigator === "undefined" ? void 0 : navigator.locks;
+  if (!storage() || !locks) return unavailableMutation();
+  try {
+    return await locks.request(CART_MUTATION_LOCK, async () => {
+      const latest = readCart();
+      const mutated = mutation(latest);
+      const proposed = {
+        ...mutated,
+        lines: normalizeCartLines(mutated.lines),
+        ...mutated.settledAttemptTokens === void 0 && latest.settledAttemptTokens ? { settledAttemptTokens: latest.settledAttemptTokens } : {}
+      };
+      if (beforePersist) {
+        const controller = new AbortController();
+        let timer;
+        const accepted = await Promise.race([
+          beforePersist(proposed, controller.signal).catch(() => false),
+          new Promise((resolve) => {
+            timer = setTimeout(() => {
+              controller.abort();
+              resolve(false);
+            }, CART_MUTATION_VALIDATION_TIMEOUT_MS);
+          })
+        ]);
+        if (timer) clearTimeout(timer);
+        if (!accepted) {
+          return {
+            cart: readCart(),
+            persisted: false,
+            status: "not_committed"
+          };
+        }
+      }
+      return persistCart(proposed);
+    });
+  } catch {
+    return unavailableMutation();
+  }
+}
+async function withCartLock(operation) {
+  const locks = typeof navigator === "undefined" ? void 0 : navigator.locks;
+  if (!storage() || !locks)
+    return { status: "cart_storage_unavailable", cart: readCart() };
+  try {
+    return await locks.request(CART_MUTATION_LOCK, async () => {
+      const latest = readCart();
+      const controller = new AbortController();
+      let timer;
+      const outcome = await Promise.race([
+        operation(latest, controller.signal).then((result) => ({
+          completed: true,
+          result
+        })),
+        new Promise((resolve) => {
+          timer = setTimeout(() => {
+            controller.abort();
+            resolve({ completed: false });
+          }, CART_MUTATION_VALIDATION_TIMEOUT_MS);
+        })
+      ]);
+      if (timer) clearTimeout(timer);
+      return outcome.completed ? { status: "completed", cart: latest, result: outcome.result } : { status: "not_completed", cart: latest };
+    });
+  } catch {
+    return { status: "not_completed", cart: readCart() };
+  }
+}
+async function writeCart(cart) {
+  return mutateCart(() => cart);
+}
+async function addToCart(variantId, quantity = 1) {
+  let status = "added";
+  const result = await mutateCart((cart) => {
+    const add = Math.min(Math.max(Math.floor(quantity), 1), MAX_QUANTITY);
+    const existing = cart.lines.find(
+      (line) => line.kind === "retail" && line.variantId === variantId
+    );
+    if (existing) {
+      if (existing.quantity >= MAX_QUANTITY) {
+        status = "quantity_limit";
+        return cart;
+      }
+      existing.quantity = Math.min(existing.quantity + add, MAX_QUANTITY);
+    } else {
+      if (cart.lines.length >= MAX_LINES) {
+        status = "line_limit";
+        return cart;
+      }
+      cart.lines.push({
+        lineId: newCartLineId(),
+        kind: "retail",
+        variantId,
+        quantity: add
+      });
+    }
+    return cart;
+  });
+  return {
+    cart: result.cart,
+    status: result.status === "cart_storage_unavailable" ? result.status : status
+  };
+}
+async function setCartQuantity(kind, variantId, quantity) {
+  const result = await mutateCart((cart) => {
+    const next = Math.floor(quantity);
+    return {
+      v: 1,
+      lines: next < 1 ? cart.lines.filter(
+        (line) => line.kind !== kind || line.variantId !== variantId
+      ) : cart.lines.map(
+        (line) => line.kind === kind && line.variantId === variantId ? { ...line, quantity: Math.min(next, MAX_QUANTITY) } : line
+      )
+    };
+  });
+  return result;
+}
+async function adjustCartQuantity(kind, variantId, delta, maximumBaseline) {
+  const result = await mutateCart((cart) => ({
+    v: 1,
+    lines: cart.lines.flatMap((line) => {
+      if (line.kind !== kind || line.variantId !== variantId) return [line];
+      const baseline = maximumBaseline === void 0 ? line.quantity : Math.min(line.quantity, Math.max(0, Math.floor(maximumBaseline)));
+      const quantity = Math.min(baseline + Math.floor(delta), MAX_QUANTITY);
+      return quantity > 0 ? [{ ...line, quantity }] : [];
+    })
+  }));
+  return result;
+}
+async function removeFromCart(variantId, kind) {
+  const result = await mutateCart((cart) => ({
+    v: 1,
+    lines: cart.lines.filter(
+      (line) => line.variantId !== variantId || kind && line.kind !== kind
+    )
+  }));
+  return result;
+}
+async function clearCart() {
+  return writeCart(emptyCart());
+}
+async function subtractPurchasedCartLines(purchasedLines, attemptToken) {
+  const purchased = new Map(
+    normalizeCartLines(
+      purchasedLines.filter(
+        (line) => Boolean(line) && typeof line === "object" && !Array.isArray(line) && cartLineId(line.lineId) !== null
+      )
+    ).map((line) => [line.lineId, line])
+  );
+  return mutateCart((cart) => {
+    if (attemptToken && cart.settledAttemptTokens?.includes(attemptToken))
+      return cart;
+    return {
+      v: 1,
+      lines: cart.lines.flatMap((line) => {
+        const purchasedLine = purchased.get(line.lineId);
+        const purchasedQuantity = purchasedLine?.kind === line.kind && purchasedLine.variantId === line.variantId ? purchasedLine.quantity : 0;
+        const quantity = line.quantity - purchasedQuantity;
+        return quantity > 0 ? [{ ...line, quantity }] : [];
+      }),
+      ...attemptToken ? {
+        settledAttemptTokens: [
+          ...cart.settledAttemptTokens ?? [],
+          attemptToken
+        ]
+      } : {}
+    };
+  });
+}
+function cartItemCount(cart = readCart()) {
+  return cart.lines.reduce((sum, l) => sum + l.quantity, 0);
+}
+function cartToWireLines(cart) {
+  return cart.lines.map((l) => ({
+    kind: l.kind,
+    variantId: l.variantId,
+    quantity: l.quantity
+  }));
+}
+var listeners = /* @__PURE__ */ new Set();
+function notify(cart) {
+  for (const fn of listeners) {
+    try {
+      fn(cart);
+    } catch {
+    }
+  }
+}
+function subscribeToCart(fn) {
+  listeners.add(fn);
+  const onStorage = (e) => {
+    if (e.key !== null && e.key !== CART_STORAGE_KEY) return;
+    fn(readCart());
+  };
+  if (typeof window !== "undefined")
+    window.addEventListener("storage", onStorage);
+  return () => {
+    listeners.delete(fn);
+    if (typeof window !== "undefined")
+      window.removeEventListener("storage", onStorage);
+  };
+}
+
+export {
+  CART_STORAGE_KEY,
+  emptyCart,
+  EMPTY_CART,
+  normalizeCartLines,
+  readCart,
+  mutateCart,
+  withCartLock,
+  writeCart,
+  addToCart,
+  setCartQuantity,
+  adjustCartQuantity,
+  removeFromCart,
+  clearCart,
+  subtractPurchasedCartLines,
+  cartItemCount,
+  cartToWireLines,
+  subscribeToCart
+};

package/dist/chunk-673YEXAI.js

@@ -0,0 +1,164 @@
+import {
+  normalizeCatalogResponse,
+  storeCatalogPath
+} from "./chunk-WQSJ46TP.js";
+import {
+  createStoreClient,
+  formatMoney
+} from "./chunk-7BUDUYXN.js";
+import {
+  addToCart,
+  cartItemCount,
+  readCart,
+  subscribeToCart
+} from "./chunk-4NF7SSIX.js";
+
+// src/store-block.client.tsx
+import * as React from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var SKELETON_CARDS = 6;
+function StoreClient({
+  categoryHandle,
+  productHandle,
+  storeApiOrigin,
+  title,
+  columns,
+  hideCartLink,
+  initialCatalog
+}) {
+  const client = React.useMemo(
+    () => createStoreClient({ apiOrigin: storeApiOrigin }),
+    [storeApiOrigin]
+  );
+  const [catalog, setCatalog] = React.useState(
+    initialCatalog ?? null
+  );
+  const [failed, setFailed] = React.useState(false);
+  const [count, setCount] = React.useState(0);
+  React.useEffect(() => {
+    setCount(cartItemCount(readCart()));
+    return subscribeToCart((cart) => setCount(cartItemCount(cart)));
+  }, []);
+  const hasSeed = initialCatalog != null;
+  React.useEffect(() => {
+    let alive = true;
+    void client.get(storeCatalogPath(productHandle)).then((result) => {
+      if (!alive) return;
+      if (!result.ok) {
+        setFailed((previous) => hasSeed ? previous : true);
+        return;
+      }
+      setCatalog(normalizeCatalogResponse(result.data));
+      setFailed(false);
+    });
+    return () => {
+      alive = false;
+    };
+  }, [client, productHandle, hasSeed]);
+  const products = React.useMemo(() => {
+    if (!catalog) return [];
+    if (productHandle || !categoryHandle) return catalog.products;
+    return catalog.products.filter(
+      (product) => product.categories.some((category) => category.handle === categoryHandle)
+    );
+  }, [catalog, categoryHandle, productHandle]);
+  if (failed && !catalog) {
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("h2", { className: "sk-store__heading", children: title ?? "Shop" }),
+      /* @__PURE__ */ jsx("p", { className: "sk-store__placeholder", role: "note", children: "Our shop is unavailable right now. Please contact the clinic to order." })
+    ] });
+  }
+  const gridStyle = columns ? { "--sk-store-columns": columns } : void 0;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs("div", { className: "sk-store__header", children: [
+      /* @__PURE__ */ jsx("h2", { className: "sk-store__heading", children: title ?? "Shop" }),
+      hideCartLink ? null : /* @__PURE__ */ jsxs("a", { className: "sk-store__cart-link", href: "/cart", children: [
+        "Cart",
+        count > 0 ? ` (${count})` : ""
+      ] })
+    ] }),
+    !catalog ? (
+      // A fixed-height skeleton grid, not a line of text: the text-then-grid swap is
+      // what made the shop jump on every load.
+      /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx("p", { className: "sk-store__placeholder sk-store__placeholder--sr", role: "status", children: "Loading the shop\u2026" }),
+        /* @__PURE__ */ jsx("ul", { className: "sk-store__grid", style: gridStyle, "aria-hidden": true, children: Array.from({ length: SKELETON_CARDS }, (_, index) => /* @__PURE__ */ jsxs("li", { className: "sk-store__card sk-store__card--skeleton", children: [
+          /* @__PURE__ */ jsx("span", { className: "sk-store__image sk-store__image--empty" }),
+          /* @__PURE__ */ jsx("span", { className: "sk-store__skeleton-line" }),
+          /* @__PURE__ */ jsx("span", { className: "sk-store__skeleton-line sk-store__skeleton-line--short" }),
+          /* @__PURE__ */ jsx("span", { className: "sk-store__skeleton-button" })
+        ] }, index)) })
+      ] })
+    ) : products.length === 0 ? /* @__PURE__ */ jsx("p", { className: "sk-store__placeholder", role: "status", children: "Nothing is available to order online just now." }) : /* @__PURE__ */ jsx("ul", { className: "sk-store__grid", style: gridStyle, children: products.map((product) => /* @__PURE__ */ jsx(StoreCard, { product }, product.id)) })
+  ] });
+}
+function StoreCard({ product }) {
+  const [variantId, setVariantId] = React.useState(
+    () => (product.variants.find((v) => v.inStock) ?? product.variants[0]).id
+  );
+  const [addFeedback, setAddFeedback] = React.useState(null);
+  const variant = product.variants.find((v) => v.id === variantId) ?? product.variants[0];
+  const image = product.thumbnailUrl ?? product.images[0]?.url ?? null;
+  async function onAdd() {
+    const result = await addToCart(variant.id, 1);
+    setAddFeedback(result.status);
+    window.setTimeout(() => setAddFeedback(null), 1600);
+  }
+  return /* @__PURE__ */ jsxs("li", { className: "sk-store__card", children: [
+    /* @__PURE__ */ jsxs("a", { className: "sk-store__card-link", href: `/store/${product.handle}`, children: [
+      image ? (
+        // Square by contract (CSS `aspect-ratio` AND the intrinsic ratio in the
+        // markup), lazy, and decoded off the main thread: the card must hold its
+        // height before the bytes arrive or the whole grid reflows around it.
+        /* @__PURE__ */ jsx(
+          "img",
+          {
+            className: "sk-store__image",
+            src: image,
+            alt: product.images[0]?.alt ?? "",
+            width: 600,
+            height: 600,
+            loading: "lazy",
+            decoding: "async"
+          }
+        )
+      ) : /* @__PURE__ */ jsx(
+        "span",
+        {
+          className: "sk-store__image sk-store__image--empty",
+          "aria-hidden": true
+        }
+      ),
+      /* @__PURE__ */ jsx("span", { className: "sk-store__title", children: product.title })
+    ] }),
+    /* @__PURE__ */ jsxs("span", { className: "sk-store__price", children: [
+      formatMoney(variant.price),
+      product.gstApplicable ? /* @__PURE__ */ jsx("span", { className: "sk-store__gst", children: " incl. GST" }) : null
+    ] }),
+    product.variants.length > 1 ? /* @__PURE__ */ jsxs("label", { className: "sk-store__variant", children: [
+      /* @__PURE__ */ jsx("span", { className: "sk-store__variant-label", children: "Option" }),
+      /* @__PURE__ */ jsx(
+        "select",
+        {
+          value: variantId,
+          onChange: (e) => setVariantId(e.target.value),
+          children: product.variants.map((v) => /* @__PURE__ */ jsx("option", { value: v.id, disabled: !v.inStock, children: (v.options.length ? v.options.join(" / ") : v.title) + (v.inStock ? "" : " \u2014 sold out") }, v.id))
+        }
+      )
+    ] }) : null,
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        className: "sk-store__add",
+        onClick: () => void onAdd(),
+        disabled: !variant.inStock,
+        children: !variant.inStock ? "Sold out" : addFeedback === "added" ? "Added \u2713" : addFeedback === "line_limit" ? "Cart full \u2014 50 products max" : addFeedback === "quantity_limit" ? "Maximum 99 in cart" : addFeedback === "cart_storage_unavailable" ? "This browser can\u2019t safely update the cart" : "Add to cart"
+      }
+    )
+  ] });
+}
+
+export {
+  StoreClient
+};

package/dist/chunk-7BUDUYXN.js

@@ -0,0 +1,80 @@
+import {
+  encodePortalReturnTarget,
+  normalizePortalApiOrigin
+} from "./chunk-FZ4WKWIE.js";
+
+// src/store-client.ts
+var STORE_REQUEST_INIT = {
+  credentials: "include",
+  cache: "no-store"
+};
+async function readResult(response) {
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    return response.ok ? { ok: false, status: null, error: null, message: null } : { ok: false, status: response.status, error: null, message: null };
+  }
+  if (response.ok) return { ok: true, data: body };
+  const failure = body;
+  return {
+    ok: false,
+    status: response.status,
+    error: typeof failure?.error === "string" ? failure.error : null,
+    message: typeof failure?.message === "string" ? failure.message : null
+  };
+}
+function createStoreClient(config = {}) {
+  const rawOrigin = config.apiOrigin?.trim() ?? "";
+  const normalizedOrigin = rawOrigin ? normalizePortalApiOrigin(rawOrigin) : "";
+  if (rawOrigin && !normalizedOrigin) {
+    console.error("[store] ignoring a malformed store API origin", rawOrigin);
+  }
+  const apiOrigin = normalizedOrigin ?? "";
+  const fetchImpl = config.fetchImpl ?? ((input, init) => globalThis.fetch(input, init));
+  const url = (path) => apiOrigin && path.startsWith("/") ? apiOrigin + path : path;
+  async function request(path, init) {
+    try {
+      return await readResult(
+        await fetchImpl(url(path), {
+          ...STORE_REQUEST_INIT,
+          ...init
+        })
+      );
+    } catch {
+      return { ok: false, status: null, error: null, message: null };
+    }
+  }
+  return {
+    apiOrigin,
+    url,
+    get: (path) => request(path, { headers: { accept: "application/json" } }),
+    post: (path, body, options) => request(path, {
+      signal: options?.signal,
+      method: "POST",
+      headers: {
+        accept: "application/json",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(body ?? {})
+    }),
+    signInHref(returnPath = "/checkout") {
+      if (typeof window === "undefined") return `${apiOrigin}/portal/sign-in`;
+      const target = new URL(returnPath, window.location.origin).toString();
+      const redirect = `/portal/return?to=${encodePortalReturnTarget(target)}`;
+      return `${apiOrigin}/portal/sign-in?redirect=${encodeURIComponent(redirect)}`;
+    }
+  };
+}
+
+// src/money.ts
+function formatMoney(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return value;
+  return `$${n.toFixed(2)}`;
+}
+
+export {
+  createStoreClient,
+  formatMoney
+};