fix(nuxt): auto imports regeneration timing

packages/nuxt/src/core/app.ts

@@ -40,15 +40,20 @@
     .filter(template => !options.filter || options.filter(template))
 
   const writes: Array<() => void> = []
-  await Promise.allSettled(filteredTemplates
+  const result = await Promise.allSettled(filteredTemplates
     .map(async (template) => {
       const fullPath = template.dst || resolve(nuxt.options.buildDir, template.filename!)
+      const oldContents = nuxt.vfs[fullPath]
       const mark = performance.mark(fullPath)
       const contents = await compileTemplate(template, templateContext).catch((e) => {
         logger.error(`Could not compile template \`${template.filename}\`.`)
         throw e
       })
 
+      if (oldContents === contents) {
+        return false
+      }
+
       nuxt.vfs[fullPath] = contents
 
       const aliasPath = '#build/' + template.filename!.replace(/\.\w+$/, '')
@@ -72,13 +77,18 @@
           writeFileSync(fullPath, contents, 'utf8')
         })
       }
+
+      return true
     }))
 
   // Write template files in single synchronous step to avoid (possible) additional
   // runtime overhead of cascading HMRs from vite/webpack
   for (const write of writes) { write() }
 
-  await nuxt.callHook('app:templatesGenerated', app, filteredTemplates, options)
+  const anyTemplateUpdated = result.some(r => r.status === 'fulfilled' && r.value)
+  if (anyTemplateUpdated) {
+    await nuxt.callHook('app:templatesGenerated', app, filteredTemplates, options)
+  }
 }
 
 /** @internal */
@@ -225,7 +235,7 @@
   for (const plugin of _plugins) {
     // Make sure dependency plugins are registered
     if (plugin.dependsOn && plugin.dependsOn.some(name => !pluginNames.includes(name))) {
       console.error(`Plugin \`${plugin.name}\` depends on \`${plugin.dependsOn.filter(name => !pluginNames.includes(name)).join(', ')}\` but they are not registered.`)
     }
     // Make graph to detect circular dependencies
     if (plugin.name) {
@@ -234,7 +244,7 @@
   }
   const checkDeps = (name: string, visited: string[] = []): string[] => {
     if (visited.includes(name)) {
       console.error(`Circular dependency detected in plugins: ${visited.join(' -> ')} -> ${name}`)
       return []
     }
     visited.push(name)

packages/nuxt/src/imports/module.ts

@@ -3,7 +3,7 @@ import { addTemplate, addVitePlugin, addWebpackPlugin, defineNuxtModule, isIgnor
 import { isAbsolute, join, normalize, relative, resolve } from 'pathe'
 import type { Import, Unimport } from 'unimport'
 import { createUnimport, scanDirExports, toExports } from 'unimport'
-import type { ImportPresetWithDeprecation, ImportsOptions } from 'nuxt/schema'
+import type { ImportPresetWithDeprecation, ImportsOptions, ResolvedNuxtTemplate } from 'nuxt/schema'
 
 import { lookupNodeModuleSubpath, parseNodeModulePath } from 'mlly'
 import { isDirectory } from '../utils'
@@ -89,6 +89,14 @@ export default defineNuxtModule<Partial<ImportsOptions>>({
 
     const priorities = nuxt.options._layers.map((layer, i) => [layer.config.srcDir, -i] as const).sort(([a], [b]) => b.length - a.length)
 
+    function isImportsTemplate (template: ResolvedNuxtTemplate) {
+      return [
+        '/types/imports.d.ts',
+        '/imports.d.ts',
+        '/imports.mjs'
+      ].some(i => template.filename.endsWith(i))
+    }
+
     const regenerateImports = async () => {
       await ctx.modifyDynamicImports(async (imports) => {
         // Clear old imports
@@ -105,6 +113,10 @@ export default defineNuxtModule<Partial<ImportsOptions>>({
         await nuxt.callHook('imports:extend', imports)
         return imports
       })
+
+      await updateTemplates({
+        filter: isImportsTemplate
+      })
     }
 
     await regenerateImports()
@@ -119,22 +131,20 @@ export default defineNuxtModule<Partial<ImportsOptions>>({
     })
 
     // Watch composables/ directory
-    const templates = [
-      'types/imports.d.ts',
-      'imports.d.ts',
-      'imports.mjs'
-    ]
     nuxt.hook('builder:watch', async (_, relativePath) => {
       const path = resolve(nuxt.options.srcDir, relativePath)
       if (composablesDirs.some(dir => dir === path || path.startsWith(dir + '/'))) {
-        await updateTemplates({
-          filter: template => templates.includes(template.filename)
-        })
+        await regenerateImports()
       }
     })
 
-    nuxt.hook('app:templatesGenerated', async () => {
-      await regenerateImports()
+    // Watch for template generation
+    nuxt.hook('app:templatesGenerated', async (_app, templates) => {
+      // Filter out templates of imports to avoid circular regeneration
+      const nonDtsTemplates = templates.filter(t => !isImportsTemplate(t))
+      if (nonDtsTemplates.length) {
+        await regenerateImports()
+      }
     })
   }
 })