@reevit/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,332 @@
+/**
+ * Reevit Core Types
+ * Shared type definitions for all Reevit SDKs
+ */
+type PaymentMethod = 'card' | 'mobile_money' | 'bank_transfer';
+type MobileMoneyNetwork = 'mtn' | 'vodafone' | 'airteltigo';
+type PSPType = 'paystack' | 'hubtel' | 'flutterwave' | 'stripe' | 'monnify' | 'mpesa';
+interface ReevitCheckoutConfig {
+    /** Your Reevit public key (pk_live_xxx or pk_test_xxx) */
+    publicKey: string;
+    /** Amount in the smallest currency unit (e.g., pesewas for GHS) */
+    amount: number;
+    /** Currency code (e.g., 'GHS', 'NGN', 'USD') */
+    currency: string;
+    /** Customer email address */
+    email?: string;
+    /** Customer phone number (required for mobile money) */
+    phone?: string;
+    /** Unique reference for this transaction */
+    reference?: string;
+    /** Additional metadata to attach to the payment */
+    metadata?: Record<string, unknown>;
+    /** Payment methods to display */
+    paymentMethods?: PaymentMethod[];
+}
+interface ReevitCheckoutCallbacks {
+    /** Called when payment is successful */
+    onSuccess?: (result: PaymentResult) => void;
+    /** Called when payment fails */
+    onError?: (error: PaymentError) => void;
+    /** Called when user closes the checkout */
+    onClose?: () => void;
+    /** Called when checkout state changes */
+    onStateChange?: (state: CheckoutState) => void;
+}
+type CheckoutState = 'idle' | 'loading' | 'ready' | 'method_selected' | 'processing' | 'success' | 'failed' | 'closed';
+interface PaymentResult {
+    /** Unique payment ID from Reevit */
+    paymentId: string;
+    /** Reference provided or generated */
+    reference: string;
+    /** Amount paid in smallest currency unit */
+    amount: number;
+    /** Currency code */
+    currency: string;
+    /** Payment method used */
+    paymentMethod: PaymentMethod;
+    /** PSP that processed the payment */
+    psp: string;
+    /** PSP's transaction reference */
+    pspReference: string;
+    /** Payment status */
+    status: 'success' | 'pending';
+    /** Any additional data from the PSP */
+    metadata?: Record<string, unknown>;
+}
+interface PaymentError {
+    /** Error code */
+    code: string;
+    /** Human-readable error message */
+    message: string;
+    /** Whether the error is recoverable (user can retry) */
+    recoverable?: boolean;
+    /** Original error from PSP if available */
+    originalError?: unknown;
+    /** Additional error details */
+    details?: Record<string, unknown>;
+}
+interface ReevitTheme {
+    /** Primary brand color */
+    primaryColor?: string;
+    /** Background color */
+    backgroundColor?: string;
+    /** Text color */
+    textColor?: string;
+    /** Border radius for inputs and buttons */
+    borderRadius?: string;
+    /** Font family to use */
+    fontFamily?: string;
+    /** Whether to use dark mode */
+    darkMode?: boolean;
+}
+interface PSPConfig {
+    id: string;
+    name: string;
+    supportedMethods: PaymentMethod[];
+    supportedCurrencies: string[];
+}
+interface MobileMoneyFormData {
+    phone: string;
+    network: MobileMoneyNetwork;
+}
+interface CardFormData {
+    /** Token from PSP's hosted fields */
+    token: string;
+    /** Last 4 digits for display */
+    last4?: string;
+    /** Card brand (visa, mastercard, etc.) */
+    brand?: string;
+}
+interface PaymentIntent {
+    /** Unique payment intent ID */
+    id: string;
+    /** Client secret for authenticating client-side operations */
+    clientSecret: string;
+    /** Amount in smallest currency unit */
+    amount: number;
+    /** Currency code */
+    currency: string;
+    /** Payment status */
+    status: 'pending' | 'processing' | 'succeeded' | 'failed' | 'cancelled';
+    /** Recommended PSP based on routing rules */
+    recommendedPsp: PSPType;
+    /** Available payment methods for this intent */
+    availableMethods: PaymentMethod[];
+    /** Connection ID (from Reevit backend) */
+    connectionId?: string;
+    /** Provider name (from backend) */
+    provider?: string;
+    /** Fee amount charged by PSP */
+    feeAmount?: number;
+    /** Fee currency */
+    feeCurrency?: string;
+    /** Net amount after fees */
+    netAmount?: number;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+
+/**
+ * Reevit API Client
+ *
+ * Handles communication with the Reevit backend for payment operations.
+ */
+
+interface CreatePaymentIntentRequest {
+    amount: number;
+    currency: string;
+    method: string;
+    country: string;
+    customer_id?: string;
+    metadata?: Record<string, unknown>;
+    description?: string;
+    policy?: {
+        prefer?: string[];
+        max_amount?: number;
+        blocked_bins?: string[];
+        allowed_bins?: string[];
+        velocity_max_per_minute?: number;
+    };
+}
+interface PaymentIntentResponse {
+    id: string;
+    connection_id: string;
+    provider: string;
+    status: string;
+    client_secret: string;
+    amount: number;
+    currency: string;
+    fee_amount: number;
+    fee_currency: string;
+    net_amount: number;
+}
+interface ConfirmPaymentRequest {
+    provider_ref_id: string;
+    provider_data?: Record<string, unknown>;
+}
+interface PaymentDetailResponse {
+    id: string;
+    connection_id: string;
+    provider: string;
+    method: string;
+    status: string;
+    amount: number;
+    currency: string;
+    fee_amount: number;
+    fee_currency: string;
+    net_amount: number;
+    customer_id?: string;
+    client_secret: string;
+    provider_ref_id?: string;
+    metadata?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+interface APIErrorResponse {
+    code: string;
+    message: string;
+    details?: Record<string, string>;
+}
+interface ReevitAPIClientConfig {
+    /** Your Reevit public key */
+    publicKey: string;
+    /** Base URL for the Reevit API (defaults to production) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+}
+/**
+ * Reevit API Client
+ */
+declare class ReevitAPIClient {
+    private readonly publicKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    constructor(config: ReevitAPIClientConfig);
+    /**
+     * Makes an authenticated API request
+     */
+    private request;
+    /**
+     * Creates a payment intent
+     */
+    createPaymentIntent(config: ReevitCheckoutConfig, method: PaymentMethod, country?: string): Promise<{
+        data?: PaymentIntentResponse;
+        error?: PaymentError;
+    }>;
+    /**
+     * Retrieves a payment intent by ID
+     */
+    getPaymentIntent(paymentId: string): Promise<{
+        data?: PaymentDetailResponse;
+        error?: PaymentError;
+    }>;
+    /**
+     * Confirms a payment after PSP callback
+     */
+    confirmPayment(paymentId: string): Promise<{
+        data?: PaymentDetailResponse;
+        error?: PaymentError;
+    }>;
+    /**
+     * Cancels a payment intent
+     */
+    cancelPaymentIntent(paymentId: string): Promise<{
+        data?: PaymentDetailResponse;
+        error?: PaymentError;
+    }>;
+    /**
+     * Maps SDK payment method to backend format
+     */
+    private mapPaymentMethod;
+}
+/**
+ * Creates a new Reevit API client instance
+ */
+declare function createReevitClient(config: ReevitAPIClientConfig): ReevitAPIClient;
+
+/**
+ * Utility Functions
+ * Shared utilities for Reevit SDKs
+ */
+
+/**
+ * Formats an amount from smallest currency unit to display format
+ */
+declare function formatAmount(amount: number, currency: string): string;
+/**
+ * Generates a unique payment reference
+ */
+declare function generateReference(prefix?: string): string;
+/**
+ * Validates a phone number for mobile money
+ */
+declare function validatePhone(phone: string, country?: string): boolean;
+/**
+ * Formats a phone number for display
+ */
+declare function formatPhone(phone: string, country?: string): string;
+/**
+ * Detects mobile money network from phone number (Ghana)
+ */
+declare function detectNetwork(phone: string): MobileMoneyNetwork | null;
+/**
+ * Creates CSS custom property variables from theme
+ */
+declare function createThemeVariables(theme: ReevitTheme): Record<string, string>;
+/**
+ * Simple class name concatenation utility
+ */
+declare function cn(...classes: (string | boolean | undefined | null)[]): string;
+/**
+ * Detects country code from currency
+ */
+declare function detectCountryFromCurrency(currency: string): string;
+
+/**
+ * Reevit State Machine
+ * Shared state management logic for all SDKs
+ */
+
+interface ReevitState {
+    status: CheckoutState;
+    paymentIntent: PaymentIntent | null;
+    selectedMethod: PaymentMethod | null;
+    error: PaymentError | null;
+    result: PaymentResult | null;
+}
+type ReevitAction = {
+    type: 'INIT_START';
+} | {
+    type: 'INIT_SUCCESS';
+    payload: PaymentIntent;
+} | {
+    type: 'INIT_ERROR';
+    payload: PaymentError;
+} | {
+    type: 'SELECT_METHOD';
+    payload: PaymentMethod;
+} | {
+    type: 'PROCESS_START';
+} | {
+    type: 'PROCESS_SUCCESS';
+    payload: PaymentResult;
+} | {
+    type: 'PROCESS_ERROR';
+    payload: PaymentError;
+} | {
+    type: 'RESET';
+} | {
+    type: 'CLOSE';
+};
+/**
+ * Creates the initial state for the checkout
+ */
+declare function createInitialState(): ReevitState;
+/**
+ * State reducer for checkout flow
+ */
+declare function reevitReducer(state: ReevitState, action: ReevitAction): ReevitState;
+
+export { type APIErrorResponse, type CardFormData, type CheckoutState, type ConfirmPaymentRequest, type CreatePaymentIntentRequest, type MobileMoneyFormData, type MobileMoneyNetwork, type PSPConfig, type PSPType, type PaymentDetailResponse, type PaymentError, type PaymentIntent, type PaymentIntentResponse, type PaymentMethod, type PaymentResult, ReevitAPIClient, type ReevitAPIClientConfig, type ReevitAction, type ReevitCheckoutCallbacks, type ReevitCheckoutConfig, type ReevitState, type ReevitTheme, cn, createInitialState, createReevitClient, createThemeVariables, detectCountryFromCurrency, detectNetwork, formatAmount, formatPhone, generateReference, reevitReducer, validatePhone };

package/dist/index.js

@@ -0,0 +1,327 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ReevitAPIClient: () => ReevitAPIClient,
+  cn: () => cn,
+  createInitialState: () => createInitialState,
+  createReevitClient: () => createReevitClient,
+  createThemeVariables: () => createThemeVariables,
+  detectCountryFromCurrency: () => detectCountryFromCurrency,
+  detectNetwork: () => detectNetwork,
+  formatAmount: () => formatAmount,
+  formatPhone: () => formatPhone,
+  generateReference: () => generateReference,
+  reevitReducer: () => reevitReducer,
+  validatePhone: () => validatePhone
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/api/client.ts
+var API_BASE_URL_PRODUCTION = "https://api.reevit.io";
+var API_BASE_URL_SANDBOX = "https://sandbox-api.reevit.io";
+var DEFAULT_TIMEOUT = 3e4;
+function isSandboxKey(publicKey) {
+  return publicKey.startsWith("pk_test_") || publicKey.startsWith("pk_sandbox_");
+}
+function createPaymentError(response, errorData) {
+  return {
+    code: errorData.code || "api_error",
+    message: errorData.message || "An unexpected error occurred",
+    details: {
+      httpStatus: response.status,
+      ...errorData.details
+    }
+  };
+}
+var ReevitAPIClient = class {
+  constructor(config) {
+    this.publicKey = config.publicKey;
+    this.baseUrl = config.baseUrl || (isSandboxKey(config.publicKey) ? API_BASE_URL_SANDBOX : API_BASE_URL_PRODUCTION);
+    this.timeout = config.timeout || DEFAULT_TIMEOUT;
+  }
+  /**
+   * Makes an authenticated API request
+   */
+  async request(method, path, body) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}${path}`, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.publicKey}`,
+          "X-Reevit-Client": "@reevit/core",
+          "X-Reevit-Client-Version": "0.1.0"
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const responseData = await response.json().catch(() => ({}));
+      if (!response.ok) {
+        return {
+          error: createPaymentError(response, responseData)
+        };
+      }
+      return { data: responseData };
+    } catch (err) {
+      clearTimeout(timeoutId);
+      if (err instanceof Error) {
+        if (err.name === "AbortError") {
+          return {
+            error: {
+              code: "request_timeout",
+              message: "The request timed out. Please try again."
+            }
+          };
+        }
+        if (err.message.includes("Failed to fetch") || err.message.includes("NetworkError")) {
+          return {
+            error: {
+              code: "network_error",
+              message: "Unable to connect to Reevit. Please check your internet connection."
+            }
+          };
+        }
+      }
+      return {
+        error: {
+          code: "unknown_error",
+          message: "An unexpected error occurred. Please try again."
+        }
+      };
+    }
+  }
+  /**
+   * Creates a payment intent
+   */
+  async createPaymentIntent(config, method, country = "GH") {
+    const request = {
+      amount: config.amount,
+      currency: config.currency,
+      method: this.mapPaymentMethod(method),
+      country,
+      customer_id: config.metadata?.customerId,
+      metadata: config.metadata
+    };
+    return this.request("POST", "/v1/payments/intents", request);
+  }
+  /**
+   * Retrieves a payment intent by ID
+   */
+  async getPaymentIntent(paymentId) {
+    return this.request("GET", `/v1/payments/${paymentId}`);
+  }
+  /**
+   * Confirms a payment after PSP callback
+   */
+  async confirmPayment(paymentId) {
+    return this.request("POST", `/v1/payments/${paymentId}/confirm`);
+  }
+  /**
+   * Cancels a payment intent
+   */
+  async cancelPaymentIntent(paymentId) {
+    return this.request("POST", `/v1/payments/${paymentId}/cancel`);
+  }
+  /**
+   * Maps SDK payment method to backend format
+   */
+  mapPaymentMethod(method) {
+    switch (method) {
+      case "card":
+        return "card";
+      case "mobile_money":
+        return "mobile_money";
+      case "bank_transfer":
+        return "bank_transfer";
+      default:
+        return method;
+    }
+  }
+};
+function createReevitClient(config) {
+  return new ReevitAPIClient(config);
+}
+
+// src/utils.ts
+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 };
+  try {
+    return new Intl.NumberFormat(format.locale, {
+      style: "currency",
+      currency: currency.toUpperCase(),
+      minimumFractionDigits: format.minimumFractionDigits
+    }).format(majorUnit);
+  } catch {
+    return `${currency} ${majorUnit.toFixed(2)}`;
+  }
+}
+function generateReference(prefix = "reevit") {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `${prefix}_${timestamp}_${random}`;
+}
+function validatePhone(phone, country = "GH") {
+  const digits = phone.replace(/\D/g, "");
+  const patterns = {
+    GH: /^(?:233|0)?[235][0-9]{8}$/,
+    // Ghana
+    NG: /^(?:234|0)?[789][01][0-9]{8}$/,
+    // Nigeria
+    KE: /^(?:254|0)?[17][0-9]{8}$/
+    // Kenya
+  };
+  const pattern = patterns[country.toUpperCase()];
+  if (!pattern) return digits.length >= 10;
+  return pattern.test(digits);
+}
+function formatPhone(phone, country = "GH") {
+  const digits = phone.replace(/\D/g, "");
+  if (country === "GH") {
+    if (digits.startsWith("233") && digits.length === 12) {
+      const local = "0" + digits.slice(3);
+      return `${local.slice(0, 3)} ${local.slice(3, 6)} ${local.slice(6)}`;
+    }
+    if (digits.length === 10 && digits.startsWith("0")) {
+      return `${digits.slice(0, 3)} ${digits.slice(3, 6)} ${digits.slice(6)}`;
+    }
+  }
+  return phone;
+}
+function detectNetwork(phone) {
+  const digits = phone.replace(/\D/g, "");
+  let prefix;
+  if (digits.startsWith("233")) {
+    prefix = digits.slice(3, 5);
+  } else if (digits.startsWith("0")) {
+    prefix = digits.slice(1, 3);
+  } else {
+    prefix = digits.slice(0, 2);
+  }
+  const mtnPrefixes = ["24", "25", "53", "54", "55", "59"];
+  const vodafonePrefixes = ["20", "50"];
+  const airteltigoPrefixes = ["26", "27", "56", "57"];
+  if (mtnPrefixes.includes(prefix)) return "mtn";
+  if (vodafonePrefixes.includes(prefix)) return "vodafone";
+  if (airteltigoPrefixes.includes(prefix)) return "airteltigo";
+  return null;
+}
+function createThemeVariables(theme) {
+  const variables = {};
+  if (theme.primaryColor) {
+    variables["--reevit-primary"] = theme.primaryColor;
+  }
+  if (theme.backgroundColor) {
+    variables["--reevit-bg"] = theme.backgroundColor;
+  }
+  if (theme.textColor) {
+    variables["--reevit-text"] = theme.textColor;
+  }
+  if (theme.borderRadius) {
+    variables["--reevit-radius"] = theme.borderRadius;
+  }
+  if (theme.fontFamily) {
+    variables["--reevit-font"] = theme.fontFamily;
+  }
+  return variables;
+}
+function cn(...classes) {
+  return classes.filter(Boolean).join(" ");
+}
+function detectCountryFromCurrency(currency) {
+  const currencyToCountry = {
+    GHS: "GH",
+    NGN: "NG",
+    KES: "KE",
+    UGX: "UG",
+    TZS: "TZ",
+    ZAR: "ZA",
+    XOF: "CI",
+    XAF: "CM",
+    USD: "US",
+    EUR: "DE",
+    GBP: "GB"
+  };
+  return currencyToCountry[currency.toUpperCase()] || "GH";
+}
+
+// src/state.ts
+function createInitialState() {
+  return {
+    status: "idle",
+    paymentIntent: null,
+    selectedMethod: null,
+    error: null,
+    result: null
+  };
+}
+function reevitReducer(state, action) {
+  switch (action.type) {
+    case "INIT_START":
+      return { ...state, status: "loading", error: null };
+    case "INIT_SUCCESS":
+      return { ...state, status: "ready", paymentIntent: action.payload };
+    case "INIT_ERROR":
+      return { ...state, status: "failed", error: action.payload };
+    case "SELECT_METHOD":
+      return { ...state, status: "method_selected", selectedMethod: action.payload };
+    case "PROCESS_START":
+      return { ...state, status: "processing", error: null };
+    case "PROCESS_SUCCESS":
+      return { ...state, status: "success", result: action.payload };
+    case "PROCESS_ERROR":
+      return { ...state, status: "failed", error: action.payload };
+    case "RESET":
+      return { ...createInitialState(), status: "ready", paymentIntent: state.paymentIntent };
+    case "CLOSE":
+      return { ...state, status: "closed" };
+    default:
+      return state;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReevitAPIClient,
+  cn,
+  createInitialState,
+  createReevitClient,
+  createThemeVariables,
+  detectCountryFromCurrency,
+  detectNetwork,
+  formatAmount,
+  formatPhone,
+  generateReference,
+  reevitReducer,
+  validatePhone
+});
+//# sourceMappingURL=index.js.map