@riverbankcms/sdk 0.72.0 → 0.75.0

package/dist/client/chunk-M3L3KYYR.mjs

@@ -0,0 +1,1181 @@
+"use client";
+import { createContext, useMemo, useContext } from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// ../blocks/src/system/runtime/api/context.tsx
+
+// ../blocks/src/system/runtime/api/deduplication.ts
+function createDeduplicationCache(options = {}) {
+  const { ttl = 100 } = options;
+  const cache = /* @__PURE__ */ new Map();
+  function getCacheKey(method, url, params) {
+    const paramsKey = params ? JSON.stringify(params) : "";
+    return `${method}:${url}:${paramsKey}`;
+  }
+  async function dedupe(key, fetcher) {
+    const now = Date.now();
+    const existing = cache.get(key);
+    if (existing) {
+      if (!existing.settled) {
+        return existing.promise;
+      }
+      if (existing.settledTime && now - existing.settledTime < ttl) {
+        return existing.promise;
+      }
+    }
+    const entry = {
+      promise: fetcher().finally(() => {
+        entry.settled = true;
+        entry.settledTime = Date.now();
+        setTimeout(() => {
+          const current = cache.get(key);
+          if (current?.promise === entry.promise) {
+            cache.delete(key);
+          }
+        }, ttl);
+      }),
+      startTime: now,
+      settled: false
+    };
+    cache.set(key, entry);
+    return entry.promise;
+  }
+  function clear() {
+    cache.clear();
+  }
+  function size() {
+    return cache.size;
+  }
+  return {
+    getCacheKey,
+    dedupe,
+    clear,
+    size
+  };
+}
+
+// ../blocks/src/system/runtime/api/requestBody.ts
+function omitUndefinedOverrides(overrides) {
+  return Object.fromEntries(
+    Object.entries(overrides).filter(([, value]) => value !== void 0)
+  );
+}
+function withRequestOverrides(body, overrides) {
+  return {
+    ...body,
+    ...omitUndefinedOverrides(overrides)
+  };
+}
+
+// ../blocks/src/system/runtime/api/endpoints.ts
+function buildPath(template, params) {
+  let path = template;
+  for (const [key, value] of Object.entries(params)) {
+    path = path.replace(`{${key}}`, encodeURIComponent(value));
+  }
+  return path;
+}
+function appendQuery(path, params) {
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== null) {
+      searchParams.append(key, String(value));
+    }
+  }
+  const queryString = searchParams.toString();
+  if (!queryString) return path;
+  return `${path}?${queryString}`;
+}
+var FORMS = {
+  submit: {
+    path: "/forms/submit",
+    method: "POST"
+  },
+  get: {
+    path: "/public/forms/{formId}",
+    method: "GET"
+  }
+};
+var BOOKINGS = {
+  createAppointment: {
+    path: "/public/bookings/appointments",
+    method: "POST"
+  },
+  createAppointmentWithPackage: {
+    path: "/public/bookings/me/appointments",
+    method: "POST",
+    authScope: "portal"
+  },
+  getEligibleAppointmentPackages: {
+    path: "/public/bookings/me/appointments/packages",
+    method: "GET",
+    authScope: "portal"
+  },
+  appointmentStatus: {
+    path: "/public/sites/{siteId}/bookings/appointments/status",
+    method: "GET"
+  },
+  getAvailableSlots: {
+    path: "/public/bookings/availability/slots",
+    method: "GET"
+  },
+  getAvailableDates: {
+    path: "/public/bookings/availability/dates",
+    method: "GET"
+  },
+  getServices: {
+    path: "/public/bookings/services",
+    method: "GET"
+  },
+  getService: {
+    path: "/public/bookings/services/{serviceId}",
+    method: "GET"
+  },
+  getResources: {
+    path: "/public/bookings/resources/reference",
+    method: "GET"
+  }
+};
+var EVENTS = {
+  list: {
+    path: "/public/sites/{siteId}/events",
+    method: "GET"
+  },
+  filters: {
+    path: "/public/sites/{siteId}/events/filters",
+    method: "GET"
+  },
+  register: {
+    path: "/public/sites/{siteId}/events/register",
+    method: "POST",
+    authScope: "portal"
+  },
+  checkout: {
+    path: "/public/sites/{siteId}/events/checkout",
+    method: "POST"
+  },
+  checkEligibility: {
+    path: "/public/sites/{siteId}/events/check-eligibility",
+    method: "POST",
+    authScope: "portal"
+  },
+  registrationStatus: {
+    path: "/public/sites/{siteId}/events/registration-status",
+    method: "GET"
+  }
+};
+var COURSES = {
+  enroll: {
+    path: "/public/sites/{siteId}/courses/enroll",
+    method: "POST",
+    authScope: "portal"
+  },
+  checkout: {
+    path: "/public/sites/{siteId}/courses/checkout",
+    method: "POST",
+    authScope: "portal"
+  },
+  checkEligibility: {
+    path: "/public/sites/{siteId}/courses/check-eligibility",
+    method: "POST",
+    authScope: "portal"
+  },
+  waitlistClaimResolve: {
+    path: "/public/sites/{siteId}/waitlists/claim/resolve",
+    method: "POST",
+    authScope: "portal"
+  },
+  registrationStatus: {
+    path: "/public/sites/{siteId}/courses/registration-status",
+    method: "GET",
+    authScope: "portal"
+  }
+};
+var SHOP = {
+  listProducts: {
+    path: "/public/sites/{siteId}/products",
+    method: "GET"
+  },
+  checkout: {
+    path: "/public/sites/{siteId}/bookings/checkout",
+    method: "POST"
+  },
+  unifiedCheckout: {
+    path: "/public/sites/{siteId}/checkout",
+    method: "POST"
+  }
+};
+var GIFTING = {
+  offers: {
+    path: "/public/sites/{siteId}/gifting/offers",
+    method: "GET"
+  },
+  checkout: {
+    path: "/public/sites/{siteId}/gifting/checkout",
+    method: "POST"
+  },
+  claim: {
+    path: "/public/sites/{siteId}/gifting/claim",
+    method: "POST"
+  }
+};
+var DISCOUNTS = {
+  available: {
+    path: "/public/sites/{siteId}/bookings/discounts/available",
+    method: "POST"
+  }
+};
+var NEWSLETTER = {
+  subscribe: {
+    path: "/public/sites/{siteId}/newsletter/subscribe",
+    method: "POST"
+  }
+};
+var PORTAL = {
+  getProfile: {
+    path: "/portal/me",
+    method: "GET",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  getCredit: {
+    path: "/portal/credit",
+    method: "GET",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  getOrders: {
+    path: "/portal/orders",
+    method: "GET",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  createOrderCheckout: {
+    path: "/portal/orders/{orderId}/checkout",
+    method: "POST",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  getDigitalProducts: {
+    path: "/portal/digital-products",
+    method: "GET",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  getDigitalProduct: {
+    path: "/portal/digital-products/{entitlementId}",
+    method: "GET",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  resendDigitalProduct: {
+    path: "/portal/digital-products/{entitlementId}/resend",
+    method: "POST",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  getDigitalProductDownloadUrl: {
+    path: "/portal/digital-products/{entitlementId}/files/{assetId}/download-url",
+    method: "GET",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  updateProfile: {
+    path: "/portal/me",
+    method: "PATCH",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  getPasses: {
+    path: "/portal/passes",
+    method: "GET",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  getMemberships: {
+    path: "/portal/memberships",
+    method: "GET",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  getEvents: {
+    path: "/portal/events",
+    method: "GET",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  getEventTicket: {
+    path: "/portal/events/{registrationId}/ticket",
+    method: "GET",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  getEventBookingQuestions: {
+    path: "/portal/events/{registrationId}/booking-questions",
+    method: "GET",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  updateEventBookingQuestions: {
+    path: "/portal/events/{registrationId}/booking-questions",
+    method: "PUT",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  getAppointments: {
+    path: "/portal/appointments",
+    method: "GET",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  getAppointmentBookingQuestions: {
+    path: "/portal/appointments/{appointmentId}/booking-questions",
+    method: "GET",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  updateAppointmentBookingQuestions: {
+    path: "/portal/appointments/{appointmentId}/booking-questions",
+    method: "PUT",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  getCourses: {
+    path: "/portal/courses",
+    method: "GET",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  getCourseBookingQuestions: {
+    path: "/portal/courses/{enrollmentId}/booking-questions",
+    method: "GET",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  updateCourseBookingQuestions: {
+    path: "/portal/courses/{enrollmentId}/booking-questions",
+    method: "PUT",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  cancelCourseEnrollment: {
+    path: "/portal/courses/{enrollmentId}/cancel",
+    method: "POST",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  cancelAppointment: {
+    path: "/portal/appointments/{appointmentId}/cancel",
+    method: "POST",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  rescheduleAppointment: {
+    path: "/portal/appointments/{appointmentId}/reschedule",
+    method: "POST",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  cancelEventRegistration: {
+    path: "/portal/events/{registrationId}/cancel",
+    method: "POST",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  getEventGuests: {
+    path: "/portal/events/{registrationId}/guests",
+    method: "GET",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  updateEventGuests: {
+    path: "/portal/events/{registrationId}/guests",
+    method: "PUT",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  transferEventRegistration: {
+    path: "/portal/events/{registrationId}/transfer",
+    method: "POST",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  cancelMembershipAtPeriodEnd: {
+    path: "/portal/memberships/{customerMembershipId}/cancel",
+    method: "POST",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  sendMagicLink: {
+    path: "/portal/auth/send-magic-link",
+    method: "POST",
+    authScope: "portal",
+    skipPreviewStage: true
+  },
+  logout: {
+    path: "/portal/auth/logout",
+    method: "POST",
+    authScope: "portal",
+    skipPreviewStage: true
+  }
+};
+
+// ../blocks/src/system/runtime/api/client.ts
+function encodePublicProductCategorySelector(selector) {
+  if (!selector) {
+    return {};
+  }
+  switch (selector.kind) {
+    case "category":
+      return {
+        productCategoryScope: "category",
+        productCategoryId: selector.productCategoryId
+      };
+    case "current-category-page":
+      if (selector.productCategoryEntryId.trim().length === 0) {
+        return {};
+      }
+      return {
+        productCategoryScope: "current-category-page",
+        productCategoryEntryId: selector.productCategoryEntryId
+      };
+  }
+}
+var BlockApiError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "BlockApiError";
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isJsonResponseContentType(contentType) {
+  if (!contentType) return false;
+  const mimeType = contentType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+  return mimeType === "application/json" || mimeType.endsWith("+json");
+}
+function getResponseContentType(response) {
+  return response.headers.get("content-type");
+}
+async function parseJsonBody(response) {
+  const rawText = await response.text();
+  if (rawText.trim().length === 0) {
+    return { kind: "empty-body" };
+  }
+  try {
+    return { kind: "success", value: JSON.parse(rawText) };
+  } catch {
+    return { kind: "invalid-json" };
+  }
+}
+function getBlockApiErrorDetails(data) {
+  if (!isRecord(data)) {
+    return {};
+  }
+  const nestedError = isRecord(data.error) ? data.error : void 0;
+  const message = typeof nestedError?.message === "string" ? nestedError.message : typeof data.message === "string" ? data.message : void 0;
+  const code = typeof nestedError?.code === "string" ? nestedError.code : typeof data.code === "string" ? data.code : void 0;
+  return { message, code };
+}
+function buildUnexpectedJsonResponseMessage(parseResult) {
+  switch (parseResult.kind) {
+    case "empty-body":
+      return "Expected JSON response body but received an empty response";
+    case "invalid-json":
+      return "Expected JSON response but received invalid JSON";
+  }
+}
+async function extractErrorDetails(response) {
+  const contentType = getResponseContentType(response);
+  const fallbackMessage = `Request failed: ${response.statusText}`;
+  if (!isJsonResponseContentType(contentType)) {
+    return {
+      message: `${fallbackMessage} (received ${contentType ?? "unknown content type"})`
+    };
+  }
+  const parseResult = await parseJsonBody(response);
+  switch (parseResult.kind) {
+    case "success": {
+      const details = getBlockApiErrorDetails(parseResult.value);
+      return {
+        message: details.message ?? fallbackMessage,
+        code: details.code
+      };
+    }
+    case "invalid-json":
+      return {
+        message: `${fallbackMessage} (received invalid JSON)`
+      };
+    case "empty-body":
+      return {
+        message: `${fallbackMessage} (received an empty response)`
+      };
+  }
+}
+async function parseJsonApiResponse(response) {
+  if (response.status === 204 || response.status === 205) {
+    return void 0;
+  }
+  const contentType = getResponseContentType(response);
+  if (!isJsonResponseContentType(contentType)) {
+    throw new BlockApiError(
+      `Expected JSON response but received ${contentType ?? "unknown content type"}`,
+      response.status
+    );
+  }
+  const parseResult = await parseJsonBody(response);
+  if (parseResult.kind !== "success") {
+    throw new BlockApiError(
+      buildUnexpectedJsonResponseMessage(parseResult),
+      response.status
+    );
+  }
+  return parseResult.value;
+}
+function getAuthHeaders(auth) {
+  switch (auth.type) {
+    case "api-key":
+      return { Authorization: `Bearer ${auth.key}` };
+    case "bearer":
+      return { Authorization: `Bearer ${auth.token}` };
+    case "none":
+      return {};
+  }
+}
+function isApiSuccessResponse(json) {
+  return json !== null && typeof json === "object" && "success" in json && json.success === true && "data" in json;
+}
+function createBlockApi(config) {
+  const { baseUrl, auth, authOverrides, siteId, isPreview } = config;
+  const dedup = createDeduplicationCache({ ttl: 100 });
+  const shouldUsePreviewStageForNonPortalRequests = isPreview && auth.type !== "none";
+  function isPortalEndpoint(endpoint) {
+    return endpoint.skipPreviewStage === true;
+  }
+  function selectAuth(endpoint) {
+    if (endpoint.authScope === "portal" && authOverrides?.portal) {
+      return authOverrides.portal;
+    }
+    return auth;
+  }
+  async function request(endpoint, options) {
+    const { path, body, query, skipDedup = false } = options ?? {};
+    const resolvedPath = path ?? endpoint.path;
+    let url = `${baseUrl}${resolvedPath}`;
+    const selectedAuth = selectAuth(endpoint);
+    const queryParams = { ...query };
+    if (shouldUsePreviewStageForNonPortalRequests && !isPortalEndpoint(endpoint) && (queryParams.stage === void 0 || queryParams.stage === null)) {
+      queryParams.stage = "preview";
+    }
+    if (Object.keys(queryParams).length > 0) {
+      url = appendQuery(url, queryParams);
+    }
+    const authHeaders = getAuthHeaders(selectedAuth);
+    const headers = {
+      Accept: "application/json",
+      ...authHeaders
+    };
+    if (body !== void 0) {
+      headers["Content-Type"] = "application/json";
+    }
+    const fetchOptions = {
+      method: endpoint.method,
+      headers
+    };
+    if (body !== void 0) {
+      fetchOptions.body = JSON.stringify(body);
+    }
+    const doFetch = async () => {
+      const response = await fetch(url, fetchOptions);
+      if (!response.ok) {
+        const details = await extractErrorDetails(response);
+        throw new BlockApiError(details.message, response.status, details.code);
+      }
+      const json = await parseJsonApiResponse(response);
+      if (isApiSuccessResponse(json)) {
+        return json.data;
+      }
+      return json;
+    };
+    if (endpoint.method === "GET" && !skipDedup) {
+      const cacheKey = dedup.getCacheKey(endpoint.method, url, void 0);
+      return dedup.dedupe(cacheKey, doFetch);
+    }
+    return doFetch();
+  }
+  function requireSiteId() {
+    if (!siteId) {
+      throw new BlockApiError("siteId is required for this operation", 400);
+    }
+    return siteId;
+  }
+  return {
+    config,
+    // Forms
+    async submitForm(data) {
+      return request(FORMS.submit, { body: data });
+    },
+    async getForm(formId, formSiteId) {
+      const sid = formSiteId ?? siteId;
+      const path = buildPath(FORMS.get.path, { formId });
+      return request(FORMS.get, { path, query: sid ? { siteId: sid } : void 0 });
+    },
+    // Bookings
+    async submitBooking(data) {
+      return request(BOOKINGS.createAppointment, { body: data });
+    },
+    async submitBookingWithPackage(data) {
+      return request(BOOKINGS.createAppointmentWithPackage, { body: data });
+    },
+    async getEligibleAppointmentPackages(params) {
+      return request(BOOKINGS.getEligibleAppointmentPackages, {
+        query: { serviceId: params.serviceId }
+      });
+    },
+    async getAppointmentBookingStatus(params) {
+      const sid = requireSiteId();
+      const path = buildPath(BOOKINGS.appointmentStatus.path, { siteId: sid });
+      return request(BOOKINGS.appointmentStatus, {
+        path,
+        query: { sessionId: params.sessionId },
+        skipDedup: true
+      });
+    },
+    async getAvailableSlots(params) {
+      const sid = requireSiteId();
+      return request(BOOKINGS.getAvailableSlots, {
+        query: {
+          siteId: sid,
+          serviceId: params.serviceId,
+          startDate: params.startDate,
+          endDate: params.endDate,
+          timezone: params.timezone,
+          resourceId: params.resourceId
+        }
+      });
+    },
+    async getAvailableDates(params) {
+      const sid = requireSiteId();
+      return request(BOOKINGS.getAvailableDates, {
+        query: {
+          siteId: sid,
+          serviceId: params.serviceId,
+          startDate: params.startDate,
+          endDate: params.endDate,
+          timezone: params.timezone,
+          resourceId: params.resourceId
+        }
+      });
+    },
+    async getBookingServices(params) {
+      const sid = requireSiteId();
+      return request(BOOKINGS.getServices, {
+        query: {
+          siteId: sid,
+          ids: params?.ids?.join(",")
+        }
+      });
+    },
+    async getBookingService(serviceId) {
+      const sid = requireSiteId();
+      const path = buildPath(BOOKINGS.getService.path, { serviceId });
+      return request(BOOKINGS.getService, { path, query: { siteId: sid } });
+    },
+    async getBookingResources(params) {
+      const sid = requireSiteId();
+      return request(BOOKINGS.getResources, {
+        query: { siteId: sid, serviceId: params.serviceId }
+      });
+    },
+    // Events
+    async getPublicEvents(params) {
+      const sid = requireSiteId();
+      const path = buildPath(EVENTS.list.path, { siteId: sid });
+      return request(EVENTS.list, {
+        path,
+        query: {
+          from: params?.from,
+          to: params?.to,
+          afterStartsAt: params?.afterStartsAt,
+          afterId: params?.afterId,
+          limit: params?.limit,
+          stage: params?.stage,
+          kind: params?.kind,
+          eventSurface: params?.eventSurface,
+          eventPresets: params?.eventPresets,
+          scheduleScope: params?.scheduleScope,
+          categoryIds: params?.categoryIds,
+          venueId: params?.venueId,
+          staffMemberId: params?.staffMemberId,
+          entryId: params?.entryId,
+          seriesId: params?.seriesId,
+          includeOccurrenceId: params?.includeOccurrenceId,
+          detailLevel: params?.detailLevel
+        }
+      });
+    },
+    async getEventFilters(params) {
+      const sid = requireSiteId();
+      const path = buildPath(EVENTS.filters.path, { siteId: sid });
+      return request(EVENTS.filters, {
+        path,
+        query: {
+          categoryIds: params?.categoryIds,
+          venueId: params?.venueId,
+          staffMemberId: params?.staffMemberId,
+          kind: params?.kind,
+          eventSurface: params?.eventSurface,
+          eventPresets: params?.eventPresets,
+          scheduleScope: params?.scheduleScope
+        }
+      });
+    },
+    async registerForEvent(data) {
+      const sid = requireSiteId();
+      const path = buildPath(EVENTS.register.path, { siteId: sid });
+      return request(EVENTS.register, {
+        path,
+        body: withRequestOverrides(
+          data,
+          shouldUsePreviewStageForNonPortalRequests ? { stage: "preview" } : {}
+        )
+      });
+    },
+    async createEventCheckout(data) {
+      const sid = requireSiteId();
+      const path = buildPath(EVENTS.checkout.path, { siteId: sid });
+      return request(EVENTS.checkout, { path, body: data });
+    },
+    async checkEligibility(data) {
+      const sid = requireSiteId();
+      const path = buildPath(EVENTS.checkEligibility.path, { siteId: sid });
+      return request(EVENTS.checkEligibility, {
+        path,
+        body: data
+      });
+    },
+    async getEventRegistrationStatus(params) {
+      const sid = requireSiteId();
+      const path = buildPath(EVENTS.registrationStatus.path, { siteId: sid });
+      return request(EVENTS.registrationStatus, {
+        path,
+        query: { attendeeId: params.attendeeId },
+        skipDedup: true
+        // Always fetch fresh status
+      });
+    },
+    // Courses
+    async enrollInCourse(data) {
+      const sid = requireSiteId();
+      const path = buildPath(COURSES.enroll.path, { siteId: sid });
+      return request(COURSES.enroll, {
+        path,
+        body: withRequestOverrides(
+          data,
+          shouldUsePreviewStageForNonPortalRequests ? { stage: "preview" } : {}
+        )
+      });
+    },
+    async checkCourseEligibility(data) {
+      const sid = requireSiteId();
+      const path = buildPath(COURSES.checkEligibility.path, { siteId: sid });
+      return request(COURSES.checkEligibility, {
+        path,
+        body: data
+      });
+    },
+    async resolveWaitlistClaim(data) {
+      const sid = requireSiteId();
+      const path = buildPath(COURSES.waitlistClaimResolve.path, { siteId: sid });
+      return request(COURSES.waitlistClaimResolve, {
+        path,
+        body: {
+          claimToken: data.claimToken
+        }
+      });
+    },
+    async createCourseCheckout(data) {
+      const sid = requireSiteId();
+      const path = buildPath(COURSES.checkout.path, { siteId: sid });
+      return request(COURSES.checkout, {
+        path,
+        body: {
+          courseId: data.courseId,
+          ...data.pricingOptionId ? { pricingOptionId: data.pricingOptionId } : {},
+          email: data.email,
+          name: data.name,
+          phone: data.phone,
+          formData: data.formData,
+          altchaSolution: data.altchaSolution,
+          discountCode: data.discountCode,
+          successUrl: data.successUrl,
+          cancelUrl: data.cancelUrl,
+          claimToken: data.claimToken
+        }
+      });
+    },
+    async getCourseRegistrationStatus(params) {
+      const sid = requireSiteId();
+      const path = buildPath(COURSES.registrationStatus.path, { siteId: sid });
+      return request(COURSES.registrationStatus, {
+        path,
+        query: { sessionId: params.sessionId },
+        skipDedup: true
+      });
+    },
+    async getDiscountsAvailable(data) {
+      const sid = requireSiteId();
+      const path = buildPath(DISCOUNTS.available.path, { siteId: sid });
+      return request(DISCOUNTS.available, {
+        path,
+        body: { context: data.context, subtotalCents: data.subtotalCents }
+      });
+    },
+    // Shop
+    async getPublicProducts(params) {
+      const sid = requireSiteId();
+      const path = buildPath(SHOP.listProducts.path, { siteId: sid });
+      const query = encodePublicProductCategorySelector(params?.categorySelector);
+      return request(SHOP.listProducts, {
+        path,
+        query: Object.keys(query).length > 0 ? query : void 0
+      });
+    },
+    async createShopCheckout(data) {
+      const sid = requireSiteId();
+      const path = buildPath(SHOP.checkout.path, { siteId: sid });
+      return request(SHOP.checkout, {
+        path,
+        body: {
+          productType: data.productType,
+          productId: data.productId,
+          customerEmail: data.customerEmail,
+          customerName: data.customerName,
+          discountCode: data.discountCode,
+          successUrl: data.successUrl,
+          cancelUrl: data.cancelUrl,
+          confirmDuplicate: data.confirmDuplicate
+        }
+      });
+    },
+    async createUnifiedCheckout(data) {
+      const sid = requireSiteId();
+      const path = buildPath(SHOP.unifiedCheckout.path, { siteId: sid });
+      return request(SHOP.unifiedCheckout, {
+        path,
+        body: data
+      });
+    },
+    async getPublicGiftingOffers() {
+      const sid = requireSiteId();
+      const path = buildPath(GIFTING.offers.path, { siteId: sid });
+      return request(GIFTING.offers, { path });
+    },
+    async createGiftingCheckout(data) {
+      const sid = requireSiteId();
+      const path = buildPath(GIFTING.checkout.path, { siteId: sid });
+      return request(GIFTING.checkout, {
+        path,
+        body: data
+      });
+    },
+    async claimGiftCard(data) {
+      const sid = requireSiteId();
+      const path = buildPath(GIFTING.claim.path, { siteId: sid });
+      return request(GIFTING.claim, {
+        path,
+        body: data
+      });
+    },
+    // Newsletter
+    async subscribeNewsletter(data) {
+      const sid = requireSiteId();
+      const path = buildPath(NEWSLETTER.subscribe.path, { siteId: sid });
+      return request(NEWSLETTER.subscribe, {
+        path,
+        body: {
+          email: data.email,
+          firstName: data.firstName,
+          lastName: data.lastName,
+          name: data.name,
+          company: data.company,
+          phone: data.phone,
+          listId: data.listId,
+          tags: data.tags,
+          blockId: data.blockId,
+          meta: data.meta
+        }
+      });
+    },
+    // Portal
+    async getPortalProfile() {
+      return request(PORTAL.getProfile);
+    },
+    async getPortalCredit() {
+      const result = await request(PORTAL.getCredit);
+      return result.credit;
+    },
+    async getPortalOrders() {
+      const result = await request(PORTAL.getOrders);
+      return result.orders;
+    },
+    async createPortalOrderCheckout(orderId, data) {
+      const path = buildPath(PORTAL.createOrderCheckout.path, { orderId });
+      return request(PORTAL.createOrderCheckout, {
+        path,
+        body: data
+      });
+    },
+    async getPortalDigitalProducts() {
+      return request(PORTAL.getDigitalProducts);
+    },
+    async getPortalDigitalProduct(entitlementId) {
+      const path = buildPath(PORTAL.getDigitalProduct.path, { entitlementId });
+      return request(PORTAL.getDigitalProduct, { path });
+    },
+    async resendPortalDigitalProduct(entitlementId) {
+      const path = buildPath(PORTAL.resendDigitalProduct.path, { entitlementId });
+      await request(PORTAL.resendDigitalProduct, { path });
+    },
+    async getPortalDigitalProductDownloadUrl(entitlementId, assetId) {
+      const path = buildPath(PORTAL.getDigitalProductDownloadUrl.path, {
+        entitlementId,
+        assetId
+      });
+      return request(PORTAL.getDigitalProductDownloadUrl, {
+        path
+      });
+    },
+    async updatePortalProfile(data) {
+      const result = await request(PORTAL.updateProfile, {
+        body: data
+      });
+      return result.profile;
+    },
+    async getPortalPasses() {
+      const result = await request(PORTAL.getPasses);
+      return result.passes;
+    },
+    async getPortalMemberships() {
+      const result = await request(PORTAL.getMemberships);
+      return result.memberships;
+    },
+    async getPortalEvents(params) {
+      const result = await request(PORTAL.getEvents, {
+        query: params?.occurrenceId ? { occurrenceId: params.occurrenceId } : void 0
+      });
+      return result.registrations;
+    },
+    async getPortalEventTicket(registrationId) {
+      const path = buildPath(PORTAL.getEventTicket.path, { registrationId });
+      const result = await request(PORTAL.getEventTicket, { path });
+      return result.ticket;
+    },
+    async getPortalAppointments() {
+      const result = await request(PORTAL.getAppointments);
+      return result.appointments;
+    },
+    async getPortalAppointmentBookingQuestions(appointmentId) {
+      const path = buildPath(PORTAL.getAppointmentBookingQuestions.path, {
+        appointmentId
+      });
+      const result = await request(
+        PORTAL.getAppointmentBookingQuestions,
+        { path }
+      );
+      return result.task;
+    },
+    async updatePortalAppointmentBookingQuestions(appointmentId, data) {
+      const path = buildPath(PORTAL.updateAppointmentBookingQuestions.path, {
+        appointmentId
+      });
+      const result = await request(
+        PORTAL.updateAppointmentBookingQuestions,
+        { path, body: data }
+      );
+      return result.task;
+    },
+    async getPortalEventBookingQuestions(registrationId) {
+      const path = buildPath(PORTAL.getEventBookingQuestions.path, {
+        registrationId
+      });
+      const result = await request(
+        PORTAL.getEventBookingQuestions,
+        { path }
+      );
+      return result.task;
+    },
+    async updatePortalEventBookingQuestions(registrationId, data) {
+      const path = buildPath(PORTAL.updateEventBookingQuestions.path, {
+        registrationId
+      });
+      const result = await request(
+        PORTAL.updateEventBookingQuestions,
+        { path, body: data }
+      );
+      return result.task;
+    },
+    async getPortalCourses() {
+      const result = await request(PORTAL.getCourses);
+      return result.enrollments;
+    },
+    async getPortalCourseBookingQuestions(enrollmentId) {
+      const path = buildPath(PORTAL.getCourseBookingQuestions.path, {
+        enrollmentId
+      });
+      const result = await request(
+        PORTAL.getCourseBookingQuestions,
+        { path }
+      );
+      return result.task;
+    },
+    async updatePortalCourseBookingQuestions(enrollmentId, data) {
+      const path = buildPath(PORTAL.updateCourseBookingQuestions.path, {
+        enrollmentId
+      });
+      const result = await request(
+        PORTAL.updateCourseBookingQuestions,
+        { path, body: data }
+      );
+      return result.task;
+    },
+    async cancelCourseEnrollment(enrollmentId, options) {
+      const path = buildPath(PORTAL.cancelCourseEnrollment.path, { enrollmentId });
+      const result = await request(
+        PORTAL.cancelCourseEnrollment,
+        { path, body: options ?? {} }
+      );
+      return result.result;
+    },
+    async cancelAppointment(appointmentId, options) {
+      const path = buildPath(PORTAL.cancelAppointment.path, { appointmentId });
+      const result = await request(
+        PORTAL.cancelAppointment,
+        { path, body: options ?? {} }
+      );
+      return result.result;
+    },
+    async rescheduleAppointment(appointmentId, data) {
+      const path = buildPath(PORTAL.rescheduleAppointment.path, { appointmentId });
+      return request(PORTAL.rescheduleAppointment, {
+        path,
+        body: data
+      });
+    },
+    async cancelEventRegistration(registrationId, options) {
+      const path = buildPath(PORTAL.cancelEventRegistration.path, { registrationId });
+      const result = await request(
+        PORTAL.cancelEventRegistration,
+        {
+          path,
+          body: options ?? {}
+        }
+      );
+      return result.result;
+    },
+    async transferEventRegistration(registrationId, data) {
+      const path = buildPath(PORTAL.transferEventRegistration.path, { registrationId });
+      const result = await request(
+        PORTAL.transferEventRegistration,
+        { path, body: data }
+      );
+      return result.result;
+    },
+    async cancelMembershipAtPeriodEnd(customerMembershipId) {
+      const path = buildPath(PORTAL.cancelMembershipAtPeriodEnd.path, { customerMembershipId });
+      const result = await request(
+        PORTAL.cancelMembershipAtPeriodEnd,
+        { path, body: {} }
+      );
+      return result.result;
+    },
+    async getEventGuests(registrationId) {
+      const path = buildPath(PORTAL.getEventGuests.path, { registrationId });
+      const result = await request(PORTAL.getEventGuests, { path });
+      return result.guests;
+    },
+    async updateEventGuests(registrationId, data) {
+      const path = buildPath(PORTAL.updateEventGuests.path, { registrationId });
+      const result = await request(PORTAL.updateEventGuests, {
+        path,
+        body: data
+      });
+      return result.guests;
+    },
+    async sendMagicLink(data) {
+      const sid = requireSiteId();
+      await request(PORTAL.sendMagicLink, {
+        body: {
+          siteId: sid,
+          email: data.email,
+          redirectUrl: data.redirectUrl
+        }
+      });
+    },
+    async logout() {
+      await request(PORTAL.logout);
+    }
+  };
+}
+function getGlobalContext() {
+  if (!globalThis.__RIVERBANK_BLOCK_API_CONTEXT__) {
+    globalThis.__RIVERBANK_BLOCK_API_CONTEXT__ = createContext(null);
+  }
+  return globalThis.__RIVERBANK_BLOCK_API_CONTEXT__;
+}
+var BlockApiContext = getGlobalContext();
+function BlockApiProvider({
+  client,
+  config,
+  children
+}) {
+  const apiClient = useMemo(() => {
+    if (client) return client;
+    if (config) return createBlockApi(config);
+    throw new Error("BlockApiProvider requires either client or config prop");
+  }, [client, config]);
+  return /* @__PURE__ */ jsx(BlockApiContext.Provider, { value: apiClient, children });
+}
+function useBlockApi() {
+  const client = useContext(BlockApiContext);
+  if (!client) {
+    throw new Error(
+      "useBlockApi must be used within a BlockApiProvider. Make sure your component is wrapped with <BlockApiProvider>."
+    );
+  }
+  return client;
+}
+function joinClasses(...parts) {
+  return parts.filter((part) => typeof part === "string" && part.length > 0).join(" ");
+}
+function FeedbackMessage({
+  tone,
+  children,
+  className,
+  title,
+  titleClassName,
+  bodyClassName,
+  role = "status",
+  live
+}) {
+  const resolvedLive = live ?? (role === "alert" ? "assertive" : "polite");
+  const shouldWrapBody = Boolean(title || bodyClassName);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className,
+      "data-feedback-tone": tone,
+      role,
+      "aria-live": resolvedLive === "off" ? void 0 : resolvedLive,
+      children: [
+        title ? /* @__PURE__ */ jsx("p", { className: joinClasses(titleClassName), "data-feedback-title": true, children: title }) : null,
+        shouldWrapBody ? /* @__PURE__ */ jsx("div", { className: joinClasses(bodyClassName), "data-feedback-body": true, children }) : children
+      ]
+    }
+  );
+}
+
+export { BlockApiError, BlockApiProvider, FeedbackMessage, useBlockApi };