@riverbankcms/sdk 0.84.0 → 0.84.1

package/dist/server/routing.mjs

@@ -6405,6 +6405,12 @@ var init_endpoints = __esm({
 });
 
 // ../core/src/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
 var init_result = __esm({
   "../core/src/result.ts"() {
     "use strict";
@@ -6479,6 +6485,30 @@ var init_collections = __esm({
 });
 
 // ../core/src/event-pricing.ts
+function publicEventPricingType(pricing) {
+  switch (pricing.kind) {
+    case "drop_in":
+    case "free_registration":
+      return "free";
+    case "single_paid":
+    case "ticket_types":
+    case "course":
+      return isFreePublicEventPriceDisplay(pricing.display) ? "free" : "paid";
+  }
+}
+function isFreePublicEventPriceDisplay(display) {
+  switch (display.kind) {
+    case "free":
+      return true;
+    case "course":
+      return display.display.kind === "free";
+    case "exact":
+    case "from":
+    case "mixed":
+    case "unavailable":
+      return false;
+  }
+}
 var init_event_pricing = __esm({
   "../core/src/event-pricing.ts"() {
     "use strict";
@@ -6514,9 +6544,140 @@ var init_booking_instalments = __esm({
 });
 
 // ../core/src/booking-date-time.ts
+function isValidTimeZone(timeZone) {
+  try {
+    new Intl.DateTimeFormat(DEFAULT_LOCALE, { timeZone }).format(/* @__PURE__ */ new Date());
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getSafeTimeZone(timeZone) {
+  const normalized = typeof timeZone === "string" ? timeZone.trim() : "";
+  return normalized && isValidTimeZone(normalized) ? normalized : FALLBACK_TIMEZONE;
+}
+function parseStrictBookingTimeZone(timeZone) {
+  const normalized = timeZone.trim();
+  if (!normalized || !isValidTimeZone(normalized)) {
+    return null;
+  }
+  return normalized;
+}
+function formatParseError(error) {
+  switch (error.reason) {
+    case "invalid_starts_at":
+      return `Expected a valid UTC/offset-aware ISO datetime in startsAt, received "${error.value}"`;
+    case "invalid_ends_at":
+      return `Expected a valid UTC/offset-aware ISO datetime in endsAt, received "${error.value ?? ""}"`;
+    case "invalid_time_zone":
+      return `Expected a valid IANA timezone in timeZone, received "${error.value}"`;
+  }
+}
+function formatToPartsLookup(date, locale, timeZone, format) {
+  return new Map(
+    new Intl.DateTimeFormat(locale, {
+      ...format,
+      timeZone
+    }).formatToParts(date).map((part) => [part.type, part.value])
+  );
+}
+function getZonedDateTimeParts(date, timeZone) {
+  const parts = formatToPartsLookup(date, "en-GB", timeZone, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  });
+  const read = (type) => Number(parts.get(type) ?? "");
+  return {
+    year: read("year"),
+    month: read("month"),
+    day: read("day"),
+    hour: read("hour"),
+    minute: read("minute"),
+    second: read("second")
+  };
+}
+function formatDateKey(date) {
+  const year = String(date.year).padStart(4, "0");
+  const month = String(date.month).padStart(2, "0");
+  const day = String(date.day).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function parseUtcIsoDateTimeString(value) {
+  const normalized = value.trim();
+  const hasUtcSuffix = normalized.endsWith("Z");
+  const hasExplicitOffset = /[+-]\d{2}:\d{2}$/u.test(normalized);
+  if (!hasUtcSuffix && !hasExplicitOffset) {
+    return err("missing-timezone-offset");
+  }
+  const date = new Date(normalized);
+  if (Number.isNaN(date.getTime())) {
+    return err("invalid-date-time");
+  }
+  return ok(date.toISOString());
+}
+function toUtcIsoDateTimeString(value) {
+  const parsed = parseUtcIsoDateTimeString(value);
+  if (!parsed.ok) {
+    const message = parsed.error === "missing-timezone-offset" ? `Expected an offset-aware ISO datetime, received "${value}"` : `Expected a valid ISO datetime, received "${value}"`;
+    throw new Error(message);
+  }
+  return parsed.value;
+}
+function parseScheduledBookingDateTime(input) {
+  try {
+    const startsAt = toUtcIsoDateTimeString(input.startsAt);
+    const timeZone = parseStrictBookingTimeZone(input.timeZone);
+    if (!timeZone) {
+      return {
+        ok: false,
+        field: "timeZone",
+        reason: "invalid_time_zone",
+        value: input.timeZone
+      };
+    }
+    return {
+      ok: true,
+      value: {
+        startsAt,
+        timeZone,
+        locale: input.locale
+      }
+    };
+  } catch {
+    return {
+      ok: false,
+      field: "startsAt",
+      reason: "invalid_starts_at",
+      value: input.startsAt
+    };
+  }
+}
+function toScheduledBookingDateTime(input) {
+  const result = parseScheduledBookingDateTime(input);
+  if (result.ok) {
+    return result.value;
+  }
+  throw new Error(formatParseError(result));
+}
+function getBookingLocalDateKey(input) {
+  return formatDateKey(getLocalScheduleDate(new Date(input.startsAt), input.timeZone));
+}
+function getLocalScheduleDate(date, timeZone) {
+  const parts = getZonedDateTimeParts(date, getSafeTimeZone(timeZone));
+  return { year: parts.year, month: parts.month, day: parts.day };
+}
+var DEFAULT_LOCALE, FALLBACK_TIMEZONE;
 var init_booking_date_time = __esm({
   "../core/src/booking-date-time.ts"() {
     "use strict";
+    init_result();
+    DEFAULT_LOCALE = "en-US";
+    FALLBACK_TIMEZONE = "UTC";
   }
 });
 
@@ -32315,6 +32476,32 @@ var init_event_registration_shared = __esm({
   }
 });
 
+// ../blocks/src/system/constants/events.ts
+function isEventCalendarDisplayMode(value) {
+  return typeof value === "string" && eventCalendarDisplayModeValues.includes(value);
+}
+function isEventCalendarListLayout(value) {
+  return typeof value === "string" && eventCalendarListLayoutValues.includes(value);
+}
+function isEventContentType(slug) {
+  if (!slug) return false;
+  return EVENT_CONTENT_TYPE_SLUGS.includes(slug);
+}
+var EVENT_CONTENT_TYPE_SLUGS, eventCalendarDisplayModeValues, eventCalendarListLayoutValues, eventCalendarListLayoutOptions;
+var init_events = __esm({
+  "../blocks/src/system/constants/events.ts"() {
+    "use strict";
+    EVENT_CONTENT_TYPE_SLUGS = ["event", "events"];
+    eventCalendarDisplayModeValues = ["combined", "month", "week", "list", "timetable"];
+    eventCalendarListLayoutValues = ["stack", "grid", "compact"];
+    eventCalendarListLayoutOptions = [
+      { id: "stack", label: "Stack" },
+      { id: "grid", label: "Grid" },
+      { id: "compact", label: "Compact" }
+    ];
+  }
+});
+
 // ../blocks/src/system/runtime/nodes/events/shared/pricing.ts
 function resolveRuntimeEventPricing(event) {
   if (isPublicEventPricing(event.pricing)) {
@@ -32441,27 +32628,6 @@ var init_pricing = __esm({
   }
 });
 
-// ../blocks/src/system/constants/events.ts
-function isEventCalendarDisplayMode(value) {
-  return typeof value === "string" && eventCalendarDisplayModeValues.includes(value);
-}
-function isEventCalendarListLayout(value) {
-  return typeof value === "string" && eventCalendarListLayoutValues.includes(value);
-}
-var eventCalendarDisplayModeValues, eventCalendarListLayoutValues, eventCalendarListLayoutOptions;
-var init_events = __esm({
-  "../blocks/src/system/constants/events.ts"() {
-    "use strict";
-    eventCalendarDisplayModeValues = ["combined", "month", "week", "list", "timetable"];
-    eventCalendarListLayoutValues = ["stack", "grid", "compact"];
-    eventCalendarListLayoutOptions = [
-      { id: "stack", label: "Stack" },
-      { id: "grid", label: "Grid" },
-      { id: "compact", label: "Compact" }
-    ];
-  }
-});
-
 // ../blocks/src/system/runtime/nodes/shared/contract-schemas.ts
 import { z as z47 } from "zod";
 var previewStageSchema, registrationButtonVariantSchema, eventButtonVariantSchema, eventLayoutSchema, eventCalendarDisplayModeSchema, columnOptionSchema, weekStartSchema, filterAutoShowSchema, calendarTabViewsSchema;
@@ -32481,19 +32647,157 @@ var init_contract_schemas = __esm({
   }
 });
 
+// ../blocks/src/system/runtime/nodes/event-registration/wizardSteps.ts
+function getWizardStepsForContext(hasPreSelectedContext, needsPaymentStep) {
+  const baseSteps = hasPreSelectedContext ? ["select-tickets", "enter-details"] : ["select-event", "select-tickets", "enter-details"];
+  if (!needsPaymentStep) {
+    return baseSteps;
+  }
+  return [...baseSteps, "select-payment"];
+}
+var init_wizardSteps = __esm({
+  "../blocks/src/system/runtime/nodes/event-registration/wizardSteps.ts"() {
+    "use strict";
+  }
+});
+
+// ../blocks/src/system/runtime/nodes/event-registration/registrationDerivations.ts
+function eventMatchesOccurrenceId(event, occurrenceId) {
+  return event.registrationOccurrenceId === occurrenceId || event.publicEventId === occurrenceId;
+}
+function findPreSelectedEvent(input) {
+  const occurrenceContext = input.occurrenceContext;
+  if (!occurrenceContext) {
+    return null;
+  }
+  const contextDate = getBookingLocalDateKey(toScheduledBookingDateTime({
+    startsAt: occurrenceContext.startsAt,
+    timeZone: occurrenceContext.timeZone
+  }));
+  return input.scopedEvents.find(
+    (event) => eventMatchesOccurrenceId(event, occurrenceContext.id) || getBookingLocalDateKey(toScheduledBookingDateTime({
+      startsAt: event.startsAt,
+      timeZone: event.timeZone
+    })) === contextDate
+  ) ?? null;
+}
+function resolveEventRequiresPayment(input) {
+  if (input.eligibility) {
+    return input.eligibility.requiresPayment;
+  }
+  if (input.selectedTicketType) {
+    return input.selectedTicketType.priceAmount > 0;
+  }
+  if (!input.event) {
+    return false;
+  }
+  return publicEventPricingType(resolveRuntimeEventPricing(input.event)) !== "free";
+}
+var init_registrationDerivations = __esm({
+  "../blocks/src/system/runtime/nodes/event-registration/registrationDerivations.ts"() {
+    "use strict";
+    init_src();
+    init_pricing();
+  }
+});
+
+// ../blocks/src/system/runtime/nodes/event-registration/registrationEventAdapter.ts
+function toRegistrationEvent(event) {
+  return {
+    ...event,
+    pricing: resolveRuntimeEventPricing(event),
+    publicEventId: event.id,
+    registrationOccurrenceId: event.occurrenceId
+  };
+}
+function toRegistrationEvents(events) {
+  return events.map(toRegistrationEvent);
+}
+var init_registrationEventAdapter = __esm({
+  "../blocks/src/system/runtime/nodes/event-registration/registrationEventAdapter.ts"() {
+    "use strict";
+    init_pricing();
+  }
+});
+
 // ../blocks/src/system/runtime/nodes/event-registration.interactive.ts
 import { z as z48 } from "zod";
 function buildEventRegistrationDisplay(source) {
+  const stepLabels = buildEventRegistrationShellStepLabels(source);
   return {
     kind: "event-registration",
     state: "generic-shell",
     className: source.className ?? null,
     titleText: "Event registration",
-    bodyText: "Preparing dates, tickets, and booking details.",
-    stepLabels: EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS,
+    bodyText: buildEventRegistrationShellBodyText(stepLabels),
+    stepLabels,
     summaryButtonText: source.buttonText?.trim() || "Register"
   };
 }
+function buildEventRegistrationShellStepLabels(source) {
+  const scopedEvents = scopeEventRegistrationEvents(source);
+  if (scopedEvents.length === 0) {
+    return EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS;
+  }
+  const preSelectedEvent = findPreSelectedEvent({
+    scopedEvents,
+    occurrenceContext: source.occurrenceContext
+  });
+  const hasPreSelectedContext = Boolean(source.occurrenceContext || preSelectedEvent);
+  const needsPaymentStep = hasPreSelectedContext && preSelectedEvent ? resolveEventRequiresPayment({
+    eligibility: null,
+    selectedTicketType: null,
+    event: preSelectedEvent
+  }) : false;
+  return getWizardStepsForContext(hasPreSelectedContext, needsPaymentStep).map((step) => shellLabelForRegistrationStep(step, scopedEvents));
+}
+function scopeEventRegistrationEvents(source) {
+  const events = toRegistrationEvents(source.events ?? []);
+  if (source.occurrenceContext?.seriesId) {
+    return events.filter((event) => event.seriesId === source.occurrenceContext?.seriesId);
+  }
+  const entrySlug = source.contentEntry?.slug;
+  const entryContentType = source.contentEntry?.contentTypeSlug;
+  if (entrySlug && entryContentType && isEventContentType(entryContentType)) {
+    return events.filter((event) => event.slug === entrySlug);
+  }
+  return events;
+}
+function shellLabelForRegistrationStep(step, events) {
+  switch (step) {
+    case "select-event":
+      return isDateSelection(events) ? "Date" : "Event";
+    case "select-tickets":
+      return "Tickets";
+    case "enter-details":
+      return "Details";
+    case "select-payment":
+      return "Payment";
+    case "error":
+    case "success":
+    case "submitting":
+    case "redirecting":
+    case "verifying-payment":
+    case "verifying-timeout":
+    case "payment-failed":
+      return "Details";
+  }
+}
+function isDateSelection(events) {
+  const firstSeriesId = events[0]?.seriesId;
+  return Boolean(
+    events.length > 1 && firstSeriesId && events.every((event) => event.seriesId === firstSeriesId)
+  );
+}
+function buildEventRegistrationShellBodyText(stepLabels) {
+  if (stepLabels.includes("Payment")) {
+    return "Preparing tickets, details, and payment options.";
+  }
+  if (stepLabels[0] === "Tickets") {
+    return "Preparing tickets and booking details.";
+  }
+  return "Preparing dates, tickets, and booking details.";
+}
 function normalizeEventRegistrationEventInput(value) {
   if (!isRecord4(value)) {
     return value;
@@ -32506,22 +32810,22 @@ function normalizeEventRegistrationEventInput(value) {
 function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS, eventRegistrationGenericDateStepLabel, eventRegistrationGenericTicketsStepLabel, eventRegistrationGenericDetailsStepLabel, contentEntrySchema, eventRegistrationPublicEventSchema, eventRegistrationSourceSchema, eventRegistrationDisplaySchema, eventRegistrationHydrationSchema, eventRegistrationRenderSchema, eventRegistrationIslandMetaCodec, eventRegistrationIslandMetaKeys, eventRegistrationBlockRuntime, eventRegistrationInteractiveIslandPropsCodec;
+var EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS, EVENT_REGISTRATION_SHELL_STEP_LABELS, contentEntrySchema, eventRegistrationPublicEventSchema, eventRegistrationSourceSchema, eventRegistrationDisplaySchema, eventRegistrationHydrationSchema, eventRegistrationRenderSchema, eventRegistrationIslandMetaCodec, eventRegistrationIslandMetaKeys, eventRegistrationBlockRuntime, eventRegistrationInteractiveIslandPropsCodec;
 var init_event_registration_interactive = __esm({
   "../blocks/src/system/runtime/nodes/event-registration.interactive.ts"() {
     "use strict";
     init_schemas2();
     init_event_registration_shared();
+    init_events();
     init_pricing();
     init_islands();
     init_runtime();
     init_contract_schemas();
+    init_wizardSteps();
+    init_registrationDerivations();
+    init_registrationEventAdapter();
     EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS = ["Date", "Tickets", "Details"];
-    [
-      eventRegistrationGenericDateStepLabel,
-      eventRegistrationGenericTicketsStepLabel,
-      eventRegistrationGenericDetailsStepLabel
-    ] = EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS;
+    EVENT_REGISTRATION_SHELL_STEP_LABELS = ["Event", "Date", "Tickets", "Details", "Payment"];
     contentEntrySchema = z48.object({
       id: z48.string(),
       slug: z48.string(),
@@ -32557,11 +32861,7 @@ var init_event_registration_interactive = __esm({
       className: z48.string().nullable(),
       titleText: z48.string(),
       bodyText: z48.string(),
-      stepLabels: z48.tuple([
-        z48.literal(eventRegistrationGenericDateStepLabel),
-        z48.literal(eventRegistrationGenericTicketsStepLabel),
-        z48.literal(eventRegistrationGenericDetailsStepLabel)
-      ]),
+      stepLabels: z48.array(z48.enum(EVENT_REGISTRATION_SHELL_STEP_LABELS)).min(1),
       summaryButtonText: z48.string()
     });
     eventRegistrationHydrationSchema = z48.object({