@navette-js/actions 0.0.0-stage → 1.0.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NavetteJS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,9 @@
-# Temporary Holding Version
+# @navette-js/actions
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Actions and modals for Navette, the Node.js port of Filament.
+
+Part of [Navette](https://github.com/NavetteJS/navette), a Node.js port of [Filament](https://filamentphp.com). Install the whole framework with `npm install @navette-js/panels`.
+
+**Beta:** the API may still change between beta releases.
+
+License: MIT. Third-party notices: see `THIRD-PARTY-NOTICES.md` where present.

package/lib/index.d.ts

@@ -0,0 +1,183 @@
+import { type ColorManager, type Lazy } from '@navette-js/support';
+import type { ComponentContext, Renderable } from '@navette-js/schemas';
+/** Emplacements de render hook d'une modale d'action — mêmes noms que `Filament\Actions\View\ActionsRenderHook`. Donnée reçue : `data.action`. */
+export declare const ActionsRenderHook: {
+    readonly MODAL_CUSTOM_CONTENT_AFTER: "actions::modal.custom-content.after";
+    readonly MODAL_CUSTOM_CONTENT_BEFORE: "actions::modal.custom-content.before";
+    readonly MODAL_CUSTOM_CONTENT_FOOTER_AFTER: "actions::modal.custom-content-footer.after";
+    readonly MODAL_CUSTOM_CONTENT_FOOTER_BEFORE: "actions::modal.custom-content-footer.before";
+    readonly MODAL_SCHEMA_AFTER: "actions::modal.schema.after";
+    readonly MODAL_SCHEMA_BEFORE: "actions::modal.schema.before";
+};
+export declare const useColorManager: (manager: ColorManager) => void;
+/** Contexte d'exécution d'une action montée. */
+export type ActionCallContext = {
+    livewire: any;
+    record: any;
+    arguments: Record<string, unknown>;
+    data: Record<string, unknown>;
+};
+export declare class Action implements Renderable {
+    /** Réglage par défaut de toutes les instances créées ensuite par `make()` : `TextInput.configureUsing((input) => input.maxLength(255))`. */
+    static configureUsing<T>(this: abstract new (...args: any[]) => T, configure: (instance: T) => void): void;
+    private name;
+    private _label;
+    private _color;
+    private _size;
+    private _submit;
+    private _hidden;
+    private _visible;
+    private _disabled;
+    private _url;
+    private _action;
+    private _handler;
+    private _requiresConfirmation;
+    private _modalHeading;
+    private _modalDescription;
+    private _modalSubmitActionLabel;
+    private _modalIcon;
+    private _icon;
+    private _alpineClick;
+    private _keyBindings;
+    private _schema;
+    private _extraModalFooterActions;
+    private _schemaColumns;
+    private _fillForm;
+    private _modalWidth;
+    private _lazyUrl;
+    private _tableIcon;
+    private _groupedIcon;
+    private _lazyColor;
+    private _lazyIcon;
+    constructor(name: string);
+    static make(name: string): Action;
+    label(label: Lazy<string | null, ComponentContext>): this;
+    /** Une fonction rend la couleur dépendante de l'enregistrement (actions de ligne). */
+    color(color: string | ((ctx: ComponentContext) => string | Promise<string>)): this;
+    size(size: string): this;
+    /** Bouton `type="submit"` qui déclenche la méthode de soumission du formulaire (`->submit('authenticate')`). */
+    submit(form: string | null): this;
+    hidden(condition?: Lazy<boolean, ComponentContext>): this;
+    /** Action de navigation : rendue en `<a href wire:navigate>`. */
+    url(url: string | null | ((ctx: ComponentContext) => string | null)): this;
+    /** Une chaîne : méthode du composant hôte appelée au clic (`wire:click`). Une fonction : traitement de l'action, monté par `mountAction()` (avec modale si elle en a une). */
+    action(action: string | ((ctx: ActionCallContext) => unknown | Promise<unknown>) | null): this;
+    icon(name: string | null | ((ctx: ComponentContext) => string | null | Promise<string | null>)): this;
+    /** Icône quand l'action est un lien de ligne de table. */
+    tableIcon(name: string | null): this;
+    private _iconButton;
+    /** Action de ligne réduite à son icône ; le libellé devient l'infobulle et le nom accessible (port de `iconButton()`). */
+    iconButton(condition?: boolean): this;
+    /** Icône quand l'action est un élément de menu (ActionGroup). */
+    groupedIcon(name: string | null): this;
+    requiresConfirmation(condition?: boolean): this;
+    modalHeading(heading: Lazy<string | null, ActionCallContext>): this;
+    modalDescription(description: Lazy<string | null, ActionCallContext>): this;
+    modalSubmitActionLabel(label: string | null): this;
+    modalIcon(name: string | null): this;
+    private _badge;
+    private _badgeColor;
+    /** Pastille affichée sur le bouton (compteur). */
+    badge(badge: string | number | null | (() => string | number | null | Promise<string | number | null>)): this;
+    badgeColor(color: string): this;
+    private _slideOver;
+    private _hasSubmit;
+    /** Modale en panneau latéral. */
+    slideOver(condition?: boolean): this;
+    /** `false` : modale de consultation, sans bouton de validation. */
+    modalSubmitAction(condition: boolean): this;
+    private _cancelLabel;
+    /** Libellé du bouton de fermeture de la modale (« Cancel » par défaut). */
+    modalCancelActionLabel(label: string | null): this;
+    private _tooltip;
+    private _newTab;
+    /** Infobulle affichée au survol. */
+    tooltip(text: Lazy<string | null, ComponentContext>): this;
+    /** Ouvre l'adresse de l'action dans un nouvel onglet. */
+    openUrlInNewTab(condition?: boolean): this;
+    private tooltipAttribute;
+    private _modalIconColor;
+    /** Couleur de l'icône de la modale ; par défaut celle de l'action. */
+    modalIconColor(color: string | null): this;
+    getColor(): string;
+    getLabel(ctx: ComponentContext): Promise<string>;
+    getIcon(ctx: ComponentContext): Promise<string | null>;
+    private _sort;
+    /** Ordre dans un menu (menu utilisateur, menu du locataire) : négatif, avant le choix du thème ou la liste des locataires. */
+    sort(sort: number): this;
+    getSort(): number;
+    /**
+     * Élément d'un menu du panel (menu utilisateur, menu du locataire) — port de l'action « grouped » à adresse.
+     * Seules les actions à adresse y ont leur place : le menu n'est pas un composant qui monte des actions.
+     */
+    toMenuItemHtml(ctx: ComponentContext, options?: {
+        navigate?: boolean;
+    }): Promise<string>;
+    /** Une adresse calculée ne se connaît qu'avec l'enregistrement : l'hôte la revérifie au montage (`resolveUrl`). */
+    isMountable(): boolean;
+    /** Adresse de l'action dans ce contexte ; une action qui en a une est un lien, jamais une action montée. */
+    resolveUrl(ctx: ComponentContext): string | null;
+    hasModal(): boolean;
+    /** Formulaire affiché dans la modale. Une fonction : les composants sont reconstruits à chaque requête. */
+    schema(components: any[] | ((schema: any) => any), columns?: Record<string, number> | number | null): this;
+    /** Applique le formulaire de l'action au schéma fourni par l'hôte : la fonction rend soit des composants, soit le schéma configuré. */
+    applySchema(schema: any): any | null;
+    /** Boutons ajoutés au pied de la modale, entre la validation et l'annulation. */
+    extraModalFooterActions(actions: Action[]): this;
+    /** État initial du formulaire (ex. à partir de l'enregistrement). */
+    fillForm(resolver: (ctx: ActionCallContext) => Record<string, unknown> | Promise<Record<string, unknown>>): this;
+    /** Largeur de la modale (`xs` … `7xl`). Par défaut `md` pour une confirmation, `4xl` pour un formulaire. */
+    modalWidth(width: string | null): this;
+    hasSchema(): boolean;
+    getFormFill(ctx: ActionCallContext): Promise<Record<string, unknown> | null>;
+    private getDefaultLabel;
+    private _mutateData;
+    private _before;
+    private _after;
+    /** Transforme les données validées du formulaire avant le traitement (ajouter l'auteur, normaliser une valeur…). */
+    mutateDataUsing(fn: (data: Record<string, unknown>, ctx: ActionCallContext) => Record<string, unknown> | Promise<Record<string, unknown>>): this;
+    /** Exécuté juste avant le traitement ; lever une erreur l'annule. */
+    before(fn: (ctx: ActionCallContext) => unknown | Promise<unknown>): this;
+    /** Exécuté après un traitement réussi (journal, notification supplémentaire…). */
+    after(fn: (ctx: ActionCallContext) => unknown | Promise<unknown>): this;
+    call(ctx: ActionCallContext): Promise<unknown>;
+    /** Élément de menu d'une action groupée de table — port de l'action « grouped » (`fi-ac-grouped-action`). Le clic passe par `filamentTable.mountAction()`, qui envoie la sélection. */
+    toGroupedHtml(ctx: ComponentContext, context: Record<string, unknown>): Promise<string>;
+    /**
+     * Élément de menu d'une action de ligne (dans un ActionGroup) — port de l'action « grouped ».
+     * Filament a deux balisages : un chemin court, et la vue Blade dès qu'un raccourci clavier est posé (ordre des classes différent).
+     */
+    toRecordGroupedHtml(ctx: ComponentContext, context: Record<string, unknown>, wireKey: string): Promise<string>;
+    /** Lien d'une action de ligne de table (`fi-ac-link-action`) — port de l'action « link » en petite taille. */
+    toLinkHtml(ctx: ComponentContext, context: Record<string, unknown>, wireKey: string): Promise<string>;
+    /** Fenêtre modale d'une action montée — port de filament-actions::action-modal et filament::components.modal (confirmation seulement). */
+    toModalHtml(ctx: ActionCallContext, index: number, content?: string | null): Promise<string>;
+    alpineClickHandler(handler: string | null): this;
+    private _livewireTarget;
+    private _iconAfter;
+    /** Cible de l'indicateur de chargement (`wire:target`), quand le clic est géré par du JavaScript. */
+    livewireTarget(target: string | null): this;
+    /** Icône (et indicateur de chargement) après le libellé : `'after'`. */
+    iconPosition(position: 'before' | 'after'): this;
+    keyBindings(bindings: string[]): this;
+    getName(): string;
+    private _authorize;
+    /** Condition d'autorisation, distincte de `visible` / `hidden` : non remplie, l'action est masquée et refusée par le serveur. */
+    authorize(condition: Lazy<boolean, ComponentContext>): this;
+    isVisible(ctx: ComponentContext): Promise<boolean>;
+    visible(condition?: Lazy<boolean, ComponentContext>): this;
+    /** Action affichée mais inutilisable ; le serveur refuse aussi de la monter. */
+    disabled(condition?: Lazy<boolean, ComponentContext>): this;
+    isDisabled(ctx: ComponentContext): Promise<boolean>;
+    /** Bouton plein — port de la vue `filament::components.button` pour une action de soumission. */
+    toHtml(ctx: ComponentContext, explicitMountContext?: Record<string, unknown> | null): Promise<string>;
+}
+/** Groupe d'actions replié dans un menu déroulant (port de ActionGroup, bouton-icône « ⋮ »). */
+export declare class ActionGroup {
+    private actions;
+    constructor(actions: Action[]);
+    static make(actions: Action[]): ActionGroup;
+    getActions(): Action[];
+    /** `keyOf` donne la clé `wire:key` de chaque action (elle dépend de l'enregistrement). */
+    toHtml(ctx: ComponentContext, context: Record<string, unknown>, keyOf: (action: Action) => string): Promise<string>;
+}

package/lib/index.js

@@ -0,0 +1,371 @@
+// @navette-js/actions — port de filament/actions : Action (bouton plein, soumission de formulaire) pour commencer.
+import { Attributes, e, evaluate, icon, js, loadingIndicator, renderHook, views, configured, configureUsing } from '@navette-js/support';
+import { t } from '@navette-js/support/i18n';
+import { fileURLToPath } from 'node:url';
+views.namespace('filament-actions', fileURLToPath(new URL('../views', import.meta.url)));
+/** Emplacements de render hook d'une modale d'action — mêmes noms que `Filament\Actions\View\ActionsRenderHook`. Donnée reçue : `data.action`. */
+export const ActionsRenderHook = {
+    MODAL_CUSTOM_CONTENT_AFTER: 'actions::modal.custom-content.after',
+    MODAL_CUSTOM_CONTENT_BEFORE: 'actions::modal.custom-content.before',
+    MODAL_CUSTOM_CONTENT_FOOTER_AFTER: 'actions::modal.custom-content-footer.after',
+    MODAL_CUSTOM_CONTENT_FOOTER_BEFORE: 'actions::modal.custom-content-footer.before',
+    MODAL_SCHEMA_AFTER: 'actions::modal.schema.after',
+    MODAL_SCHEMA_BEFORE: 'actions::modal.schema.before',
+};
+let colorManager = null;
+export const useColorManager = (manager) => { colorManager = manager; };
+export class Action {
+    /** Réglage par défaut de toutes les instances créées ensuite par `make()` : `TextInput.configureUsing((input) => input.maxLength(255))`. */
+    static configureUsing(configure) { configureUsing(this, configure); }
+    name;
+    _label = null;
+    _color = 'primary';
+    _size = 'md';
+    _submit = null;
+    _hidden = false;
+    _visible = true;
+    _disabled = false;
+    _url = null;
+    _action = null;
+    _handler = null;
+    _requiresConfirmation = false;
+    _modalHeading = null;
+    _modalDescription = null;
+    _modalSubmitActionLabel = null;
+    _modalIcon = null;
+    _icon = null;
+    _alpineClick = null;
+    _keyBindings = [];
+    _schema = null;
+    _extraModalFooterActions = [];
+    _schemaColumns = {};
+    _fillForm = null;
+    _modalWidth = null;
+    _lazyUrl = null;
+    _tableIcon = null;
+    _groupedIcon = null;
+    _lazyColor = null;
+    _lazyIcon = null;
+    constructor(name) { this.name = name; }
+    static make(name) { return configured(new Action(name)); }
+    label(label) { this._label = label; return this; }
+    /** Une fonction rend la couleur dépendante de l'enregistrement (actions de ligne). */
+    color(color) { if (typeof color === 'function')
+        this._lazyColor = color;
+    else {
+        this._color = color;
+        this._lazyColor = null;
+    } return this; }
+    size(size) { this._size = size; return this; }
+    /** Bouton `type="submit"` qui déclenche la méthode de soumission du formulaire (`->submit('authenticate')`). */
+    submit(form) { this._submit = form; return this; }
+    hidden(condition = true) { this._hidden = condition; return this; }
+    /** Action de navigation : rendue en `<a href wire:navigate>`. */
+    url(url) { if (typeof url === 'function')
+        this._lazyUrl = url;
+    else {
+        this._url = url;
+        this._lazyUrl = null;
+    } return this; }
+    /** Une chaîne : méthode du composant hôte appelée au clic (`wire:click`). Une fonction : traitement de l'action, monté par `mountAction()` (avec modale si elle en a une). */
+    action(action) {
+        if (typeof action === 'function') {
+            this._handler = action;
+            this._action = null;
+        }
+        else {
+            this._action = action;
+            this._handler = null;
+        }
+        return this;
+    }
+    icon(name) { if (typeof name === 'function')
+        this._lazyIcon = name;
+    else {
+        this._icon = name;
+        this._lazyIcon = null;
+    } return this; }
+    /** Icône quand l'action est un lien de ligne de table. */
+    tableIcon(name) { this._tableIcon = name; return this; }
+    _iconButton = false;
+    /** Action de ligne réduite à son icône ; le libellé devient l'infobulle et le nom accessible (port de `iconButton()`). */
+    iconButton(condition = true) { this._iconButton = condition; return this; }
+    /** Icône quand l'action est un élément de menu (ActionGroup). */
+    groupedIcon(name) { this._groupedIcon = name; return this; }
+    requiresConfirmation(condition = true) { this._requiresConfirmation = condition; return this; }
+    modalHeading(heading) { this._modalHeading = heading; return this; }
+    modalDescription(description) { this._modalDescription = description; return this; }
+    modalSubmitActionLabel(label) { this._modalSubmitActionLabel = label; return this; }
+    modalIcon(name) { this._modalIcon = name; return this; }
+    _badge = null;
+    _badgeColor = 'primary';
+    /** Pastille affichée sur le bouton (compteur). */
+    badge(badge) { this._badge = badge; return this; }
+    badgeColor(color) { this._badgeColor = color; return this; }
+    _slideOver = false;
+    _hasSubmit = true;
+    /** Modale en panneau latéral. */
+    slideOver(condition = true) { this._slideOver = condition; return this; }
+    /** `false` : modale de consultation, sans bouton de validation. */
+    modalSubmitAction(condition) { this._hasSubmit = condition; return this; }
+    _cancelLabel = null;
+    /** Libellé du bouton de fermeture de la modale (« Cancel » par défaut). */
+    modalCancelActionLabel(label) { this._cancelLabel = label; return this; }
+    _tooltip = null;
+    _newTab = false;
+    /** Infobulle affichée au survol. */
+    tooltip(text) { this._tooltip = text; return this; }
+    /** Ouvre l'adresse de l'action dans un nouvel onglet. */
+    openUrlInNewTab(condition = true) { this._newTab = condition; return this; }
+    async tooltipAttribute(ctx) {
+        const text = await evaluate(this._tooltip, ctx);
+        return text ? `x-tooltip="${e(`{
+ content: ${js(text)},
+ theme: $store.theme,
+ allowHTML: false,
+ }`)}" ` : '';
+    }
+    _modalIconColor = null;
+    /** Couleur de l'icône de la modale ; par défaut celle de l'action. */
+    modalIconColor(color) { this._modalIconColor = color; return this; }
+    getColor() { return this._color; }
+    async getLabel(ctx) { return (await evaluate(this._label, ctx)) ?? this.getDefaultLabel(); }
+    async getIcon(ctx) { return this._lazyIcon ? this._lazyIcon(ctx) : this._icon; }
+    _sort = 0;
+    /** Ordre dans un menu (menu utilisateur, menu du locataire) : négatif, avant le choix du thème ou la liste des locataires. */
+    sort(sort) { this._sort = sort; return this; }
+    getSort() { return this._sort; }
+    /**
+     * Élément d'un menu du panel (menu utilisateur, menu du locataire) — port de l'action « grouped » à adresse.
+     * Seules les actions à adresse y ont leur place : le menu n'est pas un composant qui monte des actions.
+     */
+    async toMenuItemHtml(ctx, options = {}) {
+        if (!colorManager)
+            throw new Error('Aucun gestionnaire de couleurs : appelez useColorManager().');
+        const href = this.resolveUrl(ctx);
+        if (!href || !/^(\/(?!\/)|https?:\/\/)/.test(href))
+            return '';
+        const iconName = await this.getIcon(ctx);
+        const colors = this._color !== 'gray' && this._color !== 'primary' ? colorManager.getComponentClasses('dropdown-item', this._color) : [];
+        const glyph = iconName ? icon(iconName, { attributes: new Attributes().class(colors.length ? ['fi-color', `fi-color-${this._color}`] : []) }) : '';
+        return `<a href="${e(href)}"${this._newTab ? ' target="_blank"' : options.navigate ? ' wire:navigate' : ''} class="${['fi-dropdown-list-item', 'fi-ac-grouped-action', ...colors].join(' ')} " role="menuitem" tabindex="-1">${glyph}<span class="fi-dropdown-list-item-label">${e(await this.getLabel(ctx))}</span></a>`;
+    }
+    /** Une adresse calculée ne se connaît qu'avec l'enregistrement : l'hôte la revérifie au montage (`resolveUrl`). */
+    isMountable() { return (this._handler !== null || this._schema !== null) && this._url === null; }
+    /** Adresse de l'action dans ce contexte ; une action qui en a une est un lien, jamais une action montée. */
+    resolveUrl(ctx) { return this._lazyUrl ? this._lazyUrl(ctx) : this._url; }
+    hasModal() { return this._requiresConfirmation || this._schema !== null; }
+    /** Formulaire affiché dans la modale. Une fonction : les composants sont reconstruits à chaque requête. */
+    schema(components, columns = {}) { this._schema = typeof components === 'function' ? components : () => components; this._schemaColumns = columns; return this; }
+    /** Applique le formulaire de l'action au schéma fourni par l'hôte : la fonction rend soit des composants, soit le schéma configuré. */
+    applySchema(schema) {
+        if (!this._schema)
+            return null;
+        const result = this._schema(schema);
+        return Array.isArray(result) ? schema.columns(this._schemaColumns).components(result) : result;
+    }
+    /** Boutons ajoutés au pied de la modale, entre la validation et l'annulation. */
+    extraModalFooterActions(actions) { this._extraModalFooterActions = actions; return this; }
+    /** État initial du formulaire (ex. à partir de l'enregistrement). */
+    fillForm(resolver) { this._fillForm = resolver; return this; }
+    /** Largeur de la modale (`xs` … `7xl`). Par défaut `md` pour une confirmation, `4xl` pour un formulaire. */
+    modalWidth(width) { this._modalWidth = width; return this; }
+    hasSchema() { return this._schema !== null; }
+    async getFormFill(ctx) { return this._fillForm ? this._fillForm(ctx) : null; }
+    getDefaultLabel() { return ((s) => s.charAt(0).toUpperCase() + s.slice(1))(this.name.replace(/[_-]+/g, ' ')); }
+    _mutateData = null;
+    _before = null;
+    _after = null;
+    /** Transforme les données validées du formulaire avant le traitement (ajouter l'auteur, normaliser une valeur…). */
+    mutateDataUsing(fn) { this._mutateData = fn; return this; }
+    /** Exécuté juste avant le traitement ; lever une erreur l'annule. */
+    before(fn) { this._before = fn; return this; }
+    /** Exécuté après un traitement réussi (journal, notification supplémentaire…). */
+    after(fn) { this._after = fn; return this; }
+    async call(ctx) {
+        if (!this._handler)
+            return null;
+        if (this._mutateData)
+            ctx = { ...ctx, data: await this._mutateData(ctx.data ?? {}, ctx) };
+        await this._before?.(ctx);
+        const result = await this._handler(ctx);
+        await this._after?.(ctx);
+        return result;
+    }
+    /** Élément de menu d'une action groupée de table — port de l'action « grouped » (`fi-ac-grouped-action`). Le clic passe par `filamentTable.mountAction()`, qui envoie la sélection. */
+    async toGroupedHtml(ctx, context) {
+        if (!colorManager)
+            throw new Error('Aucun gestionnaire de couleurs : appelez useColorManager().');
+        const expression = `mountAction(${js(this.name)}, {}, ${js(context)})`;
+        const attributes = new Attributes()
+            .merge({ role: 'menuitem', tabindex: '-1', type: 'button', 'wire:loading.attr': 'aria-disabled', 'wire:loading.class': 'fi-disabled', 'wire:target': expression })
+            .class(['fi-ac-grouped-action', 'fi-dropdown-list-item', ...(this._color !== 'gray' ? colorManager.getComponentClasses('dropdown-item', this._color) : [])])
+            .set('x-cloak', 'x-cloak').set('x-show', 'getSelectedRecordsCount()').set('x-on:click', expression);
+        const iconHtml = this._icon ? icon(this._icon, { attributes: new Attributes({ 'wire:loading.remove.delay.default': '1', 'wire:target': expression }).class(this._color !== 'gray' ? ['fi-color', `fi-color-${this._color}`] : []) }) : '';
+        return `<button ${attributes.toHtml()}>${iconHtml}${loadingIndicator(new Attributes({ 'wire:loading.delay.default': '', 'wire:target': expression }))}<span class="fi-dropdown-list-item-label">${e((await evaluate(this._label, ctx)) ?? this.getDefaultLabel())}</span></button>`;
+    }
+    /**
+     * Élément de menu d'une action de ligne (dans un ActionGroup) — port de l'action « grouped ».
+     * Filament a deux balisages : un chemin court, et la vue Blade dès qu'un raccourci clavier est posé (ordre des classes différent).
+     */
+    async toRecordGroupedHtml(ctx, context, wireKey) {
+        if (!colorManager)
+            throw new Error('Aucun gestionnaire de couleurs : appelez useColorManager().');
+        const color = this._lazyColor ? await this._lazyColor(ctx) : this._color;
+        const iconName = this._lazyIcon ? await this._lazyIcon(ctx) : (this._groupedIcon ?? this._icon);
+        const expression = e(`mountAction(${js(this.name)}, {}, ${js(context)})`);
+        const colors = color !== 'gray' ? colorManager.getComponentClasses('dropdown-item', color) : [];
+        const label = (await evaluate(this._label, ctx)) ?? this.getDefaultLabel();
+        const iconHtml = iconName ? icon(iconName, { attributes: new Attributes({ 'wire:loading.remove.delay.default': '1', 'wire:target': `mountAction(${js(this.name)}, {}, ${js(context)})` }).class(color !== 'gray' ? ['fi-color', `fi-color-${color}`] : []) }) : '';
+        const inner = `${iconHtml}${loadingIndicator(new Attributes({ 'wire:loading.delay.default': '', 'wire:target': `mountAction(${js(this.name)}, {}, ${js(context)})` }))}<span class="fi-dropdown-list-item-label">${e(label)}</span>`;
+        // Action de navigation : un lien, sans montage côté serveur.
+        const href = this._lazyUrl ? this._lazyUrl(ctx) : this._url;
+        if (href) {
+            const plainIcon = iconName ? icon(iconName, { attributes: new Attributes().class(color !== 'gray' ? ['fi-color', `fi-color-${color}`] : []) }) : '';
+            // Lien externe (nouvel onglet) : pas de navigation Livewire, classes dans l'ordre de Filament.
+            if (this._newTab)
+                return `<a href="${e(href)}" target="_blank" role="menuitem" tabindex="-1" wire:key="${e(wireKey)}" class="${['fi-ac-grouped-action', 'fi-dropdown-list-item', ...colors].join(' ')}">${plainIcon}<span class="fi-dropdown-list-item-label">${e(label)}</span></a>`;
+            return `<a href="${e(href)}" wire:navigate wire:key="${e(wireKey)}" class="${['fi-dropdown-list-item', 'fi-ac-grouped-action', ...colors].join(' ')}" role="menuitem" tabindex="-1">${plainIcon}<span class="fi-dropdown-list-item-label">${e(label)}</span></a>`;
+        }
+        if (this._disabled !== false) {
+            // Désactivation conditionnelle : Filament passe alors par sa vue Blade, que l'action soit active ou non (ordre des classes différent).
+            const disabled = await this.isDisabled(ctx);
+            return `<button ${disabled ? 'aria-disabled="true" ' : ''}role="menuitem" tabindex="-1" type="button" wire:loading.attr="aria-disabled" wire:loading.class="fi-disabled" class="${['fi-ac-grouped-action', 'fi-dropdown-list-item', disabled ? 'fi-disabled' : null, ...colors].filter(Boolean).join(' ')}" wire:click="${expression}" wire:key="${e(wireKey)}">${inner}</button>`;
+        }
+        if (this._keyBindings.length) {
+            return `<button x-bind:id="$id('key-bindings')" x-mousetrap.global.${this._keyBindings.map((k) => k.replace(/\+/g, '-')).join('.')}="document.getElementById($el.id)?.click()" role="menuitem" tabindex="-1" type="button" wire:loading.attr="aria-disabled" wire:loading.class="fi-disabled" class="${['fi-ac-grouped-action', 'fi-dropdown-list-item', ...colors].join(' ')}" wire:click="${expression}" wire:key="${e(wireKey)}">${inner}</button>`;
+        }
+        return `<button type="button" wire:loading.attr="aria-disabled" wire:loading.class="fi-disabled" wire:click="${expression}" wire:key="${e(wireKey)}" class="${['fi-dropdown-list-item', 'fi-ac-grouped-action', ...colors].join(' ')}" role="menuitem" tabindex="-1">${inner}</button>`;
+    }
+    /** Lien d'une action de ligne de table (`fi-ac-link-action`) — port de l'action « link » en petite taille. */
+    async toLinkHtml(ctx, context, wireKey) {
+        if (!colorManager)
+            throw new Error('Aucun gestionnaire de couleurs : appelez useColorManager().');
+        const color = this._lazyColor ? await this._lazyColor(ctx) : this._color;
+        const iconName = this._lazyIcon ? await this._lazyIcon(ctx) : (this._tableIcon ?? this._icon);
+        const raw = `mountAction(${js(this.name)}, {}, ${js(context)})`;
+        const label = (await evaluate(this._label, ctx)) ?? this.getDefaultLabel();
+        const classes = ['fi-ac-link-action', 'fi-link', 'fi-size-sm', ...(color !== 'gray' ? colorManager.getComponentClasses('link', color) : [])].join(' ');
+        if (this._iconButton) {
+            const disabled = this._disabled !== false && (await this.isDisabled(ctx));
+            const buttonClasses = ['fi-ac-icon-btn-action', 'fi-icon-btn', 'fi-size-sm', disabled ? 'fi-disabled' : null, ...(color !== 'gray' ? colorManager.getComponentClasses('icon-button', color) : [])].filter(Boolean).join(' ');
+            const glyph = iconName ? icon(iconName, { attributes: new Attributes({ 'wire:loading.remove.delay.default': '1', 'wire:target': raw }) }) : '';
+            return `<button title="${e(label)}" aria-label="${e(label)}" ${disabled ? 'disabled ' : ''}type="button" wire:loading.attr="aria-disabled" wire:loading.class="fi-disabled" class="${buttonClasses}"${disabled ? '' : ` wire:click="${e(raw)}"`} wire:key="${e(wireKey)}">${glyph}${loadingIndicator(new Attributes({ 'wire:loading.delay.default': '', 'wire:target': raw }))}</button>`;
+        }
+        const iconHtml = iconName ? icon(iconName, { size: 'sm', attributes: new Attributes({ 'wire:loading.remove.delay.default': '1', 'wire:target': raw }) }) : '';
+        // Action de navigation : un lien vers la page, sans montage côté serveur.
+        const href = this._lazyUrl ? this._lazyUrl(ctx) : this._url;
+        const tooltip = await this.tooltipAttribute(ctx);
+        // Seules les adresses locales ou http(s) deviennent des liens.
+        if (href && /^(\/(?!\/)|https?:\/\/)/.test(href))
+            return `<a href="${e(href)}" ${this._newTab ? 'target="_blank" ' : ''}${tooltip}${this._newTab ? '' : 'wire:navigate '}wire:key="${e(wireKey)}" class="${classes}">${iconName ? icon(iconName, { size: 'sm' }) : ''}<span class="fi-link-label">${e(label)}</span></a>`;
+        const keys = this._keyBindings.length ? `x-bind:id="$id('key-bindings')" x-mousetrap.global.${this._keyBindings.map((k) => k.replace(/\+/g, '-')).join('.')}="document.getElementById($el.id)?.click()" ` : '';
+        return `<button ${keys}${tooltip}type="button" wire:loading.attr="aria-disabled" wire:loading.class="fi-disabled" class="${classes}" wire:click="${e(raw)}" wire:key="${e(wireKey)}">${iconHtml}${loadingIndicator(new Attributes({ 'wire:loading.delay.default': '', 'wire:target': raw }), 'sm')}<span class="fi-link-label">${e(label)}</span></button>`;
+    }
+    /** Fenêtre modale d'une action montée — port de filament-actions::action-modal et filament::components.modal (confirmation seulement). */
+    async toModalHtml(ctx, index, content = null) {
+        if (!colorManager)
+            throw new Error('Aucun gestionnaire de couleurs : appelez useColorManager().');
+        const schemaCtx = { livewire: ctx.livewire, component: null, operation: null, record: ctx.record, get: () => undefined, state: undefined };
+        const label = (await evaluate(this._label, schemaCtx)) ?? this.getDefaultLabel();
+        const color = this._lazyColor ? await this._lazyColor(schemaCtx) : this._color;
+        const confirmation = this._requiresConfirmation;
+        // Comme Filament : une confirmation est centrée (md) ; un formulaire est aligné au début (4xl), sauf en petite largeur.
+        const width = this._modalWidth ?? (confirmation ? 'md' : '4xl');
+        const submitLabel = this._modalSubmitActionLabel ?? t(confirmation ? 'filament-actions::modal.actions.confirm.label' : 'filament-actions::modal.actions.submit.label');
+        // Même ordre que filament-actions::action-modal : contenu libre, schéma, pied de contenu, chacun entre ses deux emplacements.
+        const scopes = ctx.livewire.getRenderHookScopes?.() ?? [];
+        const hook = (name) => renderHook(name, scopes, { action: this });
+        const hooked = hook(ActionsRenderHook.MODAL_CUSTOM_CONTENT_BEFORE) + hook(ActionsRenderHook.MODAL_CUSTOM_CONTENT_AFTER)
+            + (content !== null ? hook(ActionsRenderHook.MODAL_SCHEMA_BEFORE) + content + hook(ActionsRenderHook.MODAL_SCHEMA_AFTER) : '')
+            + hook(ActionsRenderHook.MODAL_CUSTOM_CONTENT_FOOTER_BEFORE) + hook(ActionsRenderHook.MODAL_CUSTOM_CONTENT_FOOTER_AFTER);
+        if (content !== null || hooked !== '')
+            content = hooked;
+        return views.render('filament-actions::modal', {
+            slideOver: this._slideOver, content, confirmation, width, alignment: confirmation || ['xs', 'sm'].includes(width) ? 'center' : 'start',
+            livewireId: ctx.livewire.id, id: `fi-${ctx.livewire.id}-action-${index}`, index, name: this.name,
+            heading: (await evaluate(this._modalHeading, ctx)) ?? label,
+            description: (await evaluate(this._modalDescription, ctx)) ?? (this._requiresConfirmation ? t('filament-actions::modal.confirmation') : null),
+            iconName: this._modalIcon ?? (this._requiresConfirmation ? 'o-exclamation-triangle' : null), color,
+            cancel: await Action.make('cancel').label(this._cancelLabel ?? t('filament-actions::modal.actions.cancel.label')).color('gray').alpineClickHandler('close()').toHtml(schemaCtx),
+            // Comme Filament : le bouton de validation d'une action grise est en couleur primaire.
+            submit: !this._hasSubmit ? '' : (await Action.make('submit').label(submitLabel).color(color === 'gray' ? 'primary' : color).submit('callMountedAction').toHtml(schemaCtx)) + (await Promise.all(this._extraModalFooterActions.map((a) => a.toHtml(schemaCtx)))).join(''),
+        });
+    }
+    alpineClickHandler(handler) { this._alpineClick = handler; return this; }
+    _livewireTarget = null;
+    _iconAfter = false;
+    /** Cible de l'indicateur de chargement (`wire:target`), quand le clic est géré par du JavaScript. */
+    livewireTarget(target) { this._livewireTarget = target; return this; }
+    /** Icône (et indicateur de chargement) après le libellé : `'after'`. */
+    iconPosition(position) { this._iconAfter = position === 'after'; return this; }
+    keyBindings(bindings) { this._keyBindings = bindings; return this; }
+    getName() { return this.name; }
+    _authorize = true;
+    /** Condition d'autorisation, distincte de `visible` / `hidden` : non remplie, l'action est masquée et refusée par le serveur. */
+    authorize(condition) { this._authorize = condition; return this; }
+    async isVisible(ctx) { return !(await evaluate(this._hidden, ctx)) && (await evaluate(this._visible, ctx)) && Boolean(await evaluate(this._authorize, ctx)); }
+    visible(condition = true) { this._visible = condition; return this; }
+    /** Action affichée mais inutilisable ; le serveur refuse aussi de la monter. */
+    disabled(condition = true) { this._disabled = condition; return this; }
+    async isDisabled(ctx) { return evaluate(this._disabled, ctx); }
+    /** Bouton plein — port de la vue `filament::components.button` pour une action de soumission. */
+    async toHtml(ctx, explicitMountContext = null) {
+        if (!colorManager)
+            throw new Error('Aucun gestionnaire de couleurs : appelez useColorManager().');
+        const linkUrl = this._lazyUrl ? this._lazyUrl(ctx) : this._url;
+        if (linkUrl !== null && /^(\/(?!\/)|https?:\/\/)/.test(linkUrl)) {
+            const link = new Attributes().class(['fi-ac-btn-action', 'fi-btn', `fi-size-${this._size}`, ...(this._color !== 'gray' ? colorManager.getComponentClasses('button', this._color) : [])]);
+            const linkIcon = this._icon ? icon(this._icon) : '';
+            const badge = typeof this._badge === 'function' ? await this._badge() : this._badge;
+            const badgeHtml = badge !== null && badge !== '' ? `<div class="fi-btn-badge-ctn"><span class="${['fi-color', `fi-color-${this._badgeColor}`, ...colorManager.getComponentClasses('badge', this._badgeColor).filter((c) => !c.startsWith('fi-color')), 'fi-badge', 'fi-size-xs'].join(' ')}">${e(String(badge))}</span></div>` : '';
+            return `<a href="${e(linkUrl)}" ${this._newTab ? 'target="_blank" ' : ''}${await this.tooltipAttribute(ctx)}${this._newTab ? '' : 'wire:navigate '}${link.toHtml()}>${linkIcon}${e((await evaluate(this._label, ctx)) ?? this.getDefaultLabel())}${badgeHtml}</a>`;
+        }
+        const isSubmit = this._submit !== null;
+        // Action à traitement : le clic monte l'action côté serveur, avec le contexte fourni par l'hôte (ex. l'enregistrement).
+        const mountContext = explicitMountContext ?? ctx.livewire?.getActionMountContext?.() ?? {};
+        // Sans contexte, Filament émet la forme courte `mountAction('nom')`.
+        const mountExpression = this._handler ? (Object.keys(mountContext).length ? `mountAction(${js(this.name)}, {}, ${js(mountContext)})` : `mountAction(${js(this.name)})`) : null;
+        const attributes = new Attributes()
+            .merge({
+            type: isSubmit ? 'submit' : 'button',
+            'wire:loading.attr': 'aria-disabled',
+            'wire:loading.class': 'fi-disabled',
+            'wire:target': this._livewireTarget ?? this._submit,
+            'x-bind:disabled': isSubmit ? 'isProcessing' : null,
+        })
+            .class(['fi-ac-btn-action', 'fi-btn', `fi-size-${this._size}`, ...colorManager.getComponentClasses('button', this._color)])
+            .when(this._action, (a) => a.set('wire:click', this._action))
+            .when(mountExpression, (a) => a.set('wire:click', mountExpression))
+            .when(this._alpineClick, (a) => a.set('x-on:click', this._alpineClick));
+        const wireTarget = this._livewireTarget ?? this._submit ?? this._action ?? mountExpression;
+        const keyBindings = this._keyBindings.length ? `x-bind:id="$id('key-bindings')" x-mousetrap.global.${this._keyBindings.map((k) => k.replace(/\+/g, '-')).join('.')}="document.getElementById($el.id)?.click()" ` : '';
+        return views.render('filament-actions::button', {
+            attributes: attributes.toHtml(), isSubmit, keyBindings, iconAfter: this._iconAfter, hasWireLoader: wireTarget !== null,
+            label: (await evaluate(this._label, ctx)) ?? this.getDefaultLabel(),
+            wireLoader: loadingIndicator(new Attributes({ 'wire:loading.delay.default': '', 'wire:target': wireTarget })),
+            iconHtml: this._icon ? icon(this._icon, { attributes: new Attributes({ 'wire:loading.remove.delay.default': '1', 'wire:target': wireTarget }) }) : '',
+            formLoader: loadingIndicator(new Attributes({ 'x-cloak': 'x-cloak', 'x-show': 'isProcessing' })),
+        });
+    }
+}
+/** Groupe d'actions replié dans un menu déroulant (port de ActionGroup, bouton-icône « ⋮ »). */
+export class ActionGroup {
+    actions;
+    constructor(actions) { this.actions = actions; }
+    static make(actions) { return configured(new ActionGroup(actions)); }
+    getActions() { return this.actions; }
+    /** `keyOf` donne la clé `wire:key` de chaque action (elle dépend de l'enregistrement). */
+    async toHtml(ctx, context, keyOf) {
+        if (!colorManager)
+            throw new Error('Aucun gestionnaire de couleurs : appelez useColorManager().');
+        const items = [];
+        for (const action of this.actions)
+            if (await action.isVisible(ctx))
+                items.push(await action.toRecordGroupedHtml(ctx, context, keyOf(action)));
+        if (!items.length)
+            return '';
+        const label = e(t('filament-actions::group.trigger.label'));
+        return `<div x-data="filamentDropdown" class="fi-dropdown"><div x-on:mousedown="if ($event.button === 0) toggle($event)" class="fi-dropdown-trigger"><button title="${label}" aria-label="${label}" type="button" wire:loading.attr="aria-disabled" wire:loading.class="fi-disabled" class="${['fi-ac-icon-btn-group', 'fi-icon-btn', 'fi-size-md', ...colorManager.getComponentClasses('icon-button', 'primary')].join(' ')}">${icon('m-ellipsis-vertical')}</button></div><div x-cloak x-float.placement.bottom-end.flip.teleport.offset="{ offset: 8 }" x-ref="panel" x-transition:enter-start="fi-opacity-0" x-transition:leave-end="fi-opacity-0" role="menu" class="fi-dropdown-panel"><div class="fi-dropdown-list" role="group">${items.join(' ')}</div></div></div>`;
+    }
+}

package/package.json

@@ -1,6 +1,49 @@
 {
   "name": "@navette-js/actions",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0-beta.1",
+  "description": "Actions and modals for Navette, the Node.js port of Filament.",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    }
+  },
+  "types": "./lib/index.d.ts",
+  "files": [
+    "lib",
+    "views",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NavetteJS/navette.git",
+    "directory": "packages/actions"
+  },
+  "homepage": "https://github.com/NavetteJS/navette#readme",
+  "bugs": {
+    "url": "https://github.com/NavetteJS/navette/issues"
+  },
+  "keywords": [
+    "navette",
+    "filament",
+    "admin",
+    "panel",
+    "livewire",
+    "express",
+    "node"
+  ],
+  "dependencies": {
+    "@navette-js/support": "1.0.0-beta.1",
+    "@navette-js/schemas": "1.0.0-beta.1"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "beta"
+  }
+}

package/views/button.ejs

@@ -0,0 +1,13 @@
+<%# Bouton d'action — port de la vue Blade filament::components.button %>
+<button <%- keyBindings %><% if (isSubmit) { %>x-data="filamentFormButton" x-bind:class="{ 'fi-processing': isProcessing }" <% } %><%- attributes %>>
+    <% if (!iconAfter) { %><%- iconHtml %><% if (hasWireLoader) { %><%- wireLoader %><% } %><% if (isSubmit) { %><%- formLoader %><% } %><% } %>
+    <% if (isSubmit) { %>
+        <span x-show="! isProcessing">
+            <%= label %>
+        </span>
+        <span x-cloak x-show="isProcessing" x-text="processingMessage"></span>
+    <% } else { %>
+        <%= label %>
+    <% } %>
+    <% if (iconAfter) { %><%- iconHtml %><% if (hasWireLoader) { %><%- wireLoader %><% } %><% if (isSubmit) { %><%- formLoader %><% } %><% } %>
+</button>

package/views/modal.ejs

@@ -0,0 +1,55 @@
+<%# Modale d'une action montée — port de filament-actions::action-modal et filament::components.modal (modale de confirmation, centrée, largeur md) %>
+<div wire:partial="action-modals.<%- index %>"<% if (description) { %> aria-describedby="<%= id %>.description"<% } %> aria-labelledby="<%= id %>.heading" aria-modal="true" id="<%= id %>" role="<%- confirmation ? 'alertdialog' : 'dialog' %>" tabindex="-1" x-data="filamentModal({
+                id: <%- js(id) %>,
+                isScrollLocked: true,
+                shouldRestoreFocus: false,
+            })" data-fi-modal-id="<%= id %>" x-on:close-modal.window="if (($event.detail.id === <%- js(id) %>) && isOpen) close()" x-on:close-modal-quietly.window="if (($event.detail.id === <%- js(id) %>) && isOpen) closeQuietly()" x-on:open-modal.window="if (($event.detail.id === <%- js(id) %>) && (! isOpen)) open()" x-bind:class="{
+        'fi-modal-open': isOpen,
+    }" x-cloak x-show="isOpen" class="<%- locals.slideOver ? 'fi-modal fi-modal-slide-over fi-absolute-positioning-context' : 'fi-modal fi-absolute-positioning-context' %>" wire:key="<%= livewireId %>.actions.<%= name %>.modal" x-on:modal-closed="if ($event.detail.id === <%= js(id) %>) $wire.unmountAction(false)">
+    <div aria-hidden="true" x-show="isOpen" x-transition.duration.300ms.opacity class="fi-modal-close-overlay"></div>
+
+    <div tabindex="-1" x-on:click.self="$dispatch(<%= js('close-modal') %>, { id: <%= js(id) %> })" x-trap.noreturn="isTrapActive" class="fi-modal-window-ctn fi-clickable">
+        <form x-on:keydown.window.escape="if (isTopmost()) $dispatch(<%= js('close-modal') %>, { id: <%= js(id) %> })" x-show="isWindowVisible" x-transition:enter="fi-transition-enter" x-transition:leave="fi-transition-leave" x-transition:enter-start="fi-transition-enter-start" x-transition:enter-end="fi-transition-enter-end" x-transition:leave-start="fi-transition-leave-start" x-transition:leave-end="fi-transition-leave-end" wire:submit.prevent="callMountedAction" wire:key="<%= livewireId %>.modal.<%= id %>.window" class="<%- cls(['fi-modal-window', 'fi-modal-window-has-close-btn', { 'fi-modal-window-has-content': content !== null }, 'fi-modal-window-has-footer', { 'fi-modal-window-has-icon': iconName }, 'fi-align-' + alignment, 'fi-width-' + width]) %>">
+            <div wire:key="<%= livewireId %>.modal.<%= id %>.header" class="fi-modal-header">
+                <%- view('filament::components.icon-button', {
+                    iconName: 'o-x-mark', iconSize: 'lg', label: t('filament::components/modal.actions.close.label'), className: 'fi-modal-close-btn',
+                    extra: attrs({ tabindex: '-1' }), after: attrs({ 'x-on:click': "$dispatch('close-modal', { id: " + js(id) + ' })' }),
+                }) %>
+
+                <% if (iconName) { %>
+                    <div class="fi-modal-icon-ctn">
+                        <div class="<%- cls([...(color !== 'gray' ? ['fi-color', 'fi-color-' + color] : []), 'fi-modal-icon-bg']) %>">
+                            <%- icon(iconName, { size: 'lg' }) %>
+                        </div>
+                    </div>
+                <% } %>
+
+                <div>
+                    <h2 id="<%= id %>.heading" class="fi-modal-heading">
+                        <%= heading %>
+                    </h2>
+
+                    <% if (description) { %>
+                        <p id="<%= id %>.description" class="fi-modal-description">
+                            <%= description %>
+                        </p>
+                    <% } %>
+                </div>
+            </div>
+
+            <%# Les six emplacements de ActionsRenderHook sont assemblés dans `content` par Action.toModalHtml(). %>
+            <% if (content !== null) { %>
+                <div wire:key="<%= livewireId %>.modal.<%= id %>.content" class="fi-modal-content">
+                    <%- content %>
+                </div>
+            <% } %>
+
+            <div wire:key="<%= livewireId %>.modal.<%= id %>.footer" class="fi-modal-footer fi-align-<%- confirmation ? 'center' : 'start' %>">
+                <div class="fi-modal-footer-actions">
+                    <%# Confirmation : annuler puis confirmer ; formulaire : valider puis annuler (comme Filament) %>
+                    <%- confirmation ? cancel + submit : submit + cancel %>
+                </div>
+            </div>
+        </form>
+    </div>
+</div>