@funnelsgrove/payments 0.9.0 → 0.10.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
 
@@ -106,11 +108,11 @@ Funnels should call `resolvePublishedBillingRuntime` once at their runtime-provi
 - Stripe owns real card fields and wallet controls. Local wallet buttons are placeholders until Stripe confirms availability.
 - Keep `planId` as the funnel plan key and send Stripe's price id only as `providerPlanId`; the API uses both fields to resolve the active test/live offer mapping.
 - Wallet unavailable state must fall back to card/manual checkout or disappear.
-- Count `checkout_started` only at shared UI boundaries: when a shared card dialog opens or when Stripe reports an Apple Pay / Google Pay button click.
+- Count `checkout_started` only at shared UI boundaries: when a shared card dialog opens or when Stripe reports Apple Pay / Google Pay intent. Checkout Sessions use confirmation as a fallback because Stripe omits their click callback.
 - Pass `checkoutAnalytics` to every current shared dialog and wallet surface. The package then owns `checkout_started`, `add_payment_info`, and verified `checkout_completed`, all deduplicated by the actual Checkout Session.
 - Call funnel lifecycle `completeStep` only from the shared checkout `onSuccess` callback. Payment-info submission is not step completion.
 - Wallet slots may create render-only Checkout Sessions on mount so Apple Pay and Google Pay render before the visitor taps. Session creation is technical preparation and must never emit `checkout_started`.
-- Shared checkout analytics deduplicates `checkout_started` by Checkout Session id. Card submit and wallet confirmation must not emit it again.
+- Shared checkout analytics deduplicates `checkout_started` by Checkout Session id. Wallet confirmation may retry the start signal when the click callback is unavailable, without creating a duplicate.
 - Do not call `publicAnalyticsSdk.trackCheckoutStarted`, `trackPaymentInfoSubmitted`, or `trackCheckoutCompleted` directly from funnel checkout components.
 - Funnel paywalls should style wallet buttons through the shared slot API: `className` for the Stripe button/placeholder, `slotClassName` for the outer slot, `appearance` for Stripe Elements appearance, and `options` for Stripe Express Checkout options.
 - Keep discount math reusable here, but keep offer activation timing in funnel code.

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/StripeCheckoutExpressCheckoutButton.js

@@ -95,8 +95,18 @@ export function StripeCheckoutExpressCheckoutButton({ beforeConfirm, checkoutAna
         }
         await (onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess());
     };
+    const queueCheckoutStarted = (paymentMethod) => {
+        if (!checkoutAnalytics) {
+            return;
+        }
+        queueStripeSubscriptionCheckoutStarted(Object.assign(Object.assign({}, checkoutAnalytics), { checkoutSessionId, checkoutStartSource: 'wallet_click', paymentMethod }));
+    };
     const handleConfirm = async (event) => {
         var _a, _b, _c;
+        // Checkout Sessions omits the Express Checkout onClick callback. Confirmation
+        // is therefore the first reliable wallet-intent boundary for this provider.
+        // Session-based analytics deduplication keeps this idempotent if onClick fires.
+        queueCheckoutStarted(event.expressPaymentType);
         if (checkoutState.type !== 'success') {
             const message = checkoutState.type === 'error'
                 ? checkoutState.error.message
@@ -163,9 +173,7 @@ export function StripeCheckoutExpressCheckoutButton({ beforeConfirm, checkoutAna
         }
     };
     const handleClick = (event) => {
-        if (checkoutAnalytics) {
-            queueStripeSubscriptionCheckoutStarted(Object.assign(Object.assign({}, checkoutAnalytics), { checkoutSessionId, checkoutStartSource: 'wallet_click', paymentMethod: event.expressPaymentType }));
-        }
+        queueCheckoutStarted(event.expressPaymentType);
         event.resolve();
     };
     return (_jsxs(_Fragment, { children: [_jsx("div", { className: [

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/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

@@ -155,6 +155,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

@@ -417,7 +417,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 +427,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.0",
+  "version": "0.10.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.83",
+    "@funnelsgrove/runtime": "^0.10.0",
     "@solidgate/react-sdk": "1.34.0",
     "@stripe/react-stripe-js": "^5.6.0",
     "@stripe/stripe-js": "^8.7.0",