pay-connect/dist/index.js

A module for integrating multiple payment gateways including PayPal, Stripe, GooglePay and Momo.

"use strict";
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp.call(b, prop))
      __defNormalProp(a, prop, b[prop]);
  if (__getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(b)) {
      if (__propIsEnum.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    }
  return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __async = (__this, __arguments, generator) => {
  return new Promise((resolve, reject) => {
    var fulfilled = (value) => {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    };
    var rejected = (value) => {
      try {
        step(generator.throw(value));
      } catch (e) {
        reject(e);
      }
    };
    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
    step((generator = generator.apply(__this, __arguments)).next());
  });
};

// src/index.ts
var index_exports = {};
__export(index_exports, {
  GooglePayGateway: () => GooglePayGateway,
  MomoGateway: () => MomoGateway,
  PaypalGateway: () => PaypalGateway,
  StripeGateway: () => StripeGateway,
  initializeGateways: () => initializeGateways,
  loadStripeClient: () => loadStripeClient
});
module.exports = __toCommonJS(index_exports);

// src/gateways/momo.ts
var MomoGateway = class {
  startPayment(amount, orderId) {
    return Promise.resolve(`Payment of ${amount} for order ${orderId} started.`);
  }
  confirmPayment(paymentId) {
    return Promise.resolve(`Payment with ID ${paymentId} confirmed.`);
  }
  cancelPayment(paymentId) {
    return Promise.resolve(`Payment with ID ${paymentId} canceled.`);
  }
};

// src/gateways/paypal/utils.ts
function handleResponse(response) {
  return __async(this, null, function* () {
    if (response.status === 204) {
      return {
        jsonResponse: null,
        httpStatusCode: response.status
      };
    }
    try {
      const jsonResponse = yield response.json();
      return {
        jsonResponse,
        httpStatusCode: response.status
      };
    } catch (err) {
      const errorMessage = yield response.text();
      throw new Error(errorMessage);
    }
  });
}

// src/gateways/paypal/orders.ts
var PayPalOrders = class {
  constructor(options, baseUrl, generateAccessToken) {
    this.options = options;
    this.baseUrl = baseUrl;
    this.generateAccessToken = generateAccessToken;
  }
  createOrder(data) {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v2/checkout/orders`;
      const payload = {
        intent: this.options.intent,
        purchase_units: [
          {
            amount: {
              currency_code: this.options.currency,
              value: data.total,
              breakdown: {
                item_total: {
                  currency_code: this.options.currency,
                  value: data.subtotal
                },
                discount: {
                  currency_code: this.options.currency,
                  value: data.discount
                },
                tax_total: {
                  currency_code: this.options.currency,
                  value: data.tax
                }
              }
            },
            shipping: {
              name: {
                full_name: data.billing_info.name
              },
              address: {
                address_line_1: data.billing_info.address,
                admin_area_2: data.billing_info.city,
                admin_area_1: this.options.buyerCountry,
                country_code: this.options.buyerCountry
              }
            }
          }
        ]
      };
      if (this.options.buyerCountry === "US") {
        payload.purchase_units[0].shipping.address.postal_code = data.billing_info.postal_code;
      }
      const response = yield fetch(url, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${accessToken}`
        },
        body: JSON.stringify(payload)
      });
      return handleResponse(response);
    });
  }
  captureOrder(orderID) {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v2/checkout/orders/${orderID}/capture`;
      const response = yield fetch(url, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${accessToken}`
        }
      });
      return handleResponse(response);
    });
  }
};

// src/gateways/paypal/subscriptions.ts
var PayPalSubscriptions = class {
  constructor(options, baseUrl, generateAccessToken) {
    this.options = options;
    this.baseUrl = baseUrl;
    this.generateAccessToken = generateAccessToken;
  }
  createPlan(data) {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v1/billing/plans`;
      const response = yield fetch(url, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${accessToken}`
        },
        body: JSON.stringify(data)
      });
      return handleResponse(response);
    });
  }
  getPlanList() {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v1/billing/plans`;
      const response = yield fetch(url, {
        method: "GET",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${accessToken}`
        }
      });
      return handleResponse(response);
    });
  }
  getPlanDetails(planID) {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v1/billing/plans/${planID}`;
      const response = yield fetch(url, {
        method: "GET",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${accessToken}`
        }
      });
      return handleResponse(response);
    });
  }
  updatePlan(planID, data) {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v1/billing/plans/${planID}`;
      const response = yield fetch(url, {
        method: "PATCH",
        headers: {
          "Content-Type": "application/json",
          Accept: "application/json",
          Authorization: `Bearer ${accessToken}`
        },
        body: JSON.stringify(data)
      });
      return handleResponse(response);
    });
  }
  updatePlanPricing(planID, data) {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v1/billing/plans/${planID}/update-pricing-schemes`;
      const response = yield fetch(url, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${accessToken}`
        },
        body: JSON.stringify(data)
      });
      return handleResponse(response);
    });
  }
  createSubscription(data) {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v1/billing/subscriptions`;
      const response = yield fetch(url, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${accessToken}`
        },
        body: JSON.stringify(data)
      });
      return handleResponse(response);
    });
  }
  getSubscriptionDetails(subscriptionID) {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v1/billing/subscriptions/${subscriptionID}`;
      const response = yield fetch(url, {
        method: "GET",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${accessToken}`
        }
      });
      return handleResponse(response);
    });
  }
  updateSubscription(subscriptionID, data) {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v1/billing/subscriptions/${subscriptionID}`;
      const response = yield fetch(url, {
        method: "PATCH",
        headers: {
          "Content-Type": "application/json",
          Accept: "application/json",
          Authorization: `Bearer ${accessToken}`
        },
        body: JSON.stringify(data)
      });
      return handleResponse(response);
    });
  }
  cancelSubscription(subscriptionID, reason) {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v1/billing/subscriptions/${subscriptionID}/cancel`;
      const response = yield fetch(url, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${accessToken}`
        },
        body: JSON.stringify({ reason })
      });
      return handleResponse(response);
    });
  }
  activateSubscription(subscriptionID) {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v1/billing/subscriptions/${subscriptionID}/activate`;
      const response = yield fetch(url, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${accessToken}`
        }
      });
      return handleResponse(response);
    });
  }
  captureSubscription(subscriptionID) {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v1/billing/subscriptions/${subscriptionID}/capture`;
      const response = yield fetch(url, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${accessToken}`
        }
      });
      return handleResponse(response);
    });
  }
  suspendSubscription(subscriptionID, reason) {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v1/billing/subscriptions/${subscriptionID}/suspend`;
      const response = yield fetch(url, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${accessToken}`
        },
        body: JSON.stringify({ reason })
      });
      return handleResponse(response);
    });
  }
  reviseSubscription(subscriptionID, data) {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v1/billing/subscriptions/${subscriptionID}/revise`;
      const response = yield fetch(url, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${accessToken}`
        },
        body: JSON.stringify(data)
      });
      return handleResponse(response);
    });
  }
  listSubscriptionTransactions(subscriptionID, startTime, endTime) {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v1/billing/subscriptions/${subscriptionID}/transactions?start_time=${startTime}&end_time=${endTime}`;
      const response = yield fetch(url, {
        method: "GET",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${accessToken}`
        }
      });
      return handleResponse(response);
    });
  }
};

// src/gateways/paypal/payments.ts
var PayPalPayments = class {
  constructor(options, baseUrl, generateAccessToken) {
    this.options = options;
    this.baseUrl = baseUrl;
    this.generateAccessToken = generateAccessToken;
  }
  refundCapturedPayment(captureID, amount) {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v2/payments/captures/${captureID}/refund`;
      const payload = {
        amount: {
          value: amount,
          currency_code: this.options.currency
        }
      };
      const response = yield fetch(url, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${accessToken}`
        },
        body: JSON.stringify(payload)
      });
      return handleResponse(response);
    });
  }
  getCaptureDetails(captureID) {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v2/payments/captures/${captureID}`;
      const response = yield fetch(url, {
        method: "GET",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${accessToken}`
        }
      });
      return handleResponse(response);
    });
  }
};

// src/gateways/paypal/products.ts
var PayPalProducts = class {
  constructor(options, baseUrl, generateAccessToken) {
    this.options = options;
    this.baseUrl = baseUrl;
    this.generateAccessToken = generateAccessToken;
  }
  createProduct(data) {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v1/catalogs/products`;
      const response = yield fetch(url, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${accessToken}`
        },
        body: JSON.stringify(data)
      });
      return handleResponse(response);
    });
  }
  getProductList() {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v1/catalogs/products`;
      const response = yield fetch(url, {
        method: "GET",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${accessToken}`
        }
      });
      return handleResponse(response);
    });
  }
  getProductDetails(productId) {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v1/catalogs/products/${productId}`;
      const response = yield fetch(url, {
        method: "GET",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${accessToken}`
        }
      });
      return handleResponse(response);
    });
  }
  updateProduct(productId, data) {
    return __async(this, null, function* () {
      const accessToken = yield this.generateAccessToken();
      const url = `${this.baseUrl}/v1/catalogs/products/${productId}`;
      const response = yield fetch(url, {
        method: "PATCH",
        headers: {
          "Content-Type": "application/json",
          Accept: "application/json",
          Authorization: `Bearer ${accessToken}`
        },
        body: JSON.stringify(data)
      });
      return handleResponse(response);
    });
  }
};

// src/gateways/paypal/index.ts
var import_paypal_js = require("@paypal/paypal-js");
var PaypalGateway = class {
  constructor(options) {
    const defaultOptions = {
      currency: "USD",
      intent: "CAPTURE",
      vault: false,
      buyerCountry: "US",
      locale: "en_US"
    };
    this.options = __spreadValues(__spreadValues({}, defaultOptions), options);
    this.clientId = this.options.clientId || "test";
    this.clientSecret = this.options.clientSecret;
    this.baseUrl = this.options.environment === "production" ? "https://api-m.paypal.com" : "https://api-m.sandbox.paypal.com";
    this.orders = new PayPalOrders(
      this.options,
      this.baseUrl,
      this.generateAccessToken.bind(this)
    );
    this.subscriptions = new PayPalSubscriptions(
      this.options,
      this.baseUrl,
      this.generateAccessToken.bind(this)
    );
    this.payments = new PayPalPayments(
      this.options,
      this.baseUrl,
      this.generateAccessToken.bind(this)
    );
    this.products = new PayPalProducts(
      this.options,
      this.baseUrl,
      this.generateAccessToken.bind(this)
    );
  }
  generateAccessToken() {
    return __async(this, null, function* () {
      if (!this.clientSecret) {
        throw new Error("Client secret is required for generating access token");
      }
      const auth = Buffer.from(
        `${this.options.clientId}:${this.clientSecret}`
      ).toString("base64");
      const response = yield fetch(`${this.baseUrl}/v1/oauth2/token`, {
        method: "POST",
        body: "grant_type=client_credentials",
        headers: {
          Authorization: `Basic ${auth}`,
          "Content-Type": "application/x-www-form-urlencoded"
        }
      });
      if (!response.ok) {
        throw new Error(`Failed to generate access token: ${response.statusText}`);
      }
      const data = yield response.json();
      return data.access_token;
    });
  }
  renderCheckoutButtons(_0) {
    return __async(this, arguments, function* (containerId, options = {}) {
      const defaultOptions = {
        style: {
          shape: "rect",
          layout: "vertical",
          color: "gold",
          label: "paypal"
        }
      };
      options = Object.assign({}, defaultOptions, options);
      let paypal;
      try {
        paypal = yield (0, import_paypal_js.loadScript)({ clientId: this.clientId });
      } catch (error) {
        console.error("failed to load the PayPal JS SDK script", error);
      }
      if (paypal && paypal.Buttons) {
        try {
          yield paypal.Buttons(options).render(`#${containerId}`);
        } catch (error) {
          console.error("failed to render the PayPal Buttons", error);
        }
      }
    });
  }
  renderSubscriptionButtons(_0) {
    return __async(this, arguments, function* (containerId, options = {}) {
      const defaultOptions = {
        style: {
          layout: "vertical",
          color: "blue",
          shape: "rect",
          label: "subscribe"
        }
      };
      options = Object.assign({}, defaultOptions, options);
      let paypal;
      try {
        paypal = yield (0, import_paypal_js.loadScript)({
          clientId: this.clientId,
          vault: true,
          dataNamespace: "paypal_subscriptions"
        });
      } catch (error) {
        console.error("failed to load the PayPal JS SDK script", error);
      }
      if (paypal && paypal.Buttons) {
        try {
          yield paypal.Buttons(options).render(`#${containerId}`);
        } catch (error) {
          console.error("failed to render the PayPal Buttons", error);
        }
      }
    });
  }
};

// src/gateways/stripe/types.ts
var import_stripe = require("stripe");

// src/gateways/stripe/index.ts
var import_stripe_js = require("@stripe/stripe-js");
var loadStripeClient = (publishableKey) => __async(void 0, null, function* () {
  try {
    const clientStripe = yield (0, import_stripe_js.loadStripe)(publishableKey);
    return clientStripe;
  } catch (error) {
    console.error("Error loading Stripe client:", error);
    throw error;
  }
});
var StripeGateway = class {
  constructor(options) {
    let _stripe = null;
    const getStripe = () => {
      if (!_stripe) {
        _stripe = new import_stripe.Stripe(options.secretKey, {
          apiVersion: "2025-02-24.acacia"
        });
      }
      return _stripe;
    };
    this.serverStripe = getStripe();
  }
  createCharge(amount, currency, source) {
    return __async(this, null, function* () {
      try {
        const charge = yield this.serverStripe.charges.create({
          amount,
          currency,
          source
        });
        return {
          success: true,
          chargeId: charge.id,
          amount: charge.amount,
          currency: charge.currency,
          source: charge.source
        };
      } catch (error) {
        console.error("Error creating charge:", error);
        return { success: false, error: error.message };
      }
    });
  }
  retrieveCharge(chargeId) {
    return __async(this, null, function* () {
      try {
        const charge = yield this.serverStripe.charges.retrieve(chargeId);
        return {
          success: true,
          chargeId: charge.id,
          amount: charge.amount,
          currency: charge.currency,
          status: charge.status
        };
      } catch (error) {
        console.error("Error retrieving charge:", error);
        return { success: false, error: error.message };
      }
    });
  }
  refundCharge(chargeId) {
    return __async(this, null, function* () {
      try {
        const refund = yield this.serverStripe.refunds.create({
          charge: chargeId
        });
        return {
          success: true,
          refundId: refund.id,
          chargeId: refund.charge
        };
      } catch (error) {
        console.error("Error refunding charge:", error);
        return { success: false, error: error.message };
      }
    });
  }
  createSubscription(customerId, priceId) {
    return __async(this, null, function* () {
      if (!priceId) {
        return { success: false, error: "Price ID cannot be empty." };
      }
      try {
        const subscription = yield this.serverStripe.subscriptions.create({
          customer: customerId,
          items: [{ price: priceId }]
        });
        return {
          success: true,
          subscriptionId: subscription.id,
          status: subscription.status
        };
      } catch (error) {
        console.error("Error creating subscription:", error);
        return { success: false, error: error.message };
      }
    });
  }
  retrieveSubscription(subscriptionId) {
    return __async(this, null, function* () {
      try {
        const subscription = yield this.serverStripe.subscriptions.retrieve(subscriptionId);
        return {
          success: true,
          subscriptionId: subscription.id,
          status: subscription.status,
          items: subscription.items
        };
      } catch (error) {
        console.error("Error retrieving subscription:", error);
        return { success: false, error: error.message };
      }
    });
  }
  cancelSubscription(subscriptionId) {
    return __async(this, null, function* () {
      try {
        const canceledSubscription = yield this.serverStripe.subscriptions.cancel(subscriptionId);
        return {
          success: true,
          subscriptionId: canceledSubscription.id,
          status: canceledSubscription.status
        };
      } catch (error) {
        console.error("Error canceling subscription:", error);
        return { success: false, error: error.message };
      }
    });
  }
  retrieveCustomer(customerId) {
    return __async(this, null, function* () {
      try {
        const customer = yield this.serverStripe.customers.retrieve(customerId);
        return {
          success: true,
          customerId: customer.id,
          email: "deleted" in customer ? null : customer.email,
          name: "deleted" in customer ? null : customer.name
        };
      } catch (error) {
        console.error("Error retrieving customer:", error);
        return { success: false, error: error.message };
      }
    });
  }
  retrievePrice(priceId) {
    return __async(this, null, function* () {
      try {
        const price = yield this.serverStripe.prices.retrieve(priceId);
        return {
          success: true,
          priceId: price.id,
          unitAmount: price.unit_amount,
          currency: price.currency
        };
      } catch (error) {
        console.error("Error retrieving price:", error);
        return { success: false, error: error.message };
      }
    });
  }
  createCustomer(email, name) {
    return __async(this, null, function* () {
      try {
        const customer = yield this.serverStripe.customers.create({
          email,
          name
        });
        return {
          success: true,
          customerId: customer.id,
          email: customer.email,
          name: customer.name
        };
      } catch (error) {
        console.error("Error creating customer:", error);
        return { success: false, error: error.message };
      }
    });
  }
  createPrice(unitAmount, currency, productId) {
    return __async(this, null, function* () {
      try {
        const price = yield this.serverStripe.prices.create({
          unit_amount: unitAmount,
          currency,
          product: productId
        });
        return {
          success: true,
          priceId: price.id,
          unitAmount: price.unit_amount,
          currency: price.currency
        };
      } catch (error) {
        console.error("Error creating price:", error);
        return { success: false, error: error.message };
      }
    });
  }
  createProduct(name, description) {
    return __async(this, null, function* () {
      try {
        const product = yield this.serverStripe.products.create({
          name,
          description
        });
        return {
          success: true,
          productId: product.id,
          name: product.name,
          description: product.description
        };
      } catch (error) {
        console.error("Error creating product:", error);
        return { success: false, error: error.message };
      }
    });
  }
  listProducts() {
    return __async(this, null, function* () {
      try {
        const products = yield this.serverStripe.products.list();
        return {
          success: true,
          products: products.data
        };
      } catch (error) {
        console.error("Error listing products:", error);
        return { success: false, error: error.message };
      }
    });
  }
  createCheckoutSession(params) {
    return __async(this, null, function* () {
      try {
        const session = yield this.serverStripe.checkout.sessions.create(params);
        console.log("checkout session:", { params });
        return {
          success: true,
          sessionId: session.id,
          url: session.url
        };
      } catch (error) {
        console.error("Error creating checkout session:", error);
        return { success: false, error: error.message };
      }
    });
  }
};

// src/gateways/google-pay/index.ts
var import_dist = require("@google-pay/button-element/dist/index");
var GooglePayGateway = class {
  constructor(options) {
    this.handleLoadPaymentData = (paymentData) => {
      console.log("onLoadPaymentData", paymentData);
    };
    this.handleCancel = (reason) => {
      console.log("onCancel", reason);
    };
    this.handleError = (reason) => {
      console.error("onError", reason);
    };
    this.handleClick = (event) => {
      console.log("onClick", event);
    };
    this.onPaymentDataChanged = (intermediatePaymentData) => {
      return new Promise((resolve) => {
        var _a;
        const { shippingAddress, shippingOptionData, callbackTrigger } = intermediatePaymentData;
        const paymentDataRequestUpdate = {};
        if (callbackTrigger === "INITIALIZE") {
          paymentDataRequestUpdate.newShippingOptionParameters = __spreadValues({}, this.getGoogleDefaultShippingOptions());
        } else if (callbackTrigger === "SHIPPING_ADDRESS") {
          if ((shippingAddress == null ? void 0 : shippingAddress.administrativeArea) === "NJ") {
            paymentDataRequestUpdate.error = this.getGoogleUnserviceableAddressError();
          } else {
            const selectedShippingOptionId = (_a = shippingOptionData == null ? void 0 : shippingOptionData.id) != null ? _a : "standard";
            paymentDataRequestUpdate.newShippingOptionParameters = __spreadProps(__spreadValues({}, this.getGoogleDefaultShippingOptions()), {
              defaultSelectedOptionId: selectedShippingOptionId
            });
            paymentDataRequestUpdate.newTransactionInfo = this.calculateNewTransactionInfo(selectedShippingOptionId);
          }
        } else if (callbackTrigger === "SHIPPING_OPTION") {
          paymentDataRequestUpdate.newTransactionInfo = this.calculateNewTransactionInfo(shippingOptionData == null ? void 0 : shippingOptionData.id);
        }
        resolve(paymentDataRequestUpdate);
      });
    };
    this.onReadyToPayChange = (result) => {
      console.log("onReadyToPayChange", result);
    };
    this.processPayment = (paymentData) => {
      return new Promise((resolve) => {
        const paymentToken = paymentData.paymentMethodData.tokenizationData.token;
        console.log("onPaymentAuthorized", { paymentToken });
        setTimeout(() => {
          resolve();
        }, 1e3);
      });
    };
    this.onPaymentAuthorized = (paymentData) => {
      return new Promise((resolve) => {
        this.processPayment(paymentData).then(() => {
          resolve({
            transactionState: "SUCCESS"
          });
        }).catch(() => {
          resolve({
            transactionState: "ERROR",
            error: {
              intent: "PAYMENT_AUTHORIZATION",
              message: "Insufficient funds",
              reason: "PAYMENT_DATA_INVALID"
            }
          });
        });
      });
    };
    const defaultOptions = {
      environment: "TEST",
      buttonType: "buy",
      buttonColor: "default",
      buttonSizeMode: "static",
      existingPaymentMethodRequired: false,
      paymentRequest: {
        apiVersion: 2,
        apiVersionMinor: 0,
        allowedPaymentMethods: [
          {
            type: "CARD",
            parameters: {
              allowedAuthMethods: ["PAN_ONLY", "CRYPTOGRAM_3DS"],
              allowedCardNetworks: ["MASTERCARD", "VISA"],
              billingAddressRequired: true
            },
            tokenizationSpecification: {
              type: "PAYMENT_GATEWAY",
              parameters: {
                gateway: "example",
                gatewayMerchantId: "exampleGatewayMerchantId"
              }
            }
          }
        ],
        merchantInfo: {
          merchantId: "12345678901234567890",
          merchantName: "Demo Merchant"
        },
        transactionInfo: {
          totalPriceStatus: "FINAL",
          totalPriceLabel: "Total",
          totalPrice: "100.00",
          currencyCode: "USD",
          countryCode: "US"
        },
        callbackIntents: [
          "PAYMENT_AUTHORIZATION",
          "SHIPPING_ADDRESS",
          "SHIPPING_OPTION"
        ],
        shippingAddressRequired: true,
        shippingAddressParameters: {
          phoneNumberRequired: true
        },
        shippingOptionRequired: true
      },
      onLoadPaymentData: this.handleLoadPaymentData,
      onCancel: this.handleCancel,
      onError: this.handleError,
      onClick: this.handleClick,
      paymentDataCallbacks: {
        onPaymentAuthorized: this.onPaymentAuthorized,
        onPaymentDataChanged: this.onPaymentDataChanged
      },
      onReadyToPayChange: this.onReadyToPayChange
    };
    this.options = __spreadValues(__spreadValues({}, defaultOptions), options);
  }
  getGoogleUnserviceableAddressError() {
    return {
      reason: "SHIPPING_ADDRESS_UNSERVICEABLE",
      message: "Cannot ship to the selected address",
      intent: "SHIPPING_ADDRESS"
    };
  }
  getGoogleDefaultShippingOptions() {
    return {
      shippingOptions: [
        {
          id: "standard",
          label: "Standard shipping",
          description: "Arrives in 3-5 days"
        },
        {
          id: "express",
          label: "Express shipping",
          description: "Arrives in 1-2 days"
        }
      ],
      defaultSelectedOptionId: "standard"
    };
  }
  calculateNewTransactionInfo(selectedShippingOptionId) {
    let totalPrice = "100.00";
    if (selectedShippingOptionId === "express") {
      totalPrice = "110.00";
    }
    return {
      totalPriceStatus: "FINAL",
      totalPriceLabel: "Total",
      totalPrice,
      currencyCode: "USD",
      countryCode: "US"
    };
  }
  renderButton(containerId) {
    const button = document.createElement(
      "google-pay-button"
    );
    button.environment = this.options.environment;
    button.buttonType = this.options.buttonType;
    button.buttonColor = this.options.buttonColor;
    button.buttonLocale = this.options.buttonLocale || "";
    button.buttonSizeMode = this.options.buttonSizeMode;
    button.buttonRadius = this.options.buttonRadius;
    button.existingPaymentMethodRequired = this.options.existingPaymentMethodRequired || false;
    button.paymentRequest = this.options.paymentRequest;
    if (this.options.paymentDataCallbacks && this.options.paymentRequest.callbackIntents) {
      const { callbackIntents } = this.options.paymentRequest;
      if (callbackIntents.includes("PAYMENT_AUTHORIZATION")) {
        button.onPaymentAuthorized = this.options.paymentDataCallbacks.onPaymentAuthorized;
      }
      if (["SHIPPING_ADDRESS", "SHIPPING_OPTION"].some(
        (intent) => callbackIntents.includes(intent)
      )) {
        button.onPaymentDataChanged = this.options.paymentDataCallbacks.onPaymentDataChanged;
      }
    }
    if (this.options.onLoadPaymentData) {
      button.onLoadPaymentData = this.options.onLoadPaymentData;
    }
    if (this.options.onCancel) {
      button.onCancel = this.options.onCancel;
    }
    if (this.options.onClick) {
      button.onClick = this.options.onClick;
    }
    if (this.options.onError) {
      button.onError = this.options.onError;
    }
    if (this.options.onReadyToPayChange) {
      button.onReadyToPayChange = this.options.onReadyToPayChange;
    }
    const container = document.getElementById(containerId);
    if (container) {
      container.innerHTML = "";
      container.appendChild(button);
    }
  }
};

// src/index.ts
var initializeGateways = (config) => {
  const gateways = {};
  if (config.paypal) {
    gateways.paypal = new PaypalGateway(config.paypal.options);
  }
  if (config.stripe) {
    gateways.stripe = new StripeGateway(config.stripe.options);
  }
  if (config.momo) {
    gateways.momo = new MomoGateway();
  }
  if (config.googlePay) {
    gateways.googlePay = new GooglePayGateway(config.googlePay);
  }
  return gateways;
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  GooglePayGateway,
  MomoGateway,
  PaypalGateway,
  StripeGateway,
  initializeGateways,
  loadStripeClient
});