@patientos/website-kit 0.2.6 → 0.2.8

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-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
+};