@dnax/ui 0.0.27 → 0.0.29

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

@@ -35,4 +35,47 @@ export const icons = {
   search: "lucide:search",
   star: "lucide:star",
   x: "lucide:x",
+  // — éditeur de texte (QTiptap) —
+  undo2: "lucide:undo-2",
+  redo2: "lucide:redo-2",
+  pilcrow: "lucide:pilcrow",
+  heading1: "lucide:heading-1",
+  heading2: "lucide:heading-2",
+  heading3: "lucide:heading-3",
+  bold: "lucide:bold",
+  italic: "lucide:italic",
+  underline: "lucide:underline",
+  strikethrough: "lucide:strikethrough",
+  code: "lucide:code",
+  link: "lucide:link",
+  unlink: "lucide:unlink",
+  list: "lucide:list",
+  listOrdered: "lucide:list-ordered",
+  quote: "lucide:quote",
+  codeXml: "lucide:code-xml",
+  removeFormatting: "lucide:remove-formatting",
+  palette: "lucide:palette",
+  eraser: "lucide:eraser",
+  alignLeft: "lucide:align-left",
+  alignCenter: "lucide:align-center",
+  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

package/lib/intersection.ts

@@ -0,0 +1,118 @@
+// v-intersection — directive : appelle un handler quand l'élément entre /
+// sort du viewport (Intersection Observer), équivalent Quasar
+// https://quasar.dev/vue-directives/intersection
+//
+// Usage :
+//   <div v-intersection="onEnter">…</div>
+//   <div v-intersection.once="onFirstEnter">…</div>
+//   <div v-intersection="{ handler, cfg: { rootMargin: '0px', threshold: 0.2 } }">…</div>
+//   <div v-intersection="false">…</div>   (désactive l'observation)
+//
+// Le handler reçoit un IntersectionObserverEntry. Les éléments partageant les
+// mêmes options (cfg) utilisent le même IntersectionObserver sous le capot.
+
+export type IntersectionValue =
+  | ((entry: IntersectionObserverEntry) => void)
+  | { handler: (entry: IntersectionObserverEntry) => void; cfg?: IntersectionObserverInit }
+  | false
+  | undefined
+  | null
+
+type PoolEntry = {
+  key: string
+  observer: IntersectionObserver
+  elements: Set<Element>
+}
+
+type QElement = HTMLElement & {
+  __qIntersection?: {
+    key: string
+    observer: IntersectionObserver
+    handler: (e: IntersectionObserverEntry) => void
+    once: boolean
+    raw: IntersectionValue
+  }
+}
+
+const pool = new Map<string, PoolEntry>()
+
+function getPoolEntry(cfg: IntersectionObserverInit): PoolEntry {
+  const key = JSON.stringify([
+    cfg.rootMargin ?? "0px",
+    cfg.threshold ?? 0,
+    cfg.root === null ? null : cfg.root instanceof Element ? (cfg.root as Element).id || "" : String(cfg.root),
+  ])
+  let entry = pool.get(key)
+  if (!entry) {
+    const elements = new Set<Element>()
+    const observer = new IntersectionObserver((entries) => {
+      for (const e of entries) {
+        const rec = (e.target as QElement).__qIntersection
+        if (!rec) continue
+        if (rec.once && e.isIntersecting) {
+          rec.handler(e)
+          unobserve(e.target as QElement)
+          continue
+        }
+        rec.handler(e)
+      }
+    }, cfg)
+    entry = { key, observer, elements }
+    pool.set(key, entry)
+  }
+  return entry
+}
+
+function unobserve(el: QElement) {
+  const rec = el.__qIntersection
+  if (!rec) return
+  const entry = pool.get(rec.key)
+  el.__qIntersection = undefined
+  rec.observer.unobserve(el)
+  if (entry) {
+    entry.elements.delete(el)
+    if (entry.elements.size === 0) {
+      entry.observer.disconnect()
+      pool.delete(rec.key)
+    }
+  }
+}
+
+function apply(el: HTMLElement, value: IntersectionValue, once = false) {
+  const target = el as QElement
+  if (target.__qIntersection) unobserve(target)
+  if (!value) return
+
+  let handler: (entry: IntersectionObserverEntry) => void
+  let cfg: IntersectionObserverInit = { root: null, rootMargin: "0px", threshold: 0 }
+
+  if (typeof value === "function") {
+    handler = value
+  }
+  else if (typeof value === "object") {
+    handler = value.handler
+    if (value.cfg) cfg = { ...value.cfg }
+  }
+  else {
+    return
+  }
+
+  const entry = getPoolEntry(cfg)
+  target.__qIntersection = { key: entry.key, observer: entry.observer, handler, once, raw: value }
+  entry.elements.add(el)
+  entry.observer.observe(el)
+}
+
+export const vIntersection = {
+  mounted(el: HTMLElement, binding: { value?: IntersectionValue; modifiers?: Record<string, boolean> }) {
+    apply(el, binding.value, !!binding.modifiers?.once)
+  },
+  updated(el: HTMLElement, binding: { value?: IntersectionValue; modifiers?: Record<string, boolean> }) {
+    const rec = (el as QElement).__qIntersection
+    if (rec && rec.raw === binding.value) return
+    apply(el, binding.value, !!binding.modifiers?.once)
+  },
+  unmounted(el: HTMLElement) {
+    unobserve(el as QElement)
+  },
+}

package/lib/q.ts

@@ -14,6 +14,7 @@ import QNotifyToast from "../components/QNotifyToast.vue"
 import { platform, qBreakpoints } from "./platform"
 import { screen } from "./screen"
 import { loading } from "./loading"
+import { localStorage, sessionStorage } from "./storage"
 
 export interface DialogOptions {
   /** Composant de dialogue (SFC importé) ou nom de composant global */
@@ -323,8 +324,9 @@ function notify(opts: NotifyOptions): NotifyController {
 }
 
 // API publique : $q.dialog / $q.bottomSheet / $q.notify / $q.imagePreview / $q.platform / $q.breakpoints / $q.screen / $q.loading
+// / $q.localStorage / $q.sessionStorage (stockage web typé)
 // Conventions Quasar : .open() pour les piles (dialog, bottomSheet, imagePreview),
-// .show() pour notify et loading.
+// .show() pour notify et loading ; méthodes directes pour le stockage.
 const notifyPlugin = notify as typeof notify & { show: typeof notify }
 notifyPlugin.show = notify
 
@@ -343,6 +345,8 @@ export const $q = {
   breakpoints: qBreakpoints,
   screen,
   loading,
+  localStorage,
+  sessionStorage,
 }
 
 /** Accès programmatique aux plugins ($q.dialog, $q.notify, $q.loading…) */

package/lib/spreadsheet.test.ts

@@ -0,0 +1,92 @@
+// Tests unitaires des helpers purs du tableur (bun test).
+import { describe, expect, it } from "bun:test"
+import {
+  colLetter,
+  colFromLetters,
+  isBlankValue,
+  isoAddDays,
+  shiftFormulaRefs,
+  csvEscape,
+  csvSplitLine,
+  parseCsv,
+  deriveCols,
+} from "./spreadsheet"
+
+describe("lettres de colonnes", () => {
+  it("colLetter : 0→A, 25→Z, 26→AA, 27→AB, 701→ZZ, 702→AAA", () => {
+    expect(colLetter(0)).toBe("A")
+    expect(colLetter(25)).toBe("Z")
+    expect(colLetter(26)).toBe("AA")
+    expect(colLetter(27)).toBe("AB")
+    expect(colLetter(701)).toBe("ZZ")
+    expect(colLetter(702)).toBe("AAA")
+  })
+  it("colFromLetters est l'inverse", () => {
+    expect(colFromLetters("A")).toBe(0)
+    expect(colFromLetters("AA")).toBe(26)
+    expect(colFromLetters("zz")).toBe(701)
+    for (let i = 0; i < 200; i++) expect(colFromLetters(colLetter(i))).toBe(i)
+  })
+})
+
+describe("shiftFormulaRefs (autofill)", () => {
+  it("décale les références relatives de (dr,dc)", () => {
+    expect(shiftFormulaRefs("=B1*C1", 1, 0)).toBe("=B2*C2")
+    expect(shiftFormulaRefs("=A1", 0, 2)).toBe("=C1")
+  })
+  it("préserve les $ absolus", () => {
+    expect(shiftFormulaRefs("=$B$1+A1", 2, 0)).toBe("=$B$1+A3")
+    expect(shiftFormulaRefs("=$B1+B$1", 1, 1)).toBe("=$B2+C$1")
+  })
+  it("décale les plages entières", () => {
+    expect(shiftFormulaRefs("=SUM(D1:D4)", 1, 0)).toBe("=SUM(D2:D5)")
+  })
+  it("laisse les valeurs sans lettres intactes", () => {
+    expect(shiftFormulaRefs("=1+2", 1, 1)).toBe("=1+2")
+  })
+})
+
+describe("dates ISO", () => {
+  it("isoAddDays", () => {
+    expect(isoAddDays("2026-09-07", 1)).toBe("2026-09-08")
+    expect(isoAddDays("2026-09-07", -7)).toBe("2026-08-31")
+    expect(isoAddDays("2026-12-31", 1)).toBe("2027-01-01")
+  })
+  it("isBlankValue", () => {
+    expect(isBlankValue(null)).toBe(true)
+    expect(isBlankValue(undefined)).toBe(true)
+    expect(isBlankValue("")).toBe(true)
+    expect(isBlankValue(0)).toBe(false)
+    expect(isBlankValue("0")).toBe(false)
+  })
+})
+
+describe("CSV", () => {
+  it("csvEscape quote si nécessaire", () => {
+    expect(csvEscape("simple", ",")).toBe("simple")
+    expect(csvEscape("a,b", ",")).toBe('"a,b"')
+    expect(csvEscape('say "hi"', ",")).toBe('"say ""hi"""')
+    expect(csvEscape("ligne\nsuivante", ";")).toBe('"ligne\nsuivante"')
+    expect(csvEscape(null, ",")).toBe("")
+  })
+  it("csvSplitLine gère les guillemets doublés et les délimiteurs", () => {
+    expect(csvSplitLine('a,"b,c",d', ",")).toEqual(["a", "b,c", "d"])
+    expect(csvSplitLine('"x""y",z', ",")).toEqual(['x"y', "z"])
+    expect(csvSplitLine("a;b", ";")).toEqual(["a", "b"])
+  })
+  it("parseCsv : multiligne, quotes, CRLF", () => {
+    const text = 'h1,h2\r\n"a,1","b""2"\r\nc,d\n'
+    expect(parseCsv(text)).toEqual([
+      ["h1", "h2"],
+      ["a,1", 'b"2'],
+      ["c", "d"],
+    ])
+  })
+  it("deriveCols déduit les colonnes des clés", () => {
+    expect(deriveCols([{ a: 1, b: "x" }, { b: 2, c: true }])).toEqual([
+      { name: "a", type: "text" },
+      { name: "b", type: "text" },
+      { name: "c", type: "text" },
+    ])
+  })
+})