@navette-js/tables 1.0.0-beta.1 → 1.0.0-beta.2

package/lib/index.js

@@ -4,7 +4,7 @@ import { createHash, randomBytes } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 views.namespace('filament-tables', fileURLToPath(new URL('../views', import.meta.url)));
 export * from "./query-builder.js";
-/** Emplacements de render hook d'une table — mêmes noms que `Filament\Tables\View\TablesRenderHook`. */
+/** Render hook slots of a table. */
 export const TablesRenderHook = {
     CONTENT_AFTER: 'tables::content.after',
     CONTENT_BEFORE: 'tables::content.before',
@@ -26,17 +26,17 @@ export const TablesRenderHook = {
     TOOLBAR_START: 'tables::toolbar.start',
     FILTER_INDICATORS: 'tables::filter.indicators',
     HEADER_CELL: 'tables::header.cell',
-    /** Anciens noms, conservés par Filament. */
+    /** Legacy aliases of the column manager trigger slots. */
     TOOLBAR_TOGGLE_COLUMN_TRIGGER_AFTER: 'tables::toolbar.toggle-column-trigger.after',
     TOOLBAR_TOGGLE_COLUMN_TRIGGER_BEFORE: 'tables::toolbar.toggle-column-trigger.before',
 };
-/** Cibles de chargement de la table (`wire:target`), dans l'ordre émis par Filament. */
+/** Methods and properties that trigger the table's loading state (`wire:target`). */
 export const LOADING_TARGETS = 'activeTab,applyTableFilters,gotoPage,nextPage,previousPage,removeTableFilter,removeTableFilters,reorderTable,resetTableColumnSearch,resetTableFiltersForm,resetTableSearch,setPage,sortTable,tableColumnSearches,tableFilters,tableGrouping,tableRecordsPerPage,tableSearch,tableSort,toggleTableReordering';
 const headline = (s) => s.replace(/[_.-]+/g, ' ').replace(/^./, (c) => c.toUpperCase());
-// ------------------------------------------------------------------ colonnes
-/** Base commune des colonnes (port partiel de Filament\Tables\Columns\Column). */
+// ------------------------------------------------------------------ columns
+/** Base class of table columns. */
 export class Column {
-    /** Réglage par défaut de toutes les instances créées ensuite par `make()` : `TextInput.configureUsing((input) => input.maxLength(255))`. */
+    /** Default setup for every instance created afterwards by `make()`, e.g. `TextColumn.configureUsing((column) => column.sortable())`. */
     static configureUsing(configure) { configureUsing(this, configure); }
     name;
     _label = null;
@@ -50,20 +50,20 @@ export class Column {
     _sortColumn = null;
     _searchColumn = null;
     _url = null;
-    /** Libellé du groupe de colonnes auquel la colonne appartient (posé par ColumnGroup). */
+    /** Label of the column group this column belongs to (set by ColumnGroup). */
     _group = null;
     constructor(name) { this.name = name; }
     label(label) { this._label = label; return this; }
-    /** `column` : colonne (ou alias de la requête) utilisée pour trier quand elle diffère du nom, par exemple pour une relation. */
+    /** `column`: column (or query alias) to sort by when it differs from the name, e.g. for a relationship. */
     sortable(condition = true) { this._sortable = condition !== false; this._sortColumn = typeof condition === 'object' ? condition.column : null; this._sortInverted = typeof condition === 'object' && condition.inverted === true; return this; }
     getSortColumn() { return this._sortColumn ?? this.name; }
     _sortInverted = false;
-    /** Vrai quand la colonne de tri évolue en sens inverse de la valeur affichée (`inverted` : un âge trié par sa date). */
+    /** `inverted`: the sort column runs opposite to the displayed value (e.g. an age sorted by birth date). */
     isSortInverted() { return this._sortInverted; }
-    /** Lien posé sur la cellule ; il prend le pas sur l'action de ligne. */
+    /** Link on the cell; takes precedence over the row action. */
     url(resolver) { this._url = resolver; return this; }
     getUrl(record) { return this._url ? this._url(record) : null; }
-    /** `isGlobal: false` exclut la colonne de la recherche globale ; `isIndividual` ajoute un champ de recherche propre à la colonne. */
+    /** `isGlobal: false` excludes the column from the global search; `isIndividual` adds a search field for this column. */
     getSearchColumn() { return this._searchColumn ?? this.name; }
     searchable(options = true) {
         this._searchColumn = typeof options === 'object' ? (options.column ?? null) : null;
@@ -71,7 +71,7 @@ export class Column {
         this._individuallySearchable = typeof options === 'object' && options.isIndividual === true;
         return this;
     }
-    /** Colonne que l'utilisateur peut masquer depuis le gestionnaire de colonnes. */
+    /** Lets the user hide the column from the column manager. */
     toggleable(condition = true, options = {}) { this._toggleable = condition; this._toggledHiddenByDefault = options.isToggledHiddenByDefault === true; return this; }
     alignment(alignment) { this._alignment = alignment; return this; }
     alignEnd() { return this.alignment('end'); }
@@ -85,10 +85,10 @@ export class Column {
     isToggleable() { return this._toggleable; }
     isToggledHiddenByDefault() { return this._toggledHiddenByDefault; }
     getAlignment() { return this._alignment; }
-    /** Suffixe des classes `fi-ta-header-cell-…` / `fi-ta-cell-…` : les tirets bas deviennent des tirets, les points sont conservés (comme Filament). */
+    /** Suffix of the `fi-ta-header-cell-…` / `fi-ta-cell-…` classes: underscores become dashes, dots are kept. */
     getCssName() { return this.name.replace(/_/g, '-'); }
     async getState(record) { return this._state ? this._state({ record }) : record[this.name]; }
-    /** Vrai pour une cellule modifiable : elle n'est enveloppée ni d'un lien ni d'un bouton vers l'enregistrement. */
+    /** True for editable cells: they are not wrapped in a link or button to the record. */
     isClickDisabled() { return false; }
 }
 export class TextColumn extends Column {
@@ -106,40 +106,40 @@ export class TextColumn extends Column {
     _limit = null;
     _tooltip = null;
     static make(name) { return configured(new TextColumn(name)); }
-    /** Affiche la valeur dans une pastille. */
+    /** Displays the value in a badge. */
     badge(condition = true) { this._badge = condition; return this; }
     color(color) { this._color = color; return this; }
     icon(resolver) { this._icon = resolver; return this; }
-    /** Texte affiché à la place de la valeur brute (libellé d'une énumération, par exemple). */
+    /** Text displayed instead of the raw value (e.g. an enum label). */
     formatStateUsing(formatter) { this._format = formatter; return this; }
-    /** Date courte, comme `->date()` de Filament (« Nov 9, 2026 »). */
+    /** Short date, e.g. "Nov 9, 2026". */
     date(condition = true) { this._date = condition; return this; }
     _dateTime = false;
-    /** Date et heure, « M j, Y H:i:s » (format par défaut de Filament). */
+    /** Date and time, e.g. "Nov 9, 2026 14:30:00". */
     dateTime(condition = true) { this._dateTime = condition; this._date = condition; return this; }
-    /** Nombre formaté avec séparateurs de milliers (`->numeric()`). */
+    /** Number formatted with thousands separators. */
     _decimals = null;
-    /** `numeric(1)` : nombre de décimales fixe. */
+    /** `numeric(1)`: fixed number of decimals. */
     numeric(condition = true) { this._numeric = condition !== false; this._decimals = typeof condition === 'number' ? condition : null; return this; }
-    /** Ligne de totaux sous la table. */
+    /** Summary row below the table. */
     summarize(summarizer) { this._summarizers = Array.isArray(summarizer) ? summarizer : [summarizer]; return this; }
     getSummarizers() { return this._summarizers; }
     weight(weight) { this._weight = weight; return this; }
-    /** Tronque le texte affiché à `length` caractères, suivi de « ... » (port de `limit()`, Str::limit). */
+    /** Truncates the displayed text to `length` characters, followed by "...". */
     limit(length) { this._limit = length; return this; }
-    /** Infobulle au survol du texte ; `null` pour ne pas en afficher. */
+    /** Tooltip on hover; `null` for none. */
     tooltip(tooltip) { this._tooltip = tooltip; return this; }
     copyable(condition = true) { this._copyable = condition; return this; }
-    /** Montant formaté dans la devise donnée (`money('usd')`). */
+    /** Amount formatted in the given currency, e.g. `money('usd')`. */
     money(currency = 'usd') { this._money = currency; return this; }
-    /** Texte affiché quand la valeur est vide. */
+    /** Text displayed when the value is empty. */
     placeholder(text) { this._placeholder = text; return this; }
-    /** Contenu de cellule. Filament a deux balisages : un chemin court pour le texte simple, un chemin complet dès qu'une option est posée. */
+    /** Cell content: a short markup for plain text, a full markup as soon as an option (badge, icon, color…) is set. */
     async toHtml(record) {
         const state = await this.getState(record);
         if ((state === null || state === undefined || state === '') && this._placeholder !== null)
             return `<div class="fi-ta-text"><p class="fi-ta-placeholder">${e(this._placeholder)}</p></div>`;
-        // Valeur vide sans texte de remplacement : Filament rend un conteneur nu.
+        // Empty value without placeholder: render a bare container.
         if (state === null || state === undefined || state === '')
             return `<div class="${cls(['fi-ta-text', this._money || this._numeric ? 'fi-numeric' : null, (this._money || this._numeric) && this._alignment && this._alignment !== 'start' ? `fi-align-${this._alignment}` : null])}"></div>`;
         const currency = typeof this._money === 'function' ? this._money(record) : this._money;
@@ -153,7 +153,7 @@ export class TextColumn extends Column {
                 const color = typeof this._color === 'function' ? this._color(record) : (this._color ?? 'primary');
                 const iconName = this._icon?.(record) ?? null;
                 const classes = ['fi-badge', 'fi-size-sm', ...(color !== 'gray' ? (colorManager?.getComponentClasses('badge', color) ?? []) : [])].join(' ');
-                // Comme Filament : sans icône, la cellule passe par le chemin court, qui écrit les classes dans l'autre ordre.
+                // Without an icon the cell uses the short markup, which writes the classes in the other order.
                 return `<div class="${iconName ? 'fi-ta-text-item fi-ta-text' : 'fi-ta-text fi-ta-text-item'} fi-ta-text-has-badges"><span class="${classes}">${iconName ? icon(iconName, { size: 'sm', attributes: new Attributes({ 'aria-hidden': 'true' }) }) : ''}${e(shown)}</span></div>`;
             }
             if (!this._weight && !this._copyable)
@@ -171,7 +171,7 @@ export class TextColumn extends Column {
                             }">${e(limited)}</span>` : e(limited);
             return `<div class="${cls(['fi-ta-text-item', 'fi-size-sm', this._weight ? `fi-font-${this._weight}` : null, 'fi-ta-text', this._money || this._numeric ? 'fi-numeric' : null, align])}">${content}</div>`;
         }
-        // Hors pastille : une icône précède le texte (chemin complet), une couleur teinte le texte.
+        // Outside a badge: an icon precedes the text (full markup) and a color tints the text.
         const plainIcon = this._icon?.(record) ?? null;
         const plainColor = typeof this._color === 'function' ? this._color(record) : this._color;
         const colorClasses = plainColor ? (colorManager?.getComponentClasses('text', plainColor) ?? []) : [];
@@ -193,7 +193,7 @@ export class TextColumn extends Column {
         return `<div class="${cls(['fi-ta-text-item', 'fi-size-sm', this._weight ? `fi-font-${this._weight}` : null, 'fi-ta-text', this._money || this._numeric ? 'fi-numeric' : null, align])}">${inner}</div>`;
     }
 }
-/** Résumé d'une colonne sous la table (port de Summarizers\Summarizer) : somme, moyenne, nombre ou étendue. */
+/** Column summary below the table: sum, average, count or range. */
 export class Summarizer {
     _label = null;
     _money = null;
@@ -202,33 +202,33 @@ export class Summarizer {
     getLabel() { return this._label; }
     format(value) { return this._money ? new Intl.NumberFormat('en-US', { style: 'currency', currency: this._money }).format(value) : new Intl.NumberFormat('en-US').format(value); }
 }
-/** Total d'une colonne (port du summarizer Sum). */
+/** Column total. */
 export class Sum extends Summarizer {
     kind = 'sum';
     static make() { return configured(new Sum()); }
     getLabel() { return this._label ?? t('filament-tables::table.summary.summarizers.sum.label'); }
     summarize(column, values) { return { type: 'text', label: this.getLabel(), value: this.format(values.sum[column] ?? 0) }; }
 }
-/** Moyenne d'une colonne (port du summarizer Average). */
+/** Column average. */
 export class Average extends Summarizer {
     kind = 'avg';
     static make() { return configured(new Average()); }
     getLabel() { return this._label ?? t('filament-tables::table.summary.summarizers.average.label'); }
     summarize(column, values) { return { type: 'text', label: this.getLabel(), value: this.format(values.avg[column] ?? 0) }; }
 }
-/** Nombre d'enregistrements (port du summarizer Count). */
+/** Record count. */
 export class Count extends Summarizer {
     kind = 'count';
     static make() { return configured(new Count()); }
     getLabel() { return this._label ?? t('filament-tables::table.summary.summarizers.count.label'); }
     summarize(_column, values) { return { type: 'text', label: this.getLabel(), value: this.format(values.count) }; }
 }
-/** Plus petite et plus grande valeur d'une colonne (port du summarizer Range). */
+/** Smallest and largest value of a column. */
 export class Range extends Summarizer {
     kind = 'range';
     _minimalDateTime = false;
     static make() { return configured(new Range()); }
-    /** Dates : le jour seul quand les deux bornes diffèrent de jour, le jour et l'heure sinon ; une seule valeur si elles sont identiques. */
+    /** Dates: day only when the bounds fall on different days, day and time otherwise; a single value when both are equal. */
     minimalDateTimeDifference(condition = true) { this._minimalDateTime = condition; return this; }
     summarize(column, values) {
         let bounds = [values.min[column], values.max[column]].filter((v) => v !== null && v !== undefined && v !== '').map(String);
@@ -248,7 +248,7 @@ export class Range extends Summarizer {
         return { type: 'range', label: this._label, value: bounds.join(' - ') };
     }
 }
-/** Regroupement des lignes d'une table (port de Grouping\Group) : les lignes sont triées par la colonne, un en-tête précède chaque groupe. */
+/** Row grouping: rows are sorted by the column and each group gets a header row. */
 export class Group {
     id;
     _label = null;
@@ -261,17 +261,17 @@ export class Group {
     constructor(id) { this.id = id; }
     static make(id) { return configured(new Group(id)); }
     label(label) { this._label = label; return this; }
-    /** Colonne de la requête qui porte la valeur du groupe, quand elle diffère de l'identifiant (relation). */
+    /** Query column holding the group value, when it differs from the id (relationship). */
     column(column) { this._column = column; return this; }
-    /** Titre du groupe tiré de l'enregistrement (libellé d'une énumération, par exemple). */
+    /** Group title computed from the record (e.g. an enum label). */
     getTitleUsing(resolver) { this._title = resolver; return this; }
     getDescriptionUsing(resolver) { this._description = resolver; return this; }
-    /** Noms de Filament (`getTitleFromRecordUsing`, `getDescriptionFromRecordUsing`). */
+    /** Aliases using the `get…FromRecordUsing` naming. */
     getTitleFromRecordUsing(resolver) { return this.getTitleUsing(resolver); }
     getDescriptionFromRecordUsing(resolver) { return this.getDescriptionUsing(resolver); }
-    /** Les groupes se replient d'un clic sur leur en-tête. */
+    /** Groups collapse when their header is clicked. */
     collapsible(condition = true) { this._collapsible = condition; return this; }
-    /** La colonne est une date : les lignes d'un même jour forment un groupe. */
+    /** The column is a date: rows from the same day form one group. */
     date(condition = true) { this._date = condition; return this; }
     titlePrefixedWithLabel(condition = true) { this._titlePrefixedWithLabel = condition; return this; }
     getId() { return this.id; }
@@ -285,7 +285,7 @@ export class Group {
     isCollapsible() { return this._collapsible; }
     isDate() { return this._date; }
     isTitlePrefixedWithLabel() { return this._titlePrefixedWithLabel; }
-    /** Valeur du groupe pour un enregistrement, en texte ; `null` quand elle est vide. */
+    /** Group value of a record, as text; `null` when empty. */
     getStringKey(record) {
         let key = record?.[this.getColumn()];
         if (key === null || key === undefined || key === '')
@@ -303,7 +303,7 @@ export class Group {
         return key;
     }
     getDescription(record) { return this._description ? this._description(record) : null; }
-    /** Restreint une requête aux enregistrements du groupe de clé donnée. */
+    /** Restricts a query to the records of the group with the given key. */
     scope(query, key) {
         if (key === null)
             query.where((sub) => sub.whereNull(this.getColumn()).orWhere(this.getColumn(), ''));
@@ -314,35 +314,35 @@ export class Group {
     }
 }
 /**
- * Mise en page des colonnes (port de Tables\Columns\Layout) : dès qu'une table en contient une, ses enregistrements sont
- * rendus en cartes (`fi-ta-content`) et non plus en lignes de tableau ; le tri passe par un sélecteur « Sort by ».
+ * Column layout: as soon as a table has one, records are rendered as cards (`fi-ta-content`) instead of table rows,
+ * and sorting goes through a "Sort by" select.
  */
 export class ColumnLayout {
     _children;
     constructor(children) { this._children = children; }
     getChildren() { return this._children; }
-    /** Colonnes feuilles, dans l'ordre : ce sont elles que la table trie, cherche et masque. */
+    /** Leaf columns, in order: the ones the table sorts, searches and toggles. */
     getColumns() { return this._children.flatMap((child) => (child instanceof ColumnLayout ? child.getColumns() : [child])); }
 }
-/** Colonnes côte à côte, à partir d'un point de rupture (port de Layout\Split). */
+/** Columns side by side, from a given breakpoint. */
 export class Split extends ColumnLayout {
     _from = null;
     static make(children) { return new Split(children); }
     from(breakpoint) { this._from = breakpoint; return this; }
     getClasses() { return ['fi-ta-split', ...(this._from ? [`${this._from}:fi-ta-split`] : [])]; }
 }
-/** Colonnes l'une sous l'autre (port de Layout\Stack). */
+/** Columns stacked vertically. */
 export class Stack extends ColumnLayout {
     _space = null;
     _alignment = 'start';
     static make(children) { return new Stack(children); }
-    /** Espace entre les colonnes : 1 (petit), 2 (moyen) ou 3 (grand). */
+    /** Gap between columns: 1 (small), 2 (medium) or 3 (large). */
     space(space = 1) { this._space = space; return this; }
     alignment(alignment) { this._alignment = alignment; return this; }
     getClasses() { return ['fi-ta-stack', `fi-align-${this._alignment}`, ...(this._space ? [`fi-gap-${['sm', 'md', 'lg'][this._space - 1]}`] : [])]; }
 }
 const layoutCell = (classes, html) => `<div class="${['fi-grid-col', 'fi-growable', ...classes].join(' ')}" style="--col-span-default: span 1 / span 1;">${html}</div>`;
-/** Rendu d'un enregistrement selon la mise en page : les colonnes masquées par l'utilisateur sont sautées. */
+/** Renders a record through the layout, skipping columns the user has hidden. */
 async function renderColumnLayout(node, record, key, visible) {
     if (node instanceof ColumnLayout) {
         const children = [];
@@ -353,11 +353,11 @@ async function renderColumnLayout(node, record, key, visible) {
     if (!visible.has(node))
         return '';
     const alignment = node.getAlignment();
-    // Dans une mise en page, le texte est « en ligne » et porte lui-même l'alignement (comme Filament).
+    // Inside a layout, text is inline and carries its own alignment.
     const html = (await node.toHtml(record, key)).replace(/class="([^"]*\bfi-ta-text\b[^"]*)"/, (_match, classes) => `class="${classes.replace(/ fi-align-\w+/g, '')} fi-inline${alignment ? ` fi-align-${alignment}` : ''}"`);
     return layoutCell(['fi-ta-col', ...(alignment ? [`fi-align-${alignment}`] : [])], html);
 }
-/** Groupe de colonnes : un intitulé commun au-dessus des en-têtes (port de ColumnGroup). */
+/** Column group: a shared label above the column headers. */
 export class ColumnGroup {
     label;
     _columns = [];
@@ -367,24 +367,24 @@ export class ColumnGroup {
         c._group = this.label; return this; }
     getColumns() { return this._columns; }
 }
-/** Pastille de couleur (port de ColorColumn). */
+/** Color swatch column. */
 export class ColorColumn extends Column {
     static make(name) { return configured(new ColorColumn(name)); }
     async toHtml(record) {
         const state = await this.getState(record);
-        // Seules les couleurs hexadécimales ou fonctionnelles simples sont injectées dans le style.
+        // Only hex or simple functional colors are injected into the style attribute (no CSS injection).
         const color = typeof state === 'string' && /^(#[0-9a-fA-F]{3,8}|(rgb|hsl|oklch)a?\([0-9.,%\s/deg-]+\))$/.test(state.trim()) ? state.trim() : null;
         return `<div class="fi-ta-color">${color ? `<div aria-label="${e(color)}" role="img" class="fi-ta-color-item" style="background-color: ${color};"></div>` : ''}</div>`;
     }
 }
-/** Image (port partiel de ImageColumn) : l'état est l'adresse de l'image. Seules les adresses locales ou http(s) sont rendues. */
+/** Image column: the state is the image URL. Only local or http(s) URLs are rendered. */
 export class ImageColumn extends Column {
     _alt = null;
     _height = '2.5rem';
     _circular = false;
     static make(name) { return configured(new ImageColumn(name)); }
     alt(resolver) { this._alt = resolver; return this; }
-    /** Hauteur CSS de l'image (`2.5rem` par défaut, comme Filament). */
+    /** CSS height of the image (`2.5rem` by default). */
     imageHeight(height) { if (/^[0-9.]+(rem|px|em)$/.test(height))
         this._height = height; return this; }
     circular(condition = true) { this._circular = condition; return this; }
@@ -397,7 +397,7 @@ export class ImageColumn extends Column {
         return `<div class="fi-ta-image"><img${alt !== null ? ` alt="${e(alt)}"` : ''} src="${e(src)}" style="height: ${this._height};"${this._circular ? ' class="fi-circular"' : ''} /></div>`;
     }
 }
-/** Icône selon la valeur ; `boolean()` affiche une coche verte ou une croix rouge (port partiel de IconColumn). */
+/** Icon depending on the value; `boolean()` shows a green check or a red cross. */
 export class IconColumn extends Column {
     _boolean = false;
     static make(name) { return configured(new IconColumn(name)); }
@@ -413,7 +413,7 @@ export class IconColumn extends Column {
 }
 const isBlank = (value) => value === null || value === undefined || (typeof value === 'string' && value.trim() === '') || (Array.isArray(value) && value.length === 0);
 const isNumeric = (value) => (typeof value === 'number' && Number.isFinite(value)) || (typeof value === 'string' && value.trim() !== '' && Number.isFinite(Number(value)));
-/** Règles Laravel reconnues par `rules([...])`, avec leurs messages anglais. Une règle inconnue est refusée à la déclaration plutôt qu'ignorée. */
+/** String rules accepted by `rules([...])`, with their messages. An unknown rule throws at declaration time instead of being ignored. */
 const STRING_RULES = {
     boolean: () => ({ name: 'boolean', passes: (v) => [true, false, 0, 1, '0', '1'].includes(v), message: (a) => `The ${a} field must be true or false.` }),
     string: () => ({ name: 'string', passes: (v) => typeof v === 'string', message: (a) => `The ${a} field must be a string.` }),
@@ -426,10 +426,10 @@ const STRING_RULES = {
     in: (list) => ({ name: 'in', passes: (v) => list.split(',').includes(String(v)), message: (a) => `The selected ${a} is invalid.` }),
 };
 /**
- * Base des colonnes modifiables dans la cellule (port des traits CanBeValidated et CanUpdateState de Filament). Le navigateur appelle
- * `updateTableColumnState(colonne, clé, valeur)` sur le composant hôte : la colonne doit être déclarée, visible et active pour cet
- * enregistrement, la valeur passer les règles ; ensuite seulement viennent `beforeStateUpdated`, l'écriture et `afterStateUpdated`.
- * Comme dans Filament, l'écriture ne consulte pas les droits du modèle : `disabled()` reste le moyen de restreindre la modification.
+ * Base class of in-cell editable columns. The browser calls `updateTableColumnState(column, key, value)` on the host component:
+ * the column must be declared, visible and enabled for this record, and the value must pass the rules; only then do
+ * `beforeStateUpdated`, the write and `afterStateUpdated` run. The write does not check model permissions: use `disabled()`
+ * to restrict editing.
  */
 export class EditableColumn extends Column {
     _disabled = false;
@@ -442,31 +442,31 @@ export class EditableColumn extends Column {
     _tooltip = null;
     disabled(condition = true) { this._disabled = condition; return this; }
     async isDisabledFor(record) { return typeof this._disabled === 'function' ? this._disabled(record) : this._disabled; }
-    /** Une cellule modifiable n'est ni un lien ni un bouton vers l'enregistrement. */
+    /** An editable cell is neither a link nor a button to the record. */
     isClickDisabled() { return true; }
     isEditable() { return true; }
-    /** Règles appliquées à la valeur reçue : chaînes Laravel (`required`, `max:255`, `in:a,b`…) ou règles `{ name, passes, message }`. */
+    /** Rules applied to the received value: strings (`required`, `max:255`, `in:a,b`…) or `{ name, passes, message }` objects. */
     rules(rules) {
         for (const rule of rules)
             if (typeof rule === 'string' && rule !== 'required' && rule !== 'nullable' && !STRING_RULES[rule.split(':')[0]])
-                throw new Error(`Règle de validation non prise en charge par les colonnes : ${rule}`);
+                throw new Error(`Validation rule not supported by columns: ${rule}`);
         this._rules = [...rules];
         return this;
     }
     getRules() { return this._rules; }
-    /** Équivalent de l'ajout de `required` aux règles. */
+    /** Same as adding `required` to the rules. */
     required(condition = true) { this._rules = [...this._rules.filter((rule) => rule !== 'required'), ...(condition ? ['required'] : [])]; return this; }
     isRequired() { return this._rules.includes('required'); }
-    /** Nom de la colonne dans les messages (par défaut, le libellé avec une minuscule initiale). */
+    /** Column name used in messages (defaults to the label with a lowercase first letter). */
     validationAttribute(label) { this._validationAttribute = label; return this; }
-    /** Messages remplaçant ceux de Laravel, par nom de règle : `{ max: 'Trop long.' }`. */
+    /** Custom messages by rule name, e.g. `{ max: 'Too long.' }`. */
     validationMessages(messages) { this._validationMessages = { ...messages }; return this; }
     getValidationAttribute() { return this._validationAttribute ?? this.getLabel().replace(/^./, (c) => c.toLowerCase()); }
-    /** Règles propres au type de colonne (options d'une liste, par exemple), vérifiées après celles de l'application. */
+    /** Rules specific to the column type (e.g. select options). */
     getImplicitRules() { return []; }
     /**
-     * Message d'erreur, ou `null` si la valeur est acceptable. Comme le validateur de Laravel : une valeur vide ne passe que `required`,
-     * et plusieurs erreurs donnent le premier message suivi de « (and N more errors) ».
+     * Error message, or `null` if the value is valid. An empty value is only checked by `required`, and several errors
+     * produce the first message followed by "(and N more errors)".
      */
     validate(input) {
         const attribute = this.getValidationAttribute();
@@ -479,11 +479,11 @@ export class EditableColumn extends Column {
                 fail('required', `The ${attribute} field is required.`);
         }
         else {
-            // Règles du type de colonne d'abord : une valeur de mauvaise forme (liste, objet forgé) s'arrête là.
+            // Column-type rules first: a malformed value (list, forged object) stops here.
             const implicit = this.getImplicitRules().find((rule) => !rule.passes(input));
             if (implicit)
                 return this._validationMessages[implicit.name] ?? implicit.message(attribute);
-            // Les règles Laravel portées ne valent que pour un scalaire : une liste ou un objet les fait échouer.
+            // String rules only apply to scalars: a list or an object fails them.
             const isScalar = ['string', 'number', 'boolean'].includes(typeof input);
             for (const rule of this._rules) {
                 if (rule === 'required' || rule === 'nullable')
@@ -497,20 +497,20 @@ export class EditableColumn extends Column {
             return null;
         return errors.length === 1 ? errors[0] : `${errors[0]} (and ${errors.length - 1} more error${errors.length > 2 ? 's' : ''})`;
     }
-    /** Écriture personnalisée, à la place de la mise à jour de la colonne de l'enregistrement. Sa valeur de retour est renvoyée au navigateur. */
+    /** Custom write, replacing the update of the record's column. Its return value is sent back to the browser. */
     updateStateUsing(callback) { this._updateStateUsing = callback; return this; }
     beforeStateUpdated(callback) { this._beforeStateUpdated = callback; return this; }
     afterStateUpdated(callback) { this._afterStateUpdated = callback; return this; }
-    /** Infobulle au survol du contrôle, tant qu'aucune erreur n'est affichée. */
+    /** Tooltip on the control, shown while no error is displayed. */
     tooltip(tooltip) { this._tooltip = tooltip; return this; }
     getUpdateStateMessages() {
         return { saving: t('filament-tables::table.columns.editable.saving'), saved: t('filament-tables::table.columns.editable.saved'), failure: t('filament-tables::table.columns.editable.failure') };
     }
-    /** Valeur écrite à partir d'une valeur validée : une valeur vide devient `null` (comme `blank()` dans Filament). */
+    /** Value written from a validated value: blank values become `null`. */
     castState(input) { return isBlank(input) ? null : input; }
     /**
-     * Enregistre une valeur déjà validée (port de `updateState`). Seul le nom déclaré de la colonne est écrit : une colonne de relation
-     * (`auteur.nom`) n'est modifiable qu'avec `updateStateUsing()`.
+     * Saves an already validated value. Only the column's declared name is written: a relationship column (`author.name`)
+     * can only be edited with `updateStateUsing()`.
      */
     async updateState(record, input, adapter) {
         const state = this.castState(input);
@@ -529,7 +529,7 @@ export class EditableColumn extends Column {
         await this._afterStateUpdated?.({ state, record });
         return state;
     }
-    /** Expression `x-tooltip` des contrôles modifiables : l'infobulle de la colonne, remplacée par l'erreur de validation quand il y en a une. */
+    /** `x-tooltip` expression of editable controls: the column tooltip, replaced by the validation error when there is one. */
     tooltipExpression(record) {
         const tooltip = typeof this._tooltip === 'function' ? this._tooltip(record) : this._tooltip;
         return `error === undefined ? ${tooltip !== null && tooltip !== '' ? `{
@@ -544,7 +544,7 @@ export class EditableColumn extends Column {
                         aria: { content: null },
                     }`;
     }
-    /** Ouverture commune des cellules modifiables : composant Alpine chargé à la demande, état serveur et clé de l'enregistrement. */
+    /** Shared opening markup of editable cells: lazily loaded Alpine component, server state and record key. */
     editableAttributes(component, asset, recordKey, state) {
         return new Attributes().merge({
             'x-load': 'x-load',
@@ -563,8 +563,7 @@ export class EditableColumn extends Column {
     static STATUS_HTML = `<p x-cloak x-show="error" x-bind:id="$id('table-column-error')" x-ref="error" x-text="error" class="fi-sr-only"></p><p role="status" aria-live="polite" aria-atomic="true" x-text="status" class="fi-sr-only"></p>`;
 }
 /**
- * Liste déroulante modifiable dans la cellule (port de SelectColumn, liste native seulement). La valeur reçue doit être l'une des
- * options déclarées.
+ * In-cell editable select (native select only). The received value must be one of the declared options.
  */
 export class SelectColumn extends EditableColumn {
     _options = [];
@@ -634,11 +633,11 @@ export class SelectColumn extends EditableColumn {
                 }" x-on:click.prevent.stop class="fi-input-wrp"><select x-model="state" ${select.toHtml()}>${options}</select></div><p x-cloak x-show="error" x-bind:id="$id('table-column-error')" x-ref="error" x-text="error" class="fi-sr-only"></p><p role="status" aria-live="polite" aria-atomic="true" x-text="status" class="fi-sr-only"></p></div>`;
     }
 }
-/** Valeur booléenne reçue du navigateur (déjà passée par la règle `boolean`) : `true`, `false` ou `null`. */
+/** Boolean value received from the browser (already checked by the `boolean` rule): `true`, `false` or `null`. */
 const toBoolean = (value) => (isBlank(value) ? null : value === true || value === 1 || value === '1');
 const ALIGNMENTS = ['start', 'center', 'end', 'left', 'right', 'justify', 'between'];
 const alignmentClass = (alignment) => (alignment && ALIGNMENTS.includes(alignment) ? `fi-align-${alignment}` : null);
-/** Interrupteur modifiable dans la cellule (port de ToggleColumn). La valeur reçue doit être un booléen (règle `boolean` par défaut). */
+/** In-cell editable toggle. The received value must be a boolean (`boolean` rule by default). */
 export class ToggleColumn extends EditableColumn {
     _onColor = null;
     _offColor = null;
@@ -646,17 +645,17 @@ export class ToggleColumn extends EditableColumn {
     _offIcon = null;
     constructor(name) { super(name); this._rules = ['boolean']; }
     static make(name) { return configured(new ToggleColumn(name)); }
-    /** Couleur de l'interrupteur allumé (`primary` par défaut) et éteint (`gray`). */
+    /** Toggle color when on (`primary` by default) and off (`gray`). */
     onColor(color) { this._onColor = color; return this; }
     offColor(color) { this._offColor = color; return this; }
-    /** Icônes affichées dans le bouton de l'interrupteur. */
+    /** Icons shown inside the toggle's thumb. */
     onIcon(icon) { this._onIcon = icon; return this; }
     offIcon(icon) { this._offIcon = icon; return this; }
     castState(input) { return toBoolean(input); }
     async toHtml(record, recordKey = '') {
         const state = Boolean(await this.getState(record));
         const isDisabled = await this.isDisabledFor(record);
-        // Le gris est la couleur par défaut de l'interrupteur : il ne pose aucune classe (HasDefaultGrayColor).
+        // Gray is the toggle's default color and adds no class.
         const colorClasses = (color) => (color === 'gray' ? [] : (colorManager?.getComponentClasses('toggle', color) ?? []));
         const onColorClasses = colorClasses(this._onColor ?? 'primary');
         const onClasses = ['fi-toggle-on', ...onColorClasses].join(' ');
@@ -668,11 +667,11 @@ export class ToggleColumn extends EditableColumn {
             'x-bind:aria-invalid': "error ? 'true' : null", 'x-bind:aria-busy': "isLoading ? 'true' : null", 'x-bind:aria-describedby': "getAccessibilityAttributes()['aria-describedby']",
             'x-tooltip': this.tooltipExpression(record),
         }).class(['fi-toggle']);
-        // Interrupteur allumé : masqué (x-cloak) jusqu'au démarrage d'Alpine, remplacé en attendant par une copie statique, comme dans Filament.
+        // The live toggle is hidden (x-cloak) until Alpine starts; a static copy is shown meanwhile.
         return `<div wire:ignore.self ${outer.toHtml()}><input type="hidden" value="${state ? 1 : 0}" x-ref="serverState" /><div aria-checked="${state ? 'true' : 'false'}" x-bind:aria-checked="state ? 'true' : 'false'" x-bind:tabindex="$el.hasAttribute('disabled') ? '-1' : '0'" x-bind:aria-disabled="isLoading || $el.hasAttribute('disabled') ? 'true' : null" x-on:click.prevent.stop="if (! $el.hasAttribute('disabled')) { clearError(); state = ! state }" x-on:keydown.enter.prevent.stop="if (! $el.hasAttribute('disabled')) { clearError(); state = ! state }" x-on:keydown.space.prevent.stop="if (! $el.hasAttribute('disabled')) { clearError(); state = ! state }" x-bind:class="state ? ${js(onClasses)} : ${js(offClasses)}"${state ? ' x-cloak' : ''} role="switch" ${button.toHtml()}><div><div aria-hidden="true">${toggleIcon(this._offIcon)}</div><div aria-hidden="true">${toggleIcon(this._onIcon)}</div></div></div>${state ? `<div x-cloak="inline-flex" wire:ignore class="${e(['fi-toggle fi-toggle-on fi-hidden', ...onColorClasses].join(' '))}"><div><div aria-hidden="true"></div><div aria-hidden="true">${toggleIcon(this._onIcon)}</div></div></div>` : ''}${EditableColumn.STATUS_HTML}</div>`;
     }
 }
-/** Case à cocher modifiable dans la cellule (port de CheckboxColumn). La valeur reçue doit être un booléen (règle `boolean` par défaut). */
+/** In-cell editable checkbox. The received value must be a boolean (`boolean` rule by default). */
 export class CheckboxColumn extends EditableColumn {
     constructor(name) { super(name); this._rules = ['boolean']; }
     static make(name) { return configured(new CheckboxColumn(name)); }
@@ -692,7 +691,7 @@ export class CheckboxColumn extends EditableColumn {
                 }" x-model="state" ${input.toHtml()} />${EditableColumn.STATUS_HTML}</div>`;
     }
 }
-/** Champ de saisie modifiable dans la cellule (port de TextInputColumn). Seuls un texte ou un nombre sont acceptés du navigateur. */
+/** In-cell editable text input. Only a string or a number is accepted from the browser. */
 export class TextInputColumn extends EditableColumn {
     _type = 'text';
     _mask = null;
@@ -708,9 +707,9 @@ export class TextInputColumn extends EditableColumn {
     _prefixInline = false;
     _suffixInline = false;
     static make(name) { return configured(new TextInputColumn(name)); }
-    /** Type HTML du champ (`text` par défaut ; `number`, `email`, `color`…). */
+    /** HTML input type (`text` by default; `number`, `email`, `color`…). */
     type(type) { this._type = type && /^[a-z-]+$/.test(type) ? type : 'text'; return this; }
-    /** Masque de saisie Alpine (`x-mask`) ; le champ devient alors un champ texte. */
+    /** Alpine input mask (`x-mask`); the input then becomes a text input. */
     mask(mask) { this._mask = mask; return this; }
     inputMode(mode) { this._inputMode = mode; return this; }
     step(step) { this._step = step; return this; }
@@ -731,7 +730,7 @@ export class TextInputColumn extends EditableColumn {
         const state = raw === undefined ? null : raw;
         const isDisabled = await this.isDisabledFor(record);
         const type = this._mask ? 'text' : this._type;
-        // Icône d'affixe : la couleur grise est celle par défaut, sans classe (comme InputComponent\WrapperComponent\IconComponent).
+        // Affix icon: gray is the default color and adds no class.
         const affixIcon = (name, color) => (name ? icon(name, { attributes: new Attributes().class(color && color !== 'gray' ? ['fi-color', `fi-color-${color.replace(/[^a-zA-Z0-9_-]/g, '')}`] : []) }) : '');
         const outer = this.editableAttributes('textInputTableColumn', 'text-input', recordKey, state).class(['fi-ta-text-input']);
         const input = new Attributes().merge({
@@ -749,8 +748,8 @@ export class TextInputColumn extends EditableColumn {
     }
 }
 /**
- * Colonne au rendu libre (port de ViewColumn) : `view()` reçoit une fonction qui renvoie le HTML de la cellule, ou le nom d'une vue EJS
- * rendue avec `{ state, record, column }`. Ce HTML est celui de l'application : les données qu'il contient doivent y être échappées (`e()`).
+ * Custom-rendered column: `view()` takes a function returning the cell HTML, or the name of an EJS view rendered with
+ * `{ state, record, column }`. This HTML is the application's own: data inside it must be escaped there (`e()`).
  */
 export class ViewColumn extends Column {
     _view = null;
@@ -760,26 +759,26 @@ export class ViewColumn extends Column {
     async toHtml(record) {
         const state = await this.getState(record);
         if (this._view === null)
-            throw new Error(`ViewColumn ${this.name} : aucune vue déclarée (view()).`);
+            throw new Error(`ViewColumn ${this.name}: no view declared (view()).`);
         if (typeof this._view === 'function')
             return this._view({ state, record, column: this });
         return views.render(this._view, { ...this._viewData, state, record, column: this, getState: () => state, getRecord: () => record });
     }
 }
-/** @deprecated Port de BadgeColumn : utiliser `TextColumn.make(nom).badge()`. */
+/** @deprecated Use `TextColumn.make(name).badge()`. */
 export class BadgeColumn extends TextColumn {
     constructor(name) { super(name); this.badge(); }
     static make(name) { return configured(new BadgeColumn(name)); }
 }
-/** @deprecated Port de BooleanColumn : utiliser `IconColumn.make(nom).boolean()`. */
+/** @deprecated Use `IconColumn.make(name).boolean()`. */
 export class BooleanColumn extends IconColumn {
     constructor(name) { super(name); this.boolean(); }
     static make(name) { return configured(new BooleanColumn(name)); }
 }
 /**
- * Écriture d'une cellule modifiable reçue du navigateur (port de `updateTableColumnState`). Tout est revérifié : la colonne doit
- * être déclarée, modifiable et visible, l'enregistrement dans la portée de l'adaptateur et non désactivé pour cette colonne,
- * `authorize` (droit de modification de l'hôte) l'accepter, et la valeur passer les règles de la colonne.
+ * Writes an editable cell value received from the browser. Everything is checked again: the column must be declared, editable
+ * and visible, the record within the adapter's scope and not disabled for this column, `authorize` (the host's edit permission)
+ * must accept it, and the value must pass the column's rules.
  */
 export async function updateTableColumnState(table, host, adapter, columnName, recordKey, input, options = {}) {
     const unavailable = { error: t('filament-tables::table.columns.editable.unavailable') };
@@ -796,7 +795,7 @@ export async function updateTableColumnState(table, host, adapter, columnName, r
         return { error };
     return column.updateState(record, input, adapter);
 }
-/** Filtre « corbeille » des modèles à suppression douce (port de TrashedFilter). */
+/** "Trashed" filter for soft-deletable models. */
 export class TrashedFilter {
     name = 'trashed';
     static make() { return configured(new TrashedFilter()); }
@@ -811,7 +810,7 @@ export class TrashedFilter {
     }
 }
 const filterLabel = (name) => name.replace(/[_.-]+/g, ' ').replace(/^./, (c) => c.toUpperCase());
-/** Filtre par valeur d'une colonne, choisie dans une liste (port de SelectFilter, sélection simple). */
+/** Filters on a column value picked from a list (single select). */
 export class SelectFilter {
     name;
     _label = null;
@@ -820,9 +819,9 @@ export class SelectFilter {
     constructor(name) { this.name = name; }
     static make(name) { return configured(new SelectFilter(name)); }
     label(label) { this._label = label; return this; }
-    /** Colonne filtrée quand elle diffère du nom du filtre (clé étrangère d'une relation, par exemple). */
+    /** Filtered column when it differs from the filter name (e.g. a relationship's foreign key). */
     column(column) { this._column = column; return this; }
-    /** Options fixes, ou fonction asynchrone (enregistrements d'une relation). */
+    /** Fixed options, or an async function (e.g. records of a relationship). */
     options(options) {
         this._options = typeof options === 'function' ? options : (Array.isArray(options) ? options : Object.entries(options)).map(([value, label]) => [String(value), String(label)]);
         return this;
@@ -831,21 +830,21 @@ export class SelectFilter {
     getDefaultState() { return { value: null }; }
     getFormDefinition() { return { placeholder: t('filament-tables::table.filters.select.placeholder'), options: Array.isArray(this._options) ? this._options : [] }; }
     getFormOptions() { return typeof this._options === 'function' ? this._options() : Promise.resolve(this._options); }
-    /** Comme Filament : les options d'un SelectFilter sont évaluées à chaque rendu, le sélecteur porte donc une clé dérivée d'elles. */
+    /** Options are evaluated on every render, so the select gets a key derived from them (forces a re-render when they change). */
     hasDynamicOptions = true;
     isActive(state) { return typeof state.value === 'string' && state.value !== ''; }
     apply(query, state) {
         if (!this.isActive(state))
             return;
         const value = String(state.value).slice(0, 255);
-        // Options fixes : seule une valeur proposée filtre. Options chargées : la valeur est un paramètre lié, une valeur inconnue ne trouve rien.
+        // Fixed options: only an offered value filters. Loaded options: the value is a bound parameter, an unknown value matches nothing.
         if (Array.isArray(this._options) && !this._options.some(([option]) => option === value))
             return;
         const column = this._column ?? this.name;
         (query.modifiers ??= []).push((q) => { q.where(column, value); });
     }
 }
-/** Filtre à trois états sur une colonne booléenne : tous, oui, non (port de TernaryFilter). */
+/** Three-state filter on a boolean column: all, yes, no. */
 export class TernaryFilter {
     name;
     _label = null;
@@ -863,7 +862,7 @@ export class TernaryFilter {
         (query.modifiers ??= []).push((q) => { q.where(column, on ? 1 : 0); });
     }
 }
-/** Filtre à formulaire libre (port de Filter avec `schema()`) : la requête et les indicateurs sont écrits par l'application. */
+/** Custom form filter (`schema()`): the query and indicators are written by the application. */
 export class Filter {
     name;
     _label = null;
@@ -873,11 +872,11 @@ export class Filter {
     constructor(name) { this.name = name; }
     static make(name) { return configured(new Filter(name)); }
     label(label) { this._label = label; return this; }
-    /** Champs du filtre ; leurs noms sont les seules clés d'état acceptées du navigateur. */
+    /** Filter fields; their names are the only state keys accepted from the browser. */
     schema(components) { this._components = components; return this; }
-    /** Condition posée sur la requête à partir de l'état nettoyé du formulaire. */
+    /** Query condition built from the sanitized form state. */
     query(modifier) { this._query = modifier; return this; }
-    /** Pastilles des valeurs appliquées : `{ champ: libellé }` ; retirer une pastille efface son champ. */
+    /** Indicators of applied values as `{ field: label }`; removing one clears its field. */
     indicateUsing(resolver) { this._indicate = resolver; return this; }
     fields() { return this._components.map((c) => (typeof c?.getName === 'function' ? String(c.getName()) : null)).filter((name) => name !== null); }
     getLabel() { return this._label ?? filterLabel(this.name); }
@@ -925,13 +924,13 @@ export class Table {
     _groupingDirectionSettingHidden = false;
     _groupingSettingsInDropdownOnDesktop = false;
     _collapsedGroupsByDefault = false;
-    /** Regroupements proposés dans la barre d'outils (un identifiant de colonne vaut `Group.make(identifiant)`). */
+    /** Groupings offered in the toolbar (a column id is shorthand for `Group.make(id)`). */
     groups(groups) { this._groups = groups.map((g) => (typeof g === 'string' ? Group.make(g) : g)); return this; }
     getGroups() { return this._groups; }
     getGroup(id) { return this._groups.find((g) => g.getId() === id) ?? null; }
     /**
-     * Regroupement par défaut (port de `defaultGroup()`). S'il fait partie de `groups()`, il est seulement présélectionné à l'ouverture
-     * (`initializeTableGrouping`) et l'utilisateur peut le retirer ; sinon il s'applique toujours, sans sélecteur.
+     * Default grouping. If it is one of `groups()`, it is only preselected when the table opens (`initializeTableGrouping`)
+     * and the user can remove it; otherwise it always applies, without a selector.
      */
     defaultGroup(group, direction = 'asc') { this._defaultGroup = group; this._defaultGroupDirection = direction === 'desc' ? 'desc' : 'asc'; return this; }
     getDefaultGroup() {
@@ -943,21 +942,21 @@ export class Table {
     }
     getDefaultGroupDirection() { return this._defaultGroupDirection; }
     isDefaultGroupSelectable() { const group = this.getDefaultGroup(); return group !== null && this.getGroup(group.getId()) !== null; }
-    /** Seuls les en-têtes et résumés des groupes sont affichés, sans les lignes ni la pagination (port de `groupsOnly()`). */
+    /** Shows only group headers and summaries, without rows or pagination. */
     groupsOnly(condition = true) { this._groupsOnly = condition; return this; }
     isGroupsOnly() { return this._groupsOnly; }
-    /** Masque le sélecteur de regroupement de la barre d'outils. */
+    /** Hides the toolbar grouping selector. */
     groupingSettingsHidden(condition = true) { this._groupingSettingsHidden = condition; return this; }
     areGroupingSettingsHidden() { return this._groupingSettingsHidden; }
-    /** Masque le choix du sens (croissant / décroissant) du regroupement. */
+    /** Hides the grouping direction (ascending / descending) choice. */
     groupingDirectionSettingHidden(condition = true) { this._groupingDirectionSettingHidden = condition; return this; }
     isGroupingDirectionSettingHidden() { return this._groupingDirectionSettingHidden; }
-    /** Sur grand écran aussi, le sélecteur de regroupement est dans un menu déroulant. */
+    /** Puts the grouping selector in a dropdown on desktop too. */
     groupingSettingsInDropdownOnDesktop(condition = true) { this._groupingSettingsInDropdownOnDesktop = condition; return this; }
-    /** @deprecated Ancien nom de `groupingSettingsInDropdownOnDesktop()`. */
+    /** @deprecated Use `groupingSettingsInDropdownOnDesktop()`. */
     groupsInDropdownOnDesktop(condition = true) { return this.groupingSettingsInDropdownOnDesktop(condition); }
     areGroupingSettingsInDropdownOnDesktop() { return this._groupingSettingsInDropdownOnDesktop; }
-    /** Les groupes repliables s'affichent repliés. */
+    /** Collapsible groups start collapsed. */
     collapsedGroupsByDefault(condition = true) { this._collapsedGroupsByDefault = condition; return this; }
     areGroupsCollapsedByDefault() { return this._collapsedGroupsByDefault; }
     _columnsLayout = null;
@@ -966,45 +965,45 @@ export class Table {
         this._columnsLayout = columns.some((c) => c instanceof ColumnLayout) ? columns.filter((c) => !(c instanceof ColumnGroup)) : null;
         return this;
     }
-    /** Mise en page des colonnes, ou `null` pour un tableau classique. */
+    /** Column layout, or `null` for a regular table. */
     getColumnsLayout() { return this._columnsLayout; }
-    /** Action montée au clic sur une ligne (ex. `'edit'`), à la place d'une URL. */
+    /** Action mounted when a row is clicked (e.g. `'edit'`), instead of a URL. */
     recordAction(name) { this._recordAction = name; return this; }
     getRecordAction() { return this._recordAction; }
-    /** Titre affiché dans l'en-tête de la table. */
+    /** Heading shown in the table header. */
     heading(heading) { this._heading = heading; return this; }
     getHeading() { return this._heading; }
-    /** Actions affichées dans l'en-tête de la table. */
+    /** Actions shown in the table header. */
     headerActions(actions) { this._headerActions = actions; return this; }
     getHeaderActions() { return this._headerActions; }
-    /** Actions groupées (menu « Bulk actions ») ; sans appel, l'hôte fournit ses actions par défaut. */
+    /** Bulk actions ("Bulk actions" menu); if never called, the host provides its default ones. */
     groupedBulkActions(actions) { this._bulkActions = actions; return this; }
     getBulkActions() { return this._bulkActions; }
-    /** Actions de ligne : des `Action` ou un `ActionGroup` (menu déroulant). */
+    /** Row actions: `Action`s or an `ActionGroup` (dropdown). */
     recordActions(actions) { this._recordActions = actions; return this; }
     getRecordActions() { return this._recordActions; }
-    /** Classes CSS ajoutées à la ligne selon l'enregistrement. */
+    /** CSS classes added to a row depending on its record. */
     recordClasses(resolver) { this._recordClasses = resolver; return this; }
     getRecordClasses(record) { return this._recordClasses ? this._recordClasses(record) : null; }
     filters(filters, options = {}) { this._filters = filters; if (options.layout)
         this._filtersLayout = options.layout; return this; }
     filtersLayout(layout) { this._filtersLayout = layout; return this; }
     getFiltersLayout() { return this._filtersLayout; }
-    /** Les filtres ne s'appliquent qu'au bouton « Apply » : c'est déjà le comportement de toutes les tables (méthode gardée pour la compatibilité d'API). */
+    /** No-op kept for API compatibility: filters always wait for the "Apply" button. */
     deferFilters() { return this; }
     defaultSort(column, direction = 'asc') { this._defaultSort = { column, direction }; return this; }
     recordUrl(resolver) { this._recordUrl = resolver; return this; }
     _reorderColumn = null;
-    /** Lignes réordonnables à la main ; `column` reçoit le rang (port de `reorderable()`). */
+    /** Lets users reorder rows by hand; `column` stores the position. */
     reorderable(column) { this._reorderColumn = column; return this; }
     getReorderColumn() { return this._reorderColumn; }
     paginationPageOptions(options) { this._pageOptions = options; return this; }
     _defaultPageOption = null;
-    /** Nombre de lignes par page à l'ouverture (port de `defaultPaginationPageOption()`). */
+    /** Rows per page when the table opens. */
     defaultPaginationPageOption(option) { this._defaultPageOption = option; return this; }
     getDefaultPageOption() { return this._defaultPageOption !== null && this._pageOptions.includes(this._defaultPageOption) ? this._defaultPageOption : (this._pageOptions.includes(10) ? 10 : this._pageOptions[0]); }
     _paginationMode = 'default';
-    /** `'simple'` : boutons précédent / suivant seulement, sans numéros de page ni total (port de `PaginationMode::Simple`). */
+    /** `'simple'`: previous / next buttons only, without page numbers or total. */
     paginationMode(mode) { this._paginationMode = mode; return this; }
     getPaginationMode() { return this._paginationMode; }
     stackedOnMobile(condition = true) { this._stackedOnMobile = condition; return this; }
@@ -1018,24 +1017,26 @@ export class Table {
     isStackedOnMobile() { return this._stackedOnMobile; }
     getPluralModelLabel() { return this._label; }
     hasToggleableColumns() { return this._columns.some((c) => c.isToggleable()); }
-    /** État par défaut du gestionnaire de colonnes (port de getDefaultTableColumnState). */
+    /** Default column manager state. */
     getDefaultColumnState() {
         return this._columns.map((c) => ({ type: 'column', name: c.name, label: c.getLabel(), isHidden: false, isToggled: !c.isToggleable() || !c.isToggledHiddenByDefault(), isToggleable: c.isToggleable(), isToggledHiddenByDefault: c.isToggleable() ? c.isToggledHiddenByDefault() : null }));
     }
     getDefaultFilterState() { return Object.fromEntries(this._filters.map((f) => [f.name, f.getDefaultState()])); }
 }
-/** Colonnes affichées : celles que l'état du gestionnaire laisse cochées. L'état du navigateur ne peut masquer qu'une colonne déclarée « toggleable ». */
+/** Visible columns: those left checked in the column manager. Browser state can only hide columns declared toggleable. */
 export function getVisibleColumns(table, host) {
     const hidden = new Set((Array.isArray(host.tableColumns) ? host.tableColumns : []).filter((c) => c && c.isToggled === false).map((c) => c.name));
     return table.getColumns().filter((c) => !(c.isToggleable() && hidden.has(c.name)));
 }
-/** Nettoie un état de colonnes reçu du navigateur : seul `isToggled` des colonnes « toggleable » est repris. */
+/** Sanitizes column state from the browser: only `isToggled` of toggleable columns is kept. */
 export function sanitizeColumnState(table, state) {
     const received = new Map((Array.isArray(state) ? state : []).filter((c) => c && typeof c === 'object').map((c) => [String(c.name), c.isToggled]));
     return table.getDefaultColumnState().map((c) => (c.isToggleable && typeof received.get(c.name) === 'boolean' ? { ...c, isToggled: received.get(c.name) } : c));
 }
-/** Requête de liste (recherche, recherches par colonne, filtres, tri) correspondant à l'état de l'hôte, sans pagination.
- *  Seul ce que la table déclare est accepté, quel que soit l'état envoyé par le navigateur. */
+/**
+ * List query (search, column searches, filters, sort) for the host's state, without pagination.
+ * Only what the table declares is accepted, whatever state the browser sends.
+ */
 export function getTableQuery(table, host) {
     const [column, direction] = (host.tableSort ?? '').split(':');
     const sortColumn = table.getColumn(column);
@@ -1048,7 +1049,7 @@ export function getTableQuery(table, host) {
     const grouping = getTableGrouping(table, host);
     if (grouping)
         query.groupSort = { column: grouping.group.getColumn(), direction: grouping.direction };
-    // L'hôte peut restreindre la requête (onglet de liste actif).
+    // The host can restrict the query (active list tab).
     host.modifyTableQuery?.(query);
     for (const filter of table.getFilters()) {
         const state = host.tableFilters?.[filter.name];
@@ -1056,7 +1057,7 @@ export function getTableQuery(table, host) {
     }
     return query;
 }
-/** Regroupement courant : seul un groupe déclaré par la table est accepté, quel que soit l'état envoyé par le navigateur. */
+/** Current grouping: only a group declared by the table is accepted, whatever state the browser sends. */
 export function getTableGrouping(table, host) {
     if (host.isTableReordering === true)
         return null;
@@ -1064,25 +1065,25 @@ export function getTableGrouping(table, host) {
     const group = table.getGroup(id);
     if (group)
         return { group, direction: direction === 'desc' ? 'desc' : 'asc' };
-    // Comme Filament : un regroupement par défaut absent du sélecteur s'applique toujours ; présent, il ne vaut que s'il est choisi.
+    // A default grouping missing from the selector always applies; one listed in the selector only applies when chosen.
     const fallback = table.isDefaultGroupSelectable() ? null : table.getDefaultGroup();
     return fallback ? { group: fallback, direction: table.getDefaultGroupDirection() } : null;
 }
-/** À l'ouverture de la table (montage de l'hôte) : présélectionne le regroupement par défaut quand l'utilisateur peut le changer. */
+/** When the table opens (host mount): preselects the default grouping when the user can change it. */
 export function initializeTableGrouping(table, host) {
     const group = table.getDefaultGroup();
     if ((host.tableGrouping === null || host.tableGrouping === undefined || host.tableGrouping === '') && group && table.isDefaultGroupSelectable())
         host.tableGrouping = `${group.getId()}:${table.getDefaultGroupDirection()}`;
 }
 export function countActiveFilters(table, host) {
-    // Comme Filament : le compteur est le nombre d'indicateurs ; un filtre sans indicateurs compte pour un quand il est actif.
+    // The count is the number of indicators; an active filter without indicators counts as one.
     return table.getFilters().reduce((total, f) => { const s = host.tableFilters?.[f.name]; return total + (!s || typeof s !== 'object' ? 0 : f.getIndicators ? f.getIndicators(s).length : f.isActive(s) ? 1 : 0); }, 0);
 }
-/** Indicateurs des filtres appliqués (seuls les filtres qui en déclarent en ont). */
+/** Indicators of the applied filters (only filters that declare some have them). */
 export function getFilterIndicators(table, host) {
     return table.getFilters().flatMap((f) => { const s = host.tableFilters?.[f.name]; return s && typeof s === 'object' && f.getIndicators ? f.getIndicators(s).map((indicator) => ({ filter: f.name, ...indicator })) : []; });
 }
-/** Port de sortTable() : non trié → asc → desc → non trié. */
+/** Cycles a column's sort: none → asc → desc → none. */
 export function sortTable(host, column = null, direction = null) {
     const [current, currentDirection] = (host.tableSort ?? '').split(':');
     if (column === (host.tableSort ? current : null))
@@ -1092,13 +1093,13 @@ export function sortTable(host, column = null, direction = null) {
     host.tableSort = direction ? `${column}:${direction}` : null;
     host.paginators.page = 1;
 }
-/** Charge la page d'enregistrements correspondant à l'état de l'hôte. */
+/** Loads the page of records matching the host's state. */
 export async function getTableRecords(table, host, adapter) {
     const options = table.getPageOptions();
     const perPage = options.includes(Number(host.tableRecordsPerPage)) ? Number(host.tableRecordsPerPage) : options[0];
     return adapter.paginate({ ...getTableQuery(table, host), page: Number(host.paginators.page) || 1, perPage });
 }
-/** Éléments de pagination : port de UrlWindow de Laravel avec onEachSide(0), comme Filament. */
+/** Pagination elements: the first and last pages and a window around the current page, with `...` gaps. */
 export function paginationElements(current, last, onEachSide = 0) {
     const range = (a, b) => Array.from({ length: Math.max(0, b - a + 1) }, (_, i) => a + i);
     if (last < onEachSide * 2 + 8)
@@ -1112,9 +1113,9 @@ export function paginationElements(current, last, onEachSide = 0) {
 }
 let colorManager = null;
 export const useColorManager = (manager) => { colorManager = manager; };
-/** Nombre maximal de lignes affichées (et réordonnées) en mode tri manuel. */
+/** Maximum number of rows shown (and reorderable) in reordering mode. */
 export const REORDER_LIMIT = 1000;
-/** Ligne de résumé (port de `tables::summary.row`) ; `groupsOnly` : intitulé seul en tête, puis une cellule par colonne. */
+/** Summary row; with `groupsOnly`, a leading label cell, then one cell per column. */
 function summaryRowHtml(row, span, groupsOnly, placeholders) {
     const items = (cell) => cell.items.map((item) => `<div class="fi-ta-${item.type}-summary">${item.label !== null ? `<span class="fi-ta-${item.type}-summary-label">${e(item.label)}</span>` : ''}<span>${e(item.value)}</span></div>`).join('');
     const heading = groupsOnly
@@ -1123,16 +1124,16 @@ function summaryRowHtml(row, span, groupsOnly, placeholders) {
     return `<tr class="fi-ta-row fi-ta-summary-row${row.striped ? ' fi-striped' : ''}">${placeholders.selection ? '<td></td>' : ''}${heading}${row.cells.map((cell) => `<td class="fi-ta-cell fi-align-${e(cell.alignment)} ">${items(cell)}</td>`).join('')}${placeholders.actions ? '<td></td>' : ''}</tr>`;
 }
 /**
- * Résumés de la table (port de `tables::summary`) : sans pagination, une seule ligne « Summary » ; avec plusieurs pages, un en-tête
- * puis « This page » et « All … ». Renvoie aussi de quoi calculer la ligne de résumé d'un groupe (requête restreinte au groupe).
+ * Table summaries: a single "Summary" row without pagination; with several pages, a header then "This page" and "All …" rows.
+ * Also returns what is needed to compute a group's summary row (query restricted to the group).
  */
 async function summarize(table, host, adapter, visible, page, options) {
-    // Groupes seuls : la colonne du groupe n'a pas de cellule de résumé (son intitulé est déjà en tête de ligne).
+    // Groups only: the grouped column has no summary cell (its label already leads the row).
     const columns = options.groupsOnly && options.group ? visible.filter((c) => c.name !== options.group.getColumn()) : visible;
     const lists = columns.map((c) => (c instanceof TextColumn ? c.getSummarizers() : []));
     if (!lists.some((list) => list.length) || !page.records.length)
         return null;
-    // Comme Filament : la première cellule porte l'intitulé de la ligne ; elle s'étend jusqu'à la première colonne résumée qui la suit.
+    // The first cell holds the row label and spans up to the first summarized column after it.
     const next = lists.findIndex((list, i) => i > 0 && list.length > 0);
     const span = options.groupsOnly ? 0 : next < 0 ? columns.length : next;
     const columnOf = (c) => c.getSortColumn?.() ?? c.name;
@@ -1166,23 +1167,23 @@ async function summarize(table, host, adapter, visible, page, options) {
         : [{ heading: t('filament-tables::table.summary.heading', { label }), cells: cells(all), striped: true }];
     return {
         html: header + rows.map(rowHtml).join(''),
-        /** Ligne de résumé d'un groupe : agrégats de tous les enregistrements du groupe (pas seulement ceux de la page). */
+        /** Group summary row: aggregates over all the group's records (not only those on the page). */
         group: async (group, key, title) => {
             const values = await aggregate({ ...query, modifiers: [...(query.modifiers ?? []), (q) => group.scope(q, key)] });
             return rowHtml({ heading: options.groupsOnly ? (title ?? '') : t('filament-tables::table.summary.subheadings.group', { group: title ?? '', label }), cells: cells(values), striped: false });
         },
     };
 }
-/** Plafond d'enregistrements lus pour une table `groupsOnly` (non paginée, comme dans Filament). */
+/** Maximum records read for a `groupsOnly` table (which is not paginated). */
 export const GROUPS_ONLY_LIMIT = 1000;
 export async function renderTable(table, host, adapter, options = {}) {
     const reorderColumn = options.canReorder === false ? null : table.getReorderColumn();
     const reordering = reorderColumn !== null && host.isTableReordering === true;
-    // Tri manuel : toutes les lignes de la requête, dans l'ordre de la colonne de rang, sans pagination ni actions.
+    // Reordering: all rows of the query, in position order, without pagination or actions.
     if (reordering)
         options = { ...options, bulkActions: [], headerActions: options.headerActions, rowActions: undefined, rowActionsHtml: undefined, filtersForm: null };
     const grouping = reordering ? null : getTableGrouping(table, host);
-    // Groupes seuls : ni pagination ni lignes d'enregistrements, seulement une ligne de résumé par groupe (comme Filament).
+    // Groups only: no pagination and no record rows, just one summary row per group.
     const groupsOnly = grouping !== null && table.isGroupsOnly();
     const page = reordering
         ? await adapter.paginate({ ...getTableQuery(table, host), sort: { column: reorderColumn, direction: 'asc' }, page: 1, perPage: REORDER_LIMIT })
@@ -1194,7 +1195,7 @@ export async function renderTable(table, host, adapter, options = {}) {
     const hasBulk = (options.bulkActions ?? []).length > 0;
     const selectable = (hasBulk || reordering) && !groupsOnly;
     const filled = (value) => value !== null && value.trim() !== '';
-    // Comme Filament : un nouveau groupe commence quand le titre change ; le groupe précédent reçoit alors sa ligne de résumé.
+    // A new group starts when the title changes; the previous group then gets its summary row.
     let previousGroup = { key: null, title: null };
     const columnsLayout = table.getColumnsLayout();
     const visibleSet = new Set(visible);
@@ -1213,9 +1214,9 @@ export async function renderTable(table, host, adapter, options = {}) {
             if (!groupsOnly)
                 groupHeader = {
                     key: groupKey, title: groupTitle, label, description, collapsible: grouping.group.isCollapsible(),
-                    // Clés de tout le groupe (pas seulement de la page), pour sa case « tout sélectionner ».
+                    // Keys of the whole group (not only the page), for its "select all" checkbox.
                     keys: hasBulk ? await adapter.listKeys({ ...query, modifiers: [...(query.modifiers ?? []), (q) => grouping.group.scope(q, groupKey)] }) : [],
-                    // En-tête sans rien à annoncer : masqué aux technologies d'assistance.
+                    // Header with nothing to announce: hidden from assistive technologies.
                     ariaHidden: !(filled(groupTitle) || filled(label) || filled(description) || grouping.group.isCollapsible() || selectable),
                 };
         }
@@ -1241,19 +1242,19 @@ export async function renderTable(table, host, adapter, options = {}) {
             wasClickable: reordering && (recordAction !== null || table.getRecordUrl(record) !== null),
             key, url: reordering ? null : recordAction ? null : table.getRecordUrl(record), cells, actions: groupsOnly ? [] : ((await options.rowActions?.(record)) ?? []),
             actionsHtml: options.rowActionsHtml && !groupsOnly ? await options.rowActionsHtml(record) : null, classes: table.getRecordClasses(record),
-            // Clic sur la ligne : l'action est montée avec la clé de l'enregistrement (même expression que Filament).
+            // Row click: the action is mounted with the record key.
             mountExpression: reordering ? null : recordAction ? `mountAction(${js(recordAction)}, {}, ${js({ table: true, recordKey: key })})` : null,
         });
     }
     const hasRowActions = rows.some((row) => row.actionsHtml !== null || row.actions.length > 0);
-    // Résumés : jamais en mode « tri manuel » ; ceux des groupes s'intercalent avant l'en-tête du groupe suivant.
+    // Summaries: never while reordering; group summaries go before the next group's header.
     const summary = reordering ? null : await summarize(table, host, adapter, visible, page, { group: grouping?.group ?? null, groupsOnly, placeholders: { selection: selectable, actions: hasRowActions } });
     let trailingGroupSummary = '';
     if (summary && grouping) {
         for (const row of rows)
             if (row.summaryBefore)
                 row.groupSummaryHtml = await summary.group(grouping.group, row.summaryBefore.key, row.summaryBefore.title);
-        // Dernier groupe de la page : résumé seulement s'il ne continue pas sur la page suivante (port de shouldRenderTrailingGroupedTableSummary).
+        // Last group on the page: summarized only if it does not continue on the next page.
         let trailing = filled(previousGroup.title);
         if (trailing && !groupsOnly && page.page < page.lastPage) {
             const nextRecord = (await adapter.paginate({ ...getTableQuery(table, host), page: page.page * page.perPage + 1, perPage: 1 })).records[0];
@@ -1277,11 +1278,11 @@ export async function renderTable(table, host, adapter, options = {}) {
         grouping: { directionHidden: table.isGroupingDirectionSettingHidden(), inDropdownOnDesktop: table.areGroupingSettingsInDropdownOnDesktop(), collapsedByDefault: table.areGroupsCollapsedByDefault(), groupsOnly },
         id: host.id, targets: LOADING_TARGETS, table, rows, page, number,
         reorder: reorderColumn !== null ? { active: reordering } : null,
-        // Comme Filament : pas de cases à cocher sans action groupée (ni en mode « groupes seuls »), pas de colonne d'actions sans action de ligne.
+        // No checkboxes without bulk actions (or in groups-only mode), no actions column without row actions.
         selectable, hasRowActions,
-        // Comme Filament (Str::random) : la clé change à chaque rendu pour forcer le remplacement de la case à cocher.
+        // The key changes on every render to force the checkbox to be replaced.
         randomKey: () => Array.from(randomBytes(16), (b) => 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'[b % 62]).join(''),
-        // Total sélectionnable par « tout sélectionner » : tous les enregistrements de la requête courante.
+        // "Select all" covers every record of the current query.
         allCount: table.getPaginationMode() === 'simple' ? '' : page.total, resultsCount: table.getPaginationMode() === 'simple' ? rows.length : page.total,
         columns: visible.map((c) => ({ name: c.name, grouped: c._group !== null, cssName: c.getCssName(), alignment: c.getAlignment(), label: c.getLabel(), sortable: !reordering && c.isSortable(), individuallySearchable: !reordering && c.isIndividuallySearchable(), sort: sortColumn === c.name ? (sortDirection === 'desc' ? 'descending' : 'ascending') : 'none' })),
         linkClasses: classes('link', 'primary'), dangerLinkClasses: classes('link', 'danger'), primaryButtonClasses: classes('button', 'primary'), badgeClasses: classes('badge', 'primary'), indicatorBadgeClasses: classes('badge', 'primary'),
@@ -1289,7 +1290,7 @@ export async function renderTable(table, host, adapter, options = {}) {
         filtersForm: options.filtersForm ?? null, activeFiltersCount: countActiveFilters(table, host), filtersLayout: table.getFiltersLayout(), filterIndicators: getFilterIndicators(table, host),
         hasColumnManager: !reordering && table.hasToggleableColumns(),
         afterContainer: options.after ?? '', heading: table.getHeading(), headerActions: options.headerActions ?? [], summaryHtml: summary?.html ?? '', trailingGroupSummary,
-        // Ligne d'intitulés de groupes : une cellule par colonne isolée, une cellule fusionnée par suite de colonnes du même groupe.
+        // Column group header row: one cell per ungrouped column, one merged cell per run of columns in the same group.
         headerGroups: visible.some((c) => c._group !== null) ? visible.reduce((runs, c) => {
             const last = runs[runs.length - 1];
             if (c._group !== null && last && last.label === c._group)