@heyama/pay-react-native 1.0.4 → 1.0.5

package/dist/checkout-core/hooks/use-checkout-controller.js

@@ -1,12 +1,12 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
-import { useFormatter, useTranslations } from 'use-intl';
+import { useFormatter, useLocale, useTranslations } from 'use-intl';
 import { COPIED_MS, FLOW_TRAITS, OTP_MAX_LENGTH, OTP_PATTERN, } from "../models/checkout.constants.js";
 import { CardFieldsMessageEnum, CheckoutScreenEnum, CheckoutTabEnum, CheckoutToastToneEnum, MethodFlowEnum, MethodStateEnum, PayRefusalEnum, } from "../models/checkout.enum.js";
 import { CountryEnum } from "../models/domain.enum.js";
 import { cardLabel } from "../models/checkout.card.utils.js";
 import { formatMoney } from "../models/checkout.money.utils.js";
 import { maskE164 } from "../models/checkout.phone.utils.js";
-import { countriesOf, deriveCheckout, initialUi, logoOf, pickedPatch, screenOf, waitLeftOf, } from "../models/checkout.view.utils.js";
+import { countriesOf, deriveCheckout, dialHelpOf, initialUi, logoOf, pickedPatch, screenOf, waitLeftOf, } from "../models/checkout.view.utils.js";
 import { useNow, useReturnCountdown, useToast } from "./use-checkout-timers.js";
 import { usePhoneNumber } from "./use-phone-number.js";
 /** Before the payment has loaded, or for a link that matches none. */
@@ -34,6 +34,7 @@ const NO_PAYMENT_UI = {
 export function useCheckoutController(view, { clues, mutations, platform }) {
     const t = useTranslations('checkout');
     const format = useFormatter();
+    const lang = useLocale();
     const [patch, setPatch] = useState({});
     const [helpOpen, setHelpOpen] = useState(false);
     const [copied, setCopied] = useState(false);
@@ -302,12 +303,16 @@ export function useCheckoutController(view, { clues, mutations, platform }) {
                 pickerOpen: !suggestion,
             });
         },
-        resend: () => {
+        // Only offered on a waiting attempt's steps.
+        cannotDialCode: (code) => {
+            toast.show(t('toast.dial', { code, method: attempt.methodName }), CheckoutToastToneEnum.INFO, logoOf(attempt));
+        },
+        sendAgain: () => {
             void mutations
                 .resend({ paymentId: view.id })
                 .then((result) => result.ok
-                ? toast.show(t('toast.resent', { phone: maskE164(attempt.phone) }), CheckoutToastToneEnum.SUCCESS)
-                : toast.show(t('toast.resend_wait'), CheckoutToastToneEnum.INFO))
+                ? toast.show(t('toast.sent_again', { phone: maskE164(attempt.phone) }), CheckoutToastToneEnum.SUCCESS)
+                : toast.show(t('toast.send_again_wait'), CheckoutToastToneEnum.INFO))
                 .catch(() => toast.show(t('toast.failed'), CheckoutToastToneEnum.WARNING));
         },
         cancel: () => {
@@ -340,6 +345,7 @@ export function useCheckoutController(view, { clues, mutations, platform }) {
         derived,
         phone,
         waitLeft,
+        dialHelp: dialHelpOf(attempt, lang),
         returnLeft: countdown.left,
         helpOpen,
         toast: toast.toast,

package/dist/checkout-core/messages/en.d.ts

@@ -59,6 +59,14 @@ declare const _default: {
         bj: string;
         tg: string;
         bf: string;
+        cd: string;
+        ga: string;
+        gh: string;
+        mw: string;
+        rw: string;
+        sl: string;
+        ug: string;
+        zm: string;
         intl: string;
     };
     country: string;
@@ -73,15 +81,17 @@ declare const _default: {
     loading: string;
     confirm_title: string;
     sent_to: string;
+    manual_to: string;
     remaining: string;
     steps: {
         first: string;
         last: string;
     };
     no_prompt: string;
-    dial: string;
-    dial_only: string;
-    resend: string;
+    send_again_hint: string;
+    dial_pending: string;
+    send_again: string;
+    send_again_in: string;
     cancel: string;
     checking_title: string;
     checking_with: string;
@@ -100,6 +110,7 @@ declare const _default: {
         wrong_amount: string;
         approved_late: string;
         reversed: string;
+        approved_all: string;
     };
     failure: {
         declined: {
@@ -196,7 +207,7 @@ declare const _default: {
         approve_title: string;
         approve_body: string;
         expires_in: string;
-        resend_in: string;
+        manual_body: string;
         done_in: string;
         close_title: string;
         close_body: string;
@@ -237,8 +248,8 @@ declare const _default: {
         soon: string;
         no_answer: string;
         failed: string;
-        resent: string;
-        resend_wait: string;
+        sent_again: string;
+        send_again_wait: string;
         preview: string;
         dial: string;
     };

package/dist/checkout-core/messages/en.js

@@ -50,6 +50,14 @@ export default {
         bj: 'Benin',
         tg: 'Togo',
         bf: 'Burkina Faso',
+        cd: 'DR Congo',
+        ga: 'Gabon',
+        gh: 'Ghana',
+        mw: 'Malawi',
+        rw: 'Rwanda',
+        sl: 'Sierra Leone',
+        ug: 'Uganda',
+        zm: 'Zambia',
         intl: 'International',
     },
     country: 'Country',
@@ -64,15 +72,17 @@ export default {
     loading: 'Loading the payment',
     confirm_title: 'Confirm the payment on your phone',
     sent_to: 'We sent a {method} request to',
+    manual_to: 'Approve your {method} payment on',
     remaining: 'left to approve',
     steps: {
         first: 'Unlock your phone and open the request',
         last: 'Enter your PIN to approve',
     },
     no_prompt: "Didn't get the request?",
-    dial: 'Send it again, or dial this code to see pending payments',
-    dial_only: 'Send it again to your phone',
-    resend: 'Send again',
+    send_again_hint: 'Send it again to your phone',
+    dial_pending: 'Dial this code to see pending payments',
+    send_again: 'Send again',
+    send_again_in: 'Send again in {clock}',
     cancel: 'Cancel payment',
     checking_title: 'Confirming your payment',
     checking_with: '{method} is checking your code for',
@@ -91,6 +101,7 @@ export default {
         wrong_amount: 'Approve a wrong amount',
         approved_late: 'Approve late',
         reversed: 'Approve, then reverse',
+        approved_all: 'Approve every request',
     },
     failure: {
         declined: {
@@ -187,7 +198,7 @@ export default {
         approve_title: 'Approve on your phone',
         approve_body: 'Enter your {method} PIN in the request sent to {phone}.',
         expires_in: 'Expires in',
-        resend_in: 'Send again in {clock}',
+        manual_body: 'Approve your {method} payment on {phone}.',
         done_in: 'Done ({seconds})',
         close_title: 'Close the payment?',
         close_body: 'The request is still on your phone. If you approve it, the payment goes through.',
@@ -197,7 +208,7 @@ export default {
     faqs: {
         not_received: {
             q: "I didn't get the request on my phone",
-            a: 'Check that your phone is on and has network. You can also dial the code shown on the waiting screen to see and approve pending payments.',
+            a: 'Check that your phone is on and has network, then send it again from the waiting screen. After the last request, that screen shows what to dial if your network has a code.',
         },
         debited: {
             q: 'I was debited but the page says failed',
@@ -228,8 +239,8 @@ export default {
         soon: '{method} is coming soon',
         no_answer: 'No answer yet: try again or pick another method',
         failed: 'Something went wrong. Try again.',
-        resent: 'Request sent again to {phone}',
-        resend_wait: 'Wait a few seconds before asking again.',
+        sent_again: 'Request sent again to {phone}',
+        send_again_wait: 'Wait a few seconds before asking again.',
         preview: 'Preview only: nothing is paid here',
         dial: 'Dial {code} from your {method} phone.',
     },

package/dist/checkout-core/messages/fr.js

@@ -51,6 +51,14 @@ const messages = {
         bj: 'Bénin',
         tg: 'Togo',
         bf: 'Burkina Faso',
+        cd: 'RD Congo',
+        ga: 'Gabon',
+        gh: 'Ghana',
+        mw: 'Malawi',
+        rw: 'Rwanda',
+        sl: 'Sierra Leone',
+        ug: 'Ouganda',
+        zm: 'Zambie',
         intl: 'International',
     },
     country: 'Pays',
@@ -65,15 +73,17 @@ const messages = {
     loading: 'Chargement du paiement',
     confirm_title: 'Confirmez le paiement sur votre téléphone',
     sent_to: 'Demande {method} envoyée au',
+    manual_to: 'Validez votre paiement {method} sur le',
     remaining: 'pour valider',
     steps: {
         first: 'Déverrouillez votre téléphone et ouvrez la demande',
         last: 'Saisissez votre code secret pour valider',
     },
     no_prompt: 'Pas reçu la demande ?',
-    dial: 'Renvoyez-la, ou composez ce code pour voir les paiements en attente',
-    dial_only: 'Renvoyez-la sur votre téléphone',
-    resend: 'Renvoyer',
+    send_again_hint: 'Renvoyez-la sur votre téléphone',
+    dial_pending: 'Composez ce code pour voir les paiements en attente',
+    send_again: 'Renvoyer',
+    send_again_in: 'Renvoyer dans {clock}',
     cancel: 'Annuler le paiement',
     checking_title: 'Confirmation du paiement',
     checking_with: '{method} vérifie votre code pour le',
@@ -92,6 +102,7 @@ const messages = {
         wrong_amount: 'Valider un mauvais montant',
         approved_late: 'Valider en retard',
         reversed: 'Valider puis annuler',
+        approved_all: 'Valider toutes les demandes',
     },
     failure: {
         declined: {
@@ -188,7 +199,7 @@ const messages = {
         approve_title: 'Approuvez sur votre téléphone',
         approve_body: 'Composez votre code secret {method} dans la fenêtre reçue au {phone}.',
         expires_in: 'Expire dans',
-        resend_in: 'Renvoyer dans {clock}',
+        manual_body: 'Validez votre paiement {method} sur le {phone}.',
         done_in: 'Terminé ({seconds})',
         close_title: 'Fermer le paiement ?',
         close_body: 'La demande est toujours sur votre téléphone. Si vous la validez, le paiement passe.',
@@ -198,7 +209,7 @@ const messages = {
     faqs: {
         not_received: {
             q: "Je n'ai pas reçu la demande",
-            a: "Vérifiez que votre téléphone est allumé et capte le réseau. Vous pouvez aussi composer le code affiché sur l'écran d'attente pour voir et valider les paiements en attente.",
+            a: "Vérifiez que votre téléphone est allumé et capte le réseau, puis renvoyez-la depuis l'écran d'attente. Après la dernière demande, cet écran indique quoi composer si votre réseau a un code.",
         },
         debited: {
             q: "J'ai été débité mais la page indique un échec",
@@ -229,8 +240,8 @@ const messages = {
         soon: '{method} arrive bientôt',
         no_answer: 'Pas encore de réponse : réessayez ou choisissez un autre moyen',
         failed: 'Une erreur est survenue. Réessayez.',
-        resent: 'Demande renvoyée au {phone}',
-        resend_wait: 'Patientez quelques secondes avant de la renvoyer.',
+        sent_again: 'Demande renvoyée au {phone}',
+        send_again_wait: 'Patientez quelques secondes avant de la renvoyer.',
         preview: 'Aperçu seulement : rien n’est payé ici',
         dial: 'Composez {code} depuis votre téléphone {method}.',
     },

package/dist/checkout-core/models/checkout.constants.d.ts

@@ -11,8 +11,8 @@ export declare const TOAST_MS = 2400;
 export declare const COPIED_MS = 1800;
 /** The last seconds of the waiting clock turn red. */
 export declare const URGENT_SECONDS = 30;
-/** A prompt can be sent again this long after the last one (the backend's `RESEND_AFTER_MS`). */
-export declare const RESEND_SECONDS = 30;
+/** A prompt can be sent again this long after the last one (the backend's `SEND_AGAIN_AFTER_MS`). */
+export declare const SEND_AGAIN_SECONDS = 30;
 /** The card fields' bones until their page says how tall it is, on the web and in the sheet. */
 export declare const CARD_FIELDS_HEIGHT = 190;
 /** The only sides a brand tile is drawn at, in pixels: beside a line of text, in a list row, on the waiting screen. */
@@ -35,7 +35,7 @@ export declare const MEDIA_LINE = "rgb(120 124 132 / 0.35)";
  */
 export declare const CHECKOUT_COLORS: Record<CheckoutThemeEnum, CheckoutColors>;
 /** International dial code of each Mobile Money country. */
-export declare const DIAL_CODES: Partial<Record<CountryEnum, string>>;
+export declare const DIAL_CODES: Record<Exclude<CountryEnum, CountryEnum.INTERNATIONAL>, string>;
 /** Greyed on the Card tab until a provider for them is coded. */
 export declare const COMING_SOON_WALLETS: Array<ComingSoonWallet>;
 /** The card tile: a generic card, whatever networks the provider takes. */

package/dist/checkout-core/models/checkout.constants.js

@@ -10,8 +10,8 @@ export const TOAST_MS = 2400;
 export const COPIED_MS = 1800;
 /** The last seconds of the waiting clock turn red. */
 export const URGENT_SECONDS = 30;
-/** A prompt can be sent again this long after the last one (the backend's `RESEND_AFTER_MS`). */
-export const RESEND_SECONDS = 30;
+/** A prompt can be sent again this long after the last one (the backend's `SEND_AGAIN_AFTER_MS`). */
+export const SEND_AGAIN_SECONDS = 30;
 /** The card fields' bones until their page says how tall it is, on the web and in the sheet. */
 export const CARD_FIELDS_HEIGHT = 190;
 /** The only sides a brand tile is drawn at, in pixels: beside a line of text, in a list row, on the waiting screen. */
@@ -86,6 +86,14 @@ export const DIAL_CODES = {
     [CountryEnum.BENIN]: '229',
     [CountryEnum.TOGO]: '228',
     [CountryEnum.BURKINA_FASO]: '226',
+    [CountryEnum.DR_CONGO]: '243',
+    [CountryEnum.GABON]: '241',
+    [CountryEnum.GHANA]: '233',
+    [CountryEnum.MALAWI]: '265',
+    [CountryEnum.RWANDA]: '250',
+    [CountryEnum.SIERRA_LEONE]: '232',
+    [CountryEnum.UGANDA]: '256',
+    [CountryEnum.ZAMBIA]: '260',
 };
 /** Greyed on the Card tab until a provider for them is coded. */
 export const COMING_SOON_WALLETS = [
@@ -132,6 +140,14 @@ export const CURRENCY_DECIMALS = {
     [CurrencyEnum.XOF]: 0,
     [CurrencyEnum.EUR]: 2,
     [CurrencyEnum.USD]: 2,
+    [CurrencyEnum.GHS]: 2,
+    [CurrencyEnum.MWK]: 2,
+    [CurrencyEnum.UGX]: 0,
+    // Whole units, not ISO's two: Vodacom refuses decimals.
+    [CurrencyEnum.CDF]: 0,
+    [CurrencyEnum.SLE]: 2,
+    [CurrencyEnum.RWF]: 0,
+    [CurrencyEnum.ZMW]: 2,
 };
 /** What follows the amount: francs CFA read the same in both zones. */
 export const CURRENCY_LABEL = {
@@ -139,4 +155,11 @@ export const CURRENCY_LABEL = {
     [CurrencyEnum.XOF]: 'FCFA',
     [CurrencyEnum.EUR]: 'EUR',
     [CurrencyEnum.USD]: 'USD',
+    [CurrencyEnum.GHS]: 'GHS',
+    [CurrencyEnum.MWK]: 'MWK',
+    [CurrencyEnum.UGX]: 'UGX',
+    [CurrencyEnum.CDF]: 'CDF',
+    [CurrencyEnum.SLE]: 'SLE',
+    [CurrencyEnum.RWF]: 'RWF',
+    [CurrencyEnum.ZMW]: 'ZMW',
 };

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

@@ -92,7 +92,9 @@ export declare enum SimulatorOutcomeEnum {
     PROVIDER_ERROR = "provider_error",
     WRONG_AMOUNT = "wrong_amount",
     APPROVED_LATE = "approved_late",
-    REVERSED = "reversed"
+    REVERSED = "reversed",
+    /** A success on every send: a duplicate. Offered once there are several. */
+    APPROVED_ALL = "approved_all"
 }
 export declare enum PhoneErrorEnum {
     START = "start",

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

@@ -104,6 +104,8 @@ export var SimulatorOutcomeEnum;
     SimulatorOutcomeEnum["WRONG_AMOUNT"] = "wrong_amount";
     SimulatorOutcomeEnum["APPROVED_LATE"] = "approved_late";
     SimulatorOutcomeEnum["REVERSED"] = "reversed";
+    /** A success on every send: a duplicate. Offered once there are several. */
+    SimulatorOutcomeEnum["APPROVED_ALL"] = "approved_all";
 })(SimulatorOutcomeEnum || (SimulatorOutcomeEnum = {}));
 export var PhoneErrorEnum;
 (function (PhoneErrorEnum) {

package/dist/checkout-core/models/checkout.interface.d.ts

@@ -44,6 +44,19 @@ export interface CardSummary {
     brand: string;
     last4: string;
 }
+/** How to approve by dialling, as the provider said it, in both languages. */
+export interface AttemptDial {
+    title: {
+        en: string;
+        fr: string;
+    };
+    /** The whole code, to dial in one tap. */
+    quickLink: string | null;
+    steps: {
+        en: Array<string>;
+        fr: Array<string>;
+    };
+}
 export interface CheckoutAttempt {
     reference: string;
     method: string;
@@ -61,6 +74,26 @@ export interface CheckoutAttempt {
     startedAt: number;
     /** A test attempt the Simulator took: the tester picks its outcome. */
     simulated: boolean;
+    /** When the latest request went out: "Didn't get it?" counts from it. */
+    lastSentAt: number;
+    /** New requests the payer can still ask for. */
+    sendsLeft: number;
+    /** The network's prompt never shows by itself: the payer dials at once. */
+    manual: boolean;
+    dial: Array<AttemptDial>;
+}
+/** One way to approve by dialling, in the payer's language. */
+export interface DialChannel {
+    title: string;
+    quickLink: string | null;
+    steps: Array<string>;
+}
+/** What the waiting screen offers a payer with no prompt, once it is time to. */
+export interface DialHelp {
+    /** USSD steps: after the last new request, or at once for a `manual` network. */
+    channels: Array<DialChannel>;
+    /** The method's own code to see pending payments, when there are no steps. */
+    pendingCode: string | null;
 }
 export interface CheckoutPayer {
     name: string | null;
@@ -226,8 +259,10 @@ export interface CheckoutCoreActions {
     cannotDial: () => void;
     /** Leaves the failure screen for the suggested method, or the list. */
     useAnother: () => void;
-    /** "Didn't get it?": the prompt again. */
-    resend: () => void;
+    /** The phone could not open its dialler on a waiting attempt's code: dial it by hand. */
+    cannotDialCode: (code: string) => void;
+    /** "Didn't get it?": a new request. */
+    sendAgain: () => void;
     cancel: () => void;
     returnNow: () => void;
     stayHere: () => void;
@@ -253,6 +288,8 @@ export interface CheckoutCore {
     phone: PhoneNumber;
     /** Seconds left on the waiting screen's clock. */
     waitLeft: number;
+    /** Steps and codes the waiting screen offers now. */
+    dialHelp: DialHelp;
     /** Seconds before the success screen sends the payer back, null once stopped. */
     returnLeft: number | null;
     helpOpen: boolean;

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

@@ -1,7 +1,7 @@
-import { CheckoutScreenEnum } from './checkout.enum.js';
+import { CheckoutScreenEnum, SimulatorOutcomeEnum } 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';
+import type { LangEnum, ProviderLogoEnum } from './domain.enum.js';
+import type { CheckoutApp, CheckoutAttempt, CheckoutDerived, CheckoutMethod, CheckoutPreviewApp, CheckoutUi, CheckoutView, CountryClues, DialHelp, 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. */
@@ -30,6 +30,27 @@ export declare function logoOf(of: Pick<CheckoutMethod, 'flow' | 'logos'>): Prov
 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;
+/** The payer can still ask for a new request of this attempt. */
+export declare const canSendAgain: (attempt: Pick<CheckoutAttempt, "sendsLeft">) => boolean;
+/**
+ * What the waiting screen offers a payer with no prompt. USSD is the last
+ * resort: it shows after the last new request, or at once when the network's
+ * prompt never shows by itself, in the payer's language; a channel that only
+ * differs in its other language or by letter case shows once. The method's own
+ * code to see pending payments takes over when there are no steps to show.
+ * Nothing for a flow with no prompt.
+ */
+export declare function dialHelpOf(attempt: CheckoutAttempt | null, lang: LangEnum): DialHelp;
+/**
+ * What the Simulator offers the tester: what the flow can do, and a success on
+ * every send only once the payer asked again.
+ */
+export declare function simulatorOutcomesOf(attempt: CheckoutAttempt): Array<SimulatorOutcomeEnum>;
+/**
+ * Seconds before the prompt can be sent again: 30 from the last time it went
+ * out, by the attempt or by `sentAt`, the second of the wait a sheet just asked at.
+ */
+export declare function sendAgainLeftOf(attempt: CheckoutAttempt, waitLeft: number, sentAt?: 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. */

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

@@ -1,5 +1,5 @@
-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 { CARD_LOGO, DIAL_CODES, FLOW_TRAITS, OTP_PATTERN, PREVIEW_AMOUNT, PREVIEW_ORDER_REF, SEND_AGAIN_SECONDS, WAIT_SECONDS, } from "./checkout.constants.js";
+import { CheckoutPaymentStatusEnum, CheckoutScreenEnum, CheckoutTabEnum, MethodFlowEnum, MethodKindEnum, MethodStateEnum, SimulatorOutcomeEnum, 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) {
@@ -162,6 +162,51 @@ export function waitLeftOf(startedAt, now) {
     const elapsed = Math.floor((now - startedAt) / 1000);
     return Math.min(WAIT_SECONDS, Math.max(0, WAIT_SECONDS - elapsed));
 }
+/** The payer can still ask for a new request of this attempt. */
+export const canSendAgain = (attempt) => attempt.sendsLeft > 0;
+/**
+ * What the waiting screen offers a payer with no prompt. USSD is the last
+ * resort: it shows after the last new request, or at once when the network's
+ * prompt never shows by itself, in the payer's language; a channel that only
+ * differs in its other language or by letter case shows once. The method's own
+ * code to see pending payments takes over when there are no steps to show.
+ * Nothing for a flow with no prompt.
+ */
+export function dialHelpOf(attempt, lang) {
+    if (!attempt || !FLOW_TRAITS[attempt.flow].prompt) {
+        return { channels: [], pendingCode: null };
+    }
+    const sendAgain = canSendAgain(attempt);
+    const channels = new Map();
+    for (const { title, quickLink, steps } of sendAgain ? [] : attempt.dial) {
+        const key = [quickLink, ...steps[lang]].join('|').toLowerCase();
+        channels.set(key, { title: title[lang], quickLink, steps: steps[lang] });
+    }
+    return {
+        channels: [...channels.values()],
+        pendingCode: !sendAgain && channels.size === 0 ? attempt.pendingCode : null,
+    };
+}
+/** The payer asked for a new request since Pay. */
+const askedAgain = (attempt) => attempt.lastSentAt > attempt.startedAt;
+/**
+ * What the Simulator offers the tester: what the flow can do, and a success on
+ * every send only once the payer asked again.
+ */
+export function simulatorOutcomesOf(attempt) {
+    const { hiddenOutcomes } = FLOW_TRAITS[attempt.flow];
+    return Object.values(SimulatorOutcomeEnum).filter((outcome) => !hiddenOutcomes.includes(outcome) &&
+        (outcome !== SimulatorOutcomeEnum.APPROVED_ALL || askedAgain(attempt)));
+}
+/**
+ * Seconds before the prompt can be sent again: 30 from the last time it went
+ * out, by the attempt or by `sentAt`, the second of the wait a sheet just asked at.
+ */
+export function sendAgainLeftOf(attempt, waitLeft, sentAt = 0) {
+    const lastSent = Math.floor((attempt.lastSentAt - attempt.startedAt) / 1000);
+    const waited = WAIT_SECONDS - waitLeft - Math.max(sentAt, lastSent);
+    return Math.max(0, SEND_AGAIN_SECONDS - waited);
+}
 /** How payers reach the app's support, when it set any. */
 export function supportContactsOf(app) {
     const contacts = [];

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

@@ -7,6 +7,11 @@ export declare enum ProviderLogoEnum {
     MOOV = "moov",
     WAVE = "wave",
     MIXX = "mixx",
+    AIRTEL = "airtel",
+    AT = "at",
+    TELECEL = "telecel",
+    TNM = "tnm",
+    VODACOM = "vodacom",
     VISA = "visa",
     MASTERCARD = "mastercard",
     PAYPAL = "paypal",
@@ -22,13 +27,28 @@ export declare enum CountryEnum {
     BENIN = "bj",
     TOGO = "tg",
     BURKINA_FASO = "bf",
+    DR_CONGO = "cd",
+    GABON = "ga",
+    GHANA = "gh",
+    MALAWI = "mw",
+    RWANDA = "rw",
+    SIERRA_LEONE = "sl",
+    UGANDA = "ug",
+    ZAMBIA = "zm",
     INTERNATIONAL = "intl"
 }
 export declare enum CurrencyEnum {
     XAF = "XAF",
     XOF = "XOF",
     EUR = "EUR",
-    USD = "USD"
+    USD = "USD",
+    GHS = "GHS",
+    MWK = "MWK",
+    UGX = "UGX",
+    CDF = "CDF",
+    SLE = "SLE",
+    RWF = "RWF",
+    ZMW = "ZMW"
 }
 /** Why an attempt failed. The first five are the payer's and count toward the lock. */
 export declare enum FailureReasonEnum {

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

@@ -8,6 +8,11 @@ export var ProviderLogoEnum;
     ProviderLogoEnum["MOOV"] = "moov";
     ProviderLogoEnum["WAVE"] = "wave";
     ProviderLogoEnum["MIXX"] = "mixx";
+    ProviderLogoEnum["AIRTEL"] = "airtel";
+    ProviderLogoEnum["AT"] = "at";
+    ProviderLogoEnum["TELECEL"] = "telecel";
+    ProviderLogoEnum["TNM"] = "tnm";
+    ProviderLogoEnum["VODACOM"] = "vodacom";
     ProviderLogoEnum["VISA"] = "visa";
     ProviderLogoEnum["MASTERCARD"] = "mastercard";
     ProviderLogoEnum["PAYPAL"] = "paypal";
@@ -24,6 +29,14 @@ export var CountryEnum;
     CountryEnum["BENIN"] = "bj";
     CountryEnum["TOGO"] = "tg";
     CountryEnum["BURKINA_FASO"] = "bf";
+    CountryEnum["DR_CONGO"] = "cd";
+    CountryEnum["GABON"] = "ga";
+    CountryEnum["GHANA"] = "gh";
+    CountryEnum["MALAWI"] = "mw";
+    CountryEnum["RWANDA"] = "rw";
+    CountryEnum["SIERRA_LEONE"] = "sl";
+    CountryEnum["UGANDA"] = "ug";
+    CountryEnum["ZAMBIA"] = "zm";
     CountryEnum["INTERNATIONAL"] = "intl";
 })(CountryEnum || (CountryEnum = {}));
 export var CurrencyEnum;
@@ -32,6 +45,13 @@ export var CurrencyEnum;
     CurrencyEnum["XOF"] = "XOF";
     CurrencyEnum["EUR"] = "EUR";
     CurrencyEnum["USD"] = "USD";
+    CurrencyEnum["GHS"] = "GHS";
+    CurrencyEnum["MWK"] = "MWK";
+    CurrencyEnum["UGX"] = "UGX";
+    CurrencyEnum["CDF"] = "CDF";
+    CurrencyEnum["SLE"] = "SLE";
+    CurrencyEnum["RWF"] = "RWF";
+    CurrencyEnum["ZMW"] = "ZMW";
 })(CurrencyEnum || (CurrencyEnum = {}));
 /** Why an attempt failed. The first five are the payer's and count toward the lock. */
 export var FailureReasonEnum;

package/dist/components/SheetDial.d.ts

@@ -0,0 +1,7 @@
+import type { SheetScreenProps } from '../models/sheet.interface.js';
+/**
+ * A payer with no prompt and no new request left: the network's USSD steps, or the
+ * method's code to see pending payments, with one tap to dial where a code is
+ * given (on Android; on iOS it says to dial it by hand).
+ */
+export declare function SheetDial({ core }: SheetScreenProps): import("react").JSX.Element;

package/dist/components/SheetDial.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Linking, Platform, StyleSheet, View } from 'react-native';
+import { useTranslations } from 'use-intl';
+import { CheckoutButtonVariantEnum } from "../checkout-core/models/checkout.enum.js";
+import { telHref } from "../checkout-core/models/checkout.phone.utils.js";
+import { useSheetTheme } from "../hooks/use-sheet-theme.js";
+import { FigtreeEnum } from "../models/sheet.enum.js";
+import { SheetButton } from "./SheetButton.js";
+import { SheetText } from "./SheetText.js";
+/**
+ * A payer with no prompt and no new request left: the network's USSD steps, or the
+ * method's code to see pending payments, with one tap to dial where a code is
+ * given (on Android; on iOS it says to dial it by hand).
+ */
+export function SheetDial({ core }) {
+    const t = useTranslations('checkout');
+    const { colors } = useSheetTheme();
+    const { channels, pendingCode } = core.dialHelp;
+    const dial = (code) => {
+        // The iPhone's Phone app refuses a tel: link with * or #: say to dial it by hand.
+        if (Platform.OS === 'ios') {
+            core.actions.cannotDialCode(code);
+            return;
+        }
+        Linking.openURL(telHref(code)).catch(() => {
+            core.actions.cannotDialCode(code);
+        });
+    };
+    return (_jsxs(_Fragment, { children: [channels.map(({ title, steps, quickLink }) => (_jsxs(View, { style: styles.block, children: [_jsx(SheetText, { weight: FigtreeEnum.BOLD, accessibilityRole: "header", children: title }), quickLink && (_jsx(SheetButton, { variant: CheckoutButtonVariantEnum.SECONDARY, label: t('sheet.dial', { code: quickLink }), onPress: () => dial(quickLink) })), steps.map((step, index) => (_jsxs(View, { style: styles.step, children: [_jsxs(SheetText, { weight: FigtreeEnum.BOLD, style: styles.number, children: [index + 1, "."] }), _jsx(SheetText, { paragraph: true, size: 14, style: styles.text, children: step })] }, step)))] }, steps.join()))), pendingCode && (_jsxs(View, { style: styles.block, children: [_jsx(SheetText, { weight: FigtreeEnum.BOLD, children: t('no_prompt') }), _jsx(SheetText, { paragraph: true, size: 14, color: colors.muted, children: t('dial_pending') }), _jsx(SheetButton, { variant: CheckoutButtonVariantEnum.SECONDARY, label: t('sheet.dial', { code: pendingCode }), onPress: () => dial(pendingCode) })] }))] }));
+}
+const styles = StyleSheet.create({
+    block: { marginTop: 18, gap: 10 },
+    step: { flexDirection: 'row', gap: 8 },
+    number: { width: 20 },
+    text: { flex: 1 },
+});

package/dist/components/SheetSimulator.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { StyleSheet, TouchableOpacity, View } from 'react-native';
 import { useTranslations } from 'use-intl';
 import { FLOW_TRAITS, SIMULATOR_NO_ANSWER_SUFFIX, } from "../checkout-core/models/checkout.constants.js";
-import { SimulatorOutcomeEnum } from "../checkout-core/models/checkout.enum.js";
+import { simulatorOutcomesOf } from "../checkout-core/models/checkout.view.utils.js";
 import { useSheetTheme } from "../hooks/use-sheet-theme.js";
 import { FigtreeEnum } from "../models/sheet.enum.js";
 import { SheetText } from "./SheetText.js";
@@ -14,7 +14,7 @@ export function SheetSimulator({ core }) {
     const t = useTranslations('checkout');
     const { colors } = useSheetTheme();
     const traits = FLOW_TRAITS[core.view.attempt.flow];
-    const outcomes = Object.values(SimulatorOutcomeEnum).filter((outcome) => !traits.hiddenOutcomes.includes(outcome));
+    const outcomes = simulatorOutcomesOf(core.view.attempt);
     return (_jsxs(View, { accessibilityLabel: t('simulator.title'), style: [
             styles.panel,
             { backgroundColor: colors.warnSoft, borderColor: colors.warnLine },

package/dist/components/SheetWaiting.d.ts

@@ -1,7 +1,7 @@
 import type { SheetScreenProps } from '../models/sheet.interface.js';
 /**
  * Waiting for the payer to approve on their phone: what to do, the method
- * and the clock, Resend once 30 seconds have passed, and another method.
- * It moves on by itself.
+ * and the clock, Send again once 30 seconds have passed, the network's USSD steps
+ * once no new request is left, and another method. It moves on by itself.
  */
 export declare function SheetWaiting({ core }: SheetScreenProps): import("react").JSX.Element;

package/dist/components/SheetWaiting.js

@@ -6,10 +6,11 @@ import { FLOW_TRAITS, URGENT_SECONDS, WAIT_SECONDS, } from "../checkout-core/mod
 import { CheckoutButtonVariantEnum } from "../checkout-core/models/checkout.enum.js";
 import { formatClock, formatMoney, } from "../checkout-core/models/checkout.money.utils.js";
 import { maskE164 } from "../checkout-core/models/checkout.phone.utils.js";
+import { canSendAgain, sendAgainLeftOf, } from "../checkout-core/models/checkout.view.utils.js";
 import { useSheetTheme } from "../hooks/use-sheet-theme.js";
 import { FigtreeEnum } from "../models/sheet.enum.js";
-import { resendLeftOf } from "../models/sheet.utils.js";
 import { SheetButton } from "./SheetButton.js";
+import { SheetDial } from "./SheetDial.js";
 import { SheetLayout } from "./SheetLayout.js";
 import { SheetRow } from "./SheetRow.js";
 import { SheetSimulator } from "./SheetSimulator.js";
@@ -17,36 +18,36 @@ import { SheetText } from "./SheetText.js";
 const NO_BREAK_SPACE = '\u00a0';
 /**
  * Waiting for the payer to approve on their phone: what to do, the method
- * and the clock, Resend once 30 seconds have passed, and another method.
- * It moves on by itself.
+ * and the clock, Send again once 30 seconds have passed, the network's USSD steps
+ * once no new request is left, and another method. It moves on by itself.
  */
 export function SheetWaiting({ core }) {
     const t = useTranslations('checkout');
     const { colors, brand } = useSheetTheme();
     const { view, waitLeft, actions } = core;
     const attempt = view.attempt;
-    // A payment code or a card needs nothing more from the payer: no prompt to resend.
+    // A payment code or a card needs nothing more from the payer: no prompt to send again.
     const { prompt } = FLOW_TRAITS[attempt.flow];
     /** The second of the wait the prompt was last sent at. */
     const [sentAt, setSentAt] = useState(0);
-    const resendLeft = resendLeftOf(waitLeft, sentAt);
+    const sendAgainIn = sendAgainLeftOf(attempt, waitLeft, sentAt);
     // The number never breaks across lines.
     const phone = attempt.phone
         ? maskE164(attempt.phone).replace(/ /g, NO_BREAK_SPACE)
         : '';
-    return (_jsx(SheetLayout, { foot: _jsxs(_Fragment, { children: [prompt && (_jsx(SheetButton, { variant: CheckoutButtonVariantEnum.SECONDARY, label: resendLeft > 0
-                        ? t('sheet.resend_in', { clock: formatClock(resendLeft) })
-                        : t('resend'), disabled: resendLeft > 0, onPress: () => {
+    return (_jsx(SheetLayout, { foot: _jsxs(_Fragment, { children: [prompt && canSendAgain(attempt) && (_jsx(SheetButton, { variant: CheckoutButtonVariantEnum.SECONDARY, label: sendAgainIn > 0
+                        ? t('send_again_in', { clock: formatClock(sendAgainIn) })
+                        : t('send_again'), disabled: sendAgainIn > 0, onPress: () => {
                         setSentAt(WAIT_SECONDS - waitLeft);
-                        actions.resend();
+                        actions.sendAgain();
                     } })), _jsx(Pressable, { onPress: actions.useAnother, accessibilityRole: "button", style: styles.link, children: _jsx(SheetText, { weight: FigtreeEnum.SEMI_BOLD, style: styles.center, children: t('use_another') }) })] }), children: _jsxs(View, { style: styles.waiting, children: [_jsxs(View, { style: styles.pulse, children: [_jsx(View, { style: [styles.halo, styles.outer, { backgroundColor: brand }] }), _jsx(View, { style: [styles.halo, styles.inner, { backgroundColor: brand }] }), _jsx(View, { testID: "icon-phone", style: [styles.phone, { borderColor: brand }], children: _jsx(View, { style: [styles.speaker, { backgroundColor: brand }] }) })] }), _jsx(SheetText, { weight: FigtreeEnum.EXTRA_BOLD, size: 21, accessibilityRole: "header", style: [styles.center, styles.title], children: prompt ? t('sheet.approve_title') : t('checking_title') }), _jsx(SheetText, { paragraph: true, size: 14, color: colors.muted, style: styles.center, children: attempt.phone
                         ? prompt
-                            ? t('sheet.approve_body', {
+                            ? t(attempt.manual ? 'sheet.manual_body' : 'sheet.approve_body', {
                                 method: attempt.methodName,
                                 phone,
                             })
                             : `${t('checking_with', { method: attempt.methodName })} ${phone}`
-                        : t('checking_card', { method: attempt.methodName }) }), _jsxs(View, { style: [styles.rows, { borderColor: colors.line }], children: [_jsx(SheetRow, { label: attempt.methodName, children: formatMoney(view.amount, view.currency) }), _jsx(SheetRow, { label: t('sheet.expires_in'), urgent: waitLeft <= URGENT_SECONDS, children: formatClock(waitLeft) })] }), attempt.simulated && _jsx(SheetSimulator, { core: core })] }) }));
+                        : t('checking_card', { method: attempt.methodName }) }), _jsxs(View, { style: [styles.rows, { borderColor: colors.line }], children: [_jsx(SheetRow, { label: attempt.methodName, children: formatMoney(view.amount, view.currency) }), _jsx(SheetRow, { label: t('sheet.expires_in'), urgent: waitLeft <= URGENT_SECONDS, children: formatClock(waitLeft) })] }), attempt.simulated && _jsx(SheetSimulator, { core: core }), _jsx(SheetDial, { core: core })] }) }));
 }
 const styles = StyleSheet.create({
     waiting: { paddingHorizontal: 18, paddingTop: 30 },

package/dist/models/sheet.constants.js

@@ -9,6 +9,11 @@ import logoGooglePay from '../../assets/logos/google-pay.png';
 import logoMastercard from '../../assets/logos/mastercard.png';
 import logoMixx from '../../assets/logos/mixx.png';
 import logoMoov from '../../assets/logos/moov.png';
+import logoAirtel from '../../assets/logos/airtel.png';
+import logoAt from '../../assets/logos/at.png';
+import logoTelecel from '../../assets/logos/telecel.png';
+import logoTnm from '../../assets/logos/tnm.png';
+import logoVodacom from '../../assets/logos/vodacom.png';
 import logoMtn from '../../assets/logos/mtn.png';
 import logoOrange from '../../assets/logos/orange.png';
 import logoPaypal from '../../assets/logos/paypal.png';
@@ -54,6 +59,11 @@ export const PROVIDER_LOGOS = {
     [ProviderLogoEnum.MOOV]: logoMoov,
     [ProviderLogoEnum.WAVE]: logoWave,
     [ProviderLogoEnum.MIXX]: logoMixx,
+    [ProviderLogoEnum.AIRTEL]: logoAirtel,
+    [ProviderLogoEnum.AT]: logoAt,
+    [ProviderLogoEnum.TELECEL]: logoTelecel,
+    [ProviderLogoEnum.TNM]: logoTnm,
+    [ProviderLogoEnum.VODACOM]: logoVodacom,
     [ProviderLogoEnum.VISA]: logoVisa,
     [ProviderLogoEnum.MASTERCARD]: logoMastercard,
     [ProviderLogoEnum.PAYPAL]: logoPaypal,

package/dist/models/sheet.utils.d.ts

@@ -11,11 +11,6 @@ export declare function sheetTheme(payment: CheckoutThemeEnum | null, scheme: st
 export declare function sheetResult(view: CheckoutView | null | undefined, failed: boolean): PaymentSheetResult;
 /** `cm` → 🇨🇲: the country's flag, as the phone draws it. */
 export declare function flagOf(country: CountryEnum): string;
-/**
- * Seconds before the prompt can be sent again, from the waiting clock
- * (`waitLeft`) and the second of the wait it was last sent at (0: Pay).
- */
-export declare function resendLeftOf(waitLeft: number, sentAt: number): number;
 /**
  * The card fields page the sheet loads: English under `/en`, French the bare
  * path asking for French (as the checkout link does), with the payment, the

package/dist/models/sheet.utils.js

@@ -1,4 +1,3 @@
-import { RESEND_SECONDS, WAIT_SECONDS, } from "../checkout-core/models/checkout.constants.js";
 import { CardFieldsMessageEnum, CheckoutPaymentStatusEnum, CheckoutThemeEnum, PayRefusalEnum, } from "../checkout-core/models/checkout.enum.js";
 import { AttemptStatusEnum, LangEnum, } from "../checkout-core/models/domain.enum.js";
 import { SHEET_FLICK_SPEED, SHEET_SWIPE_DISTANCE } from "./sheet.constants.js";
@@ -36,14 +35,6 @@ export function sheetResult(view, failed) {
 export function flagOf(country) {
     return String.fromCodePoint(...[...country.toUpperCase()].map((letter) => 0x1f1e6 + letter.charCodeAt(0) - 'A'.charCodeAt(0)));
 }
-/**
- * Seconds before the prompt can be sent again, from the waiting clock
- * (`waitLeft`) and the second of the wait it was last sent at (0: Pay).
- */
-export function resendLeftOf(waitLeft, sentAt) {
-    const waited = WAIT_SECONDS - waitLeft - sentAt;
-    return Math.max(0, RESEND_SECONDS - waited);
-}
 /**
  * The card fields page the sheet loads: English under `/en`, French the bare
  * path asking for French (as the checkout link does), with the payment, the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heyama/pay-react-native",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Brissoto Pay for Expo and React Native apps: the payment sheet.",
   "license": "MIT",
   "sideEffects": false,