Comment j'ai transformé EasyAdmin en tableur intelligent.

export const nameCheck = /^[-_a-zA-Z0-9]{4,22}$/;
export const tokenCheck = /^[-_/+a-zA-Z0-9]{24,}$/;

/**
 * Generate CSRF headers for admin AJAX requests (SameOrigin double-submit cookie pattern).
 *
 * Sets a SameSite=Strict cookie and returns a headers object containing both
 * the csrf-token and X-CSRF-Token headers for Symfony's SameOriginCsrfTokenManager.
 *
 * @param {object} [extra={}] - Additional headers to merge (e.g. Content-Type)
 * @returns {object} Headers object with CSRF token headers + any extras
 */
export function csrfHeaders(extra = {}) {
	const tokenId = "csrf-token";
	const token = btoa(String.fromCharCode.apply(null, crypto.getRandomValues(new Uint8Array(18))));

	if (nameCheck.test(tokenId) && tokenCheck.test(token)) {
		const cookie = `${tokenId}_${token}=${tokenId}; path=/; samesite=strict`;
		// biome-ignore lint/suspicious/noDocumentCookie: CSRF double-submit cookie pattern required by Symfony's SameOriginCsrfTokenManager
		document.cookie = window.location.protocol === "https:" ? `__Host-${cookie}; secure` : cookie;
	}

	// Spread `extra` EN PREMIER pour que les headers CSRF gagnent en cas de
	// conflit. Sinon un caller qui passe accidentellement (ou via un path
	// user-influencé) `{ "csrf-token": "..." }` clobberait le token généré
	// — défense en profondeur, coût zéro pour les usages légitimes
	// (Content-Type, Accept, etc., ne collisionnent jamais avec CSRF).
	return {
		...extra,
		[tokenId]: token,
		"X-CSRF-Token": token,
	};
}

/**
 * Styles for inline editing in EasyAdmin
 */

/* La cellule TD parente est désactivée pour le pointer (zone padding inerte),
   le frame récupère la cliquabilité. Combiné au stopBubble du frame, ça
   neutralise la nav par défaut d'EasyAdmin (`tr.ea-clickable-row`) sans
   casser le hover ailleurs sur la ligne. */
td:has(> .inline-edit-frame) {
	pointer-events: none;
}

.inline-edit-frame {
	display: block;
	min-width: 0;
	pointer-events: auto;
}

.inline-edit-clickable {
	border-radius: 0.25rem;
	cursor: pointer;
	display: block;
	padding: 0.25rem 0.5rem;
	transition: background-color 0.2s ease;
	width: 100%;
}

.inline-edit-clickable:hover {
	background-color: color-mix(in oklab, var(--color-accent, #ec305a) 10%, transparent);
}

.inline-edit-form {
	align-items: center;
	display: flex;
	gap: 0.5rem;
}

/* Indicateur de statut auto-save : icône discrète à droite de l'input.
   Largeur minimale fixe pour éviter le layout shift quand l'icône apparaît. */
.inline-edit-status {
	align-items: center;
	color: var(--color-text-secondary, #6c757d);
	display: inline-flex;
	font-size: 0.85rem;
	min-width: 1.25rem;
	transition: opacity 0.3s ease;
}

.inline-edit-status--saving {
	color: var(--color-text-secondary, #6c757d);
}

.inline-edit-status--saved {
	color: var(--bs-success, #198754);
}

.inline-edit-status--saved.inline-edit-status--fading {
	opacity: 0;
}

.inline-edit-status--error {
	color: var(--bs-danger, #dc3545);
}

.inline-edit-error {
	color: var(--bs-danger, #dc3545);
	font-size: 0.85rem;
}

<?php

declare(strict_types=1);

/*
 * This file is part of the Lecodeestdanslepre package.
 *
 * (c) 2025 Lecodeestdanslepre <https://lecodeestdanslepre.fr>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace App\Controller\Admin\Action\Field;

use App\Controller\Admin\Action\Concerns\ValidatesAdminAjaxCsrfTrait;
use App\Service\Admin\Field\InlineEditService;
use Symfony\Bridge\Twig\Attribute\Template;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Symfony\Component\Routing\Attribute\Route;
use Symfony\Component\Security\Http\Attribute\IsGranted;

/**
 * Generic inline edit action for entity fields in EasyAdmin index view.
 *
 * @return array{entity: object, entityType: string, field: string, editMode: bool, errors?: list<string>}
 */
#[Route('/field/{entityType}/{id}/inline-edit/{field}', name: self::class, methods: ['GET', 'POST'])]
#[IsGranted('ROLE_ADMIN')]
#[Template(template: self::class . '.html.twig')]
final class InlineEditAction extends AbstractController
{
    use ValidatesAdminAjaxCsrfTrait;

    public function __construct(
        private readonly InlineEditService $inlineEditService,
    ) {}

    /**
     * @return array{entity: object, entityType: string, field: string, editMode: bool, errors?: list<string>}|JsonResponse
     */
    public function __invoke(string $entityType, string $id, string $field, Request $request): array|JsonResponse
    {
        if (!$this->inlineEditService->isEntityTypeSupported($entityType)) {
            throw new NotFoundHttpException(\sprintf('Entity type "%s" is not supported.', $entityType));
        }

        if (!$this->inlineEditService->isFieldEditable($entityType, $field)) {
            throw new BadRequestHttpException(\sprintf('Field "%s" is not editable inline for entity type "%s".', $field, $entityType));
        }

        $entity = $this->inlineEditService->findEntity($entityType, $id);
        if ($entity === null) {
            throw new NotFoundHttpException(\sprintf('Entity "%s" with id "%s" not found.', $entityType, $id));
        }

        if ($request->isMethod('GET')) {
            $mode = $request->query->get('mode', 'view');

            return [
                'entity' => $entity,
                'entityType' => $entityType,
                'field' => $field,
                'editMode' => $mode === 'edit',
            ];
        }

        if (($csrfError = $this->validateCsrf($request)) instanceof JsonResponse) {
            return $csrfError;
        }

        $value = $request->request->get('value');
        if (!\is_string($value)) {
            throw new BadRequestHttpException('Value must be a string.');
        }

        $inlineEditResult = $this->inlineEditService->updateField($entityType, $entity, $field, $value);

        // Auto-save « background » via le controller Stimulus : l'UI ne veut pas
        // re-render le fragment HTML (ça détruirait l'input et son focus pendant
        // la frappe). On répond JSON, l'UI gère le statut côté client.
        if ($this->wantsJsonResponse($request)) {
            if ($inlineEditResult->hasErrors()) {
                return new JsonResponse(
                    ['errors' => $inlineEditResult->getErrors()],
                    Response::HTTP_UNPROCESSABLE_ENTITY,
                );
            }

            return new JsonResponse(['status' => 'ok']);
        }

        if ($inlineEditResult->hasErrors()) {
            return [
                'entity' => $entity,
                'entityType' => $entityType,
                'field' => $field,
                'errors' => $inlineEditResult->getErrors(),
                'editMode' => true,
            ];
        }

        return [
            'entity' => $entity,
            'entityType' => $entityType,
            'field' => $field,
            'editMode' => false,
        ];
    }

    private function wantsJsonResponse(Request $request): bool
    {
        $accept = $request->headers->get('Accept', '');

        // L'auto-save background envoie explicitement Accept: application/json.
        // Les transitions HTML (fetch ?mode=view|edit) envoient Accept: text/html.
        return str_contains((string) $accept, 'application/json');
    }
}

<?php

declare(strict_types=1);

/*
 * This file is part of the Lecodeestdanslepre package.
 *
 * (c) 2025 Lecodeestdanslepre <https://lecodeestdanslepre.fr>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace App\Controller\Admin\Action\Concerns;

use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;

/**
 * Validates the stateless `admin_ajax` CSRF token carried by the `X-CSRF-Token`
 * header on admin AJAX writes (double-submit cookie pattern, see the front-end
 * `csrfHeaders()` helper in `assets/utils/csrf.js`).
 *
 * Factored here so every admin write endpoint (AI generation, inline edit,
 * media upload/patch/delete) enforces the exact same check instead of relying
 * on `SameSite=lax` alone. Must be used inside an
 * {@see \Symfony\Bundle\FrameworkBundle\Controller\AbstractController} — it
 * calls `isCsrfTokenValid()`.
 */
trait ValidatesAdminAjaxCsrfTrait
{
    /**
     * Returns a 403 JSON response when the token is missing or invalid, or null
     * when the request is authorised to proceed.
     */
    protected function validateCsrf(Request $request): ?JsonResponse
    {
        if (!$this->isCsrfTokenValid('admin_ajax', $request->headers->get('X-CSRF-Token'))) {
            return new JsonResponse(['error' => 'Token CSRF invalide.'], Response::HTTP_FORBIDDEN);
        }

        return null;
    }
}

<?php

declare(strict_types=1);

/*
 * This file is part of the Lecodeestdanslepre package.
 *
 * (c) 2025 Lecodeestdanslepre <https://lecodeestdanslepre.fr>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace App\Service\Admin\Field;

use App\Dto\Admin\InlineEditResult;
use App\Entity\Contact\ContactMessage;
use App\Entity\Content\Category;
use App\Entity\Content\Page;
use App\Entity\Content\Post;
use App\Enum\Contact\ContactMessageStatus;
use App\Enum\Content\ContentStatus;
use App\Enum\Content\ProficiencyLevel;
use App\Repository\Content\CategoryRepository;
use DateTimeImmutable;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\Validator\Validator\ValidatorInterface;

/**
 * Generic service for inline editing of entity fields.
 *
 * Cache invalidation is automatically handled by ContentChangeDoctrineSubscriber.
 */
final readonly class InlineEditService
{
    /**
     * Mapping of entity type slugs to their FQCN.
     *
     * @var array<string, class-string>
     */
    private const array ENTITY_MAP = [
        'post' => Post::class,
        'page' => Page::class,
        'category' => Category::class,
        'contact_message' => ContactMessage::class,
    ];

    /**
     * Whitelisted fields that can be edited inline, per entity type.
     *
     * @var array<string, list<string>>
     */
    private const array EDITABLE_FIELDS = [
        'post' => ['title', 'status', 'createdAt', 'proficiencyLevel', 'category'],
        'page' => ['title', 'status', 'createdAt'],
        'category' => ['title', 'status', 'createdAt'],
        'contact_message' => ['status'],
    ];

    /**
     * Field type configuration for special handling.
     *
     * @var array<string, string>
     */
    private const array FIELD_TYPES = [
        'status' => 'enum:status',
        'proficiencyLevel' => 'enum:proficiencyLevel',
        'createdAt' => 'datetime',
        'category' => 'association:category',
    ];

    public function __construct(
        private EntityManagerInterface $entityManager,
        private ValidatorInterface $validator,
        private CategoryRepository $categoryRepository,
    ) {}

    /**
     * Get the entity class for a given type slug.
     *
     * @return class-string|null
     *
     * @api
     */
    public function getEntityClass(string $entityType): ?string
    {
        return self::ENTITY_MAP[$entityType] ?? null;
    }

    /**
     * Check if an entity type is supported.
     */
    public function isEntityTypeSupported(string $entityType): bool
    {
        return isset(self::ENTITY_MAP[$entityType]);
    }

    /**
     * Check if a field is editable for a given entity type.
     */
    public function isFieldEditable(string $entityType, string $field): bool
    {
        return \in_array($field, self::EDITABLE_FIELDS[$entityType] ?? [], true);
    }

    /**
     * Get the field type configuration.
     */
    public function getFieldType(string $field): ?string
    {
        return self::FIELD_TYPES[$field] ?? null;
    }

    /**
     * Get options for enum fields.
     *
     * @return array<string, string>
     */
    public function getEnumOptions(string $entityType, string $field): array
    {
        return match (true) {
            'contact_message' === $entityType && 'status' === $field => array_combine(
                array_map(static fn(ContactMessageStatus $contactMessageStatusEnum): string => $contactMessageStatusEnum->value, ContactMessageStatus::cases()),
                array_map(static fn(ContactMessageStatus $contactMessageStatusEnum): string => $contactMessageStatusEnum->getLabel(), ContactMessageStatus::cases()),
            ),
            'status' === $field => $this->contentStatusOptions(),
            'proficiencyLevel' === $field => array_combine(
                array_map(static fn(ProficiencyLevel $proficiencyLevelEnum): string => $proficiencyLevelEnum->value, ProficiencyLevel::cases()),
                array_map(static fn(ProficiencyLevel $proficiencyLevelEnum): string => $proficiencyLevelEnum->getLabel(), ProficiencyLevel::cases()),
            ),
            default => [],
        };
    }

    /**
     * Options de statut proposées en édition inline.
     *
     * @return array<string, string>
     */
    private function contentStatusOptions(): array
    {
        $selectable = ContentStatus::cases();

        return array_combine(
            array_map(static fn(ContentStatus $status): string => $status->value, $selectable),
            array_map(static fn(ContentStatus $status): string => $status->getLabel(), $selectable),
        );
    }

    /**
     * Get options for association fields.
     *
     * @return array<string, string>
     */
    public function getAssociationOptions(string $field): array
    {
        return match ($field) {
            'category' => $this->getCategoryOptions(),
            default => [],
        };
    }

    /**
     * Find an entity by type and ID.
     */
    public function findEntity(string $entityType, string $id): ?object
    {
        $entityClass = $this->getEntityClass($entityType);
        if ($entityClass === null) {
            return null;
        }

        return $this->entityManager->getRepository($entityClass)->find($id);
    }

    /**
     * Update a single field on an entity.
     *
     * @return InlineEditResult Result with success status and potential errors
     */
    public function updateField(string $entityType, object $entity, string $field, string $value): InlineEditResult
    {
        // Convert value based on field type
        $convertedValue = $this->convertValue($entityType, $field, $value);
        if ($convertedValue instanceof InlineEditResult) {
            return $convertedValue;
        }

        // Update the field value using appropriate method
        $updateResult = $this->setFieldValue($entity, $field, $convertedValue);
        if ($updateResult instanceof InlineEditResult) {
            return $updateResult;
        }

        // Validate the entity. ANY violation blocks the flush — the previous
        // code only collected violations whose path matched the edited field
        // and, when none did, fell through and flushed an entity that was
        // still invalid on another field (#1392). Surface the edited field's
        // errors when present, otherwise the full list, but never persist an
        // invalid entity.
        $constraintViolationList = $this->validator->validate($entity);

        if (\count($constraintViolationList) > 0) {
            $allErrors = [];
            $fieldErrors = [];
            foreach ($constraintViolationList as $violation) {
                $message = (string) $violation->getMessage();
                $allErrors[] = $message;
                if (str_contains($violation->getPropertyPath(), $field)) {
                    $fieldErrors[] = $message;
                }
            }

            return new InlineEditResult(false, $fieldErrors !== [] ? $fieldErrors : $allErrors);
        }

        // Persist changes (cache is automatically invalidated by ContentChangeDoctrineSubscriber)
        $this->entityManager->flush();

        return new InlineEditResult(true);
    }

    /**
     * Convert string value to the appropriate type based on field configuration.
     */
    private function convertValue(string $entityType, string $field, string $value): mixed
    {
        $fieldType = $this->getFieldType($field);

        if ($fieldType === null) {
            // Simple string field
            return $value;
        }

        if (str_starts_with($fieldType, 'enum:')) {
            return $this->convertEnumValue($entityType, $field, $value);
        }

        if ($fieldType === 'datetime') {
            return $this->convertDateTimeValue($value);
        }

        if (str_starts_with($fieldType, 'association:')) {
            return $this->convertAssociationValue($field, $value);
        }

        return $value;
    }

    /**
     * Convert string to enum value.
     */
    private function convertEnumValue(string $entityType, string $field, string $value): ContentStatus|ProficiencyLevel|ContactMessageStatus|InlineEditResult
    {
        return match (true) {
            'contact_message' === $entityType && 'status' === $field => ContactMessageStatus::tryFrom($value) ?? new InlineEditResult(false, ['Statut invalide.']),
            'status' === $field => ContentStatus::tryFrom($value) ?? new InlineEditResult(false, ['Statut invalide.']),
            'proficiencyLevel' === $field => ProficiencyLevel::tryFrom($value) ?? new InlineEditResult(false, ['Niveau invalide.']),
            default => new InlineEditResult(false, ['Type enum inconnu.']),
        };
    }

    /**
     * Convert string to DateTimeImmutable.
     */
    private function convertDateTimeValue(string $value): \DateTimeImmutable|InlineEditResult|null
    {
        if ($value === '') {
            return null;
        }

        try {
            return new \DateTimeImmutable($value);
        } catch (\Exception) {
            return new InlineEditResult(false, ['Format de date invalide.']);
        }
    }

    /**
     * Convert string ID to association entity.
     */
    private function convertAssociationValue(string $field, string $value): ?object
    {
        if ($value === '') {
            return null;
        }

        return match ($field) {
            'category' => $this->categoryRepository->find($value),
            default => null,
        };
    }

    /**
     * Set field value on entity, handling special cases like private(set) properties.
     *
     * Dynamic method and property access are intentionally used here but all possible
     * values are known and validated via FIELD_TYPES and EDITABLE_FIELDS.
     */
    private function setFieldValue(object $entity, string $field, mixed $value): ?InlineEditResult
    {
        // Handle fields with setters (like createdAt which uses private(set))
        $setter = 'set' . ucfirst($field);
        if (method_exists($entity, $setter)) {
            // @phpstan-ignore-next-line Dynamic method call
            $entity->{$setter}($value);

            return null;
        }

        // Direct property assignment
        if (!property_exists($entity, $field)) {
            return new InlineEditResult(false, [\sprintf('Property "%s" does not exist.', $field)]);
        }

        // @phpstan-ignore-next-line Dynamic property access
        $entity->{$field} = $value;

        return null;
    }

    /**
     * Get category options for select field.
     *
     * @return array<string, string>
     */
    private function getCategoryOptions(): array
    {
        $categories = $this->categoryRepository->findBy([], ['title' => 'ASC']);
        $options = ['' => '-- Aucune --'];

        foreach ($categories as $category) {
            $options[(string) $category->id] = $category->title;
        }

        return $options;
    }
}

<?php

declare(strict_types=1);

/*
 * This file is part of the Lecodeestdanslepre package.
 *
 * (c) 2025 Lecodeestdanslepre <https://lecodeestdanslepre.fr>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace App\Dto\Admin;

/**
 * Result object for inline edit operations.
  * @api
  */

final readonly class InlineEditResult
{
    /**
     * @param list<string> $errors
     */
    public function __construct(
        private bool $success,
        private array $errors = [],
    ) {}

    public function isSuccess(): bool
    {
        return $this->success;
    }

    public function hasErrors(): bool
    {
        return $this->errors !== [];
    }

    /**
     * @return list<string>
     */
    public function getErrors(): array
    {
        return $this->errors;
    }
}

{# Template for inline editable fields in EasyAdmin #}
{% set edit_url = path('App\\Controller\\Admin\\Action\\Field\\InlineEditAction', { entityType: entityType, id: entity.id, field: field }) %}
{% set field_type = inline_edit_field_type(field) %}
{% set current_value = attribute(entity, field) %}

<div
    id="{{ entityType }}-{{ entity.id }}-{{ field }}"
    data-controller="inline-edit"
    data-inline-edit-url-value="{{ edit_url }}"
    data-action="click->inline-edit#stopBubble"
    class="inline-edit-frame"
>
    {% if editMode|default(false) %}
        {# Edit mode — input only, no buttons. Save = auto on input/change/blur/Enter, cancel = Escape #}
        {% set text_actions = 'input->inline-edit#scheduleSave keydown.enter->inline-edit#enter keydown.esc->inline-edit#cancelKey blur->inline-edit#blur' %}
        {% set choice_actions = 'change->inline-edit#saveImmediate keydown.enter->inline-edit#enter keydown.esc->inline-edit#cancelKey blur->inline-edit#blur' %}

        <div class="inline-edit-form">
            {% if field_type starts with 'enum:' %}
                {% set options = inline_edit_enum_options(entityType, field) %}
                {% set current_enum_value = current_value ? current_value.value : '' %}
                <select
                    name="value"
                    class="form-select form-select-sm {% if errors|default([]) %}is-invalid{% endif %}"
                    data-inline-edit-target="input"
                    data-action="{{ choice_actions }}"
                    autofocus
                >
                    {% for value, label in options %}
                        <option value="{{ value }}" {% if value == current_enum_value %}selected{% endif %}>
                            {{ label }}
                        </option>
                    {% endfor %}
                </select>

            {% elseif field_type == 'datetime' %}
                {% set datetime_value = current_value ? current_value|date('Y-m-d\\TH:i') : '' %}
                <input
                    type="datetime-local"
                    name="value"
                    value="{{ datetime_value }}"
                    class="form-control form-control-sm {% if errors|default([]) %}is-invalid{% endif %}"
                    data-inline-edit-target="input"
                    data-action="{{ choice_actions }}"
                    autofocus
                >

            {% elseif field_type starts with 'association:' %}
                {% set options = inline_edit_association_options(field) %}
                {% set current_id = current_value ? current_value.id : '' %}
                <select
                    name="value"
                    class="form-select form-select-sm {% if errors|default([]) %}is-invalid{% endif %}"
                    data-inline-edit-target="input"
                    data-action="{{ choice_actions }}"
                    autofocus
                >
                    {% for value, label in options %}
                        <option value="{{ value }}" {% if value == current_id %}selected{% endif %}>
                            {{ label }}
                        </option>
                    {% endfor %}
                </select>

            {% else %}
                <input
                    type="text"
                    name="value"
                    value="{{ current_value }}"
                    class="form-control form-control-sm {% if errors|default([]) %}is-invalid{% endif %}"
                    data-inline-edit-target="input"
                    data-action="{{ text_actions }}"
                    autofocus
                    required
                >
            {% endif %}

            <span
                class="inline-edit-status"
                data-inline-edit-target="status"
                aria-live="polite"
                aria-atomic="true"
            >
                {% if errors|default([]) %}
                    {% for error in errors %}<span class="inline-edit-error">{{ error }}</span>{% endfor %}
                {% endif %}
            </span>
        </div>
    {% else %}
        {# View mode - clickable text #}
        <span
            class="inline-edit-value inline-edit-clickable"
            data-action="click->inline-edit#edit"
            title="Cliquez pour éditer"
        >
            {% if field_type starts with 'enum:' %}
                {% if current_value %}
                    {% set text_class = current_value.color == 'warning' ? 'text-dark' : 'text-white' %}
                    <span class="badge bg-{{ current_value.color }} {{ text_class }}"><i class="fas {{ current_value.icon }}"></i> {{ current_value.label }}</span>
                {% else %}
                    -
                {% endif %}
            {% elseif field_type == 'datetime' %}
                {{ current_value ? current_value|date('d/m/Y H:i') : '-' }}
            {% elseif field_type starts with 'association:' %}
                {{ current_value ? current_value.title : '-- Aucune --' }}
            {% else %}
                {{ current_value }}
            {% endif %}
        </span>
    {% endif %}
</div>

{# Unified inline editable field template.
   Supports all field types via optional variables:
   - empty_label: text shown when value is empty (default: none)
   - raw_value:   set to true to render value as raw HTML (e.g., badges)
#}
{% set field_value = field.formattedValue %}
{% set entity_id = entity.primaryKeyValue %}
{% set field_name = field.property %}
{% set entity_type = entity.instance|entity_type %}
{% set edit_url = path('App\\Controller\\Admin\\Action\\Field\\InlineEditAction', { entityType: entity_type, id: entity_id, field: field_name }) %}

<div
    id="{{ entity_type }}-{{ entity_id }}-{{ field_name }}"
    data-controller="inline-edit"
    data-inline-edit-url-value="{{ edit_url }}"
    data-action="click->inline-edit#stopBubble"
    class="inline-edit-frame"
>
    {# Initial view mode - clickable text #}
    <span
        class="inline-edit-value inline-edit-clickable"
        data-action="click->inline-edit#edit"
        title="Cliquez pour éditer"
    >
        {% if raw_value is defined and raw_value %}
            {{ field_value|raw }}
        {% elseif empty_label is defined %}
            {{ field_value ?: empty_label }}
        {% else %}
            {{ field_value }}
        {% endif %}
    </span>
</div>