@glomopay/react-native-sdk 2.0.1 → 3.0.1

package/lib/injections/webview-standard.injection.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectedScript = void 0;
+/** Injection JavaScript for the Standard Checkout WebView */
+exports.injectedScript = `
+    (function() {
+      // Log prefix for all messages originating from the standard checkout WebView
+      const LOG_PREFIX = 'STANDARD_WEBVIEW: ';
+
+      /**
+       * Formats an array of arguments into a single prefixed string for posting back to React Native.
+       * Objects are JSON-stringified; primitives are coerced to strings.
+       */
+      function formatMessage(args) {
+        return args.map(function(arg) {
+          if (typeof arg === 'object') {
+            try {
+              return LOG_PREFIX + JSON.stringify(arg, null, 2);
+            } catch (error) {
+              return LOG_PREFIX + '[unserializable object]';
+            }
+          }
+          return LOG_PREFIX + String(arg);
+        }).join(' ');
+      }
+
+      // Saving original console methods before overriding (must be declared before safePostMessage references them)
+      const originalLog = console.log;
+      const originalWarn = console.warn;
+      const originalError = console.error;
+      const originalInfo = console.info;
+
+      /**
+       * Safely posts a message to ReactNativeWebView with a guard check.
+       * Prevents crashes if the WebView bridge is not yet ready or has been torn down.
+       */
+      function safePostMessage(payload) {
+        try {
+          if (window.ReactNativeWebView && typeof window.ReactNativeWebView.postMessage === 'function') {
+            window.ReactNativeWebView.postMessage(JSON.stringify(payload));
+          }
+        } catch (error) {
+          originalError && originalError.call(console, LOG_PREFIX + 'Failed to post message to ReactNativeWebView', error);
+        }
+      }
+
+      // Overriding console methods to forward logs back to React Native
+
+      console.log = function(...args) {
+        originalLog.apply(console, args);
+        safePostMessage({
+          type: 'console',
+          level: 'log',
+          message: formatMessage(args)
+        });
+      };
+
+      console.warn = function(...args) {
+        originalWarn.apply(console, args);
+        safePostMessage({
+          type: 'console',
+          level: 'warn',
+          message: formatMessage(args)
+        });
+      };
+
+      console.error = function(...args) {
+        originalError.apply(console, args);
+        safePostMessage({
+          type: 'console',
+          level: 'error',
+          message: formatMessage(args)
+        });
+      };
+
+      console.info = function(...args) {
+        originalInfo.apply(console, args);
+        safePostMessage({
+          type: 'console',
+          level: 'info',
+          message: formatMessage(args)
+        });
+      };
+
+      // Intercepting fetch requests to log network activity
+      const originalFetch = window.fetch;
+      window.fetch = function(...args) {
+        const url = typeof args[0] === 'string' ? args[0] : args[0]?.url || 'Unknown URL';
+        safePostMessage({
+          type: 'console',
+          level: 'network',
+          message: LOG_PREFIX + 'FETCH REQUEST: ' + url
+        });
+
+        return originalFetch.apply(this, args)
+          .then(response => {
+            safePostMessage({
+              type: 'console',
+              level: 'network',
+              message: LOG_PREFIX + 'FETCH RESPONSE: ' + url + ' - Status: ' + response.status
+            });
+            return response;
+          })
+          .catch(error => {
+            safePostMessage({
+              type: 'console',
+              level: 'error',
+              message: LOG_PREFIX + 'FETCH ERROR: ' + url + ' - ' + error.message
+            });
+            throw error;
+          });
+      };
+
+      // Intercepting XMLHttpRequest to log network activity
+      const originalOpen = XMLHttpRequest.prototype.open;
+      const originalSend = XMLHttpRequest.prototype.send;
+
+      XMLHttpRequest.prototype.open = function(method, url) {
+        this._url = url;
+        this._method = method;
+        return originalOpen.apply(this, arguments);
+      };
+
+      XMLHttpRequest.prototype.send = function() {
+        safePostMessage({
+          type: 'console',
+          level: 'network',
+          message: LOG_PREFIX + 'XHR REQUEST: ' + this._method + ' ' + this._url
+        });
+
+        this.addEventListener('load', function() {
+          safePostMessage({
+            type: 'console',
+            level: 'network',
+            message: LOG_PREFIX + 'XHR RESPONSE: ' + this._url + ' - Status: ' + this.status
+          });
+        });
+
+        this.addEventListener('error', function() {
+          safePostMessage({
+            type: 'console',
+            level: 'error',
+            message: LOG_PREFIX + 'XHR ERROR: ' + this._url
+          });
+        });
+
+        return originalSend.apply(this, arguments);
+      };
+
+      // Intercepting programmatic form.submit() - force target="_blank" to "_self"
+      const originalSubmit = HTMLFormElement.prototype.submit;
+      HTMLFormElement.prototype.submit = function() {
+        if (this.target === '_blank') {
+          this.target = '_self';
+        }
+        return originalSubmit.call(this);
+      };
+
+      // Intercepting window.open (for 3DS redirects, bank pages, etc.)
+      const originalWindowOpen = window.open;
+      window.open = function(url, target, features) {
+        safePostMessage({
+          type: 'window.open',
+          url: url,
+          target: target,
+          features: features
+        });
+
+        // Returning a mock window object so the caller does not crash on .close()/.focus() calls
+        return {
+          closed: false,
+          close: function() {
+            safePostMessage({
+              type: 'window.close'
+            });
+          },
+          focus: function() {},
+          blur: function() {}
+        };
+      };
+
+      // Listening for unhandled errors
+      window.addEventListener('error', function(event) {
+        safePostMessage({
+          type: 'console',
+          level: 'error',
+          message: LOG_PREFIX + 'Unhandled Error: ' + event.message + ' at ' + event.filename + ':' + event.lineno
+        });
+      });
+
+      // Listening for unhandled promise rejections
+      window.addEventListener('unhandledrejection', function(event) {
+        safePostMessage({
+          type: 'console',
+          level: 'error',
+          message: LOG_PREFIX + 'Unhandled Promise Rejection: ' + (event.reason?.toString() || 'Unknown')
+        });
+      });
+
+      // Listening for messages from the checkout page (payment events, lifecycle events)
+      window.addEventListener('message', function(event) {
+        console.log(LOG_PREFIX + 'Message received: ' + event.data);
+        safePostMessage({
+          type: 'message',
+          message: event.data
+        });
+      });
+
+      // Logging that injection is complete
+      console.log(LOG_PREFIX + 'GlomoPay WebView JavaScript injection complete');
+
+      true; // Required for injected JavaScript
+    })();
+`;

package/lib/services/order-type-fetcher.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Order type fetcher service.
+ * Calls the order API to determine whether a given orderId is an LRS or Standard checkout flow.
+ * Used by the unified GlomoCheckout component to delegate to the correct inner component.
+ */
+import { type GlomoServer } from "../config/base";
+/** The two supported checkout flow types */
+export type OrderType = "standard" | "lrs";
+/** Discriminated union result - either a resolved order type or an error message */
+export type OrderTypeResult = {
+    success: true;
+    orderType: OrderType;
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * Fetches the order type for the given orderId from the public API.
+ * Returns a discriminated union so the caller can handle success/failure without try-catch.
+ */
+export declare function fetchOrderType(options: {
+    orderId: string;
+    publicKey: string;
+    server?: GlomoServer;
+    timeoutMs?: number;
+    devMode?: boolean;
+}): Promise<OrderTypeResult>;
+//# sourceMappingURL=order-type-fetcher.d.ts.map

package/lib/services/order-type-fetcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-type-fetcher.d.ts","sourceRoot":"","sources":["../../src/services/order-type-fetcher.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAEvE,4CAA4C;AAC5C,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,KAAK,CAAC;AAE3C,oFAAoF;AACpF,MAAM,MAAM,eAAe,GAAG;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1G;;;GAGG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB,GAAG,OAAO,CAAC,eAAe,CAAC,CA4D3B"}

package/lib/services/order-type-fetcher.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * Order type fetcher service.
+ * Calls the order API to determine whether a given orderId is an LRS or Standard checkout flow.
+ * Used by the unified GlomoCheckout component to delegate to the correct inner component.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchOrderType = fetchOrderType;
+const axios_1 = __importStar(require("axios"));
+const base_1 = require("../config/base");
+/**
+ * Fetches the order type for the given orderId from the public API.
+ * Returns a discriminated union so the caller can handle success/failure without try-catch.
+ */
+async function fetchOrderType(options) {
+    var _a;
+    try {
+        // Resolving the API base URL from the server config
+        const config = (0, base_1.resolveServerConfig)(options.server);
+        const apiUrl = `${config.baseUrl.api}/api/public/v1/order/${options.orderId}`;
+        if (options.devMode) {
+            console.log(`[Glomo-RN-SDK] Order type API URL: ${apiUrl}`);
+        }
+        /**
+         * Calling the order API with the publicKey as Bearer token.
+         * Cache-busting headers prevent okhttp (Android) from sending If-None-Match on repeat calls,
+         * which would cause the server to return a 304 with an empty body and break order type detection.
+         */
+        const response = await axios_1.default.get(apiUrl, {
+            headers: {
+                Authorization: `Bearer ${options.publicKey}`,
+                "Cache-Control": "no-cache, no-store, must-revalidate",
+                Pragma: "no-cache",
+            },
+            timeout: (_a = options.timeoutMs) !== null && _a !== void 0 ? _a : 30000,
+        });
+        const data = response.data;
+        // Validating that the returned order type is one of the expected values
+        if (data.orderType === "lrs" || data.orderType === "standard") {
+            if (options.devMode) {
+                console.log(`[Glomo-RN-SDK] Order type for orderId: ${options.orderId} successfully determined to be ${data.orderType}`);
+            }
+            return { success: true, orderType: data.orderType };
+        }
+        if (options.devMode) {
+            console.log(`[Glomo-RN-SDK] Unexpected orderType ${data.orderType} provided for ${options.orderId}`);
+        }
+        return { success: false, error: `Unexpected order type from ${apiUrl}: ${data.orderType}` };
+    }
+    catch (error) {
+        // Extracting the error message for logging and returning
+        const message = error instanceof Error ? error.message : String(error);
+        const config = (0, base_1.resolveServerConfig)(options.server);
+        const apiUrl = `${config.baseUrl.api}/api/public/v1/order/${options.orderId}`;
+        if (options.devMode) {
+            // Logging additional response details for Axios errors (status code, response body)
+            if ((0, axios_1.isAxiosError)(error) && error.response) {
+                console.log(`[Glomo-RN-SDK] orderType determination failed for ${options.orderId} from ${apiUrl}: ${message} (${error.response.status}) and data:`, JSON.stringify(error.response.data));
+            }
+            else {
+                console.log(`[Glomo-RN-SDK] orderType determination failed for ${options.orderId} from ${apiUrl}: ${message}`);
+            }
+        }
+        return { success: false, error: `Failed to determine order type for ${apiUrl}: ${message}` };
+    }
+}

package/lib/types/checkout.d.ts

@@ -0,0 +1,53 @@
+/** Unified v3 type definitions for GlomoCheckout */
+import { type GlomoServer } from "../config/base";
+import { type SdkError } from "../utils/analytics";
+/** The payload for a successful or failed payment (unified across LRS and standard) */
+export interface GlomoCheckoutPayload {
+    orderId: string;
+    paymentId: string;
+    signature: string;
+}
+/** The payload for a bank transfer submission */
+export interface GlomoBankTransferPayload {
+    orderId: string;
+    senderAccountNumber: string;
+    transactionReference: string;
+}
+/** The payload for a pay via bank - bank connection successful event */
+export interface GlomoPayViaBankConnectionPayload {
+    bankIdentifier: string;
+    cooldownPeriodInMinutes: number;
+    bankName: string;
+    bankImageSrc: string;
+    bankImageAlt: string;
+}
+/** Unified checkout statuses - superset of LRS + standard statuses */
+export type CheckoutStatus = "ready" | "detecting_order_type" | "payment_in_progress" | "payment_successful" | "payment_failed" | "payment_cancelled" | "bank_transfer_submitted" | "pay_via_bank_completed";
+/**
+ * Ref handle for the unified checkout component.
+ * start() is async (returns Promise<boolean>) because the unified flow first detects order type
+ * via an API call before delegating to either the LRS or Standard inner component.
+ */
+export interface GlomoCheckoutRef {
+    start: () => Promise<boolean>;
+    getStatus: () => CheckoutStatus;
+}
+/** Props for the unified checkout component */
+export interface GlomoCheckoutProps {
+    server?: GlomoServer;
+    publicKey: string;
+    orderId: string;
+    onPaymentSuccess: (payload: GlomoCheckoutPayload) => void;
+    onPaymentFailure: (payload: GlomoCheckoutPayload) => void;
+    onConnectionError?: (error: unknown) => void;
+    onPaymentTerminate?: () => void;
+    onSdkError?: (error: Array<SdkError>) => void;
+    onBankTransferSubmitted?: (payload: GlomoBankTransferPayload | null | undefined) => void;
+    onPayViaBankCompleted?: (payload: {
+        status: string;
+    }) => void;
+    onPayViaBankBankConnectionSuccessful?: (payload: GlomoPayViaBankConnectionPayload | null | undefined) => void;
+    onUserRefusedCameraPermissions?: () => void;
+    devMode?: boolean;
+}
+//# sourceMappingURL=checkout.d.ts.map

package/lib/types/checkout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkout.d.ts","sourceRoot":"","sources":["../../src/types/checkout.ts"],"names":[],"mappings":"AAAA,oDAAoD;AAEpD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD,uFAAuF;AACvF,MAAM,WAAW,oBAAoB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,iDAAiD;AACjD,MAAM,WAAW,wBAAwB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,oBAAoB,EAAE,MAAM,CAAC;CAChC;AAED,wEAAwE;AACxE,MAAM,WAAW,gCAAgC;IAC7C,cAAc,EAAE,MAAM,CAAC;IACvB,uBAAuB,EAAE,MAAM,CAAC;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;CACxB;AAED,sEAAsE;AACtE,MAAM,MAAM,cAAc,GACpB,OAAO,GACP,sBAAsB,GACtB,qBAAqB,GACrB,oBAAoB,GACpB,gBAAgB,GAChB,mBAAmB,GACnB,yBAAyB,GACzB,wBAAwB,CAAC;AAE/B;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC7B,KAAK,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9B,SAAS,EAAE,MAAM,cAAc,CAAC;CACnC;AAED,+CAA+C;AAC/C,MAAM,WAAW,kBAAkB;IAC/B,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,CAAC,OAAO,EAAE,oBAAoB,KAAK,IAAI,CAAC;IAC1D,gBAAgB,EAAE,CAAC,OAAO,EAAE,oBAAoB,KAAK,IAAI,CAAC;IAC1D,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAC7C,kBAAkB,CAAC,EAAE,MAAM,IAAI,CAAC;IAChC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC;IAC9C,uBAAuB,CAAC,EAAE,CAAC,OAAO,EAAE,wBAAwB,GAAG,IAAI,GAAG,SAAS,KAAK,IAAI,CAAC;IACzF,qBAAqB,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IAC9D,oCAAoC,CAAC,EAAE,CAAC,OAAO,EAAE,gCAAgC,GAAG,IAAI,GAAG,SAAS,KAAK,IAAI,CAAC;IAC9G,8BAA8B,CAAC,EAAE,MAAM,IAAI,CAAC;IAC5C,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB"}

package/lib/types/checkout.js

@@ -0,0 +1,3 @@
+"use strict";
+/** Unified v3 type definitions for GlomoCheckout */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/standard-checkout.d.ts

@@ -0,0 +1,40 @@
+/** Type definitions for the Standard Checkout flow */
+import { type GlomoServer } from "../config/base";
+import { type SdkError } from "../utils/analytics";
+import { type GlomoBankTransferPayload, type GlomoPayViaBankConnectionPayload } from "./checkout";
+/** Standard checkout statuses */
+export type StandardCheckoutStatus = "ready" | "payment_in_progress" | "payment_successful" | "payment_failed" | "payment_cancelled" | "bank_transfer_submitted" | "pay_via_bank_completed";
+/** The payload for a successful or failed standard payment */
+export interface GlomoStandardCheckoutPayload {
+    orderId: string;
+    paymentId: string;
+    signature: string;
+}
+/**
+ * Ref handle for the standard checkout component.
+ * start() is synchronous (returns boolean) because the standard flow does not need to detect
+ * order type - unlike the unified GlomoCheckoutRef whose start() is async (returns Promise<boolean>).
+ */
+export interface GlomoStandardCheckoutRef {
+    start: () => boolean;
+    getStatus: () => StandardCheckoutStatus;
+}
+/** Props for the standard checkout component */
+export interface GlomoStandardCheckoutProps {
+    server?: GlomoServer;
+    publicKey: string;
+    orderId: string;
+    onPaymentSuccess: (payload: GlomoStandardCheckoutPayload) => void;
+    onPaymentFailure: (payload: GlomoStandardCheckoutPayload) => void;
+    onConnectionError?: (error: unknown) => void;
+    onPaymentTerminate?: () => void;
+    onSdkError?: (error: Array<SdkError>) => void;
+    onBankTransferSubmitted?: (payload: GlomoBankTransferPayload | null | undefined) => void;
+    onPayViaBankCompleted?: (payload: {
+        status: string;
+    }) => void;
+    onPayViaBankBankConnectionSuccessful?: (payload: GlomoPayViaBankConnectionPayload | null | undefined) => void;
+    onUserRefusedCameraPermissions?: () => void;
+    devMode?: boolean;
+}
+//# sourceMappingURL=standard-checkout.d.ts.map

package/lib/types/standard-checkout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-checkout.d.ts","sourceRoot":"","sources":["../../src/types/standard-checkout.ts"],"names":[],"mappings":"AAAA,sDAAsD;AAEtD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,KAAK,wBAAwB,EAAE,KAAK,gCAAgC,EAAE,MAAM,YAAY,CAAC;AAElG,iCAAiC;AACjC,MAAM,MAAM,sBAAsB,GAC5B,OAAO,GACP,qBAAqB,GACrB,oBAAoB,GACpB,gBAAgB,GAChB,mBAAmB,GACnB,yBAAyB,GACzB,wBAAwB,CAAC;AAE/B,8DAA8D;AAC9D,MAAM,WAAW,4BAA4B;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACrC,KAAK,EAAE,MAAM,OAAO,CAAC;IACrB,SAAS,EAAE,MAAM,sBAAsB,CAAC;CAC3C;AAED,gDAAgD;AAChD,MAAM,WAAW,0BAA0B;IACvC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,CAAC,OAAO,EAAE,4BAA4B,KAAK,IAAI,CAAC;IAClE,gBAAgB,EAAE,CAAC,OAAO,EAAE,4BAA4B,KAAK,IAAI,CAAC;IAClE,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAC7C,kBAAkB,CAAC,EAAE,MAAM,IAAI,CAAC;IAChC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC;IAC9C,uBAAuB,CAAC,EAAE,CAAC,OAAO,EAAE,wBAAwB,GAAG,IAAI,GAAG,SAAS,KAAK,IAAI,CAAC;IACzF,qBAAqB,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IAC9D,oCAAoC,CAAC,EAAE,CAAC,OAAO,EAAE,gCAAgC,GAAG,IAAI,GAAG,SAAS,KAAK,IAAI,CAAC;IAC9G,8BAA8B,CAAC,EAAE,MAAM,IAAI,CAAC;IAC5C,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB"}

package/lib/types/standard-checkout.js

@@ -0,0 +1,3 @@
+"use strict";
+/** Type definitions for the Standard Checkout flow */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/use-glomo-checkout.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Unified wrapper hook - detects order type (LRS vs Standard) via the order API
+ * and delegates to the appropriate inner checkout hook once resolved.
+ */
+import { type GlomoCheckoutProps, type CheckoutStatus } from "./types/checkout";
+import { type GlomoLrsCheckoutRef } from "./glomo-lrs-checkout";
+import { type GlomoStandardCheckoutRef } from "./types/standard-checkout";
+import { type OrderType } from "./services/order-type-fetcher";
+/** The return values for the useGlomoCheckout hook */
+export interface UseGlomoCheckoutReturn {
+    orderType: OrderType | null;
+    detecting: boolean;
+    start: () => Promise<boolean>;
+    getStatus: () => CheckoutStatus;
+    innerLrsRef: React.RefObject<GlomoLrsCheckoutRef>;
+    innerStandardRef: React.RefObject<GlomoStandardCheckoutRef>;
+    props: GlomoCheckoutProps;
+}
+/**
+ * The main unified checkout hook.
+ * Validates inputs, detects order type via API, then auto-starts the resolved inner component.
+ */
+export declare function useGlomoCheckout(props: GlomoCheckoutProps): UseGlomoCheckoutReturn;
+//# sourceMappingURL=use-glomo-checkout.d.ts.map

package/lib/use-glomo-checkout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-glomo-checkout.d.ts","sourceRoot":"","sources":["../src/use-glomo-checkout.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,KAAK,kBAAkB,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAChF,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1E,OAAO,EAAE,KAAK,SAAS,EAAkB,MAAM,+BAA+B,CAAC;AAS/E,sDAAsD;AACtD,MAAM,WAAW,sBAAsB;IACnC,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;IAC5B,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9B,SAAS,EAAE,MAAM,cAAc,CAAC;IAChC,WAAW,EAAE,KAAK,CAAC,SAAS,CAAC,mBAAmB,CAAC,CAAC;IAClD,gBAAgB,EAAE,KAAK,CAAC,SAAS,CAAC,wBAAwB,CAAC,CAAC;IAC5D,KAAK,EAAE,kBAAkB,CAAC;CAC7B;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,kBAAkB,GAAG,sBAAsB,CAiMlF"}

package/lib/use-glomo-checkout.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * Unified wrapper hook - detects order type (LRS vs Standard) via the order API
+ * and delegates to the appropriate inner checkout hook once resolved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGlomoCheckout = useGlomoCheckout;
+const react_1 = require("react");
+const order_type_fetcher_1 = require("./services/order-type-fetcher");
+const validation_1 = require("./utils/validation");
+const analytics_1 = require("./utils/analytics");
+/**
+ * The main unified checkout hook.
+ * Validates inputs, detects order type via API, then auto-starts the resolved inner component.
+ */
+function useGlomoCheckout(props) {
+    const { server, publicKey, orderId, onSdkError, devMode = false } = props;
+    // Order type resolved from the API - null until detection completes
+    const [orderType, setOrderType] = (0, react_1.useState)(null);
+    // Whether order type detection is in progress
+    const [detecting, setDetecting] = (0, react_1.useState)(false);
+    // Refs for the inner LRS and Standard checkout components
+    const innerLrsRef = (0, react_1.useRef)(null);
+    const innerStandardRef = (0, react_1.useRef)(null);
+    /**
+     * Tracking whether start() has been called and the inner component needs to be auto-started.
+     * This bridges the gap between order type resolution (async) and inner component mount (next render).
+     */
+    const pendingStartRef = (0, react_1.useRef)(false);
+    /**
+     * Generation counter for stale fetch detection.
+     * Incremented on every start() call and on orderId/publicKey changes. After fetchOrderType
+     * resolves, the result is discarded if the generation has moved on (props changed mid-flight).
+     */
+    const fetchGenerationRef = (0, react_1.useRef)(0);
+    /**
+     * Holds the resolve function for the pending start() promise.
+     * This allows the useEffect that auto-starts the inner component to resolve the merchant's
+     * awaited promise with the actual result of the inner start().
+     */
+    const pendingStartResolveRef = (0, react_1.useRef)(null);
+    // Deriving the unified checkout status from the inner component's status
+    const getStatus = (0, react_1.useCallback)(() => {
+        if (detecting) {
+            return "detecting_order_type";
+        }
+        // Delegating to the inner component's getStatus() once order type is resolved
+        if (orderType === "lrs" && innerLrsRef.current) {
+            return innerLrsRef.current.getStatus();
+        }
+        if (orderType === "standard" && innerStandardRef.current) {
+            return innerStandardRef.current.getStatus();
+        }
+        return "ready";
+    }, [detecting, orderType]);
+    /**
+     * Initiator for the unified checkout flow.
+     * Validates inputs, calls the order type detection API, and marks the inner component for auto-start.
+     */
+    const start = (0, react_1.useCallback)(async () => {
+        // If a previous start() call is still pending, resolve it as false before proceeding
+        if (pendingStartResolveRef.current) {
+            pendingStartResolveRef.current(false);
+            pendingStartResolveRef.current = null;
+        }
+        if (devMode) {
+            console.log("[Glomo-RN-SDK] start() called");
+        }
+        // Validating inputs before making the API call
+        const errors = [];
+        if (!(0, validation_1.isValidPublicKey)(publicKey)) {
+            errors.push({
+                type: "validation_error",
+                message: "Invalid publicKey: must start with 'live_', 'mock_', or 'test_' and be a valid string",
+                field: "publicKey",
+            });
+        }
+        if (!(0, validation_1.isValidOrderId)(orderId)) {
+            errors.push({
+                type: "validation_error",
+                message: "Invalid orderId: must start with 'order_' and be a valid string",
+                field: "orderId",
+            });
+        }
+        // Reporting validation errors and aborting if any
+        if (errors.length > 0) {
+            if (devMode) {
+                console.error("[Glomo-RN-SDK] Validation failed.");
+            }
+            (0, validation_1.safeCallback)(onSdkError, [errors], "onSdkError", devMode);
+            return false;
+        }
+        // Detecting order type via the API
+        setDetecting(true);
+        const thisGeneration = ++fetchGenerationRef.current;
+        if (devMode) {
+            console.log("[Glomo-RN-SDK] Detecting order type...");
+        }
+        (0, analytics_1.trackOrderTypeDetectionStarted)(orderId, publicKey, devMode);
+        const result = await (0, order_type_fetcher_1.fetchOrderType)({ orderId, publicKey, server, devMode });
+        // Discarding stale result if props changed while the fetch was in flight
+        if (thisGeneration !== fetchGenerationRef.current) {
+            if (devMode) {
+                console.log("[Glomo-RN-SDK] Discarding stale order type result (props changed mid-flight)");
+            }
+            return false;
+        }
+        setDetecting(false);
+        // Handling detection failure
+        if (!result.success) {
+            if (devMode) {
+                console.error(`[Glomo-RN-SDK] Order type detection failed: ${result.error}`);
+            }
+            (0, analytics_1.trackOrderTypeDetectionFailed)(orderId, publicKey, result.error, devMode);
+            (0, validation_1.safeCallback)(onSdkError, [[{ type: "validation_error", message: result.error }]], "onSdkError", devMode);
+            return false;
+        }
+        if (devMode) {
+            console.log(`[Glomo-RN-SDK] Order type resolved: ${result.orderType}`);
+        }
+        (0, analytics_1.trackOrderTypeDetectionResolved)(orderId, publicKey, result.orderType, devMode);
+        // Setting the resolved order type - this triggers a re-render that mounts the inner component
+        setOrderType(result.orderType);
+        // Returning a promise that resolves only when the inner component's start() completes
+        return new Promise((resolve) => {
+            pendingStartResolveRef.current = resolve;
+            pendingStartRef.current = true;
+        });
+    }, [devMode, publicKey, orderId, server, onSdkError]);
+    /**
+     * Auto-starting the inner component after order type is resolved and the component has rendered.
+     * The pendingStartRef bridges the async gap: start() sets it, and this effect fires after
+     * the inner component mounts in the next render cycle.
+     */
+    (0, react_1.useEffect)(() => {
+        if (!pendingStartRef.current || !orderType) {
+            return;
+        }
+        // Forwarding start() to the appropriate inner component
+        let started = false;
+        if (orderType === "lrs" && innerLrsRef.current) {
+            pendingStartRef.current = false;
+            started = innerLrsRef.current.start();
+            if (devMode) {
+                console.log(`[Glomo-RN-SDK] LRS inner start() returned: ${started}`);
+            }
+        }
+        else if (orderType === "standard" && innerStandardRef.current) {
+            pendingStartRef.current = false;
+            started = innerStandardRef.current.start();
+            if (devMode) {
+                console.log(`[Glomo-RN-SDK] Standard inner start() returned: ${started}`);
+            }
+        }
+        // Resolving the merchant's awaited start() promise with the inner component's result
+        if (pendingStartResolveRef.current) {
+            pendingStartResolveRef.current(started);
+            pendingStartResolveRef.current = null;
+        }
+    }, [orderType, devMode]);
+    // Resetting order type state when orderId or publicKey changes to force re-detection
+    (0, react_1.useEffect)(() => {
+        // Invalidating any in-flight fetchOrderType call so its stale result is discarded
+        fetchGenerationRef.current++;
+        if (pendingStartResolveRef.current) {
+            pendingStartResolveRef.current(false);
+            pendingStartResolveRef.current = null;
+        }
+        setOrderType(null);
+        setDetecting(false);
+        pendingStartRef.current = false;
+    }, [orderId, publicKey]);
+    return {
+        orderType,
+        detecting,
+        start,
+        getStatus,
+        innerLrsRef,
+        innerStandardRef,
+        props,
+    };
+}