@gbitx/pay-react-native 0.1.0

package/dist/index.cjs

@@ -0,0 +1,693 @@
+'use strict';
+
+var react = require('react');
+var reactNative = require('react-native');
+var reactNativeWebview = require('react-native-webview');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/errors.ts
+var GbitXPayError = class _GbitXPayError extends Error {
+  constructor(code, message, init) {
+    super(message);
+    this.name = "GbitXPayError";
+    this.code = code;
+    const meta = {};
+    if (init == null ? void 0 : init.onboardingStatus) meta.onboardingStatus = init.onboardingStatus;
+    if (typeof (init == null ? void 0 : init.retryAfterSec) === "number") meta.retryAfterSec = init.retryAfterSec;
+    this.meta = Object.keys(meta).length ? meta : void 0;
+    if (init && "cause" in init) {
+      Object.defineProperty(this, "cause", { value: init.cause, enumerable: false, writable: false, configurable: true });
+    }
+    Object.setPrototypeOf(this, _GbitXPayError.prototype);
+  }
+  // Custom serialization so a crash reporter or JSON.stringify() can never
+  // leak `cause` (which might hold the checkout URL with #t=<clientToken>).
+  // Only the safe, non-sensitive fields are emitted.
+  toJSON() {
+    var _a, _b;
+    const out = {
+      name: this.name,
+      code: this.code,
+      message: this.message
+    };
+    if ((_a = this.meta) == null ? void 0 : _a.onboardingStatus) out.onboardingStatus = this.meta.onboardingStatus;
+    if (typeof ((_b = this.meta) == null ? void 0 : _b.retryAfterSec) === "number") out.retryAfterSec = this.meta.retryAfterSec;
+    return out;
+  }
+};
+function isGbitXPayError(e) {
+  return e instanceof GbitXPayError || typeof e === "object" && e !== null && e.name === "GbitXPayError";
+}
+
+// src/validation.ts
+var PUBLISHABLE_KEY_RE = /^pk_(live|test)_[0-9a-f]{64}$/;
+var PAYMENT_ID_RE = /^[A-Za-z0-9_-]{8,64}$/;
+var CLIENT_TOKEN_RE = /^[A-Za-z0-9]{16,128}$/;
+function assertPublishableKey(publishableKey) {
+  if (typeof publishableKey !== "string" || publishableKey.trim() === "") {
+    throw new GbitXPayError("invalid_key", "A publishableKey string is required.");
+  }
+  const key = publishableKey.trim();
+  if (key.startsWith("gk_")) {
+    throw new GbitXPayError(
+      "secret_key_used",
+      "A SECRET key (gk_) was passed to the SDK. Use a publishable key (pk_) only, and remove the secret key from your app immediately."
+    );
+  }
+  if (!PUBLISHABLE_KEY_RE.test(key)) {
+    throw new GbitXPayError("invalid_key", "publishableKey must look like pk_live_\u2026 or pk_test_\u2026.");
+  }
+  const environment = key.startsWith("pk_live_") ? "live" : "test";
+  return { key, environment };
+}
+function assertPaymentArgs(paymentId, clientToken) {
+  const id = typeof paymentId === "string" ? paymentId.trim() : "";
+  const token = typeof clientToken === "string" ? clientToken.trim() : "";
+  if (!PAYMENT_ID_RE.test(id)) {
+    throw new GbitXPayError("invalid_arguments", "paymentId is missing or malformed.");
+  }
+  if (!CLIENT_TOKEN_RE.test(token)) {
+    throw new GbitXPayError("invalid_arguments", "clientToken is missing or malformed.");
+  }
+  return { paymentId: id, clientToken: token };
+}
+function assertHttpsOrigin(raw, label) {
+  if (typeof raw !== "string" || raw.trim() === "") {
+    throw new GbitXPayError("invalid_arguments", `${label} is required.`);
+  }
+  let u;
+  try {
+    u = new URL(raw.trim());
+  } catch {
+    throw new GbitXPayError("invalid_arguments", `${label} is not a valid URL.`);
+  }
+  if (u.protocol !== "https:") {
+    throw new GbitXPayError("invalid_arguments", `${label} must be https.`);
+  }
+  return u.origin;
+}
+function buildCheckoutUrl(checkoutOrigin, paymentId, clientToken) {
+  return `${checkoutOrigin}/p/${encodeURIComponent(paymentId)}?embed=native#t=${encodeURIComponent(clientToken)}`;
+}
+
+// src/redact.ts
+function redactUrl(url) {
+  try {
+    const u = new URL(url);
+    return `${u.origin}${u.pathname}`;
+  } catch {
+    return "[unparseable-url]";
+  }
+}
+function redactSecrets(input) {
+  return input.replace(/([gp]k_(?:live|test)_)[0-9a-f]{6,}/gi, "$1redacted").replace(/([#?&]t=)[^\s&"']+/g, "$1redacted").replace(/(Bearer\s+)[^\s"']+/gi, "$1redacted");
+}
+function safeStringify(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  try {
+    return JSON.stringify(value, (_k, v) => {
+      if (typeof v === "object" && v !== null) {
+        if (seen.has(v)) return "[circular]";
+        seen.add(v);
+      }
+      return v;
+    });
+  } catch {
+    return String(value);
+  }
+}
+var _debug = false;
+function setDebug(on) {
+  _debug = !!on;
+}
+function debugLog(...parts) {
+  if (!_debug) return;
+  try {
+    const line = parts.map((p) => typeof p === "string" ? p : safeStringify(p)).join(" ");
+    console.log("[GbitXPay]", redactSecrets(line));
+  } catch {
+  }
+}
+
+// src/config.ts
+var DEFAULT_API_BASE = "https://gateway.gbitx.com";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var MIN_TIMEOUT_MS = 1e3;
+var MAX_TIMEOUT_MS = 6e4;
+var _state = "unconfigured";
+var _config = null;
+var _inflight = null;
+var _inflightKey = null;
+function isConfigured() {
+  return _state === "configured" && _config !== null;
+}
+function getResolvedConfig() {
+  return _config;
+}
+function normalizeTimeout(ms) {
+  if (typeof ms !== "number" || !Number.isFinite(ms)) return DEFAULT_TIMEOUT_MS;
+  return Math.min(MAX_TIMEOUT_MS, Math.max(MIN_TIMEOUT_MS, Math.floor(ms)));
+}
+function safeMessage(msg, fallback) {
+  return typeof msg === "string" && msg.trim() ? redactSecrets(msg.trim()) : fallback;
+}
+function mapConfigError(status, body, retryAfterHeader) {
+  const b = body || {};
+  if (status === 403 && b.code === "ONBOARDING_REQUIRED") {
+    return new GbitXPayError("onboarding_required", safeMessage(b.message, "This publishable key is not active yet. Complete onboarding to activate."), {
+      onboardingStatus: typeof b.onboardingStatus === "string" ? b.onboardingStatus : void 0
+    });
+  }
+  if (status === 403) {
+    return new GbitXPayError("merchant_suspended", safeMessage(b.message, "This merchant account is not active."));
+  }
+  if (status === 429) {
+    const ra = Number(retryAfterHeader);
+    return new GbitXPayError("rate_limited", safeMessage(b.message, "Too many requests. Please try again shortly."), {
+      retryAfterSec: Number.isFinite(ra) && ra > 0 ? ra : void 0
+    });
+  }
+  if (status >= 500) {
+    return new GbitXPayError("server_error", safeMessage(b.message, "GbitXPay is temporarily unavailable. Please try again."));
+  }
+  return new GbitXPayError("invalid_key", safeMessage(b.message, "The publishable key was rejected."));
+}
+function parseConfigSuccess(body) {
+  const b = body;
+  if (!b || b.success !== true) {
+    throw new GbitXPayError("server_error", "Unexpected response while validating the key.");
+  }
+  if (b.environment !== "live" && b.environment !== "test") {
+    throw new GbitXPayError("server_error", "Unexpected config response (environment).");
+  }
+  let checkoutOrigin;
+  try {
+    checkoutOrigin = assertHttpsOrigin(b.checkoutBaseUrl, "checkoutBaseUrl");
+  } catch {
+    throw new GbitXPayError("server_error", "Insecure or invalid checkout origin from server.");
+  }
+  const m = b.merchant;
+  if (!m || typeof m !== "object" || Array.isArray(m)) {
+    throw new GbitXPayError("server_error", "Unexpected config response (merchant).");
+  }
+  const name = typeof m.name === "string" && m.name.trim() ? m.name.trim() : "Merchant";
+  const website = typeof m.website === "string" && m.website.trim() ? m.website.trim() : null;
+  return { environment: b.environment, checkoutOrigin, merchant: { name, website } };
+}
+async function fetchConfig(key, apiBase, timeoutMs) {
+  var _a, _b;
+  const url = `${apiBase}/v1/sdk/config`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "GET",
+      signal: controller.signal,
+      headers: { Authorization: `Bearer ${key}`, Accept: "application/json" }
+    });
+  } catch (cause) {
+    throw new GbitXPayError("network_error", "Could not reach GbitXPay to validate the publishable key.", { cause });
+  } finally {
+    clearTimeout(timer);
+  }
+  const body = await res.json().catch(() => null);
+  if (!res.ok) {
+    throw mapConfigError(res.status, body, (_b = (_a = res.headers) == null ? void 0 : _a.get) == null ? void 0 : _b.call(_a, "retry-after"));
+  }
+  const parsed = parseConfigSuccess(body);
+  return {
+    publishableKey: key,
+    environment: parsed.environment,
+    checkoutOrigin: parsed.checkoutOrigin,
+    merchant: parsed.merchant
+  };
+}
+async function configure(options) {
+  if (options && options.debug) setDebug(true);
+  const { key, environment: prefixEnv } = assertPublishableKey(options == null ? void 0 : options.publishableKey);
+  if (options.environment && options.environment !== prefixEnv) {
+    throw new GbitXPayError("environment_mismatch", "The environment option does not match the publishable key.");
+  }
+  const timeoutMs = normalizeTimeout(options.timeoutMs);
+  const apiBase = options.apiBaseUrl ? assertHttpsOrigin(options.apiBaseUrl, "apiBaseUrl") : DEFAULT_API_BASE;
+  if (_inflight && _inflightKey === key) {
+    await _inflight;
+    return;
+  }
+  _state = "configuring";
+  debugLog("configure: validating key against", `${apiBase}/v1/sdk/config`);
+  const run = (async () => {
+    const resolved = await fetchConfig(key, apiBase, timeoutMs);
+    if (resolved.environment !== prefixEnv) {
+      throw new GbitXPayError("environment_mismatch", "Key environment and server environment disagree.");
+    }
+    if (options.environment && options.environment !== resolved.environment) {
+      throw new GbitXPayError("environment_mismatch", "The environment option does not match the server environment.");
+    }
+    return resolved;
+  })();
+  _inflight = run;
+  _inflightKey = key;
+  try {
+    const resolved = await run;
+    if (_inflight === run) {
+      _config = resolved;
+      _state = "configured";
+      debugLog("configure: ok, environment =", resolved.environment);
+    }
+  } catch (err) {
+    if (_inflight === run) {
+      _state = "configure_failed";
+      _config = null;
+    }
+    throw err;
+  } finally {
+    if (_inflight === run) {
+      _inflight = null;
+      _inflightKey = null;
+    }
+  }
+}
+
+// src/controller.ts
+var _host = null;
+var _active = null;
+function registerHost(listener) {
+  _host = listener;
+  if (_active) listener(_active);
+  return () => {
+    if (_host === listener) _host = null;
+  };
+}
+function present(options) {
+  return new Promise((resolve, reject) => {
+    if (!isConfigured()) {
+      reject(new GbitXPayError("not_configured", "Call and await GbitXPay.configure({ publishableKey }) before present()."));
+      return;
+    }
+    if (!_host) {
+      reject(new GbitXPayError("not_mounted", "Mount <GbitXPayProvider> once near your app root before calling present()."));
+      return;
+    }
+    if (_active) {
+      reject(new GbitXPayError("invalid_arguments", "A checkout is already open."));
+      return;
+    }
+    let args;
+    try {
+      args = assertPaymentArgs(options == null ? void 0 : options.paymentId, options == null ? void 0 : options.clientToken);
+    } catch (e) {
+      reject(e);
+      return;
+    }
+    const config = getResolvedConfig();
+    if (!config) {
+      reject(new GbitXPayError("not_configured", "Configuration was lost. Call configure() again."));
+      return;
+    }
+    const url = buildCheckoutUrl(config.checkoutOrigin, args.paymentId, args.clientToken);
+    let done = false;
+    const session = {
+      paymentId: args.paymentId,
+      clientToken: args.clientToken,
+      url,
+      config,
+      onLoaded: options.onLoaded,
+      onEvent: options.onEvent,
+      settle: (result) => {
+        if (done) return;
+        done = true;
+        _active = null;
+        _host == null ? void 0 : _host(null);
+        resolve(result);
+      }
+    };
+    _active = session;
+    _host(session);
+  });
+}
+
+// src/GbitXPay.ts
+var GbitXPay = {
+  configure,
+  present
+};
+
+// src/messageHandler.ts
+var KNOWN_TYPES = {
+  "gbitx:payment:loaded": "loaded",
+  "gbitx:payment:confirmed": "confirmed",
+  "gbitx:payment:cancelled": "cancelled",
+  "gbitx:payment:expired": "expired",
+  "gbitx:payment:failed": "failed",
+  "gbitx:payment:closed": "closed"
+};
+var MAX_MESSAGE_BYTES = 8192;
+var PAYMENT_STATUSES = [
+  "PENDING",
+  "AWAITING_PAYMENT",
+  "UNDERPAID",
+  "CONFIRMING",
+  "CONFIRMED",
+  "EXPIRED",
+  "FAILED",
+  "CANCELLED"
+];
+function asString(v) {
+  return typeof v === "string" ? v : null;
+}
+function asDecimalString(v) {
+  if (typeof v === "string") return v;
+  if (typeof v === "number" && Number.isFinite(v)) {
+    const s = String(v);
+    return s.includes("e") || s.includes("E") ? null : s;
+  }
+  return null;
+}
+function sanitizePayment(input) {
+  var _a, _b, _c;
+  if (!input || typeof input !== "object" || Array.isArray(input)) return null;
+  const p = input;
+  const id = asString(p.id);
+  const status = asString(p.status);
+  if (!id || !status || !PAYMENT_STATUSES.includes(status)) return null;
+  const mode = p.mode === "LIVE" || p.mode === "SANDBOX" ? p.mode : "SANDBOX";
+  return {
+    id,
+    status,
+    amount: (_a = asDecimalString(p.amount)) != null ? _a : "",
+    currency: (_b = asString(p.currency)) != null ? _b : "",
+    crypto: asString(p.crypto),
+    network: asString(p.network),
+    amountCrypto: asDecimalString(p.amountCrypto),
+    amountPaid: asDecimalString(p.amountPaid),
+    mode,
+    confirmedAt: asString(p.confirmedAt),
+    expiresAt: (_c = asString(p.expiresAt)) != null ? _c : ""
+  };
+}
+function parseBridgeMessage(raw) {
+  if (typeof raw !== "string" || raw.length === 0 || raw.length > MAX_MESSAGE_BYTES) return null;
+  let obj;
+  try {
+    obj = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return null;
+  const type = obj.type;
+  if (typeof type !== "string") return null;
+  const mapped = KNOWN_TYPES[type];
+  if (!mapped) return null;
+  return {
+    type: mapped,
+    payment: sanitizePayment(obj.payment)
+  };
+}
+function terminalResult(type, payment) {
+  switch (type) {
+    case "confirmed":
+      return { status: "confirmed", payment };
+    case "cancelled":
+    case "closed":
+      return { status: "cancelled", reason: "user_closed", payment };
+    case "expired":
+      return { status: "expired", reason: "expired", payment };
+    case "failed":
+      return { status: "failed", payment };
+    case "loaded":
+    default:
+      return null;
+  }
+}
+
+// src/webviewPolicy.ts
+function parse(url) {
+  if (typeof url !== "string" || url === "") return null;
+  try {
+    return new URL(url);
+  } catch {
+    return null;
+  }
+}
+function mayLoadInWebView(checkoutOrigin, url) {
+  const u = parse(url);
+  return !!u && u.protocol === "https:" && u.origin === checkoutOrigin;
+}
+function isTrustedMessageOrigin(checkoutOrigin, url) {
+  const u = parse(url);
+  return !!u && u.protocol === "https:" && u.origin === checkoutOrigin;
+}
+function isTrustedMessageSource(checkoutOrigin, url) {
+  const u = parse(url);
+  return !!u && u.protocol === "https:" && u.origin === checkoutOrigin && u.pathname.startsWith("/p/");
+}
+var SESSION_MAX_MS = 65 * 60 * 1e3;
+function useTheme() {
+  const scheme = reactNative.useColorScheme();
+  return scheme === "dark" ? { bg: "#0a0f0c", text: "#f2f5f3", sub: "#9aa5a0", border: "#1c2620", spinner: "#3ecf6b" } : { bg: "#ffffff", text: "#0a0f0c", sub: "#5b6660", border: "#e6ebe8", spinner: "#07811f" };
+}
+function CheckoutModal({ session }) {
+  var _a;
+  const theme = useTheme();
+  const checkoutOrigin = session.config.checkoutOrigin;
+  const [pageReady, setPageReady] = react.useState(false);
+  const [loadError, setLoadError] = react.useState(false);
+  const settledRef = react.useRef(false);
+  const loadedFiredRef = react.useRef(false);
+  const committedUrlRef = react.useRef(session.url);
+  const backstopRef = react.useRef(null);
+  const webViewRef = react.useRef(null);
+  const settle = react.useCallback(
+    (result) => {
+      var _a2;
+      if (settledRef.current) return;
+      settledRef.current = true;
+      if (backstopRef.current) {
+        clearTimeout(backstopRef.current);
+        backstopRef.current = null;
+      }
+      committedUrlRef.current = "";
+      debugLog("settle", result.status, "reason" in result ? (_a2 = result.reason) != null ? _a2 : "" : "");
+      session.settle(result);
+    },
+    [session]
+  );
+  const handleShouldStart = react.useCallback(
+    (req) => mayLoadInWebView(checkoutOrigin, req.url),
+    [checkoutOrigin]
+  );
+  const handleOpenWindow = react.useCallback(() => {
+  }, []);
+  const handleMessage = react.useCallback(
+    (event) => {
+      var _a2, _b, _c, _d, _e;
+      const senderUrl = (_a2 = event == null ? void 0 : event.nativeEvent) == null ? void 0 : _a2.url;
+      const committedOnCheckout = isTrustedMessageSource(checkoutOrigin, committedUrlRef.current || session.url);
+      if (typeof senderUrl === "string" && senderUrl !== "") {
+        if (!isTrustedMessageOrigin(checkoutOrigin, senderUrl) || !committedOnCheckout) return;
+      } else if (!committedOnCheckout) {
+        return;
+      }
+      const parsed = parseBridgeMessage((_b = event == null ? void 0 : event.nativeEvent) == null ? void 0 : _b.data);
+      if (!parsed) return;
+      if (parsed.payment && parsed.payment.id !== session.paymentId) return;
+      (_d = session.onEvent) == null ? void 0 : _d.call(session, { type: parsed.type, payment: (_c = parsed.payment) != null ? _c : void 0 });
+      if (parsed.type === "loaded") {
+        setPageReady(true);
+        if (!loadedFiredRef.current) {
+          loadedFiredRef.current = true;
+          (_e = session.onLoaded) == null ? void 0 : _e.call(session);
+        }
+        return;
+      }
+      const result = terminalResult(parsed.type, parsed.payment);
+      if (result) settle(result);
+    },
+    [checkoutOrigin, session, settle]
+  );
+  const isMainFrameUrl = react.useCallback(
+    (url) => {
+      if (!url) return true;
+      try {
+        const u = new URL(url);
+        return u.origin === checkoutOrigin && u.pathname.startsWith("/p/");
+      } catch {
+        return false;
+      }
+    },
+    [checkoutOrigin]
+  );
+  const handleLoadError = react.useCallback(
+    (e) => {
+      var _a2;
+      if (isMainFrameUrl((_a2 = e == null ? void 0 : e.nativeEvent) == null ? void 0 : _a2.url)) setLoadError(true);
+    },
+    [isMainFrameUrl]
+  );
+  const handleCrash = react.useCallback(() => {
+    setLoadError(true);
+  }, []);
+  const retry = react.useCallback(() => {
+    var _a2;
+    setLoadError(false);
+    setPageReady(false);
+    (_a2 = webViewRef.current) == null ? void 0 : _a2.reload();
+  }, []);
+  react.useEffect(() => {
+    backstopRef.current = setTimeout(() => settle({ status: "expired", reason: "client_backstop" }), SESSION_MAX_MS);
+    const onBack = () => {
+      settle({ status: "cancelled", reason: "back_button" });
+      return true;
+    };
+    const sub = reactNative.BackHandler.addEventListener("hardwareBackPress", onBack);
+    return () => {
+      var _a2, _b;
+      sub.remove();
+      if (backstopRef.current) {
+        clearTimeout(backstopRef.current);
+        backstopRef.current = null;
+      }
+      (_b = (_a2 = webViewRef.current) == null ? void 0 : _a2.stopLoading) == null ? void 0 : _b.call(_a2);
+      if (!settledRef.current) {
+        settledRef.current = true;
+        session.settle({ status: "cancelled", reason: "dismissed" });
+      }
+    };
+  }, []);
+  react.useEffect(() => {
+    debugLog("present", redactUrl(session.url));
+  }, []);
+  const topInset = reactNative.Platform.OS === "android" ? (_a = reactNative.StatusBar.currentHeight) != null ? _a : 0 : 0;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.Modal,
+    {
+      visible: true,
+      animationType: "slide",
+      presentationStyle: "pageSheet",
+      statusBarTranslucent: true,
+      onRequestClose: () => settle({ status: "cancelled", reason: "back_button" }),
+      onDismiss: () => {
+        if (!settledRef.current) settle({ status: "cancelled", reason: "dismissed" });
+      },
+      children: /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: [styles.container, { backgroundColor: theme.bg, paddingTop: topInset }], children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: [styles.header, { borderBottomColor: theme.border }], children: [
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [styles.title, { color: theme.text }], numberOfLines: 1, children: session.config.merchant.name }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            reactNative.TouchableOpacity,
+            {
+              onPress: () => settle({ status: "cancelled", reason: "user_closed" }),
+              accessibilityRole: "button",
+              accessibilityLabel: "Close checkout",
+              hitSlop: { top: 12, bottom: 12, left: 12, right: 12 },
+              style: styles.closeBtn,
+              children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [styles.closeIcon, { color: theme.text }], children: "\u2715" })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles.body, children: loadError ? /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles.center, accessibilityLabel: "Checkout failed to load", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [styles.errorTitle, { color: theme.text }], children: "Could not load checkout" }),
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [styles.errorSub, { color: theme.sub }], children: "Check your connection and try again." }),
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.TouchableOpacity, { onPress: retry, accessibilityRole: "button", style: [styles.retryBtn, { borderColor: theme.border }], children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [styles.retryText, { color: theme.text }], children: "Retry" }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            reactNative.TouchableOpacity,
+            {
+              onPress: () => settle({ status: "cancelled", reason: "load_failed" }),
+              accessibilityRole: "button",
+              style: styles.closeLink,
+              children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [styles.closeLinkText, { color: theme.sub }], children: "Close" })
+            }
+          )
+        ] }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            reactNativeWebview.WebView,
+            {
+              ref: webViewRef,
+              source: { uri: session.url },
+              originWhitelist: ["*"],
+              onShouldStartLoadWithRequest: handleShouldStart,
+              onNavigationStateChange: (s) => {
+                var _a2, _b;
+                committedUrlRef.current = s.url;
+                if (typeof s.url === "string" && /^https?:/i.test(s.url) && !mayLoadInWebView(checkoutOrigin, s.url)) {
+                  if (!settledRef.current) {
+                    (_b = (_a2 = webViewRef.current) == null ? void 0 : _a2.stopLoading) == null ? void 0 : _b.call(_a2);
+                    setLoadError(true);
+                  }
+                }
+              },
+              onMessage: handleMessage,
+              onOpenWindow: handleOpenWindow,
+              setSupportMultipleWindows: false,
+              javaScriptCanOpenWindowsAutomatically: false,
+              allowFileAccess: false,
+              allowFileAccessFromFileURLs: false,
+              allowUniversalAccessFromFileURLs: false,
+              thirdPartyCookiesEnabled: false,
+              sharedCookiesEnabled: false,
+              incognito: false,
+              mixedContentMode: "never",
+              allowsInlineMediaPlayback: true,
+              mediaPlaybackRequiresUserAction: true,
+              onError: handleLoadError,
+              onHttpError: handleLoadError,
+              onContentProcessDidTerminate: handleCrash,
+              onRenderProcessGone: handleCrash,
+              onLoadEnd: () => setPageReady(true),
+              style: { flex: 1, backgroundColor: theme.bg }
+            }
+          ),
+          !pageReady ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [styles.loadingOverlay, { backgroundColor: theme.bg }], accessibilityLabel: "Loading checkout", children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.ActivityIndicator, { size: "large", color: theme.spinner }) }) : null
+        ] }) })
+      ] })
+    }
+  );
+}
+var styles = reactNative.StyleSheet.create({
+  container: { flex: 1 },
+  header: {
+    flexDirection: "row",
+    alignItems: "center",
+    justifyContent: "space-between",
+    paddingHorizontal: 16,
+    height: 52,
+    borderBottomWidth: reactNative.StyleSheet.hairlineWidth
+  },
+  title: { fontSize: 15, fontWeight: "500", flex: 1, marginRight: 12 },
+  closeBtn: { width: 32, height: 32, alignItems: "center", justifyContent: "center" },
+  closeIcon: { fontSize: 18, fontWeight: "400" },
+  body: { flex: 1 },
+  loadingOverlay: { ...reactNative.StyleSheet.absoluteFillObject, alignItems: "center", justifyContent: "center" },
+  center: { flex: 1, alignItems: "center", justifyContent: "center", padding: 32 },
+  errorTitle: { fontSize: 16, fontWeight: "500", marginBottom: 8 },
+  errorSub: { fontSize: 13, textAlign: "center", marginBottom: 20 },
+  retryBtn: { paddingHorizontal: 24, paddingVertical: 10, borderRadius: 10, borderWidth: 1 },
+  retryText: { fontSize: 14, fontWeight: "500" },
+  closeLink: { marginTop: 14, padding: 8 },
+  closeLinkText: { fontSize: 13 }
+});
+function GbitXPayProvider({ children }) {
+  const [session, setSession] = react.useState(null);
+  react.useEffect(() => registerHost(setSession), []);
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    children,
+    session ? /* @__PURE__ */ jsxRuntime.jsx(CheckoutModal, { session }, session.paymentId) : null
+  ] });
+}
+function useGbitXPay() {
+  return react.useMemo(() => ({ configure, present }), []);
+}
+
+// src/version.ts
+var SDK_VERSION = "0.1.0";
+
+exports.GbitXPay = GbitXPay;
+exports.GbitXPayError = GbitXPayError;
+exports.GbitXPayProvider = GbitXPayProvider;
+exports.SDK_VERSION = SDK_VERSION;
+exports.isGbitXPayError = isGbitXPayError;
+exports.setDebug = setDebug;
+exports.useGbitXPay = useGbitXPay;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map