@funnelsgrove/payments 0.9.1 → 0.11.0

package/README.md

@@ -13,7 +13,7 @@ Read this file before editing checkout code. Deeper implementation docs:
 
 ## Current Checkout Path
 
-Render every visible wallet placement with `StripeSubscriptionWalletSurface`. It is the normal current path for Apple Pay and Google Pay:
+Render every visible wallet placement with `StripeSubscriptionWalletSurface` or `StripeOneTimeWalletSurface`, matching the resolved plan's payment mode. They are the normal current path for Apple Pay and Google Pay:
 
 - Each surface owns one private Checkout Session per simultaneously visible wallet placement, isolated by its own `surfaceId`.
 - Simultaneously visible placements may use the same plan and coupon; nothing is shared because each surface keeps its own session.
@@ -29,6 +29,8 @@ Use these for new subscription paywalls:
 
 Use these for new one-time paywall plans:
 
+- `StripeOneTimeWalletSurface`
+- `useStripeOneTimeCheckoutSession`
 - `createStripeOneTimeCheckout`
 - `SharedStripeCheckoutV2Dialog`
 
@@ -46,7 +48,7 @@ provider-neutral status endpoint finds canonical shared-ledger payment evidence.
 
 ## Advanced Wallet Primitives
 
-`ApplePaySubscriptionCheckoutSlot`, `GooglePaySubscriptionCheckoutSlot`, and `WalletSubscriptionCheckoutSlot` stay exported and runtime-compatible. They are backward-compatible advanced low-level primitives: reach for them only when a placement needs wiring `StripeSubscriptionWalletSurface` does not cover. Never share one `useStripeSubscriptionCheckoutSession` result across placements; give each visible placement its own session.
+`ApplePaySubscriptionCheckoutSlot`, `GooglePaySubscriptionCheckoutSlot`, and `WalletSubscriptionCheckoutSlot` stay exported and runtime-compatible. They are backward-compatible advanced low-level primitives: reach for them only when a placement needs wiring the shared wallet surfaces do not cover. Never share one checkout hook result across placements; give each visible placement its own session.
 
 ## Compatibility-Only Surfaces
 

package/dist/providers/stripe/components/ApplePaySubscriptionCheckoutSlot.d.ts

@@ -5,8 +5,8 @@ export type ApplePaySubscriptionCheckoutSlotProps = Omit<WalletSubscriptionCheck
     placeholderLabel?: string;
 };
 /**
- * @deprecated Prefer StripeSubscriptionWalletSurface for visible wallet placements. This slot stays
- * exported and runtime-compatible as an advanced low-level primitive; its checkout session must
- * never be shared across placements.
+ * @deprecated Prefer StripeSubscriptionWalletSurface or StripeOneTimeWalletSurface for visible
+ * wallet placements. This slot stays exported and runtime-compatible as an advanced low-level
+ * primitive; its checkout session must never be shared across placements.
  */
 export declare function ApplePaySubscriptionCheckoutSlot({ options, placeholderLabel, ...slotProps }: ApplePaySubscriptionCheckoutSlotProps): import("react/jsx-runtime").JSX.Element;

package/dist/providers/stripe/components/ApplePaySubscriptionCheckoutSlot.js

@@ -37,9 +37,9 @@ const applePayExpressCheckoutOptions = {
     },
 };
 /**
- * @deprecated Prefer StripeSubscriptionWalletSurface for visible wallet placements. This slot stays
- * exported and runtime-compatible as an advanced low-level primitive; its checkout session must
- * never be shared across placements.
+ * @deprecated Prefer StripeSubscriptionWalletSurface or StripeOneTimeWalletSurface for visible
+ * wallet placements. This slot stays exported and runtime-compatible as an advanced low-level
+ * primitive; its checkout session must never be shared across placements.
  */
 export function ApplePaySubscriptionCheckoutSlot(_a) {
     var _b, _c, _d, _e, _f, _g, _h, _j, _k;

package/dist/providers/stripe/components/GooglePaySubscriptionCheckoutSlot.d.ts

@@ -5,8 +5,8 @@ export type GooglePaySubscriptionCheckoutSlotProps = Omit<WalletSubscriptionChec
     placeholderLabel?: string;
 };
 /**
- * @deprecated Prefer StripeSubscriptionWalletSurface for visible wallet placements. This slot stays
- * exported and runtime-compatible as an advanced low-level primitive; its checkout session must
- * never be shared across placements.
+ * @deprecated Prefer StripeSubscriptionWalletSurface or StripeOneTimeWalletSurface for visible
+ * wallet placements. This slot stays exported and runtime-compatible as an advanced low-level
+ * primitive; its checkout session must never be shared across placements.
  */
 export declare function GooglePaySubscriptionCheckoutSlot({ options, placeholderLabel, ...slotProps }: GooglePaySubscriptionCheckoutSlotProps): import("react/jsx-runtime").JSX.Element;

package/dist/providers/stripe/components/GooglePaySubscriptionCheckoutSlot.js

@@ -37,9 +37,9 @@ const googlePayExpressCheckoutOptions = {
     },
 };
 /**
- * @deprecated Prefer StripeSubscriptionWalletSurface for visible wallet placements. This slot stays
- * exported and runtime-compatible as an advanced low-level primitive; its checkout session must
- * never be shared across placements.
+ * @deprecated Prefer StripeSubscriptionWalletSurface or StripeOneTimeWalletSurface for visible
+ * wallet placements. This slot stays exported and runtime-compatible as an advanced low-level
+ * primitive; its checkout session must never be shared across placements.
  */
 export function GooglePaySubscriptionCheckoutSlot(_a) {
     var _b, _c, _d, _e, _f, _g, _h, _j, _k;

package/dist/providers/stripe/components/StripeOneTimeWalletSurface.d.ts

@@ -0,0 +1,15 @@
+import { type StripeOneTimeCheckoutSessionInput } from '../hooks/useStripeOneTimeCheckoutSession.js';
+import { type StripeWalletSurfaceAvailability, type StripeWalletSurfaceErrorContext, type StripeWalletSurfaceProps } from './StripeWalletSurface.internal.js';
+export type StripeOneTimeWalletSurfaceAvailability = StripeWalletSurfaceAvailability;
+export type StripeOneTimeWalletSurfaceErrorContext = StripeWalletSurfaceErrorContext;
+export type StripeOneTimeWalletSurfaceCheckoutInput = Omit<StripeOneTimeCheckoutSessionInput, 'onError'> & {
+    customerName?: string | null;
+};
+export type StripeOneTimeWalletSurfaceProps = Omit<StripeWalletSurfaceProps, 'applePayOptions' | 'applePayPlaceholderLabel' | 'customerEmail' | 'customerName' | 'googlePayOptions' | 'googlePayPlaceholderLabel' | 'returnUrl' | 'session'> & {
+    applePayOptions?: StripeWalletSurfaceProps['applePayOptions'];
+    applePayPlaceholderLabel?: string;
+    checkout: StripeOneTimeWalletSurfaceCheckoutInput;
+    googlePayOptions?: StripeWalletSurfaceProps['googlePayOptions'];
+    googlePayPlaceholderLabel?: string;
+};
+export declare function StripeOneTimeWalletSurface({ applePayOptions, applePayPlaceholderLabel, checkout, googlePayOptions, googlePayPlaceholderLabel, surfaceId, ...surfaceProps }: StripeOneTimeWalletSurfaceProps): import("react/jsx-runtime").JSX.Element;

package/dist/providers/stripe/components/StripeOneTimeWalletSurface.js

@@ -0,0 +1,28 @@
+'use client';
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { useStripeOneTimeCheckoutSession, } from '../hooks/useStripeOneTimeCheckoutSession.js';
+import { StripeWalletSurface, buildStripeWalletSurfaceAnalyticsMetadata, } from './StripeWalletSurface.internal.js';
+export function StripeOneTimeWalletSurface(_a) {
+    var _b, _c;
+    var { applePayOptions, applePayPlaceholderLabel = 'Buy with Apple Pay', checkout, googlePayOptions, googlePayPlaceholderLabel = 'Buy with Google Pay', surfaceId } = _a, surfaceProps = __rest(_a, ["applePayOptions", "applePayPlaceholderLabel", "checkout", "googlePayOptions", "googlePayPlaceholderLabel", "surfaceId"]);
+    const normalizedSurfaceId = surfaceId.trim();
+    const { customerName } = checkout, checkoutSessionInput = __rest(checkout, ["customerName"]);
+    const surfaceAnalyticsMetadata = useMemo(() => {
+        var _a;
+        return buildStripeWalletSurfaceAnalyticsMetadata(Object.assign(Object.assign({}, ((_a = checkout.analyticsMetadata) !== null && _a !== void 0 ? _a : {})), { paymentMode: 'one_time' }), normalizedSurfaceId);
+    }, [checkout.analyticsMetadata, normalizedSurfaceId]);
+    const session = useStripeOneTimeCheckoutSession(Object.assign(Object.assign({}, checkoutSessionInput), { analyticsMetadata: surfaceAnalyticsMetadata }));
+    return (_jsx(StripeWalletSurface, Object.assign({}, surfaceProps, { applePayOptions: Object.assign(Object.assign({}, applePayOptions), { buttonType: Object.assign({ applePay: 'buy' }, ((_b = applePayOptions === null || applePayOptions === void 0 ? void 0 : applePayOptions.buttonType) !== null && _b !== void 0 ? _b : {})) }), applePayPlaceholderLabel: applePayPlaceholderLabel, customerEmail: checkout.customerEmail, customerName: customerName, googlePayOptions: Object.assign(Object.assign({}, googlePayOptions), { buttonType: Object.assign({ googlePay: 'buy' }, ((_c = googlePayOptions === null || googlePayOptions === void 0 ? void 0 : googlePayOptions.buttonType) !== null && _c !== void 0 ? _c : {})) }), googlePayPlaceholderLabel: googlePayPlaceholderLabel, returnUrl: checkout.returnUrl, session: session, surfaceId: normalizedSurfaceId })));
+}

package/dist/providers/stripe/components/StripeSubscriptionWalletSurface.d.ts

@@ -1,82 +1,11 @@
-import { type ReactNode } from 'react';
-import type { Appearance, StripeCheckoutExpressCheckoutElementOptions } from '@stripe/stripe-js';
-import { type PlatformWalletPaymentMethod } from './walletPlatform.js';
-import type { StripeSubscriptionCheckoutAnalyticsContext } from '../services/checkoutCompletionAnalytics.service.js';
 import { type StripeSubscriptionCheckoutSessionInput } from '../hooks/useStripeSubscriptionCheckoutSession.js';
+import { applyStripeWalletSurfaceMethodAvailability as applyStripeSubscriptionWalletSurfaceMethodAvailability, buildStripeWalletSurfaceAnalyticsMetadata as buildStripeSubscriptionWalletSurfaceAnalyticsMetadata, buildStripeWalletSurfaceAvailability as buildStripeSubscriptionWalletSurfaceAvailability, buildStripeWalletSurfaceCheckoutAnalytics as buildStripeSubscriptionWalletSurfaceCheckoutAnalytics, getStripeWalletSurfaceMethodAvailability as getStripeSubscriptionWalletSurfaceMethodAvailability, getStripeWalletSurfaceVisibleMethods as getStripeSubscriptionWalletSurfaceVisibleMethods, normalizeStripeWalletSurfaceMethods as normalizeStripeSubscriptionWalletSurfaceMethods, resolveStripeWalletSurfaceError as resolveStripeSubscriptionWalletSurfaceError, shouldRenderStripeWalletSurface as shouldRenderStripeSubscriptionWalletSurface, type StripeWalletSurfaceAvailability as StripeSubscriptionWalletSurfaceAvailability, type StripeWalletSurfaceAvailabilityState as StripeSubscriptionWalletSurfaceAvailabilityState, type StripeWalletSurfaceErrorContext as StripeSubscriptionWalletSurfaceErrorContext, type StripeWalletSurfaceErrorEmission as StripeSubscriptionWalletSurfaceErrorEmission, type StripeWalletSurfaceErrorState as StripeSubscriptionWalletSurfaceErrorState, type StripeWalletSurfaceProps, type StripeWalletSurfaceRenderStateInput as StripeSubscriptionWalletSurfaceRenderStateInput } from './StripeWalletSurface.internal.js';
+export { applyStripeSubscriptionWalletSurfaceMethodAvailability, buildStripeSubscriptionWalletSurfaceAnalyticsMetadata, buildStripeSubscriptionWalletSurfaceAvailability, buildStripeSubscriptionWalletSurfaceCheckoutAnalytics, getStripeSubscriptionWalletSurfaceMethodAvailability, getStripeSubscriptionWalletSurfaceVisibleMethods, normalizeStripeSubscriptionWalletSurfaceMethods, resolveStripeSubscriptionWalletSurfaceError, shouldRenderStripeSubscriptionWalletSurface, };
+export type { StripeSubscriptionWalletSurfaceAvailability, StripeSubscriptionWalletSurfaceAvailabilityState, StripeSubscriptionWalletSurfaceErrorContext, StripeSubscriptionWalletSurfaceErrorEmission, StripeSubscriptionWalletSurfaceErrorState, StripeSubscriptionWalletSurfaceRenderStateInput, };
 export type StripeSubscriptionWalletSurfaceCheckoutInput = Omit<StripeSubscriptionCheckoutSessionInput, 'onError'> & {
     customerName?: string | null;
 };
-export type StripeSubscriptionWalletSurfaceAvailability = {
-    anyAvailable: boolean;
-    methods: Partial<Record<PlatformWalletPaymentMethod, boolean>>;
-    resolved: boolean;
-};
-export type StripeSubscriptionWalletSurfaceAvailabilityState = {
-    intentKey: string;
-    methods: Partial<Record<PlatformWalletPaymentMethod, boolean>>;
-};
-export type StripeSubscriptionWalletSurfaceErrorContext = {
-    paymentMethod?: PlatformWalletPaymentMethod;
-    surfaceId: string;
-};
-export type StripeSubscriptionWalletSurfaceErrorEmission = {
-    context: StripeSubscriptionWalletSurfaceErrorContext;
-    errorState: StripeSubscriptionWalletSurfaceErrorState;
-    message: string | null;
-};
-export type StripeSubscriptionWalletSurfaceErrorState = {
-    methodMessages: Partial<Record<PlatformWalletPaymentMethod, string>>;
-    surfaceMessage: string | null;
-};
-export type StripeSubscriptionWalletSurfaceRenderStateInput = {
-    anyAvailable: boolean;
-    configured: boolean;
-    paymentMethodCount: number;
-    resolved: boolean;
-    suspended: boolean;
-};
-export declare function buildStripeSubscriptionWalletSurfaceAnalyticsMetadata(analyticsMetadata: Record<string, unknown> | null | undefined, surfaceId: string): Record<string, unknown>;
-export declare function buildStripeSubscriptionWalletSurfaceCheckoutAnalytics(checkoutAnalytics: StripeSubscriptionCheckoutAnalyticsContext | null | undefined, surfaceId: string): StripeSubscriptionCheckoutAnalyticsContext | null;
-export declare function normalizeStripeSubscriptionWalletSurfaceMethods(paymentMethods: readonly PlatformWalletPaymentMethod[]): PlatformWalletPaymentMethod[];
-export declare function getStripeSubscriptionWalletSurfaceVisibleMethods(paymentMethods: readonly PlatformWalletPaymentMethod[], methods: Partial<Record<PlatformWalletPaymentMethod, boolean>>): PlatformWalletPaymentMethod[];
-export declare function getStripeSubscriptionWalletSurfaceMethodAvailability(state: StripeSubscriptionWalletSurfaceAvailabilityState, intentKey: string): Partial<Record<PlatformWalletPaymentMethod, boolean>>;
-export declare function applyStripeSubscriptionWalletSurfaceMethodAvailability(state: StripeSubscriptionWalletSurfaceAvailabilityState, intentKey: string, method: PlatformWalletPaymentMethod, available: boolean): StripeSubscriptionWalletSurfaceAvailabilityState;
-export declare function buildStripeSubscriptionWalletSurfaceAvailability(paymentMethods: readonly PlatformWalletPaymentMethod[], methods: Partial<Record<PlatformWalletPaymentMethod, boolean>>): StripeSubscriptionWalletSurfaceAvailability;
-export declare function shouldRenderStripeSubscriptionWalletSurface({ anyAvailable, configured, paymentMethodCount, resolved, suspended, }: StripeSubscriptionWalletSurfaceRenderStateInput): boolean;
-export declare function resolveStripeSubscriptionWalletSurfaceError({ errorState, message, paymentMethod, surfaceId, }: {
-    errorState: StripeSubscriptionWalletSurfaceErrorState;
-    message: string | null;
-    paymentMethod?: PlatformWalletPaymentMethod;
-    surfaceId: string;
-}): StripeSubscriptionWalletSurfaceErrorEmission | null;
-export type StripeSubscriptionWalletSurfaceProps = {
-    amountCents: number;
-    appearance?: Appearance;
-    applePayOptions?: Partial<StripeCheckoutExpressCheckoutElementOptions>;
-    applePayPlaceholderLabel?: string;
-    beforeConfirm?: () => Promise<string | null>;
+export type StripeSubscriptionWalletSurfaceProps = Omit<StripeWalletSurfaceProps, 'customerEmail' | 'customerName' | 'returnUrl' | 'session'> & {
     checkout: StripeSubscriptionWalletSurfaceCheckoutInput;
-    checkoutAnalytics?: StripeSubscriptionCheckoutAnalyticsContext | null;
-    className?: string;
-    containerClassName?: string;
-    disabled?: boolean;
-    googlePayOptions?: Partial<StripeCheckoutExpressCheckoutElementOptions>;
-    googlePayPlaceholderLabel?: string;
-    onAvailabilityChange?: (availability: StripeSubscriptionWalletSurfaceAvailability) => void;
-    onCancel?: () => void;
-    onError?: (message: string | null, context: StripeSubscriptionWalletSurfaceErrorContext) => void;
-    onPaymentInfoSubmitted?: () => void | Promise<void>;
-    onSuccess?: () => void | Promise<void>;
-    onUnavailableClick?: () => Promise<void> | void;
-    paymentMethods?: readonly PlatformWalletPaymentMethod[];
-    renderHeader?: (props: {
-        availability: StripeSubscriptionWalletSurfaceAvailability;
-    }) => ReactNode;
-    resolveMethodClassName?: (method: PlatformWalletPaymentMethod) => string | undefined;
-    resolveMethodWrapperClassName?: (method: PlatformWalletPaymentMethod) => string | undefined;
-    slotClassName?: string;
-    summaryLabel: string;
-    surfaceId: string;
-    suspended?: boolean;
 };
-export declare function StripeSubscriptionWalletSurface({ amountCents, appearance, applePayOptions, applePayPlaceholderLabel, beforeConfirm, checkout, checkoutAnalytics, className, containerClassName, disabled, googlePayOptions, googlePayPlaceholderLabel, onAvailabilityChange, onCancel, onError, onPaymentInfoSubmitted, onSuccess, onUnavailableClick, paymentMethods, renderHeader, resolveMethodClassName, resolveMethodWrapperClassName, slotClassName, summaryLabel, surfaceId, suspended, }: StripeSubscriptionWalletSurfaceProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function StripeSubscriptionWalletSurface({ checkout, surfaceId, ...surfaceProps }: StripeSubscriptionWalletSurfaceProps): import("react/jsx-runtime").JSX.Element;

package/dist/providers/stripe/components/StripeSubscriptionWalletSurface.js

@@ -10,179 +10,16 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { usePlatformWalletPaymentMethods, } from './walletPlatform.js';
-import { ApplePaySubscriptionCheckoutSlot } from './ApplePaySubscriptionCheckoutSlot.js';
-import { GooglePaySubscriptionCheckoutSlot } from './GooglePaySubscriptionCheckoutSlot.js';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
 import { useStripeSubscriptionCheckoutSession, } from '../hooks/useStripeSubscriptionCheckoutSession.js';
-export function buildStripeSubscriptionWalletSurfaceAnalyticsMetadata(analyticsMetadata, surfaceId) {
-    return Object.assign(Object.assign({}, (analyticsMetadata !== null && analyticsMetadata !== void 0 ? analyticsMetadata : {})), { checkoutSurfaceId: surfaceId });
-}
-export function buildStripeSubscriptionWalletSurfaceCheckoutAnalytics(checkoutAnalytics, surfaceId) {
-    if (!checkoutAnalytics) {
-        return null;
-    }
-    return Object.assign(Object.assign({}, checkoutAnalytics), { metadata: buildStripeSubscriptionWalletSurfaceAnalyticsMetadata(checkoutAnalytics.metadata, surfaceId) });
-}
-export function normalizeStripeSubscriptionWalletSurfaceMethods(paymentMethods) {
-    return paymentMethods.filter((method, index) => paymentMethods.indexOf(method) === index);
-}
-export function getStripeSubscriptionWalletSurfaceVisibleMethods(paymentMethods, methods) {
-    return paymentMethods.filter((method) => methods[method] !== false);
-}
-export function getStripeSubscriptionWalletSurfaceMethodAvailability(state, intentKey) {
-    return state.intentKey === intentKey ? state.methods : {};
-}
-export function applyStripeSubscriptionWalletSurfaceMethodAvailability(state, intentKey, method, available) {
-    return {
-        intentKey,
-        methods: Object.assign(Object.assign({}, getStripeSubscriptionWalletSurfaceMethodAvailability(state, intentKey)), { [method]: available }),
-    };
-}
-export function buildStripeSubscriptionWalletSurfaceAvailability(paymentMethods, methods) {
-    const reportedMethods = paymentMethods.filter((method) => typeof methods[method] === 'boolean');
-    return {
-        anyAvailable: reportedMethods.some((method) => methods[method] === true),
-        methods: reportedMethods.reduce((current, method) => (Object.assign(Object.assign({}, current), { [method]: methods[method] === true })), {}),
-        resolved: reportedMethods.length === paymentMethods.length,
-    };
-}
-export function shouldRenderStripeSubscriptionWalletSurface({ anyAvailable, configured, paymentMethodCount, resolved, suspended, }) {
-    return configured && !suspended && paymentMethodCount > 0 && (!resolved || anyAvailable);
-}
-export function resolveStripeSubscriptionWalletSurfaceError({ errorState, message, paymentMethod, surfaceId, }) {
-    if (paymentMethod && errorState.methodMessages[paymentMethod] === message) {
-        return null;
-    }
-    if (!paymentMethod) {
-        const methodMessages = Object.values(errorState.methodMessages);
-        if (message === null) {
-            if (errorState.surfaceMessage === null && methodMessages.length === 0) {
-                return null;
-            }
-        }
-        else if (errorState.surfaceMessage === message || methodMessages.includes(message)) {
-            return null;
-        }
-    }
-    const nextErrorState = message === null
-        ? { methodMessages: {}, surfaceMessage: null }
-        : paymentMethod
-            ? Object.assign(Object.assign({}, errorState), { methodMessages: Object.assign(Object.assign({}, errorState.methodMessages), { [paymentMethod]: message }) }) : Object.assign(Object.assign({}, errorState), { surfaceMessage: message });
-    return {
-        context: Object.assign(Object.assign({}, (paymentMethod ? { paymentMethod } : {})), { surfaceId }),
-        errorState: nextErrorState,
-        message,
-    };
-}
-// Availability identity used to notify consumers only when the aggregate actually changed.
-function buildAvailabilitySignature(availability) {
-    return [
-        availability.resolved ? 'resolved' : 'unresolved',
-        availability.anyAvailable ? 'available' : 'unavailable',
-        Object.entries(availability.methods)
-            .map(([method, available]) => `${method}:${available ? '1' : '0'}`)
-            .sort()
-            .join(','),
-    ].join('|');
-}
-export function StripeSubscriptionWalletSurface({ amountCents, appearance, applePayOptions, applePayPlaceholderLabel, beforeConfirm, checkout, checkoutAnalytics, className, containerClassName, disabled, googlePayOptions, googlePayPlaceholderLabel, onAvailabilityChange, onCancel, onError, onPaymentInfoSubmitted, onSuccess, onUnavailableClick, paymentMethods, renderHeader, resolveMethodClassName, resolveMethodWrapperClassName, slotClassName, summaryLabel, surfaceId, suspended = false, }) {
-    var _a;
-    const platformWalletPaymentMethods = usePlatformWalletPaymentMethods();
-    const walletPaymentMethods = normalizeStripeSubscriptionWalletSurfaceMethods(paymentMethods !== null && paymentMethods !== void 0 ? paymentMethods : platformWalletPaymentMethods);
+import { StripeWalletSurface, applyStripeWalletSurfaceMethodAvailability as applyStripeSubscriptionWalletSurfaceMethodAvailability, buildStripeWalletSurfaceAnalyticsMetadata as buildStripeSubscriptionWalletSurfaceAnalyticsMetadata, buildStripeWalletSurfaceAvailability as buildStripeSubscriptionWalletSurfaceAvailability, buildStripeWalletSurfaceCheckoutAnalytics as buildStripeSubscriptionWalletSurfaceCheckoutAnalytics, getStripeWalletSurfaceMethodAvailability as getStripeSubscriptionWalletSurfaceMethodAvailability, getStripeWalletSurfaceVisibleMethods as getStripeSubscriptionWalletSurfaceVisibleMethods, normalizeStripeWalletSurfaceMethods as normalizeStripeSubscriptionWalletSurfaceMethods, resolveStripeWalletSurfaceError as resolveStripeSubscriptionWalletSurfaceError, shouldRenderStripeWalletSurface as shouldRenderStripeSubscriptionWalletSurface, } from './StripeWalletSurface.internal.js';
+export { applyStripeSubscriptionWalletSurfaceMethodAvailability, buildStripeSubscriptionWalletSurfaceAnalyticsMetadata, buildStripeSubscriptionWalletSurfaceAvailability, buildStripeSubscriptionWalletSurfaceCheckoutAnalytics, getStripeSubscriptionWalletSurfaceMethodAvailability, getStripeSubscriptionWalletSurfaceVisibleMethods, normalizeStripeSubscriptionWalletSurfaceMethods, resolveStripeSubscriptionWalletSurfaceError, shouldRenderStripeSubscriptionWalletSurface, };
+export function StripeSubscriptionWalletSurface(_a) {
+    var { checkout, surfaceId } = _a, surfaceProps = __rest(_a, ["checkout", "surfaceId"]);
     const normalizedSurfaceId = surfaceId.trim();
     const { customerName } = checkout, checkoutSessionInput = __rest(checkout, ["customerName"]);
     const surfaceAnalyticsMetadata = useMemo(() => buildStripeSubscriptionWalletSurfaceAnalyticsMetadata(checkout.analyticsMetadata, normalizedSurfaceId), [checkout.analyticsMetadata, normalizedSurfaceId]);
     const session = useStripeSubscriptionCheckoutSession(Object.assign(Object.assign({}, checkoutSessionInput), { analyticsMetadata: surfaceAnalyticsMetadata }));
-    const surfaceCheckoutAnalytics = useMemo(() => buildStripeSubscriptionWalletSurfaceCheckoutAnalytics(checkoutAnalytics, normalizedSurfaceId), [checkoutAnalytics, normalizedSurfaceId]);
-    const [availabilityState, setAvailabilityState] = useState({
-        intentKey: session.intentKey,
-        methods: {},
-    });
-    const availability = buildStripeSubscriptionWalletSurfaceAvailability(walletPaymentMethods, getStripeSubscriptionWalletSurfaceMethodAvailability(availabilityState, session.intentKey));
-    const availabilitySignature = buildAvailabilitySignature(availability);
-    const reportedAvailabilitySignatureRef = useRef(null);
-    const errorStateRef = useRef({
-        methodMessages: {},
-        surfaceMessage: null,
-    });
-    const emitError = useCallback((message, paymentMethod) => {
-        const emission = resolveStripeSubscriptionWalletSurfaceError({
-            errorState: errorStateRef.current,
-            message,
-            paymentMethod,
-            surfaceId: normalizedSurfaceId,
-        });
-        if (!emission) {
-            return;
-        }
-        errorStateRef.current = emission.errorState;
-        onError === null || onError === void 0 ? void 0 : onError(emission.message, emission.context);
-    }, [normalizedSurfaceId, onError]);
-    useEffect(() => {
-        if (reportedAvailabilitySignatureRef.current === availabilitySignature) {
-            return;
-        }
-        reportedAvailabilitySignatureRef.current = availabilitySignature;
-        onAvailabilityChange === null || onAvailabilityChange === void 0 ? void 0 : onAvailabilityChange(availability);
-    }, [availability, availabilitySignature, onAvailabilityChange]);
-    useEffect(() => {
-        emitError(session.error);
-    }, [emitError, session.error]);
-    const renderWalletMethod = (method) => {
-        var _a;
-        const slotProps = {
-            amountCents,
-            appearance,
-            beforeConfirm,
-            checkoutAnalytics: surfaceCheckoutAnalytics,
-            className: (_a = resolveMethodClassName === null || resolveMethodClassName === void 0 ? void 0 : resolveMethodClassName(method)) !== null && _a !== void 0 ? _a : className,
-            customerEmail: checkout.customerEmail,
-            customerName,
-            disabled,
-            onAvailabilityChange: (available) => setAvailabilityState((current) => applyStripeSubscriptionWalletSurfaceMethodAvailability(current, session.intentKey, method, available)),
-            onCancel,
-            onError: (message) => emitError(message, method),
-            onPaymentInfoSubmitted,
-            onSuccess,
-            onUnavailableClick,
-            returnUrl: checkout.returnUrl,
-            session,
-            slotClassName,
-            summaryLabel,
-        };
-        if (method === 'applePay') {
-            return (_jsx(ApplePaySubscriptionCheckoutSlot, Object.assign({}, slotProps, { options: applePayOptions, placeholderLabel: applePayPlaceholderLabel })));
-        }
-        if (method === 'googlePay') {
-            return (_jsx(GooglePaySubscriptionCheckoutSlot, Object.assign({}, slotProps, { options: googlePayOptions, placeholderLabel: googlePayPlaceholderLabel })));
-        }
-        return null;
-    };
-    const visibleWalletPaymentMethods = getStripeSubscriptionWalletSurfaceVisibleMethods(walletPaymentMethods, availability.methods);
-    const shouldRenderSurface = shouldRenderStripeSubscriptionWalletSurface({
-        anyAvailable: availability.anyAvailable,
-        configured: session.configured,
-        paymentMethodCount: walletPaymentMethods.length,
-        resolved: availability.resolved,
-        suspended,
-    });
-    if (!shouldRenderSurface) {
-        return null;
-    }
-    return (_jsxs("div", { className: [
-            'stripe-subscription-wallet-surface',
-            containerClassName !== null && containerClassName !== void 0 ? containerClassName : '',
-        ]
-            .filter(Boolean)
-            .join(' '), "data-wallet-surface-id": normalizedSurfaceId, children: [(_a = renderHeader === null || renderHeader === void 0 ? void 0 : renderHeader({ availability })) !== null && _a !== void 0 ? _a : null, visibleWalletPaymentMethods.map((method) => {
-                var _a;
-                return (_jsx("div", { className: [
-                        'stripe-subscription-wallet-surface__method',
-                        (_a = resolveMethodWrapperClassName === null || resolveMethodWrapperClassName === void 0 ? void 0 : resolveMethodWrapperClassName(method)) !== null && _a !== void 0 ? _a : '',
-                    ]
-                        .filter(Boolean)
-                        .join(' '), "data-wallet-payment-method": method, children: renderWalletMethod(method) }, method));
-            })] }));
+    return (_jsx(StripeWalletSurface, Object.assign({}, surfaceProps, { customerEmail: checkout.customerEmail, customerName: customerName, returnUrl: checkout.returnUrl, session: session, surfaceId: normalizedSurfaceId })));
 }

package/dist/providers/stripe/components/StripeWalletSurface.internal.d.ts

@@ -0,0 +1,82 @@
+import { type ReactNode } from 'react';
+import type { Appearance, StripeCheckoutExpressCheckoutElementOptions } from '@stripe/stripe-js';
+import { type PlatformWalletPaymentMethod } from './walletPlatform.js';
+import type { StripeSubscriptionCheckoutAnalyticsContext } from '../services/checkoutCompletionAnalytics.service.js';
+import type { StripeWalletCheckoutSession } from './WalletSubscriptionCheckoutSlot.js';
+export type StripeWalletSurfaceAvailability = {
+    anyAvailable: boolean;
+    methods: Partial<Record<PlatformWalletPaymentMethod, boolean>>;
+    resolved: boolean;
+};
+export type StripeWalletSurfaceAvailabilityState = {
+    intentKey: string;
+    methods: Partial<Record<PlatformWalletPaymentMethod, boolean>>;
+};
+export type StripeWalletSurfaceErrorContext = {
+    paymentMethod?: PlatformWalletPaymentMethod;
+    surfaceId: string;
+};
+export type StripeWalletSurfaceErrorEmission = {
+    context: StripeWalletSurfaceErrorContext;
+    errorState: StripeWalletSurfaceErrorState;
+    message: string | null;
+};
+export type StripeWalletSurfaceErrorState = {
+    methodMessages: Partial<Record<PlatformWalletPaymentMethod, string>>;
+    surfaceMessage: string | null;
+};
+export type StripeWalletSurfaceRenderStateInput = {
+    anyAvailable: boolean;
+    configured: boolean;
+    paymentMethodCount: number;
+    resolved: boolean;
+    suspended: boolean;
+};
+export declare function buildStripeWalletSurfaceAnalyticsMetadata(analyticsMetadata: Record<string, unknown> | null | undefined, surfaceId: string): Record<string, unknown>;
+export declare function buildStripeWalletSurfaceCheckoutAnalytics(checkoutAnalytics: StripeSubscriptionCheckoutAnalyticsContext | null | undefined, surfaceId: string): StripeSubscriptionCheckoutAnalyticsContext | null;
+export declare function normalizeStripeWalletSurfaceMethods(paymentMethods: readonly PlatformWalletPaymentMethod[]): PlatformWalletPaymentMethod[];
+export declare function getStripeWalletSurfaceVisibleMethods(paymentMethods: readonly PlatformWalletPaymentMethod[], methods: Partial<Record<PlatformWalletPaymentMethod, boolean>>): PlatformWalletPaymentMethod[];
+export declare function getStripeWalletSurfaceMethodAvailability(state: StripeWalletSurfaceAvailabilityState, intentKey: string): Partial<Record<PlatformWalletPaymentMethod, boolean>>;
+export declare function applyStripeWalletSurfaceMethodAvailability(state: StripeWalletSurfaceAvailabilityState, intentKey: string, method: PlatformWalletPaymentMethod, available: boolean): StripeWalletSurfaceAvailabilityState;
+export declare function buildStripeWalletSurfaceAvailability(paymentMethods: readonly PlatformWalletPaymentMethod[], methods: Partial<Record<PlatformWalletPaymentMethod, boolean>>): StripeWalletSurfaceAvailability;
+export declare function shouldRenderStripeWalletSurface({ anyAvailable, configured, paymentMethodCount, resolved, suspended, }: StripeWalletSurfaceRenderStateInput): boolean;
+export declare function resolveStripeWalletSurfaceError({ errorState, message, paymentMethod, surfaceId, }: {
+    errorState: StripeWalletSurfaceErrorState;
+    message: string | null;
+    paymentMethod?: PlatformWalletPaymentMethod;
+    surfaceId: string;
+}): StripeWalletSurfaceErrorEmission | null;
+export type StripeWalletSurfaceProps = {
+    amountCents: number;
+    appearance?: Appearance;
+    applePayOptions?: Partial<StripeCheckoutExpressCheckoutElementOptions>;
+    applePayPlaceholderLabel?: string;
+    beforeConfirm?: () => Promise<string | null>;
+    checkoutAnalytics?: StripeSubscriptionCheckoutAnalyticsContext | null;
+    className?: string;
+    containerClassName?: string;
+    customerEmail?: string | null;
+    customerName?: string | null;
+    disabled?: boolean;
+    googlePayOptions?: Partial<StripeCheckoutExpressCheckoutElementOptions>;
+    googlePayPlaceholderLabel?: string;
+    onAvailabilityChange?: (availability: StripeWalletSurfaceAvailability) => void;
+    onCancel?: () => void;
+    onError?: (message: string | null, context: StripeWalletSurfaceErrorContext) => void;
+    onPaymentInfoSubmitted?: () => void | Promise<void>;
+    onSuccess?: () => void | Promise<void>;
+    onUnavailableClick?: () => Promise<void> | void;
+    paymentMethods?: readonly PlatformWalletPaymentMethod[];
+    renderHeader?: (props: {
+        availability: StripeWalletSurfaceAvailability;
+    }) => ReactNode;
+    resolveMethodClassName?: (method: PlatformWalletPaymentMethod) => string | undefined;
+    resolveMethodWrapperClassName?: (method: PlatformWalletPaymentMethod) => string | undefined;
+    returnUrl: string;
+    session: StripeWalletCheckoutSession;
+    slotClassName?: string;
+    summaryLabel: string;
+    surfaceId: string;
+    suspended?: boolean;
+};
+export declare function StripeWalletSurface({ amountCents, appearance, applePayOptions, applePayPlaceholderLabel, beforeConfirm, checkoutAnalytics, className, containerClassName, customerEmail, customerName, disabled, googlePayOptions, googlePayPlaceholderLabel, onAvailabilityChange, onCancel, onError, onPaymentInfoSubmitted, onSuccess, onUnavailableClick, paymentMethods, renderHeader, resolveMethodClassName, resolveMethodWrapperClassName, returnUrl, session, slotClassName, summaryLabel, surfaceId, suspended, }: StripeWalletSurfaceProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/providers/stripe/components/StripeWalletSurface.internal.js

@@ -0,0 +1,172 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { usePlatformWalletPaymentMethods, } from './walletPlatform.js';
+import { ApplePaySubscriptionCheckoutSlot } from './ApplePaySubscriptionCheckoutSlot.js';
+import { GooglePaySubscriptionCheckoutSlot } from './GooglePaySubscriptionCheckoutSlot.js';
+export function buildStripeWalletSurfaceAnalyticsMetadata(analyticsMetadata, surfaceId) {
+    return Object.assign(Object.assign({}, (analyticsMetadata !== null && analyticsMetadata !== void 0 ? analyticsMetadata : {})), { checkoutSurfaceId: surfaceId });
+}
+export function buildStripeWalletSurfaceCheckoutAnalytics(checkoutAnalytics, surfaceId) {
+    if (!checkoutAnalytics) {
+        return null;
+    }
+    return Object.assign(Object.assign({}, checkoutAnalytics), { metadata: buildStripeWalletSurfaceAnalyticsMetadata(checkoutAnalytics.metadata, surfaceId) });
+}
+export function normalizeStripeWalletSurfaceMethods(paymentMethods) {
+    return paymentMethods.filter((method, index) => paymentMethods.indexOf(method) === index);
+}
+export function getStripeWalletSurfaceVisibleMethods(paymentMethods, methods) {
+    return paymentMethods.filter((method) => methods[method] !== false);
+}
+export function getStripeWalletSurfaceMethodAvailability(state, intentKey) {
+    return state.intentKey === intentKey ? state.methods : {};
+}
+export function applyStripeWalletSurfaceMethodAvailability(state, intentKey, method, available) {
+    return {
+        intentKey,
+        methods: Object.assign(Object.assign({}, getStripeWalletSurfaceMethodAvailability(state, intentKey)), { [method]: available }),
+    };
+}
+export function buildStripeWalletSurfaceAvailability(paymentMethods, methods) {
+    const reportedMethods = paymentMethods.filter((method) => typeof methods[method] === 'boolean');
+    return {
+        anyAvailable: reportedMethods.some((method) => methods[method] === true),
+        methods: reportedMethods.reduce((current, method) => (Object.assign(Object.assign({}, current), { [method]: methods[method] === true })), {}),
+        resolved: reportedMethods.length === paymentMethods.length,
+    };
+}
+export function shouldRenderStripeWalletSurface({ anyAvailable, configured, paymentMethodCount, resolved, suspended, }) {
+    return configured && !suspended && paymentMethodCount > 0 && (!resolved || anyAvailable);
+}
+export function resolveStripeWalletSurfaceError({ errorState, message, paymentMethod, surfaceId, }) {
+    if (paymentMethod && errorState.methodMessages[paymentMethod] === message) {
+        return null;
+    }
+    if (!paymentMethod) {
+        const methodMessages = Object.values(errorState.methodMessages);
+        if (message === null) {
+            if (errorState.surfaceMessage === null && methodMessages.length === 0) {
+                return null;
+            }
+        }
+        else if (errorState.surfaceMessage === message || methodMessages.includes(message)) {
+            return null;
+        }
+    }
+    const nextErrorState = message === null
+        ? { methodMessages: {}, surfaceMessage: null }
+        : paymentMethod
+            ? Object.assign(Object.assign({}, errorState), { methodMessages: Object.assign(Object.assign({}, errorState.methodMessages), { [paymentMethod]: message }) }) : Object.assign(Object.assign({}, errorState), { surfaceMessage: message });
+    return {
+        context: Object.assign(Object.assign({}, (paymentMethod ? { paymentMethod } : {})), { surfaceId }),
+        errorState: nextErrorState,
+        message,
+    };
+}
+function buildAvailabilitySignature(availability) {
+    return [
+        availability.resolved ? 'resolved' : 'unresolved',
+        availability.anyAvailable ? 'available' : 'unavailable',
+        Object.entries(availability.methods)
+            .map(([method, available]) => `${method}:${available ? '1' : '0'}`)
+            .sort()
+            .join(','),
+    ].join('|');
+}
+export function StripeWalletSurface({ amountCents, appearance, applePayOptions, applePayPlaceholderLabel, beforeConfirm, checkoutAnalytics, className, containerClassName, customerEmail, customerName, disabled, googlePayOptions, googlePayPlaceholderLabel, onAvailabilityChange, onCancel, onError, onPaymentInfoSubmitted, onSuccess, onUnavailableClick, paymentMethods, renderHeader, resolveMethodClassName, resolveMethodWrapperClassName, returnUrl, session, slotClassName, summaryLabel, surfaceId, suspended = false, }) {
+    var _a;
+    const platformWalletPaymentMethods = usePlatformWalletPaymentMethods();
+    const walletPaymentMethods = normalizeStripeWalletSurfaceMethods(paymentMethods !== null && paymentMethods !== void 0 ? paymentMethods : platformWalletPaymentMethods);
+    const normalizedSurfaceId = surfaceId.trim();
+    const surfaceCheckoutAnalytics = useMemo(() => buildStripeWalletSurfaceCheckoutAnalytics(checkoutAnalytics, normalizedSurfaceId), [checkoutAnalytics, normalizedSurfaceId]);
+    const [availabilityState, setAvailabilityState] = useState({
+        intentKey: session.intentKey,
+        methods: {},
+    });
+    const availability = buildStripeWalletSurfaceAvailability(walletPaymentMethods, getStripeWalletSurfaceMethodAvailability(availabilityState, session.intentKey));
+    const availabilitySignature = buildAvailabilitySignature(availability);
+    const reportedAvailabilitySignatureRef = useRef(null);
+    const errorStateRef = useRef({
+        methodMessages: {},
+        surfaceMessage: null,
+    });
+    const emitError = useCallback((message, paymentMethod) => {
+        const emission = resolveStripeWalletSurfaceError({
+            errorState: errorStateRef.current,
+            message,
+            paymentMethod,
+            surfaceId: normalizedSurfaceId,
+        });
+        if (!emission) {
+            return;
+        }
+        errorStateRef.current = emission.errorState;
+        onError === null || onError === void 0 ? void 0 : onError(emission.message, emission.context);
+    }, [normalizedSurfaceId, onError]);
+    useEffect(() => {
+        if (reportedAvailabilitySignatureRef.current === availabilitySignature) {
+            return;
+        }
+        reportedAvailabilitySignatureRef.current = availabilitySignature;
+        onAvailabilityChange === null || onAvailabilityChange === void 0 ? void 0 : onAvailabilityChange(availability);
+    }, [availability, availabilitySignature, onAvailabilityChange]);
+    useEffect(() => {
+        emitError(session.error);
+    }, [emitError, session.error]);
+    const renderWalletMethod = (method) => {
+        var _a;
+        const slotProps = {
+            amountCents,
+            appearance,
+            beforeConfirm,
+            checkoutAnalytics: surfaceCheckoutAnalytics,
+            className: (_a = resolveMethodClassName === null || resolveMethodClassName === void 0 ? void 0 : resolveMethodClassName(method)) !== null && _a !== void 0 ? _a : className,
+            customerEmail,
+            customerName,
+            disabled,
+            onAvailabilityChange: (available) => setAvailabilityState((current) => applyStripeWalletSurfaceMethodAvailability(current, session.intentKey, method, available)),
+            onCancel,
+            onError: (message) => emitError(message, method),
+            onPaymentInfoSubmitted,
+            onSuccess,
+            onUnavailableClick,
+            returnUrl,
+            session,
+            slotClassName,
+            summaryLabel,
+        };
+        if (method === 'applePay') {
+            return (_jsx(ApplePaySubscriptionCheckoutSlot, Object.assign({}, slotProps, { options: applePayOptions, placeholderLabel: applePayPlaceholderLabel })));
+        }
+        if (method === 'googlePay') {
+            return (_jsx(GooglePaySubscriptionCheckoutSlot, Object.assign({}, slotProps, { options: googlePayOptions, placeholderLabel: googlePayPlaceholderLabel })));
+        }
+        return null;
+    };
+    const visibleWalletPaymentMethods = getStripeWalletSurfaceVisibleMethods(walletPaymentMethods, availability.methods);
+    const shouldRenderSurface = shouldRenderStripeWalletSurface({
+        anyAvailable: availability.anyAvailable,
+        configured: session.configured,
+        paymentMethodCount: walletPaymentMethods.length,
+        resolved: availability.resolved,
+        suspended,
+    });
+    if (!shouldRenderSurface) {
+        return null;
+    }
+    return (_jsxs("div", { className: [
+            'stripe-subscription-wallet-surface',
+            containerClassName !== null && containerClassName !== void 0 ? containerClassName : '',
+        ]
+            .filter(Boolean)
+            .join(' '), "data-wallet-surface-id": normalizedSurfaceId, children: [(_a = renderHeader === null || renderHeader === void 0 ? void 0 : renderHeader({ availability })) !== null && _a !== void 0 ? _a : null, visibleWalletPaymentMethods.map((method) => {
+                var _a;
+                return (_jsx("div", { className: [
+                        'stripe-subscription-wallet-surface__method',
+                        (_a = resolveMethodWrapperClassName === null || resolveMethodWrapperClassName === void 0 ? void 0 : resolveMethodWrapperClassName(method)) !== null && _a !== void 0 ? _a : '',
+                    ]
+                        .filter(Boolean)
+                        .join(' '), "data-wallet-payment-method": method, children: renderWalletMethod(method) }, method));
+            })] }));
+}

package/dist/providers/stripe/components/WalletSubscriptionCheckoutSlot.d.ts

@@ -1,7 +1,27 @@
 import { type ReactNode } from 'react';
-import type { Appearance, AvailablePaymentMethods, StripeCheckoutExpressCheckoutElementOptions } from '@stripe/stripe-js';
+import type { Appearance, AvailablePaymentMethods, Stripe, StripeCheckoutExpressCheckoutElementOptions } from '@stripe/stripe-js';
 import { type StripeSubscriptionCheckoutAnalyticsContext } from '../services/checkoutCompletionAnalytics.service.js';
-import { type StripeSubscriptionCheckoutSession } from '../hooks/useStripeSubscriptionCheckoutSession.js';
+import type { CheckoutPreparationLoading } from '../../paymentProvider.types.js';
+export type StripeWalletCheckoutPreparationOptions = {
+    checkoutStartSource?: 'card_click' | 'checkout_render' | 'wallet_click' | 'wallet_render' | (string & {});
+    forceNew?: boolean;
+    paymentMethod?: unknown;
+};
+export type StripeWalletCheckoutSession = {
+    activeClientSecret: string | null;
+    activePlanKey?: string | null;
+    checkoutSessionId: string | null;
+    configured: boolean;
+    error: string | null;
+    intentKey: string;
+    loading: CheckoutPreparationLoading;
+    planKey: string;
+    prepareWalletCheckout: (options?: StripeWalletCheckoutPreparationOptions) => Promise<string | null>;
+    restartWalletCheckout: (options?: StripeWalletCheckoutPreparationOptions) => Promise<string | null>;
+    setError: (message: string | null) => void;
+    stripePromise: Promise<Stripe | null> | null;
+    updateCheckoutSessionPlan?: () => Promise<boolean>;
+};
 export type WalletSubscriptionCheckoutRenderStateInput = {
     expressCheckoutAllowed: boolean;
     hasActiveClientSecret: boolean;
@@ -44,16 +64,16 @@ export type WalletSubscriptionCheckoutSlotProps = {
     renderPreparingPlaceholder?: (props: WalletPlaceholderButtonProps) => ReactNode;
     renderPlaceholder: (props: WalletPlaceholderButtonProps) => ReactNode;
     returnUrl: string;
-    session: StripeSubscriptionCheckoutSession;
+    session: StripeWalletCheckoutSession;
     slotClassName?: string;
     summaryLabel: string;
     suspended?: boolean;
 };
 export declare function WalletSubscriptionCheckoutLoadingPlaceholder({ className, label, }: Pick<WalletPlaceholderButtonProps, 'className' | 'label'>): import("react/jsx-runtime").JSX.Element;
 /**
- * @deprecated Prefer StripeSubscriptionWalletSurface for visible wallet placements. This slot stays
- * exported and runtime-compatible as an advanced low-level primitive; its checkout session must
- * never be shared across placements.
+ * @deprecated Prefer StripeSubscriptionWalletSurface or StripeOneTimeWalletSurface for visible
+ * wallet placements. This slot stays exported and runtime-compatible as an advanced low-level
+ * primitive; its checkout session must never be shared across placements.
  */
 export declare function WalletSubscriptionCheckoutSlot({ amountCents, appearance, availabilityPaymentMethod, beforeConfirm, checkoutAnalytics, className, customerEmail, customerName, disabled, expressCheckoutAllowed, onAvailabilityChange, onCancel, onError, onPaymentInfoSubmitted, onSuccess, onUnavailableClick, options, placeholderLabel, renderPreparingPlaceholder, renderPlaceholder, returnUrl, session, slotClassName, summaryLabel, suspended, }: WalletSubscriptionCheckoutSlotProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/providers/stripe/components/WalletSubscriptionCheckoutSlot.js

@@ -30,9 +30,9 @@ export function WalletSubscriptionCheckoutLoadingPlaceholder({ className, label,
             .join(' '), "aria-label": label, role: 'status', children: [_jsx("span", { className: 'wallet-subscription-checkout-slot__loading-bar' }), _jsx("style", { children: walletSubscriptionCheckoutLoadingPlaceholderStyles })] }));
 }
 /**
- * @deprecated Prefer StripeSubscriptionWalletSurface for visible wallet placements. This slot stays
- * exported and runtime-compatible as an advanced low-level primitive; its checkout session must
- * never be shared across placements.
+ * @deprecated Prefer StripeSubscriptionWalletSurface or StripeOneTimeWalletSurface for visible
+ * wallet placements. This slot stays exported and runtime-compatible as an advanced low-level
+ * primitive; its checkout session must never be shared across placements.
  */
 export function WalletSubscriptionCheckoutSlot({ amountCents, appearance, availabilityPaymentMethod, beforeConfirm, checkoutAnalytics, className, customerEmail, customerName, disabled = false, expressCheckoutAllowed = true, onAvailabilityChange, onCancel, onError, onPaymentInfoSubmitted, onSuccess, onUnavailableClick, options, placeholderLabel, renderPreparingPlaceholder, renderPlaceholder, returnUrl, session, slotClassName, summaryLabel, suspended = false, }) {
     const [walletAvailability, setWalletAvailability] = useState({
@@ -55,7 +55,8 @@ export function WalletSubscriptionCheckoutSlot({ amountCents, appearance, availa
         walletAvailable,
         walletPreparing: session.loading.wallet,
     });
-    const serverUpdateKey = session.activeClientSecret &&
+    const serverUpdateKey = session.updateCheckoutSessionPlan &&
+        session.activeClientSecret &&
         session.checkoutSessionId &&
         session.activePlanKey !== session.planKey
         ? session.planKey

package/dist/providers/stripe/components/index.d.ts

@@ -7,6 +7,7 @@ export * from './SharedStripeCheckoutV2Dialog.js';
 export * from './StripeCheckoutExpressCheckoutButton.js';
 export * from './StripeExpressCheckoutButton.js';
 export * from './StripeExpressCheckoutElement.js';
+export * from './StripeOneTimeWalletSurface.js';
 export * from './StripePlanSelector.js';
 export * from './StripeSubscriptionWalletSurface.js';
 export * from './WalletSubscriptionCheckoutSlot.js';

package/dist/providers/stripe/components/index.js

@@ -7,6 +7,7 @@ export * from './SharedStripeCheckoutV2Dialog.js';
 export * from './StripeCheckoutExpressCheckoutButton.js';
 export * from './StripeExpressCheckoutButton.js';
 export * from './StripeExpressCheckoutElement.js';
+export * from './StripeOneTimeWalletSurface.js';
 export * from './StripePlanSelector.js';
 export * from './StripeSubscriptionWalletSurface.js';
 export * from './WalletSubscriptionCheckoutSlot.js';

package/dist/providers/stripe/hooks/useStripeOneTimeCheckoutSession.d.ts

@@ -2,8 +2,11 @@ import type { Stripe } from '@stripe/stripe-js';
 import type { RuntimeMode } from '@funnelsgrove/runtime';
 import { type CheckoutPreparationLoading, type CheckoutPreparationSource } from '../../paymentProvider.types.js';
 import { type PaywallPlan, type StripeRuntimeConfigOverrides } from '../services/stripe.service.js';
-type StripeOneTimeCheckoutPlanInput = Pick<PaywallPlan, 'amountCents' | 'analyticsPurchaseValue' | 'description' | 'id' | 'providerPlanId' | 'title'>;
+type StripeOneTimeCheckoutPlanInput = Pick<PaywallPlan, 'amountCents' | 'analyticsPurchaseValue' | 'description' | 'id' | 'providerPlanId' | 'title' | 'funnelPlanKey' | 'offerSetId' | 'offerSetKey'>;
 export type StripeOneTimeCheckoutSessionInput = {
+    runtimeConfigRevisionId?: string | null;
+    paymentProfileId?: string | null;
+    provider?: 'stripe' | null;
     analyticsMetadata?: Record<string, unknown> | null;
     checkoutMode: RuntimeMode;
     couponId?: string | null;
@@ -40,10 +43,10 @@ export type StripeOneTimeCheckoutSession = {
     stripePromise: Promise<Stripe | null> | null;
 };
 export declare const buildStripeOneTimeCheckoutPreparationAnalyticsMetadata: (analyticsMetadata: Record<string, unknown> | null | undefined, options?: StripeOneTimeCheckoutPreparationOptions) => Record<string, unknown> | null | undefined;
-export type StripeOneTimeCheckoutIntentKeyInput = Pick<StripeOneTimeCheckoutSessionInput, 'checkoutMode' | 'couponId' | 'customerEmail' | 'plan' | 'returnUrl' | 'runtimeConfig' | 'stripePublishableKey' | 'userId'> & {
+export type StripeOneTimeCheckoutIntentKeyInput = Pick<StripeOneTimeCheckoutSessionInput, 'checkoutMode' | 'couponId' | 'customerEmail' | 'plan' | 'returnUrl' | 'runtimeConfig' | 'stripePublishableKey' | 'userId' | 'runtimeConfigRevisionId' | 'paymentProfileId' | 'provider'> & {
     analyticsMetadata?: Record<string, unknown> | null;
 };
-export declare function buildStripeOneTimeCheckoutIntentKey({ checkoutMode, couponId, customerEmail, plan, returnUrl, runtimeConfig, stripePublishableKey, userId, }: StripeOneTimeCheckoutIntentKeyInput): string;
+export declare function buildStripeOneTimeCheckoutIntentKey({ runtimeConfigRevisionId, paymentProfileId, provider, checkoutMode, couponId, customerEmail, plan, returnUrl, runtimeConfig, stripePublishableKey, userId, }: StripeOneTimeCheckoutIntentKeyInput): string;
 export declare function shouldResetStripeOneTimeCheckoutSessionForIntentKey(previousIntentKey: string | null, nextIntentKey: string): boolean;
-export declare function useStripeOneTimeCheckoutSession({ analyticsMetadata, checkoutMode, couponId, customerEmail, enabled, onError, plan, returnUrl, runtimeConfig, stripePublishableKey, userId, }: StripeOneTimeCheckoutSessionInput): StripeOneTimeCheckoutSession;
+export declare function useStripeOneTimeCheckoutSession({ runtimeConfigRevisionId, paymentProfileId, provider, analyticsMetadata, checkoutMode, couponId, customerEmail, enabled, onError, plan, returnUrl, runtimeConfig, stripePublishableKey, userId, }: StripeOneTimeCheckoutSessionInput): StripeOneTimeCheckoutSession;
 export {};

package/dist/providers/stripe/hooks/useStripeOneTimeCheckoutSession.js

@@ -36,9 +36,13 @@ export const buildStripeOneTimeCheckoutPreparationAnalyticsMetadata = (analytics
     const _b = analyticsMetadata !== null && analyticsMetadata !== void 0 ? analyticsMetadata : {}, { payment_method: _paymentMethod, paymentMethod: _camelCasePaymentMethod } = _b, metadata = __rest(_b, ["payment_method", "paymentMethod"]);
     return Object.assign(Object.assign(Object.assign({}, metadata), (checkoutStartSource ? { checkoutStartSource } : {})), (paymentMethod ? { payment_method: paymentMethod } : {}));
 };
-export function buildStripeOneTimeCheckoutIntentKey({ checkoutMode, couponId, customerEmail, plan, returnUrl, runtimeConfig, stripePublishableKey, userId, }) {
-    var _a;
+export function buildStripeOneTimeCheckoutIntentKey({ runtimeConfigRevisionId, paymentProfileId, provider, checkoutMode, couponId, customerEmail, plan, returnUrl, runtimeConfig, stripePublishableKey, userId, }) {
+    var _a, _b, _c, _d;
     const runtimeConfigSignature = [
+        (_a = runtimeConfig === null || runtimeConfig === void 0 ? void 0 : runtimeConfig.paymentsApiVersion) !== null && _a !== void 0 ? _a : 'v1',
+        runtimeConfigRevisionId !== null && runtimeConfigRevisionId !== void 0 ? runtimeConfigRevisionId : '',
+        paymentProfileId !== null && paymentProfileId !== void 0 ? paymentProfileId : '',
+        provider !== null && provider !== void 0 ? provider : '',
         normalizeRuntimeConfigValue(runtimeConfig === null || runtimeConfig === void 0 ? void 0 : runtimeConfig.apiBaseUrl),
         normalizeRuntimeConfigValue(runtimeConfig === null || runtimeConfig === void 0 ? void 0 : runtimeConfig.funnelId),
         normalizeRuntimeConfigValue(runtimeConfig === null || runtimeConfig === void 0 ? void 0 : runtimeConfig.funnelVersionId),
@@ -46,9 +50,11 @@ export function buildStripeOneTimeCheckoutIntentKey({ checkoutMode, couponId, cu
         normalizeRuntimeConfigValue(stripePublishableKey),
     ].join('|');
     const planSignature = [
+        (_b = plan === null || plan === void 0 ? void 0 : plan.offerSetId) !== null && _b !== void 0 ? _b : '',
+        (_c = plan === null || plan === void 0 ? void 0 : plan.funnelPlanKey) !== null && _c !== void 0 ? _c : '',
         normalizeRuntimeConfigValue(plan === null || plan === void 0 ? void 0 : plan.id),
         normalizeRuntimeConfigValue(plan === null || plan === void 0 ? void 0 : plan.providerPlanId),
-        (_a = plan === null || plan === void 0 ? void 0 : plan.amountCents) !== null && _a !== void 0 ? _a : '',
+        (_d = plan === null || plan === void 0 ? void 0 : plan.amountCents) !== null && _d !== void 0 ? _d : '',
     ].join('|');
     const customerEmailSignature = normalizeRuntimeConfigValue(customerEmail);
     const userIdSignature = normalizeRuntimeConfigValue(userId);
@@ -66,7 +72,7 @@ export function buildStripeOneTimeCheckoutIntentKey({ checkoutMode, couponId, cu
 export function shouldResetStripeOneTimeCheckoutSessionForIntentKey(previousIntentKey, nextIntentKey) {
     return previousIntentKey !== null && previousIntentKey !== nextIntentKey;
 }
-export function useStripeOneTimeCheckoutSession({ analyticsMetadata, checkoutMode, couponId, customerEmail, enabled = true, onError, plan, returnUrl, runtimeConfig, stripePublishableKey, userId, }) {
+export function useStripeOneTimeCheckoutSession({ runtimeConfigRevisionId, paymentProfileId, provider, analyticsMetadata, checkoutMode, couponId, customerEmail, enabled = true, onError, plan, returnUrl, runtimeConfig, stripePublishableKey, userId, }) {
     var _a, _b, _c;
     const [clientSecret, setClientSecret] = useState(null);
     const [clientSecretIntentKey, setClientSecretIntentKey] = useState(null);
@@ -76,11 +82,16 @@ export function useStripeOneTimeCheckoutSession({ analyticsMetadata, checkoutMod
     const [runtimeStripePublishableKey, setRuntimeStripePublishableKey] = useState(null);
     const creatingIntentRef = useRef(null);
     const requestIdRef = useRef(0);
+    const attemptRef = useRef(null);
+    const anonymousUserIdRef = useRef(null);
     const configured = enabled &&
         (isStripeConfigured(checkoutMode) ||
             Boolean(normalizeRuntimeConfigValue(runtimeConfig === null || runtimeConfig === void 0 ? void 0 : runtimeConfig.funnelSdkPublishableKey)) ||
             Boolean(normalizeRuntimeConfigValue(stripePublishableKey)));
     const intentKey = buildStripeOneTimeCheckoutIntentKey({
+        runtimeConfigRevisionId,
+        paymentProfileId,
+        provider,
         checkoutMode,
         couponId,
         customerEmail,
@@ -124,6 +135,7 @@ export function useStripeOneTimeCheckoutSession({ analyticsMetadata, checkoutMod
         onError === null || onError === void 0 ? void 0 : onError(message);
     }, [clearActiveCheckoutSession, onError]);
     const reset = useCallback(() => {
+        attemptRef.current = null;
         clearActiveCheckoutSession();
         setLoading(createEmptyCheckoutPreparationLoading());
         setRuntimeStripePublishableKey(null);
@@ -142,7 +154,7 @@ export function useStripeOneTimeCheckoutSession({ analyticsMetadata, checkoutMod
             : Object.assign(Object.assign({}, current), { [source]: value }));
     }, []);
     const createCheckoutSession = useCallback(async (options = {}) => {
-        var _a;
+        var _a, _b, _c;
         const forceNew = options.forceNew === true;
         if (!configured || !plan) {
             return null;
@@ -155,6 +167,14 @@ export function useStripeOneTimeCheckoutSession({ analyticsMetadata, checkoutMod
         }
         if (forceNew) {
             clearActiveCheckoutSession();
+            attemptRef.current = null;
+        }
+        if ((runtimeConfig === null || runtimeConfig === void 0 ? void 0 : runtimeConfig.paymentsApiVersion) === 'v2' && ((_b = attemptRef.current) === null || _b === void 0 ? void 0 : _b.key) !== intentKey) {
+            attemptRef.current = { key: intentKey, id: crypto.randomUUID() };
+        }
+        const idempotencyKey = (_c = attemptRef.current) === null || _c === void 0 ? void 0 : _c.id;
+        if (idempotencyKey && !userId && !anonymousUserIdRef.current) {
+            anonymousUserIdRef.current = `anonymous_${crypto.randomUUID()}`;
         }
         const requestKey = intentKey;
         const requestId = requestIdRef.current + 1;
@@ -163,6 +183,11 @@ export function useStripeOneTimeCheckoutSession({ analyticsMetadata, checkoutMod
             var _a, _b, _c, _d, _e, _f, _g, _h;
             try {
                 const response = await createStripeOneTimeCheckout({
+                    idempotencyKey,
+                    anonymousUserId: anonymousUserIdRef.current,
+                    runtimeConfigRevisionId,
+                    paymentProfileId,
+                    provider,
                     plan,
                     analyticsMetadata: buildStripeOneTimeCheckoutPreparationAnalyticsMetadata(analyticsMetadataRef.current, options),
                     couponId,
@@ -208,6 +233,9 @@ export function useStripeOneTimeCheckoutSession({ analyticsMetadata, checkoutMod
         return checkoutRequest;
     }, [
         activeClientSecret,
+        runtimeConfigRevisionId,
+        paymentProfileId,
+        provider,
         checkoutMode,
         clearActiveCheckoutSession,
         configured,

package/dist/providers/stripe/hooks/useStripeSubscriptionCheckoutSession.js

@@ -278,6 +278,9 @@ export function useStripeSubscriptionCheckoutSession({ checkoutMode, analyticsMe
             await updateStripeSubscriptionCheckoutPlan({
                 checkoutSessionId: activeCheckoutSessionId,
                 plan,
+                runtimeConfigRevisionId,
+                paymentProfileId,
+                provider,
                 analyticsMetadata: analyticsMetadataRef.current,
                 couponId,
                 customerEmail,
@@ -302,6 +305,9 @@ export function useStripeSubscriptionCheckoutSession({ checkoutMode, analyticsMe
         displayPlan,
         plan,
         planKey,
+        runtimeConfigRevisionId,
+        paymentProfileId,
+        provider,
         runtimeConfig,
         setError,
         userId,

package/dist/providers/stripe/services/stripe.service.d.ts

@@ -68,6 +68,11 @@ type CreatePaymentIntentResponse = {
 };
 type CreateOneTimeCheckoutInput = {
     plan: CheckoutSessionPlanInput;
+    runtimeConfigRevisionId?: string | null;
+    paymentProfileId?: string | null;
+    provider?: 'stripe' | null;
+    anonymousUserId?: string | null;
+    idempotencyKey?: string | null;
     couponId?: string | null;
     analyticsMetadata?: Record<string, unknown> | null;
     customerEmail?: string | null;
@@ -93,6 +98,11 @@ export declare function createStripeOneTimeCheckout(input: CreateOneTimeCheckout
 export declare function createStripePaymentIntent(input: CreatePaymentIntentInput): Promise<CreatePaymentIntentResponse>;
 export type ChargeOneClickPaymentInput = {
     planId: string;
+    planKey?: string | null;
+    offerSetId?: string | null;
+    runtimeConfigRevisionId?: string | null;
+    paymentProfileId?: string | null;
+    provider?: 'stripe' | null;
     providerPlanId?: string | null;
     amountCents: number;
     analyticsMetadata?: Record<string, unknown> | null;
@@ -155,6 +165,9 @@ type CreateSubscriptionCheckoutResponse = {
 type UpdateSubscriptionCheckoutPlanInput = {
     checkoutSessionId: string;
     plan: CheckoutSessionPlanInput;
+    runtimeConfigRevisionId?: string | null;
+    paymentProfileId?: string | null;
+    provider?: 'stripe' | null;
     couponId?: string | null;
     analyticsMetadata?: Record<string, unknown> | null;
     customerEmail?: string | null;

package/dist/providers/stripe/services/stripe.service.js

@@ -299,20 +299,26 @@ const normalizeCheckoutAnalyticsMetadata = (metadata, plan) => {
     return Object.assign(Object.assign({}, (normalized !== null && normalized !== void 0 ? normalized : {})), { analyticsPurchaseValue });
 };
 export async function createStripeOneTimeCheckout(input) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     return funnelSdkService.createOneTimeCheckout({
-        offerSetId: ((_a = input.plan.offerSetId) === null || _a === void 0 ? void 0 : _a.trim()) || undefined,
-        offerSetKey: ((_b = input.plan.offerSetKey) === null || _b === void 0 ? void 0 : _b.trim()) || undefined,
+        planKey: ((_a = input.plan.funnelPlanKey) === null || _a === void 0 ? void 0 : _a.trim()) || input.plan.id,
+        runtimeConfigRevisionId: input.runtimeConfigRevisionId,
+        paymentProfileId: input.paymentProfileId,
+        provider: input.provider,
+        anonymousUserId: input.anonymousUserId,
+        idempotencyKey: input.idempotencyKey,
+        offerSetId: ((_b = input.plan.offerSetId) === null || _b === void 0 ? void 0 : _b.trim()) || undefined,
+        offerSetKey: ((_c = input.plan.offerSetKey) === null || _c === void 0 ? void 0 : _c.trim()) || undefined,
         planId: getPaywallPlanRequestId(input.plan),
-        providerPlanId: ((_c = input.plan.providerPlanId) === null || _c === void 0 ? void 0 : _c.trim()) || undefined,
+        providerPlanId: ((_d = input.plan.providerPlanId) === null || _d === void 0 ? void 0 : _d.trim()) || undefined,
         title: input.plan.title,
-        description: ((_d = input.plan.description) === null || _d === void 0 ? void 0 : _d.trim()) || undefined,
+        description: ((_e = input.plan.description) === null || _e === void 0 ? void 0 : _e.trim()) || undefined,
         amountCents: input.plan.amountCents,
-        couponId: ((_e = input.couponId) === null || _e === void 0 ? void 0 : _e.trim()) || undefined,
+        couponId: ((_f = input.couponId) === null || _f === void 0 ? void 0 : _f.trim()) || undefined,
         analyticsMetadata: normalizeCheckoutAnalyticsMetadata(input.analyticsMetadata, input.plan),
-        customerEmail: ((_f = input.customerEmail) === null || _f === void 0 ? void 0 : _f.trim()) || undefined,
+        customerEmail: ((_g = input.customerEmail) === null || _g === void 0 ? void 0 : _g.trim()) || undefined,
         returnUrl: input.returnUrl,
-        userId: ((_g = input.user_id) === null || _g === void 0 ? void 0 : _g.trim()) || undefined,
+        userId: ((_h = input.user_id) === null || _h === void 0 ? void 0 : _h.trim()) || undefined,
         environment: input.environment,
         runtimeConfig: input.runtimeConfig,
     });
@@ -337,6 +343,11 @@ export async function createStripePaymentIntent(input) {
 export async function chargeStripeOneClickPayment(input) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j;
     return funnelSdkService.chargeOneClickPayment({
+        planKey: input.planKey,
+        offerSetId: input.offerSetId,
+        runtimeConfigRevisionId: input.runtimeConfigRevisionId,
+        paymentProfileId: input.paymentProfileId,
+        provider: input.provider,
         planId: input.planId,
         providerPlanId: ((_a = input.providerPlanId) === null || _a === void 0 ? void 0 : _a.trim()) || undefined,
         amountCents: input.amountCents,
@@ -417,7 +428,7 @@ export async function createStripeSubscriptionCheckout(input) {
     });
 }
 export async function updateStripeSubscriptionCheckoutPlan(input) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
     const recurring = resolveCheckoutPlanRecurringConfig(input.plan);
     if (!recurring) {
         throw new Error('Unable to resolve the recurring interval for the selected plan');
@@ -427,21 +438,25 @@ export async function updateStripeSubscriptionCheckoutPlan(input) {
         offerSetId: ((_a = input.plan.offerSetId) === null || _a === void 0 ? void 0 : _a.trim()) || undefined,
         offerSetKey: ((_b = input.plan.offerSetKey) === null || _b === void 0 ? void 0 : _b.trim()) || undefined,
         planId: getPaywallPlanRequestId(input.plan),
-        providerPlanId: ((_c = input.plan.providerPlanId) === null || _c === void 0 ? void 0 : _c.trim()) || undefined,
+        planKey: ((_c = input.plan.funnelPlanKey) === null || _c === void 0 ? void 0 : _c.trim()) || input.plan.id,
+        providerPlanId: ((_d = input.plan.providerPlanId) === null || _d === void 0 ? void 0 : _d.trim()) || undefined,
+        provider: input.provider,
+        paymentProfileId: ((_e = input.paymentProfileId) === null || _e === void 0 ? void 0 : _e.trim()) || undefined,
+        runtimeConfigRevisionId: ((_f = input.runtimeConfigRevisionId) === null || _f === void 0 ? void 0 : _f.trim()) || undefined,
         title: input.plan.title,
-        description: ((_d = input.plan.description) === null || _d === void 0 ? void 0 : _d.trim()) || undefined,
+        description: ((_g = input.plan.description) === null || _g === void 0 ? void 0 : _g.trim()) || undefined,
         amountCents: input.plan.amountCents,
         billingInterval: recurring.interval,
         billingIntervalCount: recurring.intervalCount,
-        followUpProviderPlanId: ((_e = input.plan.followUpProviderPlanId) === null || _e === void 0 ? void 0 : _e.trim()) || undefined,
-        followUpPlanTitle: ((_f = input.plan.followUpPlanTitle) === null || _f === void 0 ? void 0 : _f.trim()) || undefined,
+        followUpProviderPlanId: ((_h = input.plan.followUpProviderPlanId) === null || _h === void 0 ? void 0 : _h.trim()) || undefined,
+        followUpPlanTitle: ((_j = input.plan.followUpPlanTitle) === null || _j === void 0 ? void 0 : _j.trim()) || undefined,
         followUpBillingInterval: input.plan.followUpBillingInterval,
         followUpBillingIntervalCount: input.plan.followUpBillingIntervalCount,
         introIterations: input.plan.introIterations,
-        couponId: ((_g = input.couponId) === null || _g === void 0 ? void 0 : _g.trim()) || undefined,
+        couponId: ((_k = input.couponId) === null || _k === void 0 ? void 0 : _k.trim()) || undefined,
         analyticsMetadata: normalizeCheckoutAnalyticsMetadata(input.analyticsMetadata, input.plan),
-        customerEmail: ((_h = input.customerEmail) === null || _h === void 0 ? void 0 : _h.trim()) || undefined,
-        userId: ((_j = input.user_id) === null || _j === void 0 ? void 0 : _j.trim()) || undefined,
+        customerEmail: ((_l = input.customerEmail) === null || _l === void 0 ? void 0 : _l.trim()) || undefined,
+        userId: ((_m = input.user_id) === null || _m === void 0 ? void 0 : _m.trim()) || undefined,
         environment: input.environment,
         runtimeConfig: input.runtimeConfig,
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@funnelsgrove/payments",
-  "version": "0.9.1",
+  "version": "0.11.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/The-Solid-Grove/funnelsgrove.git",
@@ -32,8 +32,8 @@
     "test:run": "vitest run --passWithNoTests"
   },
   "dependencies": {
-    "@funnelsgrove/analytics": "^0.1.82",
-    "@funnelsgrove/runtime": "^0.9.0",
+    "@funnelsgrove/analytics": "^0.1.84",
+    "@funnelsgrove/runtime": "^0.11.0",
     "@solidgate/react-sdk": "1.34.0",
     "@stripe/react-stripe-js": "^5.6.0",
     "@stripe/stripe-js": "^8.7.0",