@dnax/ui 0.0.28 → 0.0.29

package/index.ts

@@ -9,6 +9,8 @@ export { default as QAvatar } from "./components/QAvatar.vue"
 export { default as QBackHeader } from "./components/QBackHeader.vue"
 export { default as QBackTop } from "./components/QBackTop.vue"
 export { default as QBadge } from "./components/QBadge.vue"
+export { default as QBar } from "./components/QBar.vue"
+export { default as QBoard } from "./components/QBoard.vue"
 export { default as QBottomSheet } from "./components/QBottomSheet.vue"
 export { default as QBottomSheetFooter } from "./components/QBottomSheetFooter.vue"
 export { default as QBottomSheetHeader } from "./components/QBottomSheetHeader.vue"
@@ -64,6 +66,7 @@ export { default as QInput } from "./components/QInput.vue"
 export { default as QInputOtp } from "./components/QInputOtp.vue"
 export { default as QInputPassword } from "./components/QInputPassword.vue"
 export { default as QInputTag } from "./components/QInputTag.vue"
+export { default as QInteract } from "./components/QInteract.vue"
 export { default as QIntersection } from "./components/QIntersection.vue"
 export { default as QItem } from "./components/QItem.vue"
 export { default as QItemSection } from "./components/QItemSection.vue"
@@ -111,6 +114,7 @@ export { default as QSlider } from "./components/QSlider.vue"
 export { default as QSpace } from "./components/QSpace.vue"
 export { default as QSpinner } from "./components/QSpinner.vue"
 export { default as QSplitter } from "./components/QSplitter.vue"
+export { default as QSpreadsheet } from "./components/QSpreadsheet.vue"
 export { default as QSticky } from "./components/QSticky.vue"
 export { default as QSwipeCell } from "./components/QSwipeCell.vue"
 export { default as QSwiper } from "./components/QSwiper.vue"
@@ -166,3 +170,5 @@ export { vTouchSwipe } from "./lib/touchSwipe"
 export type { TouchSwipeDetails, TouchSwipeHandler, SwipeDirection } from "./lib/touchSwipe"
 export { vTouchRepeat } from "./lib/touchRepeat"
 export type { TouchRepeatDetails, TouchRepeatHandler } from "./lib/touchRepeat"
+export { vIntersection } from "./lib/intersection"
+export type { IntersectionValue } from "./lib/intersection"

package/lib/config.ts

@@ -14,10 +14,14 @@ export interface QThemeColors {
   warning?: string
 }
 
+export type QAppLang = "en" | "fr"
+
 export interface QTheme {
   /** Mode clair/sombre : light | dark | system (défaut : system = préférence OS) */
   mode?: ThemeMode
   colors?: QThemeColors
+  /** Langue par défaut appliquée aux composants qui la supportent */
+  lang?: QAppLang
   /** Props par défaut par composant (clé = nom du composant, ex. "QBtn") */
   componentProps?: Record<string, Record<string, unknown>>
 }
@@ -26,6 +30,8 @@ export interface QConfigContext {
   theme: Ref<QTheme>
   /** true si le mode effectif est sombre (résout "system") */
   isDark: Readonly<Ref<boolean>>
+  /** Langue de l'application ("en" par défaut) */
+  lang: Readonly<Ref<QAppLang>>
 }
 
 export const qConfigKey: InjectionKey<QConfigContext> = Symbol("q-config")

package/lib/formula.test.ts

@@ -0,0 +1,206 @@
+// Tests unitaires du moteur de formules A1 (bun test).
+import { describe, expect, it } from "bun:test"
+import { evaluateFormula, isError } from "./formula"
+import type { FormulaValue } from "./formula"
+
+type Grid = (string | number | boolean | null)[][]
+
+function harness(grid: Grid, formulaRow = 0) {
+  return (f: string): FormulaValue =>
+    evaluateFormula(f, {
+      row: formulaRow,
+      resolveField: () => undefined,
+      resolveCell: (r, c) => {
+        const row = grid[r]
+        return row && c >= 0 && c < row.length
+          ? (row[c] as FormulaValue | undefined)
+          : undefined
+      },
+    })
+}
+
+describe("opérateurs & références", () => {
+  const grid: Grid = [
+    [1, 2, 3],
+    [10, 20, 30],
+  ]
+  const e = harness(grid)
+  it("arithmétique et parenthèses", () => {
+    expect(e("=1+2*3")).toBe(7)
+    expect(e("=(1+2)*3")).toBe(9)
+    expect(e("=2^3")).toBe(8)
+    expect(e("=10%")).toBe(0.1)
+    expect(e("=200*10%")).toBe(20)
+  })
+  it("références A1 / plages / concat", () => {
+    expect(e("=A1+B1")).toBe(3)
+    expect(e("=A2*C1")).toBe(30)
+    expect(e('="x"&A1')).toBe("x1")
+  })
+  it("comparaisons", () => {
+    expect(e("=B2>B1")).toBe(true)
+    expect(e('=A1="1"')).toBe(true)
+  })
+  it("référence hors grille → #REF!", () => {
+    expect(String(e("=Z99"))).toBe("#REF!")
+  })
+  it("division par zéro → #DIV/0!", () => {
+    expect(String(e("=1/0"))).toBe("#DIV/0!")
+  })
+})
+
+describe("fonctions agrégation", () => {
+  const grid: Grid = [
+    [5, "x", 10],
+    [null, 2, 3],
+  ]
+  const e = harness(grid)
+  it("SUM / AVERAGE / MIN / MAX sur plages", () => {
+    expect(e("=SUM(A1:C2)")).toBe(20)
+    expect(e("=AVERAGE(A1,C1,C2)")).toBe(6)
+    expect(e("=MIN(A1:C2)")).toBe(2)
+    expect(e("=MAX(A1:C2)")).toBe(10)
+  })
+  it("COUNT compte les nombres, COUNTA les non-vides", () => {
+    expect(e("=COUNT(A1:C2)")).toBe(4)
+    expect(e("=COUNTA(A1:C2)")).toBe(5)
+  })
+})
+
+describe("fonctions logiques (lazy)", () => {
+  const e = harness([[]])
+  it("IF n'évalue que la branche prise", () => {
+    expect(e("=IF(1,1,1/0)")).toBe(1)
+    expect(e('=IF(0,1,"no")')).toBe("no")
+  })
+  it("IFS premier vrai", () => {
+    expect(e('=IFS(1>2,"a",1<2,"b")')).toBe("b")
+    expect(String(e("=IFS(0,1)"))).toBe("#N/A")
+  })
+  it("SWITCH avec défaut", () => {
+    expect(e('=SWITCH(2,1,"un",2,"deux","autre")')).toBe("deux")
+    expect(e('=SWITCH(9,1,"un","autre")')).toBe("autre")
+  })
+  it("IFERROR / IFNA", () => {
+    expect(e('=IFERROR(1/0,"ko")')).toBe("ko")
+    expect(e('=IFERROR(2,"ko")')).toBe(2)
+  })
+  it("AND / OR / NOT", () => {
+    expect(e("=AND(1,1>0)")).toBe(true)
+    expect(e("=OR(0,1=1)")).toBe(true)
+    expect(e("=NOT(0)")).toBe(true)
+  })
+})
+
+describe("VLOOKUP", () => {
+  const grid: Grid = [
+    ["A", 1, "x"],
+    ["B", 2, "y"],
+    ["A", 3, "z"],
+  ]
+  const e = harness(grid)
+  it("recherche exacte dans la 1re colonne", () => {
+    expect(e('=VLOOKUP("B",A1:C3,2)')).toBe(2)
+    expect(e('=VLOOKUP("A",A1:C3,3)')).toBe("x")
+  })
+  it("absence → #N/A, colonne hors plage → #REF!", () => {
+    expect(String(e('=VLOOKUP("Z",A1:C3,2)'))).toBe("#N/A")
+    expect(String(e('=VLOOKUP("A",A1:C3,5)'))).toBe("#REF!")
+  })
+  it("pas une plage → #VALUE!", () => {
+    expect(String(e('=VLOOKUP("A",A1,2)'))).toBe("#VALUE!")
+  })
+})
+
+describe("XLOOKUP + dates avancées", () => {
+  const grid: Grid = [
+    ["A", 1, "x"],
+    ["B", 2, "y"],
+    ["A", 3, "z"],
+  ]
+  const e = harness(grid)
+  it("XLOOKUP retourne la cellule correspondante du range retour", () => {
+    expect(e('=XLOOKUP("B",A1:A3,B1:B3)')).toBe(2)
+    expect(e('=XLOOKUP("A",A1:A3,C1:C3)')).toBe("x")
+  })
+  it("XLOOKUP fallback / #N/A", () => {
+    expect(String(e('=XLOOKUP("Z",A1:A3,B1:B3,"?")'))).toBe("?")
+    expect(String(e('=XLOOKUP("Z",A1:A3,B1:B3)'))).toBe("#N/A")
+  })
+  it("WEEKDAY / EOMONTH / DATEDIF / TEXT", () => {
+    const d = harness([[]])
+    // 2026-09-07 = lundi
+    expect(d('=WEEKDAY("2026-09-07",2)')).toBe(1)
+    expect(d('=EOMONTH("2026-01-15",0)')).toBe("2026-01-31")
+    expect(d('=DATEDIF("2026-01-01","2026-02-10","D")')).toBe(40)
+    expect(d('=TEXT(1.5,"0.00")')).toBe("1.50")
+    expect(d('=TEXT(0.12,"0%")')).toBe("12%")
+    expect(d('=TEXT("2026-09-07","YYYY-MM-DD")')).toBe("2026-09-07")
+  })
+})
+
+describe("fonctions texte", () => {
+  const e = harness([[]])
+  it("LEFT / RIGHT / MID", () => {
+    expect(e('=LEFT("Hello",2)')).toBe("He")
+    expect(e('=RIGHT("Hello",2)')).toBe("lo")
+    expect(e('=MID("Hello",2,3)')).toBe("ell")
+  })
+  it("FIND / SUBSTITUTE / REPLACE / CONCAT", () => {
+    expect(e('=FIND("llo","Hello")')).toBe(3)
+    expect(e('=SUBSTITUTE("a-b-a","a","x",2)')).toBe("a-b-x")
+    expect(e('=SUBSTITUTE("a-b-a","a","x")')).toBe("x-b-x")
+    expect(e('=REPLACE("Hello",1,2,"XY")')).toBe("XYllo")
+    expect(e('=CONCATENATE("a",1)')).toBe("a1")
+  })
+  it("UPPER / LOWER / TRIM / LEN", () => {
+    expect(e('=UPPER("aB")')).toBe("AB")
+    expect(e('=TRIM("  x  ")')).toBe("x")
+    expect(e('=LEN("abc")')).toBe(3)
+  })
+})
+
+describe("fonctions dates", () => {
+  const e = harness([[]])
+  it("DATE construit en UTC", () => {
+    expect(e("=DATE(2026,9,7)")).toBe("2026-09-07")
+  })
+  it("YEAR / MONTH / DAY", () => {
+    expect(e('=YEAR("2026-09-07")')).toBe(2026)
+    expect(e('=MONTH("2026-09-07")')).toBe(9)
+    expect(e('=DAY("2026-09-07")')).toBe(7)
+  })
+  it("EDATE", () => {
+    expect(e('=EDATE("2026-01-15",1)')).toBe("2026-02-15")
+  })
+  it("TODAY / NOW / RAND sont valides", () => {
+    const t = e("=TODAY()")
+    expect(typeof t).toBe("string")
+    expect(String(t)).toMatch(/^\d{4}-\d{2}-\d{2}$/)
+    const r = e("=RAND()")
+    expect(typeof r).toBe("number")
+    expect(Number(r)).toBeGreaterThanOrEqual(0)
+    expect(Number(r)).toBeLessThan(1)
+  })
+})
+
+describe("math & erreurs de type", () => {
+  const e = harness([[]])
+  it("ABS / ROUND / INT / MOD / SQRT / POWER", () => {
+    expect(e("=ABS(-4)")).toBe(4)
+    expect(e("=ROUND(1.234,2)")).toBe(1.23)
+    expect(e("=INT(-3.7)")).toBe(-3)
+    expect(e("=MOD(7,3)")).toBe(1)
+    expect(e("=SQRT(16)")).toBe(4)
+    expect(e("=POWER(2,3)")).toBe(8)
+  })
+  it("#NAME? pour une fonction inconnue", () => {
+    expect(String(e("=NOPE(1)"))).toBe("#NAME?")
+  })
+  it("#VALUE! pour du texte en numéro", () => {
+    expect(String(e('=1+"a"'))).toBe("#VALUE!")
+  })
+  it("isError détecte FormulaError", () => {
+    expect(isError(e("=1/0"))).toBe(true)
+  })
+})

package/lib/formula.ts

@@ -503,6 +503,107 @@ function evalCall(node: Extract<Node, { kind: "call" }>, ctx: FormulaContext): F
     }
     return name === "and"
   }
+  // IFS : paires cond → valeur, évaluées paresseusement
+  if (name === "ifs") {
+    if (node.args.length % 2 !== 0) return err("#VALUE!")
+    for (let i = 0; i < node.args.length; i += 2) {
+      const cond = toScalar(evalNode(node.args[i]!, ctx, false))
+      if (isError(cond)) return cond
+      if (truthy(cond)) return toScalar(evalNode(node.args[i + 1]!, ctx, false))
+    }
+    return err("#N/A")
+  }
+  // SWITCH(expr, v1, r1, …, défaut?)
+  if (name === "switch") {
+    if (!node.args.length) return err("#N/A")
+    const expr = toScalar(evalNode(node.args[0]!, ctx, false))
+    if (isError(expr)) return expr
+    const last = node.args.length - 1
+    const hasDefault = node.args.length % 2 === 0
+    for (let i = 1; i <= (hasDefault ? last - 1 : last); i += 2) {
+      const val = toScalar(evalNode(node.args[i]!, ctx, false))
+      if (isError(val)) return val
+      if (String(expr) === String(val)) return toScalar(evalNode(node.args[i + 1]!, ctx, false))
+    }
+    return hasDefault ? toScalar(evalNode(node.args[last]!, ctx, false)) : err("#N/A")
+  }
+  if (name === "ifna" && node.args.length >= 1) {
+    const v = toScalar(evalNode(node.args[0]!, ctx, false))
+    if (isError(v) && v.code === "#N/A")
+      return node.args[1] !== undefined ? toScalar(evalNode(node.args[1]!, ctx, false)) : null
+    return v
+  }
+  // VLOOKUP : recherche EXACTE de la 1re colonne d'une plage A1 (col_index 1-based)
+  if (name === "vlookup" && node.args.length >= 3) {
+    const key = toScalar(evalNode(node.args[0]!, ctx, false))
+    const rangeNode = node.args[1]!
+    const colNumRaw = toScalar(evalNode(node.args[2]!, ctx, false))
+    const colNum = Number(colNumRaw)
+    const colI = Number.isNaN(colNum) ? 1 : Math.trunc(colNum)
+    if (isError(key)) return key
+    if (rangeNode.kind === "range") {
+      const a = resolveRefPos(rangeNode.start)
+      const b = resolveRefPos(rangeNode.end)
+      if (a && b) {
+        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 outC = c0 + colI - 1
+        if (outC < c0 || outC > c1) return err("#REF!")
+        for (let r = r0; r <= r1; r++) {
+          const cell = ctx.resolveCell(r, c0)
+          if (cell === undefined) continue
+          const hit =
+            typeof key === "number" && typeof cell === "number"
+              ? key === cell
+              : String(key ?? "") === String(cell ?? "")
+          if (hit) {
+            const found = ctx.resolveCell(r, outC)
+            return found === undefined ? err("#REF!") : found
+          }
+        }
+        return err("#N/A")
+      }
+    }
+    return err("#VALUE!")
+  }
+  // XLOOKUP(key, table, return_range, [not_found]) — correspondance exacte
+  if (name === "xlookup" && node.args.length >= 3) {
+    const key = toScalar(evalNode(node.args[0]!, ctx, false))
+    const tableNode = node.args[1]!
+    const retNode = node.args[2]!
+    if (!isError(key) && tableNode.kind === "range" && retNode.kind === "range") {
+      const ta = resolveRefPos(tableNode.start)
+      const tb = resolveRefPos(tableNode.end)
+      const ra = resolveRefPos(retNode.start)
+      const rb = resolveRefPos(retNode.end)
+      if (ta && tb && ra && rb) {
+        const r0 = Math.min(ta[0], tb[0])
+        const r1 = Math.max(ta[0], tb[0])
+        const c0 = Math.min(ta[1], tb[1])
+        const retR0 = Math.min(ra[0], rb[0])
+        const retC = ra[1]
+        for (let r = r0; r <= r1; r++) {
+          const cell = ctx.resolveCell(r, c0)
+          if (cell === undefined) continue
+          const hit =
+            typeof key === "number" && typeof cell === "number"
+              ? key === cell
+              : String(key ?? "") === String(cell ?? "")
+          if (hit) {
+            const row = retR0 + (r - r0)
+            const found = ctx.resolveCell(row, retC)
+            if (found === undefined) return err("#REF!")
+            return found
+          }
+        }
+        if (node.args[3] !== undefined) return toScalar(evalNode(node.args[3], ctx, false))
+        return err("#N/A")
+      }
+    }
+    return err("#VALUE!")
+  }
 
   const fn = FUNCTIONS[name]
   if (!fn) return err("#NAME?")
@@ -615,6 +716,197 @@ const FUNCTIONS: Record<string, GridFunction> = {
   }),
 }
 
+// ─── Fonctions étendues (texte / dates / logique) — 2026-09-07 ───
+const pad2 = (n: number) => (n < 10 ? "0" + n : String(n))
+const toLocalDate = (v: FormulaValue): Date | FormulaError => {
+  if (v === null || v === undefined || v === "") return err("#VALUE!")
+  if (typeof v === "number") return new Date(v * 86400000) // série Excel approx.
+  const s = String(v).trim().replace(" ", "T")
+  const d = new Date(s.length >= 10 ? s : s + "T00:00:00")
+  return Number.isNaN(d.getTime()) ? err("#VALUE!") : d
+}
+const isoLocal = (d: Date, time = false) => {
+  const base =
+    d.getFullYear() + "-" + pad2(d.getMonth() + 1) + "-" + pad2(d.getDate())
+  return time ? base + "T" + pad2(d.getHours()) + ":" + pad2(d.getMinutes()) : base
+}
+const isoUTC = (d: Date) =>
+  d.getUTCFullYear() + "-" + pad2(d.getUTCMonth() + 1) + "-" + pad2(d.getUTCDate())
+
+Object.assign(FUNCTIONS, {
+  // Logique étendue (évaluées paresseusement dans evalCall : IFS, SWITCH, IFNA, VLOOKUP)
+  // Texte
+  left: (args: FormulaValue[]) => {
+    const s = toStr(args[0] ?? null)
+    const n = args[1] === undefined ? 1 : Math.max(0, Math.trunc(Number(args[1]) || 0))
+    return s.slice(0, n)
+  },
+  right: (args: FormulaValue[]) => {
+    const s = toStr(args[0] ?? null)
+    const n = args[1] === undefined ? 1 : Math.max(0, Math.trunc(Number(args[1]) || 0))
+    return n === 0 ? "" : s.slice(-n)
+  },
+  mid: (args: FormulaValue[]) => {
+    const s = toStr(args[0] ?? null)
+    const start = Math.max(1, Math.trunc(Number(args[1]) || 0))
+    const len = args[2] === undefined ? s.length : Math.max(0, Math.trunc(Number(args[2]) || 0))
+    return s.slice(start - 1, start - 1 + len)
+  },
+  find: (args: FormulaValue[]) => {
+    const find = toStr(args[0] ?? null)
+    const within = toStr(args[1] ?? null)
+    const start = Math.max(1, Math.trunc(Number(args[2]) || 0)) - 1
+    if (!find) return err("#VALUE!")
+    const i = within.indexOf(find, Math.max(0, start))
+    return i === -1 ? err("#VALUE!") : i + 1
+  },
+  substitute: (args: FormulaValue[]) => {
+    const text = toStr(args[0] ?? null)
+    const oldS = toStr(args[1] ?? null)
+    const newS = toStr(args[2] ?? null)
+    if (!oldS) return text
+    const which = args[3] === undefined ? -1 : Math.trunc(Number(args[3]) || 0)
+    if (which <= 0) return text.split(oldS).join(newS)
+    let count = 0
+    let idx = 0
+    while (true) {
+      const at = text.indexOf(oldS, idx)
+      if (at === -1) return text
+      count++
+      if (count === which) {
+        return text.slice(0, at) + newS + text.slice(at + oldS.length)
+      }
+      idx = at + oldS.length
+    }
+  },
+  replace: (args: FormulaValue[]) => {
+    const s = toStr(args[0] ?? null)
+    const start = Math.max(1, Math.trunc(Number(args[1]) || 0)) - 1
+    const num = Math.max(0, Math.trunc(Number(args[2]) || 0))
+    const repl = toStr(args[3] ?? null)
+    return s.slice(0, start) + repl + s.slice(start + num)
+  },
+  concatenate: (args: FormulaValue[]) => FUNCTIONS.concat!(args, false),
+  // Dates (ISO : AAAA-MM-JJ, AAAA-MM-JJT HH:mm)
+  today: () => isoLocal(new Date()),
+  now: () => isoLocal(new Date(), true),
+  date: (args: FormulaValue[]) => {
+    const y = Math.trunc(Number(args[0]) || 0)
+    const m = Math.trunc(Number(args[1]) || 0)
+    const d = Math.trunc(Number(args[2]) || 0)
+    const dt = new Date(Date.UTC(y, m - 1, d))
+    return isoUTC(dt)
+  },
+  year: (args: FormulaValue[]) => {
+    const d = toLocalDate(args[0] ?? null)
+    return isError(d) ? d : d.getFullYear()
+  },
+  month: (args: FormulaValue[]) => {
+    const d = toLocalDate(args[0] ?? null)
+    return isError(d) ? d : d.getMonth() + 1
+  },
+  day: (args: FormulaValue[]) => {
+    const d = toLocalDate(args[0] ?? null)
+    return isError(d) ? d : d.getDate()
+  },
+  edate: (args: FormulaValue[]) => {
+    const d = toLocalDate(args[0] ?? null)
+    if (isError(d)) return d
+    const months = Math.trunc(Number(args[1]) || 0)
+    d.setMonth(d.getMonth() + months)
+    return isoLocal(d)
+  },
+  // Dates avancées (2026-09-07)
+  weekday: (args: FormulaValue[]) => {
+    const d = toLocalDate(args[0] ?? null)
+    if (isError(d)) return d
+    const t = Math.trunc(Number(args[1]) ?? 1) || 1
+    const wd = d.getDay() // 0 = dimanche
+    if (t === 2) return wd === 0 ? 7 : wd
+    if (t === 3) return wd === 0 ? 6 : wd - 1
+    return wd + 1 // 1 = dimanche .. 7 = samedi
+  },
+  eomonth: (args: FormulaValue[]) => {
+    const d = toLocalDate(args[0] ?? null)
+    if (isError(d)) return d
+    const m = Math.trunc(Number(args[1]) || 0)
+    d.setMonth(d.getMonth() + m + 1, 0)
+    return isoLocal(d)
+  },
+  datedif: (args: FormulaValue[]) => {
+    const a = toLocalDate(args[0] ?? null)
+    const b = toLocalDate(args[1] ?? null)
+    if (isError(a) || isError(b)) return isError(a) ? a : b
+    const unit = toStr(args[2] ?? "d").toUpperCase()
+    let ms = b.getTime() - a.getTime()
+    if (ms < 0 && unit !== "YD") return err("#NUM!")
+    const days = Math.floor(ms / 86400000)
+    if (unit === "D") return days
+    if (unit === "M") {
+      return (
+        (b.getFullYear() - a.getFullYear()) * 12 +
+        (b.getMonth() - a.getMonth()) -
+        (b.getDate() < a.getDate() ? 1 : 0)
+      )
+    }
+    if (unit === "Y") {
+      let y = b.getFullYear() - a.getFullYear()
+      if (b.getMonth() < a.getMonth() || (b.getMonth() === a.getMonth() && b.getDate() < a.getDate())) y--
+      return y
+    }
+    if (unit === "MD") {
+      const tmp = new Date(a)
+      tmp.setFullYear(b.getFullYear(), b.getMonth(), 1)
+      tmp.setMonth(tmp.getMonth() + 1, 0)
+      const base = Math.max(1, tmp.getDate())
+      return b.getDate() < a.getDate() ? b.getDate() + (base - a.getDate()) : b.getDate() - a.getDate()
+    }
+    if (unit === "YD") {
+      const anchor = new Date(b)
+      anchor.setFullYear(a.getFullYear())
+      if (anchor < a) anchor.setFullYear(a.getFullYear() + 1)
+      return Math.round((b.getTime() - anchor.getTime()) / 86400000)
+    }
+    return err("#VALUE!")
+  },
+  text: (args: FormulaValue[]) => {
+    const v = args[0] ?? null
+    const fmt = toStr(args[1] ?? "")
+    // nombres : 0.00 / 0% / milliers
+    if (typeof v === "number" || (typeof v === "string" && !Number.isNaN(Number(v)))) {
+      const n = typeof v === "number" ? v : Number(v)
+      const f = fmt.trim()
+      if (f.includes("%")) return String(Math.round(n * 100)) + "%"
+      const dec = /0+(\.0+)?/.exec(f)?.[0]
+      const digits = dec && dec.includes(".") ? dec.length - dec.indexOf(".") - 1 : 0
+      if (f === "0") return String(Math.round(n))
+      return n.toFixed(digits)
+    }
+    // dates ISO → tokens YYYY MM DD HH mm
+    const d = toLocalDate(v)
+    if (!isError(d)) {
+      const map: Record<string, string> = {
+        YYYY: String(d.getFullYear()),
+        YY: pad2(d.getFullYear() % 100),
+        MM: pad2(d.getMonth() + 1),
+        DD: pad2(d.getDate()),
+        HH: pad2(d.getHours()),
+        mm: pad2(d.getMinutes()),
+        hh: pad2(d.getHours() % 12 || 12),
+        ss: pad2(d.getSeconds()),
+        dddd: "",
+      }
+      let out = fmt
+      for (const k of Object.keys(map)) out = out.split(k).join(map[k]!)
+      out = out.replace(/dddd|ddd/g, "")
+      return out
+    }
+    return toStr(v)
+  },
+  // Aléatoire / autres
+  rand: () => Math.random(),
+})
+
 /** É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

package/lib/icons.ts

@@ -61,4 +61,21 @@ export const icons = {
   alignRight: "lucide:align-right",
   listChecks: "lucide:list-checks",
   table: "lucide:table",
+  // — tableur (QSpreadsheet) —
+  trash2: "lucide:trash-2",
+  clipboardPaste: "lucide:clipboard-paste",
+  rows3: "lucide:rows-3",
+  columns3: "lucide:columns-3",
+  arrowAZ: "lucide:arrow-up-a-z",
+  arrowZA: "lucide:arrow-down-a-z",
+  squarePlus: "lucide:square-plus",
+  squareMinus: "lucide:square-minus",
+  pencil: "lucide:pencil",
+  sortAsc: "lucide:arrow-up-narrow-wide",
+  sortDesc: "lucide:arrow-down-wide-narrow",
+  selectCheck: "lucide:check",
+  filter: "lucide:filter",
+  scissors: "lucide:scissors",
+  highlighter: "lucide:highlighter",
+  tableCellsMerge: "lucide:table-cells-merge",
 } as const