Initial local backup snapshot

shared/associationGovernance.ts

@@ -0,0 +1,194 @@
+export const legalRepresentativeRoleValues = [
+  "president",
+  "co_president",
+  "secretaire_general",
+  "directeur_gerant",
+] as const;
+
+export type LegalRepresentativeRole = typeof legalRepresentativeRoleValues[number];
+
+export const governanceMemberRoleValues = [
+  "tresorier",
+  "tresorier_adjoint",
+  "secretaire",
+  "secretaire_adjoint",
+  "administrateur",
+  "charge_de_mission_referent",
+  "adherent_benevole",
+] as const;
+
+export type GovernanceMemberRole = typeof governanceMemberRoleValues[number];
+
+export const legalRepresentativeRoleLabels: Record<LegalRepresentativeRole, string> = {
+  president: "Président",
+  co_president: "Co-président",
+  secretaire_general: "Secrétaire Général",
+  directeur_gerant: "Directeur / Gérant",
+};
+
+export const governanceMemberRoleLabels: Record<GovernanceMemberRole, string> = {
+  tresorier: "Trésorier",
+  tresorier_adjoint: "Trésorier adjoint",
+  secretaire: "Secrétaire",
+  secretaire_adjoint: "Secrétaire adjoint",
+  administrateur: "Membre du conseil d'administration / Administrateur",
+  charge_de_mission_referent: "Chargé de mission / Référent",
+  adherent_benevole: "Simple adhérent / Bénévole",
+};
+
+export const legalRepresentativeRoleOptions = legalRepresentativeRoleValues.map((value) => ({
+  value,
+  label: legalRepresentativeRoleLabels[value],
+}));
+
+export const governanceMemberRoleOptions = governanceMemberRoleValues.map((value) => ({
+  value,
+  label: governanceMemberRoleLabels[value],
+}));
+
+function normalizeRoleKey(value: string | null | undefined) {
+  return String(value || "")
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "_")
+    .replace(/^_+|_+$/g, "");
+}
+
+export function normalizeLegalRepresentativeRole(value: string | null | undefined): LegalRepresentativeRole {
+  const normalized = normalizeRoleKey(value);
+  switch (normalized) {
+    case "president":
+    case "presidente":
+      return "president";
+    case "co_president":
+    case "copresident":
+    case "co_presidente":
+      return "co_president";
+    case "secretaire_general":
+      return "secretaire_general";
+    case "directeur":
+    case "gerant":
+    case "directeur_gerant":
+      return "directeur_gerant";
+    default:
+      return "president";
+  }
+}
+
+export function normalizeGovernanceMemberRole(value: string | null | undefined): GovernanceMemberRole {
+  const normalized = normalizeRoleKey(value);
+  switch (normalized) {
+    case "tresorier":
+      return "tresorier";
+    case "tresorier_adjoint":
+      return "tresorier_adjoint";
+    case "secretaire":
+      return "secretaire";
+    case "secretaire_adjoint":
+      return "secretaire_adjoint";
+    case "administrateur":
+    case "membre_du_conseil_d_administration_administrateur":
+      return "administrateur";
+    case "charge_de_mission":
+    case "referent":
+    case "charge_de_mission_referent":
+      return "charge_de_mission_referent";
+    default:
+      return "adherent_benevole";
+  }
+}
+
+export type GovernancePerson = {
+  nom: string;
+  prenom: string;
+  email?: string | null;
+  telephone?: string | null;
+  fonction: string;
+};
+
+export type AssociationGovernance = {
+  representantLegal: GovernancePerson | null;
+  membres: GovernancePerson[];
+};
+
+export function createEmptyGovernancePerson(fonction = ""): GovernancePerson {
+  return {
+    nom: "",
+    prenom: "",
+    email: "",
+    telephone: "",
+    fonction,
+  };
+}
+
+export function parseAssociationGovernance(value: string | null | undefined): AssociationGovernance {
+  if (!value) {
+    return { representantLegal: null, membres: [] };
+  }
+
+  try {
+    const parsed = JSON.parse(value) as Partial<AssociationGovernance>;
+    const normalizePerson = (person: any): GovernancePerson | null => {
+      if (!person || typeof person !== "object") return null;
+      return {
+        nom: typeof person.nom === "string" ? person.nom : "",
+        prenom: typeof person.prenom === "string" ? person.prenom : "",
+        email: typeof person.email === "string" ? person.email : "",
+        telephone: typeof person.telephone === "string" ? person.telephone : "",
+        fonction: typeof person.fonction === "string" ? person.fonction : "",
+      };
+    };
+
+    return {
+      representantLegal: normalizePerson(parsed.representantLegal),
+      membres: Array.isArray(parsed.membres)
+        ? parsed.membres.map(normalizePerson).filter(Boolean) as GovernancePerson[]
+        : [],
+    };
+  } catch {
+    return { representantLegal: null, membres: [] };
+  }
+}
+
+export function serializeAssociationGovernance(
+  governance: AssociationGovernance | null | undefined
+) {
+  if (!governance?.representantLegal) return null;
+  return JSON.stringify(governance);
+}
+
+export function buildDisplayName(person: GovernancePerson | null | undefined) {
+  if (!person) return "";
+  return [person.prenom?.trim(), person.nom?.trim()].filter(Boolean).join(" ").trim();
+}
+
+export function sanitizeGovernance(governance: AssociationGovernance): AssociationGovernance {
+  const trimPerson = (
+    person: GovernancePerson | null,
+    roleNormalizer?: (value: string | null | undefined) => string
+  ): GovernancePerson | null => {
+    if (!person) return null;
+    const normalized: GovernancePerson = {
+      nom: person.nom.trim(),
+      prenom: person.prenom.trim(),
+      email: person.email?.trim() || "",
+      telephone: person.telephone?.trim() || "",
+      fonction: roleNormalizer ? roleNormalizer(person.fonction) : person.fonction.trim(),
+    };
+
+    if (!normalized.nom && !normalized.prenom && !normalized.email && !normalized.telephone && !normalized.fonction) {
+      return null;
+    }
+
+    return normalized;
+  };
+
+  return {
+    representantLegal: trimPerson(governance.representantLegal, normalizeLegalRepresentativeRole),
+    membres: governance.membres
+      .map((member) => trimPerson(member, normalizeGovernanceMemberRole))
+      .filter((member): member is GovernancePerson => Boolean(member)),
+  };
+}