refactor(utils): enhance isNuxtProject checks with directory traversal and plugin validation

- Extract helper functions for modularity: `hasNuxtDependency`, `hasNuxtConfigFile`, and `walkUpDirs`.
- Add support for detecting Nuxt projects via plugins and ancestor directories.

Author: z0ffy

src/__tests__/plugin.spec.ts

@@ -1,5 +1,8 @@
 import {expect, describe, it, vi, beforeEach, afterEach} from "vitest";
 import type {Rollup, Plugin} from 'vite';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 
 import {
   formatTime,
@@ -587,13 +590,54 @@ describe('is utils - additional tests', () => {
   });
 
   describe('isNuxtProject', () => {
+    const mkTmp = () => mkdtempSync(join(tmpdir(), 'vite-bundle-obfuscator-'));
+
+    const writePackageJson = (root: string, pkg: any) => {
+      writeFileSync(join(root, 'package.json'), JSON.stringify(pkg), 'utf-8');
+    };
+
     it('should return false for non-nuxt project', () => {
       expect(isNuxtProject({root: process.cwd()})).toBe(false);
     });
 
     it('should use process.cwd() when root is not provided', () => {
       expect(isNuxtProject({})).toBe(false);
     });
+
+    it('should return true when package.json depends on nuxt', () => {
+      const root = mkTmp();
+      try {
+        writePackageJson(root, { dependencies: { nuxt: '^3.0.0' } });
+        expect(isNuxtProject({root})).toBe(true);
+      } finally {
+        rmSync(root, { recursive: true, force: true });
+      }
+    });
+
+    it('should return true when nuxt.config exists', () => {
+      const root = mkTmp();
+      try {
+        writeFileSync(join(root, 'nuxt.config.ts'), 'export default {}', 'utf-8');
+        expect(isNuxtProject({root})).toBe(true);
+      } finally {
+        rmSync(root, { recursive: true, force: true });
+      }
+    });
+
+    it('should detect nuxt when root points inside .nuxt directory', () => {
+      const root = mkTmp();
+      try {
+        writePackageJson(root, { devDependencies: { nuxt: '^3.0.0' } });
+        mkdirSync(join(root, '.nuxt'), { recursive: true });
+        expect(isNuxtProject({root: join(root, '.nuxt')})).toBe(true);
+      } finally {
+        rmSync(root, { recursive: true, force: true });
+      }
+    });
+
+    it('should return true when nuxt plugin is present', () => {
+      expect(isNuxtProject({ plugins: [{ name: 'nuxt:config' }] } as any)).toBe(true);
+    });
   });
 });
 
@@ -1070,4 +1114,3 @@ describe('viteBundleObfuscator plugin', () => {
     });
   });
 });
-

src/utils/is.ts

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
+import { dirname, resolve } from 'node:path';
 
 const { toString } = Object.prototype;
 
@@ -57,26 +57,54 @@ export function isLibMode(config: { build?: { lib?: any } }): boolean {
   return !!config.build?.lib;
 }
 
-export function isNuxtProject(config: { root?: string }): boolean {
-  const root = config.root || process.cwd();
-  const packageJsonPath = resolve(root, 'package.json');
-
-  if (existsSync(packageJsonPath)) {
-    try {
-      const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-      const dependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
-      if (dependencies.nuxt) return true;
-    } catch {
-      /* empty */
-    }
+function hasNuxtDependency(packageJsonPath: string): boolean {
+  if (!existsSync(packageJsonPath)) return false;
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    const dependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    return !!dependencies?.nuxt;
+  } catch {
+    return false;
   }
+}
 
-  const nuxtPaths = [
+function hasNuxtConfigFile(root: string): boolean {
+  return [
     resolve(root, 'nuxt.config.js'),
     resolve(root, 'nuxt.config.ts'),
-    resolve(root, '.nuxt'),
-    resolve(root, '.output'),
-  ];
+    resolve(root, 'nuxt.config.mjs'),
+    resolve(root, 'nuxt.config.cjs'),
+  ].some(p => existsSync(p));
+}
+
+function* walkUpDirs(startDir: string): Generator<string> {
+  let current = startDir;
+  while (true) {
+    yield current;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+}
+
+function hasNuxtPlugins(config: any): boolean {
+  const plugins = config?.plugins;
+  if (!Array.isArray(plugins)) return false;
+  return plugins.some(p => typeof p?.name === 'string' && (p.name === 'nuxt' || p.name.startsWith('nuxt:')));
+}
+
+export function isNuxtProject(config: { root?: string; plugins?: any } = {}): boolean {
+  if (hasNuxtPlugins(config)) return true;
 
-  return nuxtPaths.some(path => existsSync(path));
+  const startDir = config.root || process.cwd();
+
+  for (const dir of walkUpDirs(startDir)) {
+    if (hasNuxtConfigFile(dir)) return true;
+    const packageJsonPath = resolve(dir, 'package.json');
+    if (existsSync(packageJsonPath)) {
+      return hasNuxtDependency(packageJsonPath);
+    }
+  }
+
+  return false;
 }