@riverbankcms/sdk 0.88.0 → 0.90.0

package/dist/client/{carousel-Z2LKYSWA.mjs → carousel-CVRN6EPP.mjs}

@@ -1,7 +1,8 @@
-import { normalizeCarouselProps, CarouselNodeClient } from './chunk-O5JNI3E4.mjs';
+import { normalizeCarouselProps, CarouselNodeClient } from './chunk-7DH35FGA.mjs';
+import './chunk-6N7YRNYU.mjs';
 import { mountReactIsland } from './chunk-N7PBWBWQ.mjs';
-import { defineIslandPropsDecoder } from './chunk-DIRW2LNG.mjs';
-import './chunk-LI2C6M5O.mjs';
+import { defineIslandPropsDecoder } from './chunk-6DPXDOIL.mjs';
+import './chunk-25W2EQUN.mjs';
 import { jsx } from 'react/jsx-runtime';
 
 var decode = defineIslandPropsDecoder("carousel");

package/dist/client/{cart-ND5IK4A6.mjs → cart-IYIBA5CL.mjs}

@@ -1,15 +1,15 @@
-import { mountShopBlockIsland, CartClient } from './chunk-BL66UWGD.mjs';
-import './chunk-WCVK4MBJ.mjs';
-import './chunk-O5JNI3E4.mjs';
-import './chunk-ZFHRN6W2.mjs';
+import { mountShopBlockIsland, CartClient } from './chunk-MFPKS6QS.mjs';
+import './chunk-VFHZLZAC.mjs';
+import './chunk-7DH35FGA.mjs';
+import './chunk-6N7YRNYU.mjs';
 import './chunk-L4J5Y62O.mjs';
-import './chunk-X7GVFB7Y.mjs';
+import './chunk-NBFRJ5NB.mjs';
 import './chunk-3DCJ45Z2.mjs';
 import './chunk-WBQG7VJA.mjs';
-import './chunk-GOFO7HRH.mjs';
+import './chunk-WHZQDPBZ.mjs';
 import './chunk-N7PBWBWQ.mjs';
-import { defineIslandPropsDecoder } from './chunk-DIRW2LNG.mjs';
-import './chunk-LI2C6M5O.mjs';
+import { defineIslandPropsDecoder } from './chunk-6DPXDOIL.mjs';
+import './chunk-25W2EQUN.mjs';
 
 // src/rendering/islands/enhancers/cart.tsx
 var decode = defineIslandPropsDecoder("cart");

package/dist/client/{checkout-EYUSGAY7.mjs → checkout-O3BGM4GS.mjs}

@@ -1,15 +1,15 @@
-import { mountShopBlockIsland, CheckoutClient } from './chunk-BL66UWGD.mjs';
-import './chunk-WCVK4MBJ.mjs';
-import './chunk-O5JNI3E4.mjs';
-import './chunk-ZFHRN6W2.mjs';
+import { mountShopBlockIsland, CheckoutClient } from './chunk-MFPKS6QS.mjs';
+import './chunk-VFHZLZAC.mjs';
+import './chunk-7DH35FGA.mjs';
+import './chunk-6N7YRNYU.mjs';
 import './chunk-L4J5Y62O.mjs';
-import './chunk-X7GVFB7Y.mjs';
+import './chunk-NBFRJ5NB.mjs';
 import './chunk-3DCJ45Z2.mjs';
 import './chunk-WBQG7VJA.mjs';
-import './chunk-GOFO7HRH.mjs';
+import './chunk-WHZQDPBZ.mjs';
 import './chunk-N7PBWBWQ.mjs';
-import { defineIslandPropsDecoder } from './chunk-DIRW2LNG.mjs';
-import './chunk-LI2C6M5O.mjs';
+import { defineIslandPropsDecoder } from './chunk-6DPXDOIL.mjs';
+import './chunk-25W2EQUN.mjs';
 
 // src/rendering/islands/enhancers/checkout.tsx
 var decode = defineIslandPropsDecoder("checkout");

package/dist/client/chunk-4RTFGHZN.mjs

@@ -0,0 +1,433 @@
+"use client";
+import { formatPrice } from './chunk-NBFRJ5NB.mjs';
+import { assertNever } from './chunk-6DPXDOIL.mjs';
+import { resolveFlexibleBalanceInitialPaymentCents, resolveFlexibleBalanceDueAt, getBookingInstalmentDepositRefundability, splitAmountWithRemainderInFirst, addIntervalPreservingMonthAnchor, clampConfiguredAmount, getBookingInstalmentPlanIntervalCount, omitZeroAmountFutureRows } from './chunk-25W2EQUN.mjs';
+import { useReducer, useRef, useCallback, useEffect } from 'react';
+
+// ../blocks/src/system/runtime/shared/bookingPaymentOptionCopy.ts
+function buildUpfrontBookingPaymentOptionCopy(formattedTotal) {
+  return {
+    title: "Pay in full",
+    description: "Pay everything today and your booking is confirmed.",
+    ctaLabel: `Pay ${formattedTotal} now`
+  };
+}
+function buildDeferredManualBookingPaymentOptionCopy() {
+  return {
+    title: "Pay offline",
+    description: "Book now and pay the business later, outside the platform.",
+    helperText: "Nothing is due today.",
+    ctaLabel: "Book now"
+  };
+}
+function buildInstalmentBookingPaymentOptionCopy(input) {
+  return {
+    title: "Payment plan",
+    description: describeInstalmentPlanCopy(input),
+    helperText: "You can pay the rest early any time in your customer portal.",
+    ctaLabel: `Pay ${input.formattedDueToday} now`
+  };
+}
+function describeInstalmentPlanCopy(input) {
+  if (input.depositRefundability) {
+    return `Pay ${input.formattedDueToday} today, then continue with scheduled payments. Your deposit is ${formatDepositRefundabilityLabel(input.depositRefundability)}.`;
+  }
+  if (input.futurePaymentCount === 0) {
+    return `Pay ${input.formattedDueToday} today.`;
+  }
+  if (input.futurePaymentCount === 1) {
+    return `Pay ${input.formattedDueToday} today, then one more payment later.`;
+  }
+  const formattedFirstFuture = input.formattedFirstFuture ?? input.formattedDueToday;
+  return `Pay ${input.formattedDueToday} today, then ${input.futurePaymentCount} more ${input.cadenceLabel} payments from ${formattedFirstFuture}.`;
+}
+function buildFlexibleBalanceBookingPaymentOptionCopy(input) {
+  return {
+    title: "Deposit now, pay the rest later",
+    description: `Pay ${input.formattedDueToday} today, then pay the remaining balance any time before ${input.dueDateLabel}. Your deposit is ${formatDepositRefundabilityLabel(input.depositRefundability)}.`,
+    helperText: "You can return in your customer portal to pay the rest before the due date.",
+    ctaLabel: `Pay ${input.formattedDueToday} now`
+  };
+}
+function formatDepositRefundabilityLabel(depositRefundability) {
+  return depositRefundability === "non_refundable" ? "non-refundable" : "refundable";
+}
+
+// ../blocks/src/system/runtime/shared/bookingPaymentOptions.ts
+function buildBookingPaymentSelectionViewModel(input) {
+  const currency = input.priceCurrency ?? "USD";
+  const totalCents = Math.max(0, input.priceAmount ?? 0);
+  const allowedOptions = input.paymentTerms?.allowedOptions ?? [{ kind: "upfront" }];
+  const mode = allowedOptions.length > 1 ? "choice_required" : "single_option";
+  return {
+    mode,
+    sectionTitle: mode === "choice_required" ? "Choose how you'd like to pay" : "Payment",
+    serviceTitle: input.serviceTitle,
+    options: allowedOptions.map((option) => buildBookingPaymentOptionViewModel({
+      option,
+      totalCents,
+      currency,
+      bookingStartAt: input.bookingStartAt,
+      locale: input.locale
+    }))
+  };
+}
+function buildBookingPaymentOptionViewModel(input) {
+  switch (input.option.kind) {
+    case "upfront": {
+      const formattedTotal = formatPrice(input.totalCents, input.currency, input.locale);
+      const copy = buildUpfrontBookingPaymentOptionCopy(formattedTotal);
+      return {
+        kind: "upfront",
+        title: copy.title,
+        description: copy.description,
+        summaryRows: [
+          { label: "Total", value: formattedTotal },
+          { label: "Due today", value: formattedTotal }
+        ],
+        ctaLabel: copy.ctaLabel
+      };
+    }
+    case "deferred_manual": {
+      const formattedTotal = formatPrice(input.totalCents, input.currency, input.locale);
+      const copy = buildDeferredManualBookingPaymentOptionCopy();
+      return {
+        kind: "deferred_manual",
+        title: copy.title,
+        description: copy.description,
+        summaryRows: [
+          { label: "Total", value: formattedTotal },
+          { label: "Due today", value: formatPrice(0, input.currency, input.locale) }
+        ],
+        helperText: copy.helperText,
+        ctaLabel: copy.ctaLabel
+      };
+    }
+    case "instalment_plan": {
+      const schedulePreview = buildInstalmentSchedulePreview({
+        totalCents: input.totalCents,
+        option: input.option,
+        bookingStartAt: input.bookingStartAt
+      });
+      const dueToday = schedulePreview[0]?.amountCents ?? input.totalCents;
+      const futureRows = schedulePreview.slice(1);
+      const formattedTotal = formatPrice(input.totalCents, input.currency, input.locale);
+      const formattedDueToday = formatPrice(dueToday, input.currency, input.locale);
+      const depositRefundability = getBookingInstalmentDepositRefundability(input.option.plan);
+      const copy = buildInstalmentBookingPaymentOptionCopy({
+        formattedDueToday,
+        futurePaymentCount: futureRows.length,
+        formattedFirstFuture: futureRows[0] ? formatPrice(futureRows[0].amountCents, input.currency, input.locale) : null,
+        cadenceLabel: getPaymentCadenceLabel(input.option.plan),
+        depositRefundability
+      });
+      return {
+        kind: "instalment_plan",
+        title: copy.title,
+        description: copy.description,
+        summaryRows: [
+          { label: "Total", value: formattedTotal },
+          { label: "Due today", value: formattedDueToday },
+          ...depositRefundability ? [{
+            label: "Deposit policy",
+            value: depositRefundability === "non_refundable" ? "Non-refundable" : "Refundable"
+          }] : [],
+          ...futureRows.map((row) => ({
+            label: formatScheduleDate(row.dueAt, input.locale),
+            value: formatPrice(row.amountCents, input.currency, input.locale)
+          }))
+        ],
+        helperText: copy.helperText,
+        ctaLabel: copy.ctaLabel
+      };
+    }
+    case "flexible_balance": {
+      const dueToday = resolveFlexibleBalanceInitialPaymentCents({
+        totalAmountCents: input.totalCents,
+        config: input.option.config
+      });
+      const formattedTotal = formatPrice(input.totalCents, input.currency, input.locale);
+      const formattedDueToday = formatPrice(dueToday, input.currency, input.locale);
+      const dueAt = resolveFlexibleBalanceDueAt({
+        bookingStartAt: input.bookingStartAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        dueDateRule: input.option.config.dueDateRule
+      });
+      const copy = buildFlexibleBalanceBookingPaymentOptionCopy({
+        formattedDueToday,
+        dueDateLabel: formatScheduleDate(dueAt, input.locale),
+        depositRefundability: input.option.config.depositRefundability
+      });
+      return {
+        kind: "flexible_balance",
+        title: copy.title,
+        description: copy.description,
+        summaryRows: [
+          { label: "Total", value: formattedTotal },
+          { label: "Due today", value: formattedDueToday },
+          { label: "Balance due by", value: formatScheduleDate(dueAt, input.locale) },
+          {
+            label: "Deposit policy",
+            value: input.option.config.depositRefundability === "non_refundable" ? "Non-refundable" : "Refundable"
+          }
+        ],
+        helperText: copy.helperText,
+        ctaLabel: copy.ctaLabel
+      };
+    }
+    default:
+      return assertNever(input.option);
+  }
+}
+function buildInstalmentSchedulePreview(input) {
+  const startAt = input.bookingStartAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  switch (input.option.plan.kind) {
+    case "deposit_plus_one_remainder": {
+      const deposit = clampConfiguredAmount(input.option.plan.depositAmountCents, input.totalCents);
+      const remainder = Math.max(0, input.totalCents - deposit);
+      return compactSchedulePreview([
+        { dueAt: startAt, amountCents: deposit },
+        {
+          dueAt: addIntervalPreservingMonthAnchor(
+            startAt,
+            input.option.plan.remainderDueCount,
+            input.option.plan.intervalUnit
+          ),
+          amountCents: remainder
+        }
+      ]);
+    }
+    case "deposit_plus_scheduled_instalments": {
+      const plan = input.option.plan;
+      const deposit = clampConfiguredAmount(plan.depositAmountCents, input.totalCents);
+      const remaining = Math.max(0, input.totalCents - deposit);
+      const instalments = splitAmountWithRemainderInFirst(
+        remaining,
+        plan.instalmentCount
+      );
+      return compactSchedulePreview([
+        { dueAt: startAt, amountCents: deposit },
+        ...instalments.map((amountCents, index) => ({
+          dueAt: addIntervalPreservingMonthAnchor(
+            startAt,
+            plan.intervalCount * (index + 1),
+            plan.intervalUnit
+          ),
+          amountCents
+        }))
+      ]);
+    }
+    case "equal_scheduled_instalments": {
+      const plan = input.option.plan;
+      const instalments = splitAmountWithRemainderInFirst(
+        input.totalCents,
+        plan.instalmentCount
+      );
+      return compactSchedulePreview(instalments.map((amountCents, index) => ({
+        dueAt: index === 0 ? startAt : addIntervalPreservingMonthAnchor(
+          startAt,
+          plan.intervalCount * index,
+          plan.intervalUnit
+        ),
+        amountCents
+      })));
+    }
+    default:
+      return assertNever(input.option.plan);
+  }
+}
+function getPaymentCadenceLabel(plan) {
+  const intervalCount = getBookingInstalmentPlanIntervalCount(plan);
+  const unitLabel = intervalCount === 1 ? plan.intervalUnit : `${plan.intervalUnit}s`;
+  return intervalCount === 1 ? unitLabel : `every ${intervalCount} ${unitLabel}`;
+}
+function compactSchedulePreview(schedule) {
+  return omitZeroAmountFutureRows(schedule);
+}
+function formatScheduleDate(isoString, locale) {
+  const date = new Date(isoString);
+  if (!Number.isFinite(date.getTime())) {
+    return isoString;
+  }
+  return new Intl.DateTimeFormat(locale, { dateStyle: "medium" }).format(date);
+}
+
+// ../blocks/src/system/runtime/hooks/usePolling.state.ts
+function createInitialPollingState() {
+  return {
+    tag: "idle",
+    result: null,
+    error: null
+  };
+}
+function pollingReducer(state, action) {
+  switch (action.type) {
+    case "polling-went-idle":
+      return createInitialPollingState();
+    case "polling-reset":
+      return {
+        tag: "polling",
+        result: null,
+        error: null
+      };
+    case "polling-progressed":
+      return {
+        tag: "polling",
+        result: action.result,
+        error: null
+      };
+    case "polling-completed":
+      return {
+        tag: "completed",
+        result: action.result,
+        error: null
+      };
+    case "polling-failed":
+      return {
+        tag: "failed",
+        result: action.result,
+        error: null
+      };
+    case "polling-request-failed":
+      switch (state.tag) {
+        case "idle":
+          return {
+            tag: "polling",
+            result: null,
+            error: action.error
+          };
+        case "polling":
+          return {
+            tag: "polling",
+            result: state.result,
+            error: action.error
+          };
+        case "completed":
+        case "failed":
+        case "timeout":
+          return state;
+        default:
+          return assertNever(state);
+      }
+    case "polling-timed-out":
+      return {
+        tag: "timeout",
+        result: state.result,
+        error: new Error("Polling timed out")
+      };
+    default:
+      return assertNever(action);
+  }
+}
+
+// ../blocks/src/system/runtime/hooks/usePolling.ts
+var DEFAULT_MAX_ATTEMPTS = 10;
+var DEFAULT_POLL_INTERVAL = 1e3;
+function usePolling(config) {
+  const [state, dispatch] = useReducer(
+    pollingReducer,
+    void 0,
+    createInitialPollingState
+  );
+  const attemptsRef = useRef(0);
+  const timeoutRef = useRef(null);
+  const isPollingRef = useRef(false);
+  const isActiveRef = useRef(false);
+  const generationRef = useRef(0);
+  const configRef = useRef(config);
+  configRef.current = config;
+  const cleanup = useCallback(() => {
+    isActiveRef.current = false;
+    generationRef.current += 1;
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+    isPollingRef.current = false;
+  }, []);
+  const resetState = useCallback(() => {
+    dispatch({ type: "polling-reset" });
+    attemptsRef.current = 0;
+  }, []);
+  const poll = useCallback(async () => {
+    const cfg = configRef.current;
+    if (!cfg) return true;
+    if (isPollingRef.current) return false;
+    const maxAttempts = cfg.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+    if (attemptsRef.current >= maxAttempts) {
+      dispatch({ type: "polling-timed-out" });
+      cleanup();
+      return true;
+    }
+    isPollingRef.current = true;
+    attemptsRef.current += 1;
+    const generation = generationRef.current;
+    try {
+      const data = await cfg.pollFn();
+      if (generation !== generationRef.current || !isActiveRef.current) {
+        isPollingRef.current = false;
+        return true;
+      }
+      if (cfg.isFailed?.(data)) {
+        dispatch({ type: "polling-failed", result: data });
+        cleanup();
+        return true;
+      }
+      if (cfg.isComplete(data)) {
+        dispatch({ type: "polling-completed", result: data });
+        cleanup();
+        return true;
+      }
+      dispatch({ type: "polling-progressed", result: data });
+      isPollingRef.current = false;
+      return false;
+    } catch (err) {
+      if (generation !== generationRef.current || !isActiveRef.current) {
+        isPollingRef.current = false;
+        return true;
+      }
+      if (err instanceof Error) {
+        dispatch({ type: "polling-request-failed", error: err });
+      }
+      isPollingRef.current = false;
+      return false;
+    }
+  }, [cleanup]);
+  const schedulePoll = useCallback(() => {
+    if (!isActiveRef.current) return;
+    const cfg = configRef.current;
+    const pollInterval = cfg?.interval ?? DEFAULT_POLL_INTERVAL;
+    const doPoll = async () => {
+      const shouldStop = await poll();
+      if (!shouldStop && isActiveRef.current) {
+        timeoutRef.current = setTimeout(doPoll, pollInterval);
+      }
+    };
+    void doPoll();
+  }, [poll]);
+  useEffect(() => {
+    if (!config) {
+      cleanup();
+      dispatch({ type: "polling-went-idle" });
+      return;
+    }
+    resetState();
+    isActiveRef.current = true;
+    schedulePoll();
+    return cleanup;
+  }, [config, cleanup, resetState, schedulePoll]);
+  const retry = useCallback(() => {
+    if (!configRef.current) return;
+    cleanup();
+    resetState();
+    isActiveRef.current = true;
+    schedulePoll();
+  }, [cleanup, resetState, schedulePoll]);
+  return {
+    status: config ? state.tag : "idle",
+    result: config ? state.result : null,
+    error: config ? state.error : null,
+    retry
+  };
+}
+
+export { buildBookingPaymentSelectionViewModel, usePolling };