@dnax/ui 0.0.73 → 0.0.76

package/lib/iconSetScrape.ts

@@ -0,0 +1,139 @@
+// Extraction d'icônes pour l'embarquement — **Node uniquement (build)**.
+//
+// Utilisé par :
+//   - `module.ts` (module Nuxt) : scanne les sources de l'app hôte au build ;
+//   - `scripts/gen-icon-set.ts` : produit `lib/iconSet.ts` (sous-ensemble figé) ;
+//   - `lib/iconSet.test.ts` : garde-fou contre la dérive du fichier généré.
+//
+// ⚠️ Ne pas réexporter depuis `index.ts` : ce fichier importe `node:fs`, il n'a rien à
+// faire dans un bundle client.
+import { readdirSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+import type { IconSetJson } from "./icons"
+
+/** `lucide:arrow-down`, `lucide:table-cells-merge`… */
+export const ICON_NAME_RE = /\blucide:[a-z0-9]+(?:-[a-z0-9]+)*/g
+
+const PREFIX = "lucide:"
+
+const TEXT_FILE_RE = /\.(vue|ts|js|mjs|md|mdx)$/
+
+/** Dossiers techniques jamais scannés (le reste de l'arbre est parcouru). */
+export const SKIP_DIRS = new Set([
+  "node_modules",
+  ".nuxt",
+  ".output",
+  ".data",
+  ".git",
+  "dist",
+  "coverage",
+  "public",
+])
+
+/** Noms d'icônes cités dans un texte, **sans** le préfixe (`arrow-down`). */
+export const iconNamesIn = (text: string): string[] =>
+  [...text.matchAll(ICON_NAME_RE)].map((match) => match[0].slice(PREFIX.length))
+
+/** Sous-ensemble de `IconifyJSON` (collection officielle) dont on a besoin. */
+export interface IconifySourceCollection {
+  prefix: string
+  width?: number
+  height?: number
+  icons: Record<string, { body: string; [key: string]: unknown }>
+  aliases?: Record<string, { parent: string; [key: string]: unknown }>
+}
+
+export interface ScrapeOptions {
+  /** Dossiers supplémentaires à ignorer (noms de base, pas des chemins) */
+  skipDirs?: Iterable<string>
+}
+
+/** Fichiers texte (`.vue`, `.ts`, `.js`, `.mjs`, `.md`…) sous `dir`, récursivement. */
+export const textFilesUnder = (dir: string, options: ScrapeOptions = {}): string[] => {
+  const skip = new Set([...SKIP_DIRS, ...(options.skipDirs ?? [])])
+  const found: string[] = []
+
+  const walk = (current: string): void => {
+    let entries
+    try {
+      entries = readdirSync(current, { withFileTypes: true })
+    } catch {
+      return // dossier absent ou illisible : on ignore
+    }
+    for (const entry of entries) {
+      const path = join(current, entry.name)
+      if (entry.isDirectory()) {
+        if (!skip.has(entry.name)) walk(path)
+        continue
+      }
+      // Les tests citent des noms d'icônes pour vérifier : rien à embarquer.
+      if (!TEXT_FILE_RE.test(entry.name) || entry.name.endsWith(".test.ts")) continue
+      found.push(path)
+    }
+  }
+
+  walk(dir)
+  return found
+}
+
+/** Noms d'icônes relevés dans un ensemble de dossiers (dédupliqués, triés). */
+export const scrapeIconNames = (dirs: string[], options: ScrapeOptions = {}): string[] => {
+  const names = new Set<string>()
+  for (const dir of dirs) {
+    for (const file of textFilesUnder(dir, options)) {
+      for (const name of iconNamesIn(readFileSync(file, "utf8"))) names.add(name)
+    }
+  }
+  return [...names].sort()
+}
+
+/** Construit une collection (alias résolus, parente incluse) à partir de noms nus. */
+export const buildIconSet = (
+  source: IconifySourceCollection,
+  names: Iterable<string>,
+): { set: IconSetJson; missing: string[] } => {
+  const icons: IconSetJson["icons"] = {}
+  const aliases: NonNullable<IconSetJson["aliases"]> = {}
+  const missing: string[] = []
+
+  const add = (name: string): void => {
+    if (name in icons || name in aliases) return
+    const icon = source.icons[name]
+    if (icon) {
+      icons[name] = { body: icon.body }
+      return
+    }
+    const alias = source.aliases?.[name]
+    if (alias) {
+      aliases[name] = { parent: alias.parent }
+      // Un alias ne rend rien sans sa parente : on l'embarque aussi.
+      add(alias.parent)
+      return
+    }
+    missing.push(name)
+  }
+
+  for (const name of [...names].sort()) add(name)
+
+  const set: IconSetJson = {
+    prefix: source.prefix,
+    width: source.width ?? 24,
+    height: source.height ?? 24,
+    icons,
+  }
+  if (Object.keys(aliases).length) set.aliases = aliases
+  return { set, missing }
+}
+
+/** Fusionne deux collections (les entrées de `extra` complètent `base`). */
+export const mergeIconSets = (base: IconSetJson, extra: IconSetJson): IconSetJson => {
+  const aliases = { ...base.aliases, ...extra.aliases }
+  const merged: IconSetJson = {
+    prefix: base.prefix,
+    width: base.width ?? extra.width,
+    height: base.height ?? extra.height,
+    icons: { ...base.icons, ...extra.icons },
+  }
+  if (Object.keys(aliases).length) merged.aliases = aliases
+  return merged
+}

package/lib/icons.ts

@@ -64,3 +64,19 @@ export const icons = {
   highlighter: "lucide:highlighter",
   tableCellsMerge: "lucide:table-cells-merge",
 } as const
+
+/**
+ * Collection Iconify minimale : le sous-ensemble d'une collection officielle
+ * (`lucide` ici) que l'on peut **embarquer dans le bundle** pour éviter l'appel
+ * réseau de `@iconify/vue`. Voir `lib/iconSet.ts` (généré) et `lib/registerIcons.ts`.
+ */
+export interface IconSetJson {
+  /** Préfixe de collection, sans `:` — ex. `"lucide"` */
+  prefix: string
+  width?: number
+  height?: number
+  /** Icônes : nom (sans préfixe) → corps SVG */
+  icons: Record<string, { body: string }>
+  /** Alias (lucide en a quelques-uns : `activity-square` → `square-activity`) */
+  aliases?: Record<string, { parent: string }>
+}

package/lib/pagination.test.ts

@@ -0,0 +1,77 @@
+// Pagination distante : bornes, nombre de pages, plage globale des lignes.
+// Les cas qui cassent en pratique : total qui rétrécit (page hors bornes), dernière page
+// partielle, `pageSize` désactivé, total nul.
+import { describe, expect, it } from "bun:test"
+import { pageInfo } from "./pagination"
+
+describe("pageInfo", () => {
+  it("calcule la première page", () => {
+    expect(pageInfo({ page: 1, pageSize: 400, total: 1200 })).toEqual({
+      page: 1,
+      pageCount: 3,
+      offset: 0,
+      from: 1,
+      to: 400,
+    })
+  })
+
+  it("décale la plage sur les pages suivantes", () => {
+    expect(pageInfo({ page: 3, pageSize: 400, total: 1200 })).toEqual({
+      page: 3,
+      pageCount: 3,
+      offset: 800,
+      from: 801,
+      to: 1200,
+    })
+  })
+
+  it("gère une dernière page partielle", () => {
+    expect(pageInfo({ page: 2, pageSize: 400, total: 500 })).toEqual({
+      page: 2,
+      pageCount: 2,
+      offset: 400,
+      from: 401,
+      to: 500,
+    })
+  })
+
+  it("tient compte des lignes réellement chargées", () => {
+    // La page 2 n'a reçu que 80 lignes (chargement partiel) : la plage le reflète
+    expect(pageInfo({ page: 2, pageSize: 400, total: 1200, loaded: 80 })).toMatchObject({
+      from: 401,
+      to: 480,
+    })
+  })
+
+  it("borne une page trop haute ou trop basse", () => {
+    expect(pageInfo({ page: 99, pageSize: 400, total: 1200 }).page).toBe(3)
+    expect(pageInfo({ page: 0, pageSize: 400, total: 1200 }).page).toBe(1)
+    expect(pageInfo({ page: -5, pageSize: 400, total: 1200 }).page).toBe(1)
+    expect(pageInfo({ page: Number.NaN, pageSize: 400, total: 1200 }).page).toBe(1)
+  })
+
+  it("sans pagination : une seule page, tout est affiché", () => {
+    expect(pageInfo({ page: 1, pageSize: 0, total: 250 })).toEqual({
+      page: 1,
+      pageCount: 1,
+      offset: 0,
+      from: 1,
+      to: 250,
+    })
+  })
+
+  it("total nul : from/to à 0", () => {
+    expect(pageInfo({ page: 1, pageSize: 400, total: 0 })).toEqual({
+      page: 1,
+      pageCount: 1,
+      offset: 0,
+      from: 0,
+      to: 0,
+    })
+  })
+
+  it("ne dépasse jamais le total", () => {
+    // `loaded` plus grand que le quota (données incohérentes) → plage bornée au total
+    expect(pageInfo({ page: 1, pageSize: 400, total: 10, loaded: 400 }).to).toBe(10)
+  })
+})

package/lib/pagination.ts

@@ -0,0 +1,50 @@
+// Pagination « distante » d'une grille — calculs **purs** (aucun DOM, aucun état).
+//
+// Le tableau ne découpe rien lui-même : `rows` contient **la page courante**, chargée par
+// l'app. Ce module borne la page, calcule le nombre de pages et la plage globale des lignes
+// affichées (numérotation des en-têtes de ligne, « lignes 401–800 sur 12 000 »).
+
+export interface PageInfo {
+  /** Page courante, bornée à `[1, pageCount]` */
+  page: number
+  /** Nombre de pages (toujours ≥ 1) */
+  pageCount: number
+  /** Décalage global de la première ligne affichée (0-based) */
+  offset: number
+  /** Numéro global (1-based) de la première ligne affichée — `0` si le total est nul */
+  from: number
+  /** Numéro global (1-based) de la dernière ligne affichée — `0` si le total est nul */
+  to: number
+}
+
+export interface PageInfoOptions {
+  /** Page demandée (1-based) — bornée au résultat */
+  page: number
+  /** Lignes par page (0 = pas de pagination) */
+  pageSize: number
+  /** Total de lignes, toutes pages confondues */
+  total: number
+  /** Lignes réellement fournies pour cette page (défaut : `pageSize`, ou `total` sans pagination) */
+  loaded?: number
+}
+
+/**
+ * Calcule l'état de pagination. Une page hors bornes est **ramenée** dans `[1, pageCount]`
+ * (un total qui rétrécit après un filtre ne laisse pas la vue sur une page vide), et une
+ * dernière page peut être partielle (`loaded` < `pageSize`).
+ */
+export const pageInfo = (options: PageInfoOptions): PageInfo => {
+  const size = Math.max(0, Math.trunc(options.pageSize || 0))
+  const total = Math.max(0, Math.trunc(options.total || 0))
+  const pageCount = size > 0 ? Math.max(1, Math.ceil(total / size)) : 1
+
+  const raw = Number.isFinite(options.page) ? Math.trunc(options.page) : 1
+  const page = Math.min(Math.max(1, raw), pageCount)
+  const offset = size > 0 ? (page - 1) * size : 0
+
+  const loaded = Math.max(0, Math.trunc(options.loaded ?? (size > 0 ? size : total)))
+  const from = total === 0 ? 0 : Math.min(offset + 1, total)
+  const to = total === 0 ? 0 : Math.min(offset + loaded, total)
+
+  return { page, pageCount, offset, from, to }
+}

package/lib/registerIcons.ts

@@ -0,0 +1,37 @@
+// registerIcons — embarque les icônes du design system dans le bundle.
+//
+// Par défaut, `@iconify/vue` va chercher chaque icône **à la demande** sur
+// `api.iconify.design`. En SSR cela ne rend que la coquille
+// `<svg class="iconify iconify--lucide">` (les `<path>` arrivent après le fetch
+// client) et, sans réseau, **aucune** icône n'apparaît. Enregistrer une collection
+// locale (`addCollection`) supprime la requête pour toutes les icônes de
+// `lib/iconSet.ts` (fichier généré par `scripts/gen-icon-set.ts`).
+//
+// - Appelé automatiquement par le module Nuxt `@dnax/ui` (option `icons`, défaut `true`).
+// - À appeler soi-même quand le module n'est pas utilisé (Vite/Nuxt manuel).
+// - Idempotent, et `addCollection` **fusionne** avec une collection déjà enregistrée
+//   sous le même préfixe : plusieurs appels (design system + extras d'une app) sont
+//   sans danger.
+import { addCollection } from "@iconify/vue"
+import { lucideIconSet } from "./iconSet"
+import type { IconSetJson } from "./icons"
+
+let registered = false
+
+/** Enregistre les icônes du design system auprès d'Iconify (idempotent). */
+export const registerIcons = (): void => {
+  if (registered) return
+  registered = true
+  addCollection(lucideIconSet)
+}
+
+/** `true` si `registerIcons()` a déjà été appelé. */
+export const iconsRegistered = (): boolean => registered
+
+/**
+ * Enregistre une collection Iconify **supplémentaire** (icônes propres à une app, à un
+ * site de docs…). Fusionne avec la collection déjà chargée — même préfixe compris.
+ */
+export const registerIconSet = (set: IconSetJson): void => {
+  addCollection(set)
+}

package/lib/useComponentProps.test.ts

@@ -1,6 +1,18 @@
 // Tests unitaires de la résolution du radius (échelle + style CSS).
+//
+// Ajout (2026-11-01) : `radius: true` était documenté « true = md » sur QCard / QDialog /
+// QSyntax / QTable sans poser le moindre style → surface carrée, silencieusement.
+// `radiusStyleNative` comble ce trou ; `radiusStyle` reste volontairement inchangé
+// (`true` → undefined) pour ne pas injecter un `--q-radius` global qui fuirait aux
+// enfants des champs/boutons (cf. `.memory/decisions.md`).
 import { describe, expect, it } from "bun:test"
-import { RADIUS_VALUES, radiusStyle, radiusValue } from "./useComponentProps"
+import {
+  RADIUS_VALUES,
+  isRadiusScale,
+  radiusStyle,
+  radiusStyleNative,
+  radiusValue,
+} from "./useComponentProps"
 
 describe("radiusValue", () => {
   it("traduit chaque barreau de l'échelle", () => {
@@ -33,4 +45,46 @@ describe("radiusStyle", () => {
     expect(radiusStyle(true)).toBeUndefined()
     expect(radiusStyle(undefined)).toBeUndefined()
   })
+
+  it("gère aussi none (carre) et l'échelle basse", () => {
+    expect(radiusStyle("none")).toEqual({ "--q-radius": "0px" })
+    expect(radiusStyle("sm")).toEqual({ "--q-radius": "4px" })
+  })
+})
+
+describe("isRadiusScale", () => {
+  it("reconnaît les échelles et rejette le reste", () => {
+    expect(isRadiusScale("md")).toBe(true)
+    expect(isRadiusScale("none")).toBe(true)
+    expect(isRadiusScale("12px")).toBe(false)
+    expect(isRadiusScale(true)).toBe(false)
+    expect(isRadiusScale(undefined)).toBe(false)
+  })
+})
+
+describe("RADIUS_VALUES", () => {
+  it("couvre toute l'échelle, croissante", () => {
+    expect(Object.keys(RADIUS_VALUES)).toEqual(["none", "xs", "sm", "md", "lg"])
+    expect(RADIUS_VALUES.none).toBe("0px")
+    expect(RADIUS_VALUES.lg).toBe("16px")
+  })
+})
+
+describe("radiusStyleNative (composants « true = échelle »)", () => {
+  it("convertit `true` en md par défaut", () => {
+    expect(radiusStyleNative(true)).toEqual({ "--q-radius": "8px" })
+  })
+
+  it("accepte une autre échelle par défaut", () => {
+    expect(radiusStyleNative(true, "lg")).toEqual({ "--q-radius": "16px" })
+  })
+
+  it("transmet une échelle telle quelle", () => {
+    expect(radiusStyleNative("sm")).toEqual({ "--q-radius": "4px" })
+    expect(radiusStyleNative("none")).toEqual({ "--q-radius": "0px" })
+  })
+
+  it("laisse undefined inchangé", () => {
+    expect(radiusStyleNative(undefined)).toBeUndefined()
+  })
 })

package/lib/useComponentProps.ts

@@ -65,3 +65,18 @@ export function radiusStyle(radius: RadiusProp | undefined): Record<string, stri
   const value = radiusValue(radius)
   return value ? { "--q-radius": value } : undefined
 }
+
+/**
+ * Style `--q-radius` des composants dont le booléen `radius` vaut une **échelle fixe**
+ * (documenté « true = md ») : `true` → `scale`.
+ *
+ * Les composants à forme native « pilule » (champs, boutons) ne passent **pas** par ici :
+ * ils posent leur propre classe (`.q-field--rounded`, `.q-btn--rounded`) — pour eux,
+ * `true` ne doit surtout pas devenir un `--q-radius` global qui fuirait aux enfants.
+ */
+export function radiusStyleNative(
+  radius: RadiusProp | undefined,
+  scale: RadiusScale = "md",
+): Record<string, string> | undefined {
+  return radiusStyle(radius === true ? scale : radius)
+}

package/module.ts

@@ -4,12 +4,39 @@
  *
  * - Auto-importe les composants Q* (balises kebab-case : <q-btn>, <q-header>…)
  * - Ajoute styles/main.css (safe-area, tokens, styles de tous les composants)
+ * - **Embarque les icônes** : enregistre un sous-ensemble `lucide` auprès d'Iconify
+ *   (`addCollection`) — design system + (par défaut) les icônes `lucide:…` trouvées
+ *   dans les sources de l'app. Aucune requête vers l'API Iconify pour ces noms, et les
+ *   `<path>` sont présents dès le SSR.
  *
  * Options (clé `dnaxUi`) :
- *   components: false  — désactive l'auto-import des composants
- *   css: false         — désactive l'ajout de styles/main.css
+ *   components: false            — désactive l'auto-import des composants
+ *   css: false                   — désactive l'ajout de styles/main.css
+ *   icons: false                 — n'embarque aucune icône (API Iconify à la demande)
+ *   icons: { scan: false }       — n'embarque que le design system
+ *   icons: { dirs: ["app"] }     — limite le scan (chemins relatifs à rootDir)
  */
-import { addComponentsDir, addPluginTemplate, createResolver, defineNuxtModule } from "@nuxt/kit"
+import { addComponentsDir, addPluginTemplate, createResolver, defineNuxtModule, updateTemplates } from "@nuxt/kit"
+import { readFileSync } from "node:fs"
+import { createRequire } from "node:module"
+import { join, resolve } from "node:path"
+import { lucideIconSet } from "./lib/iconSet"
+import {
+  buildIconSet,
+  mergeIconSets,
+  scrapeIconNames,
+  type IconifySourceCollection,
+} from "./lib/iconSetScrape"
+
+export interface DnaxUiIconsOptions {
+  /**
+   * Scanne les sources de l'app au build pour embarquer aussi **ses** icônes
+   * `lucide:` (défaut : true)
+   */
+  scan?: boolean
+  /** Dossiers à scanner, résolus depuis `rootDir` (défaut : tout `rootDir`) */
+  dirs?: string[]
+}
 
 export interface DnaxUiModuleOptions {
   /** Auto-importe les composants Q* (défaut : true) */
@@ -18,6 +45,33 @@ export interface DnaxUiModuleOptions {
   css?: boolean
   /** Installe le handler « retour » : ferme l'overlay ouvert au lieu de naviguer (défaut : true) */
   overlayBack?: boolean
+  /**
+   * Icônes : `false` = rien d'embarqué (API Iconify à la demande) ; objet = réglages
+   * du scan. Par défaut : sous-ensemble du design system **+** scan des sources.
+   */
+  icons?: boolean | DnaxUiIconsOptions
+}
+
+/** Collection Iconify lue pour résoudre les noms (`@iconify-json/lucide`). */
+const LUCIDE_COLLECTION = "@iconify-json/lucide/icons.json"
+
+/**
+ * Charge la collection `lucide`. Elle vit dans les dépendances de `@dnax/ui` ; on tente
+ * la résolution depuis ce module, puis depuis l'app hôte (hoisting).
+ */
+const loadLucideCollection = (rootDir: string): IconifySourceCollection | null => {
+  const resolvers = [
+    () => createRequire(import.meta.url).resolve(LUCIDE_COLLECTION),
+    () => createRequire(join(rootDir, "package.json")).resolve(LUCIDE_COLLECTION),
+  ]
+  for (const resolveSpec of resolvers) {
+    try {
+      return JSON.parse(readFileSync(resolveSpec(), "utf8")) as IconifySourceCollection
+    } catch {
+      // on passe au résolveur suivant
+    }
+  }
+  return null
 }
 
 export default defineNuxtModule<DnaxUiModuleOptions>({
@@ -30,12 +84,13 @@ export default defineNuxtModule<DnaxUiModuleOptions>({
     components: true,
     css: true,
     overlayBack: true,
+    icons: { scan: true },
   },
   setup(options, nuxt) {
-    const { resolve } = createResolver(import.meta.url)
+    const { resolve: resolvePath } = createResolver(import.meta.url)
 
     if (options.css) {
-      const cssPath = resolve("./styles/main.css")
+      const cssPath = resolvePath("./styles/main.css")
       if (!nuxt.options.css.includes(cssPath)) {
         nuxt.options.css.push(cssPath)
       }
@@ -43,13 +98,76 @@ export default defineNuxtModule<DnaxUiModuleOptions>({
 
     if (options.components) {
       addComponentsDir({
-        path: resolve("./components"),
+        path: resolvePath("./components"),
         prefix: "", // pas de préfixe : QBtn.vue → <q-btn>
         pathPrefix: false, // pas de préfixe par sous-dossier
         ignore: ["**/internal/**"], // composants internes : non auto-importés
       })
     }
 
+    // — Icônes embarquées ---------------------------------------------------------
+    // Plugin **universel** : côté serveur aussi, sinon le SSR ne rend que des coquilles
+    // `<svg class="iconify">`, les `<path>` n'arrivant qu'après le fetch client (et
+    // jamais sans réseau). `addCollection` est purement local et **fusionne**.
+    if (options.icons !== false) {
+      const iconsOptions: DnaxUiIconsOptions =
+        typeof options.icons === "object" ? options.icons : {}
+      const scan = iconsOptions.scan !== false
+
+      const dirs = iconsOptions.dirs?.length
+        ? iconsOptions.dirs.map((dir) => resolve(nuxt.options.rootDir, dir))
+        : [nuxt.options.rootDir]
+
+      const collection = scan ? loadLucideCollection(nuxt.options.rootDir) : null
+      if (scan && !collection) {
+        console.warn(
+          "[@dnax/ui] `@iconify-json/lucide` introuvable : seules les icônes du design system sont embarquées. " +
+            "Installez-le (`bun add -D @iconify-json/lucide`) pour scanner votre app.",
+        )
+      }
+
+      addPluginTemplate({
+        filename: "dnax-ui-icons.mjs",
+        getContents: () => {
+          let set = lucideIconSet
+          let scanned = false
+          if (collection) {
+            const { set: appSet, missing } = buildIconSet(collection, scrapeIconNames(dirs))
+            set = mergeIconSets(lucideIconSet, appSet)
+            scanned = true
+            if (nuxt.options.dev && missing.length) {
+              console.warn(
+                `[@dnax/ui] icône(s) \`lucide:\` absente(s) de la collection (faute de frappe ?) : ${missing.join(", ")}`,
+              )
+            }
+          }
+          return `
+import { defineNuxtPlugin } from "#imports"
+import { registerIconSet } from "@dnax/ui/runtime"
+
+// Sous-ensemble \`lucide\` embarqué (${Object.keys(set.icons).length} icônes) :
+// design system${scanned ? " + sources de l'app" : ""}. Aucune requête vers l'API Iconify
+// pour ces noms ; les autres retombent dessus (progressive enhancement).
+const ICON_SET = ${JSON.stringify(set)}
+
+export default defineNuxtPlugin(() => {
+  registerIconSet(ICON_SET)
+})
+`
+        },
+      })
+
+      // Dev : une icône ajoutée dans les sources régénère le module virtuel — sans ça
+      // il faudrait redémarrer le serveur pour l'embarquer (en attendant, l'icône
+      // s'affiche via l'API : dégradation, pas rupture).
+      if (scan) {
+        nuxt.hook("builder:watch", async (_event, watchedPath) => {
+          if (!/\.(vue|ts|js|mjs|md|mdx)$/.test(String(watchedPath).replace(/\\/g, "/"))) return
+          await updateTemplates({ filter: (template) => template.filename === "dnax-ui-icons.mjs" })
+        })
+      }
+    }
+
     // Dépendances CJS sans export ESM `default` explicite : esbuild doit les pré-bundler
     // (interop) sinon, servies brutes, le navigateur échoue sur « does not provide an
     // export named 'default' ». `leaflet` (lib/mapLeaflet.ts) est dans ce cas ; le code

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dnax/ui",
-  "version": "0.0.73",
+  "version": "0.0.76",
   "module": "index.ts",
   "description": "UI design System",
   "type": "module",
@@ -12,7 +12,8 @@
     "./styles/main.css": "./styles/main.css"
   },
   "scripts": {
-    "generate": "bun scripts/generate-exports.ts"
+    "generate": "bun scripts/generate-exports.ts",
+    "gen:icons": "bun scripts/gen-icon-set.ts --out ./lib/iconSet.ts --src ./components --src ./lib"
   },
   "private": false,
   "devDependencies": {
@@ -23,6 +24,7 @@
     "vue": "^3.5.41"
   },
   "dependencies": {
+    "@iconify-json/lucide": "^1.2.150",
     "@iconify/vue": "^5.0.1",
     "@maptiler/sdk": "^4.1.0",
     "@nuxt/kit": "4.5.2",

package/runtime.ts

@@ -46,6 +46,11 @@ export type { QNetwork, NetworkOptions } from "./lib/network"
 // `$q.wakeLock` (écran allumé) — Screen Wake Lock API.
 export { wakeLock, createWakeLock } from "./lib/wakeLock"
 export type { QWakeLock, WakeLockOptions } from "./lib/wakeLock"
+// Icônes du design system embarquées dans le bundle (`lib/iconSet.ts`, généré) :
+// appelé par le module Nuxt, à appeler soi-même sans module. Évite l'appel runtime
+// à l'API Iconify et rend les icônes dès le SSR.
+export { registerIcons, iconsRegistered } from "./lib/registerIcons"
+export { registerIconSet } from "./lib/registerIcons"
 
 // — Providers de `$q` (montés au boot par l'app hôte) —
 export { default as QDialogProvider } from "./components/QDialogProvider.vue"