@riverbankcms/sdk 0.85.0 → 0.89.1

package/dist/client/chunk-RSQWWUAD.mjs

@@ -0,0 +1,390 @@
+"use client";
+import { useBlockApi } from './chunk-STJ2NCQM.mjs';
+import { themeButtonClassName, assertNever11 } from './chunk-UQFY4AHX.mjs';
+import { resolvePlanningDateInput, formatBookingPriceDisplay } from './chunk-25W2EQUN.mjs';
+import { useState, useReducer, useSyncExternalStore, useEffect } from 'react';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+// ../blocks/src/system/runtime/nodes/shared/MagicLinkForm.state.ts
+var initialMagicLinkSubmissionState = Object.freeze({
+  tag: "idle"
+});
+function magicLinkSubmissionReducer(state, action) {
+  switch (action.type) {
+    case "submit-started":
+      if (state.tag === "submitting") {
+        return state;
+      }
+      return { tag: "submitting" };
+    case "submit-succeeded":
+      if (state.tag !== "submitting") {
+        return state;
+      }
+      return { tag: "success" };
+    case "submit-failed":
+      if (state.tag !== "submitting") {
+        return state;
+      }
+      return {
+        tag: "error",
+        message: action.message
+      };
+    case "reset":
+      return initialMagicLinkSubmissionState;
+    default:
+      return assertNever11(action);
+  }
+}
+function isMagicLinkSubmitting(state) {
+  return state.tag === "submitting";
+}
+function getMagicLinkError(state) {
+  return state.tag === "error" ? state.message : null;
+}
+function MagicLinkForm({
+  initialEmail = "",
+  title,
+  subtitle,
+  buttonText = "Send login link",
+  successMessage = "Check your email for a login link to sign in.",
+  onSuccess,
+  classPrefix = "er",
+  compact = false
+}) {
+  const api = useBlockApi();
+  const [email, setEmail] = useState(initialEmail);
+  const [submissionState, dispatchSubmission] = useReducer(
+    magicLinkSubmissionReducer,
+    initialMagicLinkSubmissionState
+  );
+  const loading = isMagicLinkSubmitting(submissionState);
+  const error = getMagicLinkError(submissionState);
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    const normalizedEmail = email.trim().toLowerCase();
+    if (!normalizedEmail || loading) return;
+    dispatchSubmission({ type: "submit-started" });
+    try {
+      const redirectTo = `${window.location.pathname}${window.location.search}${window.location.hash}`;
+      await api.sendMagicLink({
+        email: normalizedEmail,
+        redirectUrl: `${window.location.origin}/api/portal/callback?redirect_to=${encodeURIComponent(redirectTo)}`
+      });
+      dispatchSubmission({ type: "submit-succeeded" });
+      onSuccess?.();
+    } catch (err) {
+      console.error("Magic link error:", err);
+      dispatchSubmission({
+        type: "submit-failed",
+        message: getMagicLinkErrorMessage(err)
+      });
+    }
+  };
+  const handleReset = () => {
+    setEmail("");
+    dispatchSubmission({ type: "reset" });
+  };
+  if (submissionState.tag === "success") {
+    return /* @__PURE__ */ jsxs("div", { className: `${classPrefix}-magic-link-success`, children: [
+      /* @__PURE__ */ jsx("p", { className: `${classPrefix}-portal-auth-text ${classPrefix}-portal-auth-text--success`, children: successMessage }),
+      !compact && /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          className: classPrefix === "cp" ? themeButtonClassName({ variant: "secondary", size: "md" }) : `${classPrefix}-modal-btn ${classPrefix}-modal-btn--secondary`,
+          onClick: handleReset,
+          children: "Try a different email"
+        }
+      )
+    ] });
+  }
+  return /* @__PURE__ */ jsxs("form", { onSubmit: handleSubmit, className: `${classPrefix}-magic-link-form`, children: [
+    title && /* @__PURE__ */ jsx("h3", { className: `${classPrefix}-magic-link-title`, children: title }),
+    subtitle && /* @__PURE__ */ jsx("p", { className: `${classPrefix}-portal-auth-text`, children: subtitle }),
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        type: "email",
+        className: classPrefix === "cp" ? "cp-input" : `${classPrefix}-form__input`,
+        placeholder: "your@email.com",
+        value: email,
+        onChange: (e) => setEmail(e.target.value),
+        autoFocus: !compact,
+        required: true,
+        disabled: loading
+      }
+    ),
+    error && /* @__PURE__ */ jsx("p", { className: `${classPrefix}-portal-auth-text ${classPrefix}-portal-auth-text--error`, children: error }),
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "submit",
+        className: classPrefix === "cp" ? themeButtonClassName({ variant: "primary", size: "md" }) : `${classPrefix}-modal-btn`,
+        disabled: !email.trim() || loading,
+        children: loading ? "Sending..." : buttonText
+      }
+    )
+  ] });
+}
+function getMagicLinkErrorMessage(error) {
+  return error instanceof Error ? error.message : "Failed to send. Please try again.";
+}
+
+// ../blocks/src/system/blocks/courses/shared/pricing.ts
+function isSaleWindowOpen(option, now) {
+  if (!option.isActive) {
+    return false;
+  }
+  if (option.saleStartsAt && new Date(option.saleStartsAt) > now) {
+    return false;
+  }
+  if (option.saleEndsAt && new Date(option.saleEndsAt) < now) {
+    return false;
+  }
+  return true;
+}
+function toExactOrFreeDisplay(amount, currency) {
+  if (amount <= 0) {
+    return { kind: "free", currency };
+  }
+  return { kind: "exact", amount, currency };
+}
+function getSelectableCoursePricingOptionsForNow(course, now) {
+  if (!course.pricing || course.pricing.pricingStrategy !== "tiered") {
+    return [];
+  }
+  return [...course.pricing.options].filter((option) => isSaleWindowOpen(option, now)).sort((left, right) => {
+    if (left.sortOrder !== right.sortOrder) {
+      return left.sortOrder - right.sortOrder;
+    }
+    if (left.priceAmount !== right.priceAmount) {
+      return left.priceAmount - right.priceAmount;
+    }
+    return left.name.localeCompare(right.name);
+  });
+}
+function resolveCoursePricingState(course, selectedPricingOptionId, nowInput = {}) {
+  const currency = course.pricing?.currency ?? course.currency;
+  if (!course.pricing) {
+    const legacyAmount = course.priceCents ?? 0;
+    return {
+      currency,
+      display: toExactOrFreeDisplay(legacyAmount, currency),
+      selectableOptions: [],
+      requiresSelection: false,
+      selectedOption: null,
+      selectedPriceAmount: legacyAmount,
+      selectedRequiresPayment: legacyAmount > 0,
+      hasPaidSelection: legacyAmount > 0,
+      hasFreeSelection: legacyAmount <= 0
+    };
+  }
+  switch (course.pricing.pricingStrategy) {
+    case "free":
+      return {
+        currency,
+        display: { kind: "free", currency },
+        selectableOptions: [],
+        requiresSelection: false,
+        selectedOption: null,
+        selectedPriceAmount: 0,
+        selectedRequiresPayment: false,
+        hasPaidSelection: false,
+        hasFreeSelection: true
+      };
+    case "single": {
+      const amount = course.pricing.singlePriceAmount ?? 0;
+      return {
+        currency,
+        display: toExactOrFreeDisplay(amount, currency),
+        selectableOptions: [],
+        requiresSelection: false,
+        selectedOption: null,
+        selectedPriceAmount: amount,
+        selectedRequiresPayment: amount > 0,
+        hasPaidSelection: amount > 0,
+        hasFreeSelection: amount <= 0
+      };
+    }
+    case "tiered": {
+      const selectableOptions = getSelectableCoursePricingOptionsForNow(
+        course,
+        resolvePlanningDateInput(nowInput)
+      );
+      const selectedOption = (selectedPricingOptionId ? selectableOptions.find((option) => option.id === selectedPricingOptionId) : null) ?? (selectableOptions.length === 1 ? selectableOptions[0] ?? null : null);
+      const lowestAmount = selectableOptions.reduce((lowest, option) => {
+        if (lowest === null || option.priceAmount < lowest) {
+          return option.priceAmount;
+        }
+        return lowest;
+      }, null);
+      const display = lowestAmount === null ? { kind: "unavailable", currency } : selectableOptions.length > 1 && lowestAmount > 0 ? { kind: "from", amount: lowestAmount, currency } : toExactOrFreeDisplay(lowestAmount, currency);
+      return {
+        currency,
+        display,
+        selectableOptions,
+        requiresSelection: selectableOptions.length > 1,
+        selectedOption,
+        selectedPriceAmount: selectedOption?.priceAmount ?? null,
+        selectedRequiresPayment: (selectedOption?.priceAmount ?? 0) > 0,
+        hasPaidSelection: selectableOptions.some((option) => option.priceAmount > 0),
+        hasFreeSelection: selectableOptions.some((option) => option.priceAmount === 0)
+      };
+    }
+  }
+}
+function formatCoursePriceDisplay(display, locale) {
+  return formatBookingPriceDisplay(display, { decimals: "exact", locale });
+}
+function formatCoursePriceAmount(amount, currency, locale) {
+  return formatCoursePriceDisplay(
+    amount > 0 ? { kind: "exact", amount, currency } : { kind: "free", currency },
+    locale
+  );
+}
+
+// ../blocks/src/system/runtime/shared/useWaitlistClaim.state.ts
+var DEFAULT_WAITLIST_CLAIM_ERROR = "Failed to resolve waitlist claim";
+function createInitialWaitlistClaimState(hasToken) {
+  return hasToken ? { kind: "resolving" } : { kind: "idle" };
+}
+function waitlistClaimReducer(_state, action) {
+  switch (action.type) {
+    case "cleared":
+      return { kind: "idle" };
+    case "started":
+      return { kind: "resolving" };
+    case "resolved":
+      return { kind: "resolved", claim: action.claim };
+    case "failed":
+      return action.failure;
+  }
+}
+function toWaitlistClaimResolveFailure(error) {
+  const message = error instanceof Error ? error.message : DEFAULT_WAITLIST_CLAIM_ERROR;
+  if (isUnauthorizedBlockApiError(error)) {
+    return { kind: "portal-login-required", message };
+  }
+  return { kind: "error", message };
+}
+function isUnauthorizedBlockApiError(error) {
+  return error instanceof Error && error.name === "BlockApiError" && hasStatus(error) && error.status === 401;
+}
+function hasStatus(value) {
+  return typeof value === "object" && value !== null && "status" in value;
+}
+function getWaitlistClaim(state) {
+  return state.kind === "resolved" ? state.claim : null;
+}
+function getWaitlistClaimError(state) {
+  return state.kind === "error" ? state.message : null;
+}
+function getWaitlistClaimLoginMessage(state) {
+  return state.kind === "portal-login-required" ? state.message : null;
+}
+function requiresWaitlistClaimPortalLogin(state) {
+  return state.kind === "portal-login-required";
+}
+function isWaitlistClaimLoading(state) {
+  return state.kind === "resolving";
+}
+
+// ../blocks/src/system/runtime/shared/useWaitlistClaim.ts
+var WAITLIST_CLAIM_LOCATION_EVENT = "riverbank:waitlist-claim-location-change";
+var historyPatched = false;
+function emitWaitlistClaimLocationChange() {
+  if (typeof window === "undefined") return;
+  window.dispatchEvent(new Event(WAITLIST_CLAIM_LOCATION_EVENT));
+}
+function ensureWaitlistClaimLocationTracking() {
+  if (typeof window === "undefined" || historyPatched) {
+    return;
+  }
+  historyPatched = true;
+  const history = window.history;
+  if (history.__riverbankWaitlistClaimPatched__) {
+    return;
+  }
+  const wrapHistoryMethod = (method) => {
+    return function patched(...args) {
+      method.apply(this, args);
+      emitWaitlistClaimLocationChange();
+    };
+  };
+  try {
+    history.pushState = wrapHistoryMethod(history.pushState);
+    history.replaceState = wrapHistoryMethod(history.replaceState);
+    history.__riverbankWaitlistClaimPatched__ = true;
+  } catch {
+  }
+  window.addEventListener("popstate", emitWaitlistClaimLocationChange);
+}
+function getWaitlistClaimTokenFromUrl() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  const token = new URLSearchParams(window.location.search).get("waitlist_claim")?.trim() ?? "";
+  return token.length > 0 ? token : null;
+}
+function subscribeToWaitlistClaimToken(callback) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  ensureWaitlistClaimLocationTracking();
+  window.addEventListener(WAITLIST_CLAIM_LOCATION_EVENT, callback);
+  return () => {
+    window.removeEventListener(WAITLIST_CLAIM_LOCATION_EVENT, callback);
+  };
+}
+function getWaitlistClaimTokenSnapshot() {
+  return getWaitlistClaimTokenFromUrl();
+}
+function useWaitlistClaim() {
+  const api = useBlockApi();
+  const token = useSyncExternalStore(
+    subscribeToWaitlistClaimToken,
+    getWaitlistClaimTokenSnapshot,
+    () => null
+  );
+  const [state, dispatch] = useReducer(
+    waitlistClaimReducer,
+    Boolean(token),
+    createInitialWaitlistClaimState
+  );
+  useEffect(() => {
+    let cancelled = false;
+    async function resolveClaim() {
+      if (!token) {
+        dispatch({ type: "cleared" });
+        return;
+      }
+      dispatch({ type: "started" });
+      try {
+        const result = await api.resolveWaitlistClaim({ claimToken: token });
+        if (cancelled) return;
+        dispatch({ type: "resolved", claim: result });
+      } catch (claimError) {
+        if (cancelled) return;
+        dispatch({
+          type: "failed",
+          failure: toWaitlistClaimResolveFailure(claimError)
+        });
+      }
+    }
+    void resolveClaim();
+    return () => {
+      cancelled = true;
+    };
+  }, [api, token]);
+  return {
+    token,
+    claim: getWaitlistClaim(state),
+    error: getWaitlistClaimError(state),
+    loginMessage: getWaitlistClaimLoginMessage(state),
+    requiresPortalLogin: requiresWaitlistClaimPortalLogin(state),
+    isLoading: isWaitlistClaimLoading(state)
+  };
+}
+
+export { MagicLinkForm, formatCoursePriceAmount, formatCoursePriceDisplay, resolveCoursePricingState, useWaitlistClaim };

package/dist/client/{chunk-UDNSI5PY.mjs → chunk-STJ2NCQM.mjs}

@@ -915,9 +915,8 @@ function createBlockApi(config) {
           name: data.name,
           company: data.company,
           phone: data.phone,
-          listId: data.listId,
+          target: data.target,
           tags: data.tags,
-          blockId: data.blockId,
           meta: data.meta
         }
       });
@@ -1190,4 +1189,4 @@ function FeedbackMessage({
   );
 }
 
-export { BlockApiError, BlockApiProvider, FeedbackMessage, useBlockApi };
+export { BlockApiProvider, FeedbackMessage, useBlockApi };