@fanfare-io/fanfare-sdk-react 0.13.0 → 0.14.0

package/dist/components/checkout/checkout-processing-panel.d.ts

@@ -1,8 +1,8 @@
 import { CheckoutProcessingSlotProps } from '../widgets/experience-widget';
 import * as React from "react";
 /**
- * Default processing panel shown for the gap between a submitted reservation checkout and the
- * server's confirmation.
+ * Default processing panel shown for the gap between a submitted checkout and the server's
+ * confirmation.
  *
  * The consumer must not navigate away while the payment settles, so the wait is announced rather
  * than shown only as motion.

package/dist/components/checkout/index.d.ts

@@ -1,4 +1,3 @@
 export { CheckoutProcessingPanel } from './checkout-processing-panel';
 export { PaymentCollectionPanel } from './payment-collection-panel';
 export { ReceiptPanel } from './receipt-panel';
-export { ReservationCheckoutPanel } from './reservation-checkout-panel';

package/dist/components/checkout/payment-collection-panel.d.ts

@@ -1,8 +1,7 @@
 import { PaymentCollectionSlotProps } from '../widgets/experience-widget';
 import * as React from "react";
 /**
- * Default payment-collection panel for pre-auth distributions, rendered both when the consumer is
- * about to enter and when a failed authorization leaves a retry open.
+ * Default payment-collection panel for pre-auth entry/re-entry and grant-keyed at-end checkout.
  *
  * The hold amount is rendered from the view's own figure — the client never derives one.
  *
@@ -15,4 +14,4 @@ import * as React from "react";
  * minted across the whole flow. An ended view carries no pending action, so the retry mount reaches
  * none of this.
  */
-export declare function PaymentCollectionPanel({ preAuthAmount, preAuthCurrencyCode, savedPaymentMethods, paymentProvider, onEnter, isEntering, intent, pendingAction, onRetryPaymentConfig, ...slotProps }: PaymentCollectionSlotProps): React.ReactElement;
+export declare function PaymentCollectionPanel(props: PaymentCollectionSlotProps): React.ReactElement;

package/dist/components/checkout/stripe-card-field.d.ts

@@ -1,7 +1,7 @@
 import { StripeClientConfig } from './stripe-client';
 /**
  * The SDK's card-entry field: a Stripe Card Element and the controller that turns it into a
- * payment-method id. It knows nothing about reservations, pre-auth, or amounts.
+ * payment-method id. It knows nothing about settlement, pre-auth, or amounts.
  *
  * `@stripe/stripe-js` is a type-only dependency across the SDK, so no vendor bytes ship in any
  * chunk. This module is the one lazy split: it is reached only through a dynamic `import()` from

package/dist/components/checkout/stripe-client.d.ts

@@ -1,11 +1,18 @@
-import { ReservationPaymentAffordance } from '@fanfare-io/fanfare-sdk-core/experiences';
+import { SequenceView } from '@fanfare-io/fanfare-sdk-core/experiences';
 import { Stripe, StripeConstructor, StripeElementStyle } from '@stripe/stripe-js';
+/** How a granted win settles, as the granted views carry it. */
+type GrantedSettlement = Extract<SequenceView, {
+    phase: "granted";
+}>["settlement"];
 /**
  * The wire block a checkout-capable view carries, reached through the adapter's declared
  * dependency on `fanfare-sdk-core` rather than the contracts package: core re-exports the contract
- * types so adapter modules never resolve `@fanfare-io/fanfare-sdk-contracts` directly.
+ * types so adapter modules never resolve `@fanfare-io/fanfare-sdk-contracts` directly. Core names
+ * the shape only within the arms that carry it, so it is read back off one of them.
  */
-type PaymentProviderConfig = NonNullable<ReservationPaymentAffordance["paymentProvider"]>;
+type PaymentProviderConfig = NonNullable<Extract<GrantedSettlement, {
+    mode: "at_end";
+}>["paymentProvider"]>;
 declare global {
     interface Window {
         Stripe?: StripeConstructor;
@@ -62,8 +69,8 @@ export declare function deriveStripeCardStyle(root: HTMLElement): StripeElementS
  *
  * `null` means no usable Stripe client configuration reached this view. On a checkout-capable arm
  * that has exactly one cause — the configuration read failed — because the processor discriminator
- * is the `processor` field (reserved) or `checkoutMode` (enterable), never the presence of this
- * block. The condition is transient and retryable.
+ * is the settlement's `processor`/`mode` pair (granted) or `checkoutMode` (enterable), never the
+ * presence of this block. The condition is transient and retryable.
  */
 export declare function resolveStripeClientConfig(source: PaymentProviderConfig | undefined): StripeClientConfig | null;
 /** Test-only seam over every memo this module holds. Never exported from an adapter's public entry. */

package/dist/components/compositions/granted-panel.d.ts

@@ -3,9 +3,14 @@
  *
  * Shared granted composition for distribution modules. Renders the
  * winning-state panel: status badge, expiry countdown (or fallback message
- * when no expiry is known), and a checkout CTA. Used by queue / draw /
- * auction / timed-release modules — the JSX is structurally identical
- * across all four; only the i18n strings differ.
+ * when no expiry is known), and — only when the caller supplies a
+ * destination — a checkout CTA. Used by queue / draw / auction /
+ * timed-release modules — the JSX is structurally identical across all
+ * four; only the i18n strings differ.
+ *
+ * A granted frame with no `onCtaClick` renders no button: the grant is
+ * already settled where the consumer stands, so an inert affordance would
+ * promise a hand-off that does not exist.
  *
  *   <GrantedPanel
  *     label="Congratulations!"
@@ -24,9 +29,9 @@ import * as React from "react";
 export interface GrantedPanelProps {
     label: React.ReactNode;
     fallbackMessage: React.ReactNode;
-    ctaLabel: React.ReactNode;
+    ctaLabel?: React.ReactNode;
     expiresAt?: Date;
-    onCtaClick: () => void;
+    onCtaClick?: () => void;
     className?: string;
 }
 export declare function GrantedPanel({ label, fallbackMessage, ctaLabel, expiresAt, onCtaClick, className, }: GrantedPanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/widgets/experience-widget.d.ts

@@ -1,5 +1,6 @@
 import { BotMitigationState, RoutingChallenge } from '@fanfare-io/fanfare-sdk-core/challenges';
-import { CheckoutNextAction, CheckoutProcessor, FanfareCheckoutResult, JourneyHandle, JourneySnapshot, JourneyView, PaymentInput, PaymentMethodSummary, ReservationPaymentAffordance, SequenceView } from '@fanfare-io/fanfare-sdk-core/experiences';
+import { SDKEvents } from '@fanfare-io/fanfare-sdk-core/events';
+import { CheckoutNextAction, FanfareCheckoutResult, JourneyHandle, JourneySnapshot, JourneyView, PaymentInput, PaymentMethodSummary, SequenceView } from '@fanfare-io/fanfare-sdk-core/experiences';
 import { BrandTheme, WidgetVariant } from '../../theme';
 import { AuthInputMode } from '../auth/auth-input';
 import { OutcomeAction } from '../compositions/outcome-panel';
@@ -16,6 +17,8 @@ type ParticipatingSlotSequence = Extract<SequenceView, {
 type GrantedSlotSequence = Extract<SequenceView, {
     phase: "granted";
 }>;
+/** How a granted win settles: who consumes the grant, and whether money has already moved for it. */
+type GrantedSettlement = GrantedSlotSequence["settlement"];
 /** Props passed to slot render functions */
 export interface SlotProps {
     snapshot: JourneySnapshot | null;
@@ -60,22 +63,17 @@ export interface GrantedSlotProps extends SlotProps {
     grant?: string;
     expiresAt?: number;
 }
-export interface PaymentCollectionSlotProps extends SlotProps {
-    preAuthAmount: string;
-    preAuthCurrencyCode: string;
+interface PaymentCollectionBaseSlotProps extends SlotProps {
     savedPaymentMethods: PaymentMethodSummary[];
-    /** Rejects on a recoverable payment failure (e.g. a declined card) — the panel owns recovery UI for its own submit. */
+    /** Submits pre-auth entry or confirms at-end checkout; rejects when the panel should keep recovery UI mounted. */
     onEnter: (paymentInput: PaymentInput) => Promise<void>;
     isEntering: boolean;
-    /** "enter" collects payment before first entry; "reenter" collects payment to retry after a failed or expired authorization hold. */
-    intent: "enter" | "reenter";
     /**
-     * Client configuration for the processor authorizing this entry, as the server supplied it.
-     * Carried by the enterable arm only — a retry is offered from an ended view, which holds no
-     * configuration.
+     * Client configuration for the internal processor, as the server supplied it. Carried by the
+     * enterable pre-auth and granted at-end arms; an ended retry holds no configuration.
      */
     paymentProvider?: PaymentProviderConfig;
-    /** Present while the processor is waiting on an out-of-band action; re-submitting entry resolves it. */
+    /** Present while the internal processor is waiting on an out-of-band action. */
     pendingAction?: CheckoutNextAction;
     /**
      * Re-reads the consumer's journeys from the server so a provider configuration that was missing
@@ -84,35 +82,22 @@ export interface PaymentCollectionSlotProps extends SlotProps {
      */
     onRetryPaymentConfig?: () => Promise<void>;
 }
+export type PaymentCollectionSlotProps = PaymentCollectionBaseSlotProps & ({
+    intent: "checkout";
+    onResume: () => Promise<void>;
+} | {
+    intent: "enter" | "reenter";
+    preAuthAmount: string;
+    preAuthCurrencyCode: string;
+    onResume?: never;
+});
 /**
- * The processor's client configuration block, named through the affordance that carries it: core
- * re-exports the affordance but not the contract's own name for this shape.
+ * The processor's client configuration block, named through an arm that carries it: core names the
+ * shape only within those arms, not as a standalone export.
  */
-type PaymentProviderConfig = NonNullable<ReservationPaymentAffordance["paymentProvider"]>;
-export interface ReservationCheckoutSlotProps extends SlotProps {
-    reservation: {
-        token: string;
-        expiresAt: number;
-    };
-    savedPaymentMethods: PaymentMethodSummary[];
-    /** Which processor executes this reservation's payment leg; narrow before rendering processor-specific UI. */
-    processor: CheckoutProcessor;
-    /** Client configuration for the processor settling this reservation, as the server supplied it. */
-    paymentProvider?: PaymentProviderConfig;
-    /** Present while the processor is waiting on an out-of-band action; complete it, then call `onResume`. */
-    pendingAction?: CheckoutNextAction;
-    /** Rejects on a recoverable payment failure (e.g. a declined card) — the panel owns recovery UI for its own submit. */
-    onConfirm: (paymentInput: PaymentInput) => Promise<void>;
-    /** Re-submits the paused checkout after `pendingAction` has been completed. Idempotent server-side. */
-    onResume: () => Promise<void>;
-    isConfirming: boolean;
-    /**
-     * Re-reads the consumer's journeys from the server so a provider configuration that was missing
-     * or unreadable at render can arrive. This is the panel's only recovery when `paymentProvider` is
-     * absent — the value is a prop, so nothing the panel does to its own state can produce it.
-     */
-    onRetryPaymentConfig?: () => Promise<void>;
-}
+type PaymentProviderConfig = NonNullable<Extract<GrantedSettlement, {
+    mode: "at_end";
+}>["paymentProvider"]>;
 export type CheckoutProcessingSlotProps = SlotProps;
 /**
  * A Fanfare-managed payment is terminal: it produces a receipt, never an admission credential. The
@@ -164,13 +149,18 @@ export interface ExperienceWidgetSlots {
     participating?: (props: ParticipatingSlotProps) => React.ReactNode;
     granted?: (props: GrantedSlotProps) => React.ReactNode;
     paymentCollection?: (props: PaymentCollectionSlotProps) => React.ReactNode;
-    reservationCheckout?: (props: ReservationCheckoutSlotProps) => React.ReactNode;
+    /** Rendered by the at-end checkout surface while a collected payment is settling. */
     checkoutProcessing?: (props: CheckoutProcessingSlotProps) => React.ReactNode;
     receipt?: (props: ReceiptSlotProps) => React.ReactNode;
     expired?: (props: ExpiredSlotProps) => React.ReactNode;
     ended?: (props: EndedSlotProps) => React.ReactNode;
     error?: (props: ErrorSlotProps) => React.ReactNode;
 }
+/**
+ * Surface the widget is mounted on, named through the bus payload that carries it: core
+ * re-exports the event map but not the contract's own name for this shape.
+ */
+type BeaconPageType = SDKEvents["experience:widget-mounted"]["pageType"];
 /** Render props for full control */
 export interface ExperienceRenderProps {
     journey: JourneyHandle | null;
@@ -195,6 +185,11 @@ export interface ExperienceWidgetProps {
     variant?: WidgetVariant;
     /** Slots for targeted overrides */
     slots?: ExperienceWidgetSlots;
+    /**
+     * Surface this widget renders on, carried on the `experience:widget-mounted` announcement.
+     * Defaults to `embed`, the merchant-page case; Fanfare-hosted drop pages pass `hosted`.
+     */
+    pageType?: BeaconPageType;
     /** Render prop for full control (ignores slots if provided) */
     children?: (props: ExperienceRenderProps) => React.ReactNode;
     /** Checkout URL for granted state */
@@ -208,16 +203,14 @@ export interface ExperienceWidgetProps {
     onJourneyChange?: (snapshot: JourneySnapshot) => void;
     /** Called when the journey receives a grant */
     onGranted?: (grant: string) => void;
-    /** Called when a Fanfare-managed checkout completes (pre-auth capture or post-win reservation checkout) */
+    /** Called when a Fanfare-managed checkout completes */
     onFanfareCheckout?: (result: FanfareCheckoutResult) => void;
-    /** Called when the consumer wins a `post_win` distribution and must complete checkout before `expiresAt` */
-    onReserved?: (expiresAt: number) => void;
     /** Called when an error occurs */
     onError?: (error: Error) => void;
     /** Additional class name */
     className?: string;
 }
-export declare function ExperienceWidget({ experienceId, autoStart, accessCode, autoEnterWaitlist, theme, variant, slots, children, checkoutUrl, endedAction, onJourneyChange, onGranted, onFanfareCheckout, onReserved, onError, className, }: ExperienceWidgetProps): import("react/jsx-runtime").JSX.Element;
+export declare function ExperienceWidget({ experienceId, autoStart, accessCode, autoEnterWaitlist, theme, variant, slots, pageType, children, checkoutUrl, endedAction, onJourneyChange, onGranted, onFanfareCheckout, onError, className, }: ExperienceWidgetProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace ExperienceWidget {
     var displayName: string;
 }