@flopay/js 0.1.0

package/dist/index.cjs

@@ -0,0 +1,894 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FloPay: () => FloPay,
+  FloPayElements: () => FloPayElements,
+  PaymentAPI: () => PaymentAPI,
+  StripeAdapter: () => StripeAdapter,
+  createCheckoutSession: () => createCheckoutSession,
+  createCheckoutSessionWithRetries: () => createCheckoutSessionWithRetries,
+  loadFloPay: () => loadFloPay
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/load.ts
+var import_shared5 = require("@flopay/shared");
+
+// src/stripe-adapter.ts
+var import_shared = require("@flopay/shared");
+function toStripeElementType(type) {
+  const map = {
+    payment: "payment",
+    card: "card",
+    cardNumber: "cardNumber",
+    cardExpiry: "cardExpiry",
+    cardCvc: "cardCvc",
+    address: "address"
+  };
+  return map[type];
+}
+function wrapStripeElement(stripeElement) {
+  const el = stripeElement;
+  return {
+    mount(container) {
+      el.mount(container);
+    },
+    unmount() {
+      el.unmount();
+    },
+    update(options) {
+      el.update(options);
+    },
+    on(event, handler) {
+      el["on"]?.(event, handler);
+    },
+    off(event, handler) {
+      el["off"]?.(event, handler);
+    },
+    destroy() {
+      el.destroy();
+    }
+  };
+}
+var StripeAdapter = class {
+  constructor() {
+    this.name = "stripe";
+    this.stripe = null;
+    this.elements = null;
+  }
+  async initialize(config) {
+    if (typeof window === "undefined") {
+      return;
+    }
+    const { loadStripe } = await import("@stripe/stripe-js");
+    const stripe = await loadStripe(config.publishableKey, {
+      locale: config.locale ?? "auto"
+    });
+    if (!stripe) {
+      throw new import_shared.FloPayError(
+        "Failed to initialize Stripe. Check your publishable key.",
+        "authentication_error"
+      );
+    }
+    this.stripe = stripe;
+  }
+  /** Lazily creates the Stripe Elements group for the given options. */
+  getElements(options) {
+    if (!this.stripe) {
+      throw new import_shared.FloPayError(
+        "StripeAdapter not initialized. Call initialize() first.",
+        "api_error"
+      );
+    }
+    if (!this.elements) {
+      let elementsOptions;
+      if (options?.clientSecret) {
+        elementsOptions = { clientSecret: options.clientSecret };
+      } else {
+        elementsOptions = {
+          mode: "payment",
+          amount: options?.amount ?? 0,
+          currency: (options?.currency ?? "usd").toLowerCase(),
+          paymentMethodCreation: options?.paymentMethodCreation ?? "manual"
+        };
+      }
+      if (options?.appearance) {
+        elementsOptions["appearance"] = {
+          theme: options.appearance.theme ?? "stripe",
+          variables: options.appearance.variables,
+          rules: options.appearance.rules
+        };
+      }
+      this.elements = this.stripe.elements(elementsOptions);
+    }
+    return this.elements;
+  }
+  async createElement(type, options) {
+    const elements = this.getElements(options);
+    const stripeType = toStripeElementType(type);
+    const elementOptions = {};
+    if (options.layout) {
+      elementOptions["layout"] = options.layout;
+    }
+    if (options.defaultValues) {
+      elementOptions["defaultValues"] = options.defaultValues;
+    }
+    if (options.readOnly) {
+      elementOptions["readOnly"] = options.readOnly;
+    }
+    if (options.mode) {
+      elementOptions["mode"] = options.mode;
+    }
+    const stripeElement = elements.create(stripeType, elementOptions);
+    return wrapStripeElement(stripeElement);
+  }
+  getElement(type) {
+    if (!this.elements) return null;
+    const stripeType = toStripeElementType(type);
+    const existing = this.elements.getElement(stripeType);
+    if (!existing) return null;
+    return wrapStripeElement(existing);
+  }
+  async submitElements() {
+    if (!this.stripe || !this.elements) {
+      return { error: new import_shared.FloPayError("Stripe not initialized", "api_error") };
+    }
+    const { error } = await this.elements.submit();
+    if (error) {
+      return {
+        error: new import_shared.FloPayError(error.message ?? "Validation failed", "validation_error")
+      };
+    }
+    return {};
+  }
+  async createPaymentMethod() {
+    if (!this.stripe || !this.elements) {
+      return {
+        paymentMethodId: null,
+        error: new import_shared.FloPayError("Stripe not initialized", "api_error")
+      };
+    }
+    const cardNumberEl = this.elements.getElement("cardNumber");
+    const { error, paymentMethod } = cardNumberEl ? await this.stripe.createPaymentMethod({
+      type: "card",
+      card: cardNumberEl
+    }) : await this.stripe.createPaymentMethod({
+      elements: this.elements
+    });
+    if (error) {
+      return {
+        paymentMethodId: null,
+        error: new import_shared.FloPayError(
+          error.message ?? "Failed to create payment method",
+          "api_error",
+          { code: error.code }
+        )
+      };
+    }
+    return { paymentMethodId: paymentMethod.id };
+  }
+  async confirmCardPayment(params) {
+    if (!this.stripe) {
+      return {
+        status: "failed",
+        error: new import_shared.FloPayError("Stripe not initialized", "api_error")
+      };
+    }
+    const { error, paymentIntent } = await this.stripe.confirmCardPayment(
+      params.clientSecret,
+      { payment_method: params.paymentMethodId }
+    );
+    if (error) {
+      return {
+        status: "failed",
+        error: new import_shared.FloPayError(
+          error.message ?? "Payment failed",
+          "api_error",
+          { code: error.code, declineCode: error.decline_code }
+        )
+      };
+    }
+    return {
+      status: paymentIntent?.status ?? "failed",
+      paymentIntentId: paymentIntent?.id
+    };
+  }
+  async confirmPayment(params) {
+    if (!this.stripe || !this.elements) {
+      throw new import_shared.FloPayError(
+        "StripeAdapter not initialized or no elements created.",
+        "api_error"
+      );
+    }
+    const { error, paymentIntent } = await this.stripe.confirmPayment({
+      elements: this.elements,
+      clientSecret: params.clientSecret,
+      confirmParams: {
+        return_url: params.returnUrl ?? window.location.href
+      },
+      redirect: "if_required"
+    });
+    if (error) {
+      return {
+        status: "failed",
+        error: new import_shared.FloPayError(
+          error.message ?? "Payment failed",
+          "api_error",
+          {
+            code: error.code,
+            declineCode: error.decline_code
+          }
+        )
+      };
+    }
+    if (!paymentIntent) {
+      return { status: "failed", error: new import_shared.FloPayError("No payment intent returned", "api_error") };
+    }
+    const statusMap = {
+      succeeded: "succeeded",
+      processing: "processing",
+      requires_action: "requires_action",
+      requires_payment_method: "failed",
+      canceled: "failed"
+    };
+    return {
+      status: statusMap[paymentIntent.status] ?? "failed",
+      paymentIntentId: paymentIntent.id
+    };
+  }
+  async confirmPayPalPayment(params) {
+    if (!this.stripe) {
+      return { status: "failed", error: new import_shared.FloPayError("Stripe not initialized", "api_error") };
+    }
+    const baseUrl = params.billingApiUrl.replace(/\/+$/, "");
+    const createPM = this.stripe.createPaymentMethod;
+    const { error: pmError, paymentMethod } = await createPM({ type: "paypal" });
+    if (pmError) {
+      console.warn("[FloPay] Could not create PayPal PM upfront:", pmError.message);
+    }
+    const intentResponse = await fetch(`${baseUrl}/v1/checkouts/payments/intents`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        sessionId: params.sessionId,
+        email: params.email,
+        paymentMethodType: paymentMethod?.id ?? "paypal",
+        isPaypal: "true"
+      })
+    });
+    if (!intentResponse.ok) {
+      return { status: "failed", error: new import_shared.FloPayError("Failed to create PayPal payment intent", "api_error") };
+    }
+    const intentJson = await intentResponse.json();
+    const intentClientSecret = intentJson.data?.id;
+    if (!intentClientSecret) {
+      return { status: "failed", error: new import_shared.FloPayError("No client_secret in response", "api_error") };
+    }
+    const confirmParams = {
+      return_url: params.returnUrl
+    };
+    if (paymentMethod?.id) {
+      confirmParams["payment_method"] = paymentMethod.id;
+    }
+    const { error, paymentIntent } = await this.stripe.confirmPayment({
+      clientSecret: intentClientSecret,
+      confirmParams,
+      redirect: "if_required"
+    });
+    if (error) {
+      return {
+        status: "failed",
+        error: new import_shared.FloPayError(error.message ?? "PayPal payment failed", "api_error", { code: error.code })
+      };
+    }
+    const pmId = typeof paymentIntent?.payment_method === "string" ? paymentIntent.payment_method : paymentIntent?.payment_method?.id;
+    return {
+      status: paymentIntent?.status ?? "failed",
+      paymentIntentId: paymentIntent?.id,
+      paymentMethodId: pmId
+    };
+  }
+  async resumePayPalPayment() {
+    if (!this.stripe || typeof window === "undefined") return null;
+    const params = new URLSearchParams(window.location.search);
+    const paymentIntentId = params.get("payment_intent");
+    const clientSecret = params.get("payment_intent_client_secret");
+    const redirectStatus = params.get("redirect_status");
+    if (!paymentIntentId || !clientSecret) return null;
+    if (redirectStatus === "failed") {
+      return {
+        status: "failed",
+        error: new import_shared.FloPayError("PayPal payment was declined. Please try again.", "api_error")
+      };
+    }
+    const { paymentIntent, error } = await this.stripe.retrievePaymentIntent(clientSecret);
+    if (error) {
+      return {
+        status: "failed",
+        error: new import_shared.FloPayError(error.message ?? "Failed to retrieve PayPal payment", "api_error")
+      };
+    }
+    if (paymentIntent && (paymentIntent.status === "requires_capture" || paymentIntent.status === "succeeded")) {
+      const pmId = typeof paymentIntent.payment_method === "string" ? paymentIntent.payment_method : paymentIntent.payment_method?.id;
+      const url = new URL(window.location.href);
+      url.searchParams.delete("payment_intent");
+      url.searchParams.delete("payment_intent_client_secret");
+      url.searchParams.delete("redirect_status");
+      window.history.replaceState({}, "", url.toString());
+      return {
+        status: paymentIntent.status,
+        paymentIntentId: paymentIntent.id,
+        paymentMethodId: pmId
+      };
+    }
+    return {
+      status: "failed",
+      error: new import_shared.FloPayError("PayPal payment was not completed. Please try again.", "api_error")
+    };
+  }
+  getRawProvider() {
+    return this.stripe;
+  }
+  createPayPalElements(options) {
+    if (!this.stripe) return null;
+    const elementsOptions = {
+      mode: "payment",
+      amount: options.amount ?? 0,
+      currency: (options.currency ?? "usd").toLowerCase(),
+      captureMethod: "manual"
+    };
+    if (options.appearance) {
+      elementsOptions["appearance"] = {
+        theme: options.appearance.theme ?? "stripe",
+        variables: options.appearance.variables,
+        rules: options.appearance.rules
+      };
+    }
+    return this.stripe.elements(elementsOptions);
+  }
+  destroy() {
+    this.elements = null;
+    this.stripe = null;
+  }
+};
+
+// src/flopay.ts
+var import_shared4 = require("@flopay/shared");
+
+// src/elements.ts
+var import_shared2 = require("@flopay/shared");
+var FloPayElements = class {
+  constructor(provider, options) {
+    this.elementMap = /* @__PURE__ */ new Map();
+    this.provider = provider;
+    this.baseOptions = options ?? {};
+  }
+  /**
+   * Creates a new element of the given type.
+   * If an element of that type already exists, it is destroyed first.
+   */
+  async create(type, options) {
+    const providerExisting = this.provider.getElement(type);
+    if (providerExisting) {
+      this.elementMap.set(type, providerExisting);
+      return providerExisting;
+    }
+    const existing = this.elementMap.get(type);
+    if (existing) {
+      existing.destroy();
+    }
+    const merged = { ...this.baseOptions, ...options };
+    const element = await this.provider.createElement(type, merged);
+    this.elementMap.set(type, element);
+    return element;
+  }
+  /** Returns a previously created element, or `null`. */
+  getElement(type) {
+    return this.elementMap.get(type) ?? null;
+  }
+  /**
+   * Submits all mounted elements for validation.
+   *
+   * Returns an object with an optional error if validation fails.
+   * This does NOT confirm the payment — call `floPay.confirmPayment()` for that.
+   */
+  async submit() {
+    return {};
+  }
+  /** Destroys all created elements and clears the internal map. */
+  destroy() {
+    for (const element of this.elementMap.values()) {
+      element.destroy();
+    }
+    this.elementMap.clear();
+  }
+};
+
+// src/payment-api.ts
+var import_shared3 = require("@flopay/shared");
+var PaymentAPI = class {
+  constructor(billingApiUrl) {
+    this.baseUrl = billingApiUrl.replace(/\/+$/, "");
+  }
+  /** Fetch a raw checkout session by ID. */
+  async getCheckoutSession(checkoutSessionId) {
+    const response = await fetch(
+      `${this.baseUrl}/v1/checkouts/sessions/${checkoutSessionId}`
+    );
+    if (!response.ok) {
+      throw new import_shared3.FloPayError(
+        "Failed to get checkout session",
+        "api_error",
+        { code: `http_${response.status}` }
+      );
+    }
+    return response.json();
+  }
+  /**
+   * Fetch and normalize a checkout session.
+   *
+   * Reads the backend's `gateway` field to determine the provider,
+   * then wraps the session in a `NormalizedCheckoutSession` for
+   * provider-agnostic consumption.
+   */
+  async getUnifiedCheckoutSession(checkoutSessionId) {
+    const res = await this.getCheckoutSession(checkoutSessionId);
+    const session = res.data;
+    const gateway = session.gateway;
+    if (gateway === "chargebee") {
+      return {
+        provider: "chargebee",
+        mode: "tokenize",
+        data: { session: this.toCheckoutSession(session) },
+        raw: res
+      };
+    }
+    if (gateway === "stripe") {
+      return {
+        provider: "stripe",
+        mode: "tokenize",
+        data: {
+          session: this.toCheckoutSession(session),
+          stripe: {
+            clientSecret: session["stripeClientSecret"] ?? "",
+            publishableKey: session.gatewayData?.publishableKey ?? void 0
+          }
+        },
+        raw: res
+      };
+    }
+    return {
+      provider: "recurly",
+      mode: "tokenize",
+      data: { session: this.toCheckoutSession(session) },
+      raw: res
+    };
+  }
+  /**
+   * Submit a tokenized payment to the billing backend.
+   *
+   * The backend will either succeed, return `type: '3ds_required'`
+   * (with a `threeDSecureToken`), or return `type: 'paypal_redirect_required'`.
+   */
+  async processPayment(userId, data) {
+    return fetch(
+      `${this.baseUrl}/v1/checkouts/sessions/process`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-user-id": userId
+        },
+        body: JSON.stringify(data)
+      }
+    );
+  }
+  /**
+   * Create a PaymentIntent on the backend.
+   *
+   * Used by the Stripe flow to create a server-side PaymentIntent
+   * with the client's payment method attached.
+   */
+  async createPaymentIntent(sessionId, email, paymentMethodType, options) {
+    return fetch(
+      `${this.baseUrl}/v1/checkouts/payments/intents`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          sessionId,
+          email,
+          paymentMethodType,
+          isPaypal: options?.isPaypal ?? false
+        }),
+        signal: options?.signal
+      }
+    );
+  }
+  /**
+   * Create a SetupIntent for saving payment methods.
+   */
+  async createSetupIntent(sessionId, email, paymentMethodType, options) {
+    return fetch(
+      `${this.baseUrl}/v1/checkouts/payments/setup-intents`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ sessionId, email, paymentMethodType }),
+        signal: options?.signal
+      }
+    );
+  }
+  /**
+   * Fetch user's prior payments by email.
+   * Used to determine if saved card UX should be shown.
+   */
+  async getPaymentsByEmail(email, options) {
+    const page = options?.page ?? 1;
+    const limit = options?.limit ?? 1;
+    const params = new URLSearchParams({
+      email,
+      page: String(page),
+      limit: String(limit),
+      sortField: "occurredAt",
+      sortDirection: "DESC"
+    });
+    const response = await fetch(
+      `${this.baseUrl}/v1/payments?${params.toString()}`,
+      {
+        method: "GET",
+        signal: options?.signal,
+        keepalive: true
+      }
+    );
+    if (!response.ok) {
+      throw new import_shared3.FloPayError("Failed to fetch payments", "api_error");
+    }
+    return response.json();
+  }
+  /** Convert raw session to the SDK CheckoutSession shape. */
+  toCheckoutSession(raw) {
+    const totalAmount = [
+      ...raw.subscriptions.map((s) => s.overrideAmount || s.totalAmount),
+      ...raw.items.map((i) => i.overrideAmount || i.totalAmount)
+    ].reduce((sum, val) => sum + val, 0);
+    const amountInCents = Math.round(totalAmount * 100);
+    return {
+      // Core fields (backward compat)
+      id: raw.uuid,
+      clientSecret: raw.nonce,
+      mode: raw.subscriptions.length > 0 ? "subscription" : "payment",
+      status: raw.status === "completed" ? "complete" : "open",
+      amount: amountInCents,
+      currency: raw.subscriptions[0]?.currency ?? raw.items[0]?.currency ?? "USD",
+      customer: {
+        id: raw.accountData.userId,
+        email: raw.accountData.email,
+        firstName: raw.accountData.firstName,
+        lastName: raw.accountData.lastName,
+        country: raw.accountData.country ?? void 0,
+        city: raw.accountData.city ?? void 0,
+        state: raw.accountData.state ?? void 0,
+        zip: raw.accountData.zip ?? void 0,
+        gender: raw.accountData.gender ?? void 0
+      },
+      metadata: {},
+      // Full session data from billing API
+      checkoutMode: raw.checkoutMode,
+      items: raw.items,
+      subscriptions: raw.subscriptions,
+      successUrl: raw.successUrl,
+      cancelUrl: raw.cancelUrl,
+      coupons: raw.coupons,
+      createdAt: raw.createdAt,
+      gateway: raw.gateway,
+      gatewayData: raw.gatewayData,
+      accountData: raw.accountData,
+      tagsData: raw.tagsData
+    };
+  }
+};
+
+// src/flopay.ts
+var FloPay = class {
+  constructor(provider, config) {
+    this.currentElements = null;
+    this.provider = provider;
+    this.config = config;
+  }
+  /**
+   * Creates a new `FloPayElements` group for mounting payment fields.
+   *
+   * Only one elements group is active at a time. Creating a new one
+   * destroys the previous group.
+   */
+  elements(options) {
+    if (this.currentElements) {
+      this.currentElements.destroy();
+    }
+    this.currentElements = new FloPayElements(this.provider, {
+      appearance: this.config.appearance,
+      ...options
+    });
+    return this.currentElements;
+  }
+  /** Submit elements for validation. */
+  async submitElements() {
+    return this.provider.submitElements();
+  }
+  /** Create a payment method from the current elements (tokenize card). */
+  async createPaymentMethod() {
+    return this.provider.createPaymentMethod();
+  }
+  /** Confirm a card payment with a known client secret and payment method ID. */
+  async confirmCardPayment(params) {
+    return this.provider.confirmCardPayment(params);
+  }
+  /** Confirm a PayPal payment: create intent via billing API → confirm → redirect if needed. */
+  async confirmPayPalPayment(params) {
+    return this.provider.confirmPayPalPayment(params);
+  }
+  /** Resume a PayPal payment after redirect return. Returns null if no PayPal params in URL. */
+  async resumePayPalPayment() {
+    return this.provider.resumePayPalPayment();
+  }
+  /** Confirms a payment using the mounted elements. */
+  async confirmPayment(params) {
+    return this.provider.confirmPayment(params);
+  }
+  /**
+   * Retrieves a checkout session by ID via the billing API.
+   *
+   * Returns the normalized `CheckoutSession` with amount, currency,
+   * customer data, and status.
+   *
+   * Requires `billingApiUrl` to be set — either via `loadFloPay(key, { billingApiUrl })`
+   * or passed directly as the second argument.
+   */
+  async retrieveSession(sessionId, billingApiUrl) {
+    if (!sessionId) {
+      throw new import_shared4.FloPayError(
+        "sessionId is required to retrieve a session.",
+        "validation_error",
+        { param: "sessionId" }
+      );
+    }
+    const apiUrl = (0, import_shared4.resolveBillingApiUrl)(billingApiUrl ?? this.config.billingApiUrl);
+    const api = new PaymentAPI(apiUrl);
+    const unified = await api.getUnifiedCheckoutSession(sessionId);
+    if (!unified.data.session) {
+      throw new import_shared4.FloPayError("Session not found", "api_error");
+    }
+    return unified.data.session;
+  }
+  /**
+   * Retrieves and normalizes a checkout session, including provider-specific
+   * data (Stripe clientSecret/publishableKey, Chargebee site, etc.).
+   *
+   * The billing API URL is resolved from: explicit param → `loadFloPay()` config
+   * → `NEXT_PUBLIC_FLOPAY_ENV` env var → `configureFlopay()` → staging fallback.
+   */
+  async retrieveUnifiedSession(sessionId, billingApiUrl) {
+    if (!sessionId) {
+      throw new import_shared4.FloPayError(
+        "sessionId is required.",
+        "validation_error",
+        { param: "sessionId" }
+      );
+    }
+    const apiUrl = (0, import_shared4.resolveBillingApiUrl)(billingApiUrl ?? this.config.billingApiUrl);
+    const api = new PaymentAPI(apiUrl);
+    return api.getUnifiedCheckoutSession(sessionId);
+  }
+  /**
+   * Returns the raw underlying provider instance (e.g. Stripe object).
+   * Used internally by components that need direct provider access,
+   * such as PayPal which requires its own Elements instance.
+   */
+  getRawProvider() {
+    return this.provider.getRawProvider();
+  }
+  /** Tears down the SDK instance and releases resources. */
+  destroy() {
+    this.currentElements?.destroy();
+    this.currentElements = null;
+    this.provider.destroy();
+  }
+};
+
+// src/load.ts
+var cachedInstance = null;
+var cachedKey = null;
+async function loadFloPay(publishableKey, options) {
+  if (!publishableKey) {
+    throw new import_shared5.FloPayError(
+      "A publishable key is required to initialize FloPay.",
+      "validation_error",
+      { param: "publishableKey" }
+    );
+  }
+  if (cachedInstance && cachedKey === publishableKey) {
+    return cachedInstance;
+  }
+  if (cachedInstance) {
+    cachedInstance.destroy();
+  }
+  const config = {
+    publishableKey,
+    ...options
+  };
+  const adapter = new StripeAdapter();
+  await adapter.initialize(config);
+  const instance = new FloPay(adapter, config);
+  cachedKey = publishableKey;
+  cachedInstance = instance;
+  return instance;
+}
+
+// src/create-checkout-session.ts
+async function createCheckoutSession(options) {
+  const {
+    billingApiUrl,
+    checkoutBaseUrl,
+    items = [],
+    subscriptions = [],
+    account,
+    successUrl,
+    cancelUrl,
+    checkoutMode = "confirm",
+    couponCodes = [],
+    tagsData,
+    redirectParams = {},
+    setCookie = true,
+    timeoutMs = 12e3,
+    clientId,
+    utmMetadata
+  } = options;
+  const payload = {
+    clientId,
+    successUrl,
+    cancelUrl,
+    checkoutMode,
+    items: items.map((item) => ({
+      providerItemId: item.providerItemId,
+      providerItemName: item.providerItemName ?? null,
+      quantity: item.quantity ?? 1,
+      totalAmount: item.totalAmount,
+      overrideAmount: item.overrideAmount ?? null,
+      currency: item.currency ?? "USD"
+    })),
+    subscriptions: subscriptions.map((sub) => ({
+      providerPlanId: sub.providerPlanId,
+      providerPlanName: sub.providerPlanName ?? null,
+      quantity: sub.quantity ?? 1,
+      totalAmount: sub.totalAmount,
+      overrideAmount: sub.overrideAmount ?? null,
+      currency: sub.currency ?? "USD"
+    })),
+    accountData: {
+      userId: account.userId,
+      firstName: account.firstName ?? null,
+      lastName: account.lastName ?? null,
+      email: account.email,
+      country: account.country ?? null,
+      gender: account.gender ?? null,
+      city: account.city ?? null,
+      state: account.state ?? null,
+      zip: account.zip ?? null
+    },
+    couponCodes
+  };
+  if (tagsData) {
+    payload["tagsData"] = tagsData;
+  }
+  if (utmMetadata?.length) {
+    payload["utmMetadata"] = utmMetadata;
+  }
+  const url = `${billingApiUrl.replace(/\/+$/, "")}/v1/checkouts/sessions`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let status;
+  let body;
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    status = response.status;
+    try {
+      body = await response.json();
+    } catch {
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+  if (status === 201) {
+    const uuid = body?.data?.uuid;
+    if (!uuid) {
+      throw new Error("Checkout session created but no UUID was returned by the billing API");
+    }
+    const redirectUrl = new URL(`${checkoutBaseUrl.replace(/\/+$/, "")}/secure`);
+    redirectUrl.searchParams.set("id", uuid);
+    for (const [key, value] of Object.entries(redirectParams)) {
+      redirectUrl.searchParams.set(key, value);
+    }
+    if (setCookie && typeof window !== "undefined" && typeof document !== "undefined") {
+      const checkoutData = JSON.stringify({ origin_url: cancelUrl });
+      const domain = window.location.hostname.split(".").slice(-2).join(".");
+      document.cookie = `checkout_data=${encodeURIComponent(checkoutData)}; domain=.${domain}; path=/; max-age=3600; SameSite=Lax; Secure;`;
+    }
+    if (typeof window !== "undefined") {
+      window.location.href = redirectUrl.toString();
+    }
+    return { status: 201, redirectUrl: redirectUrl.toString() };
+  }
+  if (status === 204) {
+    if (typeof window !== "undefined") {
+      window.location.href = successUrl;
+    }
+    return { status: 204 };
+  }
+  return { status };
+}
+async function createCheckoutSessionWithRetries(options) {
+  const { maxRetries = 3, ...sessionOptions } = options;
+  if (!Number.isFinite(maxRetries) || !Number.isInteger(maxRetries) || maxRetries <= 0) {
+    throw new Error("Number of retries must be greater than 0");
+  }
+  let lastErr;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await createCheckoutSession(sessionOptions);
+    } catch (err) {
+      lastErr = err;
+      if (err instanceof Error && err.name === "AbortError" && attempt < maxRetries) {
+        await new Promise((r) => setTimeout(r, 100 * Math.pow(2, attempt)));
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw lastErr ?? new Error("Unknown error during checkout session creation");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FloPay,
+  FloPayElements,
+  PaymentAPI,
+  StripeAdapter,
+  createCheckoutSession,
+  createCheckoutSessionWithRetries,
+  loadFloPay
+});
+//# sourceMappingURL=index.cjs.map