Audit complet de mise en forme — Image (2e élément du tableau)

Implémente toutes les options manquantes identifiées pour l'élément
Image : dimensionnement/ratio/object-fit, filtres CSS, upload de
fichier (en plus de l'URL), lien/plein écran au clic, chargement
différé, légende, et tous les attributs de boîte partagés déjà créés
pour Titre/Paragraphe (padding/margin/fond/bordure/ombre/opacité/
position du bloc).

Système de pages : un support peut désormais avoir 0 page (un nouveau
support démarre vide), suppression de toutes les pages en un clic, et
la pagination automatique insère intelligemment la nouvelle page juste
après celle qui déborde plutôt qu'en toute fin de liste.

Bugs réels trouvés et corrigés en cours de route : le style de bloc
(dont align-self) ciblait l'élément interne au lieu de son enveloppe
(légende/lien) ; une image à sa taille native pouvait déclencher une
pagination infinie ; upload/mise à jour d'attribut ne déclenchaient
jamais le contrôle de débordement.

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

routes/document/__init__.py

@@ -13,13 +13,16 @@ from . import (  # noqa: F401 - enregistre les routes definies dans chaque modul
     document_element_move_to_page,
     document_element_update,
     document_element_upload_attachment,
+    document_element_upload_image,
     document_new,
     document_page_add,
     document_page_delete,
+    document_page_delete_all,
     document_page_move,
     document_page_rename,
     document_page_vertical_align,
     document_render,
     document_theme_apply,
     document_theme_preview,
+    document_uploaded_file,
 )

routes/document/document_edit.py

@@ -37,12 +37,21 @@ def document_edit(slug: str) -> str:
     constaté le 21/09/2026)."""
     support = db.support_meta(slug)
     pages = document_engine.list_document_pages(slug)
-    active_page = pages[0]
+    # active_page peut être None : un support peut avoir 0 page (retour
+    # utilisateur du 26/09/2026, voir document_engine/pages/pages.md) — le
+    # canevas et le panneau Pages doivent alors afficher un état "aucune
+    # page" plutôt que de planter, voir document_edit.html et
+    # document-editor.js (forgeDocSwitchPage/forgeDocRefreshCanvas).
+    active_page = pages[0] if pages else None
 
-    active_elements: list[dict[str, Any]] = [
-        {**el, "attributes": document_engine.sanitize_element_attributes(el["kind"], el["attributes"])}
-        for el in document_engine.list_document_elements(slug, active_page["id"])
-    ]
+    active_elements: list[dict[str, Any]] = (
+        [
+            {**el, "attributes": document_engine.sanitize_element_attributes(el["kind"], el["attributes"])}
+            for el in document_engine.list_document_elements(slug, active_page["id"])
+        ]
+        if active_page is not None
+        else []
+    )
 
     active_theme = document_engine.get_document_theme_entry(support["theme"]) if support["theme"] else None
 

routes/document/document_element_upload_image.py

@@ -0,0 +1,61 @@
+import os
+import uuid
+from typing import Any
+
+from flask import jsonify, request, url_for
+from werkzeug.wrappers import Response
+
+import db
+import document_engine
+from core.flask_app import app
+
+_ALLOWED_IMAGE_EXTENSIONS = (".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg")
+
+
+@app.route("/document/<slug>/elements/<int:element_id>/upload-image", methods=["POST"])
+def document_element_upload_image(slug: str, element_id: int) -> Response | tuple[Response, int]:
+    """Téléverse un fichier image pour un élément "image" (voir
+    _render_image, document_engine/rendering/render_document_element.py)
+    — mirroir de document_element_upload_attachment.py, mais stocké sous
+    `uploads/` (jamais `attachments/`, réservé au bouton) et réservé au
+    kind "image". `svg_markup` est vidé au passage : un fichier
+    téléversé implique `src`, jamais les deux modes en même temps (voir
+    element_default_attributes, `svg_markup` prioritaire sur `src` au
+    rendu — le vider ici évite qu'un ancien code SVG masque
+    silencieusement la photo qui vient d'être choisie)."""
+    element = document_engine.get_document_element(slug, element_id)
+    if element is None:
+        return jsonify({"error": "élément introuvable"}), 404
+    if element["kind"] != "image":
+        return jsonify({"error": "seul un élément image peut recevoir un fichier téléversé"}), 400
+    f = request.files.get("file")
+    if not f or not f.filename:
+        return jsonify({"error": "Aucun fichier reçu"}), 400
+    ext = os.path.splitext(f.filename)[1].lower()
+    if ext not in _ALLOWED_IMAGE_EXTENSIONS:
+        return jsonify({"error": "Format d'image non pris en charge (PNG, JPG, GIF, WEBP, SVG uniquement)"}), 400
+    stored_name = uuid.uuid4().hex + ext
+    uploads_dir = os.path.join(db.support_dir(slug), "uploads")
+    os.makedirs(uploads_dir, exist_ok=True)
+    f.save(os.path.join(uploads_dir, stored_name))
+
+    attributes = {
+        **element["attributes"],
+        "src": url_for("document_uploaded_file", slug=slug, filename=stored_name),
+        "svg_markup": "",
+    }
+    document_engine.update_document_element_attributes(slug, element_id, attributes)
+    element = db.assert_not_none(
+        document_engine.get_document_element(slug, element_id),
+        "element_id verifie present juste au-dessus, aucune suppression concurrente possible entre-temps ici",
+    )
+    elements_by_parent: dict[int | None, list[dict[str, Any]]] = {}
+    for el in document_engine.list_document_elements(slug, element["page_id"]):
+        elements_by_parent.setdefault(el["parent_id"], []).append(el)
+    return jsonify(
+        {
+            "ok": True,
+            "attributes": element["attributes"],
+            "rendered_html": document_engine.render_document_element(element, elements_by_parent),
+        }
+    )

routes/document/document_page_delete.py

@@ -7,14 +7,12 @@ from core.flask_app import app
 
 @app.route("/document/<slug>/pages/<int:page_id>/delete", methods=["POST"])
 def document_page_delete(slug: str, page_id: int) -> Response | tuple[Response, int]:
-    """Supprime une page — refuse de supprimer la DERNIÈRE page restante
-    (un support a toujours au moins une page, voir document_engine/pages/
-    pages.md) : le garde-fou vit ici, à la route, pas dans
-    delete_document_page (même découpage que routes/game/screens/
-    screen_delete.py côté jeu, qui bloque aussi au niveau route)."""
+    """Supprime une page, y compris la dernière restante — un support à 0
+    page est un état valide (retour utilisateur du 26/09/2026 : "l'éditeur
+    ne dois plus etre obliger d'avoir une page active", voir
+    document_engine/pages/pages.md). Voir aussi document_page_delete_all.py
+    pour tout supprimer d'un coup."""
     if document_engine.get_document_page(slug, page_id) is None:
         return jsonify({"error": "page introuvable"}), 404
-    if len(document_engine.list_document_pages(slug)) <= 1:
-        return jsonify({"error": "impossible de supprimer la dernière page"}), 400
     document_engine.delete_document_page(slug, page_id)
     return jsonify({"ok": True})

routes/document/document_page_delete_all.py

@@ -0,0 +1,17 @@
+from flask import jsonify
+from werkzeug.wrappers import Response
+
+import document_engine
+from core.flask_app import app
+
+
+@app.route("/document/<slug>/pages/delete-all", methods=["POST"])
+def document_page_delete_all(slug: str) -> Response:
+    """Supprime toutes les pages du support d'un coup (retour utilisateur :
+    "une option dans page pour supprimer toute les page d'un coup") — le
+    support se retrouve à 0 page, exactement comme un support neuf. Action
+    destructive et irréversible, jamais appelée sans confirmation
+    explicite côté client (voir static/document/js/document-editor.js,
+    forgeDocDeleteAllPages)."""
+    document_engine.delete_all_document_pages(slug)
+    return jsonify({"ok": True})

routes/document/document_uploaded_file.py

@@ -0,0 +1,19 @@
+import os
+
+from flask import send_from_directory
+from werkzeug.wrappers import Response
+
+import db
+from core.flask_app import app
+
+
+@app.route("/document/<slug>/uploads/<path:filename>")
+def document_uploaded_file(slug: str, filename: str) -> Response:
+    """Sert un fichier téléversé pour ce support (voir
+    document_element_upload_image.py) — mirroir de
+    routes/uploads/uploaded_file.py côté jeu, mais sous le dossier du
+    SUPPORT (db.support_dir). Affiché inline (jamais en téléchargement,
+    contrairement à document_element_download_attachment.py) : c'est une
+    image destinée à s'afficher dans la page, pas un fichier à
+    récupérer."""
+    return send_from_directory(os.path.join(db.support_dir(slug), "uploads"), filename)