feat(personnes): saisir le sexe et nommer les liens de parenté en conséquence (#114)

- Champ Sexe (femme, homme, non précisé) dans la fiche en modification, à l'ajout
  d'une personne et dans une proposition de la famille ; relu « Sexe » dans les
  propositions à relire.
- Valeurs ramenées à male / female / null à l'écriture et à la lecture (anciennes
  valeurs M/F relues sans migration), valeur inconnue refusée (400). Export GEDCOM
  inchangé dans sa forme.
- Lien au survol genré quand le sexe est connu (Père, Tante, Cousine germaine,
  Belle-mère…), forme double sinon. Nommage déplacé dans utils/kinship : une
  fonction par langue reçoit le chemin complet (pas, personnes, sexe, année de
  naissance), pour brancher d'autres langues.
- Anglais : beau-parent distingué de parent par alliance selon l'ordre du chemin
  (Stepmother / Mother-in-law).
- Propositions à relire : le nom de la personne modifiée vient de l'avant lu en
  base quand la modification ne porte que le champ changé.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
IliesAllaliandClaude Opus 5.5 committed 2026-10-20 14:25:45 +02:00
1 parent 4dd0db9699
commit eaecac8fa5
24 files changed
+521 -117

No files matched your search

+2 -1
View File
@@ -4,6 +4,7 @@
*/
import { t } from '../i18n/index.js'
import { normalizeSex } from './kinship/index.js'
/**
* Convertit une date ISO (YYYY-MM-DD) en année
@@ -53,7 +54,7 @@ export function adaptGraphForGalaxy(apiGraph, _treeId) {
birthYear: dateToYear(p.birthDate),
deathYear: dateToYear(p.deathDate),
isAlive: isAlive(p.deathDate),
sex: p.sex || null,
sex: normalizeSex(p.sex),
note: p.notes || null,
birthDate: p.birthDate,
deathDate: p.deathDate,
+46
View File
@@ -0,0 +1,46 @@
import { kinshipFacts } from './facts.js'
// Mot genré quand le sexe de la personne nommée est connu, forme neutre ou double sinon
const g = (sex, male, female, neutral) => (sex === 'male' ? male : sex === 'female' ? female : neutral)
export default function nameEn(path) {
const { ups, downs, hasSpouse, sex } = kinshipFacts(path)
// « Spouse » reste neutre : husband et wife supposeraient un mariage
if (hasSpouse && ups === 0 && downs === 0) return 'Spouse'
if (hasSpouse) {
// L'anglais distingue l'ordre : le parent du conjoint (in-law) n'est pas le conjoint du parent (step)
const viaSpouseFirst = path.steps[0].move === 'spouse'
if (ups === 1 && downs === 0) return viaSpouseFirst ? g(sex, 'Father-in-law', 'Mother-in-law', 'Parent-in-law') : g(sex, 'Stepfather', 'Stepmother', 'Stepparent')
if (ups === 0 && downs === 1) return viaSpouseFirst ? g(sex, 'Stepson', 'Stepdaughter', 'Stepchild') : g(sex, 'Son-in-law', 'Daughter-in-law', 'Child-in-law')
if (ups === 1 && downs === 1) return g(sex, 'Brother-in-law', 'Sister-in-law', 'Brother/sister-in-law')
}
let label
if (downs === 0 && ups > 0) {
if (ups === 1) label = g(sex, 'Father', 'Mother', 'Parent')
else if (ups === 2) label = g(sex, 'Grandfather', 'Grandmother', 'Grandparent')
else if (ups === 3) label = g(sex, 'Great-grandfather', 'Great-grandmother', 'Great-grandparent')
else label = `Ancestor, ${ups} generations up`
} else if (ups === 0 && downs > 0) {
if (downs === 1) label = g(sex, 'Son', 'Daughter', 'Child')
else if (downs === 2) label = g(sex, 'Grandson', 'Granddaughter', 'Grandchild')
else if (downs === 3) label = g(sex, 'Great-grandson', 'Great-granddaughter', 'Great-grandchild')
else label = `Descendant, ${downs} generations down`
} else if (ups === 1 && downs === 1) label = g(sex, 'Brother', 'Sister', 'Sibling')
else if (ups === 2 && downs === 1) label = g(sex, 'Uncle', 'Aunt', 'Uncle/Aunt')
else if (ups === 3 && downs === 1) label = g(sex, 'Great-uncle', 'Great-aunt', 'Great-uncle/aunt')
else if (ups === 1 && downs === 2) label = g(sex, 'Nephew', 'Niece', 'Nephew/Niece')
else if (ups === 1 && downs === 3) label = g(sex, 'Grandnephew', 'Grandniece', 'Grandnephew/niece')
else if (ups >= 2 && downs >= 2) {
const degree = Math.min(ups, downs) - 1
const removed = Math.abs(ups - downs)
if (degree === 1 && removed === 0) label = 'First cousin'
else if (degree === 1) label = 'First cousin once removed'
else if (removed === 0) label = `Cousin, degree ${degree}`
else label = 'Distant cousin'
} else label = `${ups + downs} steps apart`
return hasSpouse ? `${label} by marriage` : label
}
+23
View File
@@ -0,0 +1,23 @@
// Sexe d'une personne tel que l'appli le lit : 'male', 'female' ou null (non précisé).
// L'import GEDCOM écrit 'male'/'female' ; d'anciennes données ont pu garder 'M'/'F'.
export function normalizeSex(value) {
const key = String(value ?? '').trim().toLowerCase()
if (key === 'male' || key === 'm') return 'male'
if (key === 'female' || key === 'f') return 'female'
return null
}
// Ce que le français et l'anglais lisent d'un chemin : générations montées et descendues
// (un frère ou une sœur compte une montée et une descente), passage par un conjoint, et sexe
// de la personne nommée, au bout du chemin.
export function kinshipFacts(path) {
let ups = 0, downs = 0, hasSpouse = false
for (const { move } of path.steps) {
if (move === 'up') ups++
else if (move === 'down') downs++
else if (move === 'sibling') { ups++; downs++ }
else if (move === 'spouse') hasSpouse = true
}
const target = path.steps[path.steps.length - 1]?.person
return { ups, downs, hasSpouse, sex: normalizeSex(target?.sex) }
}
+43
View File
@@ -0,0 +1,43 @@
import { kinshipFacts } from './facts.js'
// Mot genré quand le sexe de la personne nommée est connu, forme double sinon
const g = (sex, male, female, both) => (sex === 'male' ? male : sex === 'female' ? female : both)
export default function nameFr(path) {
const { ups, downs, hasSpouse, sex } = kinshipFacts(path)
if (hasSpouse && ups === 0 && downs === 0) return g(sex, 'Conjoint', 'Conjointe', 'Conjoint(e)')
if (hasSpouse) {
if (ups === 1 && downs === 0) return g(sex, 'Beau-père', 'Belle-mère', 'Beau-parent')
if (ups === 0 && downs === 1) return g(sex, 'Beau-fils', 'Belle-fille', 'Bel-enfant')
if (ups === 1 && downs === 1) return g(sex, 'Beau-frère', 'Belle-sœur', 'Beau-frère/sœur')
}
let label
if (downs === 0 && ups > 0) {
if (ups === 1) label = g(sex, 'Père', 'Mère', 'Parent')
else if (ups === 2) label = g(sex, 'Grand-père', 'Grand-mère', 'Grand-parent')
else if (ups === 3) label = g(sex, 'Arrière-grand-père', 'Arrière-grand-mère', 'Arrière-grand-parent')
else label = `${g(sex, 'Aïeul', 'Aïeule', 'Aïeul(e)')} ${ups}e gén.`
} else if (ups === 0 && downs > 0) {
if (downs === 1) label = g(sex, 'Fils', 'Fille', 'Enfant')
else if (downs === 2) label = g(sex, 'Petit-fils', 'Petite-fille', 'Petit-enfant')
else if (downs === 3) label = g(sex, 'Arrière-petit-fils', 'Arrière-petite-fille', 'Arrière-petit-enfant')
else label = `${g(sex, 'Descendant', 'Descendante', 'Descendant(e)')} ${downs}e gén.`
} else if (ups === 1 && downs === 1) label = g(sex, 'Frère', 'Sœur', 'Frère/Sœur')
else if (ups === 2 && downs === 1) label = g(sex, 'Oncle', 'Tante', 'Oncle/Tante')
else if (ups === 3 && downs === 1) label = g(sex, 'Grand-oncle', 'Grand-tante', 'Grand-oncle/tante')
else if (ups === 1 && downs === 2) label = g(sex, 'Neveu', 'Nièce', 'Neveu/Nièce')
else if (ups === 1 && downs === 3) label = g(sex, 'Petit-neveu', 'Petite-nièce', 'Petit-neveu/nièce')
else if (ups >= 2 && downs >= 2) {
const degree = Math.min(ups, downs) - 1
const removed = Math.abs(ups - downs)
if (degree === 1 && removed === 0) label = g(sex, 'Cousin germain', 'Cousine germaine', 'Cousin(e) germain(e)')
else if (degree === 1) label = g(sex, 'Petit-cousin', 'Petite-cousine', 'Petit-cousin(e)')
else if (removed === 0) label = `${g(sex, 'Cousin', 'Cousine', 'Cousin(e)')} ${degree}e degré`
else label = g(sex, 'Cousin éloigné', 'Cousine éloignée', 'Cousin(e) éloigné(e)')
} else label = `${ups + downs} liens`
return hasSpouse ? `${label} par alliance` : label
}
+24
View File
@@ -0,0 +1,24 @@
// Nom d'un lien de parenté, une fonction de nommage par langue (issue #114).
//
// Le chemin arrive complet : la personne de départ, puis chaque pas avec la personne atteinte.
// { from: { id, sex, birthYear }, steps: [{ move, person: { id, sex, birthYear } }] }
// move vaut 'up' (vers un parent), 'down' (vers un enfant), 'sibling' (vers un frère ou une sœur)
// ou 'spouse' (vers un conjoint). sex vaut 'male', 'female' ou null (non précisé).
//
// Chaque langue lit ce dont elle a besoin. Le français et l'anglais comptent les générations et
// regardent le sexe de la personne nommée (kinshipFacts). Une langue qui distingue le côté paternel
// ou maternel lit le sexe du premier parent du chemin (steps[0].person quand steps[0].move === 'up'),
// et les aînés et cadets se lisent sur les années de naissance de deux personnes du chemin.
// Brancher une langue : écrire ./<code>.js sur le modèle de ./fr.js et l'ajouter à NAMERS.
import { locale } from '../../i18n/index.js'
import nameFr from './fr.js'
import nameEn from './en.js'
export { kinshipFacts, normalizeSex } from './facts.js'
const NAMERS = { fr: nameFr, en: nameEn }
export function nameKinship(path, lang = locale) {
if (!path?.steps?.length) return ''
return (NAMERS[lang] || nameEn)(path)
}
+100
View File
@@ -0,0 +1,100 @@
import { describe, it, expect } from 'vitest'
import { kinshipFacts, nameKinship, normalizeSex } from './index.js'
import { computeRelationshipLabel, kinshipPath } from '../../components/galaxy/pathfinding.js'
// Chemin écrit à la main : moves = suite de pas, sex = sexe de la personne au bout
const path = (moves, sex = null, extra = {}) => ({
from: { id: 'moi', sex: null, birthYear: null },
steps: moves.map((move, i) => ({ move, person: { id: `p${i}`, sex: i === moves.length - 1 ? sex : null, birthYear: null, ...(extra[i] || {}) } })),
})
const both = (moves) => ['male', 'female', null].map((sex) => nameKinship(path(moves, sex), 'fr'))
const bothEn = (moves) => ['male', 'female', null].map((sex) => nameKinship(path(moves, sex), 'en'))
describe('nommage français', () => {
it('genre le mot quand le sexe est connu, garde la forme double sinon', () => {
expect(both(['up'])).toEqual(['Père', 'Mère', 'Parent'])
expect(both(['down'])).toEqual(['Fils', 'Fille', 'Enfant'])
expect(both(['sibling'])).toEqual(['Frère', 'Sœur', 'Frère/Sœur'])
expect(both(['up', 'up'])).toEqual(['Grand-père', 'Grand-mère', 'Grand-parent'])
expect(both(['down', 'down'])).toEqual(['Petit-fils', 'Petite-fille', 'Petit-enfant'])
expect(both(['up', 'up', 'up'])).toEqual(['Arrière-grand-père', 'Arrière-grand-mère', 'Arrière-grand-parent'])
expect(both(['down', 'down', 'down'])).toEqual(['Arrière-petit-fils', 'Arrière-petite-fille', 'Arrière-petit-enfant'])
expect(both(['up', 'sibling'])).toEqual(['Oncle', 'Tante', 'Oncle/Tante'])
expect(both(['up', 'up', 'sibling'])).toEqual(['Grand-oncle', 'Grand-tante', 'Grand-oncle/tante'])
expect(both(['sibling', 'down'])).toEqual(['Neveu', 'Nièce', 'Neveu/Nièce'])
expect(both(['sibling', 'down', 'down'])).toEqual(['Petit-neveu', 'Petite-nièce', 'Petit-neveu/nièce'])
expect(both(['up', 'sibling', 'down'])).toEqual(['Cousin germain', 'Cousine germaine', 'Cousin(e) germain(e)'])
expect(both(['up', 'up', 'sibling', 'down'])).toEqual(['Petit-cousin', 'Petite-cousine', 'Petit-cousin(e)'])
expect(both(['up', 'up', 'sibling', 'down', 'down'])).toEqual(['Cousin 2e degré', 'Cousine 2e degré', 'Cousin(e) 2e degré'])
expect(both(['up', 'up', 'up', 'sibling', 'down', 'down'])).toEqual(['Cousin éloigné', 'Cousine éloignée', 'Cousin(e) éloigné(e)'])
expect(both(['up', 'up', 'up', 'up'])).toEqual(['Aïeul 4e gén.', 'Aïeule 4e gén.', 'Aïeul(e) 4e gén.'])
})
it('alliances', () => {
expect(both(['spouse'])).toEqual(['Conjoint', 'Conjointe', 'Conjoint(e)'])
expect(both(['spouse', 'up'])).toEqual(['Beau-père', 'Belle-mère', 'Beau-parent'])
expect(both(['down', 'spouse'])).toEqual(['Beau-fils', 'Belle-fille', 'Bel-enfant'])
expect(both(['spouse', 'sibling'])).toEqual(['Beau-frère', 'Belle-sœur', 'Beau-frère/sœur'])
expect(both(['spouse', 'up', 'sibling'])).toEqual(['Oncle par alliance', 'Tante par alliance', 'Oncle/Tante par alliance'])
})
it('le sexe des personnes du milieu ne change pas le mot (seule la personne nommée compte)', () => {
const p = path(['up', 'sibling'], 'female', { 0: { sex: 'male' } })
expect(nameKinship(p, 'fr')).toBe('Tante')
})
})
describe('nommage anglais', () => {
it('genre le mot quand le sexe est connu', () => {
expect(bothEn(['up'])).toEqual(['Father', 'Mother', 'Parent'])
expect(bothEn(['down', 'down'])).toEqual(['Grandson', 'Granddaughter', 'Grandchild'])
expect(bothEn(['sibling'])).toEqual(['Brother', 'Sister', 'Sibling'])
expect(bothEn(['up', 'sibling'])).toEqual(['Uncle', 'Aunt', 'Uncle/Aunt'])
expect(bothEn(['sibling', 'down'])).toEqual(['Nephew', 'Niece', 'Nephew/Niece'])
expect(bothEn(['spouse', 'up'])).toEqual(['Father-in-law', 'Mother-in-law', 'Parent-in-law'])
expect(bothEn(['up', 'spouse'])).toEqual(['Stepfather', 'Stepmother', 'Stepparent'])
expect(bothEn(['spouse', 'down'])).toEqual(['Stepson', 'Stepdaughter', 'Stepchild'])
expect(bothEn(['down', 'spouse'])).toEqual(['Son-in-law', 'Daughter-in-law', 'Child-in-law'])
expect(bothEn(['spouse', 'sibling'])).toEqual(['Brother-in-law', 'Sister-in-law', 'Brother/sister-in-law'])
expect(bothEn(['spouse'])).toEqual(['Spouse', 'Spouse', 'Spouse'])
expect(bothEn(['up', 'sibling', 'down'])).toEqual(['First cousin', 'First cousin', 'First cousin'])
})
it('une langue inconnue retombe sur l’anglais', () => {
expect(nameKinship(path(['up'], 'female'), 'xx')).toBe('Mother')
})
})
describe('chemin de parenté depuis le chemin BFS', () => {
// moi → union de mes parents → mon père → union des grands-parents → ma tante
const edgePath = [
{ type: 'filiation', id: 'e1' },
{ type: 'couple', id: 'u1' },
{ type: 'filiation', id: 'e2' },
{ type: 'filiation', id: 'e3' },
]
const nodePath = ['p-1', 'u-1', 'p-2', 'u-2', 'p-3']
const people = { 'p-1': { id: 1, sex: 'female', birthYear: 1990 }, 'p-2': { id: 2, sex: 'M', birthYear: 1960 }, 'p-3': { id: 3, sex: 'F', birthYear: 1955 } }
it('garde chaque pas et la personne atteinte, pour les langues qui en ont besoin', () => {
const k = kinshipPath(edgePath, nodePath, (id) => people[id])
expect(k.from).toEqual({ id: 1, sex: 'female', birthYear: 1990 })
expect(k.steps).toEqual([
{ move: 'up', person: { id: 2, sex: 'male', birthYear: 1960 } },
{ move: 'sibling', person: { id: 3, sex: 'female', birthYear: 1955 } },
])
expect(kinshipFacts(k)).toEqual({ ups: 2, downs: 1, hasSpouse: false, sex: 'female' })
})
it('nomme avec le sexe de la personne au bout', () => {
expect(computeRelationshipLabel(edgePath, nodePath, (id) => people[id])).toBe('Tante')
expect(computeRelationshipLabel(edgePath)).toBe('Oncle/Tante')
})
})
describe('normalizeSex', () => {
it('lit les anciennes valeurs M/F et le reste en non précisé', () => {
expect(['male', 'M', 'female', 'f', null, '', 'U'].map(normalizeSex)).toEqual(['male', 'male', 'female', 'female', null, null, null])
})
})
+10
View File
@@ -0,0 +1,10 @@
import { t } from '../i18n/index.js'
export { normalizeSex } from './kinship/facts.js'
// Choix proposés à la saisie du sexe d'une personne (issue #114) : null = non précisé
export const SEX_CHOICES = [
{ value: 'female', label: t('Femme') },
{ value: 'male', label: t('Homme') },
{ value: null, label: t('Non précisé') },
]