@digilogiclabs/saas-factory-payments 0.1.0

package/dist/index.js

@@ -0,0 +1,869 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BILLING_INTERVALS: () => BILLING_INTERVALS,
+  CHECKOUT_MODE: () => CHECKOUT_MODE,
+  CURRENCY_SYMBOLS: () => CURRENCY_SYMBOLS,
+  DEFAULT_CURRENCY: () => DEFAULT_CURRENCY,
+  ERROR_MESSAGES: () => ERROR_MESSAGES,
+  INVOICE_STATUS: () => INVOICE_STATUS,
+  PAYMENT_METHODS: () => PAYMENT_METHODS,
+  PaymentsProvider: () => PaymentsProvider,
+  STRIPE_API_VERSION: () => STRIPE_API_VERSION,
+  SUBSCRIPTION_STATUS: () => SUBSCRIPTION_STATUS,
+  WEBHOOK_EVENTS: () => WEBHOOK_EVENTS,
+  formatBillingInterval: () => formatBillingInterval,
+  formatCardBrand: () => formatCardBrand,
+  formatCurrency: () => formatCurrency,
+  formatDate: () => formatDate,
+  formatPaymentMethodDisplay: () => formatPaymentMethodDisplay,
+  formatPricingPlan: () => formatPricingPlan,
+  formatRelativeTime: () => formatRelativeTime,
+  formatSubscriptionStatus: () => formatSubscriptionStatus,
+  formatTrialPeriod: () => formatTrialPeriod,
+  getEnvironmentConfig: () => getEnvironmentConfig,
+  isClient: () => isClient,
+  isDevelopment: () => isDevelopment,
+  isProduction: () => isProduction,
+  isServer: () => isServer,
+  truncateText: () => truncateText,
+  usePayments: () => usePayments,
+  usePaymentsConfig: () => usePaymentsConfig,
+  usePaymentsConfigSafe: () => usePaymentsConfigSafe,
+  validateAmount: () => validateAmount,
+  validateCurrentEnvironment: () => validateCurrentEnvironment,
+  validateEmail: () => validateEmail,
+  validateEnvironment: () => validateEnvironment,
+  validatePaymentsConfig: () => validatePaymentsConfig,
+  validatePhoneNumber: () => validatePhoneNumber,
+  validatePricingPlan: () => validatePricingPlan,
+  validateStripeId: () => validateStripeId
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/shared/constants.ts
+var STRIPE_API_VERSION = "2023-10-16";
+var PAYMENT_METHODS = {
+  CARD: "card",
+  BANK_ACCOUNT: "bank_account",
+  SEPA_DEBIT: "sepa_debit",
+  IDEAL: "ideal",
+  SOFORT: "sofort"
+};
+var SUBSCRIPTION_STATUS = {
+  ACTIVE: "active",
+  CANCELED: "canceled",
+  PAST_DUE: "past_due",
+  UNPAID: "unpaid",
+  INCOMPLETE: "incomplete",
+  INCOMPLETE_EXPIRED: "incomplete_expired",
+  TRIALING: "trialing"
+};
+var INVOICE_STATUS = {
+  DRAFT: "draft",
+  OPEN: "open",
+  PAID: "paid",
+  UNCOLLECTIBLE: "uncollectible",
+  VOID: "void"
+};
+var CHECKOUT_MODE = {
+  PAYMENT: "payment",
+  SUBSCRIPTION: "subscription",
+  SETUP: "setup"
+};
+var BILLING_INTERVALS = {
+  DAY: "day",
+  WEEK: "week",
+  MONTH: "month",
+  YEAR: "year"
+};
+var CURRENCY_SYMBOLS = {
+  USD: "$",
+  EUR: "\u20AC",
+  GBP: "\xA3",
+  JPY: "\xA5",
+  CAD: "C$",
+  AUD: "A$",
+  CHF: "CHF",
+  CNY: "\xA5",
+  SEK: "kr",
+  NZD: "NZ$"
+};
+var DEFAULT_CURRENCY = "USD";
+var WEBHOOK_EVENTS = {
+  CUSTOMER_SUBSCRIPTION_CREATED: "customer.subscription.created",
+  CUSTOMER_SUBSCRIPTION_UPDATED: "customer.subscription.updated",
+  CUSTOMER_SUBSCRIPTION_DELETED: "customer.subscription.deleted",
+  INVOICE_PAYMENT_SUCCEEDED: "invoice.payment_succeeded",
+  INVOICE_PAYMENT_FAILED: "invoice.payment_failed",
+  CHECKOUT_SESSION_COMPLETED: "checkout.session.completed",
+  PAYMENT_INTENT_SUCCEEDED: "payment_intent.succeeded",
+  PAYMENT_INTENT_PAYMENT_FAILED: "payment_intent.payment_failed"
+};
+var ERROR_MESSAGES = {
+  PROVIDER_NOT_CONFIGURED: "Payments provider is not properly configured",
+  STRIPE_NOT_LOADED: "Stripe has not been loaded yet",
+  INVALID_PRICE_ID: "Invalid price ID provided",
+  INVALID_CUSTOMER_ID: "Invalid customer ID provided",
+  CHECKOUT_FAILED: "Checkout session creation failed",
+  PAYMENT_FAILED: "Payment processing failed",
+  SUBSCRIPTION_NOT_FOUND: "Subscription not found",
+  CUSTOMER_NOT_FOUND: "Customer not found"
+};
+
+// src/shared/utils/validation.ts
+var validateEmail = (email) => {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+};
+var validatePhoneNumber = (phone) => {
+  const phoneRegex = /^\+?[\d\s\-\(\)]{10,}$/;
+  return phoneRegex.test(phone);
+};
+var validatePaymentsConfig = (config) => {
+  const errors = [];
+  if (!config.publishableKey) {
+    errors.push("publishableKey is required");
+  }
+  if (!config.provider) {
+    errors.push("provider is required");
+  }
+  if (config.provider !== "stripe") {
+    errors.push("Only stripe provider is currently supported");
+  }
+  if (!config.environment) {
+    errors.push("environment is required");
+  }
+  if (config.environment && !["development", "production"].includes(config.environment)) {
+    errors.push('environment must be either "development" or "production"');
+  }
+  if (config.publishableKey && !config.publishableKey.startsWith("pk_")) {
+    errors.push('publishableKey must start with "pk_"');
+  }
+  if (config.secretKey && !config.secretKey.startsWith("sk_")) {
+    errors.push('secretKey must start with "sk_"');
+  }
+  if (config.webhookSecret && !config.webhookSecret.startsWith("whsec_")) {
+    errors.push('webhookSecret must start with "whsec_"');
+  }
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+};
+var validatePricingPlan = (plan) => {
+  const errors = [];
+  if (!plan.id) {
+    errors.push("id is required");
+  }
+  if (!plan.name) {
+    errors.push("name is required");
+  }
+  if (typeof plan.price !== "number" || plan.price < 0) {
+    errors.push("price must be a non-negative number");
+  }
+  if (!plan.currency) {
+    errors.push("currency is required");
+  }
+  if (!plan.interval) {
+    errors.push("interval is required");
+  }
+  if (!["day", "week", "month", "year"].includes(plan.interval)) {
+    errors.push("interval must be one of: day, week, month, year");
+  }
+  if (!plan.stripePriceId) {
+    errors.push("stripePriceId is required");
+  }
+  if (plan.stripePriceId && !plan.stripePriceId.startsWith("price_")) {
+    errors.push('stripePriceId must start with "price_"');
+  }
+  if (!Array.isArray(plan.features)) {
+    errors.push("features must be an array");
+  }
+  if (plan.intervalCount && (typeof plan.intervalCount !== "number" || plan.intervalCount < 1)) {
+    errors.push("intervalCount must be a positive number");
+  }
+  if (plan.trialPeriodDays && (typeof plan.trialPeriodDays !== "number" || plan.trialPeriodDays < 0)) {
+    errors.push("trialPeriodDays must be a non-negative number");
+  }
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+};
+var validateStripeId = (id, type) => {
+  const prefixes = {
+    customer: "cus_",
+    subscription: "sub_",
+    price: "price_",
+    product: "prod_",
+    payment_intent: "pi_"
+  };
+  return id.startsWith(prefixes[type]);
+};
+var validateAmount = (amount, currency) => {
+  if (typeof amount !== "number") {
+    return { isValid: false, error: "Amount must be a number" };
+  }
+  if (amount < 0) {
+    return { isValid: false, error: "Amount must be non-negative" };
+  }
+  const minimumAmounts = {
+    USD: 50,
+    // $0.50
+    EUR: 50,
+    // €0.50
+    GBP: 30,
+    // £0.30
+    JPY: 50,
+    // ¥50
+    CAD: 50,
+    // C$0.50
+    AUD: 50
+    // A$0.50
+  };
+  const minAmount = minimumAmounts[currency.toUpperCase()] || 50;
+  if (amount < minAmount) {
+    return {
+      isValid: false,
+      error: `Amount must be at least ${minAmount} ${currency.toLowerCase()} cents`
+    };
+  }
+  return { isValid: true };
+};
+
+// src/shared/utils/formatting.ts
+var formatCurrency = (amount, currency = DEFAULT_CURRENCY, options = {}) => {
+  const { showSymbol = true, showCents = true, locale = "en-US" } = options;
+  const currencyCode = currency.toUpperCase();
+  const isZeroDecimalCurrency = ["JPY", "KRW", "VND", "CLP"].includes(
+    currencyCode
+  );
+  const displayAmount = isZeroDecimalCurrency ? amount : amount / 100;
+  if (showSymbol) {
+    try {
+      return new Intl.NumberFormat(locale, {
+        style: "currency",
+        currency: currencyCode,
+        minimumFractionDigits: showCents && !isZeroDecimalCurrency ? 2 : 0,
+        maximumFractionDigits: showCents && !isZeroDecimalCurrency ? 2 : 0
+      }).format(displayAmount);
+    } catch (error) {
+      const symbol = CURRENCY_SYMBOLS[currencyCode] || currencyCode;
+      const formattedAmount = showCents && !isZeroDecimalCurrency ? displayAmount.toFixed(2) : Math.round(displayAmount).toString();
+      return `${symbol}${formattedAmount}`;
+    }
+  }
+  return showCents && !isZeroDecimalCurrency ? displayAmount.toFixed(2) : Math.round(displayAmount).toString();
+};
+var formatPricingPlan = (plan) => {
+  const price = formatCurrency(plan.price, plan.currency);
+  const interval = plan.intervalCount && plan.intervalCount > 1 ? `${plan.intervalCount} ${plan.interval}s` : plan.interval;
+  return `${price}/${interval}`;
+};
+var formatSubscriptionStatus = (status) => {
+  const statusMap = {
+    active: "Active",
+    canceled: "Canceled",
+    past_due: "Past Due",
+    unpaid: "Unpaid",
+    incomplete: "Incomplete",
+    incomplete_expired: "Incomplete (Expired)",
+    trialing: "Trial"
+  };
+  return statusMap[status] || status;
+};
+var formatDate = (date, options = {}) => {
+  const { format = "medium", locale = "en-US", timeZone } = options;
+  const dateObj = typeof date === "string" || typeof date === "number" ? new Date(date) : date;
+  const formatOptions = {
+    timeZone
+  };
+  switch (format) {
+    case "short":
+      formatOptions.dateStyle = "short";
+      break;
+    case "medium":
+      formatOptions.dateStyle = "medium";
+      break;
+    case "long":
+      formatOptions.dateStyle = "long";
+      break;
+    case "full":
+      formatOptions.dateStyle = "full";
+      break;
+  }
+  try {
+    return new Intl.DateTimeFormat(locale, formatOptions).format(dateObj);
+  } catch (error) {
+    return dateObj.toLocaleDateString();
+  }
+};
+var formatRelativeTime = (date, options = {}) => {
+  const { locale = "en-US", numeric = "auto" } = options;
+  const dateObj = typeof date === "string" || typeof date === "number" ? new Date(date) : date;
+  const now = /* @__PURE__ */ new Date();
+  const diffInSeconds = Math.floor((now.getTime() - dateObj.getTime()) / 1e3);
+  try {
+    const rtf = new Intl.RelativeTimeFormat(locale, { numeric });
+    if (Math.abs(diffInSeconds) < 60) {
+      return rtf.format(-diffInSeconds, "second");
+    } else if (Math.abs(diffInSeconds) < 3600) {
+      return rtf.format(-Math.floor(diffInSeconds / 60), "minute");
+    } else if (Math.abs(diffInSeconds) < 86400) {
+      return rtf.format(-Math.floor(diffInSeconds / 3600), "hour");
+    } else if (Math.abs(diffInSeconds) < 2592e3) {
+      return rtf.format(-Math.floor(diffInSeconds / 86400), "day");
+    } else if (Math.abs(diffInSeconds) < 31536e3) {
+      return rtf.format(-Math.floor(diffInSeconds / 2592e3), "month");
+    } else {
+      return rtf.format(-Math.floor(diffInSeconds / 31536e3), "year");
+    }
+  } catch (error) {
+    if (Math.abs(diffInSeconds) < 60) {
+      return "just now";
+    } else if (Math.abs(diffInSeconds) < 3600) {
+      const minutes = Math.floor(Math.abs(diffInSeconds) / 60);
+      return diffInSeconds < 0 ? `in ${minutes} minutes` : `${minutes} minutes ago`;
+    } else if (Math.abs(diffInSeconds) < 86400) {
+      const hours = Math.floor(Math.abs(diffInSeconds) / 3600);
+      return diffInSeconds < 0 ? `in ${hours} hours` : `${hours} hours ago`;
+    } else {
+      const days = Math.floor(Math.abs(diffInSeconds) / 86400);
+      return diffInSeconds < 0 ? `in ${days} days` : `${days} days ago`;
+    }
+  }
+};
+var formatBillingInterval = (interval, count = 1) => {
+  const intervalMap = {
+    day: count === 1 ? "daily" : `every ${count} days`,
+    week: count === 1 ? "weekly" : `every ${count} weeks`,
+    month: count === 1 ? "monthly" : `every ${count} months`,
+    year: count === 1 ? "yearly" : `every ${count} years`
+  };
+  return intervalMap[interval] || interval;
+};
+var formatTrialPeriod = (days) => {
+  if (days === 0) return "No trial";
+  if (days === 1) return "1 day trial";
+  if (days < 7) return `${days} days trial`;
+  if (days === 7) return "1 week trial";
+  if (days < 30) return `${Math.floor(days / 7)} weeks trial`;
+  if (days === 30) return "1 month trial";
+  return `${Math.floor(days / 30)} months trial`;
+};
+var truncateText = (text, maxLength) => {
+  if (text.length <= maxLength) return text;
+  return `${text.substring(0, maxLength - 3)}...`;
+};
+var formatCardBrand = (brand) => {
+  const brandMap = {
+    visa: "Visa",
+    mastercard: "Mastercard",
+    amex: "American Express",
+    discover: "Discover",
+    jcb: "JCB",
+    diners: "Diners Club",
+    unionpay: "UnionPay"
+  };
+  return brandMap[brand.toLowerCase()] || brand;
+};
+var formatPaymentMethodDisplay = (paymentMethod) => {
+  if (paymentMethod.type === "card" && paymentMethod.card) {
+    return `${formatCardBrand(paymentMethod.card.brand)} \u2022\u2022\u2022\u2022 ${paymentMethod.card.last4}`;
+  }
+  if (paymentMethod.type === "bank_account" && paymentMethod.bankAccount) {
+    const bankName = paymentMethod.bankAccount.bankName || "Bank";
+    return `${bankName} \u2022\u2022\u2022\u2022 ${paymentMethod.bankAccount.last4}`;
+  }
+  return paymentMethod.type;
+};
+
+// src/shared/utils/env.ts
+var validateEnvironment = (config) => {
+  const errors = [];
+  const warnings = [];
+  if (!config.stripePublishableKey) {
+    errors.push("STRIPE_PUBLISHABLE_KEY is required");
+  } else if (!config.stripePublishableKey.startsWith("pk_")) {
+    errors.push('STRIPE_PUBLISHABLE_KEY must start with "pk_"');
+  }
+  if (!config.environment) {
+    errors.push("Environment must be specified (development or production)");
+  } else if (!["development", "production"].includes(config.environment)) {
+    errors.push('Environment must be either "development" or "production"');
+  }
+  if (config.environment === "production") {
+    if (config.stripePublishableKey?.includes("test")) {
+      warnings.push("Using test keys in production environment");
+    }
+    if (!config.appUrl) {
+      warnings.push("APP_URL should be set in production for proper redirects");
+    } else if (!config.appUrl.startsWith("https://")) {
+      warnings.push("APP_URL should use HTTPS in production");
+    }
+  }
+  if (typeof window === "undefined") {
+    if (!config.stripeSecretKey) {
+      warnings.push(
+        "STRIPE_SECRET_KEY is recommended for server-side operations"
+      );
+    } else if (!config.stripeSecretKey.startsWith("sk_")) {
+      errors.push('STRIPE_SECRET_KEY must start with "sk_"');
+    }
+    if (!config.stripeWebhookSecret) {
+      warnings.push(
+        "STRIPE_WEBHOOK_SECRET is recommended for webhook verification"
+      );
+    } else if (!config.stripeWebhookSecret.startsWith("whsec_")) {
+      errors.push('STRIPE_WEBHOOK_SECRET must start with "whsec_"');
+    }
+  }
+  return {
+    isValid: errors.length === 0,
+    errors,
+    warnings
+  };
+};
+var getEnvironmentConfig = () => {
+  const isServer2 = typeof window === "undefined";
+  const config = {
+    stripePublishableKey: process.env.NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY || process.env.EXPO_PUBLIC_STRIPE_PUBLISHABLE_KEY || "",
+    environment: process.env.NODE_ENV || "development",
+    appUrl: process.env.NEXT_PUBLIC_APP_URL
+  };
+  if (isServer2) {
+    config.stripeSecretKey = process.env.STRIPE_SECRET_KEY;
+    config.stripeWebhookSecret = process.env.STRIPE_WEBHOOK_SECRET;
+  }
+  return config;
+};
+var validateCurrentEnvironment = () => {
+  const config = getEnvironmentConfig();
+  const validation = validateEnvironment(config);
+  if (!validation.isValid) {
+    console.error("\u274C Environment validation failed:");
+    validation.errors.forEach((error) => console.error(`  - ${error}`));
+    if (typeof window === "undefined") {
+      throw new Error(
+        `Environment validation failed: ${validation.errors.join(", ")}`
+      );
+    }
+  }
+  if (validation.warnings.length > 0) {
+    console.warn("\u26A0\uFE0F Environment warnings:");
+    validation.warnings.forEach((warning) => console.warn(`  - ${warning}`));
+  }
+  return validation;
+};
+var isDevelopment = () => {
+  return process.env.NODE_ENV === "development";
+};
+var isProduction = () => {
+  return process.env.NODE_ENV === "production";
+};
+var isServer = () => {
+  return typeof window === "undefined";
+};
+var isClient = () => {
+  return typeof window !== "undefined";
+};
+
+// src/shared/providers/PaymentsProvider.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var PaymentsContext = (0, import_react.createContext)(
+  void 0
+);
+var PaymentsProvider = ({
+  children,
+  config
+}) => {
+  const isConfigured = Boolean(
+    config.publishableKey && config.provider === "stripe" && config.environment
+  );
+  const isProduction2 = config.environment === "production";
+  if (!isConfigured && config.environment === "development") {
+    console.warn(
+      "PaymentsProvider: Configuration incomplete. Please ensure publishableKey and provider are set."
+    );
+  }
+  const contextValue = {
+    config,
+    isConfigured,
+    isProduction: isProduction2
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PaymentsContext.Provider, { value: contextValue, children });
+};
+var usePaymentsConfig = () => {
+  const context = (0, import_react.useContext)(PaymentsContext);
+  if (!context) {
+    throw new Error("usePaymentsConfig must be used within PaymentsProvider");
+  }
+  return context;
+};
+var usePaymentsConfigSafe = () => {
+  return (0, import_react.useContext)(PaymentsContext) || null;
+};
+
+// src/shared/hooks/usePayments.ts
+var import_react2 = require("react");
+var usePayments = (options = {}) => {
+  const { customerId, autoFetch = true, onError } = options;
+  const { isConfigured } = usePaymentsConfig();
+  const [customer, setCustomer] = (0, import_react2.useState)(null);
+  const [subscriptions, setSubscriptions] = (0, import_react2.useState)([]);
+  const [loading, setLoading] = (0, import_react2.useState)(false);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const handleError = (0, import_react2.useCallback)(
+    (errorMessage) => {
+      setError(errorMessage);
+      onError?.(errorMessage);
+      console.error("Payments error:", errorMessage);
+    },
+    [onError]
+  );
+  const fetchCustomerData = (0, import_react2.useCallback)(
+    async (id) => {
+      if (!validateStripeId(id, "customer")) {
+        handleError("Invalid customer ID");
+        return;
+      }
+      try {
+        const response = await fetch(`/api/payments/customer/${id}`);
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({ error: "Network error" }));
+          throw new Error(errorData.error || ERROR_MESSAGES.CUSTOMER_NOT_FOUND);
+        }
+        const customerData = await response.json();
+        setCustomer(customerData);
+        const subsResponse = await fetch(
+          `/api/payments/customer/${id}/subscriptions`
+        );
+        if (subsResponse.ok) {
+          const subsData = await subsResponse.json();
+          setSubscriptions(subsData.subscriptions || []);
+        }
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : ERROR_MESSAGES.CUSTOMER_NOT_FOUND;
+        handleError(errorMessage);
+      }
+    },
+    [handleError]
+  );
+  const refetch = (0, import_react2.useCallback)(async () => {
+    if (!customerId) {
+      handleError("Customer ID is required");
+      return;
+    }
+    if (!isConfigured) {
+      handleError(ERROR_MESSAGES.PROVIDER_NOT_CONFIGURED);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      await fetchCustomerData(customerId);
+    } finally {
+      setLoading(false);
+    }
+  }, [customerId, isConfigured, fetchCustomerData, handleError]);
+  const createCustomer = (0, import_react2.useCallback)(
+    async (params) => {
+      if (!isConfigured) {
+        handleError(ERROR_MESSAGES.PROVIDER_NOT_CONFIGURED);
+        return null;
+      }
+      if (!validateEmail(params.email)) {
+        handleError("Invalid email address");
+        return null;
+      }
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await fetch("/api/payments/customer", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(params)
+        });
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({ error: "Network error" }));
+          throw new Error(errorData.error || "Failed to create customer");
+        }
+        const customerData = await response.json();
+        setCustomer(customerData);
+        return customerData;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to create customer";
+        handleError(errorMessage);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [isConfigured, handleError]
+  );
+  const updateCustomer = (0, import_react2.useCallback)(
+    async (params) => {
+      if (!customerId) {
+        handleError("Customer ID is required");
+        return false;
+      }
+      if (!isConfigured) {
+        handleError(ERROR_MESSAGES.PROVIDER_NOT_CONFIGURED);
+        return false;
+      }
+      if (params.email && !validateEmail(params.email)) {
+        handleError("Invalid email address");
+        return false;
+      }
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await fetch(`/api/payments/customer/${customerId}`, {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(params)
+        });
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({ error: "Network error" }));
+          throw new Error(errorData.error || "Failed to update customer");
+        }
+        await refetch();
+        return true;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to update customer";
+        handleError(errorMessage);
+        return false;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [customerId, isConfigured, refetch, handleError]
+  );
+  const subscribe = (0, import_react2.useCallback)(
+    async (priceId, options2 = {}) => {
+      if (!customerId) {
+        handleError("Customer ID is required");
+        return false;
+      }
+      if (!isConfigured) {
+        handleError(ERROR_MESSAGES.PROVIDER_NOT_CONFIGURED);
+        return false;
+      }
+      if (!validateStripeId(priceId, "price")) {
+        handleError(ERROR_MESSAGES.INVALID_PRICE_ID);
+        return false;
+      }
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await fetch("/api/payments/create-subscription", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            customerId,
+            priceId,
+            ...options2
+          })
+        });
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({ error: "Network error" }));
+          throw new Error(errorData.error || "Failed to create subscription");
+        }
+        await refetch();
+        return true;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to create subscription";
+        handleError(errorMessage);
+        return false;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [customerId, isConfigured, refetch, handleError]
+  );
+  const cancelSubscription = (0, import_react2.useCallback)(
+    async (subscriptionId) => {
+      const activeSubscription2 = subscriptions.find((s) => s.status === "active");
+      const idToCancel = subscriptionId || activeSubscription2?.id;
+      if (!idToCancel) {
+        handleError("No active subscription to cancel");
+        return false;
+      }
+      if (!validateStripeId(idToCancel, "subscription")) {
+        handleError("Invalid subscription ID");
+        return false;
+      }
+      try {
+        const response = await fetch(
+          `/api/payments/subscription/${idToCancel}/cancel`,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" }
+          }
+        );
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({ error: "Network error" }));
+          throw new Error(errorData.error || "Failed to cancel subscription");
+        }
+        await refetch();
+        return true;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to cancel subscription";
+        handleError(errorMessage);
+        return false;
+      }
+    },
+    [subscriptions, refetch, handleError]
+  );
+  const reactivateSubscription = (0, import_react2.useCallback)(
+    async (subscriptionId) => {
+      const cancelledSubscription = subscriptions.find(
+        (s) => s.cancelAtPeriodEnd
+      );
+      const idToReactivate = subscriptionId || cancelledSubscription?.id;
+      if (!idToReactivate) {
+        handleError("No cancelled subscription to reactivate");
+        return false;
+      }
+      if (!validateStripeId(idToReactivate, "subscription")) {
+        handleError("Invalid subscription ID");
+        return false;
+      }
+      try {
+        const response = await fetch(
+          `/api/payments/subscription/${idToReactivate}/reactivate`,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" }
+          }
+        );
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({ error: "Network error" }));
+          throw new Error(
+            errorData.error || "Failed to reactivate subscription"
+          );
+        }
+        await refetch();
+        return true;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to reactivate subscription";
+        handleError(errorMessage);
+        return false;
+      }
+    },
+    [subscriptions, refetch, handleError]
+  );
+  const hasActiveSubscription = (0, import_react2.useCallback)(() => {
+    return subscriptions.some(
+      (s) => s.status === "active" || s.status === "trialing"
+    );
+  }, [subscriptions]);
+  const isSubscribedToPlan = (0, import_react2.useCallback)(
+    (priceId) => {
+      return subscriptions.some(
+        (s) => s.priceId === priceId && (s.status === "active" || s.status === "trialing")
+      );
+    },
+    [subscriptions]
+  );
+  const getSubscriptionStatus = (0, import_react2.useCallback)(
+    (subscriptionId) => {
+      if (subscriptionId) {
+        const subscription = subscriptions.find((s) => s.id === subscriptionId);
+        return subscription?.status || null;
+      }
+      const activeSubscription2 = subscriptions.find(
+        (s) => s.status === "active" || s.status === "trialing"
+      );
+      return activeSubscription2?.status || null;
+    },
+    [subscriptions]
+  );
+  const activeSubscription = subscriptions.find((s) => s.status === "active" || s.status === "trialing") || null;
+  (0, import_react2.useEffect)(() => {
+    if (autoFetch && customerId && isConfigured) {
+      refetch();
+    }
+  }, [autoFetch, customerId, isConfigured, refetch]);
+  return {
+    // State
+    customer,
+    subscriptions,
+    activeSubscription,
+    loading,
+    error,
+    // Customer methods
+    createCustomer,
+    updateCustomer,
+    // Subscription methods
+    subscribe,
+    cancelSubscription,
+    reactivateSubscription,
+    // Utility methods
+    refetch,
+    hasActiveSubscription,
+    isSubscribedToPlan,
+    getSubscriptionStatus
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BILLING_INTERVALS,
+  CHECKOUT_MODE,
+  CURRENCY_SYMBOLS,
+  DEFAULT_CURRENCY,
+  ERROR_MESSAGES,
+  INVOICE_STATUS,
+  PAYMENT_METHODS,
+  PaymentsProvider,
+  STRIPE_API_VERSION,
+  SUBSCRIPTION_STATUS,
+  WEBHOOK_EVENTS,
+  formatBillingInterval,
+  formatCardBrand,
+  formatCurrency,
+  formatDate,
+  formatPaymentMethodDisplay,
+  formatPricingPlan,
+  formatRelativeTime,
+  formatSubscriptionStatus,
+  formatTrialPeriod,
+  getEnvironmentConfig,
+  isClient,
+  isDevelopment,
+  isProduction,
+  isServer,
+  truncateText,
+  usePayments,
+  usePaymentsConfig,
+  usePaymentsConfigSafe,
+  validateAmount,
+  validateCurrentEnvironment,
+  validateEmail,
+  validateEnvironment,
+  validatePaymentsConfig,
+  validatePhoneNumber,
+  validatePricingPlan,
+  validateStripeId
+});