@riverbankcms/sdk 0.136.0 → 0.137.0

package/dist/client/{EventCombined.client-BWVNlXTx.mjs → EventCombined.client-CwJOxn7A.mjs}

@@ -1,11 +1,13 @@
 "use client";
 import { D as clsx } from "./colorStyles-CrxJrPjJ.mjs";
-import { At as assertNever, B as formatEventPrice, G as getContainerClass, Gt as getLocalScheduleDate, H as formatEventTeacherLine, J as resolveEventLinkProps, K as groupEventsByDate, L as formatDate, M as buildEventRuntimeFilters, N as getEventRuntimeFiltersKey, Rt as buildBookingUtcDateWindow, U as formatTime, Ut as formatLocalScheduleDate, W as getCardOrientation, X as getEventAvailability, st as themeButtonClassName } from "./propsDecoder-pzBeCh14.mjs";
-import { a as EventCardClient, i as EventPaginatedListView, n as useEventPagination, o as EventFilters, r as toError, t as useEventFilters } from "./useEventFilters-DeeyGYuk.mjs";
-import { n as useBlockApi } from "./context-BImarOAq.mjs";
+import { Dt as buildBookingUtcDateWindow, Ft as getLocalScheduleDate, L as getCardOrientation, M as buildEventRuntimeFilters, N as getEventRuntimeFiltersKey, Nt as formatLocalScheduleDate, R as getContainerClass, X as themeButtonClassName, z as formatEventPrice } from "./propsDecoder-pYvx_Srl.mjs";
+import { a as EventCardClient, i as EventPaginatedListView, n as useEventPagination, o as EventFilters, r as toError, s as formatEventTeacherLine, t as useEventFilters } from "./useEventFilters-ByuU6HLA.mjs";
+import { r as formatEventRemainingPlaces, u as isEventFull } from "./capacity-BW00PO7s.mjs";
+import { a as groupEventsByDate, i as formatTime, l as resolveEventLinkProps, t as formatDate } from "./dates-2RPXHQy4.mjs";
+import { n as useBlockApi } from "./context-DCkiHVdD.mjs";
 import { t as createBodyThemePortalRoot } from "./themePortalRoot-AGs4cE7t.mjs";
 import { t as ModalShell } from "./ModalShell-CqkBvBIC.mjs";
-import React, { createContext, useCallback, useContext, useEffect, useId, useMemo, useReducer, useRef, useState } from "react";
+import React, { createContext, useCallback, useContext, useEffect, useId, useMemo, useRef, useState } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 //#region ../calendar/src/grid.ts
 const DAY_NAMES = [
@@ -207,34 +209,80 @@ const TabBar = ({ tabs, activeTab, onTabChange, className }) => {
 };
 //#endregion
 //#region ../blocks/src/system/runtime/hooks/useCalendarEvents.state.ts
-function calendarEventCacheLoadReducer(state, action) {
-	switch (action.type) {
-		case "started": return {
+function calendarMonthKey(date) {
+	return `${date.year}-${String(date.month).padStart(2, "0")}`;
+}
+function calendarWindowMonths(date, radius) {
+	const months = [];
+	for (let offset = -radius; offset <= radius; offset++) months.push(calendarMonthKey(addMonths(date, offset)));
+	return months;
+}
+function groupEvents(events, timeZone) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		const key = calendarMonthKey(getLocalScheduleDate(new Date(event.startsAt), timeZone));
+		const month = grouped.get(key) ?? [];
+		if (!month.some((existing) => existing.id === event.id)) month.push(event);
+		grouped.set(key, month);
+	}
+	return grouped;
+}
+function seedCalendarCache(events, timeZone) {
+	return new Map([...groupEvents(events, timeZone)].map(([key, values]) => [key, {
+		kind: "seeded",
+		events: values
+	}]));
+}
+function planCalendarRequest(state, months, retry) {
+	const missing = months.filter((key) => {
+		const month = state.get(key);
+		return !month || month.kind === "seeded" || retry && month.kind === "failed";
+	});
+	return missing.length > 0 ? { months: missing } : null;
+}
+function startCalendarRequest(state, request) {
+	const next = new Map(state);
+	for (const key of request.months) {
+		const month = state.get(key);
+		if (month?.kind === "loading" || month?.kind === "ready") continue;
+		next.set(key, {
 			kind: "loading",
-			scope: action.scope
-		};
-		case "succeeded": return sameCalendarLoadScope(state, action.scope) ? { kind: "idle" } : state;
-		case "failed": return sameCalendarLoadScope(state, action.scope) ? {
-			kind: "error",
-			scope: action.scope,
-			error: action.error
-		} : state;
-		default: return assertNever(action);
+			request,
+			events: month?.events ?? []
+		});
 	}
+	return next;
 }
-function projectCalendarLoadState(state, scope) {
-	if (state.kind === "idle" || !sameCalendarLoadScope(state, scope)) return { kind: "idle" };
-	return state.kind === "loading" ? { kind: "loading" } : {
-		kind: "error",
-		error: state.error
-	};
+function calendarCacheReducer(state, action) {
+	if (action.kind === "started") return startCalendarRequest(state, action.request);
+	const next = new Map(state);
+	const grouped = action.kind === "succeeded" ? groupEvents(action.events, action.timeZone) : null;
+	for (const key of action.request.months) {
+		const month = state.get(key);
+		if (month?.kind === "loading" && month.request === action.request) next.set(key, action.kind === "succeeded" ? {
+			kind: "ready",
+			events: grouped?.get(key) ?? []
+		} : {
+			kind: "failed",
+			error: action.error,
+			events: month.events
+		});
+	}
+	return next;
 }
-function sameCalendarLoadScope(state, scope) {
-	if (state.kind === "idle") return false;
-	return state.scope.filtersKey === scope.filtersKey && state.scope.anchorDate.year === scope.anchorDate.year && state.scope.anchorDate.month === scope.anchorDate.month && state.scope.anchorDate.day === scope.anchorDate.day;
+function selectCalendarEvents(state, months) {
+	const events = /* @__PURE__ */ new Map();
+	for (const key of months) for (const event of state.get(key)?.events ?? []) events.set(event.id, event);
+	return [...events.values()].sort((a, b) => new Date(a.startsAt).getTime() - new Date(b.startsAt).getTime());
 }
-function toCalendarEventCacheLoadError(error) {
-	return toError(error, "Unknown error");
+function projectCalendarLoadState(state, months) {
+	const entries = months.map((key) => state.get(key));
+	const failed = entries.find((entry) => entry?.kind === "failed");
+	if (failed?.kind === "failed") return {
+		kind: "error",
+		error: failed.error
+	};
+	return entries.some((entry) => !entry || entry.kind === "seeded" || entry.kind === "loading") ? { kind: "loading" } : { kind: "idle" };
 }
 //#endregion
 //#region ../blocks/src/system/runtime/hooks/useCalendarEvents.ts
@@ -246,7 +294,7 @@ function toCalendarEventCacheLoadError(error) {
 */
 /** Maximum events to fetch per calendar request (covers 3 months of events) */
 const CALENDAR_FETCH_LIMIT = 200;
-async function loadCalendarEventPages(loadPage, request, isCurrent) {
+async function loadCalendarEventPages(loadPage, request) {
 	const events = [];
 	let afterStartsAt;
 	let afterId;
@@ -257,7 +305,6 @@ async function loadCalendarEventPages(loadPage, request, isCurrent) {
 			afterId,
 			limit: CALENDAR_FETCH_LIMIT
 		});
-		if (!isCurrent()) return null;
 		events.push(...page);
 		if (page.length < CALENDAR_FETCH_LIMIT) return events;
 		const last = page[page.length - 1];
@@ -267,12 +314,6 @@ async function loadCalendarEventPages(loadPage, request, isCurrent) {
 		afterId = last.occurrenceId;
 	}
 }
-/**
-* Generate a cache key for a month
-*/
-function getMonthKey(date) {
-	return `${date.year}-${String(date.month).padStart(2, "0")}`;
-}
 function useCalendarViewport({ view = "month", startOfWeek = "monday", initialDate }) {
 	const [viewDate, setViewDate] = useState(initialDate);
 	const viewport = useMemo(() => buildCalendarViewport({
@@ -303,167 +344,102 @@ function useCalendarViewport({ view = "month", startOfWeek = "monday", initialDa
 		}, [initialDate])
 	};
 }
-function addEventsToCalendarCache(cache, events, timeZone) {
-	for (const event of events) {
-		const monthKey = getMonthKey(getLocalScheduleDate(new Date(event.startsAt), timeZone));
-		const existing = cache.get(monthKey) ?? [];
-		if (!existing.some((cachedEvent) => cachedEvent.id === event.id)) cache.set(monthKey, [...existing, event]);
-	}
-}
-function useInitiallySeededCalendarCache(initialEvents, timeZone) {
-	const cacheRef = useRef(/* @__PURE__ */ new Map());
-	const seededRef = useRef(false);
-	if (!seededRef.current) {
-		addEventsToCalendarCache(cacheRef.current, initialEvents, timeZone);
-		seededRef.current = true;
-	}
-	return cacheRef;
-}
-function readEventsFromCalendarCache(cache, viewDate) {
-	const allEvents = [];
-	for (let offset = -1; offset <= 1; offset += 1) {
-		const monthEvents = cache.get(getMonthKey(addMonths(viewDate, offset))) ?? [];
-		allEvents.push(...monthEvents);
-	}
-	const seen = /* @__PURE__ */ new Set();
-	return allEvents.filter((event) => {
-		if (seen.has(event.id)) return false;
-		seen.add(event.id);
-		return true;
-	}).sort((left, right) => new Date(left.startsAt).getTime() - new Date(right.startsAt).getTime());
-}
 /**
-* Owns event loading and month-window caching for a supplied viewport anchor.
-* It does not decide navigation semantics or visible calendar days.
+* The reducer owns month data and request ownership. The hook only performs I/O.
+* Requests for other months remain useful until the query context changes.
 */
 function useCalendarEventCache({ viewDate, initialEvents = [], preloadMonths = 1, filters, stage, timeZone }) {
 	const { getPublicEvents } = useBlockApi();
-	const [loadState, dispatchLoadState] = useReducer(calendarEventCacheLoadReducer, { kind: "idle" });
-	const [cacheVersion, setCacheVersion] = useState(0);
-	const filtersKey = useMemo(() => getEventRuntimeFiltersKey(filters), [
-		filters?.categoryIds,
-		filters?.eventPresets,
-		filters?.eventSurface,
-		filters?.scheduleScope,
-		filters?.staffMemberId,
-		filters?.venueId
-	]);
-	const cacheRef = useInitiallySeededCalendarCache(initialEvents, timeZone);
-	const loadedMonthsRef = useRef(/* @__PURE__ */ new Set());
-	const fetchingRef = useRef(/* @__PURE__ */ new Set());
-	const requestIdRef = useRef(0);
-	const initializedFiltersKeyRef = useRef(null);
-	useEffect(() => {
-		if (initializedFiltersKeyRef.current === filtersKey) return;
-		initializedFiltersKeyRef.current = filtersKey;
-		cacheRef.current = /* @__PURE__ */ new Map();
-		loadedMonthsRef.current = /* @__PURE__ */ new Set();
-		fetchingRef.current = /* @__PURE__ */ new Set();
-		requestIdRef.current += 1;
-		addEventsToCalendarCache(cacheRef.current, initialEvents, timeZone);
-		setCacheVersion((v) => v + 1);
-	}, [
-		filtersKey,
-		initialEvents,
+	const context = useMemo(() => ({
+		getPublicEvents,
+		filters,
+		stage,
 		timeZone
-	]);
-	const fetchEventsForRange = useCallback(async (from, to, targetMonths, scope) => {
-		const monthsToFetch = targetMonths.filter((m) => !loadedMonthsRef.current.has(m) && !fetchingRef.current.has(m));
-		if (monthsToFetch.length === 0) return;
-		monthsToFetch.forEach((m) => fetchingRef.current.add(m));
-		const currentRequestId = ++requestIdRef.current;
-		dispatchLoadState({
-			type: "started",
-			scope
-		});
-		try {
-			const result = await loadCalendarEventPages(getPublicEvents, {
-				from,
-				to,
-				stage,
-				detailLevel: "listing",
-				eventSurface: filters?.eventSurface,
-				eventPresets: filters?.eventPresets,
-				scheduleScope: filters?.scheduleScope,
-				categoryIds: filters?.categoryIds,
-				staffMemberId: filters?.staffMemberId,
-				venueId: filters?.venueId
-			}, () => currentRequestId === requestIdRef.current);
-			if (result === null) return;
-			for (const event of result) {
-				const monthKey = getMonthKey(getLocalScheduleDate(new Date(event.startsAt), timeZone));
-				const existing = cacheRef.current.get(monthKey) || [];
-				if (!existing.some((e) => e.id === event.id)) cacheRef.current.set(monthKey, [...existing, event]);
-			}
-			for (const month of monthsToFetch) {
-				loadedMonthsRef.current.add(month);
-				if (!cacheRef.current.has(month)) cacheRef.current.set(month, []);
-			}
-			setCacheVersion((v) => v + 1);
-			dispatchLoadState({
-				type: "succeeded",
-				scope
-			});
-		} catch (err) {
-			monthsToFetch.forEach((m) => fetchingRef.current.delete(m));
-			if (currentRequestId === requestIdRef.current) dispatchLoadState({
-				type: "failed",
-				scope,
-				error: toCalendarEventCacheLoadError(err)
-			});
-		} finally {
-			monthsToFetch.forEach((m) => fetchingRef.current.delete(m));
-		}
-	}, [
+	}), [
 		getPublicEvents,
-		filters?.categoryIds,
-		filters?.eventPresets,
-		filters?.eventSurface,
-		filters?.scheduleScope,
-		filters?.staffMemberId,
-		filters?.venueId,
+		getEventRuntimeFiltersKey(filters),
 		stage,
 		timeZone
 	]);
-	const ensureEventsLoaded = useCallback((date) => {
-		const targetMonths = [];
-		for (let i = -preloadMonths; i <= preloadMonths; i++) {
-			const targetDate = addMonths(date, i);
-			targetMonths.push(getMonthKey(targetDate));
-		}
-		const unloadedMonths = targetMonths.filter((m) => !loadedMonthsRef.current.has(m) && !fetchingRef.current.has(m));
-		if (unloadedMonths.length > 0) {
-			const startDate = getStartOfMonth(addMonths(date, -preloadMonths));
-			const endDate = getEndOfMonth(addMonths(date, preloadMonths));
+	const [snapshot, setSnapshot] = useState(() => ({
+		context,
+		cache: seedCalendarCache(initialEvents, timeZone)
+	}));
+	if (snapshot.context !== context) setSnapshot({
+		context,
+		cache: seedCalendarCache(initialEvents, timeZone)
+	});
+	const months = useMemo(() => calendarWindowMonths(viewDate, preloadMonths), [
+		viewDate.year,
+		viewDate.month,
+		preloadMonths
+	]);
+	const displayMonths = useMemo(() => calendarWindowMonths(viewDate, 1), [viewDate.year, viewDate.month]);
+	const request = useMemo(() => snapshot.context === context ? planCalendarRequest(snapshot.cache, months, false) : null, [
+		snapshot,
+		context,
+		months
+	]);
+	const launched = useRef(/* @__PURE__ */ new WeakSet());
+	const runRequest = useCallback(async (planned) => {
+		if (launched.current.has(planned)) return;
+		launched.current.add(planned);
+		const apply = (action) => setSnapshot((current) => current.context === context ? {
+			context,
+			cache: calendarCacheReducer(current.cache, action)
+		} : current);
+		apply({
+			kind: "started",
+			request: planned
+		});
+		try {
 			const range = buildBookingUtcDateWindow({
-				startDate: formatLocalScheduleDate(startDate),
-				endDate: formatLocalScheduleDate(endDate),
+				startDate: formatLocalScheduleDate(getStartOfMonth(addMonths(viewDate, -preloadMonths))),
+				endDate: formatLocalScheduleDate(getEndOfMonth(addMonths(viewDate, preloadMonths))),
 				timeZone
 			});
-			const scope = {
-				anchorDate: date,
-				filtersKey
-			};
-			fetchEventsForRange(range.startAt.toISOString(), (/* @__PURE__ */ new Date(range.endExclusive.getTime() - 1)).toISOString(), unloadedMonths, scope);
+			apply({
+				kind: "succeeded",
+				request: planned,
+				events: await loadCalendarEventPages(context.getPublicEvents, {
+					...context.filters,
+					stage: context.stage,
+					from: range.startAt.toISOString(),
+					to: (/* @__PURE__ */ new Date(range.endExclusive.getTime() - 1)).toISOString(),
+					detailLevel: "listing"
+				}),
+				timeZone
+			});
+		} catch (error) {
+			apply({
+				kind: "failed",
+				request: planned,
+				error: toError(error, "Failed to load events")
+			});
 		}
 	}, [
+		context,
+		viewDate.year,
+		viewDate.month,
 		preloadMonths,
-		fetchEventsForRange,
-		filtersKey,
 		timeZone
 	]);
 	useEffect(() => {
-		ensureEventsLoaded(viewDate);
-	}, [viewDate, ensureEventsLoaded]);
+		if (request) runRequest(request);
+	}, [request, runRequest]);
 	const retryCurrentView = useCallback(() => {
-		ensureEventsLoaded(viewDate);
-	}, [ensureEventsLoaded, viewDate]);
+		if (snapshot.context !== context) return;
+		const retry = planCalendarRequest(snapshot.cache, months, true);
+		if (retry) runRequest(retry);
+	}, [
+		snapshot,
+		context,
+		months,
+		runRequest
+	]);
 	return {
-		events: useMemo(() => readEventsFromCalendarCache(cacheRef.current, viewDate), [viewDate, cacheVersion]),
-		loadState: projectCalendarLoadState(loadState, useMemo(() => ({
-			anchorDate: viewDate,
-			filtersKey
-		}), [filtersKey, viewDate])),
+		events: selectCalendarEvents(snapshot.cache, displayMonths),
+		loadState: projectCalendarLoadState(snapshot.cache, months),
 		retryCurrentView
 	};
 }
@@ -623,8 +599,8 @@ const AgendaEventCard = ({ event, showCapacity, onClick }) => {
 	const eventLinkProps = resolveEventLinkProps(event);
 	const categoryColor = event.eventCategory?.color || "rgb(var(--tb-accent))";
 	const price = formatEventPrice(event);
-	const { available, isFull } = getEventAvailability(event);
-	const capacity = showCapacity && available != null ? isFull ? "Full" : `${available} spots left` : null;
+	const capacity = showCapacity ? formatEventRemainingPlaces(event) : null;
+	const isFull = isEventFull(event);
 	const title = event.title;
 	const timeZone = event.timeZone ?? null;
 	const teacherLine = formatEventTeacherLine(event);

package/dist/client/{EventListing.client-DVFCDe3i.mjs → EventListing.client-eVwiylPW.mjs}

@@ -1,6 +1,6 @@
 "use client";
-import { M as buildEventRuntimeFilters } from "./propsDecoder-pzBeCh14.mjs";
-import { i as EventPaginatedListView, n as useEventPagination, o as EventFilters, t as useEventFilters } from "./useEventFilters-DeeyGYuk.mjs";
+import { M as buildEventRuntimeFilters } from "./propsDecoder-pYvx_Srl.mjs";
+import { i as EventPaginatedListView, n as useEventPagination, o as EventFilters, t as useEventFilters } from "./useEventFilters-ByuU6HLA.mjs";
 import { useId, useMemo } from "react";
 import { jsx } from "react/jsx-runtime";
 //#region ../blocks/src/system/runtime/nodes/events/EventListing.client.tsx

package/dist/client/{LeafletStaticMap-BY5mIHw9.mjs → LeafletStaticMap-IKenna5u.mjs}

@@ -1,5 +1,5 @@
 "use client";
-import { kt as isRecord } from "./propsDecoder-pzBeCh14.mjs";
+import { vt as isRecord } from "./propsDecoder-pYvx_Srl.mjs";
 import { useEffect, useRef, useState } from "react";
 import { jsx } from "react/jsx-runtime";
 //#region ../blocks/src/system/runtime/nodes/shared/LeafletStaticMap.tsx

package/dist/client/{accordion-CK29E8rG.mjs → accordion-MGAO3PuE.mjs}

@@ -1,4 +1,4 @@
-import { t as defineIslandPropsDecoder } from "./propsDecoder-pzBeCh14.mjs";
+import { t as defineIslandPropsDecoder } from "./propsDecoder-pYvx_Srl.mjs";
 //#region src/rendering/islands/enhancers/accordion.ts
 const decode = defineIslandPropsDecoder("accordion");
 function parseDefaultValues(value) {

package/dist/client/{bookingForm-DFvnet-N.mjs → bookingForm-CudlQPUu.mjs}

@@ -1,11 +1,11 @@
 "use client";
 import { S as unsafeAsPassId, _ as unsafeAsAppointmentResourceId, b as unsafeAsFormId, v as unsafeAsAppointmentServiceId, y as unsafeAsCustomerPassId } from "./colorStyles-CrxJrPjJ.mjs";
-import { a as buildBookingPaymentSelectionViewModel, i as usePolling, n as StepIndicator, r as SpinnerNode, t as BookingConsentAgreement } from "./BookingConsentAgreement-DCch21a6.mjs";
-import { At as assertNever, Ct as toSelectedCollectionOptionKind, Dt as isBookingRequirementConsentFieldId, Et as BOOKING_FORM_DATA_RESERVED_KEYS, Ft as reportWorkflowError, It as reportWorkflowSuccess, Kt as parseBookingLocalDate, Lt as addLocalScheduleDays, Mt as err, Pt as okWith, St as resolveDefaultBookingServiceId, Tt as resolveSelectedAppointmentConsent, Ut as formatLocalScheduleDate, Vt as formatBookingInstant, _t as parseBookingCurrencyInputToCents, bt as resolveBookingPaymentStep, dt as formatBookingCentsAsCurrencyInput, ft as formatBookingSubmissionPreparationError, gt as isBookingServiceSlidingAmountInRange, ht as getBookingSuccessMessage, jt as clearWorkflowFeedback, lt as logger, mt as getBookingServiceSlidingScale, pt as getBookingRedirectStateFromLocation, qt as resolveBookingTimeZoneId, st as themeButtonClassName, t as defineIslandPropsDecoder, tn as formatCurrencyAmount, ut as deriveBookingFormViewState, vt as prepareBookingSubmission, wt as projectSelectedAppointmentConsentIntoForm, xt as resolveBookingSiteId, yt as resolveAppointmentCheckoutVerificationState } from "./propsDecoder-pzBeCh14.mjs";
-import { n as useBlockApi, t as BlockApiProvider } from "./context-BImarOAq.mjs";
+import { a as buildBookingPaymentSelectionViewModel, i as usePolling, n as StepIndicator, r as SpinnerNode, t as BookingConsentAgreement } from "./BookingConsentAgreement--_fUCZe-.mjs";
+import { $ as deriveBookingFormViewState, Ct as okWith, Et as addLocalScheduleDays, It as parseBookingLocalDate, Kt as formatCurrencyAmount, Lt as resolveBookingTimeZoneId, Nt as formatLocalScheduleDate, Q as logger, Tt as reportWorkflowSuccess, X as themeButtonClassName, at as isBookingServiceSlidingAmountInRange, bt as clearWorkflowFeedback, ct as resolveAppointmentCheckoutVerificationState, dt as resolveDefaultBookingServiceId, et as formatBookingCentsAsCurrencyInput, ft as toSelectedCollectionOptionKind, gt as isBookingRequirementConsentFieldId, ht as BOOKING_FORM_DATA_RESERVED_KEYS, it as getBookingSuccessMessage, jt as formatBookingInstant, lt as resolveBookingPaymentStep, mt as resolveSelectedAppointmentConsent, nt as getBookingRedirectStateFromLocation, ot as parseBookingCurrencyInputToCents, pt as projectSelectedAppointmentConsentIntoForm, rt as getBookingServiceSlidingScale, st as prepareBookingSubmission, t as defineIslandPropsDecoder, tt as formatBookingSubmissionPreparationError, ut as resolveBookingSiteId, wt as reportWorkflowError, xt as err, yt as assertNever } from "./propsDecoder-pYvx_Srl.mjs";
+import { n as useBlockApi, t as BlockApiProvider } from "./context-DCkiHVdD.mjs";
 import { n as isSpamProtectionEnabled, r as AltchaWidget, t as getChallengeUrl } from "./src-B833rYRr.mjs";
-import { a as CheckIcon, i as StateIcon, n as useDiscountCodeUi, r as TerminalPanel, t as scrollToBlock } from "./scrollToBlock-CduAKf8T.mjs";
-import { t as DiscountCodeDisclosure } from "./DiscountCodeDisclosure-DIj1T59K.mjs";
+import { a as CheckIcon, i as StateIcon, n as useDiscountCodeUi, r as TerminalPanel, t as scrollToBlock } from "./scrollToBlock-ByQv96M2.mjs";
+import { t as DiscountCodeDisclosure } from "./DiscountCodeDisclosure-BMipSoDJ.mjs";
 import { t as FeedbackMessage } from "./FeedbackMessage-CtLvvS_d.mjs";
 import { n as getFieldValidationControlProps, t as FieldValidationMessage } from "./FieldValidationMessage-AYanWFb-.mjs";
 import { t as buildCheckoutReturnUrls } from "./checkoutUrls-BuseL0dw.mjs";