packages/kit/src/build.ts (2)

9-10: Consider renaming Thenable<T> to avoid confusion.

In JavaScript/TypeScript terminology, "thenable" typically refers to objects implementing a .then() method (duck-typed promises), not a union of T | Promise<T>. Consider using MaybePromise<T> or Awaitable<T> for better clarity.

Apply this diff to improve the type name:

-type Thenable<T> = T | Promise<T>
+type MaybePromise<T> = T | Promise<T>

Then update all usages of Thenable to MaybePromise throughout the file.

---

157-209: Consider caching the plugin resolution result.

The plugin factory is invoked twice—at line 171 in the vite:extend hook and at line 200 in the vite:extendConfig hook. Whilst dynamic imports are cached by the module system, if the factory creates new plugin instances or has side effects, these will occur twice. Consider caching the result after the first resolution to ensure consistent behaviour and avoid unnecessary work.

 export function addVitePlugin (pluginOrGetter: Arrayable<VitePlugin> | (() => Thenable<Arrayable<VitePlugin>>), options: ExtendConfigOptions = {}): void {
   const nuxt = useNuxt()
 
   if (options.dev === false && nuxt.options.dev) {
     return
   }
   if (options.build === false && nuxt.options.build) {
     return
   }
 
+  let cachedPlugin: VitePlugin[] | undefined
+  async function getPlugin() {
+    if (!cachedPlugin) {
+      cachedPlugin = toArray(typeof pluginOrGetter === 'function' ? await pluginOrGetter() : pluginOrGetter)
+    }
+    return cachedPlugin
+  }
+
   let needsEnvInjection = false
   nuxt.hook('vite:extend', async ({ config }) => {
     config.plugins ||= []
 
-    const plugin = toArray(typeof pluginOrGetter === 'function' ? await pluginOrGetter() : pluginOrGetter)
+    const plugin = await getPlugin()
     if (options.server !== false && options.client !== false) {
       const method: 'push' | 'unshift' = options?.prepend ? 'unshift' : 'push'
       config.plugins[method](...plugin)
       return
     }
 
     if (!config.environments?.ssr || !config.environments.client) {
       needsEnvInjection = true
       return
     }
 
     const environmentName = options.server === false ? 'client' : 'ssr'
     const pluginName = plugin.map(p => p.name).join('|')
     config.plugins.push({
       name: `${pluginName}:wrapper`,
       enforce: options?.prepend ? 'pre' : 'post',
       applyToEnvironment (environment) {
         if (environment.name === environmentName) {
           return plugin
         }
       },
     })
   })
 
   nuxt.hook('vite:extendConfig', async (config, env) => {
     if (!needsEnvInjection) {
       return
     }
-    const plugin = toArray(typeof pluginOrGetter === 'function' ? await pluginOrGetter() : pluginOrGetter)
+    const plugin = await getPlugin()
     const method: 'push' | 'unshift' = options?.prepend ? 'unshift' : 'push'
     if (env.isClient && options.server === false) {
       config.plugins![method](...plugin)
     }
     if (env.isServer && options.client === false) {
       config.plugins![method](...plugin)
     }
   })
 }

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: GalacticHypernova
Repo: nuxt/nuxt PR: 29661
File: packages/kit/src/template.ts:227-229
Timestamp: 2024-11-28T21:22:40.496Z
Learning: In `packages/kit/src/template.ts`, when updating the `EXTENSION_RE` regular expression for TypeScript configuration, avoid using patterns like `(\.\w+)+$` as they can result in catastrophic backtracking.