@navette-js/forms 1.0.0-beta.1 → 1.0.0-beta.3

package/lib/index.js

@@ -1,4 +1,4 @@
-// @navette-js/forms — port de filament/forms : Field, TextInput, Checkbox, validation côté serveur.
+// @navette-js/forms — form fields (Field, TextInput, Select, Checkbox…) and server-side validation.
 import { Attributes, HtmlString, e, evaluate, icon, js, views, configured } from '@navette-js/support';
 import { createHash } from 'node:crypto';
 import { t } from '@navette-js/support/i18n';
@@ -21,7 +21,7 @@ views.namespace('filament-forms', fileURLToPath(new URL('../views', import.meta.
 let colorManager = null;
 export const useColorManager = (manager) => { colorManager = manager; };
 const asset = (name) => views.render('filament-forms::asset', { path: name }).trim();
-/** Nombre tel que PHP l'écrit : au-delà des entiers exacts, un flottant à 14 chiffres significatifs (« 1.844674407371E+19 »). */
+/** Number for an HTML attribute: beyond exact integers, a float with 14 significant digits (`1.844674407371E+19`). */
 const phpNumber = (n) => {
     if (n === null || Number.isSafeInteger(n) || Math.abs(n) < 1e15)
         return n;
@@ -50,26 +50,25 @@ export class Field extends Component {
     disabled(condition = true) { this._disabled = condition; return this; }
     autofocus(condition = true) { this._autofocus = condition; return this; }
     default(value) { this._default = value; return this; }
-    /** Texte d'aide affiché sous le champ. */
+    /** Helper text shown under the field. */
     helperText(text) { this._helperText = text; return this; }
-    /** Identifiant du texte d'aide, à lier au contrôle par `aria-describedby`. */
+    /** Helper text id, linked to the control through `aria-describedby`. */
     getHelperTextId() { return this._helperText !== null ? `${this.getId()}-helper-text` : null; }
-    /** Libellé réservé aux lecteurs d'écran. */
+    /** Keeps the label for screen readers only. */
     hiddenLabel(condition = true) { this._hiddenLabel = condition; return this; }
-    // --- indication à droite du libellé (port de Concerns\HasHint)
     _hint = null;
     _hintColor = null;
     _hintIcon = null;
     _hintIconTooltip = null;
     _hintActions = [];
     /**
-     * Indication affichée à droite du libellé (un composant `Text`). Le texte est échappé ; une `HtmlString` de `@navette-js/support`
-     * (`raw('<a href="…">…</a>')`) est insérée telle quelle : n'y placez que des valeurs échappées avec `e()`.
+     * Hint shown to the right of the label (a `Text` component). The text is escaped; an `HtmlString` from `@navette-js/support`
+     * (`raw('<a href="…">…</a>')`) is inserted as is, so only put values escaped with `e()` in it.
      */
     hint(hint) { this._hint = hint; return this; }
-    /** Couleur de l'indication et de son icône (`gray` pour le texte, `primary` pour l'icône par défaut). */
+    /** Color of the hint and its icon (by default `gray` for the text, `primary` for the icon). */
     hintColor(color) { this._hintColor = color; return this; }
-    /** Icône d'indication, avec une infobulle facultative (qui sert aussi de nom accessible). */
+    /** Hint icon, with an optional tooltip (also used as its accessible name). */
     hintIcon(name, tooltip) {
         this._hintIcon = name;
         if (arguments.length >= 2)
@@ -77,13 +76,13 @@ export class Field extends Component {
         return this;
     }
     hintIconTooltip(tooltip) { this._hintIconTooltip = tooltip; return this; }
-    /** Action affichée après l'indication (en lien, petite taille), montée sur le champ. */
+    /** Action shown after the hint (small link), mounted on the field. */
     hintAction(action) { return this.hintActions([action]); }
     hintActions(actions) { this._hintActions = [...this._hintActions, ...actions]; return this; }
     getHintActions() { return this._hintActions; }
-    /** Actions que le champ expose au montage (`schemaComponent` = clé du champ) : ici, ses actions d'indication. */
+    /** Actions the field exposes for mounting (`schemaComponent` = field key): its hint actions. */
     getActions() { return this.getHintActions(); }
-    /** Rangée « après le libellé » : indication, icône d'indication et actions d'indication. */
+    /** Row after the label: hint, hint icon and hint actions. */
     async renderAfterLabel() {
         const ctx = this.context();
         const hint = await evaluate(this._hint, ctx);
@@ -97,22 +96,22 @@ export class Field extends Component {
         items.push(...this._hintActions);
         if (!items.length)
             return '';
-        // Comme Filament : les composants de la rangée ont le chemin du champ et, pour conteneur, celui du schéma du champ.
+        // Row components take the field's path, and the field's schema path as their container path.
         return renderInlineItems(this, items, { alignment: 'end', scope: { path: this.getStatePath(), containerPath: this.container.getStatePath() }, mountKey: this.getKey(), actionView: 'link' });
     }
-    /** Exécuté côté serveur quand l'état du champ change (champ `live()`). `set(nom, valeur)` modifie un autre champ du même formulaire. */
+    /** Runs on the server when the field state changes (`live()` field). `set(name, value)` changes another field of the same form. */
     afterStateUpdated(callback) { this._afterStateUpdated = callback; return this; }
     hasAfterStateUpdated() { return this._afterStateUpdated !== null; }
     async callAfterStateUpdated(set) { await this._afterStateUpdated?.({ ...this.context(), set }); }
-    /** Force l'inclusion du champ dans les données envoyées, même désactivé (`->disabled()->dehydrated()`). */
+    /** Forces the field into the submitted data, even when disabled (`.disabled().dehydrated()`). */
     dehydrated(condition = true) { this._dehydrated = condition; return this; }
-    /** Par défaut, un champ désactivé n'est ni validé ni enregistré. */
+    /** By default, a disabled field is neither validated nor saved. */
     async isDehydrated() { return this._dehydrated ?? !(await this.isDisabled()); }
     getDefaultState() { return typeof this._default === 'function' ? this._default() : this._default; }
-    /** Mise en forme de la valeur d'un enregistrement quand elle entre dans le formulaire (hydratation). */
+    /** Shapes a record value as it enters the form (hydration). */
     hydrateState(value) { return value; }
     rule(rule) { this._rules.push(rule); return this; }
-    /** Règle `unique` : la valeur ne doit pas exister dans la colonne du même nom ; `ignoreRecord` exclut l'enregistrement en cours d'édition. */
+    /** `unique` rule: the value must not exist in the column of the same name; `ignoreRecord` excludes the record being edited. */
     unique(options = {}) {
         return this.rule({
             name: 'unique',
@@ -120,7 +119,7 @@ export class Field extends Component {
                 const host = ctx.livewire;
                 const adapter = host.getDataAdapter?.();
                 if (!adapter)
-                    throw new Error('unique() : le composant hôte ne fournit pas d\'adaptateur de données (getDataAdapter).');
+                    throw new Error('unique(): the host component provides no data adapter (getDataAdapter).');
                 const ignored = options.ignoreRecord ? (ctx.record ? adapter.getKey(ctx.record) : (host.getRecordKey?.() ?? null)) : null;
                 return !(await adapter.exists(options.column ?? this._name, value, ignored));
             },
@@ -132,7 +131,7 @@ export class Field extends Component {
     isDisabled() { return evaluate(this._disabled, this.context()); }
     getErrors() { return this.livewire._errors[this.getStatePath()] ?? []; }
     hasError() { return this.getErrors().length > 0; }
-    /** Règles de validation : `required` d'abord, puis celles du champ. Les messages sont ceux de Laravel (en). */
+    /** Validation rules: `required` first, then the field's own. */
     async getValidationRules() {
         const rules = [];
         if (await this.isRequired())
@@ -140,11 +139,11 @@ export class Field extends Component {
         return [...rules, ...this._rules];
     }
     async validate() {
-        // Comme Filament : un champ non enregistré (`dehydrated(false)` : confirmation, mot de passe actuel) est quand même validé ;
-        // seul un champ désactivé (et non forcé par `dehydrated()`) y échappe.
+        // A field that is not saved (`dehydrated(false)`: confirmation, current password) is still validated;
+        // only a disabled field (not forced by `dehydrated()`) is skipped.
         if ((await this.isDisabled()) && this._dehydrated !== true)
             return [];
-        // Comme Laravel (ConvertEmptyStringsToNull) : une chaîne vide est traitée comme absente.
+        // An empty string is treated as missing.
         const value = this.context().state === '' ? null : this.context().state;
         const attribute = (await this.getLabel()).toLowerCase();
         for (const rule of await this.getValidationRules()) {
@@ -155,20 +154,19 @@ export class Field extends Component {
         }
         return [];
     }
-    /** Port de Field::wrapEmbeddedHtml (enveloppe par défaut). */
-    /** Valeur écrite dans les données à enregistrer (les champs composés n'y laissent qu'une ossature, remplie par leurs enfants). */
+    /** Value written to the data to save (composite fields only leave a skeleton, filled by their children). */
     dehydrateState(state) { return state; }
-    /** Dernière mise en forme de la valeur enregistrée, une fois les champs enfants dé-hydratés (liste d'éléments d'un Builder). */
+    /** Final shaping of the saved value, once child fields are dehydrated (e.g. a Builder's item list). */
     finalizeDehydratedState(state) { return state; }
     async wrap(html, options = {}) {
         const errors = this.getErrors();
-        // Champ d'un FusedGroup : enveloppe réduite à un libellé pour lecteurs d'écran (port de plain-field-wrapper).
+        // FusedGroup field: the wrapper is reduced to a screen-reader label.
         if (this.container.getFieldWrapperView?.() === 'filament-forms::plain-field-wrapper') {
             const label = await this.getLabel();
             const labelHtml = label === '' ? '' : options.labelAsDiv ? `<div id="${e(this.getId())}-label" class="fi-fo-field-label fi-sr-only">${e(label)}</div>` : `<label for="${e(this.getId())}" class="fi-fo-field-label fi-sr-only">${e(label)}</label>`;
             return `<div data-field-wrapper class="fi-fo-field">${labelHtml}${options.labelPrefix ?? ''}${html}${options.after ?? ''}</div>`;
         }
-        // Texte d'aide : un petit schéma « en ligne » sous le contrôle (port de belowContent).
+        // Helper text: a small inline schema under the control.
         if (this._helperText !== null)
             html += `<div id="${e(this.getHelperTextId())}" class="fi-sc fi-inline fi-sc-has-gap fi-sc-dense"><div x-data="filamentSchemaComponent(${e(js({ key: null, exposedMethods: [], path: this.getStatePath(), containerPath: this.container.getStatePath() }))})"><div class="fi-sc-component"><span class="fi-sc-text">${e(this._helperText)}</span></div></div></div>`;
         return views.render('filament-forms::components.field-wrapper', {
@@ -191,21 +189,21 @@ export class TextInput extends Field {
     _prefix = null;
     _live = null;
     static make(name) { return configured(new TextInput(name)); }
-    /** Nombre décimal : `type="number"`, `step="any"`. */
+    /** Decimal number: `type="number"`, `step="any"`. */
     numeric() { this._numeric = 'decimal'; return this.rule({ name: 'numeric', passes: (v) => String(v).trim() !== '' && Number.isFinite(Number(v)), message: (a) => `The ${a} field must be a number.` }); }
-    /** Nombre entier : `type="number"`, `step="1"`. */
+    /** Integer: `type="number"`, `step="1"`. */
     integer() { this._numeric = 'integer'; return this.rule({ name: 'integer', passes: (v) => /^-?\d+$/.test(String(v).trim()), message: (a) => `The ${a} field must be an integer.` }); }
     _step = null;
-    /** Pas de saisie d'un champ numérique (`step`), à la place de celui déduit de `numeric()` ou `integer()`. */
+    /** Input `step` of a numeric field, overriding the one implied by `numeric()` or `integer()`. */
     step(step) { this._step = step; return this; }
     minValue(value) { this._minValue = value; return this.rule({ name: 'min', passes: (v) => Number(v) >= value, message: (a) => `The ${a} field must be at least ${value}.` }); }
     maxValue(value) { this._maxValue = value; return this.rule({ name: 'max', passes: (v) => Number(v) <= value, message: (a) => `The ${a} field must not be greater than ${value}.` }); }
-    /** Libellé affiché avant la zone de saisie (ex. `$`). */
+    /** Label shown before the input (e.g. `$`). */
     prefix(label) { this._prefix = label; return this; }
     _suffix = null;
-    /** Libellé affiché après la saisie (« hours », « kg »…). */
+    /** Label shown after the input ("hours", "kg"…). */
     suffix(label) { this._suffix = label; return this; }
-    /** L'état est envoyé au serveur à chaque frappe, ou à la perte de focus avec `onBlur`. */
+    /** Sends the state to the server on every keystroke, or on blur with `onBlur`. */
     live(options = {}) { this._live = options.onBlur ? 'blur' : 'live'; return this; }
     type(type) { this._type = type; return this; }
     email(condition = true) {
@@ -217,16 +215,16 @@ export class TextInput extends Field {
     }
     password(condition = true) { this._isPassword = condition; return this; }
     revealable(condition = true) { this._isRevealable = condition; return this; }
-    /** `true` → "on", `false` → "off", chaîne → telle quelle (comme CanBeAutocompleted). */
+    /** `true` → "on", `false` → "off", a string as is. */
     autocomplete(value = true) { this._autocomplete = value === true ? 'on' : value === false ? 'off' : value; return this; }
     placeholder(text) { this._placeholder = text; return this; }
-    /** Adresse web : champ de type `url`, valeur http(s) valide exigée. */
     _mask = null;
-    /** Masque de saisie Alpine (`(999) 999-9999`) : guide la frappe dans le navigateur, sans valeur de validation. */
+    /** Alpine input mask (`(999) 999-9999`): guides typing in the browser, with no validation value. */
     mask(pattern) { this._mask = pattern; return this; }
-    /** Numéro de téléphone : chiffres, espaces et ponctuation usuelle. */
+    /** Phone number: digits, spaces and common punctuation. */
     tel() { this._type = 'tel'; return this.rule({ name: 'tel', passes: (v) => /^[+]*[(]{0,1}[0-9]{1,4}[)]{0,1}[-\s\.\/0-9]*$/.test(String(v)), message: (a) => `The ${a} field format is invalid.` }); }
     email() { this._type = 'email'; return this.rule({ name: 'email', passes: (v) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(v)), message: (a) => `The ${a} field must be a valid email address.` }); }
+    /** Web address: `url` input type, a valid http(s) value is required. */
     url() { this._type = 'url'; return this.rule({ name: 'url', passes: (v) => { try {
             return ['http:', 'https:'].includes(new URL(String(v)).protocol);
         }
@@ -235,7 +233,6 @@ export class TextInput extends Field {
         } }, message: (a) => `The ${a} field must be a valid URL.` }); }
     maxLength(length) { this._maxLength = length; return this.rule({ name: 'max', passes: (v) => String(v).length <= length, message: (a) => `The ${a} field must not be greater than ${length} characters.` }); }
     minLength(length) { this._minLength = length; return this.rule({ name: 'min', passes: (v) => String(v).length >= length, message: (a) => `The ${a} field must be at least ${length} characters.` }); }
-    /** Port de TextInput::toEmbeddedHtml (sans affixes libres, masque ni datalist pour l'instant). */
     async toHtml() {
         const isDisabled = await this.isDisabled();
         const revealable = this._isPassword && this._isRevealable;
@@ -250,7 +247,7 @@ export class TextInput extends Field {
             max: phpNumber(this._maxValue), min: phpNumber(this._minValue),
             maxlength: this._maxLength, minlength: this._minLength, placeholder: this._placeholder,
             required: (await this.isRequired()) && !isDisabled, step: this._step ?? (this._numeric === 'decimal' ? 'any' : this._numeric === 'integer' ? 1 : null), type,
-            // Comme Filament : les modificateurs (`.live`, `.blur`) s'ajoutent aussi à `wire:model.fill`.
+            // Modifiers (`.live`, `.blur`) also apply to `wire:model.fill`.
             [revealable ? model.replace('wire:model', 'wire:model.fill') : model]: this.getStatePath(),
             'x-bind:type': revealable ? "isPasswordRevealed ? 'text' : 'password'" : null,
             'x-mask': this._mask,
@@ -271,22 +268,22 @@ export class TextInput extends Field {
         }));
     }
 }
-/** Sélecteur de date natif (`<input type="date">`). Le sélecteur JavaScript de Filament n'est pas encore porté. */
+/** Native date picker (`<input type="date">`). */
 export class DatePicker extends Field {
     _maxDate = null;
     _minDate = null;
     _live = false;
     static make(name) { return configured(new DatePicker(name)); }
     _datePlaceholder = null;
-    /** Texte indicatif (les navigateurs ne l'affichent pas sur un champ `date` natif ; l'attribut est posé comme dans Filament). */
+    /** Placeholder attribute (browsers do not display it on a native `date` input). */
     placeholder(text) { this._datePlaceholder = text; return this; }
-    /** Envoie l'état au serveur dès qu'il change (`wire:model.live`). */
+    /** Sends the state to the server as soon as it changes (`wire:model.live`). */
     live(condition = true) { this._live = condition; return this; }
-    /** Comme Filament : l'état d'un DatePicker est une date `AAAA-MM-JJ`, quelle que soit la précision stockée. */
+    /** The state is a `YYYY-MM-DD` date, whatever the stored precision. */
     hydrateState(value) { return typeof value === 'string' && value.length > 10 ? value.slice(0, 10) : value; }
     static resolve(date) { return date === 'today' ? new Date().toISOString().slice(0, 10) : date; }
     async bound(date) { const value = await evaluate(date, this.context()); return value ? DatePicker.resolve(value) : null; }
-    /** Date la plus tardive acceptée : `'today'`, une date `AAAA-MM-JJ`, ou une fonction du contexte (`({ get }) => get('endDate') || 'today'`). */
+    /** Latest accepted date: `'today'`, a `YYYY-MM-DD` date, or a context function (`({ get }) => get('endDate') || 'today'`). */
     maxDate(date) {
         this._maxDate = date;
         return this.rule({ name: 'before_or_equal', passes: async (v) => { const max = await this.bound(date); return max === null || String(v).slice(0, 10) <= max; }, message: (a) => `The ${a} field must be a date before or equal to ${typeof date === 'string' ? date : 'the maximum date'}.` });
@@ -311,8 +308,8 @@ export class DatePicker extends Field {
     }
 }
 /**
- * Liste déroulante. Native (`<select>`) par défaut ; `searchable()` active le sélecteur JavaScript de Filament,
- * qui interroge le serveur par les méthodes exposées (`getSearchResultsForJs`…).
+ * Dropdown. Native (`<select>`) by default; `searchable()` switches to the JavaScript select,
+ * which queries the server through the exposed methods (`getSearchResultsForJs`…).
  */
 export class Select extends Field {
     _options = [];
@@ -328,34 +325,33 @@ export class Select extends Field {
     _searchResultsUsing = null;
     _optionLabelUsing = null;
     static make(name) { return configured(new Select(name)); }
-    /** Résultats de recherche calculés par le serveur à chaque frappe (sans liste d'options préchargée). */
+    /** Search results computed by the server on every keystroke (no preloaded option list). */
     getSearchResultsUsing(resolver) { this._searchResultsUsing = resolver; this._searchable = true; return this; }
-    /** Libellé d'une valeur ; sert aussi à valider qu'une valeur choisie par recherche existe bien. */
+    /** Label of a value; also used to validate that a searched value exists. */
     getOptionLabelUsing(resolver) { this._optionLabelUsing = resolver; return this; }
-    /** Options fixes, ou fonction (éventuellement asynchrone) évaluée à chaque requête. */
-    /** `dynamic: false` : options fournies par une fonction mais fixes pour la durée de la page (annoncées comme statiques au navigateur). */
     /**
-     * `dynamic: false` : options fournies par une fonction mais fixes pour la durée de la page.
-     * `searchOnServer: false` : la recherche se fait dans le navigateur, parmi les options déjà envoyées (cas d'une liste complète).
+     * Fixed options, or a (possibly async) function evaluated on every request.
+     * `dynamic: false`: options come from a function but stay fixed for the page's lifetime (announced as static to the browser).
+     * `searchOnServer: false`: search runs in the browser, among the options already sent (for a complete list).
      */
     options(options, config = {}) { this._options = options; this._dynamic = config.dynamic ?? null; this._searchOnServer = config.searchOnServer ?? null; return this; }
-    /** Option non sélectionnable selon le contexte (par exemple déjà choisie dans une autre ligne). */
+    /** Disables an option depending on the context (e.g. already picked in another row). */
     disableOptionWhen(condition) { this._disableOptionWhen = condition; return this; }
-    /** L'état est envoyé au serveur dès qu'il change. */
+    /** Sends the state to the server as soon as it changes. */
     live(condition = true) { this._live = condition; return this; }
     placeholder(label) { this._placeholder = label; return this; }
     _selectablePlaceholder = true;
-    /** `false` : le sélecteur natif n'a pas d'option vide (port de `selectablePlaceholder()`). */
+    /** `false`: the native select has no empty option. */
     selectablePlaceholder(condition = true) { this._selectablePlaceholder = condition; return this; }
     searchable(condition = true) { this._searchable = condition; return this; }
-    /** Sélection multiple : l'état est une liste de valeurs ; le sélecteur JavaScript est toujours utilisé. */
+    /** Multiple selection: the state is a list of values; always uses the JavaScript select. */
     multiple(condition = true) { this._multiple = condition; if (condition)
         this._searchable = true; return this; }
     isMultiple() { return this._multiple; }
-    /** Libellés de plusieurs valeurs d'un coup (sélection multiple avec recherche serveur) ; sert aussi à valider les valeurs. */
+    /** Labels of several values at once (multiple selection with server search); also used to validate the values. */
     getOptionLabelsUsing(resolver) { this._optionLabelsUsing = resolver; return this; }
     getDefaultState() { return this._default ?? (this._multiple ? [] : null); }
-    /** Valeurs sélectionnées, nettoyées : des chaînes, sans doublon. */
+    /** Sanitized selected values: unique strings. */
     selectedValues() { const state = this.context().state; return [...new Set((Array.isArray(state) ? state : []).filter((v) => typeof v === 'string' || typeof v === 'number').map(String))]; }
     async labelsOf(values) {
         if (!values.length)
@@ -364,7 +360,7 @@ export class Select extends Field {
         const map = new Map((Array.isArray(known) ? known : Object.entries(known)).map(([value, label]) => [String(value), String(label)]));
         return values.filter((value) => map.has(value)).map((value) => [value, map.get(value)]);
     }
-    /** Sans effet ici : les options sont toujours chargées avec le formulaire. */
+    /** No-op: options are always loaded with the form. */
     preload() { return this; }
     hydrateState(value) {
         if (this._multiple)
@@ -377,13 +373,13 @@ export class Select extends Field {
         return (Array.isArray(options) ? options : Object.entries(options)).map(([value, label]) => [String(value), String(label)]);
     }
     async getValidationRules() {
-        // Avec une recherche serveur, la valeur est valide si le serveur sait lui donner un libellé ; sinon elle doit figurer dans les options.
+        // With server search, a value is valid if the server can label it; otherwise it must be among the options.
         if (this._multiple)
             return [...(await super.getValidationRules()), { name: 'in', passes: async (v) => { const values = Array.isArray(v) ? v.map(String) : []; return (await this.labelsOf([...new Set(values)])).length === new Set(values).size; }, message: (a) => `The selected ${a} is invalid.` }];
         const passes = async (v) => (this._searchResultsUsing ? (await this._optionLabelUsing?.(String(v), this.context())) != null : (await this.resolveOptions()).some(([value]) => value === String(v)));
         return [...(await super.getValidationRules()), { name: 'in', passes, message: (a) => `The selected ${a} is invalid.` }];
     }
-    // --- méthodes exposées au JavaScript du sélecteur (appelées par callSchemaComponentMethod)
+    // Methods exposed to the select's JavaScript (called through callSchemaComponentMethod).
     getExposedMethods() { return ['getOptionLabel', 'getSearchResultsForJs', 'getOptionsForJs', 'getOptionLabelsForJs']; }
     static forJs(options) { return options.map(([value, label]) => ({ label, value, isDisabled: false })); }
     async getOptionsForJs() { return this.withDisabled(Select.forJs(await this.resolveOptions())); }
@@ -410,7 +406,6 @@ export class Select extends Field {
         return (await this.resolveOptions()).find(([value]) => value === String(state))?.[1] ?? null;
     }
     async getOptionLabelsForJs() { return this._multiple ? (await this.labelsOf(this.selectedValues())).map(([value, label]) => ({ label, value })) : []; }
-    // --- création et modification d'une option dans une modale (port de createOptionForm / editOptionForm)
     _createOptionForm = null;
     _createOptionUsing = null;
     _createOptionModalHeading = null;
@@ -421,27 +416,27 @@ export class Select extends Field {
     _editOptionModalHeading = null;
     _modifyEditOptionAction = null;
     /**
-     * Formulaire de la modale « Create » ouverte par le bouton « + » du champ. Sa validation est faite côté serveur ;
-     * `createOptionUsing()` enregistre l'option et rend sa valeur, qui devient l'état du champ (ajoutée à la liste pour un `multiple()`).
-     * Les options doivent être fournies par une fonction (`options(() => …)`, ou une recherche serveur) pour que la nouvelle valeur y figure.
+     * Form of the "Create" modal opened by the field's "+" button, validated on the server.
+     * `createOptionUsing()` saves the option and returns its value, which becomes the field state (appended for `multiple()`).
+     * Options must come from a function (`options(() => …)`, or server search) for the new value to appear.
      */
     createOptionForm(schema) { this._createOptionForm = schema; return this; }
-    /** Enregistre l'option à partir des données validées de la modale ; rend la valeur (clé) de l'option créée. */
+    /** Saves the option from the validated modal data; returns the value (key) of the created option. */
     createOptionUsing(callback) { this._createOptionUsing = callback; return this; }
     createOptionModalHeading(heading) { this._createOptionModalHeading = heading; return this; }
-    /** Personnalise l'action de création (libellé, icône, largeur de modale…). */
+    /** Customizes the create action (label, icon, modal width…). */
     createOptionAction(modify) { this._modifyCreateOptionAction = modify; return this; }
     /**
-     * Formulaire de la modale « Edit » de l'option sélectionnée (sélection simple seulement). Le champ devient `live()` pour que le bouton
-     * apparaisse dès qu'une option est choisie. Préremplissage par `fillEditOptionActionFormUsing()`, enregistrement par `updateOptionUsing()`.
+     * Form of the "Edit" modal for the selected option (single selection only). The field becomes `live()` so the button
+     * appears as soon as an option is picked. Filled by `fillEditOptionActionFormUsing()`, saved by `updateOptionUsing()`.
      */
     editOptionForm(schema) { this._editOptionForm = schema; this._live = true; return this; }
     updateOptionUsing(callback) { this._updateOptionUsing = callback; return this; }
-    /** Données initiales de la modale « Edit » (le contexte donne l'état courant du champ dans `state`). */
+    /** Initial data of the "Edit" modal (the context carries the current field state in `state`). */
     fillEditOptionActionFormUsing(callback) { this._fillEditOptionForm = callback; return this; }
     editOptionModalHeading(heading) { this._editOptionModalHeading = heading; return this; }
     editOptionAction(modify) { this._modifyEditOptionAction = modify; return this; }
-    /** Même formulaire pour la création et la modification. */
+    /** Same form for creating and editing. */
     manageOptionForm(schema) { return this.createOptionForm(schema).editOptionForm(schema); }
     setState(value) { writePath(this.livewire, this.getStatePath().split('.'), value); }
     getCreateOptionAction() {
@@ -455,14 +450,14 @@ export class Select extends Field {
             .schema(this._createOptionForm)
             .action(async ({ data }) => {
             if (!this._createOptionUsing)
-                throw new Error(`Select [${this.getStatePath()}] : createOptionUsing() est requis avec createOptionForm().`);
+                throw new Error(`Select [${this.getStatePath()}]: createOptionUsing() is required with createOptionForm().`);
             const created = await this._createOptionUsing(data, this.context());
             if (created === null || created === undefined || created === '')
                 return;
             this.setState(this._multiple ? [...new Set([...this.selectedValues(), String(created)])] : String(created));
             await this.callAfterStateUpdated((name, value) => writePath(this.livewire, [...this.container.getStatePath().split('.').filter(Boolean), ...name.split('.')], value));
         });
-        // Sélection multiple : « Create & create another » garde la modale ouverte sur un formulaire vide.
+        // Multiple selection: "Create & create another" keeps the modal open on an empty form.
         if (this._multiple)
             action.extraModalFooterActions([Action.make('createAnother').label(tr('modal.actions.create_another.label')).color('gray').action(`callMountedAction(${js({ another: true })})`)]);
         return this._modifyCreateOptionAction?.(action) ?? action;
@@ -480,14 +475,14 @@ export class Select extends Field {
             .fillForm(async () => (await this._fillEditOptionForm?.(this.context())) ?? {})
             .action(async ({ data }) => {
             if (!this._updateOptionUsing)
-                throw new Error(`Select [${this.getStatePath()}] : updateOptionUsing() est requis avec editOptionForm().`);
+                throw new Error(`Select [${this.getStatePath()}]: updateOptionUsing() is required with editOptionForm().`);
             await this._updateOptionUsing(data, this.context());
         });
         return this._modifyEditOptionAction?.(action) ?? action;
     }
-    /** Actions montées sur le champ : indication, création et modification d'option. */
+    /** Actions mounted on the field: hint, create option and edit option. */
     getActions() { return [...this.getHintActions(), ...[this.getCreateOptionAction(), this.getEditOptionAction()].filter((action) => action !== null)]; }
-    /** Boutons « + » et « modifier » à droite du champ (port des suffixActions de Select). */
+    /** "+" and "edit" buttons on the right of the field. */
     async suffixHtml() {
         const ctx = this.context();
         const context = { ...(this.livewire.getActionMountContext?.() ?? {}), schemaComponent: this.getKey() };
@@ -514,17 +509,17 @@ export class Select extends Field {
         const options = [this._selectablePlaceholder ? `<option value="">${isDisabled ? '' : e(this._placeholder ?? t('filament-forms::components.select.placeholder'))}</option>` : '', ...resolved.map(([value, label]) => `<option value="${e(value)}">${e(label)}</option>`)].join('');
         return this.wrap(`<div ${wrapper.toHtml()}><div class="fi-input-wrp-content-ctn"><select ${select.toHtml()}>${options}</select></div>${suffix}</div>`, { wrapperClass: 'fi-fo-select-wrp' });
     }
-    /** Port du rendu JavaScript de Select::toEmbeddedHtml (sélection simple). */
+    /** JavaScript select rendering. */
     async toJsHtml(options, isDisabled, suffix = '') {
         const state = this.context().state;
         const hasState = !this._multiple && state !== null && state !== undefined && state !== '';
         const selected = this._multiple ? await this.labelsOf(this.selectedValues()) : [];
         const isRequired = (await this.isRequired()) && !isDisabled;
-        // Champ obligatoire : une consigne pour lecteurs d'écran (« Select an option. ») est liée au sélecteur.
+        // Required field: a screen-reader instruction ("Select an option.") is linked to the select.
         const describedBy = [isRequired ? `${this.getId()}-required` : null, this.hasError() ? `${this.getId()}-error` : null].filter(Boolean).join(' ') || null;
         const accessibility = JSON.stringify({ 'aria-describedby': describedBy, 'aria-invalid': this.hasError() ? 'true' : null, 'aria-required': isRequired ? 'true' : null });
         const forJs = this.withDisabled(Select.forJs(options));
-        // Options « dynamiques » : fournies par une fonction, donc susceptibles de changer d'une requête à l'autre.
+        // Dynamic options come from a function, so they may change between requests.
         const hasDynamicOptions = this._dynamic ?? typeof this._options === 'function';
         const tr = (key, replace = {}) => t(`filament-forms::components.select.${key}`, replace);
         const config = `selectFormComponent({
@@ -580,7 +575,7 @@ export class Select extends Field {
  }"></div><div x-load x-load-src="${e(asset('select'))}" x-data="${e(config)}" wire:ignore wire:key="${e(key)}" x-on:set-select-property="$event.detail.isDisabled ? select.disable() : select.enable()" class="fi-select-input"><div x-ref="select"></div></div></div>${suffix}</div>`;
     }
 }
-/** Colonne d'un Repeater en table : intitulé et largeur. */
+/** Column of a table Repeater: label and width. */
 export class TableColumn {
     label;
     _width = null;
@@ -592,9 +587,9 @@ export class TableColumn {
 const ITEM_KEY = /^[A-Za-z0-9_-]{1,64}$/;
 const isItemKey = (key) => ITEM_KEY.test(key) && key !== '__proto__' && key !== 'constructor' && key !== 'prototype';
 /**
- * Liste d'éléments répétés, chacun avec les mêmes champs (port de Repeater, affichage en table).
- * L'état est une table `clé d'élément → champs` ; l'ordre des clés est l'ordre d'affichage.
- * Ajout, suppression et déplacement sont des actions du composant, montées avec `schemaComponent`.
+ * List of repeated items sharing the same fields, displayed as a table.
+ * The state is a map `item key → fields`; key order is display order.
+ * Add, delete and move are component actions, mounted with `schemaComponent`.
  */
 export class Repeater extends Field {
     _schema = () => [];
@@ -603,19 +598,18 @@ export class Repeater extends Field {
     _maxItems = 500;
     _itemLinks = [];
     static make(name) { return configured(new Repeater(name)); }
-    /** Champs d'un élément : une fonction, appelée pour chaque élément. */
+    /** Item fields: a function called for each item. */
     schema(factory) { this._schema = factory; return this; }
-    /** Affichage en table, une colonne par champ. */
+    /** Table display, one column per field. */
     table(columns) { this._columns = columns; return this; }
     defaultItems(count) { this._defaultItems = count; return this; }
     maxItems(count) { this._maxItems = count; return this; }
     _reorderable = true;
-    /** Faux : les éléments gardent leur ordre (cas d'une relation sans colonne d'ordre dans Filament). */
+    /** `false`: items keep their order (e.g. a relationship without an order column). */
     reorderable(condition = true) { this._reorderable = condition; return this; }
-    /** Lien affiché sur chaque ligne (équivalent d'une action d'élément à URL). */
+    /** Link shown on each row (an item action pointing to a URL). */
     extraItemLink(resolver) { this._itemLinks.push(resolver); return this; }
-    // --- état
-    /** Éléments bien formés : les clés viennent du navigateur, seules les clés simples sont retenues. */
+    /** Well-formed items only: keys come from the browser, so only simple keys are kept. */
     getItems() {
         const state = this.context().state;
         if (!state || typeof state !== 'object' || Array.isArray(state))
@@ -625,7 +619,7 @@ export class Repeater extends Field {
     setItems(items) { writePath(this.livewire, this.getStatePath().split('.'), items); }
     itemDefaults() { return Object.fromEntries(this._schema().map((field) => [field.getName(), field.getDefaultState()])); }
     getDefaultState() { return Object.fromEntries(Array.from({ length: this._defaultItems }, () => [randomUUID(), this.itemDefaults()])); }
-    /** Enregistrements d'une relation → éléments `record-<id>`, réduits aux champs déclarés. */
+    /** Relationship records → `record-<id>` items, limited to the declared fields. */
     hydrateState(value) {
         if (!Array.isArray(value))
             return value && typeof value === 'object' ? value : {};
@@ -643,7 +637,6 @@ export class Repeater extends Field {
             rules.push({ name: 'required', passes: () => Object.keys(this.getItems()).length > 0, message: (a) => `The ${a} field is required.` });
         return [...rules, ...this._rules];
     }
-    // --- actions du composant
     getActions() {
         const move = (offset) => ({ arguments: args }) => {
             const items = this.getItems();
@@ -663,7 +656,7 @@ export class Repeater extends Field {
                 return; delete items[key]; this.setItems(items); }),
             Action.make('moveUp').action(move(-1)),
             Action.make('moveDown').action(move(1)),
-            // Glisser-déposer : le navigateur envoie le nouvel ordre, accepté seulement si c'est une permutation des clés existantes.
+            // Drag and drop: the browser sends the new order, only accepted if it is a permutation of the existing keys.
             Action.make('reorder').action(({ arguments: args }) => {
                 const items = this.getItems();
                 const keys = Object.keys(items);
@@ -676,7 +669,7 @@ export class Repeater extends Field {
     }
     async toHtml() {
         if (!colorManager)
-            throw new Error('Aucun gestionnaire de couleurs : appelez useColorManager().');
+            throw new Error('No color manager: call useColorManager().');
         const id = this.getId();
         const key = this.getKey();
         const livewireKey = this.getLivewireKey() ?? '';
@@ -692,7 +685,7 @@ export class Repeater extends Field {
         const itemLabel = tr('reordering.item');
         const descriptionId = (itemKey) => `${id}-item-${createHash('md5').update(itemKey).digest('hex')}`;
         const rows = [];
-        // Comme Filament : pas de colonne de réordonnancement tant qu'il n'y a qu'une ligne.
+        // No reorder column while there is only one row.
         const hasReorderColumn = this._reorderable && keys.length > 1;
         for (const [index, itemKey] of keys.entries()) {
             const moveButton = (action, label, iconName, direction, disabled) => {
@@ -720,8 +713,7 @@ export class Repeater extends Field {
         return this.wrap(table, { labelAsDiv: true });
     }
 }
-/** Zone de texte multiligne (port de Textarea, sans redimensionnement automatique). */
-/** Heure (port de TimePicker, saisie native) : l'état est `HH:MM` avec `seconds(false)`, `HH:MM:SS` sinon. */
+/** Native time input: the state is `HH:MM` with `seconds(false)`, `HH:MM:SS` otherwise. */
 export class TimePicker extends Field {
     _seconds = true;
     static make(name) { return configured(new TimePicker(name)); }
@@ -741,7 +733,7 @@ export class TimePicker extends Field {
         return this.wrap(`<div ${wrapper.toHtml()}><div class="fi-input-wrp-content-ctn"><input ${input.toHtml()} /></div></div>`);
     }
 }
-/** Date et heure (port de DateTimePicker, saisie native `datetime-local`) : l'état enregistré est `AAAA-MM-JJ HH:MM:SS`. */
+/** Native `datetime-local` input: the saved state is `YYYY-MM-DD HH:MM:SS`. */
 export class DateTimePicker extends Field {
     _seconds = true;
     static make(name) { return configured(new DateTimePicker(name)); }
@@ -766,7 +758,7 @@ export class DateTimePicker extends Field {
         return this.wrap(`<div ${wrapper.toHtml()}><div class="fi-input-wrp-content-ctn"><input ${input.toHtml()} /></div></div>`);
     }
 }
-/** Choix unique en boutons radio (port de Radio). */
+/** Single choice as radio buttons. */
 export class Radio extends Field {
     _options = [];
     _descriptions = {};
@@ -774,9 +766,9 @@ export class Radio extends Field {
     _live = false;
     static make(name) { return configured(new Radio(name)); }
     options(options) { this._options = (Array.isArray(options) ? options : Object.entries(options)).map(([value, label]) => [String(value), String(label)]); return this; }
-    /** Texte d'aide par valeur, sous le libellé de l'option. */
+    /** Helper text per value, under the option label. */
     descriptions(descriptions) { this._descriptions = descriptions; return this; }
-    /** Options côte à côte. */
+    /** Options side by side. */
     inline(condition = true) { this._inline = condition; return this; }
     live(condition = true) { this._live = condition; return this; }
     async getValidationRules() {
@@ -807,7 +799,7 @@ export class Textarea extends Field {
     maxLength(length) { this._maxLength = length; return this.rule({ name: 'max', passes: (v) => String(v).length <= length, message: (a) => `The ${a} field must not be greater than ${length} characters.` }); }
     async toHtml() {
         const isDisabled = await this.isDisabled();
-        // Hauteur initiale : 1,5rem par ligne plus la marge intérieure (comme Filament).
+        // Initial height: 1.5rem per row plus padding.
         const height = (this._rows ?? 2) * 1.5 + 0.75;
         const textarea = new Attributes().merge({
             'aria-invalid': this.hasError() ? 'true' : null, disabled: isDisabled, id: this.getId(), maxlength: this._maxLength,
@@ -821,16 +813,16 @@ export class Textarea extends Field {
  })" x-model="state" ${textarea.toHtml()}></textarea></div></div></div>`, { wrapperClass: 'fi-fo-textarea-wrp' });
     }
 }
-/** Saisie d'une liste de mots-clés (port de TagsInput) : l'état est un tableau de chaînes. */
+/** Tag list input: the state is an array of strings. */
 export class TagsInput extends Field {
     _placeholder = null;
     _suggestions = [];
     _splitKeys = [];
     static make(name) { return configured(new TagsInput(name)); }
     placeholder(text) { this._placeholder = text; return this; }
-    /** Valeurs proposées à la saisie. */
+    /** Values suggested while typing. */
     suggestions(suggestions) { this._suggestions = suggestions.map(String).slice(0, 1000); return this; }
-    /** Touches qui valident le mot en cours, en plus d'Entrée (`['Tab', ',']`). */
+    /** Keys that confirm the current tag, besides Enter (`['Tab', ',']`). */
     splitKeys(keys) { this._splitKeys = keys; return this; }
     getDefaultState() { return this._default ?? []; }
     hydrateState(value) {
@@ -844,11 +836,11 @@ export class TagsInput extends Field {
         }
         return Array.isArray(value) ? value.filter((tag) => typeof tag === 'string' || typeof tag === 'number').map(String) : [];
     }
-    /** Seules des chaînes non vides sont enregistrées, quelle que soit la forme reçue du navigateur. */
+    /** Only non-empty strings are saved, whatever shape the browser sends. */
     dehydrateState(state) { return (Array.isArray(state) ? state : []).filter((tag) => typeof tag === 'string' || typeof tag === 'number').map((tag) => String(tag).trim()).filter((tag) => tag !== '').slice(0, 1000); }
     async toHtml() {
         if (!colorManager)
-            throw new Error('Aucun gestionnaire de couleurs : appelez useColorManager().');
+            throw new Error('No color manager: call useColorManager().');
         const id = this.getId();
         const isDisabled = await this.isDisabled();
         const label = await this.getLabel();
@@ -868,14 +860,14 @@ export class TagsInput extends Field {
                 })"><input ${input.toHtml()} /><div x-ref="liveRegion" aria-live="polite" class="fi-sr-only"></div><datalist id="${e(id)}-suggestions">${this._suggestions.map((s) => `<template x-bind:key="${e(js(s))}" x-if="! (state?.includes(${e(js(s))}) ?? true)"><option value="${e(s)}" /></template>`).join('')}</datalist><div wire:ignore wire:key="${e(this.getLivewireKey() ?? '')}.${createHash('md5').update(JSON.stringify(this.context().state ?? [])).digest('hex')}"><template x-cloak x-if="state?.length"><div class="fi-fo-tags-input-tags-ctn"><template x-for="(tag, index) in state" x-bind:key="\`\${tag}-\${index}\`"><span class="${badge}"><span class="fi-badge-label-ctn"><span class="fi-badge-label"><span x-text="tag"></span></span></span>${deleteButton}</span></template></div></template></div></div></div></div>`, { wrapperClass: 'fi-fo-tags-input-wrp' });
     }
 }
-/** Interrupteur (port de Toggle). */
+/** On/off switch. */
 export class Toggle extends Field {
     static make(name) { return configured(new Toggle(name)); }
     getDefaultState() { return this._default ?? false; }
     hydrateState(value) { return value === true || value === 1 || value === '1'; }
     async toHtml() {
         if (!colorManager)
-            throw new Error('Aucun gestionnaire de couleurs : appelez useColorManager().');
+            throw new Error('No color manager: call useColorManager().');
         const on = this.context().state === true;
         const colors = colorManager.getComponentClasses('toggle', 'primary').join(' ');
         const button = new Attributes().merge({ 'aria-describedby': this.getHelperTextId(), 'aria-checked': on ? 'true' : 'false', disabled: await this.isDisabled(), id: this.getId(), 'wire:target': this.getStatePath() }).class(['fi-fo-toggle', 'fi-toggle']);
@@ -883,7 +875,7 @@ export class Toggle extends Field {
         return this.wrap('', { labelPrefix: `<button x-data="{ state: $wire.$entangle(${e(js(this.getStatePath()))}, false) }" x-bind:aria-checked="state ? 'true' : 'false'" x-on:click="state = ! state" x-bind:class="state ? 'fi-toggle-on ${colors}' : 'fi-toggle-off'"${on ? ' x-cloak' : ''} role="switch" type="button" ${button.toHtml()}>${knob}</button>${on ? `<div x-cloak="inline-flex" wire:ignore wire:key="${e(this.getLivewireKey() ?? '')}.placeholder" class="fi-toggle fi-toggle-on fi-hidden ${colors}">${knob}</div>` : ''}` });
     }
 }
-/** Choix unique présenté en boutons (port de ToggleButtons, sélection simple). */
+/** Single choice shown as buttons. */
 export class ToggleButtons extends Field {
     _options = [];
     _inline = false;
@@ -892,23 +884,23 @@ export class ToggleButtons extends Field {
     _icons = {};
     static make(name) { return configured(new ToggleButtons(name)); }
     _live = false;
-    /** L'état est envoyé au serveur dès qu'il change. */
+    /** Sends the state to the server as soon as it changes. */
     live(condition = true) { this._live = condition; return this; }
-    /** Couleur par valeur (ex. celle d'une énumération). */
+    /** Color per value (e.g. from an enum). */
     colors(colors) { this._colors = colors; return this; }
-    /** Icône par valeur. */
+    /** Icon per value. */
     icons(icons) { this._icons = icons; return this; }
     options(options) { this._options = (Array.isArray(options) ? options : Object.entries(options)).map(([value, label]) => [String(value), String(label)]); return this; }
-    /** Boutons côte à côte. */
+    /** Buttons side by side. */
     inline(condition = true) { this._inline = condition; return this; }
-    /** Boutons accolés en un seul groupe. */
+    /** Buttons joined into a single group. */
     grouped(condition = true) { this._grouped = condition; return this; }
     async getValidationRules() {
         return [...(await super.getValidationRules()), { name: 'in', passes: (v) => this._options.some(([value]) => value === String(v)), message: (a) => `The selected ${a} is invalid.` }];
     }
     async toHtml() {
         if (!colorManager)
-            throw new Error('Aucun gestionnaire de couleurs : appelez useColorManager().');
+            throw new Error('No color manager: call useColorManager().');
         const id = this.getId();
         const isDisabled = await this.isDisabled();
         const isRequired = (await this.isRequired()) && !isDisabled;
@@ -927,17 +919,17 @@ export class ToggleButtons extends Field {
         return this.wrap(`<div ${container.toHtml()}>${items.join('')}</div>`, { wrapperClass: 'fi-fo-toggle-buttons-wrp', labelAsDiv: true, focusable: true, after });
     }
 }
-// Schéma TipTap du serveur : les nœuds et marques que l'éditeur de Filament sait produire avec sa barre d'outils par défaut.
-// Hors périmètre pour l'instant : grilles, blocs personnalisés, mentions, balises de fusion, couleur de texte, « lead » et « small ».
+// Server-side TipTap schema: the nodes and marks the rich editor's default toolbar can produce.
+// Not supported yet: grids, custom blocks, mentions, merge tags, text color, "lead" and "small".
 const RICH_EXTENSIONS = [StarterKit, TextAlign.configure({ types: ['heading', 'paragraph'], defaultAlignment: 'start' }), Subscript, Superscript, Highlight, Image, TableKit];
 const isRichDocument = (value) => !!value && typeof value === 'object' && value.type === 'doc';
 const richText = (node) => (typeof node?.text === 'string' ? node.text : '') + (Array.isArray(node?.content) ? node.content.map(richText).join('') : '');
 const hasRichContent = (node) => node?.type === 'image' || node?.type === 'horizontalRule' || (Array.isArray(node?.content) && node.content.some(hasRichContent));
-/** HTML enregistré → document TipTap. L'analyse écarte ce que le schéma ne connaît pas (scripts, attributs d'événement, liens `javascript:`). */
+/** Stored HTML → TipTap document. Parsing drops anything the schema does not know (scripts, event attributes, `javascript:` links). */
 export function richHtmlToDocument(html) { return generateJSON(html ?? '', RICH_EXTENSIONS); }
 /**
- * Document TipTap → HTML à enregistrer, ou null s'il est vide ou invalide. Le document vient du navigateur :
- * il est rendu puis ré-analysé, pour que seul ce que le schéma accepte soit conservé.
+ * TipTap document → HTML to save, or null if empty or invalid. The document comes from the browser,
+ * so it is rendered then re-parsed to keep only what the schema accepts.
  */
 export function richDocumentToHtml(document) {
     if (!isRichDocument(document))
@@ -951,8 +943,8 @@ export function richDocumentToHtml(document) {
     }
 }
 /**
- * Éditeur de texte riche (port de RichEditor) : le navigateur travaille sur un document TipTap, la base reçoit du HTML.
- * Le balisage est celui de Filament, repris de l'oracle (vue générée). Non portés : pièces jointes, blocs personnalisés, mentions.
+ * Rich text editor: the browser works on a TipTap document, the database receives HTML.
+ * Not supported yet: attachments, custom blocks, mentions.
  */
 export class RichEditor extends Field {
     static make(name) { return configured(new RichEditor(name)); }
@@ -971,7 +963,7 @@ export class RichEditor extends Field {
     getCustomBlockPreviewsForJs() { return []; }
     getUploadedFileAttachmentTemporaryUrl() { return null; }
     saveUploadedFileAttachmentAndGetUrl() { return null; }
-    /** Action « lien » de la barre d'outils : une modale (URL, nouvel onglet), puis des commandes renvoyées à l'éditeur du navigateur. */
+    /** Toolbar "link" action: a modal (URL, new tab), then commands sent back to the browser editor. */
     getActions() {
         const tr = (name) => t(`filament-forms::components.rich_editor.actions.link.${name}`);
         const key = this.getKey();
@@ -981,7 +973,7 @@ export class RichEditor extends Field {
                 .fillForm(({ arguments: args }) => ({ url: typeof args.url === 'string' ? args.url : null, shouldOpenInNewTab: args.shouldOpenInNewTab === true }))
                 .schema(() => [
                 TextInput.make('url').label(tr('modal.form.url.label'))
-                    // Seules des adresses sans code exécutable sont acceptées.
+                    // Only URLs that cannot execute code are accepted.
                     .rule({ name: 'url', passes: (value) => /^(https?:\/\/|mailto:|tel:|\/|#)/i.test(String(value)), message: (a) => `The ${a} field must be a valid URL.` }),
                 Checkbox.make('shouldOpenInNewTab').label(tr('modal.form.should_open_in_new_tab.label')),
             ])
@@ -1001,10 +993,10 @@ export class RichEditor extends Field {
         return this.wrap(views.render('filament-forms::components.rich-editor', { livewireId: this.livewire.id, key: this.getKey(), statePath: this.getStatePath(), label: await this.getLabel(), js }), { labelAsDiv: true });
     }
 }
-/** Sélecteur de couleur (port de ColorPicker, format hexadécimal). */
+/** Color picker (hex format). */
 export class ColorPicker extends Field {
     static make(name) { return configured(new ColorPicker(name)); }
-    /** Format hexadécimal (le seul pris en charge ; présent pour la compatibilité d'API). */
+    /** Hex format: the only one supported, kept for API compatibility. */
     hex() { return this; }
     constructor(name) {
         super(name);
@@ -1015,7 +1007,7 @@ export class ColorPicker extends Field {
         const state = this.context().state;
         const id = this.getId();
         const key = this.getLivewireKey() ?? '';
-        // Même empreinte que Filament : md5(serialize([$isDisabled])).
+        // Key hash over the serialized `[isDisabled]` options.
         const hash = createHash('md5').update(`a:1:{i:0;b:${isDisabled ? 1 : 0};}`).digest('hex');
         const input = new Attributes().merge({
             'aria-controls': `${id}-panel`, 'aria-expanded': 'false', 'aria-haspopup': 'dialog', 'aria-invalid': this.hasError() ? 'true' : null, autocomplete: 'off',
@@ -1045,13 +1037,13 @@ export class Checkbox extends Field {
         return this.wrap('', { labelPrefix: `<input ${input.toHtml()} />` });
     }
 }
-/** Plusieurs cases à cocher pour une liste de valeurs (port de CheckboxList, sans recherche ni « tout cocher »). */
+/** Checkboxes for a list of values (no search or "select all" yet). */
 export class CheckboxList extends Field {
     _options = [];
     _optionColumns = null;
     static make(name) { return configured(new CheckboxList(name)); }
     options(options) { this._options = (Array.isArray(options) ? options : Object.entries(options)).map(([value, label]) => [String(value), String(label)]); return this; }
-    /** Nombre de colonnes sur lesquelles les options se répartissent (à partir de `lg`). */
+    /** Number of columns the options are spread over (from `lg`). */
     columns(columns) { this._optionColumns = columns; return this; }
     getDefaultState() { return this._default ?? []; }
     hydrateState(value) {
@@ -1066,7 +1058,7 @@ export class CheckboxList extends Field {
         }
         return (Array.isArray(list) ? list : []).map(String);
     }
-    /** Seules les valeurs proposées sont retenues, sans doublon, dans l'ordre des options. */
+    /** Only offered values are kept, without duplicates, in option order. */
     dehydrateState(state) {
         const chosen = new Set((Array.isArray(state) ? state : []).map(String));
         return this._options.map(([value]) => value).filter((value) => chosen.has(value));
@@ -1089,7 +1081,7 @@ export class CheckboxList extends Field {
  })" aria-labelledby="${e(this.getId())}-label" class="fi-fo-checkbox-list"><div wire:key="${e(key)}.options" ${grid}>${options.join('')}</div></div>`, { labelAsDiv: true });
     }
 }
-/** Paires clé / valeur libres, enregistrées comme un objet (port de KeyValue). */
+/** Free-form key/value pairs, saved as an object. */
 export class KeyValue extends Field {
     _keyLabel = null;
     _valueLabel = null;
@@ -1098,8 +1090,8 @@ export class KeyValue extends Field {
     keyLabel(label) { this._keyLabel = label; return this; }
     valueLabel(label) { this._valueLabel = label; return this; }
     reorderable(condition = true) { this._reorderable = condition; return this; }
-    // Dans le formulaire, l'état est une liste de paires `{ key, value }` (ce qu'attend le composant du navigateur, et qui garde l'ordre) ;
-    // à l'enregistrement il redevient un objet.
+    // In the form, the state is a list of `{ key, value }` pairs (what the browser component expects, and it keeps order);
+    // it becomes an object again when saved.
     getDefaultState() { return KeyValue.toPairs(this._default); }
     static toPairs(value) {
         let object = value;
@@ -1114,7 +1106,7 @@ export class KeyValue extends Field {
         return object && typeof object === 'object' && !Array.isArray(object) ? Object.entries(object).map(([key, v]) => ({ key, value: v })) : [];
     }
     hydrateState(value) { return KeyValue.toPairs(value); }
-    /** Objet plat de chaînes : clés vides, objets imbriqués et clés dangereuses sont écartés ; 200 paires au plus. */
+    /** Flat object of strings: empty keys, nested objects and dangerous keys are dropped; 200 pairs at most. */
     dehydrateState(state) {
         const out = {};
         if (!Array.isArray(state))
@@ -1145,27 +1137,27 @@ export class KeyValue extends Field {
  })" wire:ignore wire:key="${e(key)}" class="fi-fo-key-value-table-ctn"><table aria-labelledby="${e(id)}-label" id="${e(id)}" class="fi-fo-key-value-table"><thead><tr>${this._reorderable ? `<th scope="col" x-show="rows.length" class="fi-has-action"><span class="fi-sr-only">${e(tr('columns.reorder.label'))}</span></th>` : ''}<th scope="col">${e(keyLabel)}</th><th scope="col">${e(valueLabel)}</th><th scope="col" x-show="rows.length" class="fi-has-action"><span class="fi-sr-only">${e(tr('columns.actions.label'))}</span></th></tr></thead><tbody${this._reorderable ? ' x-on:end.stop="reorderRows($event)" x-sortable data-sortable-animation-duration="300"' : ''}><template x-bind:key="row.id" x-for="(row, index) in rows"><tr${this._reorderable ? ' x-bind:x-sortable-item="row.id"' : ''}>${reorderCell}<td><input aria-label="${e(keyLabel)}" placeholder="" type="text" x-model="row.key" x-on:input.debounce.500ms="updateState" class="fi-input" /></td><td><input aria-label="${e(valueLabel)}" placeholder="" type="text" x-model="row.value" x-on:input.debounce.500ms="updateState" class="fi-input" /></td><td class="fi-has-action"><div x-on:click="deleteRow(index)"><button title="${e(tr('actions.delete.label'))}" aria-label="${e(tr('actions.delete.label'))}" ${iconButton} class="${dangerClasses}">${icon('m-trash')}</button></div></td></tr></template></tbody></table><span x-ref="reorderStatus" class="fi-sr-only" role="status" aria-live="polite" aria-atomic="true"></span><div x-on:click="addRow" class="fi-fo-key-value-add-action-ctn"><button ${iconButton} class="fi-ac-link-action fi-link fi-size-md"><span class="fi-link-label">${e(tr('actions.add.label'))}</span></button></div></div></div></div>`, { labelAsDiv: true, wrapperClass: 'fi-fo-key-value-wrp' });
     }
 }
-/** Expression JavaScript écrite par le développeur (formateur d'infobulle d'un Slider…), insérée telle quelle : jamais de donnée utilisateur. */
+/** Developer-written JavaScript expression (e.g. a Slider tooltip formatter), inserted as is: never put user data in it. */
 export class RawJs {
     js;
     constructor(js) { this.js = js; }
     static make(js) { return new RawJs(js); }
     toString() { return this.js; }
 }
-/** Longueur CSS simple (`10rem`, `300px`, `50%`) ; toute autre valeur est refusée (elle finirait dans un attribut `style`). */
+/** Simple CSS length (`10rem`, `300px`, `50%`); anything else is rejected, since it ends up in a `style` attribute. */
 const cssLength = (value) => (value !== null && /^\d+(\.\d+)?(px|rem|em|%|vh|vw)$/.test(value.trim()) ? value.trim() : null);
-/** Attributs d'accessibilité d'un champ (port de Field::getAccessibilityAttributes) : texte d'aide et message d'erreur. */
+/** Field accessibility attributes: helper text and error message. */
 function accessibilityOf(field, options = {}) {
     const ids = [field.getHelperTextId(), field.hasError() ? `${field.getId()}-error` : null].filter(Boolean);
     return { 'aria-describedby': ids.length ? ids.join(' ') : null, 'aria-invalid': options.withInvalid !== false && field.hasError() ? 'true' : null };
 }
-/** Second argument de `$entangle()` : vrai seulement pour un champ `live()` simple (ni `onBlur`, ni `debounce`), comme Filament. */
+/** Second `$entangle()` argument: true only for a plain `live()` field (no `onBlur`, no `debounce`). */
 const entangleLive = (live) => (live !== null && !live.onBlur && live.debounce === null ? 'true' : 'false');
 const MARKDOWN_TOOLBAR = [['bold', 'italic', 'strike', 'link'], ['heading'], ['blockquote', 'codeBlock', 'bulletList', 'orderedList'], ['table'], ['undo', 'redo']];
 /**
- * Éditeur Markdown (port de MarkdownEditor, éditeur EasyMDE de Filament). L'état est le texte Markdown brut, à nettoyer avant tout
- * affichage en HTML. Non portés : pièces jointes (le bouton `attachFiles` est absent par défaut) ; en lecture seule (`disabled()`),
- * le texte est affiché échappé, sans conversion Markdown.
+ * Markdown editor (EasyMDE). The state is raw Markdown text, to sanitize before any HTML display.
+ * Attachments are not supported (no `attachFiles` button by default); when read-only (`disabled()`),
+ * the text is shown escaped, without Markdown conversion.
  */
 export class MarkdownEditor extends Field {
     _toolbarButtons = MARKDOWN_TOOLBAR;
@@ -1174,24 +1166,24 @@ export class MarkdownEditor extends Field {
     _placeholder = null;
     _live = null;
     static make(name) { return configured(new MarkdownEditor(name)); }
-    /** Boutons de la barre d'outils, en groupes (`[['bold', 'italic'], ['undo', 'redo']]`) ou à plat. */
+    /** Toolbar buttons, grouped (`[['bold', 'italic'], ['undo', 'redo']]`) or flat. */
     toolbarButtons(buttons) { this._toolbarButtons = buttons; return this; }
-    /** Retire des boutons ; sans argument, les retire tous. */
+    /** Removes buttons; with no argument, removes them all. */
     disableToolbarButtons(names = []) {
         this._toolbarButtons = names.length ? this._toolbarButtons.map((group) => (Array.isArray(group) ? group.filter((name) => !names.includes(name)) : group)).filter((group) => (Array.isArray(group) ? group.length > 0 : !names.includes(group))) : [];
         return this;
     }
     disableAllToolbarButtons(condition = true) { if (condition)
         this._toolbarButtons = []; return this; }
-    /** Ajoute des boutons (dans un groupe à part). */
+    /** Adds buttons (in a separate group). */
     enableToolbarButtons(names) { this._toolbarButtons = [...this._toolbarButtons, names]; return this; }
     getToolbarButtons() { return this._toolbarButtons; }
     hasToolbarButton(name) { return this._toolbarButtons.some((group) => (Array.isArray(group) ? group.includes(name) : group === name)); }
-    /** Hauteur minimale de la zone d'édition (`10rem` par défaut). */
+    /** Minimum height of the editing area (`10rem` by default). */
     minHeight(height) { this._minHeight = cssLength(height); return this; }
     maxHeight(height) { this._maxHeight = cssLength(height); return this; }
     placeholder(text) { this._placeholder = text; return this; }
-    /** L'état est envoyé au serveur au fil de la frappe (`debounce` en millisecondes), ou à la perte de focus avec `onBlur`. */
+    /** Sends the state to the server while typing (`debounce` in milliseconds), or on blur with `onBlur`. */
     live(options = {}) { this._live = { onBlur: options.onBlur === true, debounce: options.debounce ?? null }; return this; }
     maxLength(length) { return this.rule({ name: 'max', passes: (v) => String(v).length <= length, message: (a) => `The ${a} field must not be greater than ${length} characters.` }); }
     minLength(length) { return this.rule({ name: 'min', passes: (v) => String(v).length >= length, message: (a) => `The ${a} field must be at least ${length} characters.` }); }
@@ -1242,23 +1234,23 @@ export class MarkdownEditor extends Field {
     }
 }
 const CODE_LANGUAGES = ['cpp', 'css', 'go', 'html', 'java', 'javascript', 'json', 'markdown', 'php', 'python', 'sql', 'xml', 'yaml'];
-/** Éditeur de code (port de CodeEditor, CodeMirror de Filament) : coloration selon `language()`, retour à la ligne avec `wrap()`. */
+/** Code editor (CodeMirror): highlighting from `language()`, line wrapping with `wrap()`. */
 export class CodeEditor extends Field {
     _language = null;
     _canWrap = false;
     _live = null;
     static make(name) { return configured(new CodeEditor(name)); }
-    /** Langage : `cpp`, `css`, `go`, `html`, `java`, `javascript`, `json`, `markdown`, `php`, `python`, `sql`, `xml`, `yaml`. */
+    /** Language: `cpp`, `css`, `go`, `html`, `java`, `javascript`, `json`, `markdown`, `php`, `python`, `sql`, `xml`, `yaml`. */
     language(language) {
         if (language !== null && !CODE_LANGUAGES.includes(language))
-            throw new Error(`CodeEditor : langage inconnu « ${language} ».`);
+            throw new Error(`CodeEditor: unknown language "${language}".`);
         this._language = language;
         return this;
     }
     getLanguage() { return this._language; }
     /**
-     * Retour à la ligne des lignes longues (port de `wrap()`). Appelée avec du HTML, c'est l'enveloppe de champ héritée,
-     * que le rendu du composant utilise.
+     * Wraps long lines. Called with an HTML string, it is the inherited field wrapper,
+     * which the component's rendering uses.
      */
     wrap(condition, options) {
         if (typeof condition === 'string')
@@ -1286,15 +1278,15 @@ export class CodeEditor extends Field {
  language: ${js(this._language)},
  state: $wire.$entangle(${js(this.getStatePath())}, ${entangleLive(this._live)}),
  })`;
-        // Même empreinte que Filament : md5(serialize([$isDisabled, $language])).
+        // Key hash over the serialized `[isDisabled, language]` options.
         const hash = createHash('md5').update(`a:2:{i:0;b:${isDisabled ? 1 : 0};i:1;${this._language === null ? 'N;' : `s:${this._language.length}:"${this._language}";`}}`).digest('hex');
         const wrapper = new Attributes().class(['fi-fo-code-editor', 'fi-input-wrp', { 'fi-disabled': isDisabled, 'fi-invalid': this.hasError() }]);
         return super.wrap(`<div ${wrapper.toHtml()}><div class="fi-input-wrp-content-ctn"><div hidden data-field-accessibility ${new Attributes().merge(accessibilityOf(this)).toHtml()}></div><div aria-labelledby="${e(id)}-label" id="${e(id)}" role="group" x-load x-load-src="${e(asset('code-editor'))}" x-data="${e(config)}" wire:ignore wire:key="${e(this.getLivewireKey() ?? '')}.${hash}"><div x-ref="editor" x-cloak></div></div></div></div>`, { labelAsDiv: true });
     }
 }
 /**
- * Curseur (port de Slider, noUiSlider de Filament) : une valeur, ou plusieurs poignées quand l'état est une liste (`default([20, 70])`).
- * Obligatoire par défaut, comme dans Filament ; les bornes, le pas et le type numérique sont vérifiés côté serveur.
+ * Slider (noUiSlider): one value, or several handles when the state is a list (`default([20, 70])`).
+ * Required by default; bounds, step and numeric type are checked on the server.
  */
 export class Slider extends Field {
     _minValue = 0;
@@ -1322,35 +1314,35 @@ export class Slider extends Field {
     range(minValue, maxValue) { this._minValue = minValue; this._maxValue = maxValue; return this; }
     minValue(value) { this._minValue = value; return this; }
     maxValue(value) { this._maxValue = value; return this; }
-    /** Pas entre deux valeurs ; `1` impose un entier, sinon la valeur doit être un multiple du pas. */
+    /** Step between values; `1` requires an integer, otherwise the value must be a multiple of the step. */
     step(step) { this._step = step; return this; }
-    /** Écart minimal / maximal entre deux poignées. */
+    /** Minimum / maximum gap between two handles. */
     minDifference(difference) { this._minDifference = difference; return this; }
     maxDifference(difference) { this._maxDifference = difference; return this; }
-    /** Marge interdite aux extrémités : un nombre, ou `[début, fin]`. */
+    /** Forbidden margin at the ends: a number, or `[start, end]`. */
     rangePadding(padding) { this._rangePadding = padding; return this; }
-    /** Segments colorés de la piste, un booléen par segment (`[true, false]` par défaut). */
+    /** Colored track segments, one boolean per segment (`[true, false]` by default). */
     fillTrack(fill = [true, false]) { this._fillTrack = fill; return this; }
     vertical(condition = true) { this._vertical = condition; return this; }
-    /** De droite à gauche (de haut en bas pour un curseur vertical, ce qui est le réglage par défaut en vertical). */
+    /** Right to left (top to bottom for a vertical slider, the default when vertical). */
     rtl(condition = true) { this._rtl = condition; return this; }
-    /** Comportement de la poignée (`tap`, `drag`, `fixed`, `snap`, `unconstrained`…) ; `null` : aucun. */
+    /** Handle behavior (`tap`, `drag`, `fixed`, `snap`, `unconstrained`…); `null`: none. */
     behavior(behavior = null) { this._behavior = behavior; return this; }
-    /** Infobulles sur les poignées : booléen, un booléen par poignée, ou `RawJs` qui formate `$value`. */
+    /** Handle tooltips: a boolean, one boolean per handle, or a `RawJs` formatting `$value`. */
     tooltips(tooltips = true) { this._tooltips = tooltips; return this; }
-    /** Graduations : `range` (par défaut), `steps`, `positions`, `count`, `values`. */
+    /** Pips: `range` (default), `steps`, `positions`, `count`, `values`. */
     pips(mode = 'range', density = null) { this._pipsMode = mode; this._pipsDensity = density; return this; }
     pipsMode(mode) { this._pipsMode = mode; return this; }
     pipsDensity(density) { this._pipsDensity = density; return this; }
-    /** Formatage des graduations (`RawJs` qui reçoit `$value`). */
+    /** Pip formatter (a `RawJs` receiving `$value`). */
     pipsFormatter(formatter) { this._pipsFormatter = formatter; return this; }
     pipsValues(values) { this._pipsValues = values; return this; }
     steppedPips(condition = true) { this._steppedPips = condition; return this; }
-    /** Filtre des graduations (`RawJs` qui reçoit `$value`). */
+    /** Pip filter (a `RawJs` receiving `$value`). */
     pipsFilter(filter) { this._pipsFilter = filter; return this; }
-    /** Échelle non linéaire (`{ '10%': 500, '50%': 4000 }`). */
+    /** Non-linear scale (`{ '10%': 500, '50%': 4000 }`). */
     nonLinearPoints(points) { this._nonLinearPoints = points; return this; }
-    /** Nombre de décimales de la valeur enregistrée. */
+    /** Decimal places of the saved value. */
     decimalPlaces(places) { this._decimalPlaces = places; return this; }
     live(options = {}) { this._live = { onBlur: options.onBlur === true, debounce: options.debounce ?? null }; return this; }
     getMinValueWithPadding() { const padding = this._rangePadding; return this._minValue + (typeof padding === 'number' ? padding : Array.isArray(padding) ? (padding[0] ?? 0) : 0); }
@@ -1378,7 +1370,7 @@ export class Slider extends Field {
             { name: step === 1 ? 'integer' : 'multiple_of', passes: each(onStep), message: (a) => (step === 1 ? `The ${a} field must be an integer.` : `The ${a} field must be a multiple of ${step}.`) },
         ];
     }
-    /** Port de convertRawJsExpressionsToFormatterObjects : un `RawJs` devient `{ to: ($value) => … }`. */
+    /** A `RawJs` becomes a `{ to: ($value) => … }` formatter object. */
     static formatters(value) {
         if (value instanceof RawJs)
             return `{ to: ($value) => ${value.js} }`;
@@ -1417,12 +1409,12 @@ export class Slider extends Field {
         const accessibility = accessibilityOf(this, { withInvalid: !this.isMultiple() });
         const attributes = new Attributes().merge({ 'aria-labelledby': `${id}-label`, id, role: 'group', ...this._extraAttributes })
             .class(['fi-fo-slider', { 'fi-fo-slider-has-pips': this._pipsMode !== null, 'fi-fo-slider-has-tooltips': hasTooltips, 'fi-fo-slider-vertical': this._vertical }]);
-        // Même empreinte que Filament : md5(serialize([$isDisabled])).
+        // Key hash over the serialized `[isDisabled]` options.
         const hash = createHash('md5').update(`a:1:{i:0;b:${isDisabled ? 1 : 0};}`).digest('hex');
         return this.wrap(`<div hidden data-field-accessibility ${new Attributes().merge(accessibility).toHtml()}></div><div x-load x-load-src="${e(asset('slider'))}" x-data="${e(config)}" wire:ignore wire:key="${e(this.getLivewireKey() ?? '')}.${hash}" ${attributes.toHtml()}></div>`, { labelAsDiv: true });
     }
 }
-/** Champ caché (port de Hidden) : un `<input type="hidden">` lié à l'état, sans libellé ni place dans la grille. */
+/** Hidden field: an `<input type="hidden">` bound to the state, with no label or grid slot. */
 export class Hidden extends Field {
     constructor(name) { super(name); this._columnSpan = { default: 'hidden' }; }
     static make(name) { return configured(new Hidden(name)); }
@@ -1431,22 +1423,22 @@ export class Hidden extends Field {
         return `<input ${attributes.toHtml()} />`;
     }
 }
-/** Code à usage unique (port de OneTimeCodeInput) : une case par chiffre ; l'état est la chaîne de chiffres, de longueur `length()` exactement. */
+/** One-time code: one box per digit; the state is a digit string of exactly `length()` characters. */
 export class OneTimeCodeInput extends Field {
     _length = 6;
     _submitOnCompletion = false;
     _readOnly = false;
     constructor(name) {
         super(name);
-        // Comme Filament : `numeric` (et non `integer`, qui refuserait les zéros de tête), puis `digits:<longueur>`.
+        // `numeric` rather than `integer`, which would reject leading zeros; then `digits:<length>`.
         this.rule({ name: 'numeric', passes: (v) => /^\d+$/.test(String(v)), message: (a) => `The ${a} field must be a number.` });
         this.rule({ name: 'digits', passes: (v) => new RegExp(`^\\d{${this._length}}$`).test(String(v)), message: (a) => `The ${a} field must be ${this._length} digits.` });
     }
     static make(name) { return configured(new OneTimeCodeInput(name)); }
-    /** Nombre de chiffres (6 par défaut). */
+    /** Number of digits (6 by default). */
     length(length) { this._length = Math.max(1, Math.min(32, Math.floor(length))); return this; }
     getLength() { return this._length; }
-    /** Soumet le formulaire dès que le dernier chiffre est saisi. */
+    /** Submits the form as soon as the last digit is typed. */
     submitOnCompletion(condition = true) { this._submitOnCompletion = condition; return this; }
     readOnly(condition = true) { this._readOnly = condition; return this; }
     hydrateState(value) { return value === null || value === undefined ? null : String(value); }
@@ -1464,8 +1456,7 @@ export class OneTimeCodeInput extends Field {
     }
 }
 /**
- * Texte en lecture seule dans un formulaire (port de Placeholder, déprécié dans Filament au profit de TextEntry avec `state()`).
- * Rien n'est enregistré. Une `HtmlString` est insérée telle quelle.
+ * Read-only text in a form. Nothing is saved. An `HtmlString` is inserted as is.
  */
 export class Placeholder extends Component {
     _label = null;
@@ -1486,7 +1477,7 @@ export class Placeholder extends Component {
         return `<div class="fi-in-entry">${labelCol}<div class="fi-in-entry-content-col"><div class="fi-in-entry-content-ctn" role="definition"><div class="fi-in-entry-content"><div class="fi-in-text-item fi-size-sm fi-in-text fi-wrapped">${html}</div></div></div></div></div>`;
     }
 }
-// --- état imbriqué : un champ placé dans un groupe à état (ex. `address.city`) se lit et s'écrit à son chemin relatif au schéma
+// Nested state: a field inside a stateful group (e.g. `address.city`) is read and written at its path relative to the schema.
 function relativePath(schema, field) {
     const base = schema.getStatePath();
     const full = field.getStatePath();
@@ -1502,13 +1493,13 @@ function writePath(target, segments, value) {
     }
     node[segments[segments.length - 1]] = value;
 }
-/** Remplit l'état par défaut de tous les champs d'un schéma (équivalent de `$this->form->fill()`). */
+/** Fills the default state of every field in a schema. */
 export function fillSchema(schema, target) {
     for (const c of schema.getFlatComponents())
         if (c instanceof Field)
             writePath(target, relativePath(schema, c), c.getDefaultState());
 }
-/** Remplit l'état du formulaire à partir d'un enregistrement, champ par champ (équivalent de `$this->form->fill($record->attributesToArray())`). */
+/** Fills the form state from a record, field by field. */
 export function fillSchemaFromRecord(schema, target, record) {
     for (const c of schema.getFlatComponents()) {
         if (!(c instanceof Field))
@@ -1517,7 +1508,7 @@ export function fillSchemaFromRecord(schema, target, record) {
         writePath(target, segments, c.hydrateState(readPath(record, segments) ?? c.getDefaultState()));
     }
 }
-/** Valide tous les champs visibles d'un schéma ; retourne les erreurs par chemin d'état. */
+/** Validates every visible field of a schema; returns errors by state path. */
 export async function validateSchema(schema) {
     const errors = {};
     for (const c of await schema.getVisibleFlatComponents()) {
@@ -1529,7 +1520,7 @@ export async function validateSchema(schema) {
     }
     return errors;
 }
-/** État à enregistrer : seulement les champs déclarés, visibles et « déshydratés » ; une chaîne vide vaut `null` (comme Laravel). */
+/** State to save: only declared, visible, dehydrated fields; an empty string becomes `null`. */
 export async function getSchemaState(schema) {
     const data = {};
     const fields = [];
@@ -1540,7 +1531,7 @@ export async function getSchemaState(schema) {
         writePath(data, relativePath(schema, c), state === '' || state === undefined ? null : state);
         fields.push(c);
     }
-    // Du plus profond au moins profond : un conteneur voit ses enfants déjà mis en forme.
+    // Deepest first: a container sees its children already shaped.
     for (const c of fields.reverse()) {
         const path = relativePath(schema, c);
         const current = readPath(data, path);
@@ -1550,11 +1541,11 @@ export async function getSchemaState(schema) {
     }
     return data;
 }
-/** Lancée depuis `beforeValidation` / `afterValidation` d'une étape pour rester sur l'étape courante (équivalent de l'exception `Halt` de Filament). */
+/** Throw from a step's `beforeValidation` / `afterValidation` to stay on the current step. */
 export class Halt extends Error {
     constructor() { super('Halt'); }
 }
-/** Une étape d'un assistant : un titre, une description et une icône facultatives, son propre schéma (port de Wizard\Step). */
+/** A wizard step: a label, an optional description and icon, and its own schema. */
 export class Step extends Component {
     children = [];
     _columns = {};
@@ -1571,9 +1562,9 @@ export class Step extends Component {
     description(description) { this._description = description; return this; }
     icon(name) { this._icon = name; return this; }
     completedIcon(name) { this._completedIcon = name; return this; }
-    /** Avant la validation de l'étape, au clic sur « Next » ; lever `Halt` pour rester sur l'étape. */
+    /** Runs before the step is validated, on "Next"; throw `Halt` to stay on the step. */
     beforeValidation(callback) { this._beforeValidation = callback; return this; }
-    /** Après une validation réussie, avant de passer à l'étape suivante ; lever `Halt` pour rester sur l'étape. */
+    /** Runs after a successful validation, before moving to the next step; throw `Halt` to stay on the step. */
     afterValidation(callback) { this._afterValidation = callback; return this; }
     getLabel() { return this.label; }
     getDescription() { return this._description; }
@@ -1583,7 +1574,7 @@ export class Step extends Component {
     async callAfterValidation() { await this._afterValidation?.(this.context()); }
     getChildSchemas() { return [childSchema(this, this.children).columns(this._columns)]; }
     async toHtml() { return this.getChildSchemas()[0].toHtml(); }
-    /** Panneau de l'étape : un `<form>` quand l'assistant sait quoi soumettre (Entrée passe à l'étape suivante, ou enregistre à la dernière). */
+    /** Step panel: a `<form>` when the wizard has a submit handler (Enter goes to the next step, or saves on the last one). */
     async toStepHtml(submitHandler, hasHeader) {
         const key = this.getKey();
         const tag = submitHandler ? 'form' : 'div';
@@ -1605,8 +1596,8 @@ export class Step extends Component {
     }
 }
 /**
- * Assistant par étapes (port de Wizard) : toutes les étapes sont rendues, le navigateur n'affiche que l'étape courante.
- * « Next » valide l'étape courante côté serveur avant d'avancer, sauf si l'assistant est `skippable()`.
+ * Multi-step wizard: every step is rendered, the browser only shows the current one.
+ * "Next" validates the current step on the server before moving on, unless the wizard is `skippable()`.
  */
 export class Wizard extends Component {
     steps;
@@ -1625,20 +1616,20 @@ export class Wizard extends Component {
     static make(steps = []) { return configured(new Wizard(steps)); }
     schema(steps) { this.steps = steps; return this; }
     label(label) { this._label = label; return this; }
-    /** Étapes accessibles dans n'importe quel ordre, sans validation au passage. */
+    /** Steps can be visited in any order, without validation. */
     skippable(condition = true) { this._skippable = condition; return this; }
-    /** Étape affichée à l'ouverture (à partir de 1). */
+    /** Step shown on open (1-based). */
     startOnStep(step) { this._startStep = step; return this; }
-    /** Faux : sans carte autour de l'assistant (c'est le cas sur une page de resource). */
+    /** `false`: no card around the wizard (as on a resource page). */
     contained(condition = true) { this._contained = condition; return this; }
     hiddenHeader(condition = true) { this._headerHidden = condition; return this; }
-    /** Action affichée à la place de « Back » sur la première étape. */
+    /** Action shown instead of "Back" on the first step. */
     cancelAction(action) { this._cancelAction = action; return this; }
-    /** Action affichée à la place de « Next » sur la dernière étape. */
+    /** Action shown instead of "Next" on the last step. */
     submitAction(action) { this._submitAction = action; return this; }
-    /** Expression Alpine exécutée quand la dernière étape est soumise au clavier (ex. `$wire.create()`). */
+    /** Alpine expression run when the last step is submitted from the keyboard (e.g. `$wire.create()`). */
     alpineSubmitHandler(handler) { this._alpineSubmitHandler = handler; return this; }
-    /** Garde l'étape courante dans l'adresse (`?step=…`). */
+    /** Keeps the current step in the URL (`?step=…`). */
     persistStepInQueryString(key = 'step') { this._stepQueryStringKey = key; return this; }
     nextAction(modify) { this._modifyNext = modify; return this; }
     previousAction(modify) { this._modifyPrevious = modify; return this; }
@@ -1648,11 +1639,11 @@ export class Wizard extends Component {
         return `${this.container.getKey()}.${this._label ? `${slug(this._label)}::${own}` : own}`;
     }
     getExposedMethods() { return ['nextStep', 'previousStep']; }
-    /** « Next » redessine le composant : les erreurs de validation de l'étape doivent apparaître. */
+    /** "Next" re-renders the component so the step's validation errors show up. */
     isRenderlessMethod() { return false; }
     getChildSchemas() { return [childSchema(this, this.steps)]; }
     getSteps() { this.getChildSchemas(); return this.steps; }
-    /** Appelée par le navigateur au clic sur « Next » : valide l'étape courante, puis annonce l'étape suivante. */
+    /** Called by the browser on "Next": validates the current step, then announces the next one. */
     async nextStep(currentStepIndex = null, currentStepKey = null) {
         const steps = this.getSteps();
         if (!Number.isInteger(currentStepIndex) || currentStepIndex < 0 || currentStepIndex >= steps.length - 1)
@@ -1680,7 +1671,7 @@ export class Wizard extends Component {
         }
         livewire.dispatch('next-wizard-step', { key: this.getKey(), step: steps[currentStepIndex + 1].getKey(), currentStep: current.getKey() });
     }
-    /** Le retour en arrière se fait dans le navigateur ; la méthode existe pour le contrat de Filament. */
+    /** Going back happens in the browser; this exposed method is a no-op the front end still calls. */
     previousStep() { }
     async toHtml() {
         const steps = this.getSteps();
@@ -1724,7 +1715,7 @@ export class Wizard extends Component {
                     })" x-on:next-wizard-step.window="${e(`if ($event.detail.key === ${js(key)}) goToNextStep($event.detail.step, $event.detail.currentStep)`)}" x-on:go-to-wizard-step.window="${e(`$event.detail.key === ${js(key)} && goToStep($event.detail.step)`)}" wire:ignore.self ${outer.toHtml()}><input type="hidden" value="${e(JSON.stringify(visibleKeys))}" x-ref="stepsData" />${this._headerHidden ? '' : `<ol${this._label ? ` aria-label="${e(this._label)}"` : ''} role="list" x-cloak x-ref="header" class="fi-sc-wizard-header">${header.join('')}</ol>`}${panels.join('')}<div x-cloak class="fi-sc-wizard-footer"><div x-cloak${previousDisabled ? '' : ' x-on:click="goToPreviousStep"'} x-show="! isFirstStep()">${await previousAction.toHtml(ctx)}</div><div x-show="isFirstStep()">${this._cancelAction ? await this._cancelAction.toHtml(ctx) : ''}</div><div x-cloak${nextDisabled ? '' : ` x-on:click.capture="if ($el.hasAttribute('aria-disabled')) { $event.preventDefault(); $event.stopImmediatePropagation() }" x-on:click="if (! $el.hasAttribute('aria-disabled')) requestNextStep()"`} x-bind:class="{ 'fi-hidden': isLastStep() }" wire:loading.attr="aria-disabled">${await nextAction.toHtml(ctx)}</div><div x-bind:class="{ 'fi-hidden': ! isLastStep() }">${this._submitAction ? await this._submitAction.toHtml(ctx) : ''}</div></div></div>`;
     }
 }
-/** Stockage sur le disque local, servi sous une adresse publique. Le nom du fichier est aléatoire, son extension vient du type détecté. */
+/** Local disk storage, served under a public URL. File names are random; the extension comes from the detected type. */
 export class LocalFileStorage {
     root;
     baseUrl;
@@ -1738,7 +1729,7 @@ export class LocalFileStorage {
         const key = [directory, `${randomUUID()}.${file.extension}`].filter(Boolean).join('/');
         const target = this.resolve(key);
         if (!target)
-            throw new Error('Dossier de téléversement invalide.');
+            throw new Error('Invalid upload directory.');
         mkdirSync(nodePath.dirname(target), { recursive: true });
         copyFileSync(file.path, target);
         writeFileSync(`${target}.meta.json`, JSON.stringify({ name: file.name, type: file.type }));
@@ -1752,17 +1743,17 @@ export class LocalFileStorage {
         try {
             meta = JSON.parse(readFileSync(`${target}.meta.json`, 'utf8'));
         }
-        catch { /* fichier déposé sans métadonnées */ }
+        catch { /* file dropped in without metadata */ }
         return { name: meta.name ?? nodePath.basename(key), size: statSync(target).size, type: meta.type ?? 'application/octet-stream', url: `${this.baseUrl}/${key.split('/').map(encodeURIComponent).join('/')}` };
     }
 }
 /**
- * Téléversement de fichiers (port de FileUpload, rendu FilePond de Filament).
- * État : `{ <clé de fichier>: <clé enregistrée> | 'livewire-file:<id temporaire>' }`. Une clé enregistrée n'est acceptée du navigateur
- * que si elle figure déjà dans l'enregistrement en cours d'édition : on ne peut pas s'attribuer le fichier d'un autre.
+ * File upload (FilePond).
+ * State: `{ <file key>: <stored key> | 'livewire-file:<temporary id>' }`. A stored key from the browser is only accepted
+ * if the record being edited already has it, so nobody can claim someone else's file.
  */
 export class FileUpload extends Field {
-    /** Stockage par défaut de l'application. */
+    /** Application-wide default storage. */
     static storage = null;
     _multiple = false;
     _maxFiles = null;
@@ -1776,17 +1767,17 @@ export class FileUpload extends Field {
     static make(name) { return configured(new FileUpload(name)); }
     multiple(condition = true) { this._multiple = condition; return this; }
     maxFiles(count) { this._maxFiles = count; return this; }
-    /** Taille maximale d'un fichier, en kilo-octets. */
+    /** Maximum file size, in kilobytes. */
     maxSize(kilobytes) { this._maxSize = kilobytes; return this; }
     reorderable(condition = true) { this._reorderable = condition; return this; }
-    /** Types MIME acceptés (`image/jpeg`, `image/*`…), vérifiés sur le contenu du fichier reçu. */
+    /** Accepted MIME types (`image/jpeg`, `image/*`…), checked against the received file's content. */
     acceptedFileTypes(types) { this._acceptedFileTypes = types; return this; }
     image() { return this.acceptedFileTypes(['image/*']); }
     directory(directory) { this._directory = directory; return this; }
     storage(storage) { this._storage = storage; return this; }
-    /** `false` : le champ n'enregistre rien lui-même ; les données reçoivent des `FileUploadEntry`, à traiter par l'adaptateur (médias). */
+    /** `false`: the field stores nothing itself; the data receives `FileUploadEntry` items for the adapter to process (media). */
     storeFiles(condition = true) { this._storeFiles = condition; return this; }
-    /** Informations d'un fichier déjà enregistré (nom, taille, type, adresse), quand elles ne viennent pas du stockage. */
+    /** Info about an already saved file (name, size, type, URL), when it does not come from the storage. */
     getUploadedFileUsing(resolver) { this._getUploadedFileUsing = resolver; return this; }
     getDefaultState() { return {}; }
     hydrateState(value) {
@@ -1795,20 +1786,19 @@ export class FileUpload extends Field {
     }
     get uploads() { return this.livewire._runtime?.uploads ?? null; }
     getStorage() { return this._storage ?? FileUpload.storage; }
-    /** Entrées de l'état, nettoyées : clé de fichier sûre, valeur chaîne. */
+    /** Sanitized state entries: safe file key, string value. */
     entries() {
         const state = this.context().state;
         if (!state || typeof state !== 'object' || Array.isArray(state))
             return [];
         return Object.entries(state).filter(([key, value]) => /^[A-Za-z0-9-]{1,64}$/.test(key) && typeof value === 'string').map(([key, value]) => [key, value]).slice(0, 100);
     }
-    /** Clés enregistrées que l'enregistrement en cours possède déjà : les seules qu'on accepte de relire depuis le navigateur. */
+    /** Stored keys the current record already owns: the only ones accepted back from the browser. */
     originalKeys() {
         const record = this.container.getRecord();
         return new Set(Object.values(this.hydrateState(record?.[this.getName()])));
     }
     isTemporary(value) { return value.startsWith('livewire-file:'); }
-    // --- méthodes exposées au JavaScript du champ
     getExposedMethods() { return ['deleteUploadedFile', 'removeUploadedFile', 'reorderUploadedFiles', 'getUploadedFiles']; }
     async getUploadedFiles() {
         const original = this.originalKeys();
@@ -1819,13 +1809,13 @@ export class FileUpload extends Field {
                 continue;
             }
             const info = this._getUploadedFileUsing ? await this._getUploadedFileUsing(value, this.context()) : await this.getStorage()?.info(value);
-            // Seules des adresses locales ou http(s) partent vers le navigateur.
+            // Only local or http(s) URLs are sent to the browser.
             files[fileKey] = info && /^(\/(?!\/)|https?:\/\/)/.test(info.url) ? info : null;
         }
         return files;
     }
     writeState(entries) { writePath(this.livewire, this.getStatePath().split('.'), Object.fromEntries(entries)); }
-    /** Retire un fichier du champ. Le fichier enregistré n'est supprimé qu'à l'enregistrement du formulaire, par l'application. */
+    /** Removes a file from the field. A stored file is only deleted by the application when the form is saved. */
     removeUploadedFile(fileKey) {
         const removed = this.entries().find(([key]) => key === fileKey);
         if (removed && this.isTemporary(removed[1]))
@@ -1858,7 +1848,7 @@ export class FileUpload extends Field {
             rules.push({ name: 'max', passes: () => temporary().every((file) => file !== null && file.size <= this._maxSize * 1024), message: (a) => `The ${a} field must not be greater than ${this._maxSize} kilobytes.` });
         return rules;
     }
-    /** La validation porte sur l'état entier, même vide (un champ obligatoire sans fichier doit échouer). */
+    /** Validates the whole state, even when empty (a required field without files must fail). */
     async validate() {
         if (!(await this.isDehydrated()))
             return [];
@@ -1868,7 +1858,7 @@ export class FileUpload extends Field {
                 return [rule.message(attribute)];
         return [];
     }
-    /** À l'enregistrement : les fichiers temporaires sont stockés, les clés existantes non reconnues sont écartées. */
+    /** On save: temporary files are stored, unrecognized existing keys are dropped. */
     async dehydrateState() {
         const original = this.originalKeys();
         const out = [];
@@ -1883,7 +1873,7 @@ export class FileUpload extends Field {
                 }
                 const storage = this.getStorage();
                 if (!storage)
-                    throw new Error('FileUpload : aucun stockage configuré (FileUpload.storage).');
+                    throw new Error('FileUpload: no storage configured (FileUpload.storage).');
                 out.push(await storage.store(file, this._directory));
                 this.uploads?.remove(file.id);
             }