@funnelfox/billing 0.8.0 → 0.9.0-beta.1

package/dist/chunk-stripe-card-form.es.js

@@ -0,0 +1,62 @@
+/**
+ * @funnelfox/billing v0.1.0
+ * JavaScript SDK for Funnelfox billing with Primer integration
+ * 
+ * @author Funnelfox
+ * @license MIT
+ */
+import { g as getStripe } from './chunk-stripe-loader.es.js';
+import './chunk-index.es.js';
+
+async function mountStripeCardForm(element, session, params) {
+    const { stripe_public_key, stripe_intent, order_id } = session.data;
+    const { intent_client_secret, customer_session_client_secret } = stripe_intent;
+    const stripe = await getStripe(stripe_public_key);
+    if (!stripe)
+        throw new Error('Failed to load Stripe');
+    const stripeElements = stripe.elements({
+        clientSecret: intent_client_secret,
+        customerSessionClientSecret: customer_session_client_secret,
+        appearance: params.appearance,
+    });
+    const paymentElement = stripeElements.create('payment', {
+        layout: 'tabs',
+        wallets: {
+            applePay: params.showWallets ? 'auto' : 'never',
+            googlePay: params.showWallets ? 'auto' : 'never',
+        },
+        terms: { card: 'never' },
+    });
+    paymentElement.mount(element);
+    await new Promise((resolve, reject) => {
+        paymentElement.once('ready', () => resolve());
+        // 'loaderror' is a valid Stripe event but not yet in the @stripe/stripe-js types
+        paymentElement.once('loaderror', e => reject(e.error));
+    });
+    params.onRenderSuccess?.();
+    return {
+        submit: async () => {
+            params.onLoaderChange?.(true);
+            try {
+                const { error: submitError } = await stripeElements.submit();
+                if (submitError)
+                    throw submitError;
+                const { error, paymentMethod } = await stripe.createPaymentMethod({
+                    elements: stripeElements,
+                });
+                if (error)
+                    throw error;
+                params.onPaymentSuccess?.(paymentMethod, order_id);
+            }
+            catch (err) {
+                params.onPaymentFail?.(err);
+                throw err;
+            }
+            finally {
+                params.onLoaderChange?.(false);
+            }
+        },
+    };
+}
+
+export { mountStripeCardForm };

package/dist/chunk-stripe-loader.cjs.js

@@ -0,0 +1,20 @@
+/**
+ * @funnelfox/billing v0.1.0
+ * JavaScript SDK for Funnelfox billing with Primer integration
+ * 
+ * @author Funnelfox
+ * @license MIT
+ */
+'use strict';
+
+var index = require('./chunk-index.cjs.js');
+
+const cache = new Map();
+function getStripe(publicKey) {
+    if (!cache.has(publicKey)) {
+        cache.set(publicKey, index.loadStripe(publicKey));
+    }
+    return cache.get(publicKey);
+}
+
+exports.getStripe = getStripe;

package/dist/chunk-stripe-loader.es.js

@@ -0,0 +1,18 @@
+/**
+ * @funnelfox/billing v0.1.0
+ * JavaScript SDK for Funnelfox billing with Primer integration
+ * 
+ * @author Funnelfox
+ * @license MIT
+ */
+import { l as loadStripe } from './chunk-index.es.js';
+
+const cache = new Map();
+function getStripe(publicKey) {
+    if (!cache.has(publicKey)) {
+        cache.set(publicKey, loadStripe(publicKey));
+    }
+    return cache.get(publicKey);
+}
+
+export { getStripe as g };

package/dist/chunk-stripe-wallet.cjs.js

@@ -0,0 +1,80 @@
+/**
+ * @funnelfox/billing v0.1.0
+ * JavaScript SDK for Funnelfox billing with Primer integration
+ * 
+ * @author Funnelfox
+ * @license MIT
+ */
+'use strict';
+
+var stripeLoader = require('./chunk-stripe-loader.cjs.js');
+require('./chunk-index.cjs.js');
+
+function buildPaymentRequest(stripe, stripe_intent, totalLabel) {
+    return stripe.paymentRequest({
+        country: stripe_intent.country || 'US',
+        currency: stripe_intent.currency || 'usd',
+        total: {
+            label: totalLabel ?? 'Test Total',
+            amount: stripe_intent.amount || 1,
+        },
+        requestPayerName: false,
+        requestPayerEmail: false,
+    });
+}
+async function getAvailableWallet(session) {
+    const { stripe_public_key, stripe_intent } = session.data;
+    const stripe = await stripeLoader.getStripe(stripe_public_key);
+    if (!stripe)
+        throw new Error('Failed to load Stripe');
+    const paymentRequest = buildPaymentRequest(stripe, stripe_intent);
+    const result = await paymentRequest.canMakePayment();
+    if (!result)
+        return null;
+    if (result.applePay)
+        return 'APPLE_PAY';
+    if (result.googlePay)
+        return 'GOOGLE_PAY';
+    return null;
+}
+async function purchaseWallet(session, params) {
+    const { stripe_public_key, stripe_intent, order_id } = session.data;
+    const { intent_client_secret } = stripe_intent;
+    const stripe = await stripeLoader.getStripe(stripe_public_key);
+    if (!stripe)
+        throw new Error('Failed to load Stripe');
+    const paymentRequest = buildPaymentRequest(stripe, stripe_intent, params.totalLabel);
+    const canPay = await paymentRequest.canMakePayment();
+    if (!canPay)
+        throw new Error('No wallet payment method available');
+    return new Promise((resolve, reject) => {
+        paymentRequest.on('paymentmethod', async (event) => {
+            params.onLoaderChange?.(true);
+            try {
+                const { error } = await stripe.confirmCardPayment(intent_client_secret, { payment_method: event.paymentMethod.id }, { handleActions: false });
+                if (error) {
+                    event.complete('fail');
+                    throw error;
+                }
+                event.complete('success');
+                params.onPaymentSuccess?.(event.paymentMethod, order_id);
+                resolve();
+            }
+            catch (err) {
+                params.onPaymentFail?.(err);
+                reject(err);
+            }
+            finally {
+                params.onLoaderChange?.(false);
+            }
+        });
+        paymentRequest.on('cancel', () => {
+            params.onPaymentCancel?.();
+            resolve();
+        });
+        paymentRequest.show();
+    });
+}
+
+exports.getAvailableWallet = getAvailableWallet;
+exports.purchaseWallet = purchaseWallet;

package/dist/chunk-stripe-wallet.es.js

@@ -0,0 +1,77 @@
+/**
+ * @funnelfox/billing v0.1.0
+ * JavaScript SDK for Funnelfox billing with Primer integration
+ * 
+ * @author Funnelfox
+ * @license MIT
+ */
+import { g as getStripe } from './chunk-stripe-loader.es.js';
+import './chunk-index.es.js';
+
+function buildPaymentRequest(stripe, stripe_intent, totalLabel) {
+    return stripe.paymentRequest({
+        country: stripe_intent.country || 'US',
+        currency: stripe_intent.currency || 'usd',
+        total: {
+            label: totalLabel ?? 'Test Total',
+            amount: stripe_intent.amount || 1,
+        },
+        requestPayerName: false,
+        requestPayerEmail: false,
+    });
+}
+async function getAvailableWallet(session) {
+    const { stripe_public_key, stripe_intent } = session.data;
+    const stripe = await getStripe(stripe_public_key);
+    if (!stripe)
+        throw new Error('Failed to load Stripe');
+    const paymentRequest = buildPaymentRequest(stripe, stripe_intent);
+    const result = await paymentRequest.canMakePayment();
+    if (!result)
+        return null;
+    if (result.applePay)
+        return 'APPLE_PAY';
+    if (result.googlePay)
+        return 'GOOGLE_PAY';
+    return null;
+}
+async function purchaseWallet(session, params) {
+    const { stripe_public_key, stripe_intent, order_id } = session.data;
+    const { intent_client_secret } = stripe_intent;
+    const stripe = await getStripe(stripe_public_key);
+    if (!stripe)
+        throw new Error('Failed to load Stripe');
+    const paymentRequest = buildPaymentRequest(stripe, stripe_intent, params.totalLabel);
+    const canPay = await paymentRequest.canMakePayment();
+    if (!canPay)
+        throw new Error('No wallet payment method available');
+    return new Promise((resolve, reject) => {
+        paymentRequest.on('paymentmethod', async (event) => {
+            params.onLoaderChange?.(true);
+            try {
+                const { error } = await stripe.confirmCardPayment(intent_client_secret, { payment_method: event.paymentMethod.id }, { handleActions: false });
+                if (error) {
+                    event.complete('fail');
+                    throw error;
+                }
+                event.complete('success');
+                params.onPaymentSuccess?.(event.paymentMethod, order_id);
+                resolve();
+            }
+            catch (err) {
+                params.onPaymentFail?.(err);
+                reject(err);
+            }
+            finally {
+                params.onLoaderChange?.(false);
+            }
+        });
+        paymentRequest.on('cancel', () => {
+            params.onPaymentCancel?.();
+            resolve();
+        });
+        paymentRequest.show();
+    });
+}
+
+export { getAvailableWallet, purchaseWallet };

package/dist/funnelfox-billing.js

@@ -495,7 +495,7 @@
     /**
      * @fileoverview Constants for Funnefox SDK
      */
-    const SDK_VERSION = '0.8.0';
+    const SDK_VERSION = '0.9.0-beta.1';
     const DEFAULTS = {
         BASE_URL: 'https://billing.funnelfox.com',
         REGION: 'default',
@@ -1132,7 +1132,7 @@
         async createClientSession(params) {
             const payload = {
                 region: params.region || 'default',
-                integration_type: 'primer',
+                integration_type: params.integration ?? 'primer',
                 pp_ident: params.priceId,
                 external_id: params.externalId,
                 email_address: params.email,
@@ -1268,6 +1268,45 @@
         }
     }
 
+    class SessionService {
+        constructor() {
+            this.cache = new Map();
+        }
+        buildCacheKey(p) {
+            return [p.orgId, p.priceId, p.externalId, p.email, p.integration].join('-');
+        }
+        makeClient(orgId, baseUrl) {
+            return new APIClient({
+                baseUrl: baseUrl || DEFAULTS.BASE_URL,
+                orgId,
+                timeout: DEFAULTS.REQUEST_TIMEOUT,
+                retryAttempts: DEFAULTS.RETRY_ATTEMPTS,
+            });
+        }
+        createSession(p) {
+            const key = this.buildCacheKey(p);
+            const cached = this.cache.get(key);
+            if (cached)
+                return cached;
+            const client = this.makeClient(p.orgId, p.baseUrl);
+            const req = client.createClientSession({
+                priceId: p.priceId,
+                externalId: p.externalId,
+                email: p.email,
+                region: p.region || DEFAULTS.REGION,
+                clientMetadata: p.clientMetadata,
+                countryCode: p.countryCode,
+                integration: p.integration,
+            });
+            this.cache.set(key, req);
+            return req;
+        }
+        clearCache() {
+            this.cache.clear();
+        }
+    }
+    var sessionService = new SessionService();
+
     var loaderHtml = "<div class=\"ff-sdk-loader-container\">\n  <div class=\"ff-sdk-loader\"></div>\n</div>\n";
 
     if(typeof document!=="undefined")document.head.appendChild(document.createElement("style")).textContent=".ff-sdk-loader-container {\n    position: absolute;\n    top: 0;\n    left: 0;\n    width: 100%;\n    height: 100%;\n    display: flex;\n    justify-content: center;\n    align-items: center;\n    background-color: rgba(255, 255, 255);\n    z-index: 2;\n}\n\n.ff-sdk-loader {\n    width: 24px;\n    height: 24px;\n    border: 4px solid #e32f41;\n    border-top: 4px solid transparent;\n    border-radius: 50%;\n    animation: spin 1s linear infinite;\n}\n\n@keyframes spin {\n    0% {\n      transform: rotate(0deg);\n    }\n    100% {\n      transform: rotate(360deg);\n    }\n  }";
@@ -1862,6 +1901,12 @@
             this.cardEmailAddress = this.checkoutConfig.customer.email;
             this.shouldApplySessionCardholderNameConfig =
                 this.checkoutConfig.card?.cardholderName?.required === undefined;
+            this.apiClient = new APIClient({
+                baseUrl: this.baseUrl || DEFAULTS.BASE_URL,
+                orgId: this.orgId,
+                timeout: DEFAULTS.REQUEST_TIMEOUT,
+                retryAttempts: DEFAULTS.RETRY_ATTEMPTS,
+            });
             this._setupCallbackBridges();
         }
         _setupCallbackBridges() {
@@ -1903,64 +1948,35 @@
             }
         }
         async createSession() {
-            this.apiClient = new APIClient({
-                baseUrl: this.baseUrl || DEFAULTS.BASE_URL,
+            const response = await sessionService.createSession({
                 orgId: this.orgId,
-                timeout: DEFAULTS.REQUEST_TIMEOUT,
-                retryAttempts: DEFAULTS.RETRY_ATTEMPTS,
-            });
-            const sessionParams = {
+                baseUrl: this.baseUrl,
                 priceId: this.checkoutConfig.priceId,
                 externalId: this.checkoutConfig.customer.externalId,
                 email: this.checkoutConfig.customer.email,
-                region: this.region || DEFAULTS.REGION,
+                region: this.region,
                 clientMetadata: this.checkoutConfig.clientMetadata,
                 countryCode: this.checkoutConfig.customer.countryCode,
-            };
-            const cacheKey = [
-                this.orgId,
-                this.checkoutConfig.priceId,
-                this.checkoutConfig.customer.externalId,
-                this.checkoutConfig.customer.email,
-            ].join('-');
-            let sessionResponse;
-            // Return cached response if payload hasn't changed
-            const cachedResponse = CheckoutInstance.sessionCache.get(cacheKey);
-            if (cachedResponse) {
-                sessionResponse = await cachedResponse;
-            }
-            else {
-                const sessionRequest = this.apiClient
-                    .createClientSession(sessionParams)
-                    .then((response) => {
-                    const cachedResponse = response;
-                    if (response.data?.stripe_public_key) {
-                        const stripePublicKey = response.data.stripe_public_key;
-                        cachedResponse.radarSessionId = loadStripe(stripePublicKey)
-                            .then(stripe => stripe
-                            ? stripe
-                                .createRadarSession()
-                                .then(session => session?.radarSession?.id || '')
-                                .catch(() => '')
-                            : '')
-                            .catch(() => '');
-                    }
-                    // Initialize Airwallex device fingerprinting if enabled by backend
-                    if (response.data?.airwallex_risk_enabled) {
-                        const isLivemode = response.data?.is_livemode;
-                        const deviceId = generateUUID();
-                        cachedResponse.airwallexDeviceId = loadAirwallexDeviceFingerprint(deviceId, isLivemode)
-                            .then(() => deviceId)
-                            .catch(() => {
-                            // Silently fail - return deviceId anyway
-                            return deviceId;
-                        });
-                    }
-                    return cachedResponse;
-                });
-                // Cache the successful response
-                CheckoutInstance.sessionCache.set(cacheKey, sessionRequest);
-                sessionResponse = await sessionRequest;
+                integration: 'primer',
+            });
+            const sessionResponse = response;
+            if (response.data?.stripe_public_key) {
+                const stripePublicKey = response.data.stripe_public_key;
+                sessionResponse.radarSessionId = loadStripe(stripePublicKey)
+                    .then(stripe => stripe
+                    ? stripe
+                        .createRadarSession()
+                        .then(session => session?.radarSession?.id || '')
+                        .catch(() => '')
+                    : '')
+                    .catch(() => '');
+            }
+            if (response.data?.airwallex_risk_enabled) {
+                const isLivemode = response.data?.is_livemode;
+                const deviceId = generateUUID();
+                sessionResponse.airwallexDeviceId = loadAirwallexDeviceFingerprint(deviceId, isLivemode)
+                    .then(() => deviceId)
+                    .catch(() => deviceId);
             }
             this.cachedSessionResponse = sessionResponse;
             this.isTelemetryEnabled = !!sessionResponse.data?.sdk_telemetry_enabled;
@@ -2219,8 +2235,7 @@
             try {
                 this.onLoaderChangeWithRace(true);
                 this._setState('updating');
-                // Invalidate session cache
-                CheckoutInstance.sessionCache.clear();
+                sessionService.clearCache();
                 await this.apiClient.updateClientSession({
                     orderId: this.orderId,
                     clientToken: this.clientToken,
@@ -2253,7 +2268,7 @@
                 return;
             try {
                 this.stopUnhandledTelemetry();
-                CheckoutInstance.sessionCache.clear();
+                sessionService.clearCache();
                 await this.primerWrapper.destroy();
                 this._setState('destroyed');
                 this.orderId = null;
@@ -2464,7 +2479,6 @@
             this.telemetryPaymentMethod = undefined;
         }
     }
-    CheckoutInstance.sessionCache = new Map();
 
     /**
      * @fileoverview Public API with configuration and orchestration logic
@@ -2655,6 +2669,71 @@
             throw error;
         }
     }
+    async function createStripeCardForm(element, params) {
+        const config = resolveConfig(params, 'createStripeCardForm');
+        const [session, { mountStripeCardForm }] = await Promise.all([
+            sessionService.createSession({
+                orgId: config.orgId,
+                baseUrl: config.baseUrl,
+                region: config.region,
+                priceId: params.priceId,
+                externalId: params.externalId,
+                email: params.email,
+                clientMetadata: params.clientMetadata,
+                countryCode: params.countryCode,
+                integration: 'stripe',
+            }),
+            Promise.resolve().then(function () { return stripeCardForm; }),
+        ]);
+        return mountStripeCardForm(element, session, params);
+    }
+    async function purchaseStripeWallet(params) {
+        const config = resolveConfig(params, 'purchaseStripeWallet');
+        const [session, { purchaseWallet }] = await Promise.all([
+            sessionService.createSession({
+                orgId: config.orgId,
+                baseUrl: config.baseUrl,
+                region: config.region,
+                priceId: params.priceId,
+                externalId: params.externalId,
+                email: params.email,
+                clientMetadata: params.clientMetadata,
+                countryCode: params.countryCode,
+                integration: 'stripe',
+            }),
+            Promise.resolve().then(function () { return stripeWallet; }),
+        ]);
+        return purchaseWallet(session, params);
+    }
+    async function getAvailableStripeWallet(params) {
+        const config = resolveConfig(params, 'getAvailableStripeWallet');
+        const [session, { getAvailableWallet }] = await Promise.all([
+            sessionService.createSession({
+                orgId: config.orgId,
+                baseUrl: config.baseUrl,
+                region: config.region,
+                priceId: params.priceId,
+                externalId: params.externalId,
+                email: params.email,
+                clientMetadata: params.clientMetadata,
+                countryCode: params.countryCode,
+                integration: 'stripe',
+            }),
+            Promise.resolve().then(function () { return stripeWallet; }),
+        ]);
+        const result = await getAvailableWallet(session);
+        if (result === 'APPLE_PAY')
+            return exports.PaymentMethod.APPLE_PAY;
+        if (result === 'GOOGLE_PAY')
+            return exports.PaymentMethod.GOOGLE_PAY;
+        return null;
+    }
+    async function getAvailableStripePaymentMethods(params) {
+        const wallet = await getAvailableStripeWallet(params);
+        return wallet
+            ? [exports.PaymentMethod.PAYMENT_CARD, wallet]
+            : [exports.PaymentMethod.PAYMENT_CARD];
+    }
 
     /**
      * @fileoverview Main entry point for @funnelfox/billing
@@ -2666,6 +2745,12 @@
         initMethod: initMethod,
         silentPurchase: silentPurchase,
         getAvailablePaymentMethods: getAvailablePaymentMethods,
+        stripe: {
+            createCardForm: createStripeCardForm,
+            purchaseWallet: purchaseStripeWallet,
+            getAvailableWallet: getAvailableStripeWallet,
+            getAvailablePaymentMethods: getAvailableStripePaymentMethods,
+        },
     };
     if (typeof window !== 'undefined') {
         window.Billing = Billing;
@@ -3069,6 +3154,142 @@
         default: createDefaultSkin
     });
 
+    const cache = new Map();
+    function getStripe(publicKey) {
+        if (!cache.has(publicKey)) {
+            cache.set(publicKey, loadStripe(publicKey));
+        }
+        return cache.get(publicKey);
+    }
+
+    async function mountStripeCardForm(element, session, params) {
+        const { stripe_public_key, stripe_intent, order_id } = session.data;
+        const { intent_client_secret, customer_session_client_secret } = stripe_intent;
+        const stripe = await getStripe(stripe_public_key);
+        if (!stripe)
+            throw new Error('Failed to load Stripe');
+        const stripeElements = stripe.elements({
+            clientSecret: intent_client_secret,
+            customerSessionClientSecret: customer_session_client_secret,
+            appearance: params.appearance,
+        });
+        const paymentElement = stripeElements.create('payment', {
+            layout: 'tabs',
+            wallets: {
+                applePay: params.showWallets ? 'auto' : 'never',
+                googlePay: params.showWallets ? 'auto' : 'never',
+            },
+            terms: { card: 'never' },
+        });
+        paymentElement.mount(element);
+        await new Promise((resolve, reject) => {
+            paymentElement.once('ready', () => resolve());
+            // 'loaderror' is a valid Stripe event but not yet in the @stripe/stripe-js types
+            paymentElement.once('loaderror', e => reject(e.error));
+        });
+        params.onRenderSuccess?.();
+        return {
+            submit: async () => {
+                params.onLoaderChange?.(true);
+                try {
+                    const { error: submitError } = await stripeElements.submit();
+                    if (submitError)
+                        throw submitError;
+                    const { error, paymentMethod } = await stripe.createPaymentMethod({
+                        elements: stripeElements,
+                    });
+                    if (error)
+                        throw error;
+                    params.onPaymentSuccess?.(paymentMethod, order_id);
+                }
+                catch (err) {
+                    params.onPaymentFail?.(err);
+                    throw err;
+                }
+                finally {
+                    params.onLoaderChange?.(false);
+                }
+            },
+        };
+    }
+
+    var stripeCardForm = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        mountStripeCardForm: mountStripeCardForm
+    });
+
+    function buildPaymentRequest(stripe, stripe_intent, totalLabel) {
+        return stripe.paymentRequest({
+            country: stripe_intent.country || 'US',
+            currency: stripe_intent.currency || 'usd',
+            total: {
+                label: totalLabel ?? 'Test Total',
+                amount: stripe_intent.amount || 1,
+            },
+            requestPayerName: false,
+            requestPayerEmail: false,
+        });
+    }
+    async function getAvailableWallet(session) {
+        const { stripe_public_key, stripe_intent } = session.data;
+        const stripe = await getStripe(stripe_public_key);
+        if (!stripe)
+            throw new Error('Failed to load Stripe');
+        const paymentRequest = buildPaymentRequest(stripe, stripe_intent);
+        const result = await paymentRequest.canMakePayment();
+        if (!result)
+            return null;
+        if (result.applePay)
+            return 'APPLE_PAY';
+        if (result.googlePay)
+            return 'GOOGLE_PAY';
+        return null;
+    }
+    async function purchaseWallet(session, params) {
+        const { stripe_public_key, stripe_intent, order_id } = session.data;
+        const { intent_client_secret } = stripe_intent;
+        const stripe = await getStripe(stripe_public_key);
+        if (!stripe)
+            throw new Error('Failed to load Stripe');
+        const paymentRequest = buildPaymentRequest(stripe, stripe_intent, params.totalLabel);
+        const canPay = await paymentRequest.canMakePayment();
+        if (!canPay)
+            throw new Error('No wallet payment method available');
+        return new Promise((resolve, reject) => {
+            paymentRequest.on('paymentmethod', async (event) => {
+                params.onLoaderChange?.(true);
+                try {
+                    const { error } = await stripe.confirmCardPayment(intent_client_secret, { payment_method: event.paymentMethod.id }, { handleActions: false });
+                    if (error) {
+                        event.complete('fail');
+                        throw error;
+                    }
+                    event.complete('success');
+                    params.onPaymentSuccess?.(event.paymentMethod, order_id);
+                    resolve();
+                }
+                catch (err) {
+                    params.onPaymentFail?.(err);
+                    reject(err);
+                }
+                finally {
+                    params.onLoaderChange?.(false);
+                }
+            });
+            paymentRequest.on('cancel', () => {
+                params.onPaymentCancel?.();
+                resolve();
+            });
+            paymentRequest.show();
+        });
+    }
+
+    var stripeWallet = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        getAvailableWallet: getAvailableWallet,
+        purchaseWallet: purchaseWallet
+    });
+
     exports.APIError = APIError;
     exports.Billing = Billing;
     exports.CHECKOUT_STATES = CHECKOUT_STATES;