@riverbankcms/sdk 0.85.0 → 0.89.1

package/dist/client/{accordion-2UZPBMYM.mjs → accordion-MUCVNGQ7.mjs}

@@ -1,5 +1,5 @@
-import { defineIslandPropsDecoder } from './chunk-VGDBVNOO.mjs';
-import './chunk-ZE5G642V.mjs';
+import { defineIslandPropsDecoder } from './chunk-UQFY4AHX.mjs';
+import './chunk-25W2EQUN.mjs';
 
 // src/rendering/islands/enhancers/accordion.ts
 var decode = defineIslandPropsDecoder("accordion");

package/dist/client/{bookingForm-36CWQUMV.mjs → bookingForm-PKD6EFIE.mjs}

@@ -1,16 +1,16 @@
 "use client";
-import { usePolling } from './chunk-ZKUO52W3.mjs';
-import { SpinnerNode } from './chunk-SYIJ5JO2.mjs';
+import { usePolling } from './chunk-LQFDYWPJ.mjs';
+import { SpinnerNode } from './chunk-FHU6PFPM.mjs';
 import { useDiscountCodeUi } from './chunk-ZFHRN6W2.mjs';
 import { buildRouteIslandApiConfig } from './chunk-L4J5Y62O.mjs';
-import { scrollToBlock, buildCheckoutReturnUrls, DiscountCodeDisclosure, formatPrice } from './chunk-7UCLJ5SP.mjs';
+import { scrollToBlock, buildCheckoutReturnUrls, DiscountCodeDisclosure, formatPrice } from './chunk-EY42X22F.mjs';
 import { FieldValidationMessage, getFieldValidationControlProps } from './chunk-3DCJ45Z2.mjs';
-import './chunk-DVNUDUVT.mjs';
+import './chunk-WBQG7VJA.mjs';
 import { isSpamProtectionEnabled, getChallengeUrl, AltchaWidget } from './chunk-SDIYSQAY.mjs';
-import { BlockApiProvider, useBlockApi, FeedbackMessage } from './chunk-UDNSI5PY.mjs';
+import { BlockApiProvider, useBlockApi, FeedbackMessage } from './chunk-STJ2NCQM.mjs';
 import { mountReactIsland } from './chunk-N7PBWBWQ.mjs';
-import { defineIslandPropsDecoder, resolveBookingSiteId, resolveDefaultBookingServiceId, getBookingRedirectStateFromLocation, deriveBookingFormViewState, logger, getBookingSuccessMessage, resolveAppointmentCheckoutVerificationState, themeButtonClassName, toSelectedCollectionOptionKind, assertNever11, prepareBookingSubmission, formatBookingSubmissionPreparationError, resolveBookingPaymentStep, BOOKING_FORM_DATA_RESERVED_KEYS, clearWorkflowFeedback, reportWorkflowError, reportWorkflowSuccess, okWith2, err2 } from './chunk-VGDBVNOO.mjs';
-import { resolveBookingTimeZoneId, DEFAULT_BOOKING_TIME_ZONE, unsafeAsFormId, unsafeAsAppointmentResourceId, unsafeAsCustomerPassId, unsafeAsAppointmentServiceId, formatLocalScheduleDate, addLocalScheduleDays, parseBookingLocalDate, resolveFlexibleBalanceInitialPaymentCents, resolveFlexibleBalanceDueAt, getBookingInstalmentDepositRefundability, unsafeAsPassId, splitAmountWithRemainderInFirst, addIntervalPreservingMonthAnchor, clampConfiguredAmount, getBookingInstalmentPlanIntervalCount, omitZeroAmountFutureRows, formatBookingInstant } from './chunk-ZE5G642V.mjs';
+import { defineIslandPropsDecoder, resolveBookingSiteId, resolveDefaultBookingServiceId, getBookingRedirectStateFromLocation, deriveBookingFormViewState, logger, getBookingSuccessMessage, resolveAppointmentCheckoutVerificationState, themeButtonClassName, toSelectedCollectionOptionKind, assertNever11, prepareBookingSubmission, formatBookingSubmissionPreparationError, resolveBookingPaymentStep, BOOKING_FORM_DATA_RESERVED_KEYS, clearWorkflowFeedback, reportWorkflowError, reportWorkflowSuccess, okWith2, err2 } from './chunk-UQFY4AHX.mjs';
+import { resolveBookingTimeZoneId, DEFAULT_BOOKING_TIME_ZONE, unsafeAsFormId, unsafeAsAppointmentResourceId, unsafeAsCustomerPassId, unsafeAsAppointmentServiceId, formatLocalScheduleDate, addLocalScheduleDays, parseBookingLocalDate, resolveFlexibleBalanceInitialPaymentCents, resolveFlexibleBalanceDueAt, getBookingInstalmentDepositRefundability, unsafeAsPassId, splitAmountWithRemainderInFirst, addIntervalPreservingMonthAnchor, clampConfiguredAmount, getBookingInstalmentPlanIntervalCount, omitZeroAmountFutureRows, formatBookingInstant } from './chunk-25W2EQUN.mjs';
 import React2, { useRef, useState, useMemo, useReducer, useEffect, useCallback, useLayoutEffect } from 'react';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 
@@ -141,6 +141,74 @@ function useVisibleTabPolling({
   }, [enabled, intervalMs, jitterMs, minVisibleRefreshIntervalMs]);
 }
 
+// ../blocks/src/system/runtime/hooks/useAvailableDates.state.ts
+function createEmptyAvailableDatesData() {
+  return {
+    availableDates: /* @__PURE__ */ new Set(),
+    hasMore: false,
+    loadedRange: null,
+    nextStartDate: null
+  };
+}
+function createInitialAvailableDatesState() {
+  return {
+    tag: "idle",
+    data: createEmptyAvailableDatesData()
+  };
+}
+function getAvailableDates(state) {
+  return state.data.availableDates;
+}
+function getAvailableDatesLoadedRange(state) {
+  return state.data.loadedRange;
+}
+function getAvailableDatesNextStartDate(state) {
+  return state.data.nextStartDate;
+}
+function hasMoreAvailableDates(state) {
+  return state.data.hasMore;
+}
+function isLoadingAvailableDates(state) {
+  return state.tag === "loading";
+}
+function isRefreshingAvailableDates(state) {
+  return state.tag === "refreshing";
+}
+function getAvailableDatesError(state) {
+  return state.tag === "error" ? state.message : null;
+}
+function mergeAvailableDates(previous, action) {
+  const availableDates = action.append ? new Set(previous.availableDates) : /* @__PURE__ */ new Set();
+  for (const date of action.dates) {
+    availableDates.add(date);
+  }
+  return {
+    availableDates,
+    hasMore: action.hasMore,
+    loadedRange: {
+      start: action.append && previous.loadedRange ? previous.loadedRange.start : action.startDate,
+      end: action.endDate
+    },
+    nextStartDate: action.nextStartDate
+  };
+}
+function availableDatesReducer(state, action) {
+  switch (action.type) {
+    case "query-cleared":
+      return { tag: "idle", data: createEmptyAvailableDatesData() };
+    case "load-started":
+      return { tag: "loading", data: state.data };
+    case "refresh-started":
+      return { tag: "refreshing", data: state.data };
+    case "load-succeeded":
+      return { tag: "loaded", data: mergeAvailableDates(state.data, action) };
+    case "load-failed":
+      return { tag: "error", data: state.data, message: action.message };
+    default:
+      return assertNever11(action);
+  }
+}
+
 // ../blocks/src/system/runtime/hooks/useAvailableDates.ts
 var AVAILABILITY_REFRESH_INTERVAL_MS = 3e4;
 var AVAILABILITY_REFRESH_JITTER_MS = 5e3;
@@ -153,25 +221,23 @@ function useAvailableDates({
   initialDays = 30
 }) {
   const api = useBlockApi();
-  const [availableDates, setAvailableDates] = useState(/* @__PURE__ */ new Set());
-  const [isLoading, setIsLoading] = useState(false);
-  const [isRefreshing, setIsRefreshing] = useState(false);
-  const [error, setError] = useState(null);
-  const [hasMore, setHasMore] = useState(false);
-  const [loadedRange, setLoadedRange] = useState(null);
-  const nextStartDateRef = useRef(null);
+  const [state, dispatch] = useReducer(
+    availableDatesReducer,
+    createInitialAvailableDatesState()
+  );
   const requestIdRef = useRef(0);
+  const loadedRange = getAvailableDatesLoadedRange(state);
+  const isLoading = isLoadingAvailableDates(state);
+  const nextStartDate = getAvailableDatesNextStartDate(state);
   const fetchDates = useCallback(
     async (startDate, endDate, append = false, mode = "load") => {
       if (!serviceId) return;
       const requestId = ++requestIdRef.current;
       if (mode === "refresh") {
-        setIsRefreshing(true);
+        dispatch({ type: "refresh-started" });
       } else {
-        setIsLoading(true);
-        setIsRefreshing(false);
+        dispatch({ type: "load-started" });
       }
-      setError(null);
       try {
         const data = await api.getAvailableDates({
           serviceId,
@@ -181,38 +247,29 @@ function useAvailableDates({
           resourceId
         });
         if (requestId !== requestIdRef.current) return;
-        setAvailableDates((prev) => {
-          const newSet = append ? new Set(prev) : /* @__PURE__ */ new Set();
-          data.dates.forEach((d) => newSet.add(d));
-          return newSet;
+        dispatch({
+          type: "load-succeeded",
+          dates: data.dates,
+          hasMore: data.hasMore,
+          nextStartDate: data.nextStartDate || null,
+          startDate: data.startDate,
+          endDate: data.endDate,
+          append
         });
-        setHasMore(data.hasMore);
-        nextStartDateRef.current = data.nextStartDate || null;
-        setLoadedRange((prev) => ({
-          start: append && prev ? prev.start : data.startDate,
-          end: data.endDate
-        }));
       } catch (err) {
         if (requestId !== requestIdRef.current) return;
-        setError(
-          err instanceof Error ? err.message : "Failed to load available dates"
-        );
-      } finally {
-        if (mode === "refresh" && requestId === requestIdRef.current) {
-          setIsRefreshing(false);
-        } else if (requestId === requestIdRef.current) {
-          setIsLoading(false);
-        }
+        dispatch({
+          type: "load-failed",
+          message: err instanceof Error ? err.message : "Failed to load available dates"
+        });
       }
     },
     [api, serviceId, resourceId, timezone]
   );
   useEffect(() => {
     if (!serviceId) {
-      setAvailableDates(/* @__PURE__ */ new Set());
-      setLoadedRange(null);
-      setHasMore(false);
-      setIsRefreshing(false);
+      requestIdRef.current += 1;
+      dispatch({ type: "query-cleared" });
       return;
     }
     const now = /* @__PURE__ */ new Date();
@@ -236,8 +293,8 @@ function useAvailableDates({
     }
   });
   const loadMore = useCallback(() => {
-    if (!nextStartDateRef.current || isLoading) return;
-    const start = nextStartDateRef.current;
+    if (!nextStartDate || isLoading) return;
+    const start = nextStartDate;
     const end = formatLocalScheduleDate(
       addLocalScheduleDays(
         parseBookingLocalDate(start),
@@ -245,17 +302,83 @@ function useAvailableDates({
       )
     );
     void fetchDates(start, end, true);
-  }, [fetchDates, isLoading]);
+  }, [fetchDates, isLoading, nextStartDate]);
   return {
-    availableDates,
+    availableDates: getAvailableDates(state),
     isLoading,
-    isRefreshing,
-    error,
-    hasMore,
+    isRefreshing: isRefreshingAvailableDates(state),
+    error: getAvailableDatesError(state),
+    hasMore: hasMoreAvailableDates(state),
     loadMore,
     loadedRange
   };
 }
+
+// ../blocks/src/system/runtime/hooks/useAvailableSlots.state.ts
+var initialAvailableSlotsState = { tag: "idle" };
+function getAvailableSlots(state) {
+  switch (state.tag) {
+    case "idle":
+    case "loading":
+      return [];
+    case "loaded":
+    case "refreshing":
+    case "error":
+      return state.slots;
+    default:
+      return assertNever11(state);
+  }
+}
+function hasLoadedAvailableSlots(state) {
+  switch (state.tag) {
+    case "idle":
+      return false;
+    case "loading":
+    case "refreshing":
+    case "error":
+      return state.hasLoaded;
+    case "loaded":
+      return true;
+    default:
+      return assertNever11(state);
+  }
+}
+function isLoadingAvailableSlots(state) {
+  return state.tag === "loading";
+}
+function isRefreshingAvailableSlots(state) {
+  return state.tag === "refreshing";
+}
+function getAvailableSlotsError(state) {
+  return state.tag === "error" ? state.message : null;
+}
+function availableSlotsReducer(state, action) {
+  switch (action.type) {
+    case "query-cleared":
+      return { tag: "idle" };
+    case "load-started":
+      return { tag: "loading", hasLoaded: hasLoadedAvailableSlots(state) };
+    case "refresh-started":
+      return {
+        tag: "refreshing",
+        slots: getAvailableSlots(state),
+        hasLoaded: hasLoadedAvailableSlots(state)
+      };
+    case "load-succeeded":
+      return { tag: "loaded", slots: action.slots };
+    case "load-failed":
+      return {
+        tag: "error",
+        slots: getAvailableSlots(state),
+        hasLoaded: hasLoadedAvailableSlots(state),
+        message: action.message
+      };
+    default:
+      return assertNever11(action);
+  }
+}
+
+// ../blocks/src/system/runtime/hooks/useAvailableSlots.ts
 var AVAILABILITY_REFRESH_INTERVAL_MS2 = 3e4;
 var AVAILABILITY_REFRESH_JITTER_MS2 = 5e3;
 function useAvailableSlots({
@@ -267,31 +390,23 @@ function useAvailableSlots({
   timezone
 }) {
   const api = useBlockApi();
-  const [slots, setSlots] = useState([]);
-  const [isLoading, setIsLoading] = useState(false);
-  const [isRefreshing, setIsRefreshing] = useState(false);
-  const [hasLoaded, setHasLoaded] = useState(false);
-  const [error, setError] = useState(null);
+  const [state, dispatch] = useReducer(
+    availableSlotsReducer,
+    initialAvailableSlotsState
+  );
   const requestIdRef = useRef(0);
   const fetchSlots = useCallback(
     async (mode) => {
       const requestId = ++requestIdRef.current;
       if (!selectedDate || !serviceId) {
-        setSlots([]);
-        setIsLoading(false);
-        setIsRefreshing(false);
-        setHasLoaded(false);
-        setError(null);
+        dispatch({ type: "query-cleared" });
         return;
       }
       if (mode === "refresh") {
-        setIsRefreshing(true);
+        dispatch({ type: "refresh-started" });
       } else {
-        setIsLoading(true);
-        setIsRefreshing(false);
-        setSlots([]);
+        dispatch({ type: "load-started" });
       }
-      setError(null);
       try {
         const result = await api.getAvailableSlots({
           serviceId,
@@ -301,24 +416,19 @@ function useAvailableSlots({
           resourceId
         });
         if (requestId !== requestIdRef.current) return;
-        setSlots(
-          result.slots.map((slot) => ({
+        dispatch({
+          type: "load-succeeded",
+          slots: result.slots.map((slot) => ({
             ...slot,
             resourceId: unsafeAsAppointmentResourceId(slot.resourceId)
           }))
-        );
-        setHasLoaded(true);
+        });
       } catch (err) {
         if (requestId !== requestIdRef.current) return;
-        setError(
-          err instanceof Error ? err.message : "Failed to load available times"
-        );
-      } finally {
-        if (mode === "refresh" && requestId === requestIdRef.current) {
-          setIsRefreshing(false);
-        } else if (requestId === requestIdRef.current) {
-          setIsLoading(false);
-        }
+        dispatch({
+          type: "load-failed",
+          message: err instanceof Error ? err.message : "Failed to load available times"
+        });
       }
     },
     [selectedDate, serviceId, resourceId, timezone, api]
@@ -335,7 +445,13 @@ function useAvailableSlots({
     jitterMs: AVAILABILITY_REFRESH_JITTER_MS2,
     onPoll: () => fetchSlots("refresh")
   });
-  return { slots, isLoading, isRefreshing, hasLoaded, error };
+  return {
+    slots: getAvailableSlots(state),
+    isLoading: isLoadingAvailableSlots(state),
+    isRefreshing: isRefreshingAvailableSlots(state),
+    hasLoaded: hasLoadedAvailableSlots(state),
+    error: getAvailableSlotsError(state)
+  };
 }
 
 // ../blocks/src/system/runtime/hooks/useBookingSubmission.state.ts