@reevit/core 0.8.1 → 0.9.1

package/dist/index.js

@@ -21,13 +21,17 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   ReevitAPIClient: () => ReevitAPIClient,
+  attemptIdempotencyKey: () => attemptIdempotencyKey,
   cacheIntentPromise: () => cacheIntentPromise,
   cacheIntentResponse: () => cacheIntentResponse,
+  clearIdempotencyAttemptKeys: () => clearIdempotencyAttemptKeys,
   clearIntentCacheEntry: () => clearIntentCacheEntry,
   cn: () => cn,
   createInitialState: () => createInitialState,
+  createPaymentError: () => createPaymentError,
   createReevitClient: () => createReevitClient,
   createThemeVariables: () => createThemeVariables,
+  currencyExponent: () => currencyExponent,
   detectCountryFromCurrency: () => detectCountryFromCurrency,
   detectNetwork: () => detectNetwork,
   formatAmount: () => formatAmount,
@@ -35,8 +39,11 @@ __export(index_exports, {
   generateIdempotencyKey: () => generateIdempotencyKey,
   generateReference: () => generateReference,
   getIntentCacheEntry: () => getIntentCacheEntry,
+  isPaymentError: () => isPaymentError,
+  newIdempotencyKey: () => newIdempotencyKey,
   reevitReducer: () => reevitReducer,
   resolveIntentIdentity: () => resolveIntentIdentity,
+  toMinorUnits: () => toMinorUnits,
   validatePhone: () => validatePhone
 });
 module.exports = __toCommonJS(index_exports);
@@ -44,16 +51,25 @@ module.exports = __toCommonJS(index_exports);
 // src/api/client.ts
 var API_BASE_URL_PRODUCTION = "https://api.reevit.io";
 var DEFAULT_TIMEOUT = 3e4;
+var hasWarnedAboutLiveBrowserIntents = false;
 function createPaymentError(response, errorData) {
   return {
     code: errorData.code || "api_error",
     message: errorData.message || "An unexpected error occurred",
+    recoverable: isRecoverableStatus(response.status),
     details: {
       httpStatus: response.status,
+      requestId: response.headers.get("x-request-id") || response.headers.get("x-reevit-request-id") || void 0,
       ...errorData.details
     }
   };
 }
+function isPaymentError(error) {
+  return typeof error === "object" && error !== null && "code" in error && "message" in error;
+}
+function isRecoverableStatus(status) {
+  return status === 408 || status === 409 || status === 425 || status === 429 || status >= 500;
+}
 function generateIdempotencyKey(params) {
   const sortedKeys = Object.keys(params).sort();
   const stableString = sortedKeys.map((key) => `${key}:${JSON.stringify(params[key])}`).join("|");
@@ -66,6 +82,95 @@ function generateIdempotencyKey(params) {
   const timeBucket = Math.floor(Date.now() / (5 * 60 * 1e3));
   return `reevit_${timeBucket}_${hashHex}`;
 }
+var IDEMPOTENCY_STORE_PREFIX = "reevit:idem:";
+var memoryAttemptKeys = /* @__PURE__ */ new Map();
+function getSessionStore() {
+  try {
+    const storage = globalThis.sessionStorage;
+    if (!storage) {
+      return null;
+    }
+    const probe = `${IDEMPOTENCY_STORE_PREFIX}probe`;
+    storage.setItem(probe, "1");
+    storage.removeItem(probe);
+    return storage;
+  } catch {
+    return null;
+  }
+}
+function newIdempotencyKey() {
+  const cryptoObj = globalThis.crypto;
+  if (cryptoObj && typeof cryptoObj.randomUUID === "function") {
+    try {
+      return cryptoObj.randomUUID();
+    } catch {
+    }
+  }
+  const bytes = new Uint8Array(16);
+  if (cryptoObj && typeof cryptoObj.getRandomValues === "function") {
+    cryptoObj.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = [];
+  for (let i = 0; i < bytes.length; i++) {
+    hex.push(bytes[i].toString(16).padStart(2, "0"));
+  }
+  return [
+    hex.slice(0, 4).join(""),
+    hex.slice(4, 6).join(""),
+    hex.slice(6, 8).join(""),
+    hex.slice(8, 10).join(""),
+    hex.slice(10, 16).join("")
+  ].join("-");
+}
+function attemptIdempotencyKey(lookupKey) {
+  const storageKey = `${IDEMPOTENCY_STORE_PREFIX}${lookupKey}`;
+  const store = getSessionStore();
+  if (store) {
+    try {
+      const existing2 = store.getItem(storageKey);
+      if (existing2) {
+        return existing2;
+      }
+      const created2 = newIdempotencyKey();
+      store.setItem(storageKey, created2);
+      return created2;
+    } catch {
+    }
+  }
+  const existing = memoryAttemptKeys.get(storageKey);
+  if (existing) {
+    return existing;
+  }
+  const created = newIdempotencyKey();
+  memoryAttemptKeys.set(storageKey, created);
+  return created;
+}
+function clearIdempotencyAttemptKeys() {
+  memoryAttemptKeys.clear();
+  const store = getSessionStore();
+  if (!store) {
+    return;
+  }
+  try {
+    const keys = [];
+    for (let i = 0; i < store.length; i++) {
+      const key = store.key(i);
+      if (key && key.startsWith(IDEMPOTENCY_STORE_PREFIX)) {
+        keys.push(key);
+      }
+    }
+    for (const key of keys) {
+      store.removeItem(key);
+    }
+  } catch {
+  }
+}
 var ReevitAPIClient = class {
   constructor(config) {
     this.publicKey = config.publicKey || "";
@@ -82,13 +187,13 @@ var ReevitAPIClient = class {
     const headers = {
       "Content-Type": "application/json",
       "X-Reevit-Client": "@reevit/core",
-      "X-Reevit-Client-Version": "0.8.1"
+      "X-Reevit-Client-Version": "0.9.1"
     };
     if (this.publicKey) {
       headers["X-Reevit-Key"] = this.publicKey;
     }
     if (method === "POST" || method === "PATCH" || method === "PUT") {
-      headers["Idempotency-Key"] = idempotencyKey || (body ? generateIdempotencyKey(body) : `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`);
+      headers["Idempotency-Key"] = idempotencyKey || newIdempotencyKey();
     }
     try {
       const response = await fetch(`${this.baseUrl}${path}`, {
@@ -112,7 +217,8 @@ var ReevitAPIClient = class {
           return {
             error: {
               code: "request_timeout",
-              message: "The request timed out. Please try again."
+              message: "The request timed out. Please try again.",
+              recoverable: true
             }
           };
         }
@@ -120,7 +226,8 @@ var ReevitAPIClient = class {
           return {
             error: {
               code: "network_error",
-              message: "Unable to connect to Reevit. Please check your internet connection."
+              message: "Unable to connect to Reevit. Please check your internet connection.",
+              recoverable: true
             }
           };
         }
@@ -128,7 +235,8 @@ var ReevitAPIClient = class {
       return {
         error: {
           code: "unknown_error",
-          message: "An unexpected error occurred. Please try again."
+          message: "An unexpected error occurred. Please try again.",
+          recoverable: true
         }
       };
     }
@@ -137,6 +245,21 @@ var ReevitAPIClient = class {
    * Creates a payment intent
    */
   async createPaymentIntent(config, method, country = "GH", options) {
+    if (this.publicKey.startsWith("pfk_live_") && !hasWarnedAboutLiveBrowserIntents && typeof console !== "undefined") {
+      hasWarnedAboutLiveBrowserIntents = true;
+      console.warn(
+        "Creating live payment intents from the browser is deprecated. Create a checkout session on your server and pass sessionSecret to the browser SDK instead."
+      );
+    }
+    if (typeof config.amount !== "number" || !config.currency) {
+      return {
+        error: {
+          code: "invalid_checkout_config",
+          message: "amount and currency are required when creating a payment intent in the browser.",
+          recoverable: false
+        }
+      };
+    }
     const metadata = { ...config.metadata };
     if (config.email) {
       metadata.customer_email = config.email;
@@ -160,7 +283,7 @@ var ReevitAPIClient = class {
         allowed_providers: options?.allowedProviders
       };
     }
-    const idempotencyKey = config.idempotencyKey || generateIdempotencyKey({
+    const idempotencyKey = config.idempotencyKey || attemptIdempotencyKey(generateIdempotencyKey({
       amount: config.amount,
       currency: config.currency,
       customer: config.email || config.metadata?.customerId || "",
@@ -168,7 +291,7 @@ var ReevitAPIClient = class {
       method: method || "",
       provider: options?.preferredProviders?.[0] || options?.allowedProviders?.[0] || "",
       publicKey: this.publicKey
-    });
+    }));
     return this.request("POST", "/v1/payments/intents", request, idempotencyKey);
   }
   /**
@@ -177,6 +300,15 @@ var ReevitAPIClient = class {
   async getPaymentIntent(paymentId) {
     return this.request("GET", `/v1/payments/${paymentId}`);
   }
+  /**
+   * Retrieves a server-created checkout session using its public session secret.
+   */
+  async getCheckoutSession(sessionSecret) {
+    return this.request(
+      "GET",
+      `/v1/checkout/sessions/${encodeURIComponent(sessionSecret)}`
+    );
+  }
   /**
    * Confirms a payment after PSP callback
    */
@@ -228,25 +360,62 @@ function createReevitClient(config) {
 }
 
 // src/utils.ts
+var CURRENCY_LOCALES = {
+  GHS: "en-GH",
+  NGN: "en-NG",
+  KES: "en-KE",
+  USD: "en-US",
+  EUR: "de-DE",
+  GBP: "en-GB"
+};
+var ZERO_DECIMAL_CURRENCIES = /* @__PURE__ */ new Set([
+  "XOF",
+  "XAF",
+  "RWF",
+  "UGX",
+  "JPY",
+  "KRW",
+  "BIF",
+  "GNF",
+  "VND",
+  "CLP",
+  "ISK",
+  "KMF",
+  "DJF",
+  "PYG",
+  "MGA"
+]);
+function currencyExponent(currency) {
+  const code = (currency || "").toUpperCase();
+  try {
+    const digits = new Intl.NumberFormat("en", {
+      style: "currency",
+      currency: code
+    }).resolvedOptions().maximumFractionDigits;
+    if (typeof digits === "number" && Number.isFinite(digits)) {
+      return digits;
+    }
+  } catch {
+  }
+  return ZERO_DECIMAL_CURRENCIES.has(code) ? 0 : 2;
+}
+function toMinorUnits(major, currency) {
+  return Math.round(major * 10 ** currencyExponent(currency));
+}
 function formatAmount(amount, currency) {
-  const majorUnit = amount / 100;
-  const currencyFormats = {
-    GHS: { locale: "en-GH", minimumFractionDigits: 2 },
-    NGN: { locale: "en-NG", minimumFractionDigits: 2 },
-    KES: { locale: "en-KE", minimumFractionDigits: 2 },
-    USD: { locale: "en-US", minimumFractionDigits: 2 },
-    EUR: { locale: "de-DE", minimumFractionDigits: 2 },
-    GBP: { locale: "en-GB", minimumFractionDigits: 2 }
-  };
-  const format = currencyFormats[currency.toUpperCase()] || { locale: "en-US", minimumFractionDigits: 2 };
+  const code = (currency || "").toUpperCase();
+  const exponent = currencyExponent(code);
+  const majorUnit = amount / 10 ** exponent;
+  const locale = CURRENCY_LOCALES[code] || "en-US";
   try {
-    return new Intl.NumberFormat(format.locale, {
+    return new Intl.NumberFormat(locale, {
       style: "currency",
-      currency: currency.toUpperCase(),
-      minimumFractionDigits: format.minimumFractionDigits
+      currency: code,
+      minimumFractionDigits: exponent,
+      maximumFractionDigits: exponent
     }).format(majorUnit);
   } catch {
-    return `${currency} ${majorUnit.toFixed(2)}`;
+    return `${code} ${majorUnit.toFixed(exponent)}`;
   }
 }
 function generateReference(prefix = "reevit") {
@@ -364,37 +533,60 @@ function detectCountryFromCurrency(currency) {
 // src/intent.ts
 var INTENT_CACHE_TTL_MS = 10 * 60 * 1e3;
 var intentCache = /* @__PURE__ */ new Map();
+var lookupKeyByWireKey = /* @__PURE__ */ new Map();
+function forgetKey(lookupKey) {
+  const entry = intentCache.get(lookupKey);
+  if (entry?.idempotencyKey) {
+    lookupKeyByWireKey.delete(entry.idempotencyKey);
+  }
+  intentCache.delete(lookupKey);
+}
+function toLookupKey(key) {
+  return lookupKeyByWireKey.get(key) ?? key;
+}
 function pruneIntentCache(now = Date.now()) {
   for (const [key, entry] of intentCache) {
     if (entry.expiresAt <= now) {
-      intentCache.delete(key);
+      forgetKey(key);
     }
   }
 }
-function getIntentCacheEntryInternal(key) {
-  const entry = intentCache.get(key);
+function getIntentCacheEntryInternal(lookupKey) {
+  const entry = intentCache.get(lookupKey);
   if (!entry) {
     return void 0;
   }
   if (entry.expiresAt <= Date.now()) {
-    intentCache.delete(key);
+    forgetKey(lookupKey);
     return void 0;
   }
   return entry;
 }
-function setIntentCacheEntryInternal(key, update) {
+function setIntentCacheEntryInternal(lookupKey, update) {
   const now = Date.now();
-  const existing = getIntentCacheEntryInternal(key);
+  const existing = getIntentCacheEntryInternal(lookupKey);
   const next = {
     ...existing,
     ...update,
     expiresAt: now + INTENT_CACHE_TTL_MS
   };
-  intentCache.set(key, next);
+  if (existing?.idempotencyKey && existing.idempotencyKey !== next.idempotencyKey) {
+    lookupKeyByWireKey.delete(existing.idempotencyKey);
+  }
+  intentCache.set(lookupKey, next);
+  if (next.idempotencyKey && next.idempotencyKey !== lookupKey) {
+    lookupKeyByWireKey.set(next.idempotencyKey, lookupKey);
+  }
   return next;
 }
 function buildIdempotencyPayload(options) {
   const { config, method, preferredProvider, allowedProviders, publicKey } = options;
+  if (config.sessionSecret) {
+    return {
+      sessionSecret: config.sessionSecret,
+      publicKey: publicKey || config.publicKey || ""
+    };
+  }
   const payload = {
     amount: config.amount,
     currency: config.currency,
@@ -417,24 +609,26 @@ function buildIdempotencyPayload(options) {
 }
 function resolveIntentIdentity(options) {
   pruneIntentCache();
-  const idempotencyKey = options.config.idempotencyKey || generateIdempotencyKey(buildIdempotencyPayload(options));
-  const existing = getIntentCacheEntryInternal(idempotencyKey);
+  const explicitKey = options.config.idempotencyKey;
+  const lookupKey = explicitKey || generateIdempotencyKey(buildIdempotencyPayload(options));
+  const idempotencyKey = explicitKey || attemptIdempotencyKey(lookupKey);
+  const existing = getIntentCacheEntryInternal(lookupKey);
   const reference = options.config.reference || existing?.reference || generateReference();
-  const cacheEntry = setIntentCacheEntryInternal(idempotencyKey, { reference });
-  return { idempotencyKey, reference, cacheEntry };
+  const cacheEntry = setIntentCacheEntryInternal(lookupKey, { reference, idempotencyKey });
+  return { idempotencyKey, lookupKey, reference, cacheEntry };
 }
-function getIntentCacheEntry(idempotencyKey) {
+function getIntentCacheEntry(key) {
   pruneIntentCache();
-  return getIntentCacheEntryInternal(idempotencyKey);
+  return getIntentCacheEntryInternal(toLookupKey(key));
 }
-function cacheIntentPromise(idempotencyKey, promise) {
-  return setIntentCacheEntryInternal(idempotencyKey, { promise });
+function cacheIntentPromise(key, promise) {
+  return setIntentCacheEntryInternal(toLookupKey(key), { promise });
 }
-function cacheIntentResponse(idempotencyKey, response) {
-  return setIntentCacheEntryInternal(idempotencyKey, { response, promise: void 0 });
+function cacheIntentResponse(key, response) {
+  return setIntentCacheEntryInternal(toLookupKey(key), { response, promise: void 0 });
 }
-function clearIntentCacheEntry(idempotencyKey) {
-  intentCache.delete(idempotencyKey);
+function clearIntentCacheEntry(key) {
+  forgetKey(toLookupKey(key));
 }
 
 // src/state.ts
@@ -479,13 +673,17 @@ function reevitReducer(state, action) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ReevitAPIClient,
+  attemptIdempotencyKey,
   cacheIntentPromise,
   cacheIntentResponse,
+  clearIdempotencyAttemptKeys,
   clearIntentCacheEntry,
   cn,
   createInitialState,
+  createPaymentError,
   createReevitClient,
   createThemeVariables,
+  currencyExponent,
   detectCountryFromCurrency,
   detectNetwork,
   formatAmount,
@@ -493,8 +691,11 @@ function reevitReducer(state, action) {
   generateIdempotencyKey,
   generateReference,
   getIntentCacheEntry,
+  isPaymentError,
+  newIdempotencyKey,
   reevitReducer,
   resolveIntentIdentity,
+  toMinorUnits,
   validatePhone
 });
 //# sourceMappingURL=index.js.map