Skip to content

secondsky/claude-skills / plugins/nuxt-ui-v4/skills/nuxt-ui-v4

nuxt-ui-v4

Verified

Nuxt UI v4 component library for building Nuxt v4 applications. 125+ accessible components with Tailwind v4, Reka UI, dark mode, theming. Use for dashboards, forms, overlays, editors, page layouts, pricing pages, or encountering component, theming, or TypeScript errors.

FileKindSize
SKILL.mdskill md13.0 KB
references/COMMON_ERRORS_DETAILED.mdmarkdown24.7 KB
references/accessibility-patterns.mdmarkdown822 B
references/ai-sdk-v5-integration.mdmarkdown6.4 KB
references/auth-form.mdmarkdown6.4 KB
references/chat-components.mdmarkdown13.2 KB
references/chat-reasoning.mdmarkdown3.0 KB
references/chat-shimmer.mdmarkdown1.6 KB
references/chat-tool.mdmarkdown3.6 KB
references/command-palette-setup.mdmarkdown1.1 KB
references/common-components.mdmarkdown1.2 KB
references/component-theming-guide.mdmarkdown13.2 KB
references/composables-guide.mdmarkdown908 B
references/content-components.mdmarkdown7.3 KB
references/css-variables-reference.mdmarkdown14.9 KB
references/dark-mode-guide.mdmarkdown10.9 KB
references/dashboard-components.mdmarkdown8.1 KB
references/data-display-components.mdmarkdown11.7 KB
references/design-system-guide.mdmarkdown16.1 KB
references/editor-components.mdmarkdown7.9 KB
references/feedback-components-reference.mdmarkdown11.4 KB
references/form-advanced-patterns.mdmarkdown1.7 KB
references/form-components-reference.mdmarkdown14.0 KB
references/form-validation-patterns.mdmarkdown6.4 KB
references/i18n-integration.mdmarkdown12.8 KB
references/icon-system-guide.mdmarkdown14.5 KB
references/layout-components-reference.mdmarkdown9.5 KB
references/loading-feedback-patterns.mdmarkdown1.0 KB
references/navigation-components-reference.mdmarkdown8.8 KB
references/nuxt-content-integration.mdmarkdown15.7 KB
references/nuxt-v4-features.mdmarkdown8.0 KB
references/overlay-decision-guide.mdmarkdown1.3 KB
references/page-layout-components.mdmarkdown8.4 KB
references/performance-optimization.mdmarkdown12.8 KB
references/pricing-components.mdmarkdown7.7 KB
references/responsive-patterns.mdmarkdown795 B
references/semantic-color-system.mdmarkdown1.3 KB
references/tailwind-prefix-guide.mdmarkdown7.6 KB
references/typescript-setup.mdmarkdown10.8 KB
scripts/check-versions.shexecutablescript1.3 KB
templates/app.config.tsscript2.5 KB
templates/app.vueother1.1 KB
templates/components/ui-avatar-badge.vueother7.7 KB
templates/components/ui-card-layouts.vueother5.9 KB
templates/components/ui-carousel-gallery.vueother1.4 KB
templates/components/ui-chat-full.vueother3.4 KB
templates/components/ui-chat-interface.vueother8.8 KB
templates/components/ui-command-palette.vueother1.8 KB
templates/components/ui-content-prose.vueother7.2 KB
templates/components/ui-dark-mode-toggle.vueother7.4 KB
templates/components/ui-data-table.vueother7.1 KB
templates/components/ui-drawer-mobile.vueother5.2 KB
templates/components/ui-dropdown-menu.vueother6.3 KB
templates/components/ui-empty-state.vueother5.2 KB
templates/components/ui-feedback-states.vueother6.2 KB
templates/components/ui-form-example.vueother4.5 KB
templates/components/ui-input-date.vueother5.2 KB
templates/components/ui-input-time.vueother5.8 KB
templates/components/ui-modal-dialog.vueother8.0 KB
templates/components/ui-navigation-tabs.vueother7.2 KB
templates/components/ui-popover-tooltip.vueother2.6 KB
templates/components/ui-toast-notifications.vueother8.9 KB
templates/composables/useAIChat.tsscript2.9 KB
templates/composables/useI18nForm.tsscript9.6 KB
templates/composables/useNuxtUITheme.tsscript2.4 KB
templates/layouts/dashboard.vueother3.7 KB
templates/nuxt.config.tsscript1.3 KB
templates/pages/landing.vueother5.9 KB

templates/composables/useI18nForm.ts

View on GitHub
import { z } from 'zod'
import type { ZodSchema } from 'zod'

/**
 * Composable for creating localized form schemas and validation messages.
 *
 * Features:
 * - Reactive schema that updates when locale changes
 * - Common validation patterns with i18n support
 * - Type-safe field definitions
 * - Automatic error message localization
 *
 * @example
 * ```typescript
 * const { createSchema, validators } = useI18nForm()
 *
 * const schema = createSchema({
 *   email: validators.email(),
 *   password: validators.password({ minLength: 8 }),
 *   age: validators.number({ min: 18, max: 120 })
 * })
 * ```
 */
export const useI18nForm = () => {
  const { t } = useI18n()

  /**
   * Common validation patterns with localized messages
   */
  const validators = {
    /**
     * Email field validation
     */
    email: (customMessage?: string) => {
      return z.string()
        .min(1, t('validation.required'))
        .email(customMessage || t('validation.email.invalid'))
    },

    /**
     * Password field validation
     */
    password: (options: {
      minLength?: number
      requireUppercase?: boolean
      requireNumber?: boolean
      requireSpecialChar?: boolean
      customMessage?: string
    } = {}) => {
      const {
        minLength = 8,
        requireUppercase = true,
        requireNumber = true,
        requireSpecialChar = false
      } = options

      let schema = z.string()
        .min(1, t('validation.required'))
        .min(minLength, t('validation.password.minLength', { min: minLength }))

      if (requireUppercase) {
        schema = schema.regex(
          /[A-Z]/,
          t('validation.password.uppercase')
        )
      }

      if (requireNumber) {
        schema = schema.regex(
          /[0-9]/,
          t('validation.password.number')
        )
      }

      if (requireSpecialChar) {
        schema = schema.regex(
          /[!@#$%^&*(),.?":{}|<>]/,
          t('validation.password.specialChar')
        )
      }

      return schema
    },

    /**
     * Required string field
     */
    required: (customMessage?: string) => {
      return z.string()
        .min(1, customMessage || t('validation.required'))
    },

    /**
     * Optional string field
     */
    optional: () => {
      return z.string().optional()
    },

    /**
     * Number field validation
     */
    number: (options: {
      min?: number
      max?: number
      integer?: boolean
      customMessage?: string
    } = {}) => {
      const { min, max, integer = false } = options

      let schema = z.number({
        required_error: t('validation.required'),
        invalid_type_error: t('validation.number.invalid')
      })

      if (integer) {
        schema = schema.int(t('validation.number.integer'))
      }

      if (min !== undefined) {
        schema = schema.min(min, t('validation.number.min', { min }))
      }

      if (max !== undefined) {
        schema = schema.max(max, t('validation.number.max', { max }))
      }

      return schema
    },

    /**
     * String length validation
     */
    string: (options: {
      minLength?: number
      maxLength?: number
      customMessage?: string
    } = {}) => {
      const { minLength, maxLength } = options

      let schema = z.string()
        .min(1, t('validation.required'))

      if (minLength) {
        schema = schema.min(
          minLength,
          t('validation.string.minLength', { min: minLength })
        )
      }

      if (maxLength) {
        schema = schema.max(
          maxLength,
          t('validation.string.maxLength', { max: maxLength })
        )
      }

      return schema
    },

    /**
     * URL validation
     */
    url: (customMessage?: string) => {
      return z.string()
        .min(1, t('validation.required'))
        .url(customMessage || t('validation.url.invalid'))
    },

    /**
     * Phone number validation (basic)
     */
    phone: (customMessage?: string) => {
      return z.string()
        .min(1, t('validation.required'))
        .regex(
          /^[\d\s()+-]+$/,
          customMessage || t('validation.phone.invalid')
        )
    },

    /**
     * Date validation
     */
    date: (options: {
      min?: Date
      max?: Date
      customMessage?: string
    } = {}) => {
      const { min, max } = options

      let schema = z.date({
        required_error: t('validation.required'),
        invalid_type_error: t('validation.date.invalid')
      })

      if (min) {
        schema = schema.min(min, t('validation.date.min'))
      }

      if (max) {
        schema = schema.max(max, t('validation.date.max'))
      }

      return schema
    },

    /**
     * Boolean/checkbox validation
     */
    checkbox: (options: {
      mustBeTrue?: boolean
      customMessage?: string
    } = {}) => {
      const { mustBeTrue = false, customMessage } = options

      let schema = z.boolean({
        required_error: t('validation.required')
      })

      if (mustBeTrue) {
        schema = schema.refine(
          (val) => val === true,
          customMessage || t('validation.checkbox.mustBeTrue')
        )
      }

      return schema
    },

    /**
     * Select/dropdown validation
     */
    select: <T extends readonly [string, ...string[]]>(
      options: T,
      customMessage?: string
    ) => {
      return z.enum(options, {
        required_error: t('validation.required'),
        invalid_type_error: customMessage || t('validation.select.invalid')
      })
    },

    /**
     * File upload validation
     */
    file: (options: {
      maxSize?: number  // in MB
      acceptedTypes?: string[]
      required?: boolean
    } = {}) => {
      const {
        maxSize = 5,
        acceptedTypes = ['image/jpeg', 'image/png', 'image/webp'],
        required = true
      } = options

      return z.custom<File>((file) => {
        if (!file && !required) return true
        if (!file && required) {
          throw new Error(t('validation.file.required'))
        }

        const f = file as File

        // Check file size
        const fileSizeInMB = f.size / (1024 * 1024)
        if (fileSizeInMB > maxSize) {
          throw new Error(t('validation.file.maxSize', { max: maxSize }))
        }

        // Check file type
        if (!acceptedTypes.includes(f.type)) {
          throw new Error(
            t('validation.file.type', { types: acceptedTypes.join(', ') })
          )
        }

        return true
      })
    }
  }

  /**
   * Create a reactive schema that updates when locale changes
   */
  const createSchema = <T extends Record<string, ZodSchema>>(
    fields: T
  ) => {
    return computed(() => z.object(fields))
  }

  /**
   * Format validation errors for display
   */
  const formatErrors = (errors: Record<string, string[]>) => {
    return Object.entries(errors).reduce((acc, [field, messages]) => {
      acc[field] = messages[0]  // Get first error only
      return acc
    }, {} as Record<string, string>)
  }

  /**
   * Get translated field label
   */
  const getFieldLabel = (fieldName: string, prefix = 'fields') => {
    return t(`${prefix}.${fieldName}`)
  }

  /**
   * Common form state
   */
  const createFormState = <T extends Record<string, any>>(initialValues: T) => {
    const values = ref<T>(initialValues)
    const errors = ref<Record<keyof T, string>>({} as Record<keyof T, string>)
    const isSubmitting = ref(false)
    const isDirty = ref(false)

    // Mark form as dirty when values change
    watch(
      values,
      () => {
        isDirty.value = true
      },
      { deep: true }
    )

    const reset = () => {
      values.value = { ...initialValues }
      errors.value = {} as Record<keyof T, string>
      isDirty.value = false
      isSubmitting.value = false
    }

    return {
      values,
      errors,
      isSubmitting,
      isDirty,
      reset
    }
  }

  return {
    validators,
    createSchema,
    formatErrors,
    getFieldLabel,
    createFormState,
    t  // Expose t function for custom messages
  }
}

/**
 * Example translations structure for locales/*.json:
 *
 * {
 *   "validation": {
 *     "required": "This field is required",
 *     "email": {
 *       "invalid": "Please enter a valid email address"
 *     },
 *     "password": {
 *       "minLength": "Password must be at least {min} characters",
 *       "uppercase": "Password must contain an uppercase letter",
 *       "number": "Password must contain a number",
 *       "specialChar": "Password must contain a special character"
 *     },
 *     "number": {
 *       "invalid": "Please enter a valid number",
 *       "integer": "Must be a whole number",
 *       "min": "Must be at least {min}",
 *       "max": "Must be no more than {max}"
 *     },
 *     "string": {
 *       "minLength": "Must be at least {min} characters",
 *       "maxLength": "Must be no more than {max} characters"
 *     },
 *     "url": {
 *       "invalid": "Please enter a valid URL"
 *     },
 *     "phone": {
 *       "invalid": "Please enter a valid phone number"
 *     },
 *     "date": {
 *       "invalid": "Please enter a valid date",
 *       "min": "Date must be after minimum date",
 *       "max": "Date must be before maximum date"
 *     },
 *     "checkbox": {
 *       "mustBeTrue": "You must accept this"
 *     },
 *     "select": {
 *       "invalid": "Please select a valid option"
 *     },
 *     "file": {
 *       "required": "Please upload a file",
 *       "maxSize": "File must be smaller than {max}MB",
 *       "type": "Accepted file types: {types}"
 *     }
 *   },
 *   "fields": {
 *     "email": "Email",
 *     "password": "Password",
 *     "confirmPassword": "Confirm Password",
 *     "firstName": "First Name",
 *     "lastName": "Last Name"
 *   }
 * }
 */
brainstormingobra/superpowersYou MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation).Stars: 322kUpdated Claude CodeCodexVerifiedInstall
brand-guidelinesanthropics/skillsApplies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
frontend-designanthropics/skillsGuidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
mcp-builderanthropics/skillsGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).Stars: 198kUpdated Claude CodeCodexVerifiedInstall