@dnax/ui 0.0.64 → 0.0.65

package/lib/network.ts

@@ -0,0 +1,147 @@
+// $q.network — état de la connexion réseau (API Quasar-style, SSR-safe).
+//
+// Source unique : `navigator.onLine` + événements `online` / `offline` de `window`.
+// L'objet exposé se lit **sans `.value`** (`$q.network.online`), donc directement dans
+// un template, et reste **réactif** (ses getters lisent une ref interne).
+//
+// Le serveur n'a pas d'état réseau : au SSR `online` vaut `true` (pas de bannière
+// « hors ligne » fantôme). Côté client, l'état réel de `navigator.onLine` est lu au
+// chargement du module, avant hydratation — deux rendus ne diffèrent que si l'appareil
+// est réellement hors ligne (comportement de `useOnline` de VueUse).
+//
+// La logique pure (`resolveOnline`, `onlineAfterEvent`) et la fabrique `createNetwork`
+// (cible d'événements injectable) sont testables sans DOM.
+import { reactive, ref } from "vue"
+
+/** Sous-ensemble de `navigator` utilisé (injectable pour les tests). */
+export interface NetworkNavigator {
+  onLine?: boolean
+}
+
+/** Cible des événements `online` / `offline` (`window` en production, objet factice en test). */
+export interface NetworkEventTarget {
+  addEventListener: (type: string, listener: (event: { type: string }) => void) => void
+  removeEventListener?: (type: string, listener: (event: { type: string }) => void) => void
+}
+
+export interface QNetwork {
+  /** Connecté au réseau — booléen réactif, se lit **sans `.value`** */
+  readonly online: boolean
+  /** Inversé de `online` (`v-if="$q.network.offline"`) */
+  readonly offline: boolean
+  /** Re-lit `navigator.onLine` (retour au premier plan…) et met à jour l'état */
+  refresh: () => boolean
+  /**
+   * Abonnement aux passages `"online"` / `"offline"` (transitions réelles seulement).
+   * Renvoie la fonction de désabonnement.
+   */
+  on: (type: NetworkEvent, cb: () => void) => () => void
+  /** Détache les écouteurs (instance de test / usage hors singleton) */
+  destroy: () => void
+}
+
+/** Événements réseau exposés par `$q.network.on()`. */
+export type NetworkEvent = "online" | "offline"
+
+export interface NetworkOptions {
+  /** Source de `navigator.onLine` (défaut : `navigator` global ; `null` au serveur) */
+  navigator?: NetworkNavigator | null
+  /** Cible des événements (défaut : `window` ; `null` au serveur) */
+  target?: NetworkEventTarget | null
+  /** Force la valeur initiale (sinon `resolveOnline(navigator)`) */
+  initial?: boolean
+}
+
+/**
+ * `true` par défaut : le serveur et les navigateurs sans `navigator.onLine` sont
+ * considérés **en ligne** (évite une bannière « hors ligne » au chargement SSR).
+ */
+export function resolveOnline(nav?: NetworkNavigator | null): boolean {
+  return typeof nav?.onLine === "boolean" ? nav.onLine : true
+}
+
+/** État après un événement : `online` → true, `offline` → false, autre → inchangé. */
+export function onlineAfterEvent(type: string, current: boolean): boolean {
+  if (type === "online") return true
+  if (type === "offline") return false
+  return current
+}
+
+/**
+ * Crée un objet réseau réactif. Sans `target`, aucun écouteur n'est posé (SSR) ;
+ * sans `navigator`, l'état initial vaut `true`.
+ */
+export function createNetwork(options: NetworkOptions = {}): QNetwork {
+  const nav = "navigator" in options
+    ? (options.navigator ?? null)
+    : typeof navigator !== "undefined"
+      ? navigator
+      : null
+  const target = "target" in options
+    ? (options.target ?? null)
+    : typeof window !== "undefined"
+      ? window
+      : null
+
+  const online = ref(options.initial ?? resolveOnline(nav))
+  const listeners: Record<"online" | "offline", Set<() => void>> = {
+    online: new Set(),
+    offline: new Set(),
+  }
+
+  const setOnline = (next: boolean) => {
+    if (online.value === next) return
+    online.value = next
+    for (const cb of [...listeners[next ? "online" : "offline"]]) {
+      try {
+        cb()
+      }
+      catch {
+        // Un abonné fautif ne doit pas empêcher les autres d'être notifiés.
+      }
+    }
+  }
+
+  const handleEvent = (event: { type: string }) => {
+    setOnline(onlineAfterEvent(event.type, online.value))
+  }
+
+  const refresh = () => {
+    const next = resolveOnline(nav)
+    setOnline(next)
+    return next
+  }
+
+  const on = (type: NetworkEvent, cb: () => void) => {
+    // Garde runtime : un type inconnu (JS non typé) renvoie un désabonnement inerte.
+    if (type !== "online" && type !== "offline") return () => {}
+    listeners[type].add(cb)
+    return () => {
+      listeners[type].delete(cb)
+    }
+  }
+
+  target?.addEventListener("online", handleEvent)
+  target?.addEventListener("offline", handleEvent)
+
+  return reactive({
+    /** @see QNetwork.online */
+    get online() {
+      return online.value
+    },
+    get offline() {
+      return !online.value
+    },
+    refresh,
+    on,
+    destroy: () => {
+      target?.removeEventListener?.("online", handleEvent)
+      target?.removeEventListener?.("offline", handleEvent)
+      listeners.online.clear()
+      listeners.offline.clear()
+    },
+  })
+}
+
+/** Singleton exposé sous `$q.network` (et importable directement depuis `@dnax/ui`). */
+export const network: QNetwork = createNetwork()

package/lib/q.ts

@@ -15,6 +15,8 @@ import { platform, qBreakpoints } from "./platform"
 import { screen } from "./screen"
 import { loading } from "./loading"
 import { localStorage, sessionStorage } from "./storage"
+import { network } from "./network"
+import { wakeLock } from "./wakeLock"
 
 export interface DialogOptions {
   /** Composant de dialogue (SFC importé) ou nom de composant global */
@@ -324,7 +326,8 @@ 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é)
+// / $q.localStorage / $q.sessionStorage (stockage web typé) / $q.network (connexion en ligne)
+// / $q.wakeLock (écran allumé, Screen Wake Lock API)
 // Conventions Quasar : .open() pour les piles (dialog, bottomSheet, imagePreview),
 // .show() pour notify et loading ; méthodes directes pour le stockage.
 const notifyPlugin = notify as typeof notify & { show: typeof notify }
@@ -347,6 +350,8 @@ export const $q = {
   loading,
   localStorage,
   sessionStorage,
+  network,
+  wakeLock,
 }
 
 /** Accès programmatique aux plugins ($q.dialog, $q.notify, $q.loading…) */

package/lib/styleTokens.test.ts

@@ -102,6 +102,16 @@ describe("classes de style (composant ↔ CSS)", () => {
     ],
     ["components/QCollapse.vue", "q-collapse--guide", ".q-collapse--guide .q-collapse__inner"],
     ["components/QTabs.vue", "q-tabs--arrows", ".q-tabs--arrows .q-tabs__content"],
+    [
+      "components/QTabs.vue",
+      "q-tabs--scroll-start",
+      ".q-tabs--arrows.q-tabs--scroll-start .q-tabs__content",
+    ],
+    [
+      "components/QTabs.vue",
+      "q-tabs--scroll-end",
+      ".q-tabs--arrows.q-tabs--scroll-end .q-tabs__content",
+    ],
   ]
 
   for (const [file, className, selector] of CONTRACTS) {
@@ -129,6 +139,27 @@ describe("classes de style (composant ↔ CSS)", () => {
   })
 })
 
+describe("fondu de défilement des tabs (thème-agnostique)", () => {
+  const block = blockAfter(css, ".q-tabs--arrows .q-tabs__content")
+
+  it("le fondu est un masque alpha (`#fff`), sans couleur de thème", () => {
+    // `#fff` est opaque en mode `alpha` ET `luminance` (ancien WebKit).
+    expect({ defined: block !== undefined }).toEqual({ defined: true })
+    expect({ hasMask: block!.includes("mask-image") }).toEqual({ hasMask: true })
+    expect({ opaque: block!.includes("#fff") }).toEqual({ opaque: true })
+    // Aucune couleur de surface : le fondu ne peut pas se désaligner d'un thème à l'autre.
+    expect({ themeColor: block!.includes("var(--card") }).toEqual({ themeColor: false })
+    expect({ hardcodedBlack: block!.includes("rgb(0 0 0") }).toEqual({ hardcodedBlack: false })
+  })
+
+  it("le fondu suit l'axe des tabs (horizontal → to right, vertical → to bottom)", () => {
+    const vertical = blockAfter(css, ".q-tabs--vertical.q-tabs--arrows .q-tabs__content")
+    expect({ defined: vertical !== undefined }).toEqual({ defined: true })
+    expect({ right: block!.includes("to right") }).toEqual({ right: true })
+    expect({ bottom: vertical!.includes("to bottom") }).toEqual({ bottom: true })
+  })
+})
+
 describe("mode sombre des contrôles", () => {
   it("la bordure noire du checkbox / radio décoché est corrigée en sombre", () => {
     // Base claire : bordure codée en dur (le variant `--dark` du composant la corrige, mais

package/lib/wakeLock.test.ts

@@ -0,0 +1,219 @@
+// $q.wakeLock — Screen Wake Lock : logique pure + fabrique testable hors navigateur.
+import { describe, expect, it } from "bun:test"
+import {
+  createWakeLock,
+  isDocumentVisible,
+  isWakeLockCapable,
+  shouldReacquire,
+} from "./wakeLock"
+
+class FakeSentinel {
+  released = false
+  releaseCalls = 0
+  private listeners = new Set<() => void>()
+
+  async release() {
+    this.releaseCalls++
+    this.released = true
+    for (const cb of [...this.listeners]) cb()
+  }
+
+  addEventListener(_type: "release", cb: () => void) {
+    this.listeners.add(cb)
+  }
+
+  removeEventListener(_type: "release", cb: () => void) {
+    this.listeners.delete(cb)
+  }
+
+  /** Simule le relâchement décidé par le navigateur (page masquée, veille…). */
+  autoRelease() {
+    this.released = true
+    for (const cb of [...this.listeners]) cb()
+  }
+}
+
+function fakeApi(options: { fail?: Error } = {}) {
+  const sentinels: FakeSentinel[] = []
+  return {
+    calls: 0,
+    sentinels,
+    async request(_type: "screen") {
+      this.calls++
+      if (options.fail) throw options.fail
+      const s = new FakeSentinel()
+      sentinels.push(s)
+      return s
+    },
+  }
+}
+
+function fakeVisibility(state = "visible") {
+  const listeners = new Set<() => void>()
+  return {
+    visibilityState: state as string,
+    addEventListener(_type: "visibilitychange", cb: () => void) {
+      listeners.add(cb)
+    },
+    removeEventListener(_type: "visibilitychange", cb: () => void) {
+      listeners.delete(cb)
+    },
+    set(next: string) {
+      this.visibilityState = next
+      for (const cb of [...listeners]) cb()
+    },
+    count() {
+      return listeners.size
+    },
+  }
+}
+
+function client(options: Partial<Parameters<typeof createWakeLock>[0]> = {}) {
+  return createWakeLock({
+    server: false,
+    deferCapability: false,
+    api: fakeApi(),
+    visibility: fakeVisibility(),
+    ...options,
+  })
+}
+
+describe("isWakeLockCapable", () => {
+  it("exige une API avec request()", () => {
+    expect(isWakeLockCapable(null)).toBe(false)
+    expect(isWakeLockCapable(undefined)).toBe(false)
+    expect(isWakeLockCapable({} as never)).toBe(false)
+    expect(isWakeLockCapable({ request: async () => new FakeSentinel() })).toBe(true)
+  })
+})
+
+describe("isDocumentVisible", () => {
+  it("visible sauf `visibilityState: 'hidden'` (et sans document injecté)", () => {
+    expect(isDocumentVisible(null)).toBe(true)
+    expect(isDocumentVisible({ addEventListener() {} })).toBe(true)
+    expect(
+      isDocumentVisible({ visibilityState: "visible", addEventListener() {} }),
+    ).toBe(true)
+    expect(
+      isDocumentVisible({ visibilityState: "hidden", addEventListener() {} }),
+    ).toBe(false)
+  })
+})
+
+describe("shouldReacquire", () => {
+  it("uniquement si demandé, visible et rien de tenu", () => {
+    expect(shouldReacquire(true, true, false)).toBe(true)
+    expect(shouldReacquire(false, true, false)).toBe(false)
+    expect(shouldReacquire(true, false, false)).toBe(false)
+    expect(shouldReacquire(true, true, true)).toBe(false)
+  })
+})
+
+describe("createWakeLock", () => {
+  it("au serveur : méthodes sans effet, rien de capable ni d'actif", async () => {
+    const lock = createWakeLock({ server: true })
+    expect(lock.isCapable).toBe(false)
+    expect(lock.isActive).toBe(false)
+    await expect(lock.request()).resolves.toBeUndefined()
+    await expect(lock.release()).resolves.toBeUndefined()
+  })
+
+  it("sans API : `Not capable`", async () => {
+    const lock = client({ api: null })
+    expect(lock.isCapable).toBe(false)
+    await expect(lock.request()).rejects.toThrow("Not capable")
+    expect(lock.isActive).toBe(false)
+  })
+
+  it("request() acquiert le verrou, une seule fois (idempotent)", async () => {
+    const api = fakeApi()
+    const lock = client({ api })
+
+    await lock.request()
+    expect(lock.isActive).toBe(true)
+    expect(api.calls).toBe(1)
+
+    await lock.request()
+    expect(api.calls).toBe(1)
+    expect(lock.isActive).toBe(true)
+  })
+
+  it("release() rend la main au système", async () => {
+    const api = fakeApi()
+    const lock = client({ api })
+
+    await lock.request()
+    await lock.release()
+
+    expect(lock.isActive).toBe(false)
+    expect(api.sentinels[0]!.releaseCalls).toBe(1)
+
+    // Une nouvelle demande fonctionne.
+    await lock.request()
+    expect(api.calls).toBe(2)
+    expect(lock.isActive).toBe(true)
+  })
+
+  it("le navigateur relâche → isActive retombe, et le verrou est redemandé au retour", async () => {
+    const api = fakeApi()
+    const visibility = fakeVisibility("visible")
+    const lock = client({ api, visibility })
+
+    await lock.request()
+    expect(lock.isActive).toBe(true)
+
+    // Onglet masqué : le navigateur relâche de lui-même.
+    visibility.set("hidden")
+    api.sentinels[0]!.autoRelease()
+    expect(lock.isActive).toBe(false)
+    expect(api.calls).toBe(1)
+
+    // Retour de visibilité : la demande mémorisée est rejouée.
+    visibility.set("visible")
+    await Promise.resolve()
+    expect(api.calls).toBe(2)
+    expect(lock.isActive).toBe(true)
+  })
+
+  it("après release(), plus aucune redemande au changement de visibilité", async () => {
+    const api = fakeApi()
+    const visibility = fakeVisibility("visible")
+    const lock = client({ api, visibility })
+
+    await lock.request()
+    await lock.release()
+
+    visibility.set("hidden")
+    visibility.set("visible")
+    await Promise.resolve()
+
+    expect(api.calls).toBe(1)
+    expect(lock.isActive).toBe(false)
+  })
+
+  it("le refus du navigateur est propagé (échec doux côté appelant)", async () => {
+    const api = fakeApi({ fail: new Error("denied") })
+    const lock = client({ api })
+
+    await expect(lock.request()).rejects.toThrow("denied")
+    expect(lock.isActive).toBe(false)
+  })
+
+  it("destroy() détache l'écouteur de visibilité", async () => {
+    const visibility = fakeVisibility()
+    const lock = client({ visibility })
+
+    expect(visibility.count()).toBe(1)
+    lock.destroy()
+    expect(visibility.count()).toBe(0)
+  })
+
+  it("isCapable n'est révélé qu'après hydratation (report d'un tick)", async () => {
+    const api = fakeApi()
+    const lock = createWakeLock({ server: false, api, visibility: null })
+
+    expect(lock.isCapable).toBe(false)
+    await new Promise((resolve) => setTimeout(resolve, 1))
+    expect(lock.isCapable).toBe(true)
+  })
+})

package/lib/wakeLock.ts

@@ -0,0 +1,202 @@
+// $q.wakeLock — Screen Wake Lock façon Quasar (`AppWakeLockPlugin`).
+// https://quasar.dev/quasar-plugins/app-wake-lock
+//
+// - `request()` garde l'écran allumé ; `release()` rend la main au délai système.
+// - `isActive` ne vaut `true` que **tant que le verrou est réellement tenu** : le
+//   navigateur le relâche de lui-même quand la page est masquée (onglet, veille…).
+//   La demande est alors **mémorisée** et rejouée au retour de visibilité, jusqu'à
+//   `release()`.
+// - `isCapable` vaut `false` au serveur **et au premier rendu client**, puis prend sa
+//   valeur réelle après hydratation (sinon le `v-if` d'un bouton « garder l'écran
+//   allumé » divergerait du HTML SSR).
+// - Sans API (navigateur non supporté), les méthodes rejettent `Not capable` ; au
+//   serveur elles se résolvent sans effet.
+//
+// Logique pure (`isWakeLockCapable`, `isDocumentVisible`, `shouldReacquire`) et fabrique
+// `createWakeLock` à dépendances injectables : testable sans DOM.
+import { reactive, ref } from "vue"
+
+/** Sentinel minimal du Screen Wake Lock API (injectable pour les tests). */
+export interface WakeLockSentinelLike {
+  /** Passe à `true` quand le navigateur relâche le verrou de lui-même */
+  released?: boolean
+  release: () => Promise<void>
+  addEventListener?: (type: "release", listener: () => void) => void
+  removeEventListener?: (type: "release", listener: () => void) => void
+}
+
+/** Sous-ensemble de `navigator.wakeLock`. */
+export interface WakeLockApiLike {
+  request: (type: "screen") => Promise<WakeLockSentinelLike>
+}
+
+/** Sous-ensemble de `document` utilisé pour suivre la visibilité. */
+export interface WakeLockVisibilityLike {
+  visibilityState?: string
+  addEventListener: (type: "visibilitychange", listener: () => void) => void
+  removeEventListener?: (type: "visibilitychange", listener: () => void) => void
+}
+
+export interface QWakeLock {
+  /** Un verrou est réellement tenu (réactif, lecture sans `.value`) */
+  readonly isActive: boolean
+  /** Screen Wake Lock disponible — `false` au serveur et avant hydratation */
+  readonly isCapable: boolean
+  /** Demande le verrou (idempotent). Rejette si non supporté (`Not capable`). */
+  request: () => Promise<void>
+  /** Relâche le verrou et cesse les redemandes automatiques */
+  release: () => Promise<void>
+  /** Détache l'écouteur de visibilité (instance de test / usage hors singleton) */
+  destroy: () => void
+}
+
+export interface WakeLockOptions {
+  /** API Screen Wake Lock (défaut : `navigator.wakeLock` ; `null` si absente) */
+  api?: WakeLockApiLike | null
+  /** Document pour la visibilité (défaut : `document` ; `null` au serveur) */
+  visibility?: WakeLockVisibilityLike | null
+  /** Force le mode serveur : aucune API lue, méthodes sans effet */
+  server?: boolean
+  /**
+   * Diffère `isCapable` après l'hydratation (défaut : `true` côté client) — évite un
+   * décalage entre le HTML SSR (`isCapable = false`) et le premier rendu client.
+   */
+  deferCapability?: boolean
+}
+
+/** `true` seulement si l'API Screen Wake Lock est exposée par le navigateur. */
+export function isWakeLockCapable(api?: WakeLockApiLike | null): boolean {
+  return !!api && typeof api.request === "function"
+}
+
+/** Une page est considérée visible sauf si le document dit explicitement `hidden`. */
+export function isDocumentVisible(visibility?: WakeLockVisibilityLike | null): boolean {
+  return visibility?.visibilityState !== "hidden"
+}
+
+/** Faut-il redemander le verrou ? (demandé, page visible, et rien de tenu) */
+export function shouldReacquire(wanted: boolean, visible: boolean, held: boolean): boolean {
+  return wanted && visible && !held
+}
+
+function notCapableError(): Error {
+  const message = "Not capable"
+  return typeof DOMException === "function"
+    ? new DOMException(message, "NotSupportedError")
+    : new Error(message)
+}
+
+/**
+ * Crée le gestionnaire de verrou. Sans `visibility`, aucune écoute n'est posée ;
+ * en mode serveur, `request()` / `release()` se résolvent sans effet.
+ */
+export function createWakeLock(options: WakeLockOptions = {}): QWakeLock {
+  const server = options.server ?? typeof window === "undefined"
+  const api = "api" in options
+    ? (options.api ?? null)
+    : typeof navigator !== "undefined"
+      ? ((navigator as Navigator & { wakeLock?: WakeLockApiLike }).wakeLock ?? null)
+      : null
+  const visibility = "visibility" in options
+    ? (options.visibility ?? null)
+    : typeof document !== "undefined"
+      ? document
+      : null
+
+  const active = ref(false)
+  const capable = ref(false)
+
+  // `isCapable` n'est révélé qu'après le rendu SSR/hydratation (cf. en-tête).
+  if (!server) {
+    if (options.deferCapability === false) {
+      capable.value = isWakeLockCapable(api)
+    }
+    else {
+      setTimeout(() => {
+        capable.value = isWakeLockCapable(api)
+      }, 0)
+    }
+  }
+
+  /** L'utilisateur veut garder l'écran allumé (survit aux relâchements du navigateur). */
+  let wanted = false
+  let sentinel: WakeLockSentinelLike | null = null
+  let pending: Promise<void> | null = null
+
+  const bindRelease = (s: WakeLockSentinelLike) => {
+    s.addEventListener?.("release", () => {
+      if (sentinel !== s) return
+      sentinel = null
+      active.value = false
+    })
+  }
+
+  const request = async (): Promise<void> => {
+    if (server) return
+    if (!isWakeLockCapable(api)) throw notCapableError()
+
+    wanted = true
+    if (sentinel && sentinel.released !== true) {
+      active.value = true
+      return
+    }
+    if (pending) return pending
+
+    pending = (async () => {
+      const s = await api!.request("screen")
+      if (!wanted) {
+        // `release()` a été appelé pendant la demande : ne pas reprendre le verrou.
+        await s.release().catch(() => {})
+        return
+      }
+      sentinel = s
+      active.value = true
+      bindRelease(s)
+    })()
+
+    try {
+      await pending
+    }
+    finally {
+      pending = null
+    }
+  }
+
+  const release = async (): Promise<void> => {
+    wanted = false
+    const s = sentinel
+    sentinel = null
+    active.value = false
+    if (s) await s.release().catch(() => {})
+  }
+
+  const onVisibilityChange = () => {
+    if (sentinel?.released === true) {
+      sentinel = null
+      active.value = false
+    }
+    const held = sentinel !== null && sentinel.released !== true
+    if (!shouldReacquire(wanted, isDocumentVisible(visibility), held)) return
+    // Refus possible (batterie faible, iframe…) : la prochaine visibilité réessaiera.
+    void request().catch(() => {})
+  }
+
+  visibility?.addEventListener("visibilitychange", onVisibilityChange)
+
+  return reactive({
+    get isActive() {
+      return active.value
+    },
+    get isCapable() {
+      return capable.value
+    },
+    request,
+    release,
+    destroy: () => {
+      visibility?.removeEventListener?.("visibilitychange", onVisibilityChange)
+    },
+  })
+}
+
+/** Singleton exposé sous `$q.wakeLock` (et importable directement depuis `@dnax/ui`). */
+export const wakeLock: QWakeLock = createWakeLock()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dnax/ui",
-  "version": "0.0.64",
+  "version": "0.0.65",
   "module": "index.ts",
   "description": "UI design System",
   "type": "module",

package/runtime.ts

@@ -39,6 +39,13 @@ export {
   useDialogPluginComponent,
   useBottomSheetPluginComponent,
 } from "./lib/q"
+// `$q.network` (état de connexion réactif) — accessible aussi par import direct,
+// sans évaluer le barrel ni les composants.
+export { network, createNetwork } from "./lib/network"
+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"
 
 // — Providers de `$q` (montés au boot par l'app hôte) —
 export { default as QDialogProvider } from "./components/QDialogProvider.vue"