Implemente le mini-jeu Memory (retournement de cartes, mode paire/single)

document_engine/labels/memory_config.py (nouveau) : modele de donnees,
meme convention resolve_X/sanitize_X que quiz_config.py/
association_config.py - DEFAULT_MEMORY_CONFIG, sanitize_memory_config.
Chaque carte a un recto ET un verso, chacun avec image/texte
independants et tous deux optionnels ; seul le verso doit avoir au
moins l'un des deux non vide (rien a reveler/apparier sinon) - le
recto peut rester entierement vide (dos de carte generique "?" par
defaut). Liste tronquee a MAX_CARDS=8.

Cote serveur, routes/document/document_element_update.py revalide
desormais aussi memory avant persistance. Le rendu (_render_memory)
affiche un resume reel (nombre de cartes, mode) et, des qu'au moins
une carte existe, un plateau de retournement REELEMENT interactif en
Mode Apercu (_render_memory_player) : en mode "paire", chaque carte
definie est DUPLIQUEE en deux instances partageant le meme card_index
(appariement classique) ; en mode "single", une seule instance par
carte (simple retournement, sans appariement - "c'est donc un
retourner de carte classique plus un jeu memory"). Les instances sont
melangees (random.shuffle, documente dans CODE_QUALITY.md) puis
embarquees en JSON dans data-memory-config.

Cote editeur, le panneau Proprietes propose un bascule segmentee
Paire/Simple et une liste de cartes repetable, chaque carte avec ses
deux faces (recto/verso) editables independamment (image + texte).
Extrait au passage forgeDocEscapeHtml (ex-forgeDocEscapeForTextarea,
generalise pour couvrir aussi les attributs) reutilise pour les deux
mini-jeux. Le plateau jouable (static/document/js/document-editor.js)
est une vraie carte-retournement CSS 3D (perspective/rotateY), contenu
de chaque face construit via DOM (textContent/img.src, jamais
innerHTML avec le texte du createur - meme precaution que le plateau
Association) : bon appariement verrouille en vert, mauvais reinitialise
apres un delai, ecran de resultat une fois le jeu termine (les deux
modes), et un "Recommencer" qui remelange reellement les cartes
(Fisher-Yates cote client).

Tests : 11 tests purs (tests/document/test_memory_config.py, sans
Flask, dont un qui verifie explicitement la duplication en mode paire
vs son absence en mode single) + 1 test de route verifiant la
sanitization a l'ecriture.

SKIP=djlint : backlog H021 pre-existant, aucun template touche ici.
ruff/mypy --strict/vulture/bandit/import-linter/eslint/stylelint tous
verts ; 62 tests document verifies frais. Verification manuelle live
complete : ajout, sanitization sur carte invalide, rendu du plateau,
et simulation DOM du gameplay reel dans les DEUX modes (mode paire :
mauvais appariement puis bon appariement puis jeu complet ; mode
single : retournement puis jeu complet) - script de diagnostic non
conserve dans le depot.

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

document_engine/__init__.py

@@ -41,6 +41,13 @@ from .labels.element_kind_labels import (
     SHAPE_KINDS,
     element_default_attributes,
 )
+from .labels.memory_config import (
+    CARD_MODES,
+    DEFAULT_MEMORY_CONFIG,
+    MAX_CARDS,
+    MIN_CARDS,
+    sanitize_memory_config,
+)
 from .labels.quiz_config import (
     DEFAULT_QUIZ_CONFIG,
     MAX_CHOICES,
@@ -53,14 +60,18 @@ from .labels.quiz_config import (
 from .rendering.render_document_element import render_document, render_document_element
 
 __all__ = [
+    "CARD_MODES",
     "CONTENT_KINDS",
     "DEFAULT_ASSOCIATION_CONFIG",
+    "DEFAULT_MEMORY_CONFIG",
     "DEFAULT_QUIZ_CONFIG",
     "ELEMENT_KIND_LABELS",
     "ELEMENT_LIBRARY",
+    "MAX_CARDS",
     "MAX_CHOICES",
     "MAX_PAIRS",
     "MAX_TIMER_SECONDS",
+    "MIN_CARDS",
     "MIN_CHOICES",
     "MIN_PAIRS",
     "MIN_TIMER_SECONDS",
@@ -76,6 +87,7 @@ __all__ = [
     "render_document",
     "render_document_element",
     "sanitize_association_config",
+    "sanitize_memory_config",
     "sanitize_quiz_config",
     "update_document_element_attributes",
 ]

document_engine/labels/element_kind_labels.py

@@ -6,6 +6,7 @@ défaut posés à la création de chaque type."""
 from typing import Any
 
 from .association_config import DEFAULT_ASSOCIATION_CONFIG
+from .memory_config import DEFAULT_MEMORY_CONFIG
 from .quiz_config import DEFAULT_QUIZ_CONFIG
 
 SHAPE_KINDS = ("rectangle", "cercle", "triangle", "trait")
@@ -86,11 +87,14 @@ def element_default_attributes(kind: str) -> dict[str, Any]:
     if kind == "association":
         # Même raison de copie que "quiz" ci-dessus (voir association_config.py).
         return {**DEFAULT_ASSOCIATION_CONFIG, "pairs": list(DEFAULT_ASSOCIATION_CONFIG["pairs"])}
+    if kind == "memory":
+        # Même raison de copie que "quiz"/"association" ci-dessus (voir memory_config.py).
+        return {**DEFAULT_MEMORY_CONFIG, "cards": list(DEFAULT_MEMORY_CONFIG["cards"])}
     if kind in MINIGAME_KINDS:
         # Panneau Propriétés minimal (voir PLAN.md §3.5, dernier
         # paragraphe : "état par défaut en attendant sa spécification") —
         # décision actée : cœur complet + mini-jeux en emplacement
-        # réservé (memory/mots/scenario/zones), formulaires de contenu
-        # dédiés = chantier séparé.
+        # réservé (mots/scenario/zones), formulaires de contenu dédiés =
+        # chantier séparé.
         return {"theme_color": "#ff5f2e"}
     return {}

document_engine/labels/labels.md

@@ -13,11 +13,11 @@ toujours en position absolue (`parent_id = NULL`).
 être top-niveau ou enfants d'une rangée.
 
 ## `MINIGAME_KINDS: tuple[str, ...]`
-`("quiz", "association", "memory", "mots", "scenario", "zones")` — `"quiz"`
-et `"association"` sont implémentés (voir `quiz_config.py`/
-`association_config.py` ci-dessous) ; les 4 autres gardent un panneau
-Propriétés minimal (emplacement réservé), formulaires de contenu dédiés
-hors périmètre de cette passe.
+`("quiz", "association", "memory", "mots", "scenario", "zones")` —
+`"quiz"`, `"association"` et `"memory"` sont implémentés (voir
+`quiz_config.py`/`association_config.py`/`memory_config.py` ci-dessous) ;
+les 3 autres gardent un panneau Propriétés minimal (emplacement réservé),
+formulaires de contenu dédiés hors périmètre de cette passe.
 
 ## `ELEMENT_LIBRARY: dict[str, dict[str, Any]]`
 Bibliothèque affichée dans le panneau gauche, groupée par catégorie
@@ -38,8 +38,9 @@ Attributs posés à la création d'un élément de ce type (voir
   texte (`content/style` + `bold/italic/underline/align/color`),
   image (`src/alt`), bouton (`label/target`), rangée (`gap/align/justify`),
   quiz (`DEFAULT_QUIZ_CONFIG`, voir `quiz_config.py`), association
-  (`DEFAULT_ASSOCIATION_CONFIG`, voir `association_config.py`), autre
-  mini-jeu (`theme_color`), ou `{}` pour un `kind` inconnu.
+  (`DEFAULT_ASSOCIATION_CONFIG`, voir `association_config.py`), memory
+  (`DEFAULT_MEMORY_CONFIG`, voir `memory_config.py`), autre mini-jeu
+  (`theme_color`), ou `{}` pour un `kind` inconnu.
 - **Exceptions** : aucune.
 
 ## `quiz_config.py` — modèle de données du mini-jeu Quiz
@@ -102,3 +103,39 @@ levée qui ferait échouer tout le reste du mini-jeu). La liste finale est
 tronquée à `MAX_PAIRS`.
 - **Retour** : dict complet (mêmes clés que `DEFAULT_ASSOCIATION_CONFIG`).
 - **Exceptions** : aucune.
+
+## `memory_config.py` — modèle de données du mini-jeu Memory
+
+Troisième mini-jeu implémenté : l'apprenant retourne des cartes pour
+constituer des paires identiques (mode `"paire"`) ou simplement révéler
+chaque carte une fois (mode `"single"`, sans appariement — voir
+`document_engine/rendering/render_document_element.py`::
+`_render_memory_player`). Même convention que `quiz_config.py`.
+
+### `MIN_CARDS`, `MAX_CARDS: int`
+Bornes de validation (`2`/`8` cartes DÉFINIES par le créateur — en mode
+`"paire"`, le plateau affiche le double, chaque carte étant dupliquée).
+`MIN_CARDS` n'est pas imposé par `sanitize_memory_config` (même logique
+que `MIN_PAIRS` côté Association) — recommandation pour le panneau
+Propriétés, pas une contrainte technique du rendu.
+
+### `CARD_MODES: tuple[str, ...]`
+`("paire", "single")`.
+
+### `DEFAULT_MEMORY_CONFIG: dict[str, Any]`
+`{"theme_color": "#ff5f2e", "mode": "paire", "cards": []}`.
+
+### `sanitize_memory_config(raw_config: Any) -> dict[str, Any]`
+Valide/nettoie une config de memory arbitraire (JSON venu du client) —
+jamais ne lève, renvoie toujours un dict COMPLET fusionné sur
+`DEFAULT_MEMORY_CONFIG`. `mode` retombe sur `"paire"` s'il n'est pas dans
+`CARD_MODES`. Chaque carte de `raw_config["cards"]` est validée
+indépendamment (voir `_sanitize_card`/`_sanitize_card_face`, privées) :
+chaque face (`recto`/`verso`) a un `image` et un `text` indépendants et
+tous deux optionnels, MAIS le `verso` doit avoir au moins l'un des deux
+non vide (rien à révéler/apparier sinon) — le `recto`, lui, peut rester
+entièrement vide (dos de carte générique "?" par défaut côté rendu). Une
+carte invalide est silencieusement supprimée de la liste. La liste finale
+est tronquée à `MAX_CARDS`.
+- **Retour** : dict complet (mêmes clés que `DEFAULT_MEMORY_CONFIG`).
+- **Exceptions** : aucune.

document_engine/labels/memory_config.py

@@ -0,0 +1,60 @@
+"""Modèle de données du mini-jeu Memory (voir docs/plan/PLAN.md §3.2) —
+l'apprenant retourne des cartes pour constituer des paires identiques
+(mode "paire") ou simplement révéler chaque carte une fois (mode
+"single", un retournement classique sans appariement). Même convention
+resolve_X/sanitize_X que quiz_config.py/association_config.py (aucun
+import croisé)."""
+
+from typing import Any
+
+MIN_CARDS = 2
+MAX_CARDS = 8
+CARD_MODES = ("paire", "single")
+DEFAULT_MODE = "paire"
+
+DEFAULT_MEMORY_CONFIG: dict[str, Any] = {
+    "theme_color": "#ff5f2e",
+    "mode": DEFAULT_MODE,
+    "cards": [],
+}
+
+
+def _sanitize_card_face(raw: Any) -> dict[str, str]:
+    """Une face de carte (recto ou verso) — image et texte tous deux
+    optionnels et indépendants (le créateur peut mettre l'un, l'autre, ou
+    les deux, voir docs/plan/PLAN.md)."""
+    if not isinstance(raw, dict):
+        return {"image": "", "text": ""}
+    return {
+        "image": str(raw.get("image", "")).strip(),
+        "text": str(raw.get("text", "")).strip(),
+    }
+
+
+def _sanitize_card(raw: Any) -> dict[str, Any] | None:
+    """None si la carte est invalide — un verso entièrement vide (ni image
+    ni texte) n'aurait rien à révéler/apparier, contrairement au recto qui
+    peut légitimement rester vide (dos de carte générique par défaut)."""
+    if not isinstance(raw, dict):
+        return None
+    recto = _sanitize_card_face(raw.get("recto"))
+    verso = _sanitize_card_face(raw.get("verso"))
+    if not verso["image"] and not verso["text"]:
+        return None
+    return {"recto": recto, "verso": verso}
+
+
+def sanitize_memory_config(raw_config: Any) -> dict[str, Any]:
+    config = dict(DEFAULT_MEMORY_CONFIG)
+    if not isinstance(raw_config, dict):
+        return config
+    theme_color = raw_config.get("theme_color")
+    if isinstance(theme_color, str) and theme_color:
+        config["theme_color"] = theme_color
+    mode = raw_config.get("mode")
+    config["mode"] = mode if mode in CARD_MODES else DEFAULT_MODE
+    raw_cards = raw_config.get("cards")
+    if isinstance(raw_cards, list):
+        cards = [c for c in (_sanitize_card(item) for item in raw_cards) if c is not None]
+        config["cards"] = cards[:MAX_CARDS]
+    return config

document_engine/rendering/render_document_element.py

@@ -250,6 +250,64 @@ def _render_association(el: dict[str, Any], _children_by_parent: dict[int | None
     )
 
 
+def _render_memory_player(config: dict[str, Any]) -> str:
+    """Plateau de Memory RÉELLEMENT interactif — affiché uniquement en
+    Mode Aperçu, même principe que _render_quiz_player/
+    _render_association_player. En mode "paire", chaque carte définie par
+    le créateur est dupliquée en deux instances partageant le même
+    card_index (l'appariement se fait dessus) ; en mode "single", une
+    seule instance par carte (simple retournement, sans appariement).
+    Les instances sont mélangées une seule fois ici (jamais recalculées
+    à chaque rendu répété d'un même Aperçu, voir la remarque dans
+    static/document/js/document-editor.js sur la ré-init au
+    rafraîchissement du canevas) puis embarquées en JSON."""
+    cards = config["cards"]
+    mode = config["mode"]
+    instances = []
+    for i, card in enumerate(cards):
+        instances.append({"card_index": i, "recto": card["recto"], "verso": card["verso"]})
+        if mode == "paire":
+            instances.append({"card_index": i, "recto": card["recto"], "verso": card["verso"]})
+    random.shuffle(instances)  # NOSONAR python:S2245 - melange d'affichage, pas un usage cryptographique
+    config_json = html_lib.escape(json.dumps({"mode": mode, "cards": instances}), quote=True)
+    return (
+        f'<div class="docMemoryPlayer" data-memory-config="{config_json}">'
+        f'<div class="docMemoryCardWrap">'
+        f'<div class="docQuizKicker">Memory</div>'
+        f'<div class="docAssocTitle docMemoryTitle"></div>'
+        f'<div class="docAssocMeta"><span class="docMemoryProg"></span></div>'
+        f'<div class="docMemoryGrid"></div>'
+        f"</div>"
+        f'<div class="docAssocResultCard docMemoryResultCard" style="display:none;">'
+        f'<div class="docAssocResultBig">✓</div>'
+        f'<div class="docAssocResultSub docMemoryResultSub"></div>'
+        f'<button type="button" class="docAssocRestartBtn docMemoryRestartBtn">Recommencer</button>'
+        f"</div></div>"
+    )
+
+
+def _render_memory(el: dict[str, Any], _children_by_parent: dict[int | None, list[dict[str, Any]]]) -> str:
+    from ..labels.memory_config import sanitize_memory_config
+
+    config = sanitize_memory_config(el["attributes"])
+    theme_color = html_lib.escape(str(config["theme_color"]))
+    card_count = len(config["cards"])
+    card_label = "carte" if card_count <= 1 else "cartes"
+    mode_label = "mode paire" if config["mode"] == "paire" else "mode simple"
+    subtitle = f"{card_count} {card_label} · {mode_label}"
+    player_html = _render_memory_player(config) if config["cards"] else ""
+    return (
+        f'<div class="docMinigame" data-element-id="{el["id"]}" data-kind="memory" '
+        f'style="border-color:{theme_color};">'
+        f'<div class="docMinigameBadge">'
+        f'<span class="docMinigameLabel">Memory</span>'
+        f'<span class="docMinigamePlaceholder">{html_lib.escape(subtitle)}</span>'
+        f"</div>"
+        f"{player_html}"
+        f"</div>"
+    )
+
+
 def _render_unknown(el: dict[str, Any], _children_by_parent: dict[int | None, list[dict[str, Any]]]) -> str:
     return f'<div class="docUnknown" data-element-id="{el["id"]}">Type inconnu : {html_lib.escape(el["kind"])}</div>'
 
@@ -266,7 +324,7 @@ _RENDERERS = {
     "bouton": _render_button,
     "quiz": _render_quiz,
     "association": _render_association,
-    "memory": _render_minigame_placeholder,
+    "memory": _render_memory,
     "mots": _render_minigame_placeholder,
     "scenario": _render_minigame_placeholder,
     "zones": _render_minigame_placeholder,

document_engine/rendering/rendering.md

@@ -58,7 +58,19 @@ regroupement à chaque appel.
   `CODE_QUALITY.md`) puis embarquées en JSON dans un attribut
   `data-assoc-config`, échappé pour l'HTML — même principe que le Quiz,
   aucun aller-retour serveur pendant qu'on joue.
-- **Autres mini-jeux** (`memory`/`mots`/`scenario`/`zones`) : carte
-  placeholder portant le libellé du type (voir
+- **Memory** : toujours une carte résumant la config réelle (nombre de
+  cartes définies, mode paire/simple) — sanitizée
+  (`sanitize_memory_config`) avant lecture. Si au moins une carte existe,
+  s'y ajoute (fonction privée `_render_memory_player`) le plateau de
+  retournement RÉEL et interactif : en mode `"paire"`, chaque carte
+  définie est DUPLIQUÉE en deux instances partageant le même
+  `card_index` (l'appariement se fait dessus, classique Memory) ; en mode
+  `"single"`, une seule instance par carte (simple retournement, sans
+  appariement). Les instances sont mélangées (`random.shuffle`, mélange
+  d'affichage — voir `CODE_QUALITY.md`) puis embarquées en JSON dans un
+  attribut `data-memory-config`, échappé pour l'HTML — même principe que
+  le Quiz/l'Association, aucun aller-retour serveur pendant qu'on joue.
+- **Autres mini-jeux** (`mots`/`scenario`/`zones`) : carte placeholder
+  portant le libellé du type (voir
   `document_engine/labels/element_kind_labels.py`) — emplacement réservé,
   formulaire de contenu dédié hors périmètre de cette passe.