stablezact-pay 0.66.0

package/dist/index-BTn5xw-W.js

@@ -0,0 +1,302 @@
+import { B as Buffer$1 } from "./index-DYkC2Bui.js";
+import React from "react";
+import { createRoot } from "react-dom/client";
+import { C as CoinleyPayment } from "./CoinleyPayment-BA2ym_mw.js";
+const global = globalThis || void 0 || self;
+(function initBufferPolyfill() {
+  const BufferClass = Buffer$1;
+  if (typeof globalThis !== "undefined") {
+    globalThis.Buffer = BufferClass;
+  }
+  if (typeof window !== "undefined") {
+    window.Buffer = BufferClass;
+  }
+  if (typeof global !== "undefined") {
+    global.Buffer = BufferClass;
+  }
+  if (typeof self !== "undefined") {
+    self.Buffer = BufferClass;
+  }
+})();
+class CoinleyVanilla {
+  /**
+   * Initialize Coinley payment SDK
+   * @param {Object} config - SDK configuration
+   * @param {string} [config.publicKey] - Merchant public key (recommended - starts with 'pk_')
+   * @param {string} [config.apiKey] - Merchant API key (legacy, used with apiSecret)
+   * @param {string} [config.apiSecret] - Merchant API secret (legacy, used with apiKey)
+   * @param {string} config.apiUrl - API base URL (required)
+   * @param {string} [config.theme='light'] - UI theme ('light' or 'dark')
+   * @param {boolean} [config.debug=false] - Enable debug logging
+   */
+  constructor(config = {}) {
+    if (!config.publicKey && !config.apiKey) {
+      throw new Error("CoinleyVanilla: publicKey or apiKey is required");
+    }
+    if (!config.publicKey && !config.apiSecret) {
+      throw new Error("CoinleyVanilla: apiSecret is required when using apiKey");
+    }
+    if (!config.apiUrl) {
+      throw new Error("CoinleyVanilla: apiUrl is required");
+    }
+    this.config = {
+      publicKey: config.publicKey || null,
+      apiKey: config.apiKey || null,
+      apiSecret: config.apiSecret || null,
+      apiUrl: config.apiUrl.replace(/\/$/, ""),
+      // Remove trailing slash
+      theme: config.theme || "light",
+      debug: config.debug || false,
+      ...config
+    };
+    this.isOpen = false;
+    this.root = null;
+    this.container = null;
+    this.callbacks = {};
+    this.currentPayment = null;
+    if (this.config.debug) ;
+  }
+  /**
+   * Open payment modal
+   * @param {Object} paymentConfig - Payment configuration
+   * @param {number} paymentConfig.amount - Payment amount (required)
+   * @param {string} paymentConfig.customerEmail - Customer email (required)
+   * @param {string} [paymentConfig.merchantName] - Merchant display name
+   * @param {string} [paymentConfig.callbackUrl] - Webhook callback URL
+   * @param {Object} paymentConfig.merchantWalletAddresses - Network-specific wallet addresses
+   * @param {string} [paymentConfig.preferredNetwork] - Default network to select
+   * @param {string} [paymentConfig.preferredCurrency] - Default token to select
+   * @param {Object} [paymentConfig.metadata] - Custom metadata to attach
+   * @param {Object} callbacks - Event callbacks
+   * @param {Function} callbacks.onSuccess - Called when payment succeeds (paymentId, txHash, details)
+   * @param {Function} callbacks.onError - Called when payment fails (error)
+   * @param {Function} callbacks.onClose - Called when modal closes
+   */
+  open(paymentConfig, callbacks = {}) {
+    if (this.isOpen) {
+      return;
+    }
+    try {
+      this._validatePaymentConfig(paymentConfig);
+      this.callbacks = callbacks;
+      this.currentPayment = paymentConfig;
+      this._createContainer();
+      this.root = createRoot(this.container);
+      this.isOpen = true;
+      this.root.render(
+        React.createElement(CoinleyPayment, {
+          publicKey: this.config.publicKey,
+          apiKey: this.config.apiKey,
+          apiSecret: this.config.apiSecret,
+          apiUrl: this.config.apiUrl,
+          isOpen: true,
+          theme: this.config.theme,
+          config: {
+            amount: paymentConfig.amount,
+            customerEmail: paymentConfig.customerEmail,
+            merchantName: paymentConfig.merchantName || "Merchant",
+            callbackUrl: paymentConfig.callbackUrl || this._getDefaultCallbackUrl(),
+            merchantWalletAddresses: paymentConfig.merchantWalletAddresses || {},
+            preferredNetwork: paymentConfig.preferredNetwork,
+            preferredCurrency: paymentConfig.preferredCurrency,
+            metadata: {
+              ...paymentConfig.metadata,
+              source: "vanilla-sdk",
+              sdkVersion: "2.0.0",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          },
+          onSuccess: this._handleSuccess.bind(this),
+          onError: this._handleError.bind(this),
+          onClose: this._handleClose.bind(this)
+        })
+      );
+      if (this.config.debug) {
+      }
+    } catch (error) {
+      if (callbacks.onError) {
+        callbacks.onError(error.message || "Failed to open payment modal");
+      }
+    }
+  }
+  /**
+   * Close payment modal programmatically
+   */
+  close() {
+    if (!this.isOpen) {
+      return;
+    }
+    this._cleanup();
+    if (this.config.debug) ;
+  }
+  /**
+   * Check if payment modal is currently open
+   * @returns {boolean}
+   */
+  isPaymentOpen() {
+    return this.isOpen;
+  }
+  /**
+   * Update SDK configuration
+   * @param {Object} newConfig - Configuration updates
+   */
+  updateConfig(newConfig) {
+    this.config = { ...this.config, ...newConfig };
+    if (this.config.debug) ;
+  }
+  /**
+   * Get current configuration (read-only)
+   * @returns {Object}
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Get current payment details
+   * @returns {Object|null}
+   */
+  getCurrentPayment() {
+    return this.currentPayment ? { ...this.currentPayment } : null;
+  }
+  // ==================== PRIVATE METHODS ====================
+  /**
+   * Validate payment configuration
+   * @private
+   */
+  _validatePaymentConfig(config) {
+    if (!config) {
+      throw new Error("Payment configuration is required");
+    }
+    if (!config.amount || typeof config.amount !== "number" || config.amount <= 0) {
+      throw new Error("Valid amount (number > 0) is required");
+    }
+    if (!config.customerEmail || typeof config.customerEmail !== "string") {
+      throw new Error("Customer email is required");
+    }
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailRegex.test(config.customerEmail)) {
+      throw new Error("Invalid email format");
+    }
+    if (config.merchantWalletAddresses) {
+      if (typeof config.merchantWalletAddresses !== "object") {
+        throw new Error("merchantWalletAddresses must be an object");
+      }
+      Object.keys(config.merchantWalletAddresses).length;
+    }
+  }
+  /**
+   * Create DOM container for payment modal
+   * @private
+   */
+  _createContainer() {
+    if (this.container) {
+      return;
+    }
+    this.container = document.createElement("div");
+    this.container.id = "coinley-payment-container";
+    this.container.style.cssText = `
+      position: fixed;
+      top: 0;
+      left: 0;
+      right: 0;
+      bottom: 0;
+      z-index: 999999;
+    `;
+    document.body.appendChild(this.container);
+  }
+  /**
+   * Get default callback URL
+   * @private
+   */
+  _getDefaultCallbackUrl() {
+    if (typeof window !== "undefined") {
+      return `${window.location.origin}/api/webhooks/coinley`;
+    }
+    return "";
+  }
+  /**
+   * Handle successful payment
+   * @private
+   */
+  _handleSuccess(paymentId, transactionHash, paymentDetails) {
+    if (this.config.debug) ;
+    if (this.callbacks.onSuccess) {
+      this.callbacks.onSuccess(paymentId, transactionHash, paymentDetails);
+    }
+  }
+  /**
+   * Handle payment error
+   * @private
+   */
+  _handleError(error) {
+    if (this.config.debug) ;
+    if (this.callbacks.onError) {
+      this.callbacks.onError(error);
+    }
+  }
+  /**
+   * Handle modal close
+   * @private
+   */
+  _handleClose() {
+    this._cleanup();
+    if (this.callbacks.onClose) {
+      this.callbacks.onClose();
+    }
+  }
+  /**
+   * Cleanup resources
+   * @private
+   */
+  _cleanup() {
+    this.isOpen = false;
+    if (this.root) {
+      try {
+        this.root.unmount();
+      } catch (error) {
+      }
+      this.root = null;
+    }
+    if (this.container && this.container.parentNode) {
+      this.container.parentNode.removeChild(this.container);
+      this.container = null;
+    }
+    this.currentPayment = null;
+  }
+}
+if (typeof window !== "undefined") {
+  window.CoinleyVanilla = CoinleyVanilla;
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", autoInitialize);
+  } else {
+    autoInitialize();
+  }
+}
+function autoInitialize() {
+  const scripts = document.querySelectorAll('script[src*="coinley-vanilla"]');
+  scripts.forEach((script) => {
+    const publicKey = script.getAttribute("data-public-key");
+    const apiKey = script.getAttribute("data-api-key");
+    const apiSecret = script.getAttribute("data-api-secret");
+    const apiUrl = script.getAttribute("data-api-url");
+    const theme = script.getAttribute("data-theme") || "light";
+    const debug = script.hasAttribute("data-debug");
+    if ((publicKey || apiKey && apiSecret) && apiUrl) {
+      try {
+        window.coinley = new CoinleyVanilla({
+          publicKey,
+          apiKey,
+          apiSecret,
+          apiUrl,
+          theme,
+          debug
+        });
+      } catch (error) {
+      }
+    }
+  });
+}
+export {
+  CoinleyVanilla as default
+};
+//# sourceMappingURL=index-BTn5xw-W.js.map