nuxt-users 1.37.3 → 1.39.0

package/dist/utils.d.ts

@@ -1,4 +1,7 @@
-export { g as DatabaseConfig, f as DatabaseType, D as DisplayFieldsProps, G as GoogleOAuthOptions, L as LoginFormData, c as LoginFormProps, M as ModuleOptions, b as PasswordResetToken, e as Permission, P as PersonalAccessToken, d as ResetPasswordFormProps, R as RuntimeModuleOptions, U as User, a as UserWithoutPassword, h as defaultDisplayFields, i as defaultFieldLabels } from './shared/nuxt-users.SXaMnaEL.js';
+export { defaultLocaleMessages, en, hu, huFormal } from '../dist/runtime/locales/index.js';
+export { getNestedValue, getTranslation } from '../dist/runtime/utils/locale.js';
+export { deepMerge } from '../dist/runtime/utils/deep-merge.js';
+export { g as DatabaseConfig, f as DatabaseType, D as DisplayFieldsProps, G as GoogleOAuthOptions, i as LocaleMessages, h as LocaleOptions, L as LoginFormData, c as LoginFormProps, M as ModuleOptions, b as PasswordResetToken, e as Permission, P as PersonalAccessToken, d as ResetPasswordFormProps, R as RuntimeModuleOptions, U as User, a as UserWithoutPassword, j as defaultDisplayFields, k as defaultFieldLabels } from './shared/nuxt-users.FiQjvlZl.js';
 
 interface PasswordValidationResult {
     isValid: boolean;

package/dist/utils.mjs

@@ -1,4 +1,7 @@
-export { a as getPasswordStrengthColor, b as getPasswordStrengthText, g as getPasswordValidationOptions, v as validatePassword } from './shared/nuxt-users.BnOQs2LI.mjs';
+export { a as getPasswordStrengthColor, b as getPasswordStrengthText, g as getPasswordValidationOptions, v as validatePassword } from './shared/nuxt-users.DfZ7bc_P.mjs';
+export { defaultLocaleMessages, en, hu, huFormal } from '../dist/runtime/locales/index.js';
+export { getNestedValue, getTranslation } from '../dist/runtime/utils/locale.js';
+export { deepMerge } from '../dist/runtime/utils/deep-merge.js';
 
 const defaultDisplayFields = ["id", "name", "email", "role", "active", "created_at", "updated_at", "last_login_at"];
 const defaultFieldLabels = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-users",
-  "version": "1.37.3",
+  "version": "1.39.0",
   "description": "A comprehensive user management module for Nuxt 3 and Nuxt 4 applications with authentication, authorization, database support, and CLI tools",
   "keywords": [
     "nuxt",
@@ -62,8 +62,10 @@
     "dev:prepare": "yarn nuxt-module-build build --stub && yarn nuxt-module-build prepare && nuxi prepare playground",
     "build": "nuxt-module-build build",
     "postbuild": "node scripts/post-build.js",
+    "check:translations": "tsx scripts/check-translations.ts",
+    "check:locale-consistency": "tsx scripts/check-locale-consistency.ts",
     "prerelease": "node -v | grep -q 'v22' || (echo 'Please use Node.js v22 for deployment' && exit 1)",
-    "release": "yarn lint && yarn test && yarn prepack && changelogen --release && yarn publish && git push --follow-tags",
+    "release": "yarn lint && yarn check:translations && yarn check:locale-consistency && yarn test && yarn prepack && changelogen --release && npm publish && git push --follow-tags",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "pretest": "node -v | grep -q 'v22' || (echo 'Please use Node.js v22 for testing' && exit 1)",
@@ -121,7 +123,7 @@
     "@nuxt/test-utils": "^3.19.2",
     "@nuxt/vite-builder": "^4.2.0",
     "@types/bcrypt": "^6.0.0",
-    "@types/node": "latest",
+    "@types/node": "^25.0.3",
     "@types/nodemailer": "^6.4.17",
     "@types/pg": "^8.15.4",
     "changelogen": "^0.6.2",

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/dist/runtime/plugin.client.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
-export default _default;

package/dist/runtime/plugin.client.js

@@ -1,6 +0,0 @@
-import { defineNuxtPlugin } from "#app";
-import { useAuthentication } from "./composables/useAuthentication.js";
-export default defineNuxtPlugin(async () => {
-  const { initializeUser } = useAuthentication();
-  await initializeUser();
-});