@dnax/ui 0.0.65 → 0.0.67

package/components/QSpreadsheet.vue

@@ -186,6 +186,10 @@ import {
   ISO_DATE,
   isoAddDays,
   shiftFormulaRefs,
+  functionQueryAt,
+  rankSuggestions,
+  functionCallAt,
+  signatureArgs,
   csvEscape,
   deriveCols,
   parseCsv,
@@ -349,6 +353,9 @@ const I18N = {
     sheet: "Sheet",
     fxPlaceholder: "Value or formula (=SUM(A1:A3)…)",
     fxNoSel: "Select a cell…",
+    fxSyntax: "Syntax error",
+    fxEmpty: "empty",
+    fxColumn: "column",
     cut: "Cut",
     copy: "Copy",
     paste: "Paste",
@@ -427,6 +434,9 @@ const I18N = {
     sheet: "Feuille",
     fxPlaceholder: "Valeur ou formule (=SOMME(A1:A3)…)",
     fxNoSel: "Sélectionnez une cellule…",
+    fxSyntax: "Erreur de syntaxe",
+    fxEmpty: "vide",
+    fxColumn: "colonne",
     cut: "Couper",
     copy: "Copier",
     paste: "Coller",
@@ -1069,11 +1079,13 @@ const coerceValue = (col: QSpreadsheetColumn | undefined, text: unknown, old: an
   const raw = String(text ?? "")
   const t = raw.trim()
   if (t === "") return null
-  // Formule A1 : conservée brute dans la cellule (booléen/choix exclus)
+  // Formule A1 : conservée brute dans la cellule (booléen/choix exclus) —
+  // `t` (déjà trimé) évite qu'un `"  =…"` ne soit traité comme une formule par
+  // `isFormulaRaw` tout en échouant au parsing du moteur.
   if (t.startsWith("=")) {
     if (col?.type === "boolean" || col?.type === "select" || col?.type === "multiselect")
       return old
-    return raw
+    return t
   }
   if (col?.type === "number") {
     const n = Number(raw)
@@ -1924,6 +1936,41 @@ const fxCanEdit = computed(() => {
   )
 })
 
+/**
+ * Aperçu **live** du résultat de la formule en cours de saisie dans la barre fx.
+ * Évaluée dans le contexte de la ligne sélectionnée (références par nom de colonne
+ * et A1 résolues sur la grille mémorisée). `null` si la saisie n'est pas une formule.
+ */
+const fxPreview = computed<{ text: string; error: boolean; hint: string } | null>(() => {
+  // Pendant l'édition en cellule, la grille affiche déjà le résultat.
+  if (editing.value || !sel.value || !fxCanEdit.value) return null
+  const source = fxDraft.value
+  if (!isFormulaRaw(source)) return null
+  const row = sel.value.row
+  const value = evaluateFormula(source, {
+    row,
+    resolveField: (name) => {
+      const i = colIndex(name)
+      return i === -1 ? undefined : evaluated.value[row]?.[i]
+    },
+    resolveCell: (r, c) => evaluated.value[r]?.[c],
+  })
+  if (isError(value)) {
+    return {
+      text: value.code,
+      error: true,
+      hint: value.code === "#ERROR!" ? t("fxSyntax") : value.code,
+    }
+  }
+  if (value === null || value === undefined || value === "") {
+    return { text: t("fxEmpty"), error: false, hint: "" }
+  }
+  const text = typeof value === "number"
+    ? new Intl.NumberFormat(lang.value, { maximumFractionDigits: 6 }).format(value)
+    : String(value)
+  return { text: text.length > 60 ? text.slice(0, 59) + "…" : text, error: false, hint: "" }
+})
+
 const commitFx = async () => {
   if (!sel.value) return
   if (!fxCanEdit.value) {
@@ -1939,7 +1986,21 @@ const commitFx = async () => {
 }
 
 const onFxInput = (e: Event) => {
-  fxDraft.value = (e.target as HTMLInputElement).value
+  const el = e.target as HTMLInputElement
+  fxDraft.value = el.value
+  fxCaret.value = el.selectionStart
+}
+
+/** Position du curseur depuis un événement (`null` si indisponible). */
+const caretFrom = (e: Event): number | null => {
+  const el = e.target as HTMLInputElement | HTMLTextAreaElement | null
+  return el && typeof el.selectionStart === "number" ? el.selectionStart : null
+}
+const syncFxCaret = (e: Event) => {
+  fxCaret.value = caretFrom(e)
+}
+const syncEditCaret = (e: Event) => {
+  editCaret.value = caretFrom(e)
 }
 
 const onFxKeydown = (e: KeyboardEvent) => {
@@ -1984,12 +2045,30 @@ const onFxKeydown = (e: KeyboardEvent) => {
 
 // ─── Autocomplétion des fonctions (barre fx + éditeur formule) ───
 const FORMULA_FNS: { name: string; sig: string }[] = [
+  // Agrégats & critères
   { name: "SUM", sig: "a, b, …" },
+  { name: "SUMIF", sig: "range, criteria, [sum_range]" },
+  { name: "SUMIFS", sig: "sum_range, range1, crit1…" },
   { name: "AVERAGE", sig: "a, b, …" },
-  { name: "MIN", sig: "a, b, …" },
-  { name: "MAX", sig: "a, b, …" },
+  { name: "AVERAGEIF", sig: "range, criteria, [avg_range]" },
+  { name: "AVERAGEIFS", sig: "avg_range, range1, crit1…" },
   { name: "COUNT", sig: "a, b, …" },
   { name: "COUNTA", sig: "a, b, …" },
+  { name: "COUNTIF", sig: "range, criteria" },
+  { name: "COUNTIFS", sig: "range1, crit1…" },
+  { name: "SUMPRODUCT", sig: "range1, range2…" },
+  { name: "MIN", sig: "a, b, …" },
+  { name: "MAX", sig: "a, b, …" },
+  { name: "MEDIAN", sig: "a, b, …" },
+  // Statistiques
+  { name: "LARGE", sig: "range, k" },
+  { name: "SMALL", sig: "range, k" },
+  { name: "RANK", sig: "value, range, [order]" },
+  { name: "STDEV", sig: "a, b, …" },
+  { name: "STDEVP", sig: "a, b, …" },
+  { name: "VAR", sig: "a, b, …" },
+  { name: "VARP", sig: "a, b, …" },
+  // Logique
   { name: "IF", sig: "cond, yes, no" },
   { name: "IFS", sig: "cond1, v1, cond2, v2…" },
   { name: "IFERROR", sig: "value, fallback" },
@@ -1998,7 +2077,22 @@ const FORMULA_FNS: { name: string; sig: string }[] = [
   { name: "AND", sig: "a, b…" },
   { name: "OR", sig: "a, b…" },
   { name: "NOT", sig: "v" },
-  { name: "VLOOKUP", sig: "key, range, col, [approx]" },
+  { name: "TRUE", sig: "" },
+  { name: "FALSE", sig: "" },
+  // Info / erreurs
+  { name: "ISBLANK", sig: "v" },
+  { name: "ISNUMBER", sig: "v" },
+  { name: "ISTEXT", sig: "v" },
+  { name: "ISERROR", sig: "v" },
+  { name: "ISERR", sig: "v" },
+  { name: "ISNA", sig: "v" },
+  { name: "NA", sig: "" },
+  // Recherche
+  { name: "VLOOKUP", sig: "key, range, col" },
+  { name: "XLOOKUP", sig: "key, table, return_range, [not_found]" },
+  { name: "INDEX", sig: "range, row, [col]" },
+  { name: "MATCH", sig: "key, range, [type]" },
+  // Maths
   { name: "ABS", sig: "n" },
   { name: "ROUND", sig: "n, [digits]" },
   { name: "ROUNDUP", sig: "n, [digits]" },
@@ -2011,23 +2105,26 @@ const FORMULA_FNS: { name: string; sig: string }[] = [
   { name: "POWER", sig: "n, exp" },
   { name: "PI", sig: "" },
   { name: "RAND", sig: "" },
+  // Texte
   { name: "CONCAT", sig: "a, b…" },
   { name: "CONCATENATE", sig: "a, b…" },
+  { name: "TEXTJOIN", sig: "delim, ignore_empty, a, b…" },
   { name: "UPPER", sig: "text" },
   { name: "LOWER", sig: "text" },
+  { name: "PROPER", sig: "text" },
   { name: "TRIM", sig: "text" },
   { name: "LEN", sig: "text" },
   { name: "LEFT", sig: "text, [n]" },
   { name: "RIGHT", sig: "text, [n]" },
   { name: "MID", sig: "text, start, n" },
+  { name: "SEARCH", sig: "find, text, [start]" },
   { name: "FIND", sig: "find, text, [start]" },
   { name: "SUBSTITUTE", sig: "text, old, new, [n]" },
   { name: "REPLACE", sig: "text, start, n, new" },
+  { name: "EXACT", sig: "a, b" },
   { name: "VALUE", sig: "text" },
   { name: "N", sig: "v" },
-  { name: "ISBLANK", sig: "v" },
-  { name: "ISNUMBER", sig: "v" },
-  { name: "ISTEXT", sig: "v" },
+  // Dates
   { name: "TODAY", sig: "" },
   { name: "NOW", sig: "" },
   { name: "DATE", sig: "y, m, d" },
@@ -2035,20 +2132,51 @@ const FORMULA_FNS: { name: string; sig: string }[] = [
   { name: "MONTH", sig: "date" },
   { name: "DAY", sig: "date" },
   { name: "EDATE", sig: "date, months" },
+  { name: "EOMONTH", sig: "date, months" },
+  { name: "DATEDIF", sig: "start, end, unit" },
+  { name: "DAYS", sig: "end, start" },
+  { name: "WEEKDAY", sig: "date, [type]" },
+  { name: "WEEKNUM", sig: "date, [type]" },
+  { name: "ISOWEEKNUM", sig: "date" },
+  { name: "WORKDAY", sig: "start, days, [holidays]" },
+  { name: "NETWORKDAYS", sig: "start, end, [holidays]" },
+  { name: "TEXT", sig: "value, format" },
 ]
 // La source alimente des méthodes de chaîne (`.trim()`, `.startsWith()`) :
 // la valeur brute d'une cellule peut être un nombre / booléen → on coerce.
 const fxSource = computed(() => String((editing.value ? draft.value : fxDraft.value) ?? ""))
-const fxQuery = computed(() => {
-  const s = fxSource.value
-  if (!s.trim().startsWith("=")) return ""
-  const m = s.match(/[A-Za-z]{1,}$/)
-  return m ? m[0].toLowerCase() : ""
-})
+/** Position du curseur (fx bar / éditeur de cellule) — pilote les suggestions. */
+const fxCaret = ref<number | null>(null)
+const editCaret = ref<number | null>(null)
+const fxQuery = computed(() =>
+  functionQueryAt(
+    fxSource.value,
+    (editing.value ? editCaret.value : fxCaret.value) ?? undefined,
+  ),
+)
 const fxSuggestions = computed(() => {
   const q = fxQuery.value
   if (!q) return []
-  return FORMULA_FNS.filter((f) => f.name.toLowerCase().startsWith(q)).slice(0, 12)
+  const fns = rankSuggestions(FORMULA_FNS, q, 8).map((f) => ({
+    kind: "fn" as const,
+    name: f.name,
+    detail: f.sig,
+    insert: f.name + "(",
+  }))
+  // Colonnes de la feuille : les formules acceptent `=price * qty`
+  const fields = rankSuggestions(
+    cols.value.map((col) => ({
+      name: col.name,
+      detail:
+        col.label !== undefined && String(col.label) !== col.name
+          ? String(col.label)
+          : t("fxColumn"),
+      insert: col.name,
+    })),
+    q,
+    4,
+  ).map((f) => ({ kind: "field" as const, ...f }))
+  return [...fns, ...fields]
 })
 const fxHide = ref(false)
 const fxActive = ref(0)
@@ -2057,6 +2185,23 @@ watch(fxQuery, () => {
   fxActive.value = 0
   fxHide.value = false
 })
+/** Signature de la fonction au curseur (argument courant surligné). */
+const fxHint = computed<{ name: string; args: string[]; active: number } | null>(() => {
+  const source = fxSource.value
+  if (!isFormulaRaw(source)) return null
+  const caret = Math.min(
+    (editing.value ? editCaret.value : fxCaret.value) ?? source.length,
+    source.length,
+  )
+  const call = functionCallAt(source, caret, FORMULA_FNS.map((f) => f.name))
+  if (!call) return null
+  const fn = FORMULA_FNS.find((f) => f.name.toLowerCase() === call.name)
+  if (!fn) return null
+  const args = signatureArgs(fn.sig)
+  if (!args.length) return null
+  return { name: fn.name, args, active: Math.min(call.index, args.length - 1) }
+})
+
 const fxPopStyle = ref<Record<string, string>>({})
 const refreshFxPop = () => {
   if (!fxOpen.value || !fxInputEl.value) return
@@ -2078,9 +2223,18 @@ const stepFx = (d: number) => {
 const acceptFx = () => {
   const f = fxSuggestions.value[fxActive.value]
   if (!f) return
-  const replaceTail = (s: string) => s.replace(/[A-Za-z]+$/, f.name + "(")
-  if (editing.value) draft.value = replaceTail(String(draft.value ?? ""))
-  else fxDraft.value = replaceTail(String(fxDraft.value ?? ""))
+  const source = editing.value ? String(draft.value ?? "") : String(fxDraft.value ?? "")
+  const caret = Math.min(
+    (editing.value ? editCaret.value : fxCaret.value) ?? source.length,
+    source.length,
+  )
+  const query = functionQueryAt(source, caret)
+  if (!query) return
+  const start = caret - query.length
+  const inserted = f.insert
+  const next = source.slice(0, start) + inserted + source.slice(caret)
+  if (editing.value) draft.value = next
+  else fxDraft.value = next
   fxActive.value = 0
   nextTick(() => {
     const el = editing.value
@@ -2088,7 +2242,12 @@ const acceptFx = () => {
         ? editAreaEl.value
         : editInputEl.value
       : fxInputEl.value
-    el?.focus({ preventScroll: true })
+    if (!el) return
+    el.focus({ preventScroll: true })
+    const pos = start + inserted.length
+    el.setSelectionRange(pos, pos)
+    if (editing.value) editCaret.value = pos
+    else fxCaret.value = pos
   })
 }
 const acceptFxAt = (i: number) => {
@@ -2915,8 +3074,8 @@ const applyFill = () => {
         const sr = b.r0 + (((rr - b.r0) % h) + h) % h
         const sc = b.c0 + (((cc - b.c0) % w) + w) % w
         let raw = state.value[sr]?.[colNameAt(sc)]
-        if (typeof raw === "string" && raw.startsWith("=")) {
-          raw = shiftFormulaRefs(raw, rr - sr, cc - sc)
+        if (typeof raw === "string" && raw.trim().startsWith("=")) {
+          raw = shiftFormulaRefs(raw.trim(), rr - sr, cc - sc)
         }
         val = raw
       }
@@ -4527,9 +4686,23 @@ defineExpose({
         :placeholder="fxCanEdit ? t('fxPlaceholder') : t('fxNoSel')"
         spellcheck="false"
         @input="onFxInput"
+        @keyup="syncFxCaret"
+        @click="syncFxCaret"
         @keydown="onFxKeydown"
         @blur="commitFx"
       />
+      <span v-if="fxHint && !fxOpen && !editing" class="q-spreadsheet__fxhint">
+        <strong>{{ fxHint.name }}</strong>(<template v-for="(arg, i) in fxHint.args" :key="i"><span
+          class="q-spreadsheet__fxhint-arg"
+          :class="{ 'q-spreadsheet__fxhint-arg--on': i === fxHint.active }"
+        >{{ arg }}</span><span v-if="i < fxHint.args.length - 1">, </span></template>)
+      </span>
+      <span
+        v-if="fxPreview"
+        class="q-spreadsheet__fx-preview"
+        :class="{ 'q-spreadsheet__fx-preview--error': fxPreview.error }"
+        :title="fxPreview.hint"
+      ><span class="q-spreadsheet__fx-preview-eq" aria-hidden="true">=</span>{{ fxPreview.text }}</span>
     </div>
 
     <!-- ═══════ Barre Find & Replace ═══════ -->
@@ -4909,6 +5082,9 @@ defineExpose({
           class="q-spreadsheet__editor-input q-spreadsheet__editor-area"
           :rows="draftLines"
           spellcheck="false"
+          @input="syncEditCaret"
+          @keyup="syncEditCaret"
+          @click="syncEditCaret"
           @keydown="onEditKeydown"
           @blur="commitEdit"
         />
@@ -4923,6 +5099,12 @@ defineExpose({
           @keydown="onEditKeydown"
           @blur="commitEdit"
         />
+        <div v-if="editingIsFormula && fxHint && !fxOpen" class="q-spreadsheet__fxhint q-spreadsheet__fxhint--editor">
+          <strong>{{ fxHint.name }}</strong>(<template v-for="(arg, i) in fxHint.args" :key="i"><span
+            class="q-spreadsheet__fxhint-arg"
+            :class="{ 'q-spreadsheet__fxhint-arg--on': i === fxHint.active }"
+          >{{ arg }}</span><span v-if="i < fxHint.args.length - 1">, </span></template>)
+        </div>
         <div v-if="editingIsChoice && selectOptions.length" class="q-spreadsheet__options">
           <button
             v-for="opt in selectOptions"
@@ -4947,7 +5129,7 @@ defineExpose({
         <div v-if="editingIsFormula && fxOpen" class="q-spreadsheet__fnsug">
           <button
             v-for="(f, fi) in fxSuggestions"
-            :key="f.name"
+            :key="`${f.kind}:${f.name}`"
             type="button"
             class="q-spreadsheet__fnsug-item"
             :class="{ 'q-spreadsheet__fnsug-item--on': fxActive === fi }"
@@ -4955,7 +5137,8 @@ defineExpose({
             @click="acceptFxAt(fi)"
           >
             <code>{{ f.name }}</code>
-            <span>({{ f.sig }})</span>
+            <span v-if="f.kind === 'fn'">({{ f.detail }})</span>
+            <span v-else class="q-spreadsheet__fnsug-kind">{{ f.detail }}</span>
           </button>
         </div>
       </div>
@@ -5252,7 +5435,7 @@ defineExpose({
       >
         <button
           v-for="(f, fi) in fxSuggestions"
-          :key="f.name"
+          :key="`${f.kind}:${f.name}`"
           type="button"
           class="q-spreadsheet__fnsug-item"
           :class="{ 'q-spreadsheet__fnsug-item--on': fxActive === fi }"
@@ -5260,7 +5443,8 @@ defineExpose({
           @click="acceptFxAt(fi)"
         >
           <code>{{ f.name }}</code>
-          <span>({{ f.sig }})</span>
+          <span v-if="f.kind === 'fn'">({{ f.detail }})</span>
+          <span v-else class="q-spreadsheet__fnsug-kind">{{ f.detail }}</span>
         </button>
       </div>
     </Teleport>

package/components/QTable.vue

@@ -35,6 +35,7 @@ import { icons } from "../lib/icons"
 import { cn } from "../lib/utils"
 import { radiusStyle, useRadius } from "../lib/useComponentProps"
 import type { RadiusProp } from "../lib/useComponentProps"
+import QSelect from "./QSelect.vue"
 
 interface Props {
   /** Lignes de données */
@@ -164,6 +165,13 @@ const rowsPerPage = computed({
   get: () => pagination.value.rowsPerPage,
   set: (v) => setPagination({ page: 1, rowsPerPage: v }),
 })
+
+/** Libellé d'une option « lignes par page » (0 = tout afficher).
+ *  Reçoit l'option normalisée par QSelect (`{ value, label }`) ou la valeur brute. */
+const rowsPerPageOptionLabel = (opt: any): string => {
+  const value = opt !== null && typeof opt === "object" ? opt.value : opt
+  return value === 0 ? "All" : String(value)
+}
 const sortBy = computed(() => pagination.value.sortBy)
 const descending = computed(() => pagination.value.descending)
 
@@ -729,12 +737,18 @@ const virtual = computed(() => {
       <slot name="bottom" />
       <div class="q-table__pagination">
         <span class="q-table__range">{{ rangeLabel }}</span>
-        <label class="q-table__rows-select">
-          Rows per page
-          <select :value="rowsPerPage" @change="(e) => (rowsPerPage = Number((e.target as HTMLSelectElement).value))">
-            <option v-for="n in rowsPerPageOptions" :key="n" :value="n">{{ n === 0 ? 'All' : n }}</option>
-          </select>
-        </label>
+        <div class="q-table__rows-select">
+          <span>Rows per page</span>
+          <q-select
+            v-model="rowsPerPage"
+            class="q-table__rows-field"
+            :options="rowsPerPageOptions"
+            :option-label="rowsPerPageOptionLabel"
+            emit-value
+            dense
+            aria-label="Rows per page"
+          />
+        </div>
         <div class="q-table__page-nav">
           <button
             type="button"

package/lib/formula.test.ts

@@ -1,6 +1,6 @@
 // Tests unitaires du moteur de formules A1 (bun test).
 import { describe, expect, it } from "bun:test"
-import { evaluateFormula, isError } from "./formula"
+import { criteriaMatcher, evaluateFormula, FORMULA_FUNCTION_NAMES, isError } from "./formula"
 import type { FormulaValue } from "./formula"
 
 type Grid = (string | number | boolean | null)[][]
@@ -184,6 +184,14 @@ describe("fonctions dates", () => {
   })
 })
 
+describe("espaces autour de la formule", () => {
+  const e = harness([[]])
+  it("accepte des espaces avant le `=` (isFormulaRaw les tolère)", () => {
+    expect(e("  =1+2")).toBe(3)
+    expect(e(" =SUM(1,2) ")).toBe(3)
+  })
+})
+
 describe("math & erreurs de type", () => {
   const e = harness([[]])
   it("ABS / ROUND / INT / MOD / SQRT / POWER", () => {
@@ -204,3 +212,188 @@ describe("math & erreurs de type", () => {
     expect(isError(e("=1/0"))).toBe(true)
   })
 })
+
+// ─── Extension 2026-10-17 : critères, stats, recherche, dates, texte ───
+
+describe("critères (SUMIF / COUNTIF / *IFS)", () => {
+  const grid: Grid = [
+    ["A", "x", 10],
+    ["B", "y", 20],
+    ["C", "x", 30],
+    [null, null, null],
+    ["D", "y", 40],
+  ]
+  const e = harness(grid)
+
+  it("SUMIF : critère texte, comparaison numérique, plage de somme optionnelle", () => {
+    expect(e('=SUMIF(B1:B5,"x",C1:C5)')).toBe(40)
+    expect(e('=SUMIF(B1:B5,"y",C1:C5)')).toBe(60)
+    expect(e('=SUMIF(C1:C5,">15")')).toBe(90)
+    expect(e('=SUMIF(C1:C5,"<>")')).toBe(100)
+  })
+
+  it("COUNTIF : égalité (insensible à la casse), vides, jokers", () => {
+    expect(e('=COUNTIF(A1:A5,"a")')).toBe(1)
+    expect(e('=COUNTIF(A1:A5,"?")')).toBe(4)
+    expect(e('=COUNTIF(A1:A5,"")')).toBe(1)
+    expect(e('=COUNTIF(A1:A5,"<>")')).toBe(4)
+    expect(e('=COUNTIF(A1:A5,"a*")')).toBe(1)
+    expect(e('=COUNTIF(A1:A5,">b")')).toBe(2)
+  })
+
+  it("AVERAGEIF ignore les non-nombres ; #DIV/0! sans correspondance", () => {
+    expect(e('=AVERAGEIF(B1:B5,"y",C1:C5)')).toBe(30)
+    expect(String(e('=AVERAGEIF(B1:B5,"z",C1:C5)'))).toBe("#DIV/0!")
+  })
+
+  it("COUNTIFS / SUMIFS / AVERAGEIFS croisent plusieurs critères", () => {
+    expect(e('=COUNTIFS(B1:B5,"x",C1:C5,">15")')).toBe(1)
+    expect(e('=SUMIFS(C1:C5,B1:B5,"x",C1:C5,">15")')).toBe(30)
+    expect(e('=SUMIFS(C1:C5,B1:B5,"x")')).toBe(40)
+    expect(e('=AVERAGEIFS(C1:C5,B1:B5,"y")')).toBe(30)
+  })
+
+  it("SUMPRODUCT multiplie les plages terme à terme", () => {
+    expect(e("=SUMPRODUCT(C1:C3,C1:C3)")).toBe(1400)
+    expect(e("=SUMPRODUCT(C1:C2)")).toBe(30)
+  })
+})
+
+describe("criteriaMatcher (unitaire)", () => {
+  it("compare nombres, textes, vides et jokers", () => {
+    expect(criteriaMatcher(">10")(15)).toBe(true)
+    expect(criteriaMatcher(">10")("abc")).toBe(false)
+    expect(criteriaMatcher("<=5")(5)).toBe(true)
+    expect(criteriaMatcher(0)("0")).toBe(true)
+    expect(criteriaMatcher("paris")("PARIS")).toBe(true)
+    expect(criteriaMatcher("paris")("paris ")).toBe(false)
+    expect(criteriaMatcher("par*")("paris")).toBe(true)
+    expect(criteriaMatcher("<>")(null)).toBe(false)
+    expect(criteriaMatcher("")("")).toBe(true)
+    expect(criteriaMatcher("<m")("apple")).toBe(true)
+  })
+})
+
+describe("statistiques", () => {
+  const grid: Grid = [
+    [10],
+    [20],
+    [30],
+    [40],
+  ]
+  const e = harness(grid)
+
+  it("MEDIAN / LARGE / SMALL / RANK", () => {
+    expect(e("=MEDIAN(A1:A4)")).toBe(25)
+    expect(e("=LARGE(A1:A4,2)")).toBe(30)
+    expect(e("=SMALL(A1:A4,2)")).toBe(20)
+    expect(e("=RANK(20,A1:A4)")).toBe(3)
+    expect(e("=RANK(20,A1:A4,1)")).toBe(2)
+    expect(String(e("=LARGE(A1:A4,9)"))).toBe("#NUM!")
+    expect(String(e("=RANK(99,A1:A4)"))).toBe("#N/A")
+  })
+
+  it("STDEV / STDEVP / VAR / VARP", () => {
+    expect(Number(e("=STDEV(A1:A4)"))).toBeCloseTo(12.9099, 3)
+    expect(Number(e("=STDEVP(A1:A4)"))).toBeCloseTo(11.1803, 3)
+    expect(Number(e("=VAR(A1:A4)"))).toBeCloseTo(166.6667, 3)
+    expect(e("=VARP(A1:A4)")).toBe(125)
+    expect(String(e("=STDEV(A1)"))).toBe("#DIV/0!")
+  })
+})
+
+describe("recherche INDEX / MATCH", () => {
+  const grid: Grid = [
+    ["A", "x", 10],
+    ["B", "y", 20],
+    ["C", "x", 30],
+  ]
+  const e = harness(grid)
+
+  it("INDEX sur une plage (ligne/colonne, index unique)", () => {
+    expect(e("=INDEX(C1:C3,2)")).toBe(20)
+    expect(e("=INDEX(A1:C1,2)")).toBe("x")
+    expect(e("=INDEX(A1:C3,3,3)")).toBe(30)
+    expect(String(e("=INDEX(A1:C3,9,1)"))).toBe("#REF!")
+  })
+
+  it("MATCH exact et approché", () => {
+    expect(e('=MATCH("x",B1:B3,0)')).toBe(1)
+    expect(e("=MATCH(30,C1:C3,0)")).toBe(3)
+    expect(e("=MATCH(25,C1:C3,1)")).toBe(2)
+    expect(String(e("=MATCH(99,C1:C3,0)"))).toBe("#N/A")
+  })
+})
+
+describe("littéraux TRUE / FALSE", () => {
+  const e = harness([[]])
+  it("valeurs booléennes en littéral et en fonction", () => {
+    expect(e("=IF(TRUE,1,2)")).toBe(1)
+    expect(e("=IF(FALSE,1,2)")).toBe(2)
+    expect(e("=TRUE()")).toBe(true)
+    expect(e("=FALSE()")).toBe(false)
+    expect(e('=IFS(0,1,TRUE,"x")')).toBe("x")
+  })
+  it("un identifiant plus long reste une référence", () => {
+    expect(String(e("=TRUE1"))).toBe("#NAME?")
+  })
+})
+
+describe("erreurs (ISERROR / ISERR / ISNA / NA)", () => {
+  const e = harness([[]])
+  it("distingue erreur générique, #N/A et absence d'erreur", () => {
+    expect(e("=ISERROR(1/0)")).toBe(true)
+    expect(e("=ISERROR(1)")).toBe(false)
+    expect(e("=ISERR(1/0)")).toBe(true)
+    expect(e("=ISERR(NA())")).toBe(false)
+    expect(e("=ISNA(NA())")).toBe(true)
+    expect(e("=ISNA(1/0)")).toBe(false)
+    expect(String(e("=NA()"))).toBe("#N/A")
+  })
+})
+
+describe("texte étendu", () => {
+  const e = harness([[]])
+  it("TEXTJOIN / PROPER / SEARCH / EXACT", () => {
+    expect(e('=TEXTJOIN("-",1,"a","","b")')).toBe("a-b")
+    expect(e('=TEXTJOIN("-",0,"a","","b")')).toBe("a--b")
+    expect(e('=PROPER("hello world")')).toBe("Hello World")
+    expect(e('=SEARCH("B","abc")')).toBe(2)
+    expect(String(e('=SEARCH("z","abc")'))).toBe("#VALUE!")
+    expect(e('=EXACT("a","A")')).toBe(false)
+    expect(e('=EXACT("a","a")')).toBe(true)
+  })
+})
+
+describe("dates étendues", () => {
+  const grid: Grid = [
+    ["2026-10-05"],
+    ["2026-10-06"],
+  ]
+  const e = harness(grid)
+  it("DAYS / WEEKNUM / ISOWEEKNUM", () => {
+    expect(e('=DAYS("2026-10-10","2026-10-01")')).toBe(9)
+    expect(e('=WEEKNUM("2026-01-05",2)')).toBe(2)
+    expect(e('=ISOWEEKNUM("2026-01-05")')).toBe(2)
+    expect(e('=WEEKDAY("2026-10-05",2)')).toBe(1)
+  })
+  it("WORKDAY / NETWORKDAYS (avec et sans fériés)", () => {
+    expect(e('=WORKDAY("2026-10-16",1)')).toBe("2026-10-19")
+    expect(e('=NETWORKDAYS("2026-10-01","2026-10-07")')).toBe(5)
+    expect(e('=NETWORKDAYS("2026-10-01","2026-10-07",A1:A2)')).toBe(3)
+  })
+})
+
+describe("parité moteur ↔ autocomplétion", () => {
+  it("aucune fonction intégrée n'est absente de FORMULA_FNS", async () => {
+    const vue = await Bun.file(new URL("../components/QSpreadsheet.vue", import.meta.url)).text()
+    const start = vue.indexOf("const FORMULA_FNS")
+    const end = vue.indexOf("const fxSource")
+    const block = vue.slice(start, end)
+    const suggested = new Set([...block.matchAll(/name: "([A-Z]+)"/g)].map((m) => m[1]!))
+    // Alias internes volontairement absents des suggestions.
+    const aliases = new Set(["AVG", "CEIL", "POW"])
+    const missing = FORMULA_FUNCTION_NAMES.filter((n) => !aliases.has(n) && !suggested.has(n))
+    expect(missing).toEqual([])
+  })
+})