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

package/lib/query-builder.js

@@ -1,11 +1,7 @@
-// Filtre « constructeur de requêtes » — port de Filament\Tables\Filters\QueryBuilder et de filament/query-builder.
-// L'utilisateur compose des règles (contrainte + opérateur + réglages), éventuellement regroupées par des blocs « OR ».
-// Tout l'état vient du navigateur : il est nettoyé contre les contraintes déclarées avant de servir (requête, indicateurs, rendu).
-// Portés : TextConstraint, NumberConstraint, BooleanConstraint, DateConstraint (avec ou sans heure), SelectConstraint,
-// RelationshipConstraint (nombre d'enregistrements liés, vide, `selectable(IsRelatedToOperator)`), contraintes sur une relation
-// (`relationship(nom, attribut)`), opérateur « Is filled » (`nullable()`), bloc OR, indicateurs.
-// Non portés : agrégats de relation (somme, moyenne… d'une colonne liée), groupes de contraintes, recherche serveur dans les listes.
-// Le SQL de date et de recherche est écrit pour SQLite, MySQL / MariaDB, PostgreSQL et SQL Server, selon le client knex de la requête.
+// Query builder filter: users compose rules (constraint + operator + settings), optionally grouped in "OR" blocks.
+// All state comes from the browser: it is sanitized against the declared constraints before any use (query, indicators, render).
+// Not supported yet: relationship aggregates (sum, average… of a related column), constraint groups, server-side option search.
+// Date and search SQL is generated for SQLite, MySQL / MariaDB, PostgreSQL and SQL Server, depending on the query's knex client.
 import { Action } from '@navette-js/actions';
 import { DatePicker, DateTimePicker, Field, Select, TextInput } from '@navette-js/forms';
 import { Block, Builder, colorsOf, iconActionButton, isItemKey, shortKey, writeState } from '@navette-js/forms/builder';
@@ -16,16 +12,16 @@ import { createHash } from 'node:crypto';
 const tr = (key, replace = {}) => t(`filament-query-builder::query-builder.${key}`, replace);
 const headline = (s) => s.replace(/[_.-]+/g, ' ').replace(/^./, (c) => c.toUpperCase());
 const scalar = (value) => typeof value === 'string' ? value.slice(0, 1000) : typeof value === 'boolean' || (typeof value === 'number' && Number.isFinite(value)) ? value : null;
-/** Réglage reçu du navigateur : un scalaire, ou une liste de scalaires (sélection multiple), bornée. */
+/** Setting received from the browser: a scalar, or a bounded list of scalars (multiple select). */
 const setting = (value) => Array.isArray(value) ? value.slice(0, MAX_LIST_VALUES).map(scalar).filter((item) => typeof item === 'string' || typeof item === 'number') : scalar(value);
-/** Plafonds appliqués à l'arbre de règles reçu du navigateur. */
+/** Limits applied to the rule tree received from the browser. */
 export const MAX_RULES = 100;
 export const MAX_NESTING_DEPTH = 3;
-/** Nombre maximal de valeurs d'une sélection multiple. */
+/** Maximum number of values in a multiple select. */
 export const MAX_LIST_VALUES = 100;
 const OR = 'or';
 const label = (group, name) => (inverse) => tr(`operators.${group}.${name}.label.${inverse ? 'inverse' : 'direct'}`);
-/** Liste de libellés à la manière de `Arr::join($labels, ', ', ' or ')`. */
+/** Joins labels as "a, b or c" using the translated glue strings. */
 const joinLabels = (labels, glueKey) => (labels.length <= 1 ? labels.join('') : `${labels.slice(0, -1).join(tr(`${glueKey}.0`))}${tr(`${glueKey}.final`)}${labels[labels.length - 1]}`);
 const summary = (group, name, inverse, replace) => tr(`operators.${group}.${name}.summary.${inverse ? 'inverse' : 'direct'}`, replace);
 const likeEscape = (text) => text.replace(/[\\%_]/g, '\\$&');
@@ -48,7 +44,7 @@ function textOperator(name, key, pattern) {
 function numberOperator(name, key, direct, inverted) {
     return {
         name, label: label('number', key), defaults: () => ({ number: null, aggregate: null }),
-        // `aggregate` ne sert qu'aux relations : le champ existe, masqué, comme dans Filament.
+        // `aggregate` is only used for relationships; the field exists but stays hidden.
         fields: () => [TextInput.make('number').label(tr('operators.number.form.number.label')).numeric().required(), Select.make('aggregate').label(tr('operators.number.form.aggregate.label')).hidden()],
         resolve: (settings, inverse, constraint) => {
             const raw = settings.number;
@@ -59,11 +55,10 @@ function numberOperator(name, key, direct, inverted) {
         },
     };
 }
-// --- dates
 const pad = (n) => String(n).padStart(2, '0');
 const toDateString = (date) => `${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())}`;
 const toDateTimeString = (date) => `${toDateString(date)} ${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())}:${pad(date.getUTCSeconds())}`;
-/** Date `AAAA-MM-JJ` réelle, sinon null. */
+/** A valid `YYYY-MM-DD` date, otherwise null. */
 function parseDate(value) {
     const m = typeof value === 'string' ? /^(\d{4})-(\d{2})-(\d{2})/.exec(value) : null;
     if (!m)
@@ -71,7 +66,7 @@ function parseDate(value) {
     const date = new Date(Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3])));
     return toDateString(date) === `${m[1]}-${m[2]}-${m[3]}` ? toDateString(date) : null;
 }
-/** Date et heure `AAAA-MM-JJ HH:MM[:SS]` (ou avec `T`) réelles → `AAAA-MM-JJ HH:MM:SS` ; une date seule vaut minuit. */
+/** A valid `YYYY-MM-DD HH:MM[:SS]` (or `T`-separated) date-time → `YYYY-MM-DD HH:MM:SS`; a bare date means midnight. */
 function parseDateTime(value) {
     const date = parseDate(value);
     if (date === null)
@@ -83,7 +78,7 @@ function parseDateTime(value) {
     return Number(hours) < 24 && Number(minutes) < 60 && Number(seconds) < 60 ? `${date} ${hours}:${minutes}:${seconds}` : null;
 }
 const formatDate = (date) => new Intl.DateTimeFormat('en-US', { month: 'short', day: 'numeric', year: 'numeric', timeZone: 'UTC' }).format(new Date(`${date.slice(0, 10)}T00:00:00Z`));
-/** Date et heure comme Carbon `toFormattedDayDateString() . ' ' . format('H:i:s')` : « Mon, Jun 1, 2026 14:30:00 ». */
+/** Formats a date-time as "Mon, Jun 1, 2026 14:30:00". */
 const formatDayDateTime = (dateTime) => `${new Intl.DateTimeFormat('en-US', { weekday: 'short', timeZone: 'UTC' }).format(new Date(`${dateTime.slice(0, 10)}T00:00:00Z`))}, ${formatDate(dateTime)} ${dateTime.length > 10 ? dateTime.slice(11, 19) : '00:00:00'}`;
 const MONTHS = Array.from({ length: 12 }, (_, i) => new Intl.DateTimeFormat('en-US', { month: 'long', timeZone: 'UTC' }).format(new Date(Date.UTC(2024, i, 1))));
 const UNITS = ['day', 'week', 'month', 'quarter', 'year'];
@@ -108,7 +103,7 @@ const shift = (now, unit, amount) => {
         date.setUTCFullYear(date.getUTCFullYear() + amount);
     return date;
 };
-/** Préréglages de fenêtre glissante (port de resolveRelativeDate). */
+/** Relative date presets. */
 const PRESETS = {
     past_decade: (n) => shift(n, 'year', -10), past_5_years: (n) => shift(n, 'year', -5), past_2_years: (n) => shift(n, 'year', -2), past_year: (n) => shift(n, 'year', -1),
     past_6_months: (n) => shift(n, 'month', -6), past_quarter: (n) => shift(n, 'quarter', -1), past_month: (n) => shift(n, 'month', -1), past_2_weeks: (n) => shift(n, 'week', -2), past_week: (n) => shift(n, 'week', -1),
@@ -117,21 +112,21 @@ const PRESETS = {
     next_week: (n) => shift(n, 'week', 1), next_2_weeks: (n) => shift(n, 'week', 2), next_month: (n) => shift(n, 'month', 1), next_quarter: (n) => shift(n, 'quarter', 1), next_6_months: (n) => shift(n, 'month', 6),
     next_year: (n) => shift(n, 'year', 1), next_2_years: (n) => shift(n, 'year', 2), next_5_years: (n) => shift(n, 'year', 5), next_decade: (n) => shift(n, 'year', 10),
 };
-/** Préréglages à la minute ou à l'heure, proposés seulement pour une contrainte `time()` : ils comparent la date et l'heure. */
+/** Minute and hour presets, only offered for `time()` constraints: they compare date and time. */
 const TIME_PRESETS = {
     past_hour: (n) => shift(n, 'hour', -1), past_minute: (n) => shift(n, 'minute', -1),
     this_hour: (n) => new Date(Date.UTC(n.getUTCFullYear(), n.getUTCMonth(), n.getUTCDate(), n.getUTCHours())), this_minute: (n) => new Date(Date.UTC(n.getUTCFullYear(), n.getUTCMonth(), n.getUTCDate(), n.getUTCHours(), n.getUTCMinutes())),
     next_minute: (n) => shift(n, 'minute', 1), next_hour: (n) => shift(n, 'hour', 1),
 };
-/** Ordre des préréglages dans la liste, comme Filament (les horaires s'intercalent seulement avec `time()`). */
+/** Preset order in the select (time presets are interleaved only with `time()`). */
 const presetNames = (hasTime) => [
     'past_decade', 'past_5_years', 'past_2_years', 'past_year', 'past_6_months', 'past_quarter', 'past_month', 'past_2_weeks', 'past_week', ...(hasTime ? ['past_hour', 'past_minute'] : []),
     'this_decade', 'this_year', 'this_quarter', 'this_month', 'today', ...(hasTime ? ['this_hour', 'this_minute', 'next_minute', 'next_hour'] : []),
     'next_week', 'next_2_weeks', 'next_month', 'next_quarter', 'next_6_months', 'next_year', 'next_2_years', 'next_5_years', 'next_decade', 'custom',
 ];
 /**
- * Moment visé par les réglages d'un opérateur « après / avant » : date fixe, préréglage, ou décalage personnalisé. `time` est vrai quand la
- * comparaison porte sur la date et l'heure (contrainte `time()` avec une date fixe, un préréglage horaire ou une unité de moins d'un jour).
+ * Moment targeted by an "after / before" operator's settings: fixed date, preset, or custom offset. `time` is true when the comparison
+ * uses date and time (`time()` constraint with a fixed date, a time preset or a sub-day unit).
  */
 function resolveRuleMoment(settings, now, hasTime) {
     if (settings.mode !== 'relative') {
@@ -144,7 +139,7 @@ function resolveRuleMoment(settings, now, hasTime) {
     if (preset !== 'custom')
         return { value: toDateString((Object.hasOwn(PRESETS, preset) ? PRESETS[preset] : PRESETS.today)(now)), time: false };
     const value = Math.floor(Number(settings.relative_value));
-    // Comme le formulaire de Filament : un entier d'au moins 1 (borné ici pour rester dans les dates représentables).
+    // An integer of at least 1, capped to stay within representable dates.
     if (!Number.isFinite(value) || value < 1 || value > 10000)
         return null;
     const units = hasTime ? [...TIME_UNITS, ...UNITS] : UNITS;
@@ -152,7 +147,7 @@ function resolveRuleMoment(settings, now, hasTime) {
     const moment = shift(now, unit, settings.tense === 'future' ? value : -value);
     return TIME_UNITS.includes(unit) ? { value: toDateTimeString(moment), time: true } : { value: toDateString(moment), time: false };
 }
-/** Date (ou date et heure, avec `hasTime`) visée par les réglages d'un opérateur « après / avant ». */
+/** Date (or date-time, with `hasTime`) targeted by an "after / before" operator's settings. */
 export function resolveRuleDate(settings, now = new Date(), hasTime = false) { return resolveRuleMoment(settings, now, hasTime)?.value ?? null; }
 function windowOperator(name, key, direct, inverted, hasTime) {
     const option = (path, names) => names.map((value) => [value, tr(`${path}.${value}`)]);
@@ -164,7 +159,6 @@ function windowOperator(name, key, direct, inverted, hasTime) {
             (hasTime ? DateTimePicker.make('date') : DatePicker.make('date')).label(tr('operators.date.form.date.label')).hidden(({ get }) => get('mode') === 'relative').required(({ get }) => get('mode') !== 'relative'),
             Select.make('preset').label(tr('operators.date.form.preset.label')).live().options(option('operators.date.presets', presetNames(hasTime))).default('past_month')
                 .hidden(({ get }) => get('mode') !== 'relative').required(({ get }) => get('mode') === 'relative'),
-            // Dans Filament ces trois champs sont fusionnés (FusedGroup) ; ici ils sont côte à côte.
             Group.make([
                 Select.make('tense').label(tr('operators.date.form.tense.label')).options(option('operators.date.form.tense.options', ['past', 'future'])).default('past').required(),
                 TextInput.make('relative_value').label(tr('operators.date.form.relative_value.label')).numeric().minValue(1).default(1).required(),
@@ -175,7 +169,7 @@ function windowOperator(name, key, direct, inverted, hasTime) {
             const moment = resolveRuleMoment(settings, new Date(), hasTime);
             if (moment === null)
                 return null;
-            // Avec l'heure, la colonne est comparée telle quelle (`where`) ; sinon, sa seule date (`whereDate`), comme Filament.
+            // With time, the column is compared as is; otherwise only its date part is compared.
             const condition = moment.time
                 ? { kind: 'compare', column: constraint.getColumn(), operator: inverse ? inverted : direct, value: moment.value }
                 : { kind: 'date', column: constraint.getColumn(), operator: inverse ? inverted : direct, value: moment.value };
@@ -183,7 +177,7 @@ function windowOperator(name, key, direct, inverted, hasTime) {
         },
     };
 }
-/** Opérateur « Is filled » (port de IsFilledOperator), proposé par les contraintes `nullable()`. */
+/** "Is filled" operator, offered by `nullable()` constraints. */
 const isFilledOperator = {
     name: 'isFilled', label: (inverse) => tr(`operators.is_filled.label.${inverse ? 'inverse' : 'direct'}`), defaults: () => null, fields: () => [],
     resolve: (_settings, inverse, constraint) => ({ condition: { kind: 'filled', column: constraint.getColumn(), negate: inverse }, summary: tr(`operators.is_filled.summary.${inverse ? 'inverse' : 'direct'}`, { attribute: constraint.getAttributeLabel() }) }),
@@ -226,8 +220,8 @@ const OPERATORS = {
     ],
 };
 /**
- * Attribut filtrable par le constructeur de requêtes (port de Constraint). La colonne et la relation interrogées sont celles déclarées
- * ici, jamais des valeurs du navigateur : celui-ci ne choisit qu'une contrainte (par son nom) et un opérateur de sa liste.
+ * Attribute the query builder can filter on. The queried column and relationship are the ones declared here, never browser values:
+ * the browser only picks a constraint (by name) and one of its operators.
  */
 export class Constraint {
     name;
@@ -239,24 +233,24 @@ export class Constraint {
     _relationship = null;
     _modifyRelationshipQuery = null;
     _nullable = false;
-    /** Modèle Objection interrogé (enregistrements de la table), pour les listes d'enregistrements liés. */
+    /** Objection model of the table's records, used to list related records. */
     _model = null;
     constructor(name, type, icon) {
         if (!isItemKey(name) || name === OR)
-            throw new Error(`Nom de contrainte invalide : ${name}`);
+            throw new Error(`Invalid constraint name: ${name}`);
         this.name = name;
         this.type = type;
         this._icon = icon;
     }
     label(label) { this._label = label; return this; }
-    /** Nom de l'attribut dans les résumés des règles (par défaut, le libellé). */
+    /** Attribute name used in rule summaries (defaults to the label). */
     attributeLabel(label) { this._attributeLabel = label; return this; }
     icon(name) { this._icon = name; return this; }
-    /** Colonne (ou alias de la requête) interrogée quand elle diffère du nom. */
+    /** Queried column (or query alias) when it differs from the name. */
     attribute(column) { this._column = column; return this; }
     /**
-     * La contrainte porte sur un attribut d'enregistrements liés (`whereHas`) : `relationship('author', 'name')` filtre sur le nom de
-     * l'auteur. La relation doit être déclarée par le modèle Objection (`relationMappings`).
+     * Filters on an attribute of related records: `relationship('author', 'name')` filters on the author's name.
+     * The relationship must be declared by the Objection model (`relationMappings`).
      */
     relationship(name, titleAttribute, modifyQueryUsing = null) {
         this._relationship = name;
@@ -265,7 +259,7 @@ export class Constraint {
         return this;
     }
     modifyRelationshipQueryUsing(callback) { this._modifyRelationshipQuery = callback; return this; }
-    /** Ajoute l'opérateur « Is filled » / « Is blank » (port de `nullable()`). */
+    /** Adds the "Is filled" / "Is blank" operator. */
     nullable(condition = true) { this._nullable = condition; return this; }
     isNullable() { return this._nullable; }
     model(model) { this._model = model; return this; }
@@ -274,11 +268,11 @@ export class Constraint {
     getAttributeLabel() { return this._attributeLabel ?? this.getLabel(); }
     getIcon() { return this._icon; }
     getColumn() { return this._column ?? this.name; }
-    /** Relation dont les enregistrements portent l'attribut, ou `null` pour une colonne de la table. */
+    /** Relationship whose records hold the attribute, or `null` for a column of the table. */
     getRelationshipName() { return this._relationship; }
     getModifyRelationshipQueryUsing() { return this._modifyRelationshipQuery; }
     getOperators() { return [...OPERATORS[this.type], ...(this._nullable ? [isFilledOperator] : [])]; }
-    /** `contains` ou `contains.inverse` → opérateur et sens ; null si la contrainte ne le déclare pas. */
+    /** `contains` or `contains.inverse` → operator and direction; null if the constraint does not declare it. */
     parseOperator(value) {
         if (typeof value !== 'string')
             return null;
@@ -287,9 +281,9 @@ export class Constraint {
         return operator ? { operator, inverse } : null;
     }
     getOperatorOptions() { return this.getOperators().flatMap((operator) => [[operator.name, operator.label(false)], [`${operator.name}.inverse`, operator.label(true)]]); }
-    /** Noms de réglages connus de la contrainte, tous opérateurs confondus (un changement d'opérateur conserve les anciens, comme Filament). */
+    /** Setting names known to the constraint across all operators (switching operator keeps the previous settings). */
     getSettingNames() { return [...new Set(this.getOperators().flatMap((operator) => Object.keys(operator.defaults() ?? {})))]; }
-    /** Réglages dont la valeur est une liste (sélection multiple). */
+    /** Settings whose value is a list (multiple select). */
     getListSettingNames() { return [...new Set(this.getOperators().flatMap((operator) => Object.entries(operator.defaults() ?? {}).filter(([, value]) => Array.isArray(value)).map(([name]) => name)))]; }
     getDefaultData() { const [first] = this.getOperators(); return { operator: first.name, settings: first.defaults() }; }
 }
@@ -302,7 +296,7 @@ export class NumberConstraint extends Constraint {
 export class BooleanConstraint extends Constraint {
     static make(name) { return configured(new BooleanConstraint(name, 'boolean', 'm-check-circle')); }
 }
-/** Date ; avec `time()`, la date et l'heure (sélecteur date-heure, préréglages et unités à la minute ou à l'heure). */
+/** Date constraint; with `time()`, date and time (date-time picker, minute and hour presets and units). */
 export class DateConstraint extends Constraint {
     _time = false;
     static make(name) { return configured(new DateConstraint(name, 'date', 'm-calendar')); }
@@ -312,13 +306,13 @@ export class DateConstraint extends Constraint {
         return [windowOperator('isAfter', 'is_after', '>=', '<', this._time), windowOperator('isBefore', 'is_before', '<=', '>', this._time), ...super.getOperators()];
     }
 }
-/** Valeur choisie dans une liste fixe (port de SelectConstraint) ; `multiple()` : l'une des valeurs choisies. */
+/** Value picked from a fixed list; with `multiple()`, any of the picked values. */
 export class SelectConstraint extends Constraint {
     _options = [];
     _multiple = false;
     _searchable = false;
     static make(name) { return configured(new SelectConstraint(name, 'select', 'm-chevron-up-down')); }
-    /** Options `[valeur, libellé]` ou `{ valeur: libellé }` ; seules ces valeurs filtrent. */
+    /** Options as `[value, label]` pairs or `{ value: label }`; only these values can filter. */
     options(options) {
         this._options = (Array.isArray(options) ? options : Object.entries(options)).map(([value, label]) => [String(value), String(label)]);
         return this;
@@ -335,7 +329,7 @@ export class SelectConstraint extends Constraint {
             fields: () => [Select.make(field).label(tr(`operators.select.is.form.${field}.label`)).options(this._options).multiple(this._multiple).searchable(this._searchable).required().columnSpanFull()],
             resolve: (settings, inverse, constraint) => {
                 const raw = settings[field];
-                // Valeurs forgées ou inconnues écartées : il ne reste que des options déclarées (sinon la règle est sans effet).
+                // Forged or unknown values are dropped: only declared options remain (otherwise the rule has no effect).
                 const values = (Array.isArray(raw) ? raw : this._multiple ? [] : [raw]).filter(known).map(String);
                 if (!values.length)
                     return null;
@@ -349,7 +343,7 @@ export class SelectConstraint extends Constraint {
         return [is, ...(this._nullable ? [isFilledOperator] : [])];
     }
 }
-/** Nombre entier d'enregistrements liés, d'au moins 1 (formulaire `count` des opérateurs de RelationshipConstraint). */
+/** Integer related-record count of at least 1 (the `count` setting of RelationshipConstraint operators). */
 const countSetting = (value) => (isNumericValue(value) && Number(value) >= 1 && Number(value) <= 1e9 ? Math.floor(Number(value)) : null);
 const isNumericValue = (value) => typeof value === 'number' ? Number.isFinite(value) : typeof value === 'string' && value.trim() !== '' && Number.isFinite(Number(value));
 function relationshipCountOperator(name, key, direct, inverted) {
@@ -365,8 +359,8 @@ function relationshipCountOperator(name, key, direct, inverted) {
     };
 }
 /**
- * Opérateur « Is » / « Contains » d'une RelationshipConstraint (port de IsRelatedToOperator) : les enregistrements liés sont choisis dans
- * une liste tirée du modèle lié, par leur clé ; `titleAttribute` est la colonne affichée.
+ * "Is" / "Contains" operator of a RelationshipConstraint: related records are picked by key from a list loaded from the related model;
+ * `titleAttribute` is the displayed column.
  */
 export class IsRelatedToOperator {
     _titleAttribute = null;
@@ -385,7 +379,7 @@ export class IsRelatedToOperator {
     optionsLimit(limit) { this._optionsLimit = Math.max(1, Math.floor(limit)); return this; }
     modifyRelationshipQueryUsing(callback) { this._modifyQuery = callback; return this; }
     getModifyRelationshipQueryUsing() { return this._modifyQuery; }
-    /** Opérateur du constructeur pour la contrainte donnée. */
+    /** Builds the query builder operator for the given constraint. */
     toOperator(constraint) {
         const field = constraint.isMultiple() ? 'values' : 'value';
         const variant = constraint.isMultiple() ? 'multiple' : 'single';
@@ -411,14 +405,14 @@ export class IsRelatedToOperator {
     getOptionsLimit() { return this._optionsLimit; }
 }
 /**
- * Enregistrements liés (port de RelationshipConstraint) : nombre minimal, maximal ou exact (`multiple()`), relation vide (`emptyable()`,
- * par défaut avec `multiple()`), ou liés à des enregistrements choisis (`selectable(IsRelatedToOperator.make()…)`).
+ * Related records: minimum, maximum or exact count (`multiple()`), empty relationship (`emptyable()`, on by default with `multiple()`),
+ * or related to picked records (`selectable(IsRelatedToOperator.make()…)`).
  */
 export class RelationshipConstraint extends Constraint {
     _multiple = false;
     _emptyable = null;
     _selectable = null;
-    /** Libellés des enregistrements liés cités par les règles, chargés avant le calcul des indicateurs. */
+    /** Labels of the related records cited by rules, loaded before indicators are computed. */
     _relatedLabels = new Map();
     static make(name) { return configured(new RelationshipConstraint(name, 'relationship', 'm-arrows-pointing-out')); }
     multiple(condition = true) { this._multiple = condition; return this; }
@@ -427,7 +421,7 @@ export class RelationshipConstraint extends Constraint {
     canBeEmpty() { return this._emptyable ?? this._multiple; }
     selectable(operator) { this._selectable = operator; return this; }
     getSelectableOperator() { return this._selectable; }
-    /** Relation interrogée : celle de `relationship()`, sinon `attribute()`, sinon le nom de la contrainte. */
+    /** Queried relationship: from `relationship()`, else `attribute()`, else the constraint name. */
     getRelationshipName() { return this._relationship ?? this.getColumn(); }
     getOperators() {
         return [
@@ -443,11 +437,11 @@ export class RelationshipConstraint extends Constraint {
         ];
     }
     getRelatedLabel(key) { return this._relatedLabels.get(String(key)) ?? null; }
-    /** Modèle lié, retrouvé par la relation du modèle de la table (déclaré, ou celui de l'adaptateur Objection de l'hôte). */
+    /** Related model, found through the table model's relationship (declared, or the host's Objection adapter model). */
     relatedModel(host) {
         const model = this._model ?? modelOfHost(host);
         if (!model?.getRelation)
-            throw new Error(`RelationshipConstraint ${this.name} : modèle de la table introuvable ; déclarez-le avec model() sur la contrainte ou le QueryBuilder.`);
+            throw new Error(`RelationshipConstraint ${this.name}: table model not found; declare it with model() on the constraint or the QueryBuilder.`);
         return model.getRelation(this.getRelationshipName()).relatedModelClass;
     }
     relatedQuery(operator, host) {
@@ -457,14 +451,14 @@ export class RelationshipConstraint extends Constraint {
         operator.getModifyRelationshipQueryUsing()?.(query);
         return { query, id: `${related.tableName}.${related.idColumn}`, title: `${related.tableName}.${title}` };
     }
-    /** Options de la liste : enregistrements du modèle lié, triés par leur titre. */
+    /** Select options: records of the related model, sorted by title. */
     async loadRelatedOptions(operator, host) {
         const { query, id, title } = this.relatedQuery(operator, host);
-        // Comme une liste non cherchable de Filament : toutes les options, ici plafonnées.
+        // All options are loaded (no server-side search), capped.
         const rows = await query.clearSelect().select({ __key: id, __title: title }).orderBy(title).limit(1000);
         return rows.map((row) => [String(row.__key), String(row.__title ?? row.__key)]);
     }
-    /** Charge les libellés des clés citées par des règles (indicateurs « Author is Ada or Linus »). */
+    /** Loads labels of the keys cited by rules (for indicators such as "Author is Ada or Linus"). */
     async loadRelatedLabels(keys, host) {
         if (!this._selectable || !keys.length)
             return;
@@ -474,7 +468,7 @@ export class RelationshipConstraint extends Constraint {
             this._relatedLabels.set(String(row.__key), String(row.__title ?? row.__key));
     }
 }
-/** Modèle Objection de la table de l'hôte (adaptateur `ObjectionAdapter`), quand l'application ne l'a pas déclaré. */
+/** Objection model of the host's table (`ObjectionAdapter`), when the application did not declare one. */
 function modelOfHost(host) {
     const adapter = host?.getDataAdapterForTable?.() ?? host?.resource?.adapter ?? null;
     const model = adapter?.model;
@@ -482,8 +476,8 @@ function modelOfHost(host) {
 }
 const isObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
 /**
- * Arbre de règles reçu du navigateur → arbre ne contenant que ce que le filtre déclare : types de blocs connus, opérateurs de la contrainte,
- * réglages scalaires aux noms connus, profondeur et nombre de règles bornés. Un opérateur inconnu est remis à vide (règle sans effet).
+ * Reduces the browser's rule tree to what the filter declares: known block types, the constraint's operators, scalar settings with
+ * known names, bounded depth and rule count. An unknown operator is reset to null (the rule has no effect).
  */
 export function sanitizeRules(constraints, raw, depth = 1, budget = { rules: MAX_RULES }) {
     const rules = {};
@@ -510,21 +504,21 @@ export function sanitizeRules(constraints, raw, depth = 1, budget = { rules: MAX
         if (!constraint)
             continue;
         budget.rules--;
-        // Une liste n'est acceptée que pour un réglage qui en est une par défaut (sélection multiple) ; ailleurs, seulement un scalaire.
+        // A list is only accepted for settings whose default is a list (multiple select); elsewhere only a scalar.
         const lists = constraint.getListSettingNames();
         const settings = isObject(data.settings) ? Object.fromEntries(constraint.getSettingNames().filter((name) => Object.hasOwn(data.settings, name)).map((name) => [name, lists.includes(name) ? setting(data.settings[name]) : scalar(data.settings[name])])) : null;
         rules[key] = { type: constraint.name, data: { operator: constraint.parseOperator(data.operator) ? data.operator : null, settings } };
     }
     return rules;
 }
-/** Règles nettoyées → conditions et libellés d'indicateurs (une entrée par règle de premier niveau qui a un effet). */
+/** Sanitized rules → conditions and indicator labels (one entry per effective top-level rule). */
 export function compileRules(constraints, rules, iteration = 1) {
     const nodes = [];
     const summaries = {};
     for (const [key, rule] of Object.entries(rules)) {
         if (rule.type === OR) {
             const groups = Object.values((rule.data.groups ?? {})).map((group) => compileRules(constraints, group.rules, iteration + 1));
-            // Un groupe sans règle effective n'ajoute rien (dans Filament, `orWhere` avec une clôture vide est ignoré).
+            // A group without effective rules adds nothing.
             const effective = groups.filter((group) => group.nodes.length);
             if (!effective.length)
                 continue;
@@ -540,7 +534,7 @@ export function compileRules(constraints, rules, iteration = 1) {
         const resolved = parsed.operator.resolve(isObject(rule.data.settings) ? rule.data.settings : {}, parsed.inverse, constraint);
         if (!resolved)
             continue;
-        // Attribut d'une relation : la condition porte sur les enregistrements liés (`whereHas`), comme Operator::applyToBaseQuery.
+        // Relationship attribute: the condition applies to the related records, unless the operator targets the base query.
         const relationship = parsed.operator.onBaseQuery ? null : constraint.getRelationshipName();
         const modify = constraint.getModifyRelationshipQueryUsing();
         nodes.push(relationship === null ? resolved.condition : { relationship, nodes: [resolved.condition], ...(modify ? { modify } : {}) });
@@ -548,7 +542,7 @@ export function compileRules(constraints, rules, iteration = 1) {
     }
     return { nodes, summaries };
 }
-/** Dialecte lu dans le client knex (`query.client.config.client`, ou celui de la connexion du modèle Objection) ; SQLite par défaut. */
+/** Dialect read from the knex client (`query.client.config.client`, or the Objection model's connection); SQLite by default. */
 export function sqlDialectOf(query) {
     const client = query?.client ?? query?.knex?.()?.client ?? query?.modelClass?.()?.knex?.()?.client;
     const configured = client?.config?.client;
@@ -561,28 +555,28 @@ export function sqlDialectOf(query) {
         return 'mssql';
     return 'sqlite';
 }
-/** Fragments SQL qui diffèrent d'une base à l'autre. `??` est la colonne (identifiant lié), jamais une valeur du navigateur. */
+/** Dialect-specific SQL fragments. `??` is the column (bound identifier), never a browser value. */
 const SQL = {
     sqlite: { date: 'date(??)', month: "cast(strftime('%m', ??) as integer)", year: "cast(strftime('%Y', ??) as integer)", text: '??', like: "?? like ? escape '\\'" },
-    // MySQL : la barre oblique inverse est déjà le caractère d'échappement de LIKE (et doit être doublée dans un littéral).
+    // MySQL: backslash is already LIKE's escape character (and would need doubling inside a literal).
     mysql: { date: 'date(??)', month: 'month(??)', year: 'year(??)', text: '??', like: '?? like ?' },
-    // PostgreSQL : LIKE sensible à la casse, d'où la comparaison en minuscules (comme Filament) ; `cast` pour les colonnes non textuelles.
+    // PostgreSQL: LIKE is case-sensitive, hence the lowercase comparison; `cast` handles non-text columns.
     pg: { date: 'cast(?? as date)', month: 'extract(month from ??)', year: 'extract(year from ??)', text: 'cast(?? as text)', like: "lower(cast(?? as text)) like ? escape '\\'" },
     mssql: { date: 'cast(?? as date)', month: 'month(??)', year: 'year(??)', text: '??', like: "?? like ? escape '\\'" },
 };
-/** Requête des enregistrements liés à ceux de la requête (sous-requête corrélée d'Objection, `relatedQuery`). */
+/** Correlated subquery of the records related to the query's records (Objection `relatedQuery`). */
 function relatedQuery(query, relationship, modify) {
     const model = query?.modelClass?.();
     if (typeof model?.relatedQuery !== 'function')
-        throw new Error(`Constructeur de requêtes : la relation ${relationship} demande une requête Objection (modèle avec relationMappings).`);
-    // Alias fixé ici (sinon Objection en pose un seulement pour certaines relations) : les colonnes liées sont qualifiées par lui.
+        throw new Error(`Query builder: relationship ${relationship} requires an Objection query (model with relationMappings).`);
+    // Fixed alias (Objection only sets one for some relationships): related columns are qualified with it.
     const sub = model.relatedQuery(relationship).alias(`${relationship}_related`);
     modify?.(sub);
     return sub;
 }
 /**
- * Applique des conditions à une requête knex / objection. Colonnes passées en identifiants, valeurs en paramètres liés ; les opérateurs
- * de comparaison viennent d'une liste fermée. Le SQL de date et de recherche suit le dialecte de la connexion.
+ * Applies conditions to a knex / objection query. Columns are bound as identifiers and values as parameters; comparison operators
+ * come from a closed list. Date and search SQL follows the connection's dialect.
  */
 export function applyConditions(query, nodes, dialect = sqlDialectOf(query)) {
     const sql = SQL[dialect];
@@ -593,7 +587,7 @@ export function applyConditions(query, nodes, dialect = sqlDialectOf(query)) {
         }
         else if ('nodes' in node) {
             const sub = relatedQuery(query, node.relationship, node.modify);
-            // Colonne qualifiée par la table liée : la sous-requête peut joindre une table pivot.
+            // Qualify columns with the related table: the subquery may join a pivot table.
             const table = sub.tableRefFor(sub.modelClass());
             sub.where((inner) => applyConditions(inner, node.nodes.map((child) => qualify(child, table)), dialect));
             query.whereExists(sub);
@@ -611,7 +605,7 @@ export function applyConditions(query, nodes, dialect = sqlDialectOf(query)) {
         else if (node.kind === 'year')
             query.whereRaw(`${sql.year} ${node.operator} ?`, [node.column, node.value]);
         else if (node.kind === 'filled') {
-            // Port de IsFilledOperator : ni NULL ni chaîne vide (la colonne est lue en texte sous PostgreSQL).
+            // Neither NULL nor an empty string (the column is cast to text on PostgreSQL).
             const column = node.column;
             query.where((inner) => (node.negate ? inner.whereNull(column).orWhereRaw(`${sql.text} = ?`, [column, '']) : inner.whereNotNull(column).whereRaw(`not (${sql.text} = ?)`, [column, ''])));
         }
@@ -622,7 +616,7 @@ export function applyConditions(query, nodes, dialect = sqlDialectOf(query)) {
                 query.whereIn(node.column, node.values);
         }
         else if (node.kind === 'relationCount') {
-            // Sous-requête de comptage en paramètre lié (Objection ne l'accepte pas comme colonne de `where`).
+            // Count subquery passed as a bound parameter (Objection does not accept it as a `where` column).
             query.whereRaw(`(?) ${node.operator} ?`, [relatedQuery(query, node.relationship, node.modify).count(), node.value]);
         }
         else if (node.kind === 'related') {
@@ -638,7 +632,7 @@ export function applyConditions(query, nodes, dialect = sqlDialectOf(query)) {
         }
     }
 }
-/** Colonne d'une condition qualifiée par la table des enregistrements liés (sauf si elle l'est déjà). */
+/** Qualifies a condition's column with the related table (unless already qualified). */
 function qualify(node, table) {
     if ('or' in node)
         return { or: node.or.map((group) => group.map((child) => qualify(child, table))) };
@@ -646,11 +640,11 @@ function qualify(node, table) {
         return node;
     return { ...node, column: `${table}.${node.column}` };
 }
-// ------------------------------------------------------------------ formulaire
+// ------------------------------------------------------------------ form
 const CONTAINER_GRID = { '@md': 2, '@xl': 3, '!@sm': 2, '!@md': 3 };
 const SETTINGS_GRID = { '@xl': 2, '!@md': 2 };
 const anonymousScope = (path) => `x-data="filamentSchemaComponent(${e(js({ key: null, exposedMethods: [], path, containerPath: path }))})"`;
-/** Réglages d'un opérateur : groupe à état `settings`, masqué quand l'opérateur n'a pas de formulaire. */
+/** Operator settings: a stateful `settings` group, hidden when the operator has no form. */
 class SettingsGroup extends Component {
     fields;
     constructor(fields) {
@@ -667,13 +661,13 @@ class SettingsGroup extends Component {
     }
     async toHtml() { return `<div id="${e(this.getKey())}">${await this.getChildSchemas()[0].toHtml()}</div>`; }
 }
-/** Boutons « dupliquer » et « supprimer » d'un élément, portés par le Builder parent. */
+/** "Clone" and "delete" buttons of an item; the actions belong to the parent Builder. */
 function itemActions(builder, itemKey, path, cloneDisabled) {
     const label = (name) => t(`filament-forms::components.builder.actions.${name}.label`);
     const danger = colorsOf(builder.livewire)?.getComponentClasses('icon-button', 'danger') ?? [];
     return `<div wire:key="" ${anonymousScope(path)}><div class="fi-sc-actions"><div class="fi-ac">${iconActionButton({ label: label('clone'), icon: 'm-square-2-stack', expression: builder.actionExpression('clone', { item: itemKey }), disabled: cloneDisabled })}${iconActionButton({ label: label('delete'), icon: 'm-trash', expression: builder.actionExpression('delete', { item: itemKey }), colorClasses: danger })}</div></div></div>`;
 }
-/** Ligne d'une règle : sélecteur d'opérateur, réglages, actions (port du Flex de Constraint::getBuilderBlock). */
+/** Rule row: operator select, settings, actions. */
 class RuleRow extends Component {
     builder;
     itemKey;
@@ -685,7 +679,7 @@ class RuleRow extends Component {
         const constraint = this.constraint;
         const parsed = constraint.parseOperator(this.data.operator);
         const operator = Select.make('operator').label(constraint.getLabel()).placeholder(t('filament-forms::components.select.placeholder')).options(constraint.getOperatorOptions()).live()
-            // Changement d'opérateur : ses réglages par défaut complètent les réglages existants (comme `fill()` dans Filament).
+            // On operator change, its default settings fill in the gaps without overwriting existing settings.
             .afterStateUpdated(({ state, get, set }) => {
             const next = constraint.parseOperator(state)?.operator.defaults() ?? null;
             const current = get('settings');
@@ -694,14 +688,14 @@ class RuleRow extends Component {
         return [new Schema(c.livewire).key(c.getKey()).statePath(c.getStatePath() || null).operation(c.getOperation()).record(c.getRecord()).root(false).columns(CONTAINER_GRID).dense()
                 .components([operator, new SettingsGroup(parsed ? parsed.operator.fields() : [])])];
     }
-    /** Le conteneur de la ligne est un conteneur de requêtes CSS (`gridContainer()`), dont dépendent les colonnes `@md` / `@xl`. */
+    /** The row is a CSS container (`fi-grid-ctn`), which the `@md` / `@xl` columns depend on. */
     async toSchemaHtml(isVisible) { return (await super.toSchemaHtml(isVisible)).replace('class="fi-sc-component"', 'class="fi-sc-component fi-grid-ctn"'); }
     async toHtml() {
         const path = this.container.getStatePath();
         return `<div role="group" aria-label="${e(this.constraint.getLabel())}" class="fi-sc-flex fi-from-default"><div wire:key="" ${anonymousScope(path)} class="fi-growable"><div>${await this.getChildSchemas()[0].toHtml()}</div></div>${itemActions(this.builder, this.itemKey, path, this.builder.isAtRuleLimit())}</div>`;
     }
 }
-/** Groupes d'un bloc « OR » : chaque groupe contient son propre constructeur de règles (port du Repeater `groups`). */
+/** Groups of an "OR" block: each group holds its own rule builder (rendered as a repeater). */
 class OrGroups extends Field {
     builder;
     itemKey;
@@ -759,7 +753,7 @@ class OrGroups extends Field {
         return `<div role="group" aria-label="${e(tr('form.or_groups.block.label'))}" class="fi-sc-flex fi-from-default"><div wire:key="${e(livewireKey)}" ${anonymousScope(path)} class="fi-growable">${await this.wrap(repeater, { labelAsDiv: true })}</div>${itemActions(this.builder, this.itemKey, path, this.builder.isAtRuleLimit())}</div>`;
     }
 }
-/** Constructeur de règles (port de RuleBuilder) : un Builder dont les blocs sont les contraintes du filtre, plus le bloc « OR ». */
+/** Rule builder: a Builder whose blocks are the filter's constraints, plus the "OR" block. */
 export class RuleBuilder extends Builder {
     filter;
     depth;
@@ -782,7 +776,7 @@ export class RuleBuilder extends Builder {
             .blockPickerColumns(columns).blockPickerWidth(columns === 2 ? 'md' : columns === 3 ? '2xl' : null)
             .extraClass('fi-fo-builder-not-contained').maxItems(MAX_RULES);
     }
-    /** Le bloc « OR » n'est plus proposé (ni accepté) quand il dépasserait la profondeur autorisée ; rien ne l'est une fois le plafond de règles atteint. */
+    /** The "OR" block is neither offered nor accepted beyond the maximum depth; nothing is offered once the rule limit is reached. */
     getBlockPickerBlocks() {
         if (this.isAtRuleLimit())
             return [];
@@ -790,13 +784,13 @@ export class RuleBuilder extends Builder {
     }
     getBlock(name) { return name === OR && this.depth >= MAX_NESTING_DEPTH ? undefined : super.getBlock(name); }
     canAdd() { return !this.isAtRuleLimit(); }
-    /** Nombre de règles de l'arbre entier (les blocs « OR » ne comptent pas), lu dans l'état différé de l'hôte. */
+    /** Counts rules across the whole tree ("OR" blocks excluded), read from the host's deferred filter state. */
     isAtRuleLimit() { return this.filter.countRules(this.livewire.tableDeferredFilters?.[this.filter.name]) >= MAX_RULES; }
-    /** Action de composant sans modale (utilisée aussi par les groupes « OR »). */
+    /** Component action without modal (also used by "OR" groups). */
     makeAction(name, handler) { return this.getActions()[0].constructor.make(name).action(({ arguments: args }) => handler(args)); }
 }
-// ------------------------------------------------------------------ filtre
-/** Filtre « constructeur de requêtes » d'une table. */
+// ------------------------------------------------------------------ filter
+/** Query builder table filter. */
 export class QueryBuilder {
     name = 'queryBuilder';
     _constraints = [];
@@ -805,7 +799,7 @@ export class QueryBuilder {
     static make() { return configured(new QueryBuilder()); }
     constraints(constraints) {
         if (new Set(constraints.map((c) => c.name)).size !== constraints.length)
-            throw new Error('QueryBuilder : deux contraintes portent le même nom.');
+            throw new Error('QueryBuilder: two constraints have the same name.');
         this._constraints = constraints;
         if (this._model)
             for (const constraint of constraints)
@@ -813,7 +807,7 @@ export class QueryBuilder {
                     constraint.model(this._model);
         return this;
     }
-    /** Modèle Objection de la table, transmis aux contraintes de relation (listes d'enregistrements liés). */
+    /** Objection model of the table, passed to relationship constraints (related record lists). */
     model(model) {
         this._model = model;
         for (const constraint of this._constraints)
@@ -821,7 +815,7 @@ export class QueryBuilder {
                 constraint.model(model);
         return this;
     }
-    /** Avant les indicateurs : charge les libellés des enregistrements liés que citent les règles (`RelationshipConstraint.selectable`). */
+    /** Before indicators: loads labels of the related records cited by rules (`RelationshipConstraint.selectable`). */
     async loadIndicatorData(state, host) {
         const keys = new Map();
         const walk = (rules) => {
@@ -849,7 +843,7 @@ export class QueryBuilder {
     getLabel() { return tr('label'); }
     getDefaultState() { return { rules: {} }; }
     getFormDefinition() { return { placeholder: '', options: [] }; }
-    /** Le filtre occupe toute la largeur du formulaire des filtres. */
+    /** The filter spans the full width of the filters form. */
     getColumnSpan() { return { default: 'full' }; }
     getFormComponents() { return [new RuleBuilder('rules', this).label(this.getLabel()).hiddenLabel()]; }
     sanitizeState(state) { return { rules: sanitizeRules(this._constraints, isObject(state) ? state.rules : null) }; }
@@ -860,7 +854,7 @@ export class QueryBuilder {
     compile(state) { return compileRules(this._constraints, this.sanitizeState(state).rules); }
     isActive(state) { return this.compile(state).nodes.length > 0; }
     getIndicators(state) { return Object.entries(this.compile(state).summaries).map(([field, label]) => ({ label, field })); }
-    /** Retrait d'un indicateur : la règle de premier niveau correspondante disparaît. */
+    /** Removing an indicator removes the matching top-level rule. */
     removeIndicator(state, field) {
         const rules = { ...this.sanitizeState(state).rules };
         if (Object.hasOwn(rules, field))