fix: ne plus geler la sauvegarde du plan sur une confirmation GPS

Déplacer un arbre géolocalisé demande une confirmation, car cela réécrit
son relevé terrain. Mais le verrou portait sur la sauvegarde entière : une
confirmation abandonnée sans réponse rendait planches, objets et tous les
autres arbres non enregistrables — silencieusement, et sans issue puisque
le plan n'a pas de bouton « Enregistrer » manuel.

- la sauvegarde diffère les seuls arbres dont la confirmation est
  pendante, et le toast dit combien ont été laissés de côté ;
- l'auto-save n'est plus bloquée par une attente ;
- un indicateur « n position GPS à confirmer » rend le verrou visible ;
- les attentes sont purgées au changement de parcelle et au démontage,
  la confirmation ne pouvant plus y être tranchée.

Le bandeau du plan signale aussi les arbres dont le relevé GPS tombe hors
de la parcelle affichée : ils étaient dessinés à l'origine sans
avertissement, ce qui invitait précisément à les déplacer et donc à
écraser leurs coordonnées réelles.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: Guigui64260

src/app/jardin/page.tsx

@@ -49,6 +49,7 @@ import { useFondPlan } from "@/hooks/use-fond-plan"
 import { calibrerFond, distance, formatDistance } from "@/lib/plan-fond-utils"
 import { croissanceCulture, envergureArbreADate } from "@/lib/plan-croissance"
 import { projeterGpsSurPlan, projeterPlanSurGps } from "@/lib/gps-plan-utils"
+import { partitionnerArbresPourSauvegarde } from "@/lib/plan-sauvegarde"
 
 // Palier 4 (perf) : dialogs lourds chargés à la demande, hors du bundle
 // initial de l'éditeur (le plus gros écran client de l'app).
@@ -380,6 +381,22 @@ function JardinContent() {
     }
   }, [selectedParcelleId])
 
+  /**
+   * QA 2026-07-30 — Une attente de confirmation GPS ne doit pas survivre au
+   * changement de parcelle ni au démontage : l'arbre concerné n'est plus à
+   * l'écran, sa confirmation ne peut plus être tranchée, et le compteur
+   * resterait affiché sans action possible.
+   */
+  React.useEffect(() => {
+    const purger = () => {
+      if (pendingGpsMovesRef.current.size === 0) return
+      pendingGpsMovesRef.current.clear()
+      setPendingGpsMovesCount(0)
+    }
+    purger()
+    return purger
+  }, [selectedParcelleId])
+
   // Charger les especes pour la création de cultures
   const fetchEspeces = React.useCallback(async () => {
     try {
@@ -596,7 +613,15 @@ function JardinContent() {
     selectedParcelleId,
   ])
 
-  const arbresGpsProjetables = React.useMemo(() => {
+  /**
+   * QA 2026-07-30 — On comptait seulement les arbres alignables. Un arbre dont
+   * le relevé GPS tombe hors de la parcelle affichée n'est pas projetable : il
+   * était dessiné à l'origine du plan sans le moindre avertissement, ce qui
+   * invitait à le déplacer… et donc à écraser son relevé terrain par une
+   * position fictive. On distingue désormais les deux populations.
+   */
+  const statsArbresGps = React.useMemo(() => {
+    const inerte = { projetables: 0, nonProjetables: 0 }
     if (
       !selectedParcelleId ||
       selectedParcelleId === "none" ||
@@ -607,25 +632,36 @@ function JardinContent() {
       !fond.contour ||
       !fondDimensions
     ) {
-      return 0
+      return inerte
     }
-    return arbres.filter(
-      (arbre) =>
-        arbre.parcelleGeoId === selectedParcelleId &&
-        arbre.gpsLat != null &&
-        arbre.gpsLng != null &&
-        projeterGpsSurPlan({
-          gpsLat: arbre.gpsLat,
-          gpsLng: arbre.gpsLng,
-          geometryGeoJson: selectedParcelle.geometry,
-          contour: fond.contour!,
-          fond,
-          imageWidth: fondDimensions.width,
-          imageHeight: fondDimensions.height,
-        }) !== null
-    ).length
+    let projetables = 0
+    let nonProjetables = 0
+    for (const arbre of arbres) {
+      if (
+        arbre.parcelleGeoId !== selectedParcelleId ||
+        arbre.gpsLat == null ||
+        arbre.gpsLng == null
+      ) {
+        continue
+      }
+      const projection = projeterGpsSurPlan({
+        gpsLat: arbre.gpsLat,
+        gpsLng: arbre.gpsLng,
+        geometryGeoJson: selectedParcelle.geometry,
+        contour: fond.contour!,
+        fond,
+        imageWidth: fondDimensions.width,
+        imageHeight: fondDimensions.height,
+      })
+      if (projection !== null) projetables += 1
+      else nonProjetables += 1
+    }
+    return { projetables, nonProjetables }
   }, [arbres, fond, fondDimensions, selectedParcelle, selectedParcelleId])
 
+  const arbresGpsProjetables = statsArbresGps.projetables
+  const arbresGpsHorsCadre = statsArbresGps.nonProjetables
+
   const convertirPositionPlanEnGps = React.useCallback(
     (arbre: Arbre, x: number, y: number) => {
       if (
@@ -948,9 +984,13 @@ function JardinContent() {
 
   // Sauvegarder les positions
   const handleSave = async () => {
-    // Une position GPS en cours de confirmation ne doit jamais être persistée
-    // avec l'ancien relevé terrain.
-    if (pendingGpsMovesRef.current.size > 0) return
+    // QA 2026-07-30 — Une position GPS en attente de confirmation ne doit pas
+    // être persistée, mais le verrou portait sur TOUTE la sauvegarde : une
+    // modale abandonnée sans réponse rendait planches, objets et tous les
+    // autres arbres non sauvegardables, silencieusement et sans issue (il n'y a
+    // pas de bouton « Enregistrer » manuel). Cf. src/lib/plan-sauvegarde.ts.
+    const { aEcrire: arbresAEcrire, differes: arbresDifferes } =
+      partitionnerArbresPourSauvegarde(arbres, pendingGpsMovesRef.current.keys())
     setSaving(true)
     try {
       const planchePromises = planches.map(p =>
@@ -984,7 +1024,7 @@ function JardinContent() {
         })
       )
 
-      const arbrePromises = arbres.map(a =>
+      const arbrePromises = arbresAEcrire.map(a =>
         fetch(`/api/arbres/${a.id}`, {
           method: "PUT",
           headers: { "Content-Type": "application/json" },
@@ -1028,7 +1068,9 @@ function JardinContent() {
       if (results.every(r => r.ok)) {
         toast({
           title: "Plan sauvegardé",
-          description: "Les positions ont été enregistrées"
+          description: arbresDifferes.length > 0
+            ? `Positions enregistrées. ${arbresDifferes.length} arbre${arbresDifferes.length > 1 ? "s" : ""} en attente de confirmation GPS ${arbresDifferes.length > 1 ? "n'ont" : "n'a"} pas été déplacé${arbresDifferes.length > 1 ? "s" : ""}.`
+            : "Les positions ont été enregistrées"
         })
         setHasChanges(false)
       } else {
@@ -1051,7 +1093,10 @@ function JardinContent() {
 
   // Auto-save débounced (1s après le dernier changement)
   React.useEffect(() => {
-    if (!hasChanges || saving || pendingGpsMovesCount > 0) return
+    // `pendingGpsMovesCount` ne bloque plus l'auto-save (cf. handleSave) : il
+    // reste dans les dépendances pour relancer une sauvegarde dès qu'une
+    // confirmation est tranchée.
+    if (!hasChanges || saving) return
     if (autoSaveTimer.current) clearTimeout(autoSaveTimer.current)
     autoSaveTimer.current = setTimeout(() => {
       handleSave()
@@ -1803,6 +1848,14 @@ function JardinContent() {
             {saving && (
               <span className="text-xs text-muted-foreground animate-pulse">Sauvegarde...</span>
             )}
+            {pendingGpsMovesCount > 0 && (
+              <span
+                className="rounded-md bg-amber-100 px-2 py-1 text-xs font-medium text-amber-800"
+                title="Confirmez ou annulez le déplacement pour enregistrer la nouvelle position GPS."
+              >
+                {pendingGpsMovesCount} position GPS à confirmer
+              </span>
+            )}
           </div>
 
           <div className="flex w-full flex-wrap items-center gap-2 xl:hidden">
@@ -1907,6 +1960,11 @@ function JardinContent() {
             {saving && (
               <span className="w-full text-xs text-muted-foreground animate-pulse">Sauvegarde...</span>
             )}
+            {pendingGpsMovesCount > 0 && (
+              <span className="w-full rounded-md bg-amber-100 px-2 py-1 text-xs font-medium text-amber-800">
+                {pendingGpsMovesCount} position GPS à confirmer
+              </span>
+            )}
           </div>
         </div>
       </header>
@@ -3010,6 +3068,14 @@ function JardinContent() {
                     le fond géoréférencé.
                   </p>
                 )}
+                {arbresGpsHorsCadre > 0 && (
+                  <p className="text-amber-700">
+                    • {arbresGpsHorsCadre} arbre{arbresGpsHorsCadre > 1 ? "s" : ""} {arbresGpsHorsCadre > 1 ? "ont" : "a"} un
+                    relevé GPS situé hors de cette parcelle : {arbresGpsHorsCadre > 1 ? "leur position" : "sa position"} sur
+                    le plan n&apos;est pas significative. Corrigez le relevé depuis la fiche de l&apos;arbre plutôt
+                    qu&apos;en le déplaçant ici, ce qui écraserait les coordonnées réelles.
+                  </p>
+                )}
               </CardContent>
             </Card>
           </div>

src/lib/__tests__/plan-sauvegarde.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest"
+
+import { partitionnerArbresPourSauvegarde } from "../plan-sauvegarde"
+
+const arbres = [
+  { id: 1, nom: "Pommier" },
+  { id: 2, nom: "Poirier" },
+  { id: 3, nom: "Cerisier" },
+]
+
+describe("partitionnerArbresPourSauvegarde", () => {
+  it("écrit tous les arbres quand aucune confirmation n'est pendante", () => {
+    const { aEcrire, differes } = partitionnerArbresPourSauvegarde(arbres, [])
+
+    expect(aEcrire).toHaveLength(3)
+    expect(differes).toEqual([])
+  })
+
+  it("diffère le seul arbre en attente et laisse passer les autres", () => {
+    const { aEcrire, differes } = partitionnerArbresPourSauvegarde(arbres, [2])
+
+    expect(aEcrire.map(a => a.id)).toEqual([1, 3])
+    expect(differes.map(a => a.id)).toEqual([2])
+  })
+
+  it("ne bloque jamais la sauvegarde entière, même avec plusieurs attentes", () => {
+    const { aEcrire, differes } = partitionnerArbresPourSauvegarde(arbres, [1, 3])
+
+    // Le cœur du correctif : une confirmation abandonnée gelait tout le plan.
+    expect(aEcrire.map(a => a.id)).toEqual([2])
+    expect(differes.map(a => a.id)).toEqual([1, 3])
+  })
+
+  it("ignore les identifiants en attente qui ne sont pas à l'écran", () => {
+    const { aEcrire, differes } = partitionnerArbresPourSauvegarde(arbres, [99])
+
+    expect(aEcrire).toHaveLength(3)
+    expect(differes).toEqual([])
+  })
+
+  it("ne renvoie aucun arbre à écrire quand tous sont en attente", () => {
+    const { aEcrire, differes } = partitionnerArbresPourSauvegarde(arbres, [1, 2, 3])
+
+    expect(aEcrire).toEqual([])
+    expect(differes).toHaveLength(3)
+  })
+
+  it("ne modifie pas le tableau source", () => {
+    const source = [...arbres]
+    partitionnerArbresPourSauvegarde(source, [2])
+
+    expect(source).toEqual(arbres)
+  })
+})

src/lib/plan-sauvegarde.ts

@@ -0,0 +1,39 @@
+/**
+ * Règle de sauvegarde du plan 2D face aux confirmations GPS en attente.
+ *
+ * Déplacer un arbre géolocalisé réécrit son relevé terrain : la nouvelle
+ * position n'est donc persistée qu'après confirmation explicite (correctif du
+ * 2026-07-26). Le verrou initial portait sur la sauvegarde entière, si bien
+ * qu'une confirmation abandonnée sans réponse rendait planches, objets et tous
+ * les autres arbres non enregistrables — silencieusement, et sans issue puisque
+ * le plan n'a pas de bouton « Enregistrer » manuel (QA 2026-07-30).
+ *
+ * La règle correcte tient en deux points : ne jamais écrire un arbre dont la
+ * confirmation est pendante, et ne jamais laisser cette attente bloquer le
+ * reste du plan.
+ */
+
+export type ElementPositionne = { id: number }
+
+export type PartitionSauvegardePlan<T extends ElementPositionne> = {
+  /** Arbres à écrire immédiatement. */
+  aEcrire: T[]
+  /** Arbres dont l'écriture attend une confirmation GPS. */
+  differes: T[]
+}
+
+export function partitionnerArbresPourSauvegarde<T extends ElementPositionne>(
+  arbres: readonly T[],
+  idsEnAttenteConfirmationGps: Iterable<number>,
+): PartitionSauvegardePlan<T> {
+  const enAttente = new Set(idsEnAttenteConfirmationGps)
+  if (enAttente.size === 0) return { aEcrire: [...arbres], differes: [] }
+
+  const aEcrire: T[] = []
+  const differes: T[] = []
+  for (const arbre of arbres) {
+    if (enAttente.has(arbre.id)) differes.push(arbre)
+    else aEcrire.push(arbre)
+  }
+  return { aEcrire, differes }
+}