@pi-spi/app 0.0.0-stage → 1.2.1

package/src/shared/material/overlays.tsx

@@ -0,0 +1,232 @@
+import { createContext, useContext, useEffect, useRef, type ReactNode } from 'react';
+import {
+  Animated,
+  BackHandler,
+  Easing,
+  KeyboardAvoidingView,
+  PanResponder,
+  Platform,
+  Pressable,
+  StyleSheet,
+  View,
+} from 'react-native';
+
+import type { SdkRouter } from '../../core/router';
+import { useAppRouter } from '../../core/router';
+import { useTheme } from '../../core/theme';
+import { useValueListenable } from '../../core/value_notifier';
+
+/**
+ * Feuilles du bas (`showModalBottomSheet`) et dialogues (`showDialog`) du
+ * SDK. Comme en Flutter, où ce sont des routes du navigateur, ils sont
+ * empilés dans le routeur du SDK : `AppRouter.pop` ferme d'abord le plus
+ * récent (avec sa valeur de retour), et le bouton retour Android aussi —
+ * sauf si son contenu est enveloppé dans `<PopScope canPop={false}>`.
+ */
+
+export type OverlayKind = 'sheet' | 'dialog' | 'menu';
+
+export type OverlayEntry = {
+  id: number;
+  kind: OverlayKind;
+  builder: () => ReactNode;
+  /** Feuille sur le fond du thème (`bottomSheetTheme`), sur toute la largeur. */
+  themed: boolean;
+  /** Un tap sur le fond (barrière) ferme l'overlay. */
+  barrierDismissible: boolean;
+  /** Mis à `false` par `<PopScope canPop={false}>` : le retour système et la barrière sont ignorés. */
+  canPop: boolean;
+  resolve: (value: unknown) => void;
+};
+
+/**
+ * Affiche une feuille ancrée en bas de l'écran (≈ `showModalBottomSheet`
+ * avec `isScrollControlled: true`). La promesse est résolue à sa
+ * fermeture, avec la valeur passée à `AppRouter.pop`.
+ *
+ * Par défaut, comme avec `backgroundColor: Colors.transparent` en
+ * Flutter, le contenu dessine lui-même son fond. Avec [themed] (le cas
+ * Flutter sans `backgroundColor`), la feuille occupe toute la largeur,
+ * sur le fond `bottomSheetTheme` aux coins supérieurs arrondis.
+ */
+export function showModalBottomSheet<T = void>(
+  router: SdkRouter,
+  options: { builder: () => ReactNode; isDismissible?: boolean; themed?: boolean },
+): Promise<T | undefined> {
+  return router.showOverlay<T>('sheet', options.builder, options.isDismissible ?? true, { themed: options.themed });
+}
+
+/** Affiche un dialogue centré (≈ `showDialog`) ; le contenu dessine lui-même sa boîte. */
+export function showDialog<T = void>(
+  router: SdkRouter,
+  options: { builder: () => ReactNode; barrierDismissible?: boolean },
+): Promise<T | undefined> {
+  return router.showOverlay<T>('dialog', options.builder, options.barrierDismissible ?? true);
+}
+
+/**
+ * Affiche un menu contextuel (≈ `showMenu`) : pas de fond assombri, et le
+ * contenu se positionne lui-même (ex. à l'endroit de l'appui long). Un tap
+ * en dehors le ferme.
+ */
+export function showMenu<T = void>(router: SdkRouter, options: { builder: () => ReactNode }): Promise<T | undefined> {
+  return router.showOverlay<T>('menu', options.builder, true);
+}
+
+const OverlayEntryContext = createContext<OverlayEntry | null>(null);
+
+/**
+ * Équivalent de `PopScope(canPop: false)` pour une feuille ou un dialogue :
+ * bloque le bouton retour Android et le tap sur la barrière. Une fermeture
+ * explicite (`AppRouter.pop`) reste possible, comme `Navigator.pop`.
+ */
+export function PopScope({ canPop, children }: { canPop: boolean; children: ReactNode }) {
+  const entry = useContext(OverlayEntryContext);
+  if (entry) entry.canPop = canPop;
+  return <>{children}</>;
+}
+
+/** Affiche la pile des overlays du routeur, par-dessus le navigateur du SDK. */
+export function OverlayHost() {
+  const router = useAppRouter();
+  const entries = useValueListenable(router.overlays);
+
+  // Bouton retour Android : enregistré à chaque changement de la pile pour
+  // passer devant le gestionnaire du navigateur (les derniers inscrits
+  // sont appelés en premier).
+  useEffect(() => {
+    if (entries.length === 0) return undefined;
+    const subscription = BackHandler.addEventListener('hardwareBackPress', () => {
+      const top = entries[entries.length - 1];
+      if (top.canPop) router.pop();
+      return true;
+    });
+    return () => subscription.remove();
+  }, [entries, router]);
+
+  return (
+    <>
+      {entries.map((entry) => (
+        <OverlayView key={entry.id} entry={entry} router={router} />
+      ))}
+    </>
+  );
+}
+
+function OverlayView({ entry, router }: { entry: OverlayEntry; router: SdkRouter }) {
+  const progress = useRef(new Animated.Value(0)).current;
+
+  useEffect(() => {
+    Animated.timing(progress, {
+      toValue: 1,
+      duration: entry.kind === 'sheet' ? 250 : 150,
+      easing: Easing.out(Easing.cubic),
+      useNativeDriver: true,
+    }).start();
+  }, [entry.kind, progress]);
+
+  // Comme `enableDrag` des feuilles Flutter : glisser la feuille vers le
+  // bas la ferme, même quand `PopScope` bloque le bouton retour (Flutter
+  // appelle alors `Navigator.pop` directement).
+  const drag = useRef(new Animated.Value(0)).current;
+  const panResponder = useRef(
+    PanResponder.create({
+      onMoveShouldSetPanResponder: (_e, g) => g.dy > 10 && Math.abs(g.dy) > Math.abs(g.dx),
+      onPanResponderMove: (_e, g) => drag.setValue(Math.max(0, g.dy)),
+      onPanResponderRelease: (_e, g) => {
+        if (g.dy > 120 || g.vy > 1.2) {
+          if (router.isTopOverlay(entry)) router.pop();
+        } else {
+          Animated.spring(drag, { toValue: 0, useNativeDriver: true }).start();
+        }
+      },
+      onPanResponderTerminate: () => Animated.spring(drag, { toValue: 0, useNativeDriver: true }).start(),
+    }),
+  ).current;
+
+  const onBarrierPress = () => {
+    if (entry.barrierDismissible && entry.canPop && router.isTopOverlay(entry)) router.pop();
+  };
+
+  const built = <OverlayEntryContext.Provider value={entry}>{entry.builder()}</OverlayEntryContext.Provider>;
+  const content = entry.themed ? <ThemedSheet>{built}</ThemedSheet> : built;
+
+  if (entry.kind === 'menu') {
+    return (
+      <View style={StyleSheet.absoluteFill}>
+        <Pressable style={StyleSheet.absoluteFill} onPress={onBarrierPress} accessibilityLabel="Fermer" />
+        <Animated.View pointerEvents="box-none" style={[StyleSheet.absoluteFill, { opacity: progress }]}>
+          {content}
+        </Animated.View>
+      </View>
+    );
+  }
+
+  return (
+    <View style={StyleSheet.absoluteFill}>
+      <Animated.View style={[StyleSheet.absoluteFill, styles.barrier, { opacity: progress }]}>
+        <Pressable style={StyleSheet.absoluteFill} onPress={onBarrierPress} accessibilityLabel="Fermer" />
+      </Animated.View>
+      <KeyboardAvoidingView
+        style={entry.kind === 'sheet' ? styles.sheetHost : styles.dialogHost}
+        behavior={Platform.OS === 'ios' ? 'padding' : undefined}
+        pointerEvents="box-none"
+      >
+        {entry.kind === 'sheet' ? (
+          <Animated.View
+            {...panResponder.panHandlers}
+            style={{
+              transform: [
+                {
+                  translateY: Animated.add(
+                    progress.interpolate({ inputRange: [0, 1], outputRange: [400, 0] }),
+                    drag,
+                  ),
+                },
+              ],
+            }}
+          >
+            {content}
+          </Animated.View>
+        ) : (
+          // Comme `showDialog` en Flutter : le contenu est affiché tel quel
+          // (c'est lui qui dessine sa boîte, ex. `CustomAlertDialog`).
+          <Animated.View
+            pointerEvents="box-none"
+            style={[
+              styles.dialog,
+              { opacity: progress },
+              { transform: [{ scale: progress.interpolate({ inputRange: [0, 1], outputRange: [0.9, 1] }) }] },
+            ]}
+          >
+            {content}
+          </Animated.View>
+        )}
+      </KeyboardAvoidingView>
+    </View>
+  );
+}
+
+/** Fond d'une feuille « thémée » : toute la largeur, coins supérieurs arrondis. */
+function ThemedSheet({ children }: { children: ReactNode }) {
+  const sheet = useTheme().bottomSheetTheme;
+  return (
+    <View
+      style={{
+        backgroundColor: sheet.backgroundColor,
+        borderTopLeftRadius: sheet.borderTopRadius,
+        borderTopRightRadius: sheet.borderTopRadius,
+        overflow: 'hidden',
+      }}
+    >
+      {children}
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  barrier: { backgroundColor: 'rgba(0,0,0,0.54)' },
+  sheetHost: { flex: 1, justifyContent: 'flex-end' },
+  dialogHost: { flex: 1, justifyContent: 'center' },
+  dialog: { flexGrow: 0 },
+});

package/src/shared/material/popup_menu.tsx

@@ -0,0 +1,71 @@
+import { MaterialIcons } from '@expo/vector-icons';
+import { Dimensions, Pressable, StyleSheet, Text, View } from 'react-native';
+
+import { AppRouter, type SdkRouter } from '../../core/router';
+import { useTheme } from '../../core/theme';
+import { showMenu } from './overlays';
+
+export type PopupMenuItem = {
+  icon: keyof typeof MaterialIcons.glyphMap;
+  iconSize?: number;
+  label: string;
+  onTap: () => void;
+};
+
+const MENU_WIDTH = 220;
+const ITEM_HEIGHT = 48;
+
+/**
+ * Menu contextuel affiché à la position [x], [y] de l'écran (≈ `showMenu`
+ * avec des `PopupMenuItem`) : il se ferme au choix d'une entrée, avant
+ * l'appel de son `onTap`, ou à un tap en dehors.
+ */
+export function showPopupMenu(router: SdkRouter, options: { x: number; y: number; items: PopupMenuItem[] }): Promise<void> {
+  const window = Dimensions.get('window');
+  const height = options.items.length * ITEM_HEIGHT + 16;
+  const left = Math.max(8, Math.min(options.x, window.width - MENU_WIDTH - 8));
+  const top = Math.max(8, Math.min(options.y, window.height - height - 8));
+  return showMenu<void>(router, {
+    builder: () => <PopupMenu left={left} top={top} items={options.items} router={router} />,
+  }).then(() => undefined);
+}
+
+function PopupMenu({ left, top, items, router }: { left: number; top: number; items: PopupMenuItem[]; router: SdkRouter }) {
+  const theme = useTheme();
+  return (
+    <View style={[styles.menu, { left, top, backgroundColor: theme.cardTheme.color }]}>
+      {items.map((item, i) => (
+        <Pressable
+          key={i}
+          accessibilityRole="menuitem"
+          onPress={() => {
+            AppRouter.pop(router);
+            item.onTap();
+          }}
+          style={({ pressed }) => [styles.item, pressed ? { backgroundColor: theme.colorScheme.secondary } : null]}
+        >
+          <MaterialIcons name={item.icon} size={item.iconSize ?? 16} color={theme.colorScheme.onSurface} />
+          <View style={styles.gap12} />
+          {/* Comme `PopupMenuItem` Flutter : texte au style `labelLarge` du thème */}
+          <Text style={[theme.textTheme.labelLarge, { color: theme.colorScheme.onSurface }]}>{item.label}</Text>
+        </Pressable>
+      ))}
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  menu: {
+    position: 'absolute',
+    width: MENU_WIDTH,
+    borderRadius: 16,
+    paddingVertical: 8,
+    elevation: 6,
+    shadowColor: '#000',
+    shadowOpacity: 0.2,
+    shadowRadius: 8,
+    shadowOffset: { width: 0, height: 3 },
+  },
+  item: { flexDirection: 'row', alignItems: 'center', paddingHorizontal: 16, height: ITEM_HEIGHT },
+  gap12: { width: 12 },
+});

package/src/shared/material/scaffold.tsx

@@ -0,0 +1,93 @@
+import { MaterialIcons } from '@expo/vector-icons';
+import type { ReactNode } from 'react';
+import { Pressable, StyleSheet, Text, View, type StyleProp, type ViewStyle } from 'react-native';
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
+
+import { useTheme } from '../../core/theme';
+
+/**
+ * Équivalents minimaux de `Scaffold` et `AppBar` (Material) utilisés par
+ * les écrans du SDK Flutter, stylés à partir du thème courant du SDK.
+ */
+
+export type AppBarProps = {
+  title?: ReactNode;
+  /** Bouton à gauche ; par défaut, une flèche retour si [onBack] est fourni. */
+  leading?: ReactNode;
+  onBack?: () => void;
+  actions?: ReactNode;
+  centerTitle?: boolean;
+  backgroundColor?: string;
+};
+
+export function AppBar({ title, leading, onBack, actions, centerTitle = true, backgroundColor }: AppBarProps) {
+  const theme = useTheme();
+  const color = theme.appBarTheme.foregroundColor;
+  const leadingNode =
+    leading ??
+    (onBack ? (
+      <Pressable accessibilityRole="button" hitSlop={12} onPress={onBack} style={styles.leading}>
+        <MaterialIcons name="arrow-back" size={24} color={color} />
+      </Pressable>
+    ) : null);
+
+  return (
+    <View style={[styles.appBar, { backgroundColor: backgroundColor ?? theme.appBarTheme.backgroundColor }]}>
+      <View style={styles.side}>{leadingNode}</View>
+      <View style={[styles.title, centerTitle ? styles.titleCentered : null]}>
+        {typeof title === 'string' ? (
+          <Text numberOfLines={1} style={[theme.textTheme.headlineSmall, { color }]}>
+            {title}
+          </Text>
+        ) : (
+          title
+        )}
+      </View>
+      <View style={[styles.side, styles.actions]}>{actions}</View>
+    </View>
+  );
+}
+
+export type ScaffoldProps = {
+  appBar?: ReactNode;
+  children?: ReactNode;
+  backgroundColor?: string;
+  style?: StyleProp<ViewStyle>;
+  /** Applique les marges de la zone sûre en haut (par défaut si [appBar] est fourni). */
+  safeTop?: boolean;
+  /** Applique les marges de la zone sûre en bas. */
+  safeBottom?: boolean;
+};
+
+export function Scaffold({ appBar, children, backgroundColor, style, safeTop, safeBottom = true }: ScaffoldProps) {
+  const theme = useTheme();
+  const insets = useSafeAreaInsets();
+  const applyTop = safeTop ?? appBar != null;
+  return (
+    <View
+      style={[
+        styles.scaffold,
+        {
+          backgroundColor: backgroundColor ?? theme.scaffoldBackgroundColor,
+          paddingTop: applyTop ? insets.top : 0,
+          paddingBottom: safeBottom ? insets.bottom : 0,
+        },
+        style,
+      ]}
+    >
+      {appBar}
+      <View style={styles.body}>{children}</View>
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  scaffold: { flex: 1 },
+  body: { flex: 1 },
+  appBar: { height: 56, flexDirection: 'row', alignItems: 'center', paddingHorizontal: 4 },
+  side: { minWidth: 48, alignItems: 'center', justifyContent: 'center' },
+  actions: { flexDirection: 'row' },
+  leading: { padding: 12 },
+  title: { flex: 1, paddingHorizontal: 8 },
+  titleCentered: { alignItems: 'center' },
+});

package/src/shared/models/alias_pi.ts

@@ -0,0 +1,104 @@
+/** Types d'erreurs possibles sur le champ alias (valeur = codification) */
+export enum AliasPIError {
+  empty = 'AliasPIErrorEmpty',
+  invalid = 'AliasPIErrorInvalid',
+  mbnoForbidden = 'AliasPIErrorMbnoForbidden',
+  mbnoInvalid = 'AliasPIErrorMbnoInvalid',
+  notFound = 'AliasPIErrorNotFound',
+}
+
+/** Modeles et regles de validation du champ alias */
+export class AliasPI {
+  static label = '@PI';
+
+  value?: string;
+  error?: AliasPIError;
+  mbnoForbidden?: boolean;
+
+  constructor(params: { value?: string; mbnoForbidden?: boolean } = {}) {
+    this.value = params.value;
+    this.mbnoForbidden = params.mbnoForbidden;
+  }
+
+  /** Format de numéro de téléphone des 8 pays de l'union */
+  static readonly patternMBNO =
+    /^(?:\+225\d{10}|\+221\d{9}|\+223\d{8}|\+226\d{8}|\+229\d{10}|\+228\d{8}|\+227\d{8}|\+245\d{6})$/;
+
+  static readonly patternSHID =
+    /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/;
+
+  isValid(): boolean {
+    const value = this.value;
+    // lorsque l'identifiant n'est pas renseigné
+    if (value == null || value.length === 0) {
+      this.error = AliasPIError.empty;
+    }
+    // lorsque le numéro de téléphone est interdit
+    else if (this.mbnoForbidden === true && AliasPI.patternMBNO.test(value)) {
+      this.error = AliasPIError.mbnoForbidden;
+    }
+    // lorsque le SHID est invalide
+    else if (this.mbnoForbidden === true && !AliasPI.patternSHID.test(value)) {
+      this.error = AliasPIError.mbnoInvalid;
+    }
+    // L'alias est un numéro de téléphone ou SHID
+    else if (!AliasPI.patternMBNO.test(value) && !AliasPI.patternSHID.test(value)) {
+      this.error = AliasPIError.invalid;
+    }
+    // lorsque l'identifiant est valide
+    else {
+      this.error = undefined;
+    }
+    return this.error == null;
+  }
+
+  static isValidAlias(alias: string, options: { mbnoForbidden?: boolean } = {}): boolean {
+    const mbnoForbidden = options.mbnoForbidden ?? false;
+    if (alias.length === 0) return false;
+    if (mbnoForbidden && AliasPI.patternMBNO.test(alias)) return false;
+    if (mbnoForbidden && !AliasPI.patternSHID.test(alias)) return false;
+    return AliasPI.patternMBNO.test(alias) || AliasPI.patternSHID.test(alias);
+  }
+
+  static formatPhoneNumber(input: string): string {
+    const value = input.replace(/ /g, '');
+    // Vérifier si le numéro commence par un préfixe international (ex: +225)
+    const match = /^\+\d{3}/.exec(value);
+    const numeric = /^\d+$/;
+
+    if (match == null) {
+      return numeric.test(value) ? AliasPI.remaining(value) : value;
+    }
+
+    // Extraire le préfixe international et le reste du numéro
+    const prefix = match[0];
+    const remaining = value.substring(prefix.length);
+    if (!numeric.test(remaining)) return value;
+
+    // Retourner le numéro formaté avec le préfixe
+    return `${prefix} ${AliasPI.remaining(remaining)}`;
+  }
+
+  /** Groupes de chiffres selon la longueur (3 à 10 chiffres) */
+  private static remaining(remaining: string): string {
+    const groups: Record<number, number[]> = {
+      3: [2, 1], // "124" -> "12 4"
+      4: [2, 2], // "1245" -> "12 45"
+      5: [2, 3], // "12455" -> "12 455"
+      6: [2, 2, 2], // "124544" -> "12 45 44"
+      7: [2, 3, 2], // "1245467" -> "12 454 67"
+      8: [2, 2, 2, 2], // "12345678" -> "12 34 56 78"
+      9: [2, 3, 2, 2], // "123456789" -> "12 345 67 89"
+      10: [2, 3, 3, 2], // "1234567890" -> "12 345 678 90"
+    };
+    const sizes = groups[remaining.length];
+    if (!sizes) return remaining;
+    const parts: string[] = [];
+    let index = 0;
+    for (const size of sizes) {
+      parts.push(remaining.substring(index, index + size));
+      index += size;
+    }
+    return parts.join(' ');
+  }
+}

package/src/shared/models/compte_validator.ts

@@ -0,0 +1,88 @@
+import { UEMOACountry } from './uemoa_countries';
+
+export class CompteValidator {
+  /**
+   * Vérifie si un IBAN UEMOA est valide.
+   * ```
+   * SN  08  SN012 01201 035204653501  69
+   * │   │   │     │     │             └─ clé RIB          (2 chiffres)
+   * │   │   │     │     └─────────────── numero de compte (12 chiffres)
+   * │   │   │     └───────────────────── code agence      (5 chiffres)
+   * │   │   └─────────────────────────── code banque      (5 lettres)
+   * │   └─────────────────────────────── clé IBAN         (2 chiffres)
+   * └─────────────────────────────────── pays IBAN        (2 lettres)
+   * ```
+   * Ex : SN08SN0120120103520465350169, CI93CI0080111301134291200589
+   */
+  static isUemoaIban(compte: string | null | undefined): boolean {
+    if (compte == null || compte.length === 0) return false;
+    const codeIban = compte.trim().toUpperCase().replace(/ /g, '');
+
+    if (!/^[A-Z]{2}\d{2}[A-Z]{2}\d{22}$/.test(codeIban)) return false;
+
+    // Pays UEMOA uniquement
+    if (!UEMOACountry.paysIsoCodes().includes(codeIban.substring(0, 2))) return false;
+
+    if (codeIban.length !== 28) return false;
+    const rearranged = codeIban.substring(4) + codeIban.substring(0, 4);
+    return CompteValidator.modulo97(CompteValidator.lettersToDigits(rearranged)) === 1;
+  }
+
+  /**
+   * Vérifie si un RIB UEMOA est valide.
+   * ```
+   * CI008 01113 01134291200 89
+   * │     │     │           └─ Clé RIB          (2 chiffres)
+   * │     │     └───────────── Numéro de compte (12 chiffres)
+   * │     └─────────────────── Code agence      (5 chiffres)
+   * └───────────────────────── Code banque      (5 chiffres)
+   * ```
+   * Ex : SN0120120103520465350169, CI0080111301134291200589
+   */
+  static isUemoaRib(compte: string | null | undefined): boolean {
+    if (compte == null || compte.length === 0) return false;
+    const rib = compte.trim().toUpperCase().replace(/ /g, '');
+
+    // Format UEMOA : 2 lettres pays + 22 chiffres = 24 caractères
+    if (!/^[A-Z]{2}\d{22}$/.test(rib)) return false;
+
+    // Code pays UEMOA valide
+    const pays = rib.substring(0, 2);
+    if (!UEMOACountry.paysIsoCodes().includes(pays)) return false;
+
+    // Clé IBAN calculée à partir du RIB (réarrangement : RIB + pays + "00")
+    const numerique = CompteValidator.lettersToDigits(`${rib}${pays}00`);
+    const cleIban = String(98 - CompteValidator.modulo97(numerique)).padStart(2, '0');
+
+    // Valider l'IBAN reconstitué (pays + cleIban + RIB)
+    return CompteValidator.isUemoaIban(`${pays}${cleIban}${rib}`);
+  }
+
+  /**
+   * Vérifie si un numéro de téléphone UEMOA est valide (avec indicatif ou non).
+   * Ex : +2250788495430, 0788495430, +221775177023
+   */
+  static isUemoaPhone(compte: string | null | undefined): boolean {
+    if (compte == null || compte.length === 0) return false;
+    const numero = compte.trim().replace(/ /g, '').replace(/-/g, '');
+    return /^(?:\+225\d{10}|\+221\d{9}|\+223\d{8}|\+226\d{8}|\+229\d{10}|\+228\d{8}|\+227\d{8}|\+245\d{6}|\d{6,10})$/.test(
+      numero,
+    );
+  }
+
+  private static lettersToDigits(value: string): string {
+    let out = '';
+    for (const car of value) {
+      out += /[A-Z]/.test(car) ? String(car.charCodeAt(0) - 55) : car;
+    }
+    return out;
+  }
+
+  private static modulo97(valeur: string): number {
+    let reste = 0;
+    for (const digit of valeur) {
+      reste = (reste * 10 + parseInt(digit, 10)) % 97;
+    }
+    return reste;
+  }
+}

package/src/shared/models/frequence_command.ts

@@ -0,0 +1,43 @@
+/** Frequences de paiement (valeur = codification) */
+export enum Frequence {
+  /** Quotidienne */
+  quotidienne = 'J',
+  /** Hebdomadaire */
+  hebdomadaire = 'S',
+  /** Mensuelle */
+  mensuelle = 'M',
+  /** Annuelle */
+  annuelle = 'A',
+}
+
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace Frequence {
+  /** Fréquence à partir de son nom (`mensuelle`) ou de son code (`M`). */
+  export function get(frequence: string | null | undefined): Frequence {
+    const entry = Object.entries(Frequence).find(
+      ([name, code]) => typeof code === 'string' && (name === frequence || code === frequence),
+    );
+    if (!entry) throw new Error(`Aucune correspondance pour la valeur ${frequence}`);
+    return entry[1] as Frequence;
+  }
+
+  /** Nom de la fréquence (`Frequence.mensuelle` → `mensuelle`), comme `.name` en Dart. */
+  export function nameOf(frequence: Frequence): string {
+    return Object.entries(Frequence).find(([, code]) => code === frequence)![0];
+  }
+}
+
+/** Frequences */
+export class FrequenceCommand {
+  static custom = 'CUSTOM';
+
+  value?: Frequence;
+  periodicite?: number;
+  done: boolean;
+
+  constructor(params: { value?: Frequence; periodicite?: number; done?: boolean } = {}) {
+    this.value = params.value;
+    this.periodicite = params.periodicite;
+    this.done = params.done ?? false;
+  }
+}

package/src/shared/models/liste_meta.ts

@@ -0,0 +1,42 @@
+export class ListeMeta {
+  readonly total: number;
+  readonly previous?: unknown;
+  readonly next?: unknown;
+  readonly current?: unknown;
+  readonly limit: number;
+
+  constructor(params: { total: number; limit: number; previous?: unknown; next?: unknown; current?: unknown }) {
+    this.total = params.total;
+    this.limit = params.limit;
+    this.previous = params.previous;
+    this.next = params.next;
+    this.current = params.current;
+  }
+
+  static fromJson(json: Record<string, any>): ListeMeta {
+    return new ListeMeta({
+      total: Number(json.total),
+      previous: json.previous,
+      next: json.next,
+      current: json.current,
+      limit: Number(json.limit),
+    });
+  }
+
+  toJson(): Record<string, unknown> {
+    return {
+      total: String(this.total),
+      limit: String(this.limit),
+      previous: this.previous,
+      current: this.current,
+      next: this.next,
+    };
+  }
+}
+
+export class ListData<T> {
+  constructor(
+    readonly data: T[],
+    readonly meta: ListeMeta,
+  ) {}
+}