@pi-spi/app 1.2.0 → 1.2.1

package/README.md

@@ -136,6 +136,24 @@ indépendant : il ne perturbe pas celui de l'hôte, même si l'hôte utilise
 lui aussi React Navigation), son propre thème et ses propres traductions :
 l'hôte n'a rien d'autre à déclarer.
 
+### Exemple d'intégration
+
+Le package publié contient l'app hôte d'exemple, consultable depuis
+l'onglet **Code** de la page npm (ou dans `node_modules/@pi-spi/app/example/`
+une fois le package installé) :
+
+- [`example/App.tsx`](example/App.tsx) : une app hôte factice qui ouvre le
+  SDK en mode démo, avec un ou plusieurs comptes, dans chacun des thèmes,
+  qui simule un push (`PiSpiPush.handleIncoming`), un écran de
+  vérification renforcée (`requireStepUpIdentification`), et qui gère le
+  bouton retour Android ;
+- [`example/app.json`](example/app.json) : la configuration Expo, avec les
+  plugins et les messages des permissions natives.
+
+Les logos π et PI-SPI utilisés sur les boutons de l'exemple, dans toutes
+leurs variantes de couleurs, sont disponibles dans
+[mobile-app-flutter-sdk-assets/variante_logo_pi_et_pispi](https://github.com/pisfn-sandbox/mobile-app-flutter-sdk-assets/tree/main/variante_logo_pi_et_pispi).
+
 ### `PiSpiUserIdentity`
 
 Identité de l'utilisateur connecté côté hôte. Le SDK ne gère aucune

package/example/App.tsx

@@ -0,0 +1,470 @@
+import { MaterialIcons } from '@expo/vector-icons';
+import {
+  PiSpiApiConfig,
+  PiSpiAppConfig,
+  PiSpiCompte,
+  PiSpiIdentificationConfig,
+  PiSpiLogConfig,
+  PiSpiPush,
+  PiSpiSdkConfig,
+  PiSpiSdkEntry,
+  PiSpiUserIdentity,
+  Themes,
+} from '@pi-spi/app';
+import { StatusBar } from 'expo-status-bar';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import {
+  ActivityIndicator,
+  Alert,
+  BackHandler,
+  Image,
+  Pressable,
+  ScrollView,
+  StyleSheet,
+  Text,
+  View,
+  type ImageSourcePropType,
+} from 'react-native';
+import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
+
+/**
+ * Application hôte factice : simule une app participant déjà authentifiée,
+ * qui affiche l'écran du SDK PI-SPI par-dessus la sienne.
+ *
+ * **L'essentiel à lire pour intégrer le SDK dans une vraie app est la
+ * fonction `openPiSpiSdk` ci-dessous** : c'est le seul point d'entrée du
+ * SDK, tout le reste de ce fichier (tuiles, `StepUpAuthPage`, `PinKeypad`)
+ * n'est que du décor pour cette démo.
+ *
+ * Tourne en `demoMode: true` (aucune requête réelle, données mockées
+ * depuis `assets/json/` du SDK) pour pouvoir visualiser le SDK sans
+ * backend. Repassez `demoMode` à `false` et fournissez une vraie
+ * `apiBaseUrl` + un vrai token pour tester contre un backend PI-SPI réel.
+ */
+export default function FakeHostApp() {
+  return (
+    <SafeAreaProvider>
+      <FakeHostHomePage />
+    </SafeAreaProvider>
+  );
+}
+
+// Mode démo : aucune requête réelle n'est faite (API mockée), donc ni
+// l'URL ni le token n'ont besoin d'être valides.
+const API_BASE_URL = 'https://sandbox.pi-bceao.com/api';
+const FAKE_ACCESS_TOKEN = 'DEMO_MODE_TOKEN';
+
+type TileSpec = { asset: ImageSourcePropType; background: string; theme?: Themes; wide?: boolean };
+
+// Les logos π et PI-SPI des boutons (toutes les variantes de couleurs)
+// sont disponibles ici, pour les reprendre dans votre propre app :
+// https://github.com/pisfn-sandbox/mobile-app-flutter-sdk-assets/tree/main/variante_logo_pi_et_pispi
+const PI_MARRON = require('./assets/host/pi_marron.png');
+const PI_BLANC = require('./assets/host/pi_blanc.png');
+const PI_JAUNE = require('./assets/host/pi_jaune.png');
+const LOGO_BLANC = require('./assets/host/logo_blanc.png');
+const LOGO_MARRON_JAUNE = require('./assets/host/logo_maron_jaune.png');
+const LOGO_JAUNE_MARRON = require('./assets/host/logo_jaune_maron.png');
+const LOGO_JAUNE_BLANC = require('./assets/host/logo_jaune_blanc.png');
+
+const SINGLE_ACCOUNT_TILES: TileSpec[] = [
+  { asset: PI_MARRON, background: '#F5F0E8' },
+  { asset: PI_BLANC, background: '#151413', theme: Themes.dark },
+  { asset: PI_JAUNE, background: '#F5F0E8', theme: Themes.yellow },
+  { asset: PI_BLANC, background: '#2E7D32', theme: Themes.green },
+  { asset: PI_JAUNE, background: '#1565C0', theme: Themes.blue },
+  { asset: PI_BLANC, background: '#C62828', theme: Themes.red },
+  { asset: PI_BLANC, background: '#EF6C00', theme: Themes.orange },
+  { asset: PI_JAUNE, background: '#6A1B9A', theme: Themes.purple },
+  { asset: PI_BLANC, background: '#AD1457', theme: Themes.pink },
+];
+
+const MULTI_ACCOUNT_TILES: TileSpec[] = [
+  { asset: LOGO_MARRON_JAUNE, background: '#F5F0E8', wide: true },
+  { asset: LOGO_BLANC, background: '#151413', theme: Themes.dark, wide: true },
+  { asset: LOGO_MARRON_JAUNE, background: '#F5F0E8', theme: Themes.light, wide: true },
+  { asset: LOGO_JAUNE_MARRON, background: '#F5F0E8', theme: Themes.yellow, wide: true },
+  { asset: LOGO_BLANC, background: '#2E7D32', theme: Themes.green, wide: true },
+  { asset: LOGO_JAUNE_BLANC, background: '#1565C0', theme: Themes.blue, wide: true },
+  { asset: LOGO_BLANC, background: '#C62828', theme: Themes.red, wide: true },
+  { asset: LOGO_BLANC, background: '#EF6C00', theme: Themes.orange, wide: true },
+  { asset: LOGO_JAUNE_BLANC, background: '#6A1B9A', theme: Themes.purple, wide: true },
+  { asset: LOGO_BLANC, background: '#AD1457', theme: Themes.pink, wide: true },
+];
+
+const PUSH_TILES: TileSpec[] = [
+  { asset: LOGO_JAUNE_BLANC, background: '#1565C0', theme: Themes.blue, wide: true },
+  { asset: LOGO_BLANC, background: '#C62828', theme: Themes.red, wide: true },
+];
+
+/**
+ * Accueil de l'app hôte factice : une grille de trois scénarios de démo,
+ * chacun ouvrant le SDK dans une configuration différente, et chaque tuile
+ * avec son propre thème de démarrage (`PiSpiAppConfig.defaultTheme`).
+ *
+ * - **Compte unique** : le SDK saute l'écran de sélection de compte et le
+ *   carrousel de l'accueil.
+ * - **Comptes multiples** : écran de sélection à l'ouverture, puis
+ *   carrousel sur l'accueil du SDK.
+ * - **Simuler un push** : ouvre le SDK normalement, puis simule 3 s plus
+ *   tard la réception d'un message push (`PiSpiPush.handleIncoming`).
+ */
+function FakeHostHomePage() {
+  const [sdkConfig, setSdkConfig] = useState<PiSpiSdkConfig | null>(null);
+  const stepUp = useStepUpAuth();
+
+  const closeSdk = useCallback(() => setSdkConfig(null), []);
+
+  /**
+   * Point d'entrée du SDK : c'est cette fonction (et uniquement elle) que
+   * vous devez adapter pour l'intégrer dans une vraie app.
+   *
+   * 1. Elle construit un `PiSpiSdkConfig` à partir des informations que
+   *    l'app hôte possède déjà (l'utilisateur est déjà connecté chez le
+   *    participant *avant* d'ouvrir le SDK — le SDK ne gère lui-même aucune
+   *    authentification). Ici tout est codé en dur pour la démo.
+   * 2. Elle affiche `<PiSpiSdkEntry config={...} />` par-dessus l'écran de
+   *    l'hôte (ici, en remplaçant simplement son contenu).
+   */
+  const openPiSpiSdk = useCallback(
+    (options: { multiCompte?: boolean; theme?: Themes } = {}) => {
+      const config = new PiSpiSdkConfig({
+        // Identité du client déjà connecté côté hôte. Dans une vraie app,
+        // ces valeurs viennent de votre propre backend/session.
+        user: new PiSpiUserIdentity({
+          firstName: 'Jean',
+          lastName: 'Doe',
+          fullName: 'Jean Doe',
+          // Pays de domiciliation du compte : un code pays UEMOA.
+          pays: 'SN',
+          // comptes ne doit jamais être vide. Avec un seul élément, le SDK
+          // saute l'écran de sélection et le carrousel de l'accueil.
+          comptes: options.multiCompte
+            ? [
+                new PiSpiCompte({ numero: 'SNB0000000000000000001', libelle: 'Courant', solde: 4240320 }),
+                new PiSpiCompte({ numero: 'SNB0000000000000000002', libelle: 'Chèque', solde: 240000 }),
+                new PiSpiCompte({ numero: 'SNB0000000000000000003', libelle: 'Épargne', solde: 32240320 }),
+              ]
+            : [new PiSpiCompte({ numero: 'SNB0000000000000000001', libelle: 'Courant', solde: 4240320 })],
+        }),
+        // Connexion au backend PI-SPI : URL, authentification, mode démo.
+        api: new PiSpiApiConfig({
+          apiBaseUrl: API_BASE_URL,
+          // Token d'accès (Bearer) valide au moment de l'ouverture du SDK,
+          // ajouté par le SDK à chaque requête vers apiBaseUrl.
+          accessToken: FAKE_ACCESS_TOKEN,
+          // Appelé si une requête échoue en 401 (ou 403 avec un token
+          // expiré) : l'hôte rafraîchit son token et le retourne.
+          onAccessTokenExpired: async () => FAKE_ACCESS_TOKEN,
+          // Le SDK ne parvient plus à obtenir de token valide : on referme
+          // son écran et on prévient l'utilisateur.
+          onSessionExpired: async () => {
+            closeSdk();
+            Alert.alert('Session PI-SPI expirée');
+          },
+          // Mode démo : tous les appels API du SDK sont mockés.
+          demoMode: true,
+        }),
+        // Identité et préférences de l'application hôte.
+        appConfig: new PiSpiAppConfig({
+          // Code membre PSP du participant auprès de la BCEAO.
+          pspCodeMembre: 'SNB000',
+          // Le SDK n'a pas son propre sélecteur de langue : c'est l'hôte
+          // qui décide (français par défaut).
+          defaultLocale: 'fr',
+          // Optionnel : appliqué et persisté comme thème par défaut à
+          // chaque ouverture (écrase même un choix fait dans le SDK).
+          defaultTheme: options.theme,
+        }),
+        // Politique de step-up avant chaque action sensible.
+        identification: new PiSpiIdentificationConfig({
+          confirmationMethodLabel: 'external',
+          // Appelé par le SDK avant chaque action sensible. Dans une vraie
+          // app, remplacez ce faux écran par un vrai écran PIN/biométrie
+          // (ex. expo-local-authentication) : le SDK ne voit jamais le
+          // secret, seulement le booléen retourné ici.
+          requireStepUpIdentification: stepUp.request,
+        }),
+        // Journalisation et remontée d'erreurs.
+        log: new PiSpiLogConfig({
+          logLevel: 'debug',
+          // Dans une vraie app, transmettez l'erreur à votre outil de
+          // crash reporting (Crashlytics, Sentry...).
+          onError: (error) => console.log('[Host] Erreur remontée par le SDK :', error),
+        }),
+        // Fermeture volontaire (bouton retour/fermeture, compte clôturé...) :
+        // ce n'est pas une erreur, on referme juste l'écran.
+        onClose: async () => closeSdk(),
+      });
+      setSdkConfig(config);
+    },
+    [closeSdk, stepUp.request],
+  );
+
+  const openPiSpiSdkAndSimulatePush = useCallback(
+    (theme?: Themes) => {
+      // ouvrir d'abord le SDK
+      openPiSpiSdk({ theme });
+      // attendre trois secondes (le temps que l'écran du SDK soit affiché)
+      // avant de simuler la réception du push
+      setTimeout(simulateIncomingPush, 3000);
+    },
+    [openPiSpiSdk],
+  );
+
+  // Bouton retour Android : le SDK gère d'abord sa propre pile d'écrans ;
+  // quand il n'a plus rien à dépiler, l'hôte referme le SDK.
+  useEffect(() => {
+    if (!sdkConfig) return undefined;
+    const sub = BackHandler.addEventListener('hardwareBackPress', () => {
+      closeSdk();
+      return true;
+    });
+    return () => sub.remove();
+  }, [sdkConfig, closeSdk]);
+
+  return (
+    <View style={styles.flex}>
+      <StatusBar style="auto" />
+      {sdkConfig ? (
+        <PiSpiSdkEntry config={sdkConfig} />
+      ) : (
+        <SafeAreaView style={styles.flex} edges={['top', 'bottom']}>
+          <Text style={styles.appBarTitle}>App PSP</Text>
+          <ScrollView contentContainerStyle={styles.content}>
+            <AppSection
+              title="Le client a un seul compte"
+              tiles={SINGLE_ACCOUNT_TILES}
+              onTapTile={(theme) => openPiSpiSdk({ theme })}
+            />
+            <AppSection
+              title="Le client a plusieurs comptes"
+              tiles={MULTI_ACCOUNT_TILES}
+              onTapTile={(theme) => openPiSpiSdk({ multiCompte: true, theme })}
+            />
+            <AppSection
+              title="Simuler un push (transfert reçu)"
+              tiles={PUSH_TILES}
+              onTapTile={openPiSpiSdkAndSimulatePush}
+            />
+          </ScrollView>
+        </SafeAreaView>
+      )}
+      {stepUp.visible && <StepUpAuthPage onDone={stepUp.complete} />}
+    </View>
+  );
+}
+
+/**
+ * Illustre `PiSpiPush.handleIncoming` : dans une vraie app, ce serait
+ * appelé depuis le handler de message push de l'hôte. Si l'écran du SDK
+ * est ouvert, ça déclenche le même toast/rafraîchissement qu'un vrai push.
+ */
+function simulateIncomingPush() {
+  PiSpiPush.handleIncoming(
+    { idObject: 'ESNB00120240105153554CancelpNvhUk9e', type: 'TRANSFERT_RECU', montant: '1500' },
+    { title: 'Transfert reçu', body: 'Vous avez reçu 1 500 F CFA de Aïda Diop' },
+  );
+}
+
+/** Affiche le faux écran de step-up et résout la promesse demandée par le SDK. */
+function useStepUpAuth() {
+  const [visible, setVisible] = useState(false);
+  const resolver = useRef<((ok: boolean) => void) | null>(null);
+
+  const request = useCallback(
+    () =>
+      new Promise<boolean>((resolve) => {
+        resolver.current = resolve;
+        setVisible(true);
+      }),
+    [],
+  );
+
+  const complete = useCallback((ok: boolean) => {
+    setVisible(false);
+    resolver.current?.(ok);
+    resolver.current = null;
+  }, []);
+
+  return { visible, request, complete };
+}
+
+function AppSection({
+  title,
+  tiles,
+  onTapTile,
+}: {
+  title: string;
+  tiles: TileSpec[];
+  onTapTile: (theme?: Themes) => void;
+}) {
+  return (
+    <View style={styles.section}>
+      <Text style={styles.sectionTitle}>{title}</Text>
+      <View style={styles.wrap}>
+        {tiles.map((tile, i) => (
+          <Pressable
+            key={i}
+            onPress={() => onTapTile(tile.theme)}
+            style={({ pressed }) => [
+              styles.tile,
+              {
+                width: tile.wide ? 140 : 72,
+                paddingHorizontal: tile.wide ? 12 : 14,
+                paddingVertical: tile.wide ? 20 : 14,
+                backgroundColor: tile.background,
+                opacity: pressed ? 0.8 : 1,
+              },
+            ]}
+          >
+            <Image source={tile.asset} style={styles.tileImage} resizeMode="contain" />
+          </Pressable>
+        ))}
+      </View>
+    </View>
+  );
+}
+
+const PIN_LENGTH = 4;
+
+/** Faux écran de vérification (empreinte simulée, ou code PIN à 4 chiffres). */
+function StepUpAuthPage({ onDone }: { onDone: (ok: boolean) => void }) {
+  const [showPinFallback, setShowPinFallback] = useState(false);
+  const [scanning, setScanning] = useState(false);
+  const [pin, setPin] = useState<number[]>([]);
+
+  useEffect(() => {
+    const sub = BackHandler.addEventListener('hardwareBackPress', () => {
+      onDone(false);
+      return true;
+    });
+    return () => sub.remove();
+  }, [onDone]);
+
+  const startBiometricScan = () => {
+    setScanning(true);
+    setTimeout(() => onDone(true), 1400);
+  };
+
+  const onDigitPressed = (digit: number) => {
+    if (pin.length >= PIN_LENGTH) return;
+    const next = [...pin, digit];
+    setPin(next);
+    if (next.length === PIN_LENGTH) setTimeout(() => onDone(true), 200);
+  };
+
+  return (
+    <SafeAreaView style={[StyleSheet.absoluteFill, styles.stepUp]}>
+      <Pressable accessibilityRole="button" onPress={() => onDone(false)} style={styles.close} hitSlop={12}>
+        <MaterialIcons name="close" size={24} color="#1C1B1F" />
+      </Pressable>
+      <View style={styles.flex} />
+      <Text style={styles.stepUpTitle}>Vérification requise</Text>
+      <Text style={styles.stepUpSubtitle}>
+        {showPinFallback ? 'Saisissez votre code PIN' : 'Confirmez avec votre empreinte ou Face ID'}
+      </Text>
+      {!showPinFallback ? (
+        <View style={styles.center}>
+          <Pressable
+            disabled={scanning}
+            onPress={startBiometricScan}
+            style={[styles.fingerprint, scanning ? styles.fingerprintScanning : null]}
+          >
+            {scanning ? (
+              <ActivityIndicator size="large" color="#6750A4" />
+            ) : (
+              <MaterialIcons name="fingerprint" size={64} color="#6750A4" />
+            )}
+          </Pressable>
+          <Text style={styles.hint}>{scanning ? 'Scan en cours…' : 'Touchez pour scanner'}</Text>
+          <Pressable onPress={() => setShowPinFallback(true)} style={styles.link}>
+            <Text style={styles.linkText}>Utiliser le code PIN</Text>
+          </Pressable>
+        </View>
+      ) : (
+        <View style={styles.center}>
+          <View style={styles.dots}>
+            {Array.from({ length: PIN_LENGTH }, (_, i) => (
+              <View key={i} style={[styles.dot, i < pin.length ? styles.dotFilled : null]} />
+            ))}
+          </View>
+          <PinKeypad onDigit={onDigitPressed} onBackspace={() => setPin((p) => p.slice(0, -1))} />
+        </View>
+      )}
+      <View style={styles.flex} />
+    </SafeAreaView>
+  );
+}
+
+function PinKeypad({ onDigit, onBackspace }: { onDigit: (d: number) => void; onBackspace: () => void }) {
+  const rows = [
+    [1, 2, 3],
+    [4, 5, 6],
+    [7, 8, 9],
+  ];
+  return (
+    <View style={styles.keypad}>
+      {rows.map((row) => (
+        <View key={row[0]} style={styles.keypadRow}>
+          {row.map((d) => (
+            <KeypadButton key={d} label={String(d)} onPress={() => onDigit(d)} />
+          ))}
+        </View>
+      ))}
+      <View style={styles.keypadRow}>
+        <View style={styles.key} />
+        <KeypadButton label="0" onPress={() => onDigit(0)} />
+        <Pressable onPress={onBackspace} style={styles.key}>
+          <MaterialIcons name="backspace" size={24} color="#1C1B1F" />
+        </Pressable>
+      </View>
+    </View>
+  );
+}
+
+function KeypadButton({ label, onPress }: { label: string; onPress: () => void }) {
+  return (
+    <Pressable onPress={onPress} style={({ pressed }) => [styles.key, pressed ? styles.keyPressed : null]}>
+      <Text style={styles.keyText}>{label}</Text>
+    </Pressable>
+  );
+}
+
+const styles = StyleSheet.create({
+  flex: { flex: 1 },
+  appBarTitle: { fontSize: 22, fontWeight: '500', paddingHorizontal: 20, paddingVertical: 14 },
+  content: { padding: 20, paddingBottom: 40 },
+  section: { marginBottom: 28 },
+  sectionTitle: { fontSize: 16, fontWeight: '500', marginBottom: 12 },
+  wrap: { flexDirection: 'row', flexWrap: 'wrap', gap: 14 },
+  tile: { height: 72, borderRadius: 18 },
+  tileImage: { flex: 1, width: '100%' },
+  stepUp: { backgroundColor: '#FFFBFE', paddingHorizontal: 24 },
+  close: { alignSelf: 'flex-start', padding: 12 },
+  stepUpTitle: { fontSize: 24, fontWeight: '600', textAlign: 'center' },
+  stepUpSubtitle: { fontSize: 14, color: '#79747E', textAlign: 'center', marginTop: 8, marginBottom: 40 },
+  center: { alignItems: 'center' },
+  fingerprint: {
+    width: 120,
+    height: 120,
+    borderRadius: 60,
+    borderWidth: 2,
+    borderColor: '#6750A4',
+    backgroundColor: '#EADDFF',
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  fingerprintScanning: { backgroundColor: 'rgba(103,80,164,0.15)' },
+  hint: { marginTop: 24, fontSize: 12 },
+  link: { marginTop: 32, padding: 8 },
+  linkText: { color: '#6750A4', fontSize: 14, fontWeight: '500' },
+  dots: { flexDirection: 'row', gap: 16, marginBottom: 32 },
+  dot: { width: 14, height: 14, borderRadius: 7, borderWidth: 2, borderColor: '#6750A4' },
+  dotFilled: { backgroundColor: '#6750A4' },
+  keypad: { gap: 12 },
+  keypadRow: { flexDirection: 'row', gap: 24 },
+  key: { width: 72, height: 72, borderRadius: 36, alignItems: 'center', justifyContent: 'center' },
+  keyPressed: { backgroundColor: '#EADDFF' },
+  keyText: { fontSize: 28 },
+});

package/example/app.json

@@ -0,0 +1,62 @@
+{
+  "expo": {
+    "name": "PI-SPI SDK (exemple)",
+    "slug": "pispi-sdk-example",
+    "version": "1.0.0",
+    "orientation": "portrait",
+    "icon": "./assets/icon.png",
+    "userInterfaceStyle": "automatic",
+    "ios": {
+      "supportsTablet": true,
+      "bundleIdentifier": "com.bceao.pispi.sdk.example"
+    },
+    "android": {
+      "adaptiveIcon": {
+        "backgroundColor": "#E6F4FE",
+        "foregroundImage": "./assets/android-icon-foreground.png",
+        "backgroundImage": "./assets/android-icon-background.png",
+        "monochromeImage": "./assets/android-icon-monochrome.png"
+      },
+      "predictiveBackGestureEnabled": false,
+      "package": "com.bceao.pispi.sdk.example"
+    },
+    "web": {
+      "favicon": "./assets/favicon.png"
+    },
+    "plugins": [
+      "expo-secure-store",
+      "expo-audio",
+      "expo-image",
+      "expo-font",
+      "expo-asset",
+      "expo-video",
+      [
+        "expo-contacts",
+        {
+          "contactsPermission": "Autorisez l’accès à vos contacts pour envoyer de l’argent à un contact."
+        }
+      ],
+      [
+        "expo-location",
+        {
+          "locationWhenInUsePermission": "Votre position est utilisée pour vérifier vos transactions et prévenir la fraude."
+        }
+      ],
+      "expo-sharing",
+      [
+        "expo-camera",
+        {
+          "cameraPermission": "Autorisez l’accès à l’appareil photo pour scanner un QR code PI-SPI.",
+          "recordAudioAndroid": false
+        }
+      ],
+      [
+        "expo-image-picker",
+        {
+          "photosPermission": "Autorisez l’accès à vos photos pour joindre un ticket de caisse à une transaction.",
+          "cameraPermission": "Autorisez l’accès à l’appareil photo pour photographier un ticket de caisse."
+        }
+      ]
+    ]
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-spi/app",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "SDK React Native permettant d'intégrer PI-SPI (transactions, demande d'annulation, retour de fond, demande de paiement, QR Code, gestion des alias, gestion des abonnements, notifications, profil, compte) dans une application mobile existante.",
   "homepage": "https://github.com/pisfn-sandbox/mobile-app-react-native-sdk.git",
   "repository": {
@@ -24,6 +24,8 @@
     "src",
     "lib",
     "assets",
+    "example/App.tsx",
+    "example/app.json",
     "!**/__tests__",
     "!**/*.arb"
   ],