nuxt-users 1.38.0 → 1.40.0

package/scripts/check-locale-consistency.ts

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const rootDir = join(__dirname, '..')
+
+/**
+ * Get all translation keys from the Hungarian locale file
+ */
+const getHungarianKeys = (): { base: Set<string>, informal: Set<string>, formal: Set<string> } => {
+  const huFilePath = join(rootDir, 'src/runtime/locales/hu.ts')
+  const content = readFileSync(huFilePath, 'utf8')
+
+  // Extract huBase object
+  const baseMatch = content.match(/const huBase: LocaleMessages = \{([\s\S]*?)\n\}/)
+  if (!baseMatch) {
+    throw new Error('Could not find huBase in hu.ts')
+  }
+
+  // Extract huInformalOverrides object
+  const informalMatch = content.match(/const huInformalOverrides: LocaleMessages = \{([\s\S]*?)\n\}/)
+  if (!informalMatch) {
+    throw new Error('Could not find huInformalOverrides in hu.ts')
+  }
+
+  // Extract huFormalOverrides object
+  const formalMatch = content.match(/const huFormalOverrides: LocaleMessages = \{([\s\S]*?)\n\}/)
+  if (!formalMatch) {
+    throw new Error('Could not find huFormalOverrides in hu.ts')
+  }
+
+  // Parse the objects (simple parsing for nested structures)
+  const parseKeys = (objString: string): Set<string> => {
+    const keys = new Set<string>()
+    const lines = objString.split('\n')
+    const stack: string[] = []
+
+    for (const line of lines) {
+      const trimmed = line.trim()
+
+      // Skip empty lines and comments
+      if (!trimmed || trimmed.startsWith('//')) {
+        continue
+      }
+
+      // Check for opening brace (nested object)
+      if (trimmed.match(/^(\w+):\s*\{/)) {
+        const match = trimmed.match(/^(\w+):\s*\{/)
+        if (match && match[1]) {
+          stack.push(match[1])
+        }
+        continue
+      }
+
+      // Check for closing brace
+      if (trimmed === '},') {
+        stack.pop()
+        continue
+      }
+
+      // Check for key-value pair
+      if (trimmed.match(/^(\w+):/)) {
+        const match = trimmed.match(/^(\w+):/)
+        if (match) {
+          const key = match[1]
+          const fullKey = stack.length > 0 ? `${stack.join('.')}.${key}` : key
+          if (fullKey) {
+            keys.add(fullKey)
+          }
+        }
+      }
+    }
+
+    return keys
+  }
+
+  const baseKeys = parseKeys(baseMatch[1] || '')
+  const informalKeys = parseKeys(informalMatch[1] || '')
+  const formalKeys = parseKeys(formalMatch[1] || '')
+
+  return { base: baseKeys, informal: informalKeys, formal: formalKeys }
+}
+
+/**
+ * Check for consistency issues
+ */
+const checkConsistency = () => {
+  console.log('[Nuxt Users] 🔍 Checking Hungarian locale formal/informal consistency...\n')
+
+  const { base, informal, formal } = getHungarianKeys()
+
+  console.log('[Nuxt Users] 📊 Statistics:')
+  console.log(`   Base keys: ${base.size}`)
+  console.log(`   Informal override keys: ${informal.size}`)
+  console.log(`   Formal override keys: ${formal.size}`)
+  console.log()
+
+  // Check 1: Formal keys that don't exist in informal
+  const formalOnlyKeys: string[] = []
+  for (const key of formal) {
+    if (!informal.has(key)) {
+      formalOnlyKeys.push(key)
+    }
+  }
+
+  // Check 2: Informal keys that don't exist in formal
+  const informalOnlyKeys: string[] = []
+  for (const key of informal) {
+    if (!formal.has(key)) {
+      informalOnlyKeys.push(key)
+    }
+  }
+
+  let hasErrors = false
+
+  if (formalOnlyKeys.length > 0) {
+    hasErrors = true
+    console.log('❌ Formal keys without informal equivalent:\n')
+    for (const key of formalOnlyKeys.sort()) {
+      console.log(`   - ${key}`)
+    }
+    console.log()
+  }
+
+  if (informalOnlyKeys.length > 0) {
+    hasErrors = true
+    console.log('❌ Informal keys without formal equivalent:\n')
+    for (const key of informalOnlyKeys.sort()) {
+      console.log(`   - ${key}`)
+    }
+    console.log()
+  }
+
+  if (hasErrors) {
+    console.log('[Nuxt Users] ⚠️  Inconsistencies found!')
+    console.log('[Nuxt Users] 💡 Tip: All formal variants must have an informal equivalent and vice versa.')
+    console.log('[Nuxt Users]      This ensures consistent translations across both Hungarian variants.')
+    console.log()
+    process.exit(1)
+  }
+
+  console.log('[Nuxt Users] ✅ All formal/informal translations are consistent!')
+  console.log()
+}
+
+// Main execution
+try {
+  checkConsistency()
+}
+catch (error) {
+  console.error('[Nuxt Users] ❌ Error:', error instanceof Error ? error.message : 'Unknown error')
+  process.exit(1)
+}

package/scripts/check-peer-dependencies.js

@@ -58,16 +58,16 @@ function getPackageManagerCommand() {
   if (existsSync(join(cwd, 'pnpm-lock.yaml'))) {
     return 'pnpm add'
   }
-  else if (existsSync(join(cwd, 'yarn.lock'))) {
+  if (existsSync(join(cwd, 'yarn.lock'))) {
     return 'yarn add'
   }
-  else if (existsSync(join(cwd, 'package-lock.json'))) {
+  if (existsSync(join(cwd, 'package-lock.json'))) {
     return 'npm install'
   }
-  else if (process.env.npm_config_user_agent?.includes('pnpm')) {
+  if (process.env.npm_config_user_agent?.includes('pnpm')) {
     return 'pnpm add'
   }
-  else if (process.env.npm_config_user_agent?.includes('yarn')) {
+  if (process.env.npm_config_user_agent?.includes('yarn')) {
     return 'yarn add'
   }
 
@@ -123,7 +123,7 @@ function displayResults({ missing, optional, packageName }) {
   if (missing.length === 0 && optional.length === 0) {
     console.log(`✅ nuxt-users: All dependencies found in ${packageName}!`)
   }
-  else if (missing.length === 0) {
+  if (missing.length === 0) {
     console.log(`✅ nuxt-users: All required dependencies found in ${packageName}!`)
   }
 }

package/scripts/check-translations.ts

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+import { readFileSync, readdirSync, statSync } from 'node:fs'
+import { join, relative, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const rootDir = join(__dirname, '..')
+
+interface StringMatch {
+  file: string
+  line: number
+  column: number
+  content: string
+  context: string
+}
+
+/**
+ * Recursively find all Vue files in a directory
+ */
+const findVueFiles = (dir: string, fileList: string[] = []): string[] => {
+  const files = readdirSync(dir)
+
+  for (const file of files) {
+    const filePath = join(dir, file)
+    const stat = statSync(filePath)
+
+    if (stat.isDirectory()) {
+      findVueFiles(filePath, fileList)
+      continue
+    }
+
+    if (file.endsWith('.vue')) {
+      fileList.push(filePath)
+    }
+  }
+
+  return fileList
+}
+
+/**
+ * Check if a string should be ignored (technical strings, not user-facing)
+ */
+const shouldIgnoreString = (str: string): boolean => {
+  const ignoredPatterns = [
+    /^\s*$/, // Empty or whitespace only
+    /^[a-z-]+$/, // CSS classes, HTML tags, etc. (lowercase with dashes)
+    /^\d+$/, // Numbers only
+    /^\*+$/, // Asterisks for password placeholders
+    /^[./#@]+$/, // Special chars only
+    /^\$/, // Vue/JS variables
+    /^v-/, // Vue directives
+    /^:/, // Vue bindings
+    /^@/, // Vue events
+    /^#/, // Template refs
+    /^%/, // Placeholders
+    /^\{/, // Object/template literals
+    /^\[/, // Arrays
+    /^\//, // Paths/URLs start
+    /^https?:\/\//, // URLs
+    /^\.\.?\//, // Relative paths
+    /^data-/, // Data attributes
+    /^aria-/, // ARIA attributes
+    /^role$/i, // ARIA role
+    /^id$/i, // HTML id
+    /^class$/i, // HTML class
+    /^src$/i, // HTML src
+    /^alt$/i, // HTML alt
+    /^type$/i, // HTML type
+    /^name$/i, // HTML name
+    /^for$/i, // HTML for
+    /^t$/i, // Translation function itself
+    /^useNuxtUsersLocale$/i, // Composable name
+  ]
+
+  return ignoredPatterns.some(pattern => pattern.test(str.trim()))
+}
+
+/**
+ * Extract template content from Vue file
+ */
+const extractTemplate = (content: string): string | null => {
+  const templateMatch = content.match(/<template>([\s\S]*?)<\/template>/)
+  return templateMatch ? templateMatch[1] || null : null
+}
+
+/**
+ * Find hardcoded strings in template
+ */
+const findHardcodedStrings = (template: string, filePath: string): StringMatch[] => {
+  const matches: StringMatch[] = []
+  const lines = template.split('\n')
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    if (!line) {
+      continue
+    }
+    const lineNum = i + 1
+
+    // Skip lines that already use t() function or have Vue directives/bindings
+    if (line.includes('t(') || line.includes('{{ t(') || line.includes('v-if')
+      || line.includes('v-else') || line.includes('v-for') || line.includes('v-show')
+      || line.includes('@click') || line.includes('@') || line.includes('viewBox')
+      || line.includes('<path') || line.includes('<svg')) {
+      continue
+    }
+
+    // Find strings in template interpolations {{ "string" }} or {{ 'string' }}
+    const interpolationRegex = /\{\{\s*["']([^"']+)["']\s*\}\}/g
+    let match
+    while ((match = interpolationRegex.exec(line)) !== null) {
+      const str = match[1]
+      if (str && !shouldIgnoreString(str)) {
+        matches.push({
+          file: filePath,
+          line: lineNum,
+          column: match.index + 1,
+          content: str,
+          context: line.trim()
+        })
+      }
+    }
+
+    // Find strings in attributes (but not v-bind:, :, v-on:, @)
+    // Match patterns like: attribute="string" but not :attribute="string" or @event="handler"
+    // Skip this check entirely for lines with : prefix (Vue bindings)
+    if (line.includes(':')) {
+      continue
+    }
+    const attrRegex = /(\w+)=["']([^"']+)["']/g
+    while ((match = attrRegex.exec(line)) !== null) {
+      const attrName = match[1]
+      const attrValue = match[2]
+
+      // Skip certain attributes that are typically technical
+      const technicalAttrs = ['id', 'class', 'data-', 'aria-', 'role', 'type', 'name', 'for', 'src', 'href', 'alt',
+        'viewBox', 'd', 'stroke', 'fill', 'xmlns', 'width', 'height', 'to', 'method']
+      const isTechnical = technicalAttrs.some(attr => attrName && attrName.startsWith(attr))
+
+      // Skip if value looks like a variable name, function call, or expression
+      if (/^[a-z][a-zA-Z0-9]*$/.test(attrValue || '') || attrValue?.includes('(') || attrValue?.includes('.')) {
+        continue
+      }
+
+      if (!isTechnical && attrValue && !shouldIgnoreString(attrValue) && attrValue.length > 1) {
+        matches.push({
+          file: filePath,
+          line: lineNum,
+          column: match.index + 1,
+          content: attrValue,
+          context: line.trim()
+        })
+      }
+    }
+
+    // Find text content between tags (but not inside {{ }})
+    // This is a simplified check - a full parser would be better but more complex
+    const textContentRegex = />([^<{]+)</g
+    while ((match = textContentRegex.exec(line)) !== null) {
+      const text = match[1]?.trim()
+
+      // Check if it's actual text content (contains letters and is meaningful)
+      if (text && /[a-z]{2,}/i.test(text) && !shouldIgnoreString(text)) {
+        // Skip if it's inside a comment
+        if (!line.includes('<!--') || line.indexOf('-->') < match.index) {
+          matches.push({
+            file: filePath,
+            line: lineNum,
+            column: match.index + 1,
+            content: text,
+            context: line.trim()
+          })
+        }
+      }
+    }
+  }
+
+  return matches
+}
+
+// Main execution
+const main = () => {
+  try {
+    const args = process.argv.slice(2)
+    const pathArg = args.find(arg => arg.startsWith('--path='))
+    const scanPathRelative = pathArg ? pathArg.split('=')[1] : 'src/runtime/components'
+    const scanPath = join(rootDir, scanPathRelative || '')
+
+    console.log(`[Nuxt Users] 🔍 Scanning Vue files in: ${scanPath}`)
+    console.log()
+
+    const vueFiles = findVueFiles(scanPath)
+
+    if (vueFiles.length === 0) {
+      console.log('[Nuxt Users] ⚠️  No Vue files found in the specified path')
+      return
+    }
+
+    console.log(`[Nuxt Users] 📄 Found ${vueFiles.length} Vue file(s)`)
+    console.log()
+
+    let totalMatches = 0
+    const fileResults: Record<string, StringMatch[]> = {}
+
+    for (const filePath of vueFiles) {
+      const content = readFileSync(filePath, 'utf8')
+      const template = extractTemplate(content)
+
+      if (!template) {
+        continue
+      }
+
+      const matches = findHardcodedStrings(template, filePath)
+
+      if (matches.length > 0) {
+        const relativePath = relative(rootDir, filePath)
+        fileResults[relativePath] = matches
+        totalMatches += matches.length
+      }
+    }
+
+    if (totalMatches === 0) {
+      console.log('[Nuxt Users] ✅ No hardcoded strings found! All strings appear to use t()')
+      console.log()
+      return
+    }
+
+    console.log(`[Nuxt Users] ⚠️  Found ${totalMatches} potential hardcoded string(s):\n`)
+
+    for (const [file, matches] of Object.entries(fileResults)) {
+      console.log(`📁 ${file}`)
+
+      for (const match of matches) {
+        console.log(`   Line ${match.line}:${match.column}`)
+        console.log(`   String: "${match.content}"`)
+        console.log(`   Context: ${match.context}`)
+        console.log()
+      }
+    }
+
+    console.log('[Nuxt Users] 💡 Tip: Replace hardcoded strings with t() function from useNuxtUsersLocale()')
+    console.log('[Nuxt Users] Example: "Login" → {{ t(\'login.submit\') }}')
+    console.log()
+
+    // Exit with error code if hardcoded strings found
+    process.exit(1)
+  }
+  catch (error) {
+    console.error('[Nuxt Users] ❌ Error:', error instanceof Error ? error.message : 'Unknown error')
+    process.exit(1)
+  }
+}
+
+main()

package/scripts/post-build.js

@@ -44,7 +44,7 @@ function fixImportPaths(dir) {
     if (item.isDirectory()) {
       fixImportPaths(fullPath)
     }
-    else if (item.isFile() && (item.name.endsWith('.js') || item.name.endsWith('.mjs') || item.name.endsWith('.vue') || item.name.endsWith('.ts'))) {
+    if (item.isFile() && (item.name.endsWith('.js') || item.name.endsWith('.mjs') || item.name.endsWith('.vue') || item.name.endsWith('.ts'))) {
       let content = readFileSync(fullPath, 'utf8')
       let modified = false
 

package/scripts/test-nuxt3.sh

@@ -0,0 +1,78 @@
+#!/bin/bash
+
+# Nuxt 3 Local Test Runner
+# This script temporarily installs Nuxt 3, runs the specified test,
+# and then restores the original Nuxt 4 dependencies.
+
+set -e
+
+# --- Configuration ---
+NUXT3_VERSION="^3.17.6"
+TEST_TYPE=$1
+
+# --- Colors for output ---
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+# --- Helper functions ---
+print_status() {
+    echo -e "${BLUE}$1${NC}"
+}
+
+print_error() {
+    echo -e "${RED}❌ $1${NC}"
+}
+
+print_success() {
+    echo -e "${GREEN}✅ $1${NC}"
+}
+
+# --- Cleanup function ---
+cleanup() {
+    print_status "🧹 Restoring original dependencies..."
+    if [ -f "package.json.bak" ]; then
+        mv package.json.bak package.json
+    fi
+    if [ -f "yarn.lock.bak" ]; then
+        mv yarn.lock.bak yarn.lock
+    fi
+    npx nypm@latest i
+    print_success "Dependencies restored to Nuxt 4."
+}
+
+# --- Main script ---
+
+# 1. Validate input
+if [ -z "$TEST_TYPE" ]; then
+    print_error "Usage: ./scripts/test-nuxt3.sh [sqlite|mysql|postgresql|unit|integration]"
+    exit 1
+fi
+
+# 2. Set up cleanup trap
+trap cleanup EXIT
+
+# 3. Backup original package files
+print_status "📦 Backing up package files..."
+cp package.json package.json.bak
+cp yarn.lock yarn.lock.bak
+
+# 4. Install Nuxt 3
+print_status "🚀 Installing Nuxt v3 (version: ${NUXT3_VERSION})..."
+npx nypm@latest i nuxt@${NUXT3_VERSION}
+print_success "Nuxt 3 installed."
+
+# 5. Run the specified test
+print_status "🧪 Running tests for '$TEST_TYPE' against Nuxt 3..."
+if [ -f "scripts/test-${TEST_TYPE}.sh" ]; then
+    "./scripts/test-${TEST_TYPE}.sh"
+else
+    print_error "Invalid test type '$TEST_TYPE'. No script found at scripts/test-${TEST_TYPE}.sh"
+    exit 1
+fi
+
+print_success "Nuxt 3 tests completed successfully!"
+
+# 6. Cleanup will be handled by the trap
+exit 0