create-crm-tmp 2.0.0 → 2.1.0

package/template/src/lib/date-utils.ts

@@ -47,3 +47,130 @@ export function getWednesdayBeforeISOWeek(date: Date, weeksBefore: number = 4):
 
   return target;
 }
+
+/** Motif pour une valeur issue de `<input type="datetime-local">` : `YYYY-MM-DDTHH:mm` ou avec secondes. */
+const DATETIME_LOCAL_PAYLOAD_RE =
+  /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2}))?$/;
+
+/**
+ * Date du calendrier local (sans fuseau explicite dans la chaîne).
+ */
+export function toLocalDateInput(value: Date | string): string {
+  const date = typeof value === 'string' ? new Date(value) : value;
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  return `${year}-${month}-${day}`;
+}
+
+/**
+ * Valeur pour `<input type="datetime-local">` à partir d’une Date ou d’une ISO renvoyée par l’API.
+ */
+export function toLocalDateTimeInput(value: Date | string): string {
+  const date = typeof value === 'string' ? new Date(value) : value;
+  const localDate = toLocalDateInput(date);
+  const hours = String(date.getHours()).padStart(2, '0');
+  const minutes = String(date.getMinutes()).padStart(2, '0');
+  return `${localDate}T${hours}:${minutes}`;
+}
+
+/**
+ * Convertit une date/heure saisie en local (`YYYY-MM-DDTHH:mm`) en chaîne ISO UTC pour les APIs.
+ * Si la chaîne contient déjà un fuseau (`Z` ou `±hh:mm`), utilise le parseur natif.
+ */
+export function scheduledAtPayloadToIso(value: string): string {
+  const trimmed = value.trim();
+  const m = DATETIME_LOCAL_PAYLOAD_RE.exec(trimmed);
+  if (m) {
+    const year = Number(m[1]);
+    const month = Number(m[2]) - 1;
+    const day = Number(m[3]);
+    const hour = Number(m[4]);
+    const minute = Number(m[5]);
+    const second = m[6] === undefined ? 0 : Number(m[6]);
+    const local = new Date(year, month, day, hour, minute, second, 0);
+    if (Number.isNaN(local.getTime())) {
+      throw new TypeError('Date/heure invalide');
+    }
+    return local.toISOString();
+  }
+  const parsed = new Date(trimmed);
+  if (Number.isNaN(parsed.getTime())) {
+    throw new TypeError('Date/heure invalide');
+  }
+  return parsed.toISOString();
+}
+
+/** Fuseau pour formater les textes d’activité côté serveur (Vercel = UTC par défaut). Dom Tom : surcharger APP_DISPLAY_TIMEZONE. */
+const DEFAULT_APP_DISPLAY_TIMEZONE = 'Europe/Paris';
+
+/**
+ * Date/heure d’un RDV pour les chaînes enregistrées en base (serveur).
+ * Utilise APP_DISPLAY_TIMEZONE ou Europe/Paris par défaut.
+ */
+export function formatFrenchAppointmentDateTime(
+  date: Date,
+  timeZone: string = process.env.APP_DISPLAY_TIMEZONE ?? DEFAULT_APP_DISPLAY_TIMEZONE,
+): string {
+  return new Intl.DateTimeFormat('fr-FR', {
+    day: 'numeric',
+    month: 'long',
+    year: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+    timeZone,
+  }).format(date);
+}
+
+/**
+ * Même rendu que l’agenda / navigateur : fuseau local du client.
+ */
+export function formatFrenchAppointmentDateTimeLocal(date: Date | string): string {
+  const d = typeof date === 'string' ? new Date(date) : date;
+  return new Intl.DateTimeFormat('fr-FR', {
+    day: 'numeric',
+    month: 'long',
+    year: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+  }).format(d);
+}
+
+const APPOINTMENT_INTERACTION_TYPES = new Set([
+  'APPOINTMENT_CREATED',
+  'APPOINTMENT_CHANGED',
+  'APPOINTMENT_DELETED',
+]);
+
+/**
+ * Corps d’affichage pour cartes activités RDV : heure locale navigateur, corrige l’historique UTC en base.
+ */
+export function formatAppointmentInteractionBodyForDisplay(interaction: {
+  type: string;
+  content: string;
+  date: string | null;
+  metadata?: unknown;
+}): string {
+  if (!APPOINTMENT_INTERACTION_TYPES.has(interaction.type) || !interaction.date) {
+    return interaction.content;
+  }
+  const at = formatFrenchAppointmentDateTimeLocal(interaction.date);
+  const meta =
+    interaction.metadata &&
+    typeof interaction.metadata === 'object' &&
+    interaction.metadata !== null &&
+    'isGoogleMeet' in interaction.metadata
+      ? Boolean((interaction.metadata as { isGoogleMeet?: boolean }).isGoogleMeet)
+      : false;
+  const label = meta ? 'Google Meet' : 'Rendez-vous';
+  switch (interaction.type) {
+    case 'APPOINTMENT_CREATED':
+      return `Rendez-vous programmé le ${at}`;
+    case 'APPOINTMENT_CHANGED':
+      return `${label} programmé le ${at} a été modifié.`;
+    case 'APPOINTMENT_DELETED':
+      return `${label} prévu le ${at} a été annulé.`;
+    default:
+      return interaction.content;
+  }
+}

package/template/src/lib/default-widgets.ts

@@ -0,0 +1,12 @@
+export const DEFAULT_WIDGETS = [
+  { type: 'stat_total_contacts', x: 0, y: 0, w: 3, h: 2 },
+  { type: 'stat_new_contacts', x: 3, y: 0, w: 3, h: 2 },
+  { type: 'stat_completed_tasks', x: 6, y: 0, w: 3, h: 2 },
+  { type: 'stat_pending_tasks', x: 9, y: 0, w: 3, h: 2 },
+  { type: 'contacts_chart', x: 0, y: 2, w: 6, h: 4 },
+  { type: 'top_contacts', x: 6, y: 2, w: 6, h: 4 },
+  { type: 'activity_chart', x: 0, y: 6, w: 8, h: 4 },
+  { type: 'tasks_pie', x: 8, y: 6, w: 4, h: 4 },
+  { type: 'upcoming_tasks', x: 0, y: 10, w: 6, h: 5 },
+  { type: 'recent_activity', x: 6, y: 10, w: 6, h: 5 },
+];

package/template/src/lib/editor-html-image-dimensions.ts

@@ -0,0 +1,172 @@
+/**
+ * LexKit : export HTML correct (figure.align-left, width/height…), mais importFromHTML
+ * - ne remet pas __width/__height sur le nœud image ;
+ * - pour <figure>, force __alignment à "center" (bug / choix amont), d’où un logo visuellement centré
+ *   dans l’éditeur alors que le HTML sauvegardé reste à gauche.
+ * Ces helpers réappliquent taille + alignement après import, d’après le HTML réel.
+ */
+
+import type { LexicalEditor, LexicalNode } from 'lexical';
+import { $getRoot, $isElementNode } from 'lexical';
+
+function parsePositiveInt(value: string | null | undefined): number | null {
+  if (value == null || value === '') return null;
+  const n = Number.parseInt(String(value).trim(), 10);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+
+function parsePxFromStyle(style: string, prop: 'width' | 'height'): number | null {
+  const re = new RegExp(`${prop}\\s*:\\s*(\\d+)\\s*px`, 'i');
+  const m = re.exec(style);
+  if (!m) return null;
+  const n = Number.parseInt(m[1], 10);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+
+export type ImgDimensions = { w: number; h: number };
+export type ImgAlignment = 'left' | 'center' | 'right' | 'none';
+
+function extractImgAlignment(img: HTMLImageElement): ImgAlignment {
+  const fig = img.closest('figure');
+  const classBlob = [fig?.className, img.className].filter(Boolean).join(' ');
+  const styleBlob = [fig?.getAttribute('style'), img.getAttribute('style')]
+    .filter(Boolean)
+    .join(';');
+
+  if (/\balign-left\b/.test(classBlob)) return 'left';
+  if (/\balign-right\b/.test(classBlob)) return 'right';
+  if (/\balign-center\b/.test(classBlob)) return 'center';
+  if (/\balign-none\b/.test(classBlob)) return 'none';
+
+  if (/float\s*:\s*left/i.test(styleBlob)) return 'left';
+  if (/float\s*:\s*right/i.test(styleBlob)) return 'right';
+  if (/text-align\s*:\s*left/i.test(styleBlob)) return 'left';
+  if (/text-align\s*:\s*right/i.test(styleBlob)) return 'right';
+  if (/text-align\s*:\s*center/i.test(styleBlob)) return 'center';
+
+  return 'none';
+}
+
+function extractImgDimensions(img: HTMLImageElement): ImgDimensions | null {
+  let w = parsePositiveInt(img.getAttribute('width'));
+  let h = parsePositiveInt(img.getAttribute('height'));
+  const st = img.getAttribute('style') || '';
+  if (w == null) w = parsePxFromStyle(st, 'width');
+  if (h == null) h = parsePxFromStyle(st, 'height');
+  if (w != null && h != null) return { w, h };
+  return null;
+}
+
+export function extractOrderedImgLayout(html: string): {
+  dimensions: Array<ImgDimensions | null>;
+  alignments: ImgAlignment[];
+} {
+  if (!html.includes('<img')) {
+    return { dimensions: [], alignments: [] };
+  }
+  try {
+    const doc = new DOMParser().parseFromString(
+      `<div id="__editor_img_layout__">${html}</div>`,
+      'text/html',
+    );
+    const root = doc.getElementById('__editor_img_layout__');
+    if (!root) return { dimensions: [], alignments: [] };
+
+    const dimensions: Array<ImgDimensions | null> = [];
+    const alignments: ImgAlignment[] = [];
+    root.querySelectorAll('img').forEach((img) => {
+      dimensions.push(extractImgDimensions(img));
+      alignments.push(extractImgAlignment(img));
+    });
+    return { dimensions, alignments };
+  } catch {
+    return { dimensions: [], alignments: [] };
+  }
+}
+
+/** Copie width/height attributs → style inline (meilleure compat import LexKit + clients mail). */
+export function mergeImgDimensionAttrsIntoStyle(html: string): string {
+  if (!html.includes('<img')) return html;
+  try {
+    const doc = new DOMParser().parseFromString(
+      `<div id="__editor_sig_root__">${html}</div>`,
+      'text/html',
+    );
+    const root = doc.getElementById('__editor_sig_root__');
+    if (!root) return html;
+
+    root.querySelectorAll('img').forEach((img) => {
+      const wAttr = parsePositiveInt(img.getAttribute('width'));
+      const hAttr = parsePositiveInt(img.getAttribute('height'));
+      const style = (img.getAttribute('style') || '').trim();
+
+      const parts: string[] = [];
+      if (wAttr != null && !/\bwidth\s*:/i.test(style)) {
+        parts.push(`width:${wAttr}px`);
+      }
+      if (hAttr != null && !/\bheight\s*:/i.test(style)) {
+        parts.push(`height:${hAttr}px`);
+      }
+      if (parts.length === 0) return;
+
+      const merged = [style.replace(/;+\s*$/, ''), ...parts].filter(Boolean).join(';');
+      img.setAttribute('style', merged);
+    });
+
+    return root.innerHTML;
+  } catch {
+    return html;
+  }
+}
+
+type ImageNodeWithLayout = {
+  getType(): string;
+  setWidthAndHeight(width: number, height: number): void;
+  setAlignment(alignment: ImgAlignment): void;
+};
+
+function collectImageNodesInDocumentOrder(node: LexicalNode): ImageNodeWithLayout[] {
+  const list: ImageNodeWithLayout[] = [];
+
+  const visit = (n: LexicalNode) => {
+    if (n.getType() === 'image') {
+      list.push(n as unknown as ImageNodeWithLayout);
+    }
+    if ($isElementNode(n)) {
+      n.getChildren().forEach(visit);
+    }
+  };
+
+  visit(node);
+  return list;
+}
+
+/** Après importFromHTML : restaure __width/__height et __alignment (corrige le « center » forcé par LexKit sur <figure>). */
+export function applyOrderedImageLayoutAfterImport(editor: LexicalEditor, html: string): void {
+  if (!html.includes('<img')) return;
+
+  const { dimensions, alignments } = extractOrderedImgLayout(html);
+  if (dimensions.length === 0 || alignments.length === 0) return;
+
+  editor.update(() => {
+    const images = collectImageNodesInDocumentOrder($getRoot());
+    const count = Math.min(images.length, dimensions.length, alignments.length);
+    for (let i = 0; i < count; i++) {
+      const node = images[i];
+      const d = dimensions[i];
+      const a = alignments[i];
+      if (d) {
+        try {
+          node.setWidthAndHeight(d.w, d.h);
+        } catch {
+          /* ignore */
+        }
+      }
+      try {
+        node.setAlignment(a);
+      } catch {
+        /* ignore */
+      }
+    }
+  });
+}

package/template/src/lib/editor-image-limits.ts

@@ -0,0 +1,19 @@
+/**
+ * Taille max recommandée pour un logo en signature (HTML en data URL = base64,
+ * donc ~33 % plus lourd que le fichier binaire — mieux vaut rester léger).
+ */
+export const SIGNATURE_MAX_IMAGE_BYTES = 350 * 1024;
+
+export function formatImageFileSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} o`;
+  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} Ko`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} Mo`;
+}
+
+/** Lève une erreur avec un message utilisateur si le fichier dépasse la limite. */
+export function assertImageFileWithinLimit(file: File, maxBytes: number): void {
+  if (file.size <= maxBytes) return;
+  throw new Error(
+    `Image trop lourde (maximum ${formatImageFileSize(maxBytes)}, fichier : ${formatImageFileSize(file.size)}). Compressez ou réduisez le logo.`,
+  );
+}

package/template/src/lib/email-html-sanitize.ts

@@ -0,0 +1,19 @@
+import sanitize from 'sanitize-html';
+
+export function sanitizeEmailHtml(input: string): string {
+  if (!input) return '';
+  return sanitize(input, {
+    allowedTags: [
+      'p', 'br', 'strong', 'em', 'u', 'a', 'div', 'span',
+      'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+      'ul', 'ol', 'li', 'blockquote', 'pre', 'code',
+      'table', 'thead', 'tbody', 'tr', 'th', 'td',
+      'img', 'hr', 'sub', 'sup', 's',
+    ],
+    allowedAttributes: {
+      a: ['href', 'title', 'target', 'rel'],
+      img: ['src', 'alt', 'width', 'height'],
+      '*': ['style', 'class'],
+    },
+  });
+}

package/template/src/lib/encryption.ts

@@ -33,11 +33,12 @@ export function encrypt(text: string): string {
 
   const key = getEncryptionKey();
 
-  // Si la clé n'est pas définie, retourner le texte en clair (avec un avertissement)
+  // Si la clé n'est pas définie, lever une erreur en production
   if (!key) {
-    console.warn(
-      '⚠️  Chiffrement désactivé : ENCRYPTION_KEY non définie. Le mot de passe sera stocké en clair.',
-    );
+    if (process.env.NODE_ENV === 'production') {
+      throw new Error('ENCRYPTION_KEY must be configured in production');
+    }
+    console.warn('⚠️  Chiffrement désactivé : ENCRYPTION_KEY non définie...');
     return text;
   }
 
@@ -92,8 +93,10 @@ export function decrypt(encryptedData: string): string {
 
     return decrypted;
   } catch (error) {
-    // Si le déchiffrement échoue, retourner tel quel (pour la compatibilité)
-    console.error('Erreur lors du déchiffrement:', error);
+    if (process.env.NODE_ENV === 'production') {
+      throw new Error('Decryption failed - data may be corrupted');
+    }
+    console.warn('Decryption failed, returning raw data:', error);
     return encryptedData;
   }
 }

package/template/src/lib/fr-geography.ts

@@ -0,0 +1,192 @@
+/**
+ * Filtres liste contacts par région / département (dérivés du code postal).
+ * Codes région = INSEE (11, 24, 27, …). Codes département = 01–95, 2A, 2B, 971–976, etc.
+ */
+
+/** Préfixe `reg:` évite les collisions avec les codes département (ex. région 93 vs dept 93). */
+export const FR_REGIONS: { code: string; name: string }[] = [
+  { code: 'reg:01', name: 'Guadeloupe' },
+  { code: 'reg:02', name: 'Martinique' },
+  { code: 'reg:03', name: 'Guyane' },
+  { code: 'reg:04', name: 'La Réunion' },
+  { code: 'reg:06', name: 'Mayotte' },
+  { code: 'reg:11', name: 'Île-de-France' },
+  { code: 'reg:24', name: 'Centre-Val de Loire' },
+  { code: 'reg:27', name: 'Bourgogne-Franche-Comté' },
+  { code: 'reg:28', name: 'Normandie' },
+  { code: 'reg:32', name: 'Hauts-de-France' },
+  { code: 'reg:44', name: 'Grand Est' },
+  { code: 'reg:52', name: 'Pays de la Loire' },
+  { code: 'reg:53', name: 'Bretagne' },
+  { code: 'reg:75', name: 'Nouvelle-Aquitaine' },
+  { code: 'reg:76', name: 'Occitanie' },
+  { code: 'reg:84', name: 'Auvergne-Rhône-Alpes' },
+  { code: 'reg:93', name: "Provence-Alpes-Côte d'Azur" },
+  { code: 'reg:94', name: 'Corse' },
+];
+
+/** Clé = code dans FR_REGIONS (reg:xx) → codes département. */
+export const REGION_TO_DEPARTMENT_CODES: Record<string, string[]> = {
+  'reg:01': ['971'],
+  'reg:02': ['972'],
+  'reg:03': ['973'],
+  'reg:04': ['974'],
+  'reg:06': ['976'],
+  'reg:11': ['75', '77', '78', '91', '92', '93', '94', '95'],
+  'reg:24': ['18', '28', '36', '37', '41', '45'],
+  'reg:27': ['21', '25', '39', '58', '70', '71', '89', '90'],
+  'reg:28': ['14', '27', '50', '61', '76'],
+  'reg:32': ['02', '59', '60', '62', '80'],
+  'reg:44': ['08', '10', '51', '52', '54', '55', '57', '67', '68', '88'],
+  'reg:52': ['44', '49', '53', '72', '85'],
+  'reg:53': ['22', '29', '35', '56'],
+  'reg:75': ['16', '17', '19', '23', '24', '33', '40', '47', '64', '79', '86', '87'],
+  'reg:76': ['09', '11', '12', '30', '31', '32', '34', '46', '48', '65', '66', '81', '82'],
+  'reg:84': ['01', '03', '07', '15', '26', '38', '42', '43', '63', '69', '73', '74'],
+  'reg:93': ['04', '05', '06', '13', '83', '84'],
+  'reg:94': ['2A', '2B'],
+};
+
+export const FR_DEPARTMENTS: { code: string; name: string }[] = [
+  { code: '01', name: 'Ain' },
+  { code: '02', name: 'Aisne' },
+  { code: '03', name: 'Allier' },
+  { code: '04', name: 'Alpes-de-Haute-Provence' },
+  { code: '05', name: 'Hautes-Alpes' },
+  { code: '06', name: 'Alpes-Maritimes' },
+  { code: '07', name: 'Ardèche' },
+  { code: '08', name: 'Ardennes' },
+  { code: '09', name: 'Ariège' },
+  { code: '10', name: 'Aube' },
+  { code: '11', name: 'Aude' },
+  { code: '12', name: 'Aveyron' },
+  { code: '13', name: 'Bouches-du-Rhône' },
+  { code: '14', name: 'Calvados' },
+  { code: '15', name: 'Cantal' },
+  { code: '16', name: 'Charente' },
+  { code: '17', name: 'Charente-Maritime' },
+  { code: '18', name: 'Cher' },
+  { code: '19', name: 'Corrèze' },
+  { code: '2A', name: 'Corse-du-Sud' },
+  { code: '2B', name: 'Haute-Corse' },
+  { code: '21', name: "Côte-d'Or" },
+  { code: '22', name: "Côtes-d'Armor" },
+  { code: '23', name: 'Creuse' },
+  { code: '24', name: 'Dordogne' },
+  { code: '25', name: 'Doubs' },
+  { code: '26', name: 'Drôme' },
+  { code: '27', name: 'Eure' },
+  { code: '28', name: 'Eure-et-Loir' },
+  { code: '29', name: 'Finistère' },
+  { code: '30', name: 'Gard' },
+  { code: '31', name: 'Haute-Garonne' },
+  { code: '32', name: 'Gers' },
+  { code: '33', name: 'Gironde' },
+  { code: '34', name: 'Hérault' },
+  { code: '35', name: 'Ille-et-Vilaine' },
+  { code: '36', name: 'Indre' },
+  { code: '37', name: 'Indre-et-Loire' },
+  { code: '38', name: 'Isère' },
+  { code: '39', name: 'Jura' },
+  { code: '40', name: 'Landes' },
+  { code: '41', name: 'Loir-et-Cher' },
+  { code: '42', name: 'Loire' },
+  { code: '43', name: 'Haute-Loire' },
+  { code: '44', name: 'Loire-Atlantique' },
+  { code: '45', name: 'Loiret' },
+  { code: '46', name: 'Lot' },
+  { code: '47', name: 'Lot-et-Garonne' },
+  { code: '48', name: 'Lozère' },
+  { code: '49', name: 'Maine-et-Loire' },
+  { code: '50', name: 'Manche' },
+  { code: '51', name: 'Marne' },
+  { code: '52', name: 'Haute-Marne' },
+  { code: '53', name: 'Mayenne' },
+  { code: '54', name: 'Meurthe-et-Moselle' },
+  { code: '55', name: 'Meuse' },
+  { code: '56', name: 'Morbihan' },
+  { code: '57', name: 'Moselle' },
+  { code: '58', name: 'Nièvre' },
+  { code: '59', name: 'Nord' },
+  { code: '60', name: 'Oise' },
+  { code: '61', name: 'Orne' },
+  { code: '62', name: 'Pas-de-Calais' },
+  { code: '63', name: 'Puy-de-Dôme' },
+  { code: '64', name: 'Pyrénées-Atlantiques' },
+  { code: '65', name: 'Hautes-Pyrénées' },
+  { code: '66', name: 'Pyrénées-Orientales' },
+  { code: '67', name: 'Bas-Rhin' },
+  { code: '68', name: 'Haut-Rhin' },
+  { code: '69', name: 'Rhône' },
+  { code: '70', name: 'Haute-Saône' },
+  { code: '71', name: 'Saône-et-Loire' },
+  { code: '72', name: 'Sarthe' },
+  { code: '73', name: 'Savoie' },
+  { code: '74', name: 'Haute-Savoie' },
+  { code: '75', name: 'Paris' },
+  { code: '76', name: 'Seine-Maritime' },
+  { code: '77', name: 'Seine-et-Marne' },
+  { code: '78', name: 'Yvelines' },
+  { code: '79', name: 'Deux-Sèvres' },
+  { code: '80', name: 'Somme' },
+  { code: '81', name: 'Tarn' },
+  { code: '82', name: 'Tarn-et-Garonne' },
+  { code: '83', name: 'Var' },
+  { code: '84', name: 'Vaucluse' },
+  { code: '85', name: 'Vendée' },
+  { code: '86', name: 'Vienne' },
+  { code: '87', name: 'Haute-Vienne' },
+  { code: '88', name: 'Vosges' },
+  { code: '89', name: 'Yonne' },
+  { code: '90', name: 'Territoire de Belfort' },
+  { code: '91', name: 'Essonne' },
+  { code: '92', name: 'Hauts-de-Seine' },
+  { code: '93', name: 'Seine-Saint-Denis' },
+  { code: '94', name: 'Val-de-Marne' },
+  { code: '95', name: "Val-d'Oise" },
+  { code: '971', name: 'Guadeloupe' },
+  { code: '972', name: 'Martinique' },
+  { code: '973', name: 'Guyane' },
+  { code: '974', name: 'La Réunion' },
+  { code: '976', name: 'Mayotte' },
+];
+
+export function getPostalPrefixesForDepartment(code: string): string[] {
+  const c = code.trim().toUpperCase();
+  if (c === '2A') return ['200', '201'];
+  if (c === '2B') return ['202'];
+  if (/^97[1-6]$/.test(c)) return [c];
+  if (/^\d{3}$/.test(c) && (c.startsWith('97') || c.startsWith('98'))) return [c];
+  if (/^\d{1,2}$/.test(c)) {
+    const n = Number.parseInt(c, 10);
+    if (n >= 1 && n <= 95) return [String(n).padStart(2, '0')];
+  }
+  if (/^0\d$/.test(c)) return [c];
+  return [c];
+}
+
+export function expandRegionCodesToDepartmentCodes(regionCodes: string[]): string[] {
+  const out = new Set<string>();
+  for (const r of regionCodes) {
+    const depts = REGION_TO_DEPARTMENT_CODES[r.trim()];
+    if (depts) {
+      for (const d of depts) out.add(d);
+    }
+  }
+  return [...out];
+}
+
+/** Prisma: contact dont le code postal commence par un préfixe du département. */
+export function prismaPostalMatchesDepartmentsCondition(departmentCodes: string[]): {
+  OR: Record<string, unknown>[];
+} | null {
+  if (departmentCodes.length === 0) return null;
+  const ors: Record<string, unknown>[] = [];
+  for (const code of departmentCodes) {
+    for (const prefix of getPostalPrefixesForDepartment(code)) {
+      ors.push({ postalCode: { startsWith: prefix, mode: 'insensitive' as const } });
+    }
+  }
+  if (ors.length === 0) return null;
+  return { OR: ors };
+}