@dnax/ui 0.0.64 → 0.0.66

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)[][]
@@ -204,3 +204,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([])
+  })
+})

package/lib/formula.ts

@@ -45,6 +45,7 @@ interface RefToken {
 type Node =
   | { kind: "num"; value: number }
   | { kind: "str"; value: string }
+  | { kind: "bool"; value: boolean }
   | { kind: "ref"; ref: RefToken }
   | { kind: "range"; start: RefToken; end: RefToken }
   | { kind: "call"; name: string; args: Node[] }
@@ -242,6 +243,13 @@ class Parser {
     let digits = ""
     while (!this.eof() && /[0-9]/.test(this.peek()!)) digits += this.next()
 
+    // Littéraux TRUE / FALSE (Excel) — ne s'appliquent pas à une référence type TRUE1.
+    const keyword = letters.toUpperCase()
+    if (!colAbs && !rowAbs && digits.length === 0 && (keyword === "TRUE" || keyword === "FALSE")) {
+      this.skipWs()
+      if (this.peek() !== ":") return { kind: "bool", value: keyword === "TRUE" }
+    }
+
     let token: RefToken
     if (digits.length > 0 && letters.length <= 3) {
       token = {
@@ -327,6 +335,77 @@ const truthy = (v: FormulaValue): boolean => {
   return v !== ""
 }
 
+/** Cellule « vide » au sens des critères (`null`, `undefined` ou chaîne vide). */
+const isBlankValue = (v: FormulaValue): boolean => v === null || v === undefined || v === ""
+
+/** Motif texte → expression régulière : `*` = tout, `?` = un caractère, insensible à la casse. */
+const wildcardRegExp = (pattern: string): RegExp => {
+  let out = ""
+  for (const ch of pattern) {
+    if (ch === "*") out += ".*"
+    else if (ch === "?") out += "."
+    else out += ch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+  }
+  return new RegExp("^" + out + "$", "i")
+}
+
+/**
+ * Transforme un critère de `SUMIF` / `COUNTIF` (…) en prédicat.
+ *
+ * - `10` / `"10"` → égalité numérique ;
+ * - `">10"`, `"<=5"`, `"<>abc"`, `"<m"` → comparaison (numérique ou texte) ;
+ * - `""` / `"<>"` → cellules **vides** / **non vides** ;
+ * - `*` et `?` → jokers sur le texte, insensible à la casse.
+ */
+export function criteriaMatcher(criteria: FormulaValue): (v: FormulaValue) => boolean {
+  if (isError(criteria)) return () => false
+  if (criteria === null || criteria === undefined) return isBlankValue
+  if (typeof criteria === "number" || typeof criteria === "boolean") {
+    const target = typeof criteria === "boolean" ? (criteria ? 1 : 0) : criteria
+    return (v) => {
+      if (isBlankValue(v)) return false
+      const n = typeof v === "number" ? v : Number(v)
+      return !Number.isNaN(n) && n === target
+    }
+  }
+
+  const m = /^(>=|<=|<>|>|<|=)?([\s\S]*)$/.exec(String(criteria))!
+  const op = m[1] ?? "="
+  const raw = (m[2] ?? "").trim()
+
+  // Critères de vacuité : "" (vides) / "<>" (non vides)
+  if (raw === "" && (op === "=" || op === "<>")) {
+    return op === "=" ? isBlankValue : (v) => !isBlankValue(v)
+  }
+
+  const numeric = raw !== "" && !Number.isNaN(Number(raw))
+  const equals = (v: FormulaValue): boolean => {
+    if (isBlankValue(v)) return false
+    if (numeric) {
+      const n = typeof v === "number" ? v : Number(v)
+      return !Number.isNaN(n) && n === Number(raw)
+    }
+    return wildcardRegExp(raw).test(toStr(v))
+  }
+  if (op === "=" || op === "<>") return op === "=" ? equals : (v) => !equals(v)
+
+  if (numeric) {
+    const target = Number(raw)
+    return (v) => {
+      if (isBlankValue(v)) return false
+      const n = typeof v === "number" ? v : Number(v)
+      if (Number.isNaN(n)) return false
+      return op === ">" ? n > target : op === "<" ? n < target : op === ">=" ? n >= target : n <= target
+    }
+  }
+  const target = raw.toLowerCase()
+  return (v) => {
+    if (isBlankValue(v)) return false
+    const s = toStr(v).toLowerCase()
+    return op === ">" ? s > target : op === "<" ? s < target : op === ">=" ? s >= target : s <= target
+  }
+}
+
 // collect=false ne produit jamais de tableau (les plages renvoient #VALUE!) —
 // ce garde sert uniquement au typage.
 const toScalar = (v: EvalValue): FormulaValue => (Array.isArray(v) ? err("#VALUE!") : v)
@@ -355,6 +434,8 @@ function evalNode(node: Node, ctx: FormulaContext, collect: boolean): EvalValue
       return node.value
     case "str":
       return node.value
+    case "bool":
+      return node.value
     case "ref":
       return resolveRef(node.ref, ctx)
     case "range": {
@@ -387,6 +468,18 @@ function evalNode(node: Node, ctx: FormulaContext, collect: boolean): EvalValue
   }
 }
 
+// — Évaluation d'un argument en liste (plage → valeurs, scalaire → [valeur]) —
+// Indispensable aux fonctions à plages multiples (`SUMIF`, `SUMPRODUCT`…) : la forme
+// et l'ordre des arguments doivent rester distincts (contrairement au dispatch générique
+// qui aplatit tous les arguments dans un seul tableau).
+const evalList = (node: Node, ctx: FormulaContext): FormulaValue[] => {
+  const v = evalNode(node, ctx, true)
+  return Array.isArray(v) ? v : [v]
+}
+
+const evalScalar = (node: Node, ctx: FormulaContext): FormulaValue =>
+  toScalar(evalNode(node, ctx, false))
+
 function evalBinary(node: Extract<Node, { kind: "binary" }>, ctx: FormulaContext): FormulaValue {
   if (node.op === "&") {
     const a = toScalar(evalNode(node.left, ctx, false))
@@ -605,6 +698,176 @@ function evalCall(node: Extract<Node, { kind: "call" }>, ctx: FormulaContext): F
     return err("#VALUE!")
   }
 
+  // ── Fonctions à plages multiples (alignées par index) ──
+  // La forme des arguments compte (plage de critères ↔ plage de valeurs) : elles sont
+  // donc évaluées ici, argument par argument, avant le dispatch générique qui aplatit.
+  const pairsFrom = (
+    from: number,
+  ): [FormulaValue[], ((v: FormulaValue) => boolean)][] | FormulaError => {
+    const out: [FormulaValue[], ((v: FormulaValue) => boolean)][] = []
+    for (let i = from; i + 1 < node.args.length; i += 2) {
+      const criteria = evalScalar(node.args[i + 1]!, ctx)
+      if (isError(criteria)) return criteria
+      out.push([evalList(node.args[i]!, ctx), criteriaMatcher(criteria)])
+    }
+    return out
+  }
+
+  /** Index (0-based) où **toutes** les paires (plage, critère) correspondent. */
+  const matched = (pairs: [FormulaValue[], ((v: FormulaValue) => boolean)][]): number[] => {
+    const len = pairs[0]?.[0].length ?? 0
+    const out: number[] = []
+    for (let i = 0; i < len; i++) {
+      if (pairs.every(([values, hit]) => hit(values[i] ?? null))) out.push(i)
+    }
+    return out
+  }
+
+  const numbersAt = (values: FormulaValue[], indexes: number[]): number[] =>
+    indexes.map((i) => values[i]).filter((v): v is number => typeof v === "number")
+
+  const holidaysOf = (n: Node | undefined): Set<string> => {
+    const out = new Set<string>()
+    if (!n) return out
+    for (const v of evalList(n, ctx)) {
+      const d = toLocalDate(v)
+      if (!isError(d)) out.add(dayKey(d))
+    }
+    return out
+  }
+
+  if ((name === "sumif" || name === "averageif") && node.args.length >= 2) {
+    const criteria = evalScalar(node.args[1]!, ctx)
+    if (isError(criteria)) return criteria
+    const criterionValues = evalList(node.args[0]!, ctx)
+    const valueValues = node.args[2] ? evalList(node.args[2], ctx) : criterionValues
+    const nums = numbersAt(valueValues, matched([[criterionValues, criteriaMatcher(criteria)]]))
+    const total = nums.reduce((a, b) => a + b, 0)
+    if (name === "sumif") return total
+    return nums.length ? total / nums.length : err("#DIV/0!")
+  }
+
+  if (name === "countif" && node.args.length >= 2) {
+    const criteria = evalScalar(node.args[1]!, ctx)
+    if (isError(criteria)) return criteria
+    return matched([[evalList(node.args[0]!, ctx), criteriaMatcher(criteria)]]).length
+  }
+
+  if (name === "countifs" && node.args.length >= 2) {
+    const pairs = pairsFrom(0)
+    if (isError(pairs)) return pairs
+    return matched(pairs).length
+  }
+
+  if ((name === "sumifs" || name === "averageifs") && node.args.length >= 3) {
+    const pairs = pairsFrom(1)
+    if (isError(pairs)) return pairs
+    const nums = numbersAt(evalList(node.args[0]!, ctx), matched(pairs))
+    const total = nums.reduce((a, b) => a + b, 0)
+    if (name === "sumifs") return total
+    return nums.length ? total / nums.length : err("#DIV/0!")
+  }
+
+  if (name === "sumproduct" && node.args.length >= 1) {
+    const lists = node.args.map((a) => evalList(a, ctx))
+    const len = lists[0]?.length ?? 0
+    if (!len || lists.some((l) => l.length !== len)) return err("#VALUE!")
+    let total = 0
+    for (let i = 0; i < len; i++) {
+      let product = 1
+      // Comme Excel : une valeur non numérique compte pour 0 dans le produit.
+      for (const l of lists) product *= typeof l[i] === "number" ? (l[i] as number) : 0
+      total += product
+    }
+    return total
+  }
+
+  if ((name === "large" || name === "small") && node.args.length >= 2) {
+    const values = evalList(node.args[0]!, ctx).filter((v): v is number => typeof v === "number")
+    const k = Math.trunc(Number(evalScalar(node.args[1]!, ctx)) || 0)
+    if (k < 1 || k > values.length) return err("#NUM!")
+    values.sort((a, b) => (name === "large" ? b - a : a - b))
+    return values[k - 1]!
+  }
+
+  if (name === "rank" && node.args.length >= 2) {
+    const target = evalScalar(node.args[0]!, ctx)
+    if (isError(target)) return target
+    const values = evalList(node.args[1]!, ctx).filter((v): v is number => typeof v === "number")
+    const n = Number(target)
+    if (Number.isNaN(n) || !values.includes(n)) return err("#N/A")
+    const order = node.args[2] ? Number(evalScalar(node.args[2], ctx)) : 0
+    const sorted = [...values].sort((a, b) => (order ? a - b : b - a))
+    return sorted.indexOf(n) + 1
+  }
+
+  if (name === "index" && node.args.length >= 2) {
+    const rangeNode = node.args[0]!
+    if (rangeNode.kind !== "range") return err("#VALUE!")
+    const a = resolveRefPos(rangeNode.start)
+    const b = resolveRefPos(rangeNode.end)
+    if (!a || !b) return err("#REF!")
+    const r0 = Math.min(a[0], b[0])
+    const r1 = Math.max(a[0], b[0])
+    const c0 = Math.min(a[1], b[1])
+    const c1 = Math.max(a[1], b[1])
+    const rows = r1 - r0 + 1
+    const cols = c1 - c0 + 1
+    const first = Math.trunc(Number(evalScalar(node.args[1]!, ctx)) || 0)
+    const second = node.args[2] ? Math.trunc(Number(evalScalar(node.args[2], ctx)) || 0) : 0
+    // Un seul index : ligne, ou colonne quand la plage n'a qu'une ligne (usage Excel).
+    const row = !second && rows === 1 ? 1 : first
+    const col = !second ? (rows === 1 ? first : 1) : second
+    if (row < 1 || col < 1 || row > rows || col > cols) return err("#REF!")
+    const value = ctx.resolveCell(r0 + row - 1, c0 + col - 1)
+    return value === undefined ? err("#REF!") : value
+  }
+
+  if (name === "match" && node.args.length >= 2) {
+    const rangeNode = node.args[1]!
+    if (rangeNode.kind !== "range") return err("#N/A")
+    const a = resolveRefPos(rangeNode.start)
+    const b = resolveRefPos(rangeNode.end)
+    if (!a || !b) return err("#N/A")
+    const key = evalScalar(node.args[0]!, ctx)
+    if (isError(key)) return key
+    const values: FormulaValue[] = []
+    for (let r = Math.min(a[0], b[0]); r <= Math.max(a[0], b[0]); r++)
+      for (let c = Math.min(a[1], b[1]); c <= Math.max(a[1], b[1]); c++)
+        values.push(ctx.resolveCell(r, c) ?? null)
+    const type = node.args[2] ? Math.trunc(Number(evalScalar(node.args[2], ctx)) || 0) : 1
+    if (type === 0) {
+      const at = values.findIndex((v) =>
+        typeof key === "number" && typeof v === "number"
+          ? v === key
+          : toStr(v).toLowerCase() === toStr(key).toLowerCase())
+      return at === -1 ? err("#N/A") : at + 1
+    }
+    // Approché : dernier ≤ clé (croissant) / dernier ≥ clé (décroissant)
+    let best = -1
+    values.forEach((v, i) => {
+      const cmp = compare(v, key)
+      if (cmp === "err") return
+      if (type === -1 ? cmp >= 0 : cmp <= 0) best = i
+    })
+    return best === -1 ? err("#N/A") : best + 1
+  }
+
+  if (name === "workday" && node.args.length >= 2) {
+    const start = toLocalDate(evalScalar(node.args[0]!, ctx))
+    if (isError(start)) return start
+    const days = Math.trunc(Number(evalScalar(node.args[1]!, ctx)) || 0)
+    return isoLocal(addWorkdays(start, days, holidaysOf(node.args[2])))
+  }
+
+  if (name === "networkdays" && node.args.length >= 2) {
+    const start = toLocalDate(evalScalar(node.args[0]!, ctx))
+    const end = toLocalDate(evalScalar(node.args[1]!, ctx))
+    if (isError(start)) return start
+    if (isError(end)) return end
+    return countWorkdays(start, end, holidaysOf(node.args[2]))
+  }
+
   const fn = FUNCTIONS[name]
   if (!fn) return err("#NAME?")
 
@@ -733,6 +996,72 @@ const isoLocal = (d: Date, time = false) => {
 const isoUTC = (d: Date) =>
   d.getUTCFullYear() + "-" + pad2(d.getUTCMonth() + 1) + "-" + pad2(d.getUTCDate())
 
+// — Dates « métier » (jours ouvrés, semaines) — calculs en UTC pour ignorer le fuseau/DST.
+/** Clé de jour (`YYYY-MM-DD`) insensible à l'heure et au fuseau. */
+const dayKey = (d: Date): string =>
+  isoUTC(new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate())))
+
+/** Numéro de semaine « type Excel » : `startDay` 0 = dimanche, 1 = lundi. */
+const weekNumber = (d: Date, startDay: number): number => {
+  const jan1 = Date.UTC(d.getFullYear(), 0, 1)
+  const today = Date.UTC(d.getFullYear(), d.getMonth(), d.getDate())
+  const offset = (new Date(jan1).getUTCDay() - startDay + 7) % 7
+  const dayOfYear = Math.round((today - jan1) / 86400000)
+  return Math.floor((dayOfYear + offset) / 7) + 1
+}
+
+/** Numéro de semaine ISO 8601 (semaine 1 = celle du premier jeudi). */
+const isoWeekNumber = (d: Date): number => {
+  const t = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()))
+  const day = t.getUTCDay() || 7
+  t.setUTCDate(t.getUTCDate() + 4 - day)
+  const yearStart = Date.UTC(t.getUTCFullYear(), 0, 1)
+  return Math.ceil(((t.getTime() - yearStart) / 86400000 + 1) / 7)
+}
+
+/** Ajoute (ou retire) des jours ouvrés (lun–ven), hors jours fériés. */
+const addWorkdays = (start: Date, days: number, holidays: Set<string>): Date => {
+  let t = Date.UTC(start.getFullYear(), start.getMonth(), start.getDate())
+  const step = days < 0 ? -86400000 : 86400000
+  let left = Math.abs(Math.trunc(days))
+  while (left > 0) {
+    t += step
+    const d = new Date(t)
+    const wd = d.getUTCDay()
+    if (wd === 0 || wd === 6) continue
+    if (holidays.has(isoUTC(d))) continue
+    left--
+  }
+  const out = new Date(t)
+  return new Date(out.getUTCFullYear(), out.getUTCMonth(), out.getUTCDate())
+}
+
+/** Jours ouvrés entre deux dates (bornes incluses ; négatif si `end` < `start`). */
+const countWorkdays = (start: Date, end: Date, holidays: Set<string>): number => {
+  const a = Date.UTC(start.getFullYear(), start.getMonth(), start.getDate())
+  const b = Date.UTC(end.getFullYear(), end.getMonth(), end.getDate())
+  const sign = a <= b ? 1 : -1
+  const from = Math.min(a, b)
+  const to = Math.max(a, b)
+  let n = 0
+  for (let t = from; t <= to; t += 86400000) {
+    const d = new Date(t)
+    const wd = d.getUTCDay()
+    if (wd === 0 || wd === 6) continue
+    if (holidays.has(isoUTC(d))) continue
+    n++
+  }
+  return n * sign
+}
+
+/** Variance d'une liste de nombres (`sample` → n−1, sinon population). */
+const varianceOf = (values: number[], sample: boolean): FormulaValue => {
+  if (values.length < (sample ? 2 : 1)) return err("#DIV/0!")
+  const mean = values.reduce((a, b) => a + b, 0) / values.length
+  const sum = values.reduce((a, b) => a + (b - mean) ** 2, 0)
+  return sum / (sample ? values.length - 1 : values.length)
+}
+
 Object.assign(FUNCTIONS, {
   // Logique étendue (évaluées paresseusement dans evalCall : IFS, SWITCH, IFNA, VLOOKUP)
   // Texte
@@ -907,6 +1236,119 @@ Object.assign(FUNCTIONS, {
   rand: () => Math.random(),
 })
 
+// ─── Critères, statistiques, texte et dates (extension 2026-10-17) ───
+// Les agrégats conditionnels (`SUMIF`, `COUNTIF`, `*IFS`, `SUMPRODUCT`), `INDEX`/`MATCH`,
+// `LARGE`/`SMALL`/`RANK` et `WORKDAY`/`NETWORKDAYS` sont traités dans `evalCall` (plages).
+Object.assign(FUNCTIONS, {
+  median: (args: FormulaValue[]) => {
+    const n = numbers(args).sort((a, b) => a - b)
+    if (!n.length) return err("#NUM!")
+    const mid = Math.floor(n.length / 2)
+    return n.length % 2 ? n[mid]! : (n[mid - 1]! + n[mid]!) / 2
+  },
+  stdev: (args: FormulaValue[]) => {
+    const v = varianceOf(numbers(args), true)
+    return typeof v === "number" ? Math.sqrt(v) : v
+  },
+  stdevp: (args: FormulaValue[]) => {
+    const v = varianceOf(numbers(args), false)
+    return typeof v === "number" ? Math.sqrt(v) : v
+  },
+  var: (args: FormulaValue[]) => varianceOf(numbers(args), true),
+  varp: (args: FormulaValue[]) => varianceOf(numbers(args), false),
+  // Constantes logiques (aussi disponibles en littéraux `TRUE` / `FALSE`)
+  true: () => true,
+  false: () => false,
+  // Info / erreurs
+  iserror: (args: FormulaValue[], h: boolean) => scalar(args, h, (v) => isError(v)),
+  iserr: (args: FormulaValue[], h: boolean) =>
+    scalar(args, h, (v) => isError(v) && v.code !== "#N/A"),
+  isna: (args: FormulaValue[], h: boolean) =>
+    scalar(args, h, (v) => isError(v) && v.code === "#N/A"),
+  na: () => err("#N/A"),
+  // Texte
+  proper: (args: FormulaValue[], h: boolean) =>
+    scalar(args, h, (v) =>
+      toStr(v)
+        .toLowerCase()
+        .replace(/(^|[^\p{L}\p{N}])(\p{L})/gu, (_m: string, sep: string, ch: string) => sep + ch.toUpperCase())),
+  exact: (args: FormulaValue[]) => toStr(args[0] ?? null) === toStr(args[1] ?? null),
+  search: (args: FormulaValue[]) => {
+    const needle = toStr(args[0] ?? null).toLowerCase()
+    const hay = toStr(args[1] ?? null).toLowerCase()
+    const start = Math.max(1, Math.trunc(Number(args[2] ?? 1)) || 1) - 1
+    const at = hay.indexOf(needle, start)
+    return at === -1 ? err("#VALUE!") : at + 1
+  },
+  textjoin: (args: FormulaValue[]) => {
+    const delimiter = toStr(args[0] ?? "")
+    const ignoreEmpty = args[1] === undefined ? true : truthy(args[1])
+    return args
+      .slice(2)
+      .filter((v) => !(ignoreEmpty && (v === null || v === undefined || v === "")))
+      .map(toStr)
+      .join(delimiter)
+  },
+  // Dates
+  days: (args: FormulaValue[]) => {
+    const end = toLocalDate(args[0] ?? null)
+    const start = toLocalDate(args[1] ?? null)
+    if (isError(end)) return end
+    if (isError(start)) return start
+    const a = Date.UTC(end.getFullYear(), end.getMonth(), end.getDate())
+    const b = Date.UTC(start.getFullYear(), start.getMonth(), start.getDate())
+    return Math.round((a - b) / 86400000)
+  },
+  weeknum: (args: FormulaValue[]) => {
+    const d = toLocalDate(args[0] ?? null)
+    if (isError(d)) return d
+    const type = Math.trunc(Number(args[1] ?? 1)) || 1
+    return weekNumber(d, type === 2 ? 1 : 0)
+  },
+  isoweeknum: (args: FormulaValue[]) => {
+    const d = toLocalDate(args[0] ?? null)
+    return isError(d) ? d : isoWeekNumber(d)
+  },
+})
+
+/** Fonctions évaluées hors `FUNCTIONS` (accès aux plages / arguments paresseux). */
+const NODE_FUNCTION_NAMES = [
+  "AND",
+  "AVERAGEIF",
+  "AVERAGEIFS",
+  "COUNTIF",
+  "COUNTIFS",
+  "IF",
+  "IFERROR",
+  "IFNA",
+  "IFS",
+  "INDEX",
+  "LARGE",
+  "MATCH",
+  "NETWORKDAYS",
+  "OR",
+  "RANK",
+  "SMALL",
+  "SUMPRODUCT",
+  "SUMIF",
+  "SUMIFS",
+  "SWITCH",
+  "VLOOKUP",
+  "WORKDAY",
+  "XLOOKUP",
+]
+
+/**
+ * Noms des fonctions intégrées (majuscules, triés) — contrat avec les suggestions de
+ * l'éditeur : aucune fonction ne doit être « invisible » dans l'autocomplétion.
+ */
+export const FORMULA_FUNCTION_NAMES: string[] = [
+  ...new Set([
+    ...Object.keys(FUNCTIONS).map((name) => name.toUpperCase()),
+    ...NODE_FUNCTION_NAMES,
+  ]),
+].sort()
+
 /** Évalue une formule ("=…" optionnel). Retourne une valeur ou une FormulaError. */
 export function evaluateFormula(source: string, ctx: FormulaContext): FormulaValue {
   const src = source.startsWith("=") ? source.slice(1) : source