@immense/vue-pom-generator 1.0.51 → 1.0.53

package/dist/index.mjs

@@ -1,7 +1,8 @@
+import fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
+import { createRequire } from "node:module";
 import { pathToFileURL, fileURLToPath } from "node:url";
-import fs from "node:fs";
 import * as compilerDom from "@vue/compiler-dom";
 import { parse as parse$2, NodeTypes as NodeTypes$1 } from "@vue/compiler-dom";
 import { parse as parse$1, compileScript } from "@vue/compiler-sfc";
@@ -63,6 +64,133 @@ function createLogger(options) {
     }
   };
 }
+const requireFromModule = createRequire(import.meta.url);
+function toUniqueResolvedPaths(paths) {
+  return Array.from(new Set(paths.map((value) => path.resolve(value))));
+}
+function resolveNuxtAlias(value, context) {
+  const aliases = [
+    ["~~", context.rootDir],
+    ["@@", context.rootDir],
+    ["~/", `${context.srcDir}${path.sep}`],
+    ["@/", `${context.srcDir}${path.sep}`],
+    ["~", context.srcDir],
+    ["@", context.srcDir]
+  ];
+  for (const [alias, replacement] of Object.entries(context.alias ?? {})) {
+    aliases.push([alias, replacement]);
+  }
+  aliases.sort((a, b) => b[0].length - a[0].length);
+  for (const [alias, replacement] of aliases) {
+    if (value === alias)
+      return replacement;
+    if (value.startsWith(`${alias}/`) || value.startsWith(`${alias}${path.sep}`)) {
+      const suffix = value.slice(alias.length + 1);
+      return path.resolve(replacement, suffix);
+    }
+  }
+  return value;
+}
+function resolveNuxtPath(value, baseDir, context) {
+  const resolvedAlias = resolveNuxtAlias(value, context);
+  return path.isAbsolute(resolvedAlias) ? path.resolve(resolvedAlias) : path.resolve(baseDir, resolvedAlias);
+}
+function normalizeNuxtComponentDirs(value, baseDir, context) {
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => normalizeNuxtComponentDirs(entry, baseDir, context));
+  }
+  if (value === false) {
+    return [];
+  }
+  if (value === true || value === void 0) {
+    return [
+      path.resolve(baseDir, "components/islands"),
+      path.resolve(baseDir, "components/global"),
+      path.resolve(baseDir, "components")
+    ];
+  }
+  if (typeof value === "string") {
+    return [resolveNuxtPath(value, baseDir, context)];
+  }
+  if (!value || typeof value !== "object") {
+    return [];
+  }
+  if (typeof value === "object" && value && "path" in value && typeof value.path === "string") {
+    return [resolveNuxtPath(value.path, baseDir, context)];
+  }
+  if (typeof value !== "object" || !value || !("dirs" in value)) {
+    return [];
+  }
+  return normalizeNuxtComponentDirs(value.dirs, baseDir, context);
+}
+function resolveNuxtProjectDiscovery(nuxtOptions, getLayerDirectories, cwd = process.cwd()) {
+  const rootDir = path.resolve(nuxtOptions.rootDir ?? cwd);
+  const srcDir = path.resolve(nuxtOptions.srcDir ?? rootDir);
+  const fallbackLayer = {
+    cwd: rootDir,
+    config: {
+      rootDir,
+      srcDir,
+      dir: nuxtOptions.dir,
+      components: nuxtOptions.components,
+      alias: nuxtOptions.alias
+    }
+  };
+  const layers = nuxtOptions._layers?.length ? nuxtOptions._layers : [fallbackLayer];
+  const normalizedNuxtOptions = {
+    ...nuxtOptions,
+    _layers: layers
+  };
+  const layerDirectories = getLayerDirectories({ options: normalizedNuxtOptions });
+  const pageDirs = layerDirectories.map((layer) => layer.appPages);
+  const layoutDirs = layerDirectories.map((layer) => layer.appLayouts);
+  const componentDirs = [];
+  for (const [index, layer] of layers.entries()) {
+    const layerDirectory = layerDirectories[index];
+    const layerRootDir = path.resolve(layerDirectory?.root ?? layer.config?.rootDir ?? layer.cwd ?? rootDir);
+    const layerSrcDir = path.resolve(layerDirectory?.app ?? layer.config?.srcDir ?? layer.cwd ?? srcDir);
+    const context = {
+      rootDir: layerRootDir,
+      srcDir: layerSrcDir,
+      alias: {
+        ...nuxtOptions.alias ?? {},
+        ...layer.config?.alias ?? {}
+      }
+    };
+    componentDirs.push(...normalizeNuxtComponentDirs(layer.config?.components, layerSrcDir, context));
+  }
+  const uniquePageDirs = toUniqueResolvedPaths(pageDirs);
+  const uniqueLayoutDirs = toUniqueResolvedPaths(layoutDirs);
+  const uniqueComponentDirs = toUniqueResolvedPaths(componentDirs);
+  return {
+    rootDir,
+    srcDir,
+    pageDirs: uniquePageDirs,
+    layoutDirs: uniqueLayoutDirs,
+    componentDirs: uniqueComponentDirs,
+    wrapperSearchRoots: []
+  };
+}
+async function loadNuxtProjectDiscovery(cwd = process.cwd()) {
+  let loadNuxtConfig;
+  let getLayerDirectories;
+  try {
+    const nuxtKitEntry = requireFromModule.resolve("@nuxt/kit");
+    ({ loadNuxtConfig, getLayerDirectories } = await import(pathToFileURL(nuxtKitEntry).href));
+  } catch (error) {
+    throw new TypeError(
+      `[vue-pom-generator] Nuxt mode requires @nuxt/kit to be available so Nuxt directories can be resolved from nuxt.config. ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (typeof loadNuxtConfig !== "function") {
+    throw new TypeError("[vue-pom-generator] Nuxt mode requires @nuxt/kit.loadNuxtConfig().");
+  }
+  if (typeof getLayerDirectories !== "function") {
+    throw new TypeError("[vue-pom-generator] Nuxt mode requires @nuxt/kit.getLayerDirectories().");
+  }
+  const nuxtOptions = await loadNuxtConfig({ cwd });
+  return resolveNuxtProjectDiscovery(nuxtOptions, getLayerDirectories, cwd);
+}
 function createTypeScriptProject() {
   return new Project({
     useInMemoryFileSystem: true,
@@ -728,7 +856,14 @@ function getTemplateSlotScope(node) {
   return null;
 }
 function isSimpleScopeIdentifier(value) {
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value);
+  if (!value) {
+    return false;
+  }
+  try {
+    return isIdentifier(parseExpression(value, { plugins: ["typescript"] }));
+  } catch {
+    return false;
+  }
 }
 function buildSlotScopeFallbackKeyExpression(identifier) {
   return `${identifier}.key ?? ${identifier}.data?.id ?? ${identifier}.id ?? ${identifier}.value ?? ${identifier}`;
@@ -748,6 +883,29 @@ function tryGetBindingIdentifierName(node) {
   }
   return null;
 }
+function splitNullishCoalescingExpression(expr) {
+  const ast = parseExpression(expr, { plugins: ["typescript"] });
+  const toSourceText = (node) => {
+    if (node.start == null || node.end == null) {
+      throw new Error("[vue-pom-generator] Unable to recover source for nullish-coalescing expression.");
+    }
+    return expr.slice(node.start, node.end).trim();
+  };
+  const parts = [];
+  const visit = (node) => {
+    if (isLogicalExpression(node) && node.operator === "??") {
+      visit(node.left);
+      visit(node.right);
+      return;
+    }
+    const candidate = toSourceText(node);
+    if (candidate) {
+      parts.push(candidate);
+    }
+  };
+  visit(ast);
+  return parts;
+}
 function getSlotScopeObjectPropertyKeyName(node) {
   if (isIdentifier(node)) {
     return node.name;
@@ -2004,7 +2162,7 @@ function applyResolvedDataTestId(args) {
     if (!expr) {
       return [];
     }
-    return expr.split("??").map((part) => part.trim()).filter(Boolean);
+    return splitNullishCoalescingExpression(expr);
   };
   let dataTestId = args.preferredGeneratedValue;
   let fromExisting = false;
@@ -2725,27 +2883,24 @@ function safeRealpath(value) {
   const resolvedParent = safeRealpath(parent);
   return resolvedParent === parent ? value : path.join(resolvedParent, path.basename(value));
 }
+function isPathWithinDir(filePathAbs, dirPathAbs) {
+  const fileAbs = path.resolve(filePathAbs);
+  const dirAbs = path.resolve(dirPathAbs);
+  const rel = path.relative(dirAbs, fileAbs);
+  if (!rel)
+    return true;
+  return !rel.startsWith("..") && !path.isAbsolute(rel);
+}
 function resolveComponentNameFromPath(options) {
-  const { projectRoot, viewsDirAbs, scanDirs, extraRoots = [] } = options;
+  const { projectRoot, viewsDirAbs, sourceDirs, extraRoots = [] } = options;
   const cleanFilename = options.filename.includes("?") ? options.filename.substring(0, options.filename.indexOf("?")) : options.filename;
   const absFilename = path.isAbsolute(cleanFilename) ? cleanFilename : path.resolve(projectRoot, cleanFilename);
   const normalizedAbsFilename = path.normalize(safeRealpath(absFilename));
   const rootBases = [projectRoot, ...extraRoots.filter((r) => r !== projectRoot)];
-  const roots = [viewsDirAbs, ...rootBases.flatMap((base) => scanDirs.map((d) => path.resolve(base, d)))];
-  for (const base of rootBases) {
-    for (const dir of scanDirs) {
-      const absDir = path.resolve(base, dir);
-      try {
-        const pagesDir = path.join(absDir, "pages");
-        if (fs.existsSync(pagesDir))
-          roots.push(pagesDir);
-        const componentsDir = path.join(absDir, "components");
-        if (fs.existsSync(componentsDir))
-          roots.push(componentsDir);
-      } catch {
-      }
-    }
-  }
+  const roots = [
+    viewsDirAbs,
+    ...sourceDirs.flatMap((dir) => path.isAbsolute(dir) ? [dir] : rootBases.map((base) => path.resolve(base, dir)))
+  ];
   const potentialRoots = Array.from(new Set(roots.map((r) => path.normalize(safeRealpath(r))))).sort((a, b) => b.length - a.length);
   for (const root of potentialRoots) {
     if (normalizedAbsFilename.startsWith(root + path.sep) || normalizedAbsFilename === root) {
@@ -3109,7 +3264,7 @@ function resolveIntrospectedComponentName(componentInfo, componentNaming) {
       filename: componentInfo.filePath,
       projectRoot: componentNaming.projectRoot,
       viewsDirAbs: componentNaming.viewsDirAbs,
-      scanDirs: componentNaming.scanDirs,
+      sourceDirs: componentNaming.sourceDirs,
       extraRoots: componentNaming.extraRoots
     });
   }
@@ -3221,69 +3376,97 @@ async function ensureDomShim() {
   if (!g.requestAnimationFrame)
     g.requestAnimationFrame = (cb) => setTimeout(() => cb(Date.now()), 16);
 }
-async function introspectNuxtPages(projectRoot) {
-  const possiblePagesDirs = ["app/pages", "pages"];
-  let pagesDir = "";
-  for (const dir of possiblePagesDirs) {
-    const abs = path.resolve(projectRoot, dir);
-    if (fs.existsSync(abs) && fs.statSync(abs).isDirectory()) {
-      pagesDir = abs;
+function unwrapNuxtPageSegment(segment, prefix, suffix) {
+  if (!segment.startsWith(prefix) || !segment.endsWith(suffix))
+    return null;
+  const value = segment.slice(prefix.length, segment.length - suffix.length);
+  return value.length > 0 ? value : null;
+}
+function resolveNuxtPageSegment(segment) {
+  if (segment === "index") {
+    return { pathPart: "", params: [] };
+  }
+  const optionalParamName = unwrapNuxtPageSegment(segment, "[[", "]]");
+  if (optionalParamName) {
+    return {
+      pathPart: `:${optionalParamName}?`,
+      params: [{ name: optionalParamName, optional: true }]
+    };
+  }
+  const catchAllParamName = unwrapNuxtPageSegment(segment, "[...", "]");
+  if (catchAllParamName) {
+    return {
+      pathPart: `:${catchAllParamName}(.*)*`,
+      params: [{ name: catchAllParamName, optional: false }]
+    };
+  }
+  const requiredParamName = unwrapNuxtPageSegment(segment, "[", "]");
+  if (requiredParamName) {
+    return {
+      pathPart: `:${requiredParamName}`,
+      params: [{ name: requiredParamName, optional: false }]
+    };
+  }
+  return { pathPart: segment, params: [] };
+}
+function toPathSegments(value) {
+  const segments = [];
+  let current = path.normalize(value);
+  while (current && current !== "." && current !== path.sep) {
+    const parsed = path.parse(current);
+    if (!parsed.base || parsed.base === ".")
       break;
-    }
+    segments.unshift(parsed.base);
+    if (!parsed.dir || parsed.dir === "." || parsed.dir === current)
+      break;
+    current = parsed.dir;
   }
-  if (!pagesDir) {
+  return segments;
+}
+async function introspectNuxtPages(projectRoot, options = {}) {
+  const possiblePageDirs = options.pageDirs?.length ? options.pageDirs : ["app/pages", "pages"].map((dir) => path.resolve(projectRoot, dir));
+  const pageDirs = possiblePageDirs.map((dir) => path.resolve(projectRoot, dir)).filter((dir) => {
+    try {
+      return fs.existsSync(dir) && fs.statSync(dir).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+  if (!pageDirs.length) {
     debugLog(`[router-introspection][nuxt] Could not find pages directory in ${projectRoot}`);
     return { routeNameMap: /* @__PURE__ */ new Map(), routePathMap: /* @__PURE__ */ new Map(), routeMetaEntries: [] };
   }
+  const routePathMap = /* @__PURE__ */ new Map();
   const routeMetaEntries = [];
-  const walk = (dir, baseRoute) => {
+  const walk = (pagesDir, dir) => {
     const files = fs.readdirSync(dir);
     for (const file of files) {
       const fullPath = path.join(dir, file);
       const stat = fs.statSync(fullPath);
       if (stat.isDirectory()) {
-        walk(fullPath, `${baseRoute}/${file}`);
+        walk(pagesDir, fullPath);
         continue;
       }
       if (!file.endsWith(".vue"))
         continue;
-      const componentName = file.slice(0, -4);
-      if (componentName === "index" && baseRoute === "") {
-        routeMetaEntries.push({
-          componentName: "index",
-          pathTemplate: "/",
-          params: [],
-          query: []
-        });
-        continue;
-      }
-      let routePath = componentName === "index" ? baseRoute : `${baseRoute}/${componentName}`;
-      if (!routePath.startsWith("/"))
-        routePath = `/${routePath}`;
+      const componentName = resolveComponentNameFromPath({
+        filename: fullPath,
+        projectRoot,
+        viewsDirAbs: pagesDir,
+        sourceDirs: [pagesDir],
+        extraRoots: [process.cwd()]
+      });
+      const relativePath = path.relative(pagesDir, fullPath);
+      const parsed = path.parse(relativePath);
+      const routeSegments = toPathSegments(path.join(parsed.dir, parsed.name));
       const params = [];
-      let pathTemplate = "";
-      for (let i = 0; i < routePath.length; i++) {
-        const ch = routePath[i];
-        if (ch !== "[") {
-          pathTemplate += ch;
-          continue;
-        }
-        let name = "";
-        i++;
-        while (i < routePath.length) {
-          const c = routePath[i];
-          if (c === "]")
-            break;
-          name += c;
-          i++;
-        }
-        if (name) {
-          params.push({ name, optional: false });
-          pathTemplate += `:${name}`;
-        } else {
-          pathTemplate += "[]";
-        }
-      }
+      const pathParts = routeSegments.flatMap((segment) => {
+        const resolution = resolveNuxtPageSegment(segment);
+        params.push(...resolution.params);
+        return resolution.pathPart ? [resolution.pathPart] : [];
+      });
+      const pathTemplate = pathParts.length ? `/${pathParts.join("/")}` : "/";
+      routePathMap.set(pathTemplate, componentName);
       routeMetaEntries.push({
         componentName,
         pathTemplate,
@@ -3292,10 +3475,12 @@ async function introspectNuxtPages(projectRoot) {
       });
     }
   };
-  walk(pagesDir, "");
+  for (const pageDir of pageDirs) {
+    walk(pageDir, pageDir);
+  }
   return {
     routeNameMap: /* @__PURE__ */ new Map(),
-    routePathMap: /* @__PURE__ */ new Map(),
+    routePathMap,
     routeMetaEntries
   };
 }
@@ -3591,15 +3776,20 @@ function resolveVueSourcePath(targetClassName, vueFilesPathMap, projectRoot) {
 }
 async function getRouteMetaByComponent(projectRoot, routerEntry, routerType, options = {}) {
   const root = projectRoot ?? process.cwd();
-  const viewsDir = options.viewsDir ?? "src/views";
-  const viewsDirAbs = path.isAbsolute(viewsDir) ? viewsDir : path.resolve(root, viewsDir);
-  const scanDirs = options.scanDirs?.length ? options.scanDirs : ["src"];
+  const pageDirs = options.pageDirs?.length ? options.pageDirs : ["src/views"];
+  const pageDirsAbs = pageDirs.map((dir) => path.isAbsolute(dir) ? dir : path.resolve(root, dir));
+  const primaryPageDirAbs = pageDirsAbs[0] ?? path.resolve(root, "src/views");
+  const sourceDirs = [
+    ...pageDirs,
+    ...options.componentDirs?.length ? options.componentDirs : ["src/components"],
+    ...options.layoutDirs?.length ? options.layoutDirs : ["src/layouts"]
+  ];
   const extraRoots = process.cwd() !== root ? [process.cwd()] : [];
-  const { routeMetaEntries } = routerType === "nuxt" ? await introspectNuxtPages(root) : await parseRouterFileFromCwd(resolveRouterEntry(root, routerEntry), {
+  const { routeMetaEntries } = routerType === "nuxt" ? await introspectNuxtPages(root, { pageDirs: pageDirsAbs }) : await parseRouterFileFromCwd(resolveRouterEntry(root, routerEntry), {
     componentNaming: {
       projectRoot: root,
-      viewsDirAbs,
-      scanDirs,
+      viewsDirAbs: primaryPageDirAbs,
+      sourceDirs,
       extraRoots
     }
   });
@@ -3799,15 +3989,17 @@ async function generateFiles(componentHierarchyMap, vueFilesPathMap, basePageCla
     vueRouterFluentChaining,
     routerEntry,
     routerType,
-    viewsDir,
-    scanDirs,
+    pageDirs,
+    componentDirs,
+    layoutDirs,
     routeMetaByComponent: routeMetaByComponentOverride
   } = options;
   const emitLanguages = emitLanguagesOverride?.length ? emitLanguagesOverride : ["ts"];
   const outDir = outDirOverride ?? "./pom";
   const routeMetaByComponent = routeMetaByComponentOverride ?? (vueRouterFluentChaining ? await getRouteMetaByComponent(projectRoot, routerEntry, routerType, {
-    viewsDir,
-    scanDirs
+    pageDirs,
+    componentDirs,
+    layoutDirs
   }) : void 0);
   const generatedFilePaths = [];
   const writeGeneratedFile = (file) => {
@@ -6596,8 +6788,11 @@ function createBuildProcessorPlugin(options) {
   const {
     componentHierarchyMap,
     vueFilesPathMap,
-    viewsDir,
-    scanDirs,
+    getPageDirs,
+    getComponentDirs,
+    getLayoutDirs,
+    getViewsDir,
+    getSourceDirs,
     basePageClassPath,
     normalizedBasePagePath,
     outDir,
@@ -6618,7 +6813,7 @@ function createBuildProcessorPlugin(options) {
     excludedComponents,
     getWrapperSearchRoots,
     routerAwarePoms,
-    resolvedRouterEntry,
+    getResolvedRouterEntry,
     routerType,
     routerModuleShims,
     loggerRef
@@ -6628,7 +6823,8 @@ function createBuildProcessorPlugin(options) {
     interactiveComponentCount: 0,
     dataTestIdCount: 0
   };
-  const getViewsDirAbs = () => path.isAbsolute(viewsDir) ? viewsDir : path.resolve(projectRootRef.current, viewsDir);
+  const getViewsDirAbs = () => path.isAbsolute(getViewsDir()) ? getViewsDir() : path.resolve(projectRootRef.current, getViewsDir());
+  const getPageDirsAbs = () => getPageDirs().map((dir) => path.isAbsolute(dir) ? dir : path.resolve(projectRootRef.current, dir));
   const getScriptInfo = (source, filename) => {
     try {
       const { descriptor } = parse$1(source, { filename });
@@ -6668,7 +6864,7 @@ function createBuildProcessorPlugin(options) {
       return out;
     };
     let supplemented = 0;
-    for (const dir of scanDirs) {
+    for (const dir of getSourceDirs()) {
       const absDir = path.resolve(projectRootRef.current, dir);
       if (!fs.existsSync(absDir))
         continue;
@@ -6678,7 +6874,7 @@ function createBuildProcessorPlugin(options) {
           filename: absolutePath,
           projectRoot: projectRootRef.current,
           viewsDirAbs: getViewsDirAbs(),
-          scanDirs,
+          sourceDirs: getSourceDirs(),
           extraRoots: [process.cwd()]
         });
         if (componentHierarchyMap.has(componentName))
@@ -6753,16 +6949,17 @@ function createBuildProcessorPlugin(options) {
       }
       let result;
       if (routerType === "nuxt") {
-        result = await introspectNuxtPages(projectRootRef.current);
+        result = await introspectNuxtPages(projectRootRef.current, { pageDirs: getPageDirsAbs() });
       } else {
+        const resolvedRouterEntry = getResolvedRouterEntry();
         if (!resolvedRouterEntry)
           throw new Error("[vue-pom-generator] router.entry is required when router introspection is enabled.");
         result = await parseRouterFileFromCwd(resolvedRouterEntry, {
           moduleShims: routerModuleShims,
           componentNaming: {
             projectRoot: projectRootRef.current,
-            viewsDirAbs: path.isAbsolute(viewsDir) ? viewsDir : path.resolve(projectRootRef.current, viewsDir),
-            scanDirs
+            viewsDirAbs: getViewsDirAbs(),
+            sourceDirs: getSourceDirs()
           }
         });
       }
@@ -6822,10 +7019,11 @@ function createBuildProcessorPlugin(options) {
         customPomImportNameCollisionBehavior,
         testIdAttribute,
         vueRouterFluentChaining: routerAwarePoms,
-        routerEntry: resolvedRouterEntry,
+        routerEntry: getResolvedRouterEntry(),
         routerType,
-        viewsDir,
-        scanDirs
+        pageDirs: getPageDirs(),
+        componentDirs: getComponentDirs(),
+        layoutDirs: getLayoutDirs()
       });
       lastGeneratedMetrics = metrics;
       loggerRef.current.info(`generated POMs (${metrics.entryCount} entries, ${metrics.interactiveComponentCount} interactive components, ${metrics.dataTestIdCount} selectors)`);
@@ -6839,8 +7037,11 @@ function createDevProcessorPlugin(options) {
   const {
     nativeWrappers,
     excludedComponents,
-    viewsDir,
-    scanDirs,
+    getPageDirs,
+    getComponentDirs,
+    getLayoutDirs,
+    getViewsDir,
+    getSourceDirs,
     getWrapperSearchRoots,
     projectRootRef,
     normalizedBasePagePath,
@@ -6859,12 +7060,29 @@ function createDevProcessorPlugin(options) {
     existingIdBehavior,
     testIdAttribute,
     routerAwarePoms,
-    resolvedRouterEntry,
+    getResolvedRouterEntry,
     routerType,
     routerModuleShims,
     loggerRef
   } = options;
   let scheduleVueFileRegen = null;
+  const getProjectRootCandidates = () => Array.from(/* @__PURE__ */ new Set([
+    path.resolve(projectRootRef.current),
+    path.resolve(process.cwd())
+  ]));
+  const resolveProjectPath = (maybePath) => {
+    if (path.isAbsolute(maybePath))
+      return maybePath;
+    const candidates = getProjectRootCandidates().map((root) => path.resolve(root, maybePath));
+    return candidates.find((candidate) => fs.existsSync(candidate)) ?? candidates[0];
+  };
+  const getSourceDirRoots = () => Array.from(new Set(
+    getProjectRootCandidates().flatMap((root) => getSourceDirs().map((dir) => path.resolve(root, dir)))
+  ));
+  const isContainedInScanDirs = (filePath) => {
+    const absolutePath = path.resolve(filePath);
+    return getSourceDirRoots().some((scanDirAbs) => isPathWithinDir(absolutePath, scanDirAbs));
+  };
   return {
     name: "vue-pom-generator-dev",
     apply: "serve",
@@ -6875,16 +7093,13 @@ function createDevProcessorPlugin(options) {
         return;
       if (!ctx.file.endsWith(".vue"))
         return;
-      const isContainedInScanDirs = scanDirs.some((dir) => {
-        const absDir = path.resolve(projectRootRef.current, dir);
-        return ctx.file.startsWith(absDir + path.sep);
-      });
-      if (!isContainedInScanDirs)
+      if (!isContainedInScanDirs(ctx.file))
         return;
       scheduleVueFileRegen(ctx.file, "hmr");
     },
     async configureServer(server) {
-      const getViewsDirAbs = () => path.isAbsolute(viewsDir) ? viewsDir : path.resolve(projectRootRef.current, viewsDir);
+      const getViewsDirAbs = () => resolveProjectPath(getViewsDir());
+      const getPageDirsAbs = () => getPageDirs().map((dir) => resolveProjectPath(dir));
       const routerInitPromise = (async () => {
         if (!routerAwarePoms) {
           setRouteNameToComponentNameMap(/* @__PURE__ */ new Map());
@@ -6893,8 +7108,9 @@ function createDevProcessorPlugin(options) {
         }
         let result;
         if (routerType === "nuxt") {
-          result = await introspectNuxtPages(projectRootRef.current);
+          result = await introspectNuxtPages(projectRootRef.current, { pageDirs: getPageDirsAbs() });
         } else {
+          const resolvedRouterEntry = getResolvedRouterEntry();
           if (!resolvedRouterEntry)
             throw new Error("[vue-pom-generator] router.entry is required when router introspection is enabled.");
           result = await parseRouterFileFromCwd(resolvedRouterEntry, {
@@ -6902,7 +7118,7 @@ function createDevProcessorPlugin(options) {
             componentNaming: {
               projectRoot: projectRootRef.current,
               viewsDirAbs: getViewsDirAbs(),
-              scanDirs,
+              sourceDirs: getSourceDirs(),
               extraRoots: [process.cwd()]
             }
           });
@@ -6974,6 +7190,19 @@ function createDevProcessorPlugin(options) {
       let snapshotHierarchy = /* @__PURE__ */ new Map();
       let snapshotVuePathMap = /* @__PURE__ */ new Map();
       const filePathToComponentName = /* @__PURE__ */ new Map();
+      const createEmptyComponentDependencies = (absolutePath) => {
+        const viewsDirAbs = path.resolve(getViewsDirAbs());
+        const relToViewsDir = path.relative(viewsDirAbs, absolutePath);
+        const isView = !relToViewsDir.startsWith("..") && !path.isAbsolute(relToViewsDir);
+        return {
+          filePath: absolutePath,
+          childrenComponentSet: /* @__PURE__ */ new Set(),
+          usedComponentSet: /* @__PURE__ */ new Set(),
+          dataTestIdSet: /* @__PURE__ */ new Set(),
+          isView,
+          methodsContent: ""
+        };
+      };
       const getComponentNameForFile = (filePath) => {
         const normalized = path.resolve(filePath);
         const existing = filePathToComponentName.get(normalized);
@@ -6983,7 +7212,7 @@ function createDevProcessorPlugin(options) {
           filename: normalized,
           projectRoot: projectRootRef.current,
           viewsDirAbs: getViewsDirAbs(),
-          scanDirs,
+          sourceDirs: getSourceDirs(),
           extraRoots: [process.cwd()]
         });
         filePathToComponentName.set(normalized, name);
@@ -6993,8 +7222,6 @@ function createDevProcessorPlugin(options) {
         const started = performance.now();
         const absolutePath = path.resolve(filePath);
         const componentName = getComponentNameForFile(absolutePath);
-        targetVuePathMap.set(componentName, absolutePath);
-        targetHierarchy.delete(componentName);
         let sfc = "";
         try {
           sfc = fs.readFileSync(absolutePath, "utf8");
@@ -7002,9 +7229,15 @@ function createDevProcessorPlugin(options) {
           return { componentName, ms: performance.now() - started, compiled: false };
         }
         const template = extractTemplateFromSfc(sfc, absolutePath);
-        if (!template.trim())
+        if (!template.trim()) {
+          targetVuePathMap.set(componentName, absolutePath);
+          targetHierarchy.set(componentName, createEmptyComponentDependencies(absolutePath));
           return { componentName, ms: performance.now() - started, compiled: true };
+        }
         const { bindings: bindingMetadata, isScriptSetup } = getScriptInfo(sfc, absolutePath);
+        const provisionalHierarchy = /* @__PURE__ */ new Map();
+        const provisionalVuePathMap = new Map(targetVuePathMap);
+        provisionalVuePathMap.set(componentName, absolutePath);
         compilerDom.compile(template, {
           filename: absolutePath,
           prefixIdentifiers: true,
@@ -7013,7 +7246,7 @@ function createDevProcessorPlugin(options) {
           nodeTransforms: [
             createTestIdTransform(
               componentName,
-              targetHierarchy,
+              provisionalHierarchy,
               nativeWrappers,
               excludedComponents,
               getViewsDirAbs(),
@@ -7023,23 +7256,27 @@ function createDevProcessorPlugin(options) {
                 missingSemanticNameBehavior,
                 testIdAttribute,
                 warn: (message) => loggerRef.current.warn(message),
-                vueFilesPathMap: targetVuePathMap,
+                vueFilesPathMap: provisionalVuePathMap,
                 wrapperSearchRoots: getWrapperSearchRoots()
               }
             )
           ]
         });
+        targetVuePathMap.set(componentName, absolutePath);
+        targetHierarchy.set(
+          componentName,
+          provisionalHierarchy.get(componentName) ?? createEmptyComponentDependencies(absolutePath)
+        );
         return { componentName, ms: performance.now() - started, compiled: true };
       };
-      const fullRebuildSnapshotFromFilesystem = () => {
+      const fullRebuildSnapshotFromFilesystem = (logLabel) => {
         const t0 = performance.now();
         const nextHierarchy = /* @__PURE__ */ new Map();
         const nextVuePathMap = /* @__PURE__ */ new Map();
         filePathToComponentName.clear();
         let totalVueFiles = 0;
         let compiledCount = 0;
-        for (const dir of scanDirs) {
-          const absDir = path.resolve(projectRootRef.current, dir);
+        for (const absDir of getSourceDirRoots()) {
           if (!fs.existsSync(absDir))
             continue;
           const vueFiles = walkFilesRecursive(absDir);
@@ -7053,12 +7290,12 @@ function createDevProcessorPlugin(options) {
         snapshotHierarchy = nextHierarchy;
         snapshotVuePathMap = nextVuePathMap;
         const t1 = performance.now();
-        logInfo(`initial scan: found ${totalVueFiles} .vue files in ${scanDirs.join(", ")}`);
-        logInfo(`initial compile: ${compiledCount}/${totalVueFiles} files in ${formatMs(t1 - t0)} (components=${snapshotHierarchy.size})`);
+        logInfo(`scan(${logLabel}): found ${totalVueFiles} .vue files in ${getSourceDirs().join(", ")}`);
+        logInfo(`compile(${logLabel}): ${compiledCount}/${totalVueFiles} files in ${formatMs(t1 - t0)} (components=${snapshotHierarchy.size})`);
       };
-      const generateAggregatedFromSnapshot = (reason) => {
+      const generateAggregatedFromSnapshot = async (logLabel) => {
         const t0 = performance.now();
-        generateFiles(snapshotHierarchy, snapshotVuePathMap, normalizedBasePagePath, {
+        await generateFiles(snapshotHierarchy, snapshotVuePathMap, normalizedBasePagePath, {
           outDir,
           emitLanguages,
           typescriptOutputStructure,
@@ -7069,25 +7306,27 @@ function createDevProcessorPlugin(options) {
           customPomDir,
           customPomImportAliases,
           customPomImportNameCollisionBehavior,
-          viewsDir,
-          scanDirs,
+          pageDirs: getPageDirs(),
+          componentDirs: getComponentDirs(),
+          layoutDirs: getLayoutDirs(),
           testIdAttribute,
           vueRouterFluentChaining: routerAwarePoms,
-          routerEntry: resolvedRouterEntry,
+          routerEntry: getResolvedRouterEntry(),
           routerType
         });
         const t1 = performance.now();
-        logInfo(`generate(${reason}): components=${snapshotHierarchy.size} in ${formatMs(t1 - t0)}`);
+        logInfo(`generate(${logLabel}): components=${snapshotHierarchy.size} in ${formatMs(t1 - t0)}`);
       };
       let timer = null;
       let maxWaitTimer = null;
       const pendingChangedVueFiles = /* @__PURE__ */ new Set();
       const pendingDeletedComponents = /* @__PURE__ */ new Set();
+      let regenerationSequence = Promise.resolve();
       const initialBuildPromise = (async () => {
         const t0 = performance.now();
         await routerInitPromise;
-        fullRebuildSnapshotFromFilesystem();
-        generateAggregatedFromSnapshot("startup");
+        fullRebuildSnapshotFromFilesystem("startup");
+        await generateAggregatedFromSnapshot("startup");
         const t1 = performance.now();
         logInfo(`startup total: ${formatMs(t1 - t0)}`);
       })();
@@ -7115,7 +7354,7 @@ function createDevProcessorPlugin(options) {
         snapshotHierarchy = nextHierarchy;
         snapshotVuePathMap = nextVuePathMap;
         const t1 = performance.now();
-        generateAggregatedFromSnapshot(reason);
+        await generateAggregatedFromSnapshot(reason);
         const t2 = performance.now();
         return {
           files,
@@ -7126,7 +7365,12 @@ function createDevProcessorPlugin(options) {
           totalMs: t2 - t0
         };
       };
-      const watchedVueGlobs = scanDirs.map((dir) => path.resolve(projectRootRef.current, dir, "**", "*.vue"));
+      const enqueueRegeneration = (reason) => {
+        const currentRun = regenerationSequence.catch(() => void 0).then(() => regenerateFromPending(reason));
+        regenerationSequence = currentRun.then(() => void 0, () => void 0);
+        return currentRun;
+      };
+      const watchedVueGlobs = getSourceDirRoots().map((scanDirAbs) => path.resolve(scanDirAbs, "**", "*.vue"));
       const watchedPluginGlob = path.resolve(projectRootRef.current, "vite-plugins", "vue-pom-generator", "**", "*.ts");
       const runtimeDir = path.dirname(basePageClassPath);
       server.watcher.add([
@@ -7152,7 +7396,7 @@ function createDevProcessorPlugin(options) {
               timer = null;
             }
             maxWaitTimer = null;
-            void regenerateFromPending("max-wait").then(({ files, deletedCount, compileMs, preGenerateMs, generateMs, totalMs }) => {
+            void enqueueRegeneration("max-wait").then(({ files, deletedCount, compileMs, preGenerateMs, generateMs, totalMs }) => {
               logInfo(
                 `max-wait: files=${files.length} deleted=${deletedCount} compile=${formatMs(compileMs)} wall=${formatMs(preGenerateMs)} gen=${formatMs(generateMs)} total=${formatMs(totalMs)}`
               );
@@ -7176,7 +7420,7 @@ function createDevProcessorPlugin(options) {
             maxWaitTimer = null;
           }
           const reason = pendingChangedVueFiles.size || pendingDeletedComponents.size ? "batched" : "noop";
-          void regenerateFromPending(reason).then(({ files, deletedCount, compileMs, preGenerateMs, generateMs, totalMs }) => {
+          void enqueueRegeneration(reason).then(({ files, deletedCount, compileMs, preGenerateMs, generateMs, totalMs }) => {
             if (files.length || deletedCount) {
               logInfo(
                 `batched: files=${files.length} deleted=${deletedCount} compile=${formatMs(compileMs)} wall=${formatMs(preGenerateMs)} gen=${formatMs(generateMs)} total=${formatMs(totalMs)}`
@@ -7203,11 +7447,7 @@ function createDevProcessorPlugin(options) {
           return;
         if (!p.endsWith(".vue"))
           return;
-        const isContainedInScanDirs = scanDirs.some((dir) => {
-          const absDir = path.resolve(projectRootRef.current, dir);
-          return p.startsWith(absDir + path.sep);
-        });
-        if (!isContainedInScanDirs)
+        if (!isContainedInScanDirs(p))
           return;
         void (async () => {
           await initialBuildPromise;
@@ -7220,11 +7460,7 @@ function createDevProcessorPlugin(options) {
           return;
         if (!p.endsWith(".vue"))
           return;
-        const isContainedInScanDirs = scanDirs.some((dir) => {
-          const absDir = path.resolve(projectRootRef.current, dir);
-          return p.startsWith(absDir + path.sep);
-        });
-        if (!isContainedInScanDirs)
+        if (!isContainedInScanDirs(p))
           return;
         void (async () => {
           await initialBuildPromise;
@@ -7288,8 +7524,11 @@ function createSupportPlugins(options) {
     vueFilesPathMap,
     nativeWrappers,
     excludedComponents,
-    viewsDir,
-    scanDirs,
+    getPageDirs,
+    getComponentDirs,
+    getLayoutDirs,
+    getViewsDir,
+    getSourceDirs,
     getWrapperSearchRoots,
     nameCollisionBehavior = "suffix",
     missingSemanticNameBehavior,
@@ -7321,7 +7560,6 @@ function createSupportPlugins(options) {
       throw new Error("[vue-pom-generator] router.entry is required when router introspection is enabled.");
     return path.isAbsolute(routerEntry) ? routerEntry : path.resolve(projectRootRef.current, routerEntry);
   };
-  const resolvedRouterEntry = resolveRouterEntry2();
   const getDefaultBasePageClassPath = () => {
     try {
       return fileURLToPath(new URL("../class-generation/base-page.ts", import.meta.url));
@@ -7334,8 +7572,11 @@ function createSupportPlugins(options) {
   const tsProcessor = createBuildProcessorPlugin({
     componentHierarchyMap,
     vueFilesPathMap,
-    viewsDir,
-    scanDirs,
+    getPageDirs,
+    getComponentDirs,
+    getLayoutDirs,
+    getViewsDir,
+    getSourceDirs,
     basePageClassPath,
     normalizedBasePagePath,
     outDir,
@@ -7357,15 +7598,18 @@ function createSupportPlugins(options) {
     getWrapperSearchRoots,
     routerAwarePoms,
     routerType,
-    resolvedRouterEntry,
+    getResolvedRouterEntry: resolveRouterEntry2,
     routerModuleShims,
     loggerRef
   });
   const devProcessor = createDevProcessorPlugin({
     nativeWrappers,
     excludedComponents,
-    viewsDir,
-    scanDirs,
+    getPageDirs,
+    getComponentDirs,
+    getLayoutDirs,
+    getViewsDir,
+    getSourceDirs,
     getWrapperSearchRoots,
     projectRootRef,
     normalizedBasePagePath,
@@ -7385,7 +7629,7 @@ function createSupportPlugins(options) {
     testIdAttribute,
     routerAwarePoms,
     routerType,
-    resolvedRouterEntry,
+    getResolvedRouterEntry: resolveRouterEntry2,
     routerModuleShims,
     loggerRef
   });
@@ -7543,7 +7787,7 @@ function createVuePluginWithTestIds(options) {
     getViewsDirAbs,
     testIdAttribute,
     loggerRef,
-    scanDirs = ["src"],
+    getSourceDirs,
     getWrapperSearchRoots,
     getProjectRoot
   } = options;
@@ -7552,7 +7796,7 @@ function createVuePluginWithTestIds(options) {
       filename,
       projectRoot: getProjectRoot(),
       viewsDirAbs: getViewsDirAbs(),
-      scanDirs,
+      sourceDirs: getSourceDirs(),
       extraRoots: [process.cwd()]
     });
   };
@@ -7568,7 +7812,7 @@ function createVuePluginWithTestIds(options) {
     if (absFilename.startsWith(viewsDirAbs + path.sep) || absFilename === viewsDirAbs)
       return true;
     const rootsToTry = [projectRoot, process.cwd()];
-    const matched = scanDirs.some((dir) => {
+    const matched = getSourceDirs().some((dir) => {
       return rootsToTry.some((root) => {
         const absDir = path.resolve(root, dir);
         if (absFilename.startsWith(absDir + path.sep) || absFilename === absDir)
@@ -7743,6 +7987,25 @@ function createVuePluginWithTestIds(options) {
   };
   return { metadataCollectorPlugin, internalVuePlugin, nuxtVueBridgePlugin, templateCompilerOptions };
 }
+const nuxtConfigMarker$1 = /* @__PURE__ */ Symbol.for("@immense/vue-pom-generator.nuxt");
+const nuxtConfigFileNames = [
+  "nuxt.config.ts",
+  "nuxt.config.js",
+  "nuxt.config.mjs",
+  "nuxt.config.cjs",
+  "nuxt.config.mts",
+  "nuxt.config.cts",
+  ".nuxtrc"
+];
+const nuxtSourceMarkers = [
+  "app.vue",
+  "app",
+  "pages",
+  "layouts",
+  "components",
+  "layers",
+  ".nuxt"
+];
 function assertNonEmptyString(value, name) {
   if (!value || !value.trim()) {
     throw new Error(`${name} must be a non-empty string.`);
@@ -7790,6 +8053,57 @@ function resolveMissingSemanticNameBehavior(value) {
   }
   return value.missingSemanticNameBehavior ?? "ignore";
 }
+function readPackageJson(projectRoot) {
+  const packageJsonPath = path.join(projectRoot, "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function recordHasOwnStringKey(value, key) {
+  return value !== null && value !== void 0 && !Array.isArray(value) && Object.prototype.hasOwnProperty.call(value, key) && typeof value[key] === "string";
+}
+function projectPackageLooksNuxt(projectRoot) {
+  const packageJson = readPackageJson(projectRoot);
+  if (!packageJson) {
+    return false;
+  }
+  const dependencyGroups = [
+    packageJson.dependencies,
+    packageJson.devDependencies,
+    packageJson.peerDependencies,
+    packageJson.optionalDependencies
+  ];
+  if (dependencyGroups.some((group) => {
+    const dependencyGroup = typeof group === "object" && group !== null ? group : void 0;
+    return recordHasOwnStringKey(dependencyGroup, "nuxt") || recordHasOwnStringKey(dependencyGroup, "nuxt-nightly");
+  })) {
+    return true;
+  }
+  if (typeof packageJson.scripts !== "object" || packageJson.scripts === null || Array.isArray(packageJson.scripts)) {
+    return false;
+  }
+  return Object.values(packageJson.scripts).some((script) => {
+    if (typeof script !== "string") {
+      return false;
+    }
+    const normalizedScript = script.trim();
+    return normalizedScript === "nuxt" || normalizedScript.startsWith("nuxt ") || normalizedScript === "nuxi" || normalizedScript.startsWith("nuxi ");
+  });
+}
+function detectNuxtProject(options, projectRoot) {
+  if (options[nuxtConfigMarker$1] === true) {
+    return true;
+  }
+  if (nuxtConfigFileNames.some((fileName) => fs.existsSync(path.join(projectRoot, fileName)))) {
+    return true;
+  }
+  return projectPackageLooksNuxt(projectRoot) && nuxtSourceMarkers.some((entry) => fs.existsSync(path.join(projectRoot, entry)));
+}
 function assertRouterModuleShims(value, name) {
   if (!value)
     return;
@@ -7897,14 +8211,18 @@ function assertNotVitePluginInstance(options) {
 function createVuePomGeneratorPlugins(options = {}) {
   assertNotVitePluginInstance(options);
   const injection = options.injection ?? {};
+  const isNuxt = detectNuxtProject(options, process.cwd());
   const generationSetting = options.generation;
   const generationOptions = generationSetting === false ? null : generationSetting ?? {};
   const generationEnabled = generationOptions !== null;
+  const vueGenerationOptions = generationOptions;
   const verbosity = options.logging?.verbosity ?? "warn";
   const vueOptions = options.vueOptions;
-  const viewsDir = injection.viewsDir ?? "src/views";
-  const scanDirs = injection.scanDirs ?? ["src"];
-  const wrapperSearchRoots = injection.wrapperSearchRoots ?? [];
+  const legacyVueOptions = options;
+  const pageDirsRef = { current: !isNuxt ? [legacyVueOptions.injection?.viewsDir ?? "src/views"] : ["app/pages"] };
+  const componentDirsRef = { current: !isNuxt ? legacyVueOptions.injection?.componentDirs ?? ["src/components"] : ["app/components"] };
+  const layoutDirsRef = { current: !isNuxt ? legacyVueOptions.injection?.layoutDirs ?? ["src/layouts"] : ["app/layouts"] };
+  const wrapperSearchRootsRef = { current: !isNuxt ? legacyVueOptions.injection?.wrapperSearchRoots ?? [] : [] };
   const nativeWrappers = injection.nativeWrappers ?? {};
   const excludedComponents = injection.excludeComponents ?? [];
   const testIdAttribute = (injection.attribute ?? "data-testid").trim() || "data-testid";
@@ -7912,10 +8230,9 @@ function createVuePomGeneratorPlugins(options = {}) {
   const outDir = (generationOptions?.outDir ?? "tests/playwright/__generated__").trim();
   const emitLanguages = generationOptions?.emit && generationOptions.emit.length ? generationOptions.emit : ["ts"];
   const nameCollisionBehavior = generationOptions?.nameCollisionBehavior ?? "suffix";
-  const routerEntry = generationOptions?.router?.entry;
-  const routerType = generationOptions?.router?.type ?? "vue-router";
-  const routerModuleShims = generationOptions?.router?.moduleShims;
-  const isNuxt = routerType === "nuxt";
+  const routerEntry = !isNuxt ? vueGenerationOptions?.router?.entry : void 0;
+  const routerType = isNuxt ? "nuxt" : vueGenerationOptions?.router?.type ?? "vue-router";
+  const routerModuleShims = !isNuxt ? vueGenerationOptions?.router?.moduleShims : void 0;
   if (isNuxt && options.vuePluginOwnership === "internal") {
     throw new Error('[vue-pom-generator] Nuxt projects must use the resolved app-owned vite:vue plugin. Omit vuePluginOwnership or set it to "external".');
   }
@@ -7932,17 +8249,30 @@ function createVuePomGeneratorPlugins(options = {}) {
   const resolvedCustomPomImportAliases = customPoms?.importAliases;
   const resolvedCustomPomImportCollisionBehavior = customPoms?.importNameCollisionBehavior ?? "error";
   const basePageClassPathOverride = generationOptions?.basePageClassPath;
+  const getPageDirs = () => pageDirsRef.current;
+  const getViewsDir = () => getPageDirs()[0] ?? "src/views";
+  const getComponentDirs = () => componentDirsRef.current;
+  const getLayoutDirs = () => layoutDirsRef.current;
+  const getSourceDirs = () => Array.from(/* @__PURE__ */ new Set([
+    ...getPageDirs(),
+    ...getComponentDirs(),
+    ...getLayoutDirs()
+  ]));
+  const getWrapperSearchRoots = () => wrapperSearchRootsRef.current;
   const sharedStateKey = JSON.stringify({
     cwd: process.cwd(),
-    viewsDir,
-    scanDirs,
-    wrapperSearchRoots,
+    mode: isNuxt ? "nuxt" : "vue",
+    pageDirs: isNuxt ? null : getPageDirs(),
+    componentDirs: isNuxt ? null : getComponentDirs(),
+    layoutDirs: isNuxt ? null : getLayoutDirs(),
+    wrapperSearchRoots: isNuxt ? null : getWrapperSearchRoots(),
     outDir,
     testIdAttribute,
     routerType,
     vuePluginOwnership
   });
   const sharedState = getSharedGeneratorState(sharedStateKey);
+  let templateCompilerOptionsForResolvedPlugin;
   const projectRootRef = { current: process.cwd() };
   const loggerRef = {
     current: createLogger({ verbosity })
@@ -7950,30 +8280,50 @@ function createVuePomGeneratorPlugins(options = {}) {
   const configPlugin = {
     name: "vue-pom-generator-config",
     enforce: "pre",
-    configResolved(config) {
+    async configResolved(config) {
       projectRootRef.current = config.root;
       loggerRef.current = createLogger({ verbosity, viteLogger: config.logger });
+      if (vueGenerationOptions?.router?.type === "nuxt") {
+        throw new Error('[vue-pom-generator] Remove generation.router.type="nuxt". Nuxt projects are auto-detected.');
+      }
+      if (isNuxt) {
+        const nuxtDiscovery = await loadNuxtProjectDiscovery(process.cwd());
+        projectRootRef.current = nuxtDiscovery.rootDir;
+        pageDirsRef.current = nuxtDiscovery.pageDirs.length ? nuxtDiscovery.pageDirs : [path.resolve(nuxtDiscovery.srcDir, "pages")];
+        componentDirsRef.current = nuxtDiscovery.componentDirs;
+        layoutDirsRef.current = nuxtDiscovery.layoutDirs;
+        wrapperSearchRootsRef.current = nuxtDiscovery.wrapperSearchRoots;
+      }
       assertNonEmptyString(testIdAttribute, "[vue-pom-generator] injection.attribute");
-      assertNonEmptyString(viewsDir, "[vue-pom-generator] injection.viewsDir");
-      assertNonEmptyStringArray(wrapperSearchRoots, "[vue-pom-generator] injection.wrapperSearchRoots");
+      assertNonEmptyString(getViewsDir(), "[vue-pom-generator] injection.viewsDir");
+      assertNonEmptyStringArray(getComponentDirs(), "[vue-pom-generator] injection.componentDirs");
+      assertNonEmptyStringArray(getLayoutDirs(), "[vue-pom-generator] injection.layoutDirs");
+      assertNonEmptyStringArray(getWrapperSearchRoots(), "[vue-pom-generator] injection.wrapperSearchRoots");
       assertErrorBehavior(errorBehavior, "[vue-pom-generator] errorBehavior");
       if (generationEnabled) {
         assertNonEmptyString(outDir, "[vue-pom-generator] generation.outDir");
         assertOneOf(typescriptOutputStructure, ["aggregated", "split"], "[vue-pom-generator] generation.playwright.outputStructure");
         assertRouterModuleShims(routerModuleShims, "[vue-pom-generator] generation.router.moduleShims");
-        if (generationOptions?.router && routerType === "vue-router") {
+        if (!isNuxt && vueGenerationOptions?.router && routerType === "vue-router") {
           assertNonEmptyString(routerEntry, "[vue-pom-generator] generation.router.entry");
         }
       }
       if (usesExternalVuePlugin) {
-        applyTemplateCompilerOptionsToResolvedVuePlugin(config, templateCompilerOptions, isNuxt ? "nuxt" : vuePluginOwnership);
+        applyTemplateCompilerOptionsToResolvedVuePlugin(
+          config,
+          templateCompilerOptionsForResolvedPlugin,
+          isNuxt ? "nuxt" : vuePluginOwnership
+        );
       }
       loggerRef.current.info(`projectRoot=${projectRootRef.current}`);
+      loggerRef.current.info(`viewsDir=${getViewsDir()}`);
+      loggerRef.current.info(`componentDirs=${getComponentDirs().join(", ")}`);
+      loggerRef.current.info(`layoutDirs=${getLayoutDirs().join(", ")}`);
       loggerRef.current.info(`Active plugins: ${(config.plugins ?? []).map((p) => p.name).filter((n) => n.includes("vue-pom")).join(", ")}`);
     }
   };
-  const getViewsDirAbs = () => resolveFromProjectRoot(projectRootRef.current, viewsDir);
-  const getWrapperSearchRootsAbs = () => wrapperSearchRoots.map((root) => resolveFromProjectRoot(projectRootRef.current, root));
+  const getViewsDirAbs = () => resolveFromProjectRoot(projectRootRef.current, getViewsDir());
+  const getWrapperSearchRootsAbs = () => getWrapperSearchRoots().map((root) => resolveFromProjectRoot(projectRootRef.current, root));
   const { componentTestIds, elementMetadata, semanticNameMap, componentHierarchyMap, vueFilesPathMap } = sharedState;
   const { metadataCollectorPlugin, internalVuePlugin, templateCompilerOptions } = createVuePluginWithTestIds({
     vueOptions,
@@ -7988,10 +8338,11 @@ function createVuePomGeneratorPlugins(options = {}) {
     getViewsDirAbs,
     testIdAttribute,
     loggerRef,
-    scanDirs,
+    getSourceDirs,
     getWrapperSearchRoots: getWrapperSearchRootsAbs,
     getProjectRoot: () => projectRootRef.current
   });
+  templateCompilerOptionsForResolvedPlugin = templateCompilerOptions;
   const routerAwarePoms = typeof routerEntry === "string" && routerEntry.trim().length > 0 || routerType === "nuxt";
   const supportPlugins = createSupportPlugins({
     componentTestIds,
@@ -7999,8 +8350,11 @@ function createVuePomGeneratorPlugins(options = {}) {
     vueFilesPathMap,
     nativeWrappers,
     excludedComponents,
-    viewsDir,
-    scanDirs,
+    getPageDirs,
+    getComponentDirs,
+    getLayoutDirs,
+    getViewsDir,
+    getSourceDirs,
     getWrapperSearchRoots: getWrapperSearchRootsAbs,
     nameCollisionBehavior,
     missingSemanticNameBehavior,
@@ -8045,12 +8399,22 @@ function createVuePomGeneratorPlugins(options = {}) {
   }
   return resultPlugins;
 }
+const nuxtConfigMarker = /* @__PURE__ */ Symbol.for("@immense/vue-pom-generator.nuxt");
 function defineVuePomGeneratorConfig(options) {
   return options;
 }
+function defineNuxtPomGeneratorConfig(options) {
+  const markedOptions = { ...options };
+  Object.defineProperty(markedOptions, nuxtConfigMarker, {
+    value: true,
+    enumerable: false
+  });
+  return markedOptions;
+}
 export {
   createVuePomGeneratorPlugins,
   createVuePomGeneratorPlugins as default,
+  defineNuxtPomGeneratorConfig,
   defineVuePomGeneratorConfig,
   createVuePomGeneratorPlugins as vuePomGenerator
 };