@dnax/ui 0.0.27 → 0.0.29

package/lib/touchPan.ts

@@ -0,0 +1,237 @@
+// v-touch-pan — directive : détecte les gestes « pan » (glisser) sur un
+// élément, tactile ET souris (modifier .mouse), équivalent Quasar
+// https://quasar.dev/vue-directives/touch-pan
+//
+// Usage : <div v-touch-pan.horizontal.mouse.prevent="onPan" />
+//   modifiers : horizontal | vertical | up | down | left | right (filtres de
+//   direction), mouse (inclut la souris), prevent (bloque le scroll natif),
+//   stop, capture, passive, mouseCapture
+//
+// Détails passés au handler (compatible Quasar) :
+//   { evt, position: { top, left }, direction, delta: { x, y },
+//     distance: { x, y }, duration, speed: { x, y },
+//     isFirst, isFinal, isVertical, isHorizontal }
+
+export interface PanPosition {
+  top: number
+  left: number
+}
+
+export interface PanDelta {
+  x: number
+  y: number
+}
+
+export type PanDirection = "up" | "down" | "left" | "right"
+
+export interface PanDetails {
+  evt: PointerEvent
+  position: PanPosition
+  direction: PanDirection
+  delta: PanDelta
+  distance: PanDelta
+  duration: number
+  speed: PanDelta
+  isFirst: boolean
+  isFinal: boolean
+  isVertical: boolean
+  isHorizontal: boolean
+}
+
+export type TouchPanHandler = (details: PanDetails) => void
+
+interface PanState {
+  pointerId: number
+  startX: number
+  startY: number
+  lastX: number
+  lastY: number
+  startTime: number
+  lastTime: number
+  axis: "horizontal" | "vertical" | null
+  panning: boolean
+}
+
+const PAN_MIN = 4 // seuil avant de déclarer le pan (px)
+
+interface TouchPanOptions {
+  handler: TouchPanHandler
+  allowHorizontal: boolean
+  allowVertical: boolean
+  allowUp: boolean
+  allowDown: boolean
+  allowLeft: boolean
+  allowRight: boolean
+  mouse: boolean
+  prevent: boolean
+  stop: boolean
+  capture: boolean
+  passive: boolean
+  mouseCapture: boolean
+}
+
+type QElement = HTMLElement & { __qTouchPanCleanup?: () => void }
+
+function axisAllowed(options: TouchPanOptions, direction: PanDirection) {
+  if (options.allowHorizontal) return direction === "left" || direction === "right"
+  if (options.allowVertical) return direction === "up" || direction === "down"
+  switch (direction) {
+    case "up": return options.allowUp
+    case "down": return options.allowDown
+    case "left": return options.allowLeft
+    case "right": return options.allowRight
+  }
+}
+
+function parseDirection(dx: number, dy: number): PanDirection {
+  return Math.abs(dx) >= Math.abs(dy) ? (dx > 0 ? "right" : "left") : (dy > 0 ? "down" : "up")
+}
+
+function applyPrevent(e: Event, options: TouchPanOptions, active: boolean) {
+  if (options.stop) e.stopPropagation()
+  if (options.prevent && active) e.preventDefault()
+}
+
+export const vTouchPan = {
+  mounted(el: HTMLElement, binding: { value?: unknown; modifiers?: Record<string, boolean> }) {
+    const handler = binding.value
+    if (typeof handler !== "function") {
+      console.warn("[v-touch-pan] value doit être une fonction (handler)")
+      return
+    }
+    const m = binding.modifiers ?? {}
+    const options: TouchPanOptions = {
+      handler: handler as TouchPanHandler,
+      allowHorizontal: !!m.horizontal,
+      allowVertical: !!m.vertical,
+      allowUp: !!m.up,
+      allowDown: !!m.down,
+      allowLeft: !!m.left,
+      allowRight: !!m.right,
+      mouse: !!m.mouse || !!m.mouseCapture,
+      prevent: !!m.prevent,
+      stop: !!m.stop,
+      capture: !!m.capture || !!m.mouseCapture,
+      passive: !!m.passive,
+      mouseCapture: false,
+    }
+    options.mouseCapture = !!m.mouseCapture
+
+    let state: PanState | null = null
+
+    // touch-action : laisser le scroll natif quand on ne capture qu'un axe
+    if (options.prevent) el.style.touchAction = "none"
+    else if (options.allowHorizontal && !options.allowVertical) el.style.touchAction = "pan-y"
+    else if (options.allowVertical && !options.allowHorizontal) el.style.touchAction = "pan-x"
+    else el.style.touchAction = options.allowUp || options.allowDown || options.allowLeft || options.allowRight ? "pan-y pan-x" : "auto"
+
+    const onPointerDown = (e: PointerEvent) => {
+      if (state) return
+      if (e.pointerType === "mouse" && !options.mouse) return
+      applyPrevent(e, options, false)
+      state = {
+        pointerId: e.pointerId,
+        startX: e.clientX,
+        startY: e.clientY,
+        lastX: e.clientX,
+        lastY: e.clientY,
+        startTime: performance.now(),
+        lastTime: performance.now(),
+        axis: null,
+        panning: false,
+      }
+      try { (e.currentTarget as Element).setPointerCapture?.(e.pointerId) } catch { /* ignore */ }
+    }
+
+    const onPointerMove = (e: PointerEvent) => {
+      if (!state || state.pointerId !== e.pointerId) return
+      const dx = e.clientX - state.startX
+      const dy = e.clientY - state.startY
+      const deltaX = e.clientX - state.lastX
+      const deltaY = e.clientY - state.lastY
+      const now = performance.now()
+      const duration = now - state.startTime
+
+      if (!state.panning) {
+        if (Math.abs(dx) < PAN_MIN && Math.abs(dy) < PAN_MIN) return
+        const direction = parseDirection(dx, dy)
+        if (!axisAllowed(options, direction)) return
+        state.axis = direction === "left" || direction === "right" ? "horizontal" : "vertical"
+        state.panning = true
+        applyPrevent(e, options, true)
+        state.lastX = e.clientX
+        state.lastY = e.clientY
+        state.lastTime = now
+        emit(state, e, direction, { x: 0, y: 0 }, { x: dx, y: dy }, duration, true)
+        return
+      }
+
+      const direction = state.axis === "horizontal" ? (dx > 0 ? "right" : "left") : (dy > 0 ? "down" : "up")
+      applyPrevent(e, options, true)
+      state.lastX = e.clientX
+      state.lastY = e.clientY
+      state.lastTime = now
+      emit(state, e, direction, { x: deltaX, y: deltaY }, { x: dx, y: dy }, duration, false)
+    }
+
+    const onPointerEnd = (e: PointerEvent) => {
+      if (!state || state.pointerId !== e.pointerId) return
+      const dx = e.clientX - state.startX
+      const dy = e.clientY - state.startY
+      const duration = performance.now() - state.startTime
+      if (state.panning) {
+        const direction = state.axis === "horizontal" ? (dx > 0 ? "right" : "left") : (dy > 0 ? "down" : "up")
+        emit(state, e, direction, { x: 0, y: 0 }, { x: dx, y: dy }, duration, false, true)
+      }
+      state = null
+    }
+
+    const onPointerCancel = (e: PointerEvent) => {
+      if (state && state.pointerId === e.pointerId) state = null
+    }
+
+    const emit = (
+      s: PanState,
+      evt: PointerEvent,
+      direction: PanDirection,
+      delta: PanDelta,
+      distance: PanDelta,
+      duration: number,
+      isFirst: boolean,
+      isFinal = false,
+    ) => {
+      const elapsed = Math.max(duration, 1)
+      options.handler({
+        evt,
+        position: { top: evt.clientY, left: evt.clientX },
+        direction,
+        delta,
+        distance,
+        duration,
+        speed: { x: Math.abs(distance.x) / elapsed * 1000, y: Math.abs(distance.y) / elapsed * 1000 },
+        isFirst,
+        isFinal,
+        isVertical: s.axis === "vertical",
+        isHorizontal: s.axis === "horizontal",
+      })
+    }
+
+    const capture = options.capture
+    el.addEventListener("pointerdown", onPointerDown, { capture, passive: options.passive })
+    el.addEventListener("pointermove", onPointerMove, { capture, passive: options.passive })
+    el.addEventListener("pointerup", onPointerEnd, { capture })
+    el.addEventListener("pointercancel", onPointerCancel, { capture })
+
+    ;(el as QElement).__qTouchPanCleanup = () => {
+      el.removeEventListener("pointerdown", onPointerDown, { capture } as any)
+      el.removeEventListener("pointermove", onPointerMove, { capture } as any)
+      el.removeEventListener("pointerup", onPointerEnd, { capture } as any)
+      el.removeEventListener("pointercancel", onPointerCancel, { capture } as any)
+      el.style.touchAction = ""
+    }
+  },
+  unmounted(el: HTMLElement) {
+    ;(el as QElement).__qTouchPanCleanup?.()
+    delete (el as QElement).__qTouchPanCleanup
+  },
+}

package/lib/touchRepeat.ts

@@ -0,0 +1,148 @@
+// v-touch-repeat — directive : déclenche un handler en boucle tant que
+// l'élément est pressé (appui long répété), équivalent Quasar
+// https://quasar.dev/vue-directives/touch-repeat
+//
+// Usage :
+//   <button v-touch-repeat.mouse="onRepeat">…</button>
+//   <button v-touch-repeat.mouse="{ delay: 500, interval: 100 }">…</button>
+//   <button v-touch-repeat.mouse="'500:100'">…</button>
+// modifiers : mouse (inclut la souris), capture / mouseCapture, stop, prevent,
+// passive
+//
+// Détails du handler : { evt, count, elapsed }
+
+export interface TouchRepeatDetails {
+  evt: Event
+  /** Nombre d'appels (1 = premier, après le délai) */
+  count: number
+  /** Temps écoulé depuis le pointerdown (ms) */
+  elapsed: number
+}
+
+export type TouchRepeatHandler = (details: TouchRepeatDetails) => void
+
+const DEFAULTS = { delay: 600, interval: 150 }
+
+interface RepeatOptions {
+  handler: TouchRepeatHandler
+  delay: number
+  interval: number
+  mouse: boolean
+  stop: boolean
+  prevent: boolean
+  capture: boolean
+  passive: boolean
+}
+
+type QElement = HTMLElement & { __qTouchRepeatCleanup?: () => void }
+
+function parseValue(value: unknown): { delay?: number; interval?: number } {
+  if (typeof value === "number") return { interval: value }
+  if (typeof value === "string") {
+    const [delay, interval] = value.split(":")
+    const out: { delay?: number; interval?: number } = {}
+    const d = Number(delay)
+    if (Number.isFinite(d)) out.delay = d
+    const i = Number(interval)
+    if (Number.isFinite(i)) out.interval = i
+    return out
+  }
+  if (value && typeof value === "object") {
+    const o = value as Record<string, unknown>
+    const out: { delay?: number; interval?: number } = {}
+    const d = Number(o.delay)
+    if (Number.isFinite(d)) out.delay = d
+    const i = Number(o.interval)
+    if (Number.isFinite(i)) out.interval = i
+    return out
+  }
+  return {}
+}
+
+export const vTouchRepeat = {
+  mounted(el: HTMLElement, binding: { value?: unknown; modifiers?: Record<string, boolean> }) {
+    const handler = binding.value
+    if (typeof handler !== "function") {
+      console.warn("[v-touch-repeat] value doit être une fonction (handler)")
+      return
+    }
+    const m = binding.modifiers ?? {}
+    const parsed = parseValue(binding.value)
+    const options: RepeatOptions = {
+      handler: handler as TouchRepeatHandler,
+      delay: parsed.delay ?? DEFAULTS.delay,
+      interval: parsed.interval ?? DEFAULTS.interval,
+      mouse: !!m.mouse || !!m.mouseCapture,
+      stop: !!m.stop,
+      prevent: !!m.prevent,
+      capture: !!m.capture || !!m.mouseCapture,
+      passive: !!m.passive,
+    }
+
+    el.style.touchAction = "none"
+
+    let active = false
+    let count = 0
+    let startTime = 0
+    let timer: ReturnType<typeof setTimeout> | undefined
+    let intervalTimer: ReturnType<typeof setInterval> | undefined
+
+    const stop = () => {
+      active = false
+      if (timer) clearTimeout(timer)
+      if (intervalTimer) clearInterval(intervalTimer)
+      timer = undefined
+      intervalTimer = undefined
+    }
+
+    const tick = () => {
+      count++
+      options.handler({
+        evt: lastEvt ?? new Event("touch-repeat"),
+        count,
+        elapsed: Math.round(performance.now() - startTime),
+      })
+    }
+
+    let lastEvt: Event | null = null
+
+    const onPointerDown = (e: PointerEvent) => {
+      if (active) return
+      if (e.pointerType === "mouse" && !options.mouse) return
+      if (options.prevent && !options.passive) e.preventDefault()
+      if (options.stop) e.stopPropagation()
+      active = true
+      count = 0
+      startTime = performance.now()
+      lastEvt = e
+      timer = setTimeout(() => {
+        tick()
+        intervalTimer = setInterval(tick, options.interval)
+      }, options.delay)
+    }
+
+    const onPointerUp = (e: PointerEvent) => {
+      lastEvt = e
+      stop()
+    }
+
+    const capture = options.capture
+    el.addEventListener("pointerdown", onPointerDown, { capture, passive: options.passive })
+    el.addEventListener("pointerup", onPointerUp, { capture })
+    el.addEventListener("pointercancel", onPointerUp, { capture })
+    el.addEventListener("pointerleave", onPointerUp, { capture })
+
+    ;(el as QElement).__qTouchRepeatCleanup = () => {
+      el.removeEventListener("pointerdown", onPointerDown, { capture } as any)
+      el.removeEventListener("pointerup", onPointerUp, { capture } as any)
+      el.removeEventListener("pointercancel", onPointerUp, { capture } as any)
+      el.removeEventListener("pointerleave", onPointerUp, { capture } as any)
+      stop()
+      el.style.touchAction = ""
+    }
+  },
+  unmounted(el: HTMLElement) {
+    ;(el as QElement).__qTouchRepeatCleanup?.()
+    delete (el as QElement).__qTouchRepeatCleanup
+  },
+}

package/lib/touchSwipe.ts

@@ -0,0 +1,182 @@
+// v-touch-swipe — directive : détecte le « swipe » (glissement rapide puis
+// relâchement), équivalent Quasar
+// https://quasar.dev/vue-directives/touch-swipe
+//
+// Usage :
+//   <div v-touch-swipe.horizontal.mouse="onSwipe">…</div>
+//   <div v-touch-swipe="{ distance: 40, duration: 300 }">…</div>
+// modifiers : horizontal | vertical | up | down | left | right (filtres de
+// direction), mouse (inclut la souris), capture / mouseCapture, stop, prevent,
+// passive
+//
+// Détails du handler : { evt, direction, distance: { x, y }, duration,
+// speed: { x, y } }
+
+export type SwipeDirection = "up" | "down" | "left" | "right"
+
+export interface TouchSwipeDetails {
+  evt: PointerEvent
+  direction: SwipeDirection
+  /** Distance totale (px), par axe (signée) */
+  distance: { x: number; y: number }
+  duration: number
+  /** Vitesse finale (px/s), par axe */
+  speed: { x: number; y: number }
+}
+
+export type TouchSwipeHandler = (details: TouchSwipeDetails) => void
+
+const DEFAULTS = { distance: 50, duration: 300 }
+
+interface SwipeOptions {
+  handler: TouchSwipeHandler
+  distance: number
+  duration: number
+  allowHorizontal: boolean
+  allowVertical: boolean
+  allowUp: boolean
+  allowDown: boolean
+  allowLeft: boolean
+  allowRight: boolean
+  mouse: boolean
+  stop: boolean
+  prevent: boolean
+  capture: boolean
+  passive: boolean
+}
+
+type QElement = HTMLElement & { __qTouchSwipeCleanup?: () => void }
+
+function parseValue(value: unknown): { distance?: number; duration?: number } {
+  if (value && typeof value === "object") {
+    const o = value as Record<string, unknown>
+    const out: { distance?: number; duration?: number } = {}
+    const d = Number(o.distance)
+    if (Number.isFinite(d)) out.distance = d
+    const t = Number(o.duration)
+    if (Number.isFinite(t)) out.duration = t
+    return out
+  }
+  return {}
+}
+
+function axisAllowed(o: SwipeOptions, direction: SwipeDirection) {
+  if (o.allowHorizontal) return direction === "left" || direction === "right"
+  if (o.allowVertical) return direction === "up" || direction === "down"
+  switch (direction) {
+    case "up": return o.allowUp
+    case "down": return o.allowDown
+    case "left": return o.allowLeft
+    case "right": return o.allowRight
+  }
+}
+
+export const vTouchSwipe = {
+  mounted(el: HTMLElement, binding: { value?: unknown; modifiers?: Record<string, boolean> }) {
+    const handler = binding.value
+    if (typeof handler !== "function") {
+      console.warn("[v-touch-swipe] value doit être une fonction (handler)")
+      return
+    }
+    const m = binding.modifiers ?? {}
+    const parsed = parseValue(binding.value)
+    const options: SwipeOptions = {
+      handler: handler as TouchSwipeHandler,
+      distance: parsed.distance ?? DEFAULTS.distance,
+      duration: parsed.duration ?? DEFAULTS.duration,
+      allowHorizontal: !!m.horizontal,
+      allowVertical: !!m.vertical,
+      allowUp: !!m.up,
+      allowDown: !!m.down,
+      allowLeft: !!m.left,
+      allowRight: !!m.right,
+      mouse: !!m.mouse || !!m.mouseCapture,
+      stop: !!m.stop,
+      prevent: !!m.prevent,
+      capture: !!m.capture || !!m.mouseCapture,
+      passive: !!m.passive,
+    }
+
+    if (options.prevent) el.style.touchAction = "none"
+    else if (options.allowHorizontal && !options.allowVertical) el.style.touchAction = "pan-y"
+    else if (options.allowVertical && !options.allowHorizontal) el.style.touchAction = "pan-x"
+    else el.style.touchAction = "auto"
+
+    let startX = 0
+    let startY = 0
+    let startTime = 0
+    let lastX = 0
+    let lastY = 0
+    let lastTime = 0
+    let tracking = false
+
+    const guard = (e: Event) => {
+      if (options.stop) e.stopPropagation()
+      if (options.prevent) e.preventDefault()
+    }
+
+    const onPointerDown = (e: PointerEvent) => {
+      if (tracking) return
+      if (e.pointerType === "mouse" && !options.mouse) return
+      guard(e)
+      tracking = true
+      startX = lastX = e.clientX
+      startY = lastY = e.clientY
+      startTime = lastTime = performance.now()
+    }
+
+    const onPointerMove = (e: PointerEvent) => {
+      if (!tracking) return
+      lastX = e.clientX
+      lastY = e.clientY
+      lastTime = performance.now()
+      guard(e)
+    }
+
+    const onPointerUp = (e: PointerEvent) => {
+      if (!tracking) return
+      tracking = false
+      const now = performance.now()
+      const duration = now - startTime
+      const dx = e.clientX - startX
+      const dy = e.clientY - startY
+      const direction: SwipeDirection =
+        Math.abs(dx) >= Math.abs(dy) ? (dx > 0 ? "right" : "left") : (dy > 0 ? "down" : "up")
+      if (!axisAllowed(options, direction)) return
+      const along = direction === "left" || direction === "right" ? Math.abs(dx) : Math.abs(dy)
+      if (along < options.distance) return
+      if (duration > options.duration) return
+      const elapsed = Math.max(now - lastTime, 1)
+      const instSpeed = {
+        x: (lastX - startX) / elapsed * 1000,
+        y: (lastY - startY) / elapsed * 1000,
+      }
+      options.handler({
+        evt: e,
+        direction,
+        distance: { x: dx, y: dy },
+        duration,
+        speed: { x: Math.round(instSpeed.x), y: Math.round(instSpeed.y) },
+      })
+    }
+
+    const onCancel = () => { tracking = false }
+    const capture = options.capture
+    el.addEventListener("pointerdown", onPointerDown, { capture, passive: options.passive })
+    el.addEventListener("pointermove", onPointerMove, { capture, passive: options.passive })
+    el.addEventListener("pointerup", onPointerUp, { capture })
+    el.addEventListener("pointercancel", onCancel, { capture })
+
+    ;(el as QElement).__qTouchSwipeCleanup = () => {
+      el.removeEventListener("pointerdown", onPointerDown, { capture } as any)
+      el.removeEventListener("pointermove", onPointerMove, { capture } as any)
+      el.removeEventListener("pointerup", onPointerUp, { capture } as any)
+      el.removeEventListener("pointercancel", onCancel, { capture } as any)
+      el.style.touchAction = ""
+    }
+  },
+  unmounted(el: HTMLElement) {
+    ;(el as QElement).__qTouchSwipeCleanup?.()
+    delete (el as QElement).__qTouchSwipeCleanup
+  },
+}

package/lib/useComponentProps.ts

@@ -1,6 +1,7 @@
 import { computed, inject, toValue } from "vue"
 import type { ComputedRef, MaybeRefOrGetter } from "vue"
 import { qConfigKey } from "./config"
+import type { QAppLang } from "./config"
 
 /** Échelle de rayon : none (carré) → lg (très arrondi) */
 export type RadiusScale = "none" | "xs" | "sm" | "md" | "lg"
@@ -19,6 +20,12 @@ export const RADIUS_VALUES: Record<RadiusScale, string> = {
 export const isRadiusScale = (v: unknown): v is RadiusScale =>
   v === "none" || v === "xs" || v === "sm" || v === "md" || v === "lg"
 
+/** Langue d'application fournie par QConfigProvider ("en" par défaut). */
+export function useConfigLang(): ComputedRef<QAppLang> {
+  const config = inject(qConfigKey, null)
+  return computed(() => config?.lang.value ?? "en")
+}
+
 /**
  * Props par défaut d'un composant depuis `theme.componentProps` :
  * `default` (appliqué à tous) puis `<Nom>` (spécifique, prioritaire).

package/module.ts

@@ -93,9 +93,19 @@ export default defineNuxtPlugin((nuxtApp) => {
       getContents: () => `
 import { defineNuxtPlugin } from "#imports"
 import { vClose } from "@dnax/ui/runtime"
+import { vTouchPan } from "@dnax/ui/runtime"
+import { vTouchHold } from "@dnax/ui/runtime"
+import { vTouchSwipe } from "@dnax/ui/runtime"
+import { vTouchRepeat } from "@dnax/ui/runtime"
+import { vIntersection } from "@dnax/ui/runtime"
 
 export default defineNuxtPlugin((nuxtApp) => {
   nuxtApp.vueApp.directive("close", vClose)
+  nuxtApp.vueApp.directive("touch-pan", vTouchPan)
+  nuxtApp.vueApp.directive("touch-hold", vTouchHold)
+  nuxtApp.vueApp.directive("touch-swipe", vTouchSwipe)
+  nuxtApp.vueApp.directive("touch-repeat", vTouchRepeat)
+  nuxtApp.vueApp.directive("intersection", vIntersection)
 })
 `,
     })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dnax/ui",
-  "version": "0.0.27",
+  "version": "0.0.29",
   "module": "index.ts",
   "description": "UI design System",
   "type": "module",
@@ -22,15 +22,41 @@
     "vue": "^3.5.41"
   },
   "dependencies": {
+    "@editorjs/checklist": "^1.6.0",
+    "@editorjs/code": "^2.9.4",
+    "@editorjs/delimiter": "^1.4.2",
+    "@editorjs/editorjs": "^2.31.6",
+    "@editorjs/header": "^2.8.9",
+    "@editorjs/list": "^2.0.9",
+    "@editorjs/paragraph": "^2.11.7",
+    "@editorjs/quote": "^2.7.6",
     "@iconify/vue": "^5.0.1",
     "@nuxt/kit": "^4.5.2",
+    "@tiptap/extension-bubble-menu": "^3.31.3",
+    "@tiptap/extension-drag-handle": "^3.31.3",
+    "@tiptap/extension-drag-handle-vue-3": "^3.31.3",
+    "@tiptap/extension-floating-menu": "^3.31.3",
+    "@tiptap/extension-image": "^3.31.3",
+    "@tiptap/extension-mention": "^3.31.3",
+    "@tiptap/extension-table": "^3.31.3",
+    "@tiptap/extension-table-of-contents": "^3.31.3",
+    "@tiptap/extension-task-item": "^3.31.3",
+    "@tiptap/extension-task-list": "^3.31.3",
+    "@tiptap/extension-text-align": "^3.31.3",
+    "@tiptap/extension-text-style": "^3.31.3",
+    "@tiptap/pm": "^3.31.3",
+    "@tiptap/starter-kit": "^3.31.3",
+    "@tiptap/suggestion": "^3.31.3",
+    "@tiptap/vue-3": "^3.31.3",
     "@videojs/html": "^10.0.0-beta.32",
     "@vueuse/core": "^14.4.0",
+    "arktype": "^2.2.3",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "embla-carousel": "^8.5.0",
     "embla-carousel-vue": "^8.5.0",
     "fuse.js": "^7.1.0",
+    "moment": "^2.30.1",
     "shiki": "^3.0.0",
     "swiper": "^14.2.0",
     "tailwind-merge": "^3.6.0",

package/scripts/generate-exports.ts

@@ -42,6 +42,8 @@ export { screen } from "./lib/screen"
 export type { QScreen } from "./lib/screen"
 export { loading } from "./lib/loading"
 export type { LoadingOptions, QLoadingPlugin } from "./lib/loading"
+export { localStorage, sessionStorage } from "./lib/storage"
+export type { QWebStorage } from "./lib/storage"
 export {
   registerOverlay,
   unregisterOverlay,
@@ -52,6 +54,16 @@ export {
 } from "./lib/overlayBack"
 export type { OverlayHandle } from "./lib/overlayBack"
 export { markOverlayClose, closeParentOverlay, vClose } from "./lib/closeOverlay"
+export { vTouchPan } from "./lib/touchPan"
+export type { PanDetails, TouchPanHandler, PanDirection } from "./lib/touchPan"
+export { vTouchHold } from "./lib/touchHold"
+export type { TouchHoldDetails, TouchHoldHandler } from "./lib/touchHold"
+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"
 `
 
 await Bun.write(indexFile, `${exports}\n${manualExports}`)