daisy-ui-kit 5.0.2 → 5.0.4

package/app/composables/use-toast.ts

@@ -1,345 +0,0 @@
-import type { Ref } from 'vue'
-import { computed, reactive, ref, toRef } from 'vue'
-
-export type ToastType = 'success' | 'error' | 'info' | 'warning' | string
-
-export type ToastPosition =
-  | 'top-start'
-  | 'top-center'
-  | 'top-end'
-  | 'middle-start'
-  | 'middle-center'
-  | 'middle-end'
-  | 'bottom-start'
-  | 'bottom-center'
-  | 'bottom-end'
-
-export type ToastStatus = 'pending' | 'success' | 'error' | 'info' | 'warning' | 'default'
-
-export interface Toast {
-  id: number
-  message: string
-  name?: string // toast channel name, optional but always set by logic
-  type?: ToastType
-  duration?: number
-  position: ToastPosition
-  countdown?: number
-  status?: ToastStatus
-  progress?: number // 0-1 for progress bar
-  promiseId?: string // for async/promise support
-  ariaLive?: 'polite' | 'assertive' // accessibility
-  [key: string]: any
-}
-
-/**
- * State for a single toast channel (internal use)
- */
-export interface ToastChannelState {
-  toasts: Ref<Toast[]>
-  toastQueue: Toast[]
-  toastLimit: number | null
-}
-
-let globalToastChannels: Ref<Record<string, ToastChannelState & { defaults?: Partial<Toast> }>> | null = null
-let globalNextToastId: Ref<number> | null = null
-
-function getGlobalToastChannels() {
-  if (!globalToastChannels) {
-    globalToastChannels = ref({})
-  }
-  return globalToastChannels
-}
-function getGlobalNextToastId() {
-  if (!globalNextToastId) {
-    globalNextToastId = ref(1)
-  }
-  return globalNextToastId
-}
-
-function getOrCreateChannel(name: string, defaults?: Partial<Toast>, limit?: number | null) {
-  const channels = getGlobalToastChannels().value
-  if (!channels[name]) {
-    channels[name] = {
-      toasts: ref<Toast[]>([]),
-      toastQueue: [],
-      toastLimit: typeof limit === 'number' ? limit : null,
-      defaults,
-    }
-  }
-  return toRef(channels[name])
-}
-
-/**
- * Clear all toast queues for all channels (useful for logout or channel switch)
- */
-export function clearAllToastQueues() {
-  const channels = getGlobalToastChannels().value
-  Object.values(channels).forEach(channel => {
-    channel.toastQueue.length = 0
-  })
-}
-
-/**
- * Global toast notification composable supporting named channels.
- *
- * - Each toast has an optional `name` property (defaults to 'default').
- * - All toast state (toasts, queue, limit) is isolated per channel.
- * - UI and logic can independently manage/display different channels.
- * - Defensive dev warnings if name is missing/invalid.
- *
- * Example usage:
- *   const { toasts, addToast } = useToast({ name: 'admin' })
- *   addToast({ message: 'Hi', name: 'admin' })
- *   // In UI: <Toast name="admin" />
- */
-/**
- * Options for useToast composable.
- * - name: channel name (default: 'default')
- * - defaults: default toast settings for this channel (merged into each toast)
- */
-export interface UseToastOptions {
-  name?: string
-  defaults?: Partial<Toast>
-  limit?: number // per-channel toast limit
-}
-
-/**
- * Global toast notification composable supporting named channels and customizable defaults.
- *
- * - Each toast has an optional `name` property (defaults to 'default').
- * - All toast state (toasts, queue, limit) is isolated per channel.
- * - UI and logic can independently manage/display different channels.
- * - Defensive dev warnings if name is missing/invalid.
- * - You can provide `defaults` to set default toast settings for all toasts in this channel.
- *
- * Example usage:
- *   const { toasts, addToast } = useToast({ name: 'admin', defaults: { duration: 6000, type: 'info' } })
- *   addToast({ message: 'Hi' }) // will use defaults
- *   // In UI: <Toast name="admin" />
- */
-function normalizeToast(toast: any): Toast & { countdown: number; originalDuration: number; intervalId?: number } {
-  if (toast.originalDuration == null) {
-    toast.originalDuration = toast.duration ?? 0
-  }
-  if (toast.countdown == null) {
-    toast.countdown = toast.originalDuration
-  }
-  if (typeof toast.intervalId === 'undefined') {
-    toast.intervalId = undefined
-  }
-  return toast as Toast & { countdown: number; originalDuration: number; intervalId?: number }
-}
-
-export function useToast(options?: UseToastOptions) {
-  const name = options?.name?.trim() || 'default'
-  const defaults = options?.defaults || {}
-  const limit = typeof options?.limit === 'number' ? options.limit : null
-
-  // Always get or create the channel (init only once)
-  const channel = getOrCreateChannel(name, defaults, limit)
-
-  function addToast(
-    toast: { message: string; position?: ToastPosition; name?: string } & Partial<Omit<Toast, 'id' | 'name'>>,
-  ) {
-    const toastName = toast.name?.trim() || name
-    const nextToastIdRef = getGlobalNextToastId()
-    // Always get or create the target channel for this toast, using the correct limit if provided
-    const channelLimit = typeof options?.limit === 'number' ? options.limit : null
-    const channel = getOrCreateChannel(toastName, defaults, channelLimit)
-    const merged = { ...channel.value.defaults, ...defaults, ...toast }
-    const position = merged.position ?? 'bottom-center'
-    const duration = merged.duration ?? 0
-    const status = merged.status ?? 'default'
-    if (import.meta.env.NODE_ENV !== 'production' && !toastName) {
-      console.warn('[addToast] Toast channel name is empty or invalid. Falling back to "default".')
-    }
-    const id = nextToastIdRef.value++
-    const newToast = normalizeToast(
-      reactive({
-        id,
-        ...merged,
-        name: toastName,
-        position,
-        countdown: duration,
-        originalDuration: duration,
-        status,
-        progress: typeof merged.progress === 'number' ? merged.progress : undefined,
-        ariaLive: merged.ariaLive ?? 'polite',
-        intervalId: undefined as number | undefined,
-      }),
-    )
-
-    // If limit is set and reached, queue the toast
-    if (channel.value.toastLimit && channel.value.toasts.length >= channel.value.toastLimit) {
-      ;(channel.value.toastQueue ??= []).push(newToast)
-      return id
-    }
-    channel.value.toasts.push(newToast)
-    // Ensure timer always starts for visible toasts
-    if (channel.value.toasts.includes(newToast)) {
-      startToastTimer(newToast)
-    }
-    return id
-  }
-
-  function removeToast(id: number) {
-    const idx = channel.value.toasts.findIndex(t => t.id === id)
-    if (idx !== -1) {
-      // Defensive: clear countdown timer if present
-      const toast = channel.value.toasts[idx] as Toast & { intervalId?: number }
-      if (toast.intervalId) {
-        clearInterval(toast.intervalId)
-      }
-      channel.value.toasts.splice(idx, 1)
-      // If queue exists, pop next toast
-      if (channel.value.toastLimit && (channel.value.toastQueue?.length ?? 0) > 0) {
-        const next = channel.value.toastQueue!.shift()
-        if (next) {
-          const norm = normalizeToast(next)
-          channel.value.toasts.push(norm)
-          // Ensure timer always starts for visible toasts
-          if (channel.value.toasts.includes(norm)) {
-            startToastTimer(norm)
-          }
-        }
-      }
-    }
-  }
-
-  function clearToasts() {
-    channel.value.toasts = []
-    if (channel.value.toastQueue) {
-      channel.value.toastQueue.length = 0
-    }
-  }
-
-  /**
-   * Update or replace a toast by id
-   */
-  function updateToast(id: number, updates: Partial<Toast>) {
-    const toast = channel.value.toasts.find(t => t.id === id)
-    if (toast) {
-      Object.assign(toast, updates)
-      normalizeToast(toast)
-      // If updating countdown/duration, recalculate progress
-      if (typeof toast.countdown === 'number' && typeof toast.duration === 'number' && toast.duration > 0) {
-        toast.progress = Math.max(0, toast.countdown / toast.duration)
-      }
-    }
-  }
-
-  /**
-   * Show a toast for the duration of a promise
-   * Sets status to 'pending', then 'success' or 'error' on resolve/reject
-   */
-  function toastPromise<T>(
-    promise: Promise<T>,
-    options: {
-      pending: Omit<Toast, 'id'>
-      success: Omit<Toast, 'id'>
-      error: Omit<Toast, 'id'>
-      name?: string
-    },
-  ): Promise<T> {
-    const toastName = options.name?.trim() || name
-    if (import.meta.env.NODE_ENV !== 'production' && !toastName) {
-      console.warn('[toastPromise] Toast channel name is empty or invalid. Falling back to "default".')
-    }
-    const promiseId = `promise-${Date.now()}-${Math.random()}`
-    const pendingId = addToast({
-      ...options.pending,
-      status: 'pending',
-      promiseId,
-      message: options.pending.message,
-      name: toastName,
-    })
-    return promise.then(
-      result => {
-        updateToast(pendingId, {
-          ...options.success,
-          status: 'success',
-          promiseId,
-          message: options.success.message,
-          name: toastName,
-        })
-        return result
-      },
-      err => {
-        updateToast(pendingId, {
-          ...options.error,
-          status: 'error',
-          promiseId,
-          message: options.error.message,
-          name: toastName,
-        })
-        throw err
-      },
-    )
-  }
-
-  /**
-   * Set a maximum number of visible toasts (queue extras)
-   */
-  function setToastLimit(limit: number) {
-    channel.value.toastLimit = limit
-    if (channel.value.toastLimit) {
-      // If over limit, move extras to queue
-      while (channel.value.toasts.length > channel.value.toastLimit) {
-        const removed = channel.value.toasts.pop()
-        if (removed) {
-          // Stop timer for toast leaving visible list
-          if (removed.intervalId) {
-            clearInterval(removed.intervalId)
-            removed.intervalId = undefined
-          }
-          ;(channel.value.toastQueue ??= []).unshift(removed)
-        }
-      }
-      // If under limit and queue has items, fill up
-      while (channel.value.toasts.length < channel.value.toastLimit && (channel.value.toastQueue?.length ?? 0) > 0) {
-        const next = channel.value.toastQueue!.shift()
-        if (next) {
-          const norm = normalizeToast(next)
-          channel.value.toasts.push(norm)
-          // Ensure timer always starts for visible toasts
-          if (channel.value.toasts.includes(norm)) {
-            startToastTimer(norm)
-          }
-        }
-      }
-    }
-  }
-
-  function startToastTimer(
-    toast: Toast & { countdown: number; originalDuration: number; intervalId?: number; startTime?: number },
-  ) {
-    if (toast.originalDuration > 0) {
-      if (toast.intervalId) {
-        clearInterval(toast.intervalId)
-      }
-      const start = Date.now()
-      toast.startTime = start
-
-      toast.intervalId = setInterval(() => {
-        const elapsed = Date.now() - (toast.startTime ?? start)
-        toast.countdown = Math.max(0, toast.originalDuration - elapsed)
-        toast.progress = Math.max(0, toast.countdown / toast.originalDuration)
-        if (toast.countdown <= 0) {
-          clearInterval(toast.intervalId)
-          removeToast(toast.id)
-        }
-      }, 16) as unknown as number // 60fps for smooth animation
-    }
-  }
-
-  return {
-    toasts: computed(() => channel.value.toasts),
-    addToast,
-    removeToast,
-    clearToasts,
-    updateToast,
-    toastPromise,
-    setToastLimit,
-    name,
-  }
-}

package/app/composables/useSearch.ts

@@ -1,22 +0,0 @@
-const isSearchOpen = ref(false)
-
-export function useSearch() {
-  function openSearch() {
-    isSearchOpen.value = true
-  }
-
-  function closeSearch() {
-    isSearchOpen.value = false
-  }
-
-  function toggleSearch() {
-    isSearchOpen.value = !isSearchOpen.value
-  }
-
-  return {
-    isSearchOpen,
-    openSearch,
-    closeSearch,
-    toggleSearch,
-  }
-}

package/app/utils/drawer-utils.ts

@@ -1,34 +0,0 @@
-import { reactive } from 'vue'
-
-export interface DrawerState {
-  name: string
-  isDrawerOpen: boolean
-  openDrawer: () => void
-  closeDrawer: () => void
-  toggleDrawer: () => void
-}
-export interface Drawers {
-  [key: string]: DrawerState
-}
-
-export const drawers = reactive<Drawers>({})
-
-export function createDrawerState(name: string) {
-  const drawerState =
-    drawers[name] ||
-    reactive<DrawerState>({
-      name,
-      isDrawerOpen: false,
-      openDrawer() {
-        drawerState.isDrawerOpen = true
-      },
-      closeDrawer() {
-        drawerState.isDrawerOpen = false
-      },
-      toggleDrawer() {
-        drawerState.isDrawerOpen = !drawerState.isDrawerOpen
-      },
-    })
-  drawers[name] = drawerState
-  return drawerState
-}

package/app/utils/position-area.ts

@@ -1,40 +0,0 @@
-/**
- * Maps placement values to CSS position-area values for anchor positioning
- *
- * Using span to align edges:
- * - "bottom span-right" = below anchor, aligned to left edge (spans from left to center)
- * - "bottom span-left" = below anchor, aligned to right edge (spans from center to right)
- */
-export function getPositionArea(placement: string): string {
-  const positionMap: Record<string, string> = {
-    // Top positions
-    top: 'center top', // centered above
-    'top-start': 'top span-right', // above, left edge aligned
-    'top-end': 'top span-left', // above, right edge aligned
-
-    // Right positions
-    right: 'center right', // centered to right
-    'right-start': 'right span-bottom', // right, top edge aligned
-    'right-end': 'right span-top', // right, bottom edge aligned
-
-    // Bottom positions (most common for dropdowns)
-    bottom: 'center bottom', // centered below
-    'bottom-start': 'bottom span-right', // below, left edge aligned
-    'bottom-end': 'bottom span-left', // below, right edge aligned
-
-    // Left positions
-    left: 'center left', // centered to left
-    'left-start': 'left span-bottom', // left, top edge aligned
-    'left-end': 'left span-top', // left, bottom edge aligned
-  }
-
-  return positionMap[placement] || 'bottom span-right'
-}
-
-/**
- * Gets position-try-fallbacks for automatic repositioning
- */
-export function getPositionFallbacks(_placement: string): string {
-  // Simple flip fallbacks - flip to opposite side on same axis
-  return 'flip-block, flip-inline'
-}