@dnax/ui 0.0.27 → 0.0.29

package/lib/spreadsheet.ts

@@ -0,0 +1,175 @@
+// Helpers purs du tableur QSpreadsheet — extraits du composant pour être
+// testables unitairement (bun test). Aucune dépendance DOM / Vue.
+
+/** Index de colonne (0-based) → lettres Excel : 0 → "A", 25 → "Z", 26 → "AA" */
+export const colLetter = (i: number): string => {
+  let n = i
+  let s = ""
+  while (n >= 0) {
+    s = String.fromCharCode(65 + (n % 26)) + s
+    n = Math.floor(n / 26) - 1
+  }
+  return s
+}
+
+/** Lettres Excel → index de colonne 0-based : "A" → 0, "AA" → 26 */
+export const colFromLetters = (s: string): number => {
+  let n = 0
+  for (const ch of s.toUpperCase()) n = n * 26 + (ch.charCodeAt(0) - 64)
+  return n - 1
+}
+
+/** Cellule « vide » : null, undefined ou chaîne vide */
+export const isBlankValue = (v: any): boolean =>
+  v === null || v === undefined || v === ""
+
+/**
+ * Décale les références A1 non absolues d'une formule de (dr, dc) —
+ * plages incluses, `$` préservés (copie / autofill).
+ */
+export const shiftFormulaRefs = (src: string, dr: number, dc: number): string =>
+  src.replace(
+    /(\$?)([A-Za-z]{1,3})(\$?)(\d+)/g,
+    (_m: string, ca: string, L: string, ra: string, D: string) => {
+      const col = colFromLetters(L) + (ca === "$" ? 0 : dc)
+      const row = Number(D) - 1 + (ra === "$" ? 0 : dr)
+      if (col < 0 || row < 0) return _m
+      return ca + colLetter(col) + ra + (row + 1)
+    },
+  )
+
+/** Date ISO AAAA-MM-JJ */
+export const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/
+
+/** Ajoute des jours à une date ISO (UTC, évite le décalage de fuseau) */
+export const isoAddDays = (iso: string, days: number): string => {
+  const d = new Date(iso + "T00:00:00Z")
+  d.setUTCDate(d.getUTCDate() + days)
+  return d.toISOString().slice(0, 10)
+}
+
+/** Échappe une valeur pour un CSV (quote si délimiteur / guillemet / newline) */
+export const csvEscape = (s: unknown, delim: string): string => {
+  const str = s === null || s === undefined ? "" : String(s)
+  return str.includes(delim) || str.includes('"') || /[\n\r]/.test(str)
+    ? '"' + str.replace(/"/g, '""') + '"'
+    : str
+}
+
+/**
+ * Décode une ligne CSV (guillemets doublés, délimiteur multi-caractère géré
+ * comme un caractère unique ; retourne les cellules décodées).
+ */
+export const csvSplitLine = (line: string, delim = ","): string[] => {
+  const out: string[] = []
+  let cur = ""
+  let inQ = false
+  let i = 0
+  const isDelim = (at: number) => line.startsWith(delim, at)
+  while (i < line.length) {
+    const ch = line[i]!
+    if (inQ) {
+      if (ch === '"') {
+        if (line[i + 1] === '"') {
+          cur += '"'
+          i += 2
+          continue
+        }
+        inQ = false
+        i++
+        continue
+      }
+      cur += ch
+      i++
+      continue
+    }
+    if (ch === '"') {
+      inQ = true
+      i++
+      continue
+    }
+    if (isDelim(i)) {
+      out.push(cur)
+      cur = ""
+      i += delim.length
+      continue
+    }
+    cur += ch
+    i++
+  }
+  out.push(cur)
+  return out
+}
+
+/**
+ * Parse un texte CSV complet (CRLF ou LF, guillemets) en lignes de cellules.
+ */
+export const parseCsv = (text: string, delim = ","): string[][] => {
+  const lines: string[][] = []
+  const current: string[] = []
+  let cell = ""
+  let inQ = false
+  let sawDelim = false
+  let i = 0
+  const isDelim = (at: number) => text.startsWith(delim, at)
+  const pushCell = () => {
+    current.push(cell)
+    cell = ""
+  }
+  while (i < text.length) {
+    const ch = text[i]!
+    if (inQ) {
+      if (ch === '"') {
+        if (text[i + 1] === '"') {
+          cell += '"'
+          i += 2
+          continue
+        }
+        inQ = false
+        i++
+        continue
+      }
+      cell += ch
+      i++
+      continue
+    }
+    if (ch === '"') {
+      inQ = true
+      i++
+      continue
+    }
+    if (isDelim(i)) {
+      pushCell()
+      sawDelim = true
+      i += delim.length
+      continue
+    }
+    if (ch === "\n") {
+      pushCell()
+      lines.push(current.splice(0))
+      sawDelim = false
+      i++
+      continue
+    }
+    if (ch === "\r") {
+      // les retours \r\n sont déjà gérés par le \n
+      i++
+      continue
+    }
+    cell += ch
+    i++
+  }
+  pushCell()
+  const onlyTrailingNewline = current.length === 1 && current[0] === "" && !sawDelim
+  if (lines.length === 0 || !onlyTrailingNewline) lines.push(current)
+  return lines
+}
+
+/** Colonnes déduites des clés d'un jeu de lignes (type texte) */
+export const deriveCols = (
+  rows: Record<string, any>[],
+): { name: string; type: "text" }[] => {
+  const keys = new Set<string>()
+  for (const r of rows) Object.keys(r).forEach((k) => keys.add(k))
+  return [...keys].map((k) => ({ name: k, type: "text" as const }))
+}

package/lib/storage.ts

@@ -0,0 +1,175 @@
+// $q.localStorage / $q.sessionStorage — stockage web façon Quasar
+// (https://quasar.dev/quasar-plugins/web-storage).
+//
+// Les valeurs sont sérialisées avec leur type d'origine (Date, RegExp, number,
+// boolean, string, objets/tableaux) grâce à un encodage préfixé — le format
+// `__q_*` est volontairement IDENTIQUE à celui de Quasar : des clés écrites par
+// une app Quasar restent lisibles par dnax.ui et inversement.
+//
+// Autres types (undefined, null, bigint, symbol, fonction) : stockés sous forme
+// de string (comportement Quasar).
+//
+// SSR-safe : côté serveur (ou quand le Web Storage est indisponible — mode
+// privé, iframe sandbox…), toutes les méthodes deviennent des no-op et
+// getItem/getIndex/getKey renvoient null, getAll {}, getAllKeys [].
+
+export interface QWebStorage {
+  /** true si la clé existe */
+  has(key: string): boolean
+  /** Alias de has() */
+  hasItem(key: string): boolean
+  /** Nombre de clés stockées */
+  getLength(): number
+  /** Valeur (typée) de la clé, ou null si absente */
+  getItem<T = unknown>(key: string): T | null
+  /** Valeur (typée) stockée à l'index donné (ordre du Web Storage), ou null */
+  getIndex<T = unknown>(index: number): T | null
+  /** Clé stockée à l'index donné, ou null */
+  getKey(index: number): string | null
+  /** Toutes les entrées : { clé: valeur typée } */
+  getAll(): Record<string, unknown>
+  /** Toutes les clés, dans l'ordre du Web Storage */
+  getAllKeys(): string[]
+  /** Stocke une valeur (sérialisation typée) — alias de setItem() */
+  set(key: string, value: unknown): void
+  /** Stocke une valeur (sérialisation typée) */
+  setItem(key: string, value: unknown): void
+  /** Supprime la clé — alias de removeItem() */
+  remove(key: string): void
+  /** Supprime la clé */
+  removeItem(key: string): void
+  /** Vide tout le stockage */
+  clear(): void
+  /** true si le stockage est vide */
+  isEmpty(): boolean
+}
+
+// — Sérialisation typée (format compatible Quasar) —
+// Encode : `__q_<type>|<payload>` — tout type supporté ré-encode ses données
+// pour que le Web Storage (qui ne stocke que des strings) restitue le type.
+
+function encode(value: unknown): string {
+  if (value instanceof Date) return `__q_date|${value.getTime()}`
+  if (value instanceof RegExp) return `__q_expr|${value.source}`
+  switch (typeof value) {
+    case "number": return `__q_numb|${value}`
+    case "boolean": return `__q_bool|${value ? "1" : "0"}`
+    case "string": return `__q_strn|${value}`
+    case "function": return `__q_strn|${value.toString()}`
+    case "object":
+      if (value !== null) return `__q_objt|${JSON.stringify(value)}`
+      break
+  }
+  // Type non supporté (undefined, null, bigint, symbol…) : stocké tel quel
+  // (le Web Storage le convertit en string — même résultat côté lecture).
+  return String(value)
+}
+
+const NUMBER_RE = /^-?\d+$/
+
+function decode(value: string): unknown {
+  // Valeur non encodée par nous (< préfixe, ou préfixe inconnu) : telle quelle
+  if (value.length < 9) return value
+  const type = value.slice(0, 8)
+  const source = value.slice(9)
+
+  switch (type) {
+    case "__q_date": {
+      // Horodatage numérique (format actuel) ou string ISO (anciens formats)
+      return new Date(NUMBER_RE.test(source) ? Number.parseInt(source, 10) : source)
+    }
+    case "__q_expr":
+      return new RegExp(source)
+    case "__q_numb":
+      return Number(source)
+    case "__q_bool":
+      return source === "1"
+    case "__q_strn":
+      return source
+    case "__q_objt": {
+      try {
+        return JSON.parse(source)
+      }
+      catch {
+        // Payload corrompu → valeur brute plutôt que de faire planter getItem()
+        return value
+      }
+    }
+    default:
+      return value
+  }
+}
+
+// Instance no-op pour SSR / Web Storage indisponible (miroir de Quasar :
+// getEmptyStorage) — jamais de throw ni d'accès à window.
+function emptyStorage(): QWebStorage {
+  const noop = () => {}
+  return {
+    has: () => false,
+    hasItem: () => false,
+    getLength: () => 0,
+    getItem: () => null,
+    getIndex: () => null,
+    getKey: () => null,
+    getAll: () => ({}),
+    getAllKeys: () => [],
+    set: noop,
+    setItem: noop,
+    remove: noop,
+    removeItem: noop,
+    clear: noop,
+    isEmpty: () => true,
+  }
+}
+
+function init(type: "local" | "session"): QWebStorage {
+  try {
+    if (typeof window === "undefined") return emptyStorage()
+    const ws = type === "local" ? window.localStorage : window.sessionStorage
+    if (!ws) return emptyStorage()
+
+    const get = (key: string): unknown => {
+      const item = ws.getItem(key)
+      return item === null ? null : decode(item)
+    }
+
+    return {
+      has: (key) => ws.getItem(key) !== null,
+      hasItem: (key) => ws.getItem(key) !== null,
+      getLength: () => ws.length,
+      getItem: <T = unknown>(key: string): T | null => get(key) as T | null,
+      getIndex: <T = unknown>(index: number): T | null =>
+        index < ws.length ? (get(ws.key(index) as string) as T | null) : null,
+      getKey: (index) => (index < ws.length ? ws.key(index) : null),
+      getAll: () => {
+        const result: Record<string, unknown> = {}
+        for (let i = 0; i < ws.length; i++) {
+          const key = ws.key(i) as string
+          result[key] = get(key)
+        }
+        return result
+      },
+      getAllKeys: () => {
+        const result: string[] = []
+        for (let i = 0; i < ws.length; i++) result.push(ws.key(i) as string)
+        return result
+      },
+      set: (key, value) => ws.setItem(key, encode(value)),
+      setItem: (key, value) => ws.setItem(key, encode(value)),
+      remove: (key) => ws.removeItem(key),
+      removeItem: (key) => ws.removeItem(key),
+      clear: () => ws.clear(),
+      isEmpty: () => ws.length === 0,
+    }
+  }
+  catch {
+    // Accès bloqué (mode privé, cookies désactivés…) → instance no-op
+    return emptyStorage()
+  }
+}
+
+/** $q.localStorage — stockage persistant (API Quasar Web Storage) */
+export const localStorage: QWebStorage = init("local")
+
+/** $q.sessionStorage — stockage par session (API Quasar Web Storage) */
+export const sessionStorage: QWebStorage = init("session")

package/lib/tiptap-table.ts

@@ -0,0 +1,19 @@
+// Tables Tiptap pour QTiptap — le nœud « table » est rendu par une NodeView
+// Vue (QTiptapTableView) au lieu du rendu DOM/colgroup par défaut. On garde
+// les nœuds officiels TableRow/TableHeader/TableCell (schéma, keymaps,
+// commandes) ; on ne remplace que le addNodeView de « table ».
+import { Table, TableHeader, TableCell, TableRow } from "@tiptap/extension-table"
+import { VueNodeViewRenderer } from "@tiptap/vue-3"
+import type { NodeViewProps } from "@tiptap/vue-3"
+import type { Component } from "vue"
+import QTiptapTableView from "../components/internal/QTiptapTableView.vue"
+
+export { TableHeader, TableCell, TableRow }
+
+export const QTipTapTable = Table.extend({
+  addNodeView() {
+    // defineProps(nodeViewProps) ne fait pas remonter les types vers le renderer
+    // → cast vers Component<NodeViewProps>
+    return VueNodeViewRenderer(QTiptapTableView as Component<NodeViewProps>)
+  },
+})

package/lib/tiptap-task-list.ts

@@ -0,0 +1,16 @@
+// Task list Tiptap pour QTiptap — l'élément de liste est rendu par une
+// NodeView Vue (q-checkbox dnax.ui) : on garde l'extension officielle
+// TaskItem (schéma, parse/render, keymap, input rules) et on ne remplace que
+// son addNodeView par VueNodeViewRenderer(QTiptapTaskItemView).
+import TaskList from "@tiptap/extension-task-list"
+import TaskItem from "@tiptap/extension-task-item"
+import { VueNodeViewRenderer } from "@tiptap/vue-3"
+import QTiptapTaskItemView from "../components/internal/QTiptapTaskItemView.vue"
+
+export { TaskList }
+
+export const QTipTapTaskItem = TaskItem.extend({
+  addNodeView() {
+    return VueNodeViewRenderer(QTiptapTaskItemView)
+  },
+})

package/lib/touchHold.ts

@@ -0,0 +1,221 @@
+// v-touch-hold — directive : détecte l'appui long (hold) sur un élément,
+// tactile ET souris (modifier .mouse), équivalent Quasar
+// https://quasar.dev/vue-directives/touch-hold
+//
+// Usage :
+//   <div v-touch-hold="handler" />                  → 600ms, sensibilité 5/7px
+//   <div v-touch-hold.mouse="{ time: 400, sensitivity: 6 }" />
+//   <div v-touch-hold="'400:8:10'" />               → 400ms, 8px tactile, 10px souris
+//   <div v-touch-hold="350" />
+// modifiers : mouse (inclut la souris), capture / mouseCapture, stop, prevent,
+// passive
+//
+// Détails du handler (compatible Quasar) :
+//   { evt, position: { left, top }, duration }
+// Après déclenchement, le geste est « consommé » : le click/touchend qui suit
+// est supprimé (un appui long ne déclenche pas aussi un clic).
+
+export interface TouchHoldDetails {
+  evt: Event
+  position: { left: number; top: number }
+  duration: number
+}
+
+export type TouchHoldHandler = (details: TouchHoldDetails) => void
+
+const DEFAULTS = { time: 600, touchSensitivity: 5, mouseSensitivity: 7 }
+
+interface HoldOptions {
+  handler: TouchHoldHandler
+  time: number
+  touchSensitivity: number
+  mouseSensitivity: number
+  mouse: boolean
+  stop: boolean
+  prevent: boolean
+  capture: boolean
+  passive: boolean
+}
+
+type QElement = HTMLElement & { __qTouchHoldCleanup?: () => void }
+
+function parseValue(value: unknown): Partial<typeof DEFAULTS> {
+  if (typeof value === "number") return { time: value }
+  if (typeof value === "string") {
+    const [t, touch, mouse] = value.split(":")
+    const out: Partial<typeof DEFAULTS> = {}
+    const num = Number(t)
+    if (Number.isFinite(num)) out.time = num
+    if (touch !== undefined) {
+      const n = Number(touch)
+      if (Number.isFinite(n)) out.touchSensitivity = n
+    }
+    if (mouse !== undefined) {
+      const n = Number(mouse)
+      if (Number.isFinite(n)) out.mouseSensitivity = n
+    }
+    return out
+  }
+  if (Array.isArray(value)) {
+    const out: Partial<typeof DEFAULTS> = {}
+    const t = Number(value[0])
+    if (Number.isFinite(t)) out.time = t
+    const touch = Number(value[1])
+    if (Number.isFinite(touch)) out.touchSensitivity = touch
+    const mouse = Number(value[2])
+    if (Number.isFinite(mouse)) out.mouseSensitivity = mouse
+    return out
+  }
+  if (value && typeof value === "object") {
+    const o = value as Record<string, unknown>
+    const out: Partial<typeof DEFAULTS> = {}
+    const t = Number(o.time ?? o.duration)
+    if (Number.isFinite(t)) out.time = t
+    const touch = Number(o.sensitivity ?? o.touchSensitivity)
+    if (Number.isFinite(touch)) out.touchSensitivity = touch
+    const mouse = Number(o.mouseSensitivity)
+    if (Number.isFinite(mouse)) out.mouseSensitivity = mouse
+    return out
+  }
+  return {}
+}
+
+export const vTouchHold = {
+  mounted(el: HTMLElement, binding: { value?: unknown; modifiers?: Record<string, boolean> }) {
+    const handler = binding.value
+    if (typeof handler !== "function") {
+      console.warn("[v-touch-hold] value doit être une fonction (handler)")
+      return
+    }
+    const m = binding.modifiers ?? {}
+    const parsed = parseValue(binding.value)
+    const options: HoldOptions = {
+      handler: handler as TouchHoldHandler,
+      time: parsed.time ?? DEFAULTS.time,
+      touchSensitivity: parsed.touchSensitivity ?? DEFAULTS.touchSensitivity,
+      mouseSensitivity: parsed.mouseSensitivity ?? DEFAULTS.mouseSensitivity,
+      mouse: !!m.mouse || !!m.mouseCapture,
+      stop: !!m.stop,
+      prevent: !!m.prevent,
+      capture: !!m.capture || !!m.mouseCapture,
+      passive: !!m.passive,
+    }
+
+    // Éviter scroll / context menu / sélection pendant l'appui
+    el.style.touchAction = "none"
+    el.style.userSelect = "none"
+    ;(el as HTMLElement).style.webkitUserSelect = "none"
+
+    let timer: ReturnType<typeof setTimeout> | undefined
+    let pending = false
+    let consumed = false
+    let startX = 0
+    let startY = 0
+    let lastEvt: PointerEvent | null = null
+    let startTime = 0
+
+    const clearTimer = () => {
+      if (timer) clearTimeout(timer)
+      timer = undefined
+    }
+
+    const cancel = () => {
+      clearTimer()
+      pending = false
+    }
+
+    const finish = () => {
+      clearTimer()
+      if (!pending) return
+      pending = false
+      consumed = true
+      const duration = Math.round(performance.now() - startTime)
+      const evt = lastEvt
+      if (evt) {
+        options.handler({
+          evt,
+          position: { left: evt.clientX, top: evt.clientY },
+          duration: options.time || duration,
+        })
+      }
+      // Consomme la fin du geste : pas de click/touchend après un hold
+      const onUp = (e: Event) => {
+        if (options.prevent) e.preventDefault()
+        if (options.stop) e.stopPropagation()
+        window.removeEventListener("pointerup", onUp, true)
+        window.removeEventListener("pointercancel", onCancelAfter, true)
+        window.removeEventListener("click", onClick, true)
+        window.removeEventListener("touchend", onUp, true)
+      }
+      const onClick = (e: Event) => {
+        e.preventDefault()
+        e.stopPropagation()
+        window.removeEventListener("click", onClick, true)
+        window.removeEventListener("pointerup", onUp, true)
+        window.removeEventListener("touchend", onUp, true)
+      }
+      const onCancelAfter = () => {
+        window.removeEventListener("pointerup", onUp, true)
+        window.removeEventListener("pointercancel", onCancelAfter, true)
+        window.removeEventListener("click", onClick, true)
+      }
+      window.addEventListener("pointerup", onUp, true)
+      window.addEventListener("pointercancel", onCancelAfter, true)
+      window.addEventListener("touchend", onUp, true)
+      window.addEventListener("click", onClick, true)
+    }
+
+    const onPointerDown = (e: PointerEvent) => {
+      if (pending || consumed) return
+      if (e.pointerType === "mouse" && !options.mouse) return
+      if (options.prevent && !options.passive) e.preventDefault()
+      pending = true
+      startX = e.clientX
+      startY = e.clientY
+      startTime = performance.now()
+      lastEvt = e
+      const sensitivity = e.pointerType === "mouse" ? options.mouseSensitivity : options.touchSensitivity
+      timer = setTimeout(finish, options.time)
+
+      const onMove = (ev: PointerEvent) => {
+        if (!pending) return
+        if (Math.abs(ev.clientX - startX) > sensitivity || Math.abs(ev.clientY - startY) > sensitivity) {
+          cancel()
+          cleanup()
+        }
+      }
+      const onUpEarly = () => cancel()
+      const cleanup = () => {
+        el.removeEventListener("pointermove", onMove)
+        el.removeEventListener("pointerup", onUpEarly)
+        el.removeEventListener("pointercancel", onUpEarly)
+      }
+      el.addEventListener("pointermove", onMove, { passive: options.passive })
+      el.addEventListener("pointerup", onUpEarly)
+      el.addEventListener("pointercancel", onUpEarly)
+      ;(el as any).__qHoldCleanupEarly = cleanup
+    }
+
+    const onContext = (e: Event) => {
+      if (pending || consumed) e.preventDefault()
+    }
+
+    const capture = options.capture
+    el.addEventListener("pointerdown", onPointerDown, { capture, passive: options.passive })
+    el.addEventListener("contextmenu", onContext, { capture })
+
+    ;(el as QElement).__qTouchHoldCleanup = () => {
+      el.removeEventListener("pointerdown", onPointerDown, { capture } as any)
+      el.removeEventListener("contextmenu", onContext, { capture } as any)
+      ;(el as any).__qHoldCleanupEarly?.()
+      clearTimer()
+      el.style.touchAction = ""
+      el.style.userSelect = ""
+      el.style.webkitUserSelect = ""
+    }
+  },
+  unmounted(el: HTMLElement) {
+    ;(el as QElement).__qTouchHoldCleanup?.()
+    delete (el as QElement).__qTouchHoldCleanup
+  },
+}