@heyama/pay-react-native 0.0.0-stage → 1.0.0

package/dist/checkout-core/models/checkout.money.utils.d.ts

@@ -0,0 +1,7 @@
+import type { CurrencyEnum } from './domain.enum.js';
+/** 15000 XAF → "15 000", 1250 EUR → "12.50": grouped with a narrow no-break space, so it never wraps. */
+export declare function formatAmount(minor: number, currency: CurrencyEnum): string;
+/** "15 000 FCFA". */
+export declare function formatMoney(minor: number, currency: CurrencyEnum): string;
+/** "02:05" style clock for the approval countdown. */
+export declare function formatClock(totalSeconds: number): string;

package/dist/checkout-core/models/checkout.money.utils.js

@@ -0,0 +1,21 @@
+import { CURRENCY_DECIMALS, CURRENCY_LABEL } from "./checkout.constants.js";
+const THIN_SPACE = ' ';
+/** 15000 XAF → "15 000", 1250 EUR → "12.50": grouped with a narrow no-break space, so it never wraps. */
+export function formatAmount(minor, currency) {
+    const decimals = CURRENCY_DECIMALS[currency];
+    const [whole, fraction] = (minor / 10 ** decimals)
+        .toFixed(decimals)
+        .split('.');
+    const grouped = whole.replace(/\B(?=(\d{3})+(?!\d))/g, THIN_SPACE);
+    return fraction ? `${grouped}.${fraction}` : grouped;
+}
+/** "15 000 FCFA". */
+export function formatMoney(minor, currency) {
+    return `${formatAmount(minor, currency)} ${CURRENCY_LABEL[currency]}`;
+}
+/** "02:05" style clock for the approval countdown. */
+export function formatClock(totalSeconds) {
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = String(totalSeconds % 60).padStart(2, '0');
+    return `${minutes}:${seconds}`;
+}

package/dist/checkout-core/models/checkout.phone.utils.d.ts

@@ -0,0 +1,33 @@
+import { CountryEnum } from './domain.enum.js';
+import type { OperatorDetection, PhoneInputs, PhoneStatus, TypedNumber } from './checkout.interface.js';
+/** Which operator a number belongs to, from its first digits. */
+export declare function detectOperator(country: CountryEnum, digits: string): OperatorDetection;
+/**
+ * What the field should say about the number typed so far, by the country's
+ * own mobile rules. Errors that typing more can never fix (a wrong first
+ * digit) show at once; the rest wait until the field is left or Pay pressed.
+ */
+export declare function getPhoneStatus({ country, digits, foreign, touched, focused, submitTried, }: PhoneInputs): PhoneStatus;
+/** "691234567" → "6 91 23 45 67", grouped the way the country writes it. */
+export declare function formatNational(digits: string, country: CountryEnum): string;
+/** "+33612345678" → "+33 6 12 34 56 78": a full number, grouped its country's way. */
+export declare function formatInternational(number: string): string;
+/** A real-looking mobile number of the country, for the empty field. */
+export declare function placeholderOf(country: CountryEnum): string;
+/** The number as providers want it: `+237691234567`. Empty while incomplete. */
+export declare function toE164(digits: string, country: CountryEnum): string;
+/**
+ * Reads what the payer typed or pasted. A national number stays in the
+ * country; a full international one (`+225…`, `00225…`) moves to its country
+ * when the payment can be paid there, and is kept as typed until its country
+ * is known.
+ */
+export declare function readTypedNumber(raw: string, country: CountryEnum, countries: Array<CountryEnum>): TypedNumber;
+/** "6 91 23 45 67" → "6 91 •• •• 67": keeps the first 3 and last 2 digits. */
+export declare function maskNumber(formatted: string): string;
+/** Where the caret goes in `formatted` to sit after its `count`-th digit. */
+export declare function caretAfterDigits(formatted: string, count: number): number;
+/** A USSD code as a link that dials it: `#` must be escaped in a `tel:` URL. */
+export declare function telHref(code: string): string;
+/** `+237691234567` → `+237 6 91 •• •• 67`: the dial code, then the number masked. */
+export declare function maskE164(phone: string): string;

package/dist/checkout-core/models/checkout.phone.utils.js

@@ -0,0 +1,159 @@
+import { AsYouType, getExampleNumber, isValidPhoneNumber, parsePhoneNumberFromString, validatePhoneNumberLength, } from 'libphonenumber-js/mobile';
+import examples from 'libphonenumber-js/mobile/examples';
+import { DIAL_CODES } from "./checkout.constants.js";
+import { CountryEnum } from "./domain.enum.js";
+import { MethodBrandEnum, PhoneErrorEnum } from "./checkout.enum.js";
+/** Cameroon mobile numbers are 9 digits and always start with 6. */
+const CAMEROON_LENGTH = 9;
+const MTN_CAMEROON = /^6(7\d|5[0-4]|8[0-4])$/;
+const ORANGE_CAMEROON = /^6(9\d|5[5-9]|8[5-9]|4\d)$/;
+const CI_OPERATOR_BY_PREFIX = {
+    '07': MethodBrandEnum.ORANGE,
+    '05': MethodBrandEnum.MTN,
+    '01': MethodBrandEnum.MOOV,
+};
+/** `cm` → `CM`, the library's country code. */
+function codeOf(country) {
+    return country.toUpperCase();
+}
+/** Which operator a number belongs to, from its first digits. */
+export function detectOperator(country, digits) {
+    if (country === CountryEnum.CAMEROON) {
+        if (digits.length < 3)
+            return { operator: null, unrecognized: false };
+        const prefix = digits.slice(0, 3);
+        if (MTN_CAMEROON.test(prefix))
+            return { operator: MethodBrandEnum.MTN, unrecognized: false };
+        if (ORANGE_CAMEROON.test(prefix))
+            return { operator: MethodBrandEnum.ORANGE, unrecognized: false };
+        return { operator: null, unrecognized: true };
+    }
+    if (country === CountryEnum.COTE_D_IVOIRE && digits.length >= 2) {
+        return {
+            operator: CI_OPERATOR_BY_PREFIX[digits.slice(0, 2)] ?? null,
+            unrecognized: false,
+        };
+    }
+    return { operator: null, unrecognized: false };
+}
+/**
+ * What the field should say about the number typed so far, by the country's
+ * own mobile rules. Errors that typing more can never fix (a wrong first
+ * digit) show at once; the rest wait until the field is left or Pay pressed.
+ */
+export function getPhoneStatus({ country, digits, foreign, touched, focused, submitTried, }) {
+    const isCameroon = country === CountryEnum.CAMEROON;
+    const { operator, unrecognized } = detectOperator(country, digits);
+    const valid = isValidPhoneNumber(digits, codeOf(country));
+    let error = null;
+    if (isCameroon && digits.length > 0 && !digits.startsWith('6')) {
+        error = PhoneErrorEnum.START;
+    }
+    else if (isCameroon && digits.length === CAMEROON_LENGTH && unrecognized) {
+        error = PhoneErrorEnum.OPERATOR;
+    }
+    else if ((touched && !focused) || submitTried) {
+        if (foreign) {
+            error = PhoneErrorEnum.COUNTRY;
+        }
+        else if (digits.length === 0) {
+            if (submitTried)
+                error = PhoneErrorEnum.EMPTY;
+        }
+        else if (validatePhoneNumberLength(digits, codeOf(country)) === 'TOO_SHORT') {
+            error = PhoneErrorEnum.SHORT;
+        }
+        else if (!valid) {
+            error = PhoneErrorEnum.INVALID;
+        }
+    }
+    return { error, valid: error === null && valid, operator };
+}
+/** "691234567" → "6 91 23 45 67", grouped the way the country writes it. */
+export function formatNational(digits, country) {
+    return new AsYouType(codeOf(country)).input(digits);
+}
+/** "+33612345678" → "+33 6 12 34 56 78": a full number, grouped its country's way. */
+export function formatInternational(number) {
+    return new AsYouType().input(number);
+}
+/** A real-looking mobile number of the country, for the empty field. */
+export function placeholderOf(country) {
+    return getExampleNumber(codeOf(country), examples).formatNational();
+}
+/** The number as providers want it: `+237691234567`. Empty while incomplete. */
+export function toE164(digits, country) {
+    return parsePhoneNumberFromString(digits, codeOf(country))?.number ?? '';
+}
+/** Drops the digits past the longest number the country has. */
+function fit(digits, country) {
+    let kept = digits;
+    while (validatePhoneNumberLength(kept, codeOf(country)) === 'TOO_LONG') {
+        kept = kept.slice(0, -1);
+    }
+    return kept;
+}
+/**
+ * Reads what the payer typed or pasted. A national number stays in the
+ * country; a full international one (`+225…`, `00225…`) moves to its country
+ * when the payment can be paid there, and is kept as typed until its country
+ * is known.
+ */
+export function readTypedNumber(raw, country, countries) {
+    const text = raw.trim();
+    if (text.startsWith('+') || text.startsWith('00')) {
+        const international = `+${text.replace(/^(\+|00)/, '').replace(/\D/g, '')}`;
+        const typer = new AsYouType();
+        typer.input(international);
+        const found = typer.getCountry()?.toLowerCase();
+        if (found && countries.includes(found)) {
+            return {
+                country: found,
+                // A known country comes with its digits.
+                digits: fit(typer.getNumber().nationalNumber, found),
+                pending: null,
+            };
+        }
+        return { country, digits: '', pending: international };
+    }
+    const typed = text.replace(/\D/g, '');
+    // "237691234567": the dial code typed without its plus.
+    const parsed = typed.startsWith(DIAL_CODES[country])
+        ? parsePhoneNumberFromString(typed, codeOf(country))
+        : undefined;
+    const digits = parsed?.isValid() ? parsed.nationalNumber : typed;
+    return { country, digits: fit(digits, country), pending: null };
+}
+/** "6 91 23 45 67" → "6 91 •• •• 67": keeps the first 3 and last 2 digits. */
+export function maskNumber(formatted) {
+    const total = (formatted.match(/\d/g) ?? []).length;
+    let seen = 0;
+    return formatted.replace(/\d/g, (digit) => {
+        seen += 1;
+        return seen <= 3 || seen > total - 2 ? digit : '•';
+    });
+}
+/** Where the caret goes in `formatted` to sit after its `count`-th digit. */
+export function caretAfterDigits(formatted, count) {
+    if (count === 0)
+        return 0;
+    let seen = 0;
+    for (let index = 0; index < formatted.length; index++) {
+        if (/\d/.test(formatted[index]))
+            seen += 1;
+        if (seen === count)
+            return index + 1;
+    }
+    return formatted.length;
+}
+/** A USSD code as a link that dials it: `#` must be escaped in a `tel:` URL. */
+export function telHref(code) {
+    return `tel:${code.replace(/#/g, '%23')}`;
+}
+/** `+237691234567` → `+237 6 91 •• •• 67`: the dial code, then the number masked. */
+export function maskE164(phone) {
+    const parsed = parsePhoneNumberFromString(phone);
+    if (!parsed)
+        return maskNumber(phone);
+    return `+${parsed.countryCallingCode} ${maskNumber(parsed.formatNational())}`;
+}

package/dist/checkout-core/models/checkout.view.utils.d.ts

@@ -0,0 +1,34 @@
+import { CheckoutScreenEnum } from './checkout.enum.js';
+import { CountryEnum } from './domain.enum.js';
+import type { ProviderLogoEnum } from './domain.enum.js';
+import type { CheckoutApp, CheckoutDerived, CheckoutMethod, CheckoutPreviewApp, CheckoutUi, CheckoutView, CountryClues, PhoneStatus, SupportContact } from './checkout.interface.js';
+/** Countries with Mobile Money methods, in the order their first method comes. */
+export declare function countriesOf(methods: Array<CheckoutMethod>): Array<CountryEnum>;
+/** The country whose dial code starts this E.164 number. */
+export declare function countryOfPhone(phone: string): CountryEnum | null;
+/**
+ * The payer's country (docs/v1-plan.md, Checkout): the app's hint, then the
+ * phone's dial code, then the request's IP, then the browser's language
+ * (`fr-CM`). Only countries this payment can be paid in count; with none, the
+ * first country the gateway serves, for a page that has nothing to offer.
+ */
+export declare function pickCountry(view: CheckoutView, clues: CountryClues, countries: Array<CountryEnum>): CountryEnum;
+/**
+ * How the page opens: on the app's preferred method when it can be paid with,
+ * else on its preferred tab, with the list open.
+ */
+export declare function initialUi(view: CheckoutView, clues: CountryClues): CheckoutUi;
+/** Which screen shows: the payment's status first, then what the payer is doing. */
+export declare function screenOf(view: CheckoutView | null | undefined, ui: CheckoutUi): CheckoutScreenEnum;
+/** The brand of a Mobile Money method, which a number's first digits can reveal. */
+export declare function brandOf(method: CheckoutMethod): string;
+/** The tile of a method or an attempt: the generic card for cards, whatever networks they take. */
+export declare function logoOf(of: Pick<CheckoutMethod, 'flow' | 'logos'>): ProviderLogoEnum;
+/** Works out what the screens show from the payment, the page and the number typed. */
+export declare function deriveCheckout(view: CheckoutView, ui: CheckoutUi, phone: PhoneStatus): CheckoutDerived;
+/** Seconds left to approve an attempt started at `startedAt`. */
+export declare function waitLeftOf(startedAt: number, now: number): number;
+/** How payers reach the app's support, when it set any. */
+export declare function supportContactsOf(app: CheckoutApp): Array<SupportContact>;
+/** A pending test payment for the Branding tab's preview, branded as typed. */
+export declare function previewView(app: CheckoutPreviewApp, methods: Array<CheckoutMethod>): CheckoutView;

package/dist/checkout-core/models/checkout.view.utils.js

@@ -0,0 +1,205 @@
+import { CARD_LOGO, DIAL_CODES, OTP_PATTERN, PREVIEW_AMOUNT, PREVIEW_ORDER_REF, WAIT_SECONDS, } from "./checkout.constants.js";
+import { CheckoutPaymentStatusEnum, CheckoutScreenEnum, CheckoutTabEnum, MethodFlowEnum, MethodKindEnum, MethodStateEnum, SupportChannelEnum, } from "./checkout.enum.js";
+import { AttemptStatusEnum, CountryEnum, CurrencyEnum } from "./domain.enum.js";
+/** Countries with Mobile Money methods, in the order their first method comes. */
+export function countriesOf(methods) {
+    const countries = methods
+        .filter((method) => method.kind === MethodKindEnum.MOBILE_MONEY)
+        .map((method) => method.country);
+    return [...new Set(countries)];
+}
+/** The country whose dial code starts this E.164 number. */
+export function countryOfPhone(phone) {
+    const found = Object.entries(DIAL_CODES).find(([, dial]) => phone.startsWith(`+${dial}`));
+    return found ? found[0] : null;
+}
+/**
+ * The payer's country (docs/v1-plan.md, Checkout): the app's hint, then the
+ * phone's dial code, then the request's IP, then the browser's language
+ * (`fr-CM`). Only countries this payment can be paid in count; with none, the
+ * first country the gateway serves, for a page that has nothing to offer.
+ */
+export function pickCountry(view, clues, countries) {
+    const fromLanguages = clues.languages.map((tag) => tag.split('-')[1]?.toLowerCase());
+    const candidates = [
+        view.country,
+        view.payer.phone ? countryOfPhone(view.payer.phone) : null,
+        clues.ipCountry?.toLowerCase(),
+        ...fromLanguages,
+    ];
+    const found = candidates.find((candidate) => countries.includes(candidate));
+    return (found ??
+        countries.at(0) ??
+        Object.values(CountryEnum)[0]);
+}
+/**
+ * How the page opens: on the app's preferred method when it can be paid with,
+ * else on its preferred tab, with the list open.
+ */
+export function initialUi(view, clues) {
+    const countries = countriesOf(view.methods);
+    const preferred = view.methods.find((method) => method.id === view.preferredMethod &&
+        method.state === MethodStateEnum.AVAILABLE);
+    const base = {
+        tab: view.preferredTab ?? CheckoutTabEnum.MOBILE_MONEY,
+        country: pickCountry(view, clues, countries),
+        method: null,
+        code: '',
+        cardComplete: false,
+        cardPaying: false,
+        pickerOpen: true,
+        summaryOpen: false,
+        submitting: false,
+        dismissed: null,
+        redirecting: false,
+    };
+    if (preferred?.kind !== MethodKindEnum.MOBILE_MONEY)
+        return base;
+    return {
+        ...base,
+        tab: CheckoutTabEnum.MOBILE_MONEY,
+        country: preferred.country,
+        method: preferred.id,
+        pickerOpen: false,
+    };
+}
+const TERMINAL_SCREEN = {
+    [CheckoutPaymentStatusEnum.PAID]: CheckoutScreenEnum.SUCCESS,
+    [CheckoutPaymentStatusEnum.EXPIRED]: CheckoutScreenEnum.EXPIRED,
+    [CheckoutPaymentStatusEnum.CANCELLED]: CheckoutScreenEnum.CANCELLED,
+    [CheckoutPaymentStatusEnum.LOCKED]: CheckoutScreenEnum.LOCKED,
+};
+/** Which screen shows: the payment's status first, then what the payer is doing. */
+export function screenOf(view, ui) {
+    if (view === undefined)
+        return CheckoutScreenEnum.LOADING;
+    if (view === null)
+        return CheckoutScreenEnum.INVALID;
+    if (ui.redirecting)
+        return CheckoutScreenEnum.REDIRECT;
+    const terminal = TERMINAL_SCREEN[view.status];
+    if (terminal)
+        return terminal;
+    const { attempt } = view;
+    // A card's fields page is still paying: the form stays until it says how it went.
+    const shown = attempt && attempt.reference !== ui.dismissed && !ui.cardPaying
+        ? attempt.status
+        : null;
+    if (shown === AttemptStatusEnum.PENDING)
+        return CheckoutScreenEnum.WAITING;
+    // The app offers nothing any more: no form to fill, no other method to try.
+    if (view.methods.length === 0)
+        return CheckoutScreenEnum.NO_METHOD;
+    if (shown === AttemptStatusEnum.FAILED)
+        return CheckoutScreenEnum.FAILED;
+    return ui.submitting ? CheckoutScreenEnum.SUBMITTING : CheckoutScreenEnum.FORM;
+}
+/** The brand of a Mobile Money method, which a number's first digits can reveal. */
+export function brandOf(method) {
+    return method.logos[0];
+}
+/** Everything the picked method needs is in: the card, or the number and its payment code. */
+function readyToPay(method, ui, phone) {
+    if (method.flow === MethodFlowEnum.CARD_FIELDS)
+        return ui.cardComplete;
+    return (phone.valid &&
+        (method.flow !== MethodFlowEnum.OTP || OTP_PATTERN.test(ui.code)));
+}
+/** The tile of a method or an attempt: the generic card for cards, whatever networks they take. */
+export function logoOf(of) {
+    return of.flow === MethodFlowEnum.CARD_FIELDS ? CARD_LOGO : of.logos[0];
+}
+/** Works out what the screens show from the payment, the page and the number typed. */
+export function deriveCheckout(view, ui, phone) {
+    const wallets = view.methods.filter((method) => method.kind === MethodKindEnum.MOBILE_MONEY &&
+        method.country === ui.country);
+    const cards = view.methods.filter((method) => method.kind === MethodKindEnum.CARD);
+    const onCard = ui.tab === CheckoutTabEnum.CARD;
+    const picked = (onCard ? cards : wallets).find((method) => method.id === ui.method);
+    const selected = !ui.pickerOpen && picked?.state === MethodStateEnum.AVAILABLE
+        ? picked
+        : null;
+    const detected = phone.valid
+        ? (wallets.find((method) => method.state === MethodStateEnum.AVAILABLE &&
+            brandOf(method) === phone.operator) ?? null)
+        : null;
+    const failed = view.methods.find((method) => method.id === view.attempt?.method);
+    const suggestion = view.methods.find((method) => method.kind === MethodKindEnum.MOBILE_MONEY &&
+        method.state === MethodStateEnum.AVAILABLE &&
+        method.country === failed?.country &&
+        method.id !== failed.id) ?? null;
+    return {
+        screen: screenOf(view, ui),
+        countries: countriesOf(view.methods),
+        wallets,
+        cards,
+        selected,
+        canPay: !!selected &&
+            readyToPay(selected, ui, phone) &&
+            !ui.submitting &&
+            !ui.cardPaying,
+        // Only a Mobile Money method has a number to belong to another one.
+        mismatch: selected && !onCard && detected && detected.id !== selected.id
+            ? detected
+            : null,
+        suggestion,
+    };
+}
+/** Seconds left to approve an attempt started at `startedAt`. */
+export function waitLeftOf(startedAt, now) {
+    const elapsed = Math.floor((now - startedAt) / 1000);
+    return Math.min(WAIT_SECONDS, Math.max(0, WAIT_SECONDS - elapsed));
+}
+/** How payers reach the app's support, when it set any. */
+export function supportContactsOf(app) {
+    const contacts = [];
+    if (app.supportWhatsapp) {
+        contacts.push({
+            channel: SupportChannelEnum.WHATSAPP,
+            value: app.supportWhatsapp,
+            href: `https://wa.me/${app.supportWhatsapp.slice(1)}`,
+        });
+    }
+    if (app.supportEmail) {
+        contacts.push({
+            channel: SupportChannelEnum.EMAIL,
+            value: app.supportEmail,
+            href: `mailto:${app.supportEmail}`,
+        });
+    }
+    return contacts;
+}
+/** A pending test payment for the Branding tab's preview, branded as typed. */
+export function previewView(app, methods) {
+    return {
+        id: 'preview',
+        status: CheckoutPaymentStatusEnum.PENDING,
+        test: false,
+        amount: PREVIEW_AMOUNT,
+        currency: CurrencyEnum.XAF,
+        orderRef: PREVIEW_ORDER_REF,
+        items: [],
+        returnUrl: '',
+        expiresAt: 0,
+        paidAt: null,
+        payer: { name: null, phone: null, email: null },
+        country: null,
+        language: null,
+        theme: null,
+        preferredMethod: null,
+        preferredTab: null,
+        attemptsLeft: 0,
+        maxAttempts: 0,
+        // The preview offers no card: nothing loads from the site.
+        siteUrl: '',
+        app: {
+            ...app,
+            termsUrl: null,
+            privacyUrl: null,
+            supportEmail: null,
+            supportWhatsapp: null,
+        },
+        methods,
+        attempt: null,
+    };
+}

package/dist/checkout-core/models/domain.enum.d.ts

@@ -0,0 +1,56 @@
+/** Domain enums the checkout core needs; `src/models` re-exports them for the rest of the app. */
+/** Values are the file names in `public/logo/`, without the extension. */
+/** A brand tile in `public/logo/`: one per brand a payer recognises (see `docs/design-system.md`, Logos). */
+export declare enum ProviderLogoEnum {
+    ORANGE = "orange",
+    MTN = "mtn",
+    MOOV = "moov",
+    WAVE = "wave",
+    MIXX = "mixx",
+    VISA = "visa",
+    MASTERCARD = "mastercard",
+    PAYPAL = "paypal",
+    CARD = "card",
+    APPLE_PAY = "apple-pay",
+    GOOGLE_PAY = "google-pay"
+}
+/** Declared in the order the Providers page lists its country groups. */
+export declare enum CountryEnum {
+    CAMEROON = "cm",
+    COTE_D_IVOIRE = "ci",
+    SENEGAL = "sn",
+    BENIN = "bj",
+    TOGO = "tg",
+    BURKINA_FASO = "bf",
+    INTERNATIONAL = "intl"
+}
+export declare enum CurrencyEnum {
+    XAF = "XAF",
+    XOF = "XOF",
+    EUR = "EUR",
+    USD = "USD"
+}
+/** Why an attempt failed. The first five are the payer's and count toward the lock. */
+export declare enum FailureReasonEnum {
+    DECLINED = "declined",
+    INSUFFICIENT_FUNDS = "insufficient_funds",
+    /** No mobile money account on this number. */
+    NO_ACCOUNT = "no_account",
+    WRONG_PIN = "wrong_pin",
+    /** An OTP method: the payment code was wrong or had expired. */
+    WRONG_CODE = "wrong_code",
+    PROVIDER_ERROR = "provider_error",
+    TIMEOUT = "timeout",
+    MISMATCH = "mismatch"
+}
+/** GLOSSARY: Attempt. */
+export declare enum AttemptStatusEnum {
+    PENDING = "pending",
+    SUCCEEDED = "succeeded",
+    FAILED = "failed"
+}
+/** Interface languages. Values are the URL prefix and the saved cookie value. */
+export declare enum LangEnum {
+    FR = "fr",
+    EN = "en"
+}

package/dist/checkout-core/models/domain.enum.js

@@ -0,0 +1,62 @@
+/** Domain enums the checkout core needs; `src/models` re-exports them for the rest of the app. */
+/** Values are the file names in `public/logo/`, without the extension. */
+/** A brand tile in `public/logo/`: one per brand a payer recognises (see `docs/design-system.md`, Logos). */
+export var ProviderLogoEnum;
+(function (ProviderLogoEnum) {
+    ProviderLogoEnum["ORANGE"] = "orange";
+    ProviderLogoEnum["MTN"] = "mtn";
+    ProviderLogoEnum["MOOV"] = "moov";
+    ProviderLogoEnum["WAVE"] = "wave";
+    ProviderLogoEnum["MIXX"] = "mixx";
+    ProviderLogoEnum["VISA"] = "visa";
+    ProviderLogoEnum["MASTERCARD"] = "mastercard";
+    ProviderLogoEnum["PAYPAL"] = "paypal";
+    ProviderLogoEnum["CARD"] = "card";
+    ProviderLogoEnum["APPLE_PAY"] = "apple-pay";
+    ProviderLogoEnum["GOOGLE_PAY"] = "google-pay";
+})(ProviderLogoEnum || (ProviderLogoEnum = {}));
+/** Declared in the order the Providers page lists its country groups. */
+export var CountryEnum;
+(function (CountryEnum) {
+    CountryEnum["CAMEROON"] = "cm";
+    CountryEnum["COTE_D_IVOIRE"] = "ci";
+    CountryEnum["SENEGAL"] = "sn";
+    CountryEnum["BENIN"] = "bj";
+    CountryEnum["TOGO"] = "tg";
+    CountryEnum["BURKINA_FASO"] = "bf";
+    CountryEnum["INTERNATIONAL"] = "intl";
+})(CountryEnum || (CountryEnum = {}));
+export var CurrencyEnum;
+(function (CurrencyEnum) {
+    CurrencyEnum["XAF"] = "XAF";
+    CurrencyEnum["XOF"] = "XOF";
+    CurrencyEnum["EUR"] = "EUR";
+    CurrencyEnum["USD"] = "USD";
+})(CurrencyEnum || (CurrencyEnum = {}));
+/** Why an attempt failed. The first five are the payer's and count toward the lock. */
+export var FailureReasonEnum;
+(function (FailureReasonEnum) {
+    FailureReasonEnum["DECLINED"] = "declined";
+    FailureReasonEnum["INSUFFICIENT_FUNDS"] = "insufficient_funds";
+    /** No mobile money account on this number. */
+    FailureReasonEnum["NO_ACCOUNT"] = "no_account";
+    FailureReasonEnum["WRONG_PIN"] = "wrong_pin";
+    /** An OTP method: the payment code was wrong or had expired. */
+    FailureReasonEnum["WRONG_CODE"] = "wrong_code";
+    FailureReasonEnum["PROVIDER_ERROR"] = "provider_error";
+    FailureReasonEnum["TIMEOUT"] = "timeout";
+    FailureReasonEnum["MISMATCH"] = "mismatch";
+})(FailureReasonEnum || (FailureReasonEnum = {}));
+/** GLOSSARY: Attempt. */
+export var AttemptStatusEnum;
+(function (AttemptStatusEnum) {
+    AttemptStatusEnum["PENDING"] = "pending";
+    AttemptStatusEnum["SUCCEEDED"] = "succeeded";
+    AttemptStatusEnum["FAILED"] = "failed";
+})(AttemptStatusEnum || (AttemptStatusEnum = {}));
+/** Interface languages. Values are the URL prefix and the saved cookie value. */
+export var LangEnum;
+(function (LangEnum) {
+    LangEnum["FR"] = "fr";
+    LangEnum["EN"] = "en";
+})(LangEnum || (LangEnum = {}));

package/dist/components/BrissotoPayProvider.d.ts

@@ -0,0 +1,6 @@
+import type { BrissotoPayProviderProps } from '../models/sheet.interface.js';
+/**
+ * Around the app: holds the connection to Brissoto Pay and the one payment
+ * sheet `usePaymentSheet().presentPayment` opens.
+ */
+export declare function BrissotoPayProvider({ url, children, }: BrissotoPayProviderProps): import("react").JSX.Element;

package/dist/components/BrissotoPayProvider.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ConvexReactClient } from 'convex/react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { PaymentSheetContext } from "../hooks/use-payment-sheet.js";
+import { DEFAULT_URL } from "../models/sheet.constants.js";
+import { convexCheckoutCalls } from "../services/checkout.service.js";
+import { PaymentSheetModal } from "./PaymentSheetModal.js";
+/**
+ * Around the app: holds the connection to Brissoto Pay and the one payment
+ * sheet `usePaymentSheet().presentPayment` opens.
+ */
+export function BrissotoPayProvider({ url = DEFAULT_URL, children, }) {
+    const [client, setClient] = useState(null);
+    useEffect(() => {
+        const next = new ConvexReactClient(url, { unsavedChangesWarning: false });
+        setClient(next);
+        return () => void next.close();
+    }, [url]);
+    const calls = useMemo(() => client && convexCheckoutCalls(client), [client]);
+    const [request, setRequest] = useState(null);
+    /** Sheets opened, so each gets a fresh one. */
+    const [count, setCount] = useState(0);
+    const busy = useRef(false);
+    const presentPayment = useCallback(({ paymentId }) => {
+        if (busy.current) {
+            return Promise.reject(new Error('A payment sheet is already open.'));
+        }
+        busy.current = true;
+        return new Promise((resolve) => {
+            setCount((previous) => previous + 1);
+            setRequest({ paymentId, open: true, resolve });
+        });
+    }, []);
+    const sheet = useMemo(() => ({ presentPayment }), [presentPayment]);
+    const close = (closing, result) => {
+        busy.current = false;
+        setRequest({ ...closing, open: false });
+        closing.resolve(result);
+    };
+    return (_jsxs(PaymentSheetContext, { value: sheet, children: [children, calls && request && (_jsx(PaymentSheetModal, { calls: calls, request: request, onClose: (result) => close(request, result) }, count))] }));
+}

package/dist/components/PaymentSheetModal.d.ts

@@ -0,0 +1,8 @@
+import type { PaymentSheetModalProps } from '../models/sheet.interface.js';
+/**
+ * One payment in a bottom sheet over the dimmed app, as tall as what it
+ * shows, in the payment's language and theme, else the device's. Close,
+ * a swipe down, a tap on the app behind, back or escape leave it; leaving
+ * while a prompt waits on the phone asks first, and resolves `pending`.
+ */
+export declare function PaymentSheetModal({ calls, request, onClose, }: PaymentSheetModalProps): import("react").JSX.Element;