@applite/duticotac-react 0.0.3 → 0.0.5

package/dist/index.js

@@ -6,6 +6,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -28,6 +31,318 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// ../../node_modules/.pnpm/@applite+duticotac@0.0.3/node_modules/@applite/duticotac/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/.pnpm/@applite+duticotac@0.0.3/node_modules/@applite/duticotac/dist/index.js"(exports2, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports2 = {};
+    __export2(index_exports2, {
+      BalanceModule: () => BalanceModule,
+      DuticotacError: () => DuticotacError2,
+      DuticotacSDK: () => DuticotacSDK2,
+      ERROR_MESSAGES: () => ERROR_MESSAGES,
+      HttpClient: () => HttpClient,
+      MobileMoneyModule: () => MobileMoneyModule,
+      OfferModule: () => OfferModule,
+      PaymentMethodModule: () => PaymentMethodModule,
+      TransactionModule: () => TransactionModule,
+      WebhookModule: () => WebhookModule,
+      getErrorMessage: () => getErrorMessage2,
+      getProviderLogo: () => getProviderLogo2,
+      getProviderName: () => getProviderName2
+    });
+    module2.exports = __toCommonJS2(index_exports2);
+    var ERROR_MESSAGES = {
+      "payment-failed": "\xC9chec du paiement",
+      "ref-or-idFromClient-required": "R\xE9f\xE9rence ou IDFromClient requis",
+      "product-not-found": "Produit non trouv\xE9",
+      "no-api-key": "Cl\xE9 API non fournie",
+      "phone-required": "Num\xE9ro de t\xE9l\xE9phone requis",
+      "iap-not-available": "Les achats in-app ne sont pas disponibles.",
+      "iap-purchase-failed": "Echec de l'achat",
+      "otp-required": "Code OTP requis pour les paiements Orange Money",
+      "app-not-found": "Application non trouv\xE9e dans AppLite UI",
+      "duticotac-setting-not-found": "Configuration Duticotac non trouv\xE9e",
+      "payment-method-not-activated": "M\xE9thode de paiement non activ\xE9e",
+      "no-provider-found": "M\xE9thode de paiement non activ\xE9e",
+      "customer-not-found": "Client non trouv\xE9",
+      "invalid-plateform": "Plateforme invalide",
+      "unknown-error": "Une erreur inconnue est survenue",
+      "reference-required": "R\xE9f\xE9rence requise",
+      "polling-timeout": "Temps d'attente de la transaction expir\xE9",
+      "payment-cancelled": "Paiement annul\xE9",
+      "wait-before-retry": "Veuillez attendre avant de r\xE9essayer",
+      "context-not-mounted": "Contexte non mont\xE9",
+      "show-modal-bottom-sheet-error": "Erreur lors de l'affichage de la fen\xEAtre modale"
+    };
+    function getErrorMessage2(code) {
+      return ERROR_MESSAGES[code] ?? ERROR_MESSAGES["unknown-error"];
+    }
+    var DuticotacError2 = class extends Error {
+      constructor(code, message) {
+        super(message ?? getErrorMessage2(code));
+        this.code = code;
+        this.name = "DuticotacError";
+      }
+    };
+    var DEFAULT_BASE_URL = "https://api.applite.freddydro.dev";
+    var HttpClient = class {
+      constructor(config = {}) {
+        this.baseUrl = config.baseUrl?.replace(/\/$/, "") ?? DEFAULT_BASE_URL;
+        this.headers = config.headers ?? {};
+        this.fetchImpl = config.fetchFn ?? fetch;
+        this.apiKey = config.apiKey;
+        this.appId = config.appId;
+      }
+      async post(path, body) {
+        const mergedBody = {
+          ...this.apiKey ? { apiKey: this.apiKey } : {},
+          ...this.appId !== void 0 ? { appId: this.appId } : {},
+          ...body
+        };
+        const url = `${this.baseUrl}${path}`;
+        const response = await this.fetchImpl(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...this.headers
+          },
+          body: JSON.stringify(mergedBody)
+        });
+        const contentType = response.headers.get("content-type") ?? "";
+        const isJson = contentType.includes("application/json");
+        const payload = isJson ? await response.json() : null;
+        if (!response.ok) {
+          const errorCode = typeof payload?.error === "string" ? payload.error : "unknown-error";
+          throw new DuticotacError2(
+            errorCode,
+            `Request failed with status ${response.status}: ${payload?.error ?? response.statusText}`
+          );
+        }
+        if (!payload || payload.success !== true) {
+          const errorCode = typeof payload?.error === "string" ? payload.error : "unknown-error";
+          throw new DuticotacError2(errorCode);
+        }
+        return payload;
+      }
+    };
+    var BalanceModule = class {
+      constructor(http) {
+        this.http = http;
+      }
+      balance(params = {}) {
+        return this.http.post("/duticotac/balance", params);
+      }
+    };
+    var OfferModule = class {
+      constructor(http) {
+        this.http = http;
+      }
+      create(params) {
+        return this.http.post("/duticotac/offer/create", params);
+      }
+      list(params = {}) {
+        return this.http.post("/duticotac/offer/list", params);
+      }
+      get(params) {
+        const { ref, ...body } = params;
+        return this.http.post(`/duticotac/offer/${ref}`, body);
+      }
+      update(params) {
+        const { ref, ...body } = params;
+        return this.http.post(`/duticotac/offer/${ref}/edit`, body);
+      }
+      delete(params) {
+        const { ref, ...body } = params;
+        return this.http.post(`/duticotac/offer/${ref}/delete`, body);
+      }
+    };
+    var MobileMoneyModule = class {
+      constructor(http) {
+        this.http = http;
+      }
+      cashin(params) {
+        return this.http.post(
+          "/duticotac/pay/mobile-money/cashin",
+          params
+        );
+      }
+      cashout(params) {
+        if (params.paymentMethod === "OM_CI" && !params.otp) {
+          throw new DuticotacError2("otp-required");
+        }
+        if (!params.ref && !params.idFromClient) {
+          throw new DuticotacError2("ref-or-idFromClient-required");
+        }
+        return this.http.post(
+          "/duticotac/pay/mobile-money/cashout",
+          params
+        );
+      }
+      handleCashinWebhook(params) {
+        return this.http.post("/duticotac/pay/mobile-money/cashin/webhook", params);
+      }
+      handleCashoutWebhook(params) {
+        return this.http.post(
+          "/duticotac/pay/mobile-money/cashout/webhook",
+          params
+        );
+      }
+    };
+    var PaymentMethodModule = class {
+      constructor(http) {
+        this.http = http;
+      }
+      get(params = {}) {
+        return this.http.post(
+          "/duticotac/payment-method",
+          params
+        );
+      }
+      set(params) {
+        return this.http.post(
+          "/duticotac/payment-method/set",
+          params
+        );
+      }
+    };
+    var WebhookModule = class {
+      constructor(http) {
+        this.http = http;
+      }
+      get(params = {}) {
+        return this.http.post("/duticotac/webhook", params);
+      }
+      set(params) {
+        return this.http.post("/duticotac/webhook/set", params);
+      }
+    };
+    function backoff(attempt) {
+      switch (attempt) {
+        case 1:
+          return 1e3;
+        case 2:
+          return 2e3;
+        case 3:
+          return 3e3;
+        case 4:
+          return 5e3;
+        default:
+          return 8e3;
+      }
+    }
+    function delay(ms) {
+      return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    var TransactionModule = class {
+      constructor(http) {
+        this.http = http;
+      }
+      get(params) {
+        return this.http.post(
+          "/duticotac/transaction/get",
+          params
+        );
+      }
+      async poll(id, options) {
+        const intervalMs = options?.intervalMs ?? 2e3;
+        const timeoutMs = options?.timeoutMs ?? 9e4;
+        const start = Date.now();
+        let attempt = 0;
+        while (true) {
+          attempt++;
+          const elapsed = Date.now() - start;
+          if (elapsed > timeoutMs) {
+            throw new DuticotacError2("polling-timeout");
+          }
+          if (options?.signal?.aborted) {
+            throw new DuticotacError2("payment-cancelled");
+          }
+          options?.onPoll?.(attempt, elapsed);
+          try {
+            const result = await this.get({ id });
+            const status = result.data?.status;
+            if (status === "CONFIRMED") return result;
+            if (status === "CANCELLED") throw new DuticotacError2("payment-cancelled");
+            if (status === "FAILED")
+              throw new DuticotacError2("payment-failed");
+            const wait = Math.max(backoff(attempt), intervalMs);
+            await delay(wait);
+          } catch (e) {
+            if (e instanceof DuticotacError2) throw e;
+            const wait = Math.max(backoff(attempt), intervalMs);
+            await delay(wait);
+          }
+        }
+      }
+    };
+    function getProviderName2(provider) {
+      switch (provider) {
+        case "OM_CI":
+          return "Orange Money";
+        case "MTN_CI":
+          return "MTN Momo";
+        case "MOOV_CI":
+          return "Moov (Flooz)";
+        case "WAVE_CI":
+          return "Wave";
+        case "CREDIT_CARD":
+          return "Carte de cr\xE9dit";
+        case "CASH":
+          return "Esp\xE8ces";
+        case "IAP":
+          return "Achat Int\xE9gr\xE9";
+      }
+    }
+    function getProviderLogo2(provider) {
+      switch (provider) {
+        case "OM_CI":
+          return "https://payto.freddydro.dev/images/OM.png";
+        case "MTN_CI":
+          return "https://payto.freddydro.dev/images/MTN.png";
+        case "MOOV_CI":
+          return "https://payto.freddydro.dev/images/MOOV.png";
+        case "WAVE_CI":
+          return "https://payto.freddydro.dev/images/WAVE.png";
+        case "CREDIT_CARD":
+          return "https://payto.freddydro.dev/images/CREDIT_CARD.png";
+        case "CASH":
+          return "https://payto.freddydro.dev/images/CASH.png";
+        case "IAP":
+          return "https://payto.freddydro.dev/images/IAP.png";
+      }
+    }
+    var DuticotacSDK2 = class {
+      constructor(config = {}) {
+        this.http = new HttpClient(config);
+        this.balance = new BalanceModule(this.http);
+        this.offer = new OfferModule(this.http);
+        this.mobileMoney = new MobileMoneyModule(this.http);
+        this.paymentMethod = new PaymentMethodModule(this.http);
+        this.webhook = new WebhookModule(this.http);
+        this.transaction = new TransactionModule(this.http);
+      }
+    };
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -49,10 +364,10 @@ module.exports = __toCommonJS(index_exports);
 
 // src/components/payment-modal.tsx
 var React2 = __toESM(require("react"));
-var import_duticotac2 = require("@applite/duticotac");
+var import_duticotac2 = __toESM(require_dist());
 
 // src/components/provider-selector.tsx
-var import_duticotac = require("@applite/duticotac");
+var import_duticotac = __toESM(require_dist());
 
 // src/utils/cn.ts
 var import_clsx = require("clsx");