@screenbook/cli 1.6.1 → 1.7.1

package/dist/index.mjs

@@ -827,23 +827,22 @@ async function generateCoverageData(config, cwd, screens) {
 		cwd,
 		ignore: config.ignore
 	});
-	new Set(screens.map((s) => {
-		const parts = s.id.split(".");
-		return parts.slice(0, -1).join("/") || parts[0];
-	}));
+	const metaDirs = /* @__PURE__ */ new Set();
+	for (const screen of screens) if (screen.filePath) {
+		const absoluteDir = dirname(screen.filePath);
+		const relativeDir = absoluteDir.startsWith(cwd) ? absoluteDir.slice(cwd.length + 1) : absoluteDir;
+		metaDirs.add(relativeDir);
+	}
 	const missing = [];
 	for (const routeFile of routeFiles) {
 		const routeDir = dirname(routeFile);
-		if (!screens.some((s) => {
-			const screenDir = s.id.replace(/\./g, "/");
-			return routeDir.includes(screenDir) || screenDir.includes(routeDir.replace(/^src\/pages\//, "").replace(/^app\//, ""));
-		})) missing.push({
+		if (!metaDirs.has(routeDir)) missing.push({
 			route: routeFile,
 			suggestedPath: join(dirname(routeFile), "screen.meta.ts")
 		});
 	}
 	const total = routeFiles.length > 0 ? routeFiles.length : screens.length;
-	const covered = screens.length;
+	const covered = routeFiles.length > 0 ? routeFiles.length - missing.length : screens.length;
 	const percentage = total > 0 ? Math.round(covered / total * 100) : 100;
 	const byOwner = {};
 	for (const screen of screens) {
@@ -3042,25 +3041,26 @@ function parseVueRouterConfig(filePath, preloadedContent) {
 		throw new Error(`Failed to parse routes file "${absolutePath}": ${message}`);
 	}
 	const routes = [];
+	const importMap = buildImportMap(ast.program.body, routesFileDir);
 	for (const node of ast.program.body) {
 		if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration") {
 			for (const decl of node.declaration.declarations) if (decl.id.type === "Identifier" && decl.id.name === "routes" && decl.init?.type === "ArrayExpression") {
-				const parsed = parseRoutesArray(decl.init, routesFileDir, warnings);
+				const parsed = parseRoutesArray(decl.init, routesFileDir, warnings, importMap);
 				routes.push(...parsed);
 			}
 		}
 		if (node.type === "VariableDeclaration") {
 			for (const decl of node.declarations) if (decl.id.type === "Identifier" && decl.id.name === "routes" && decl.init?.type === "ArrayExpression") {
-				const parsed = parseRoutesArray(decl.init, routesFileDir, warnings);
+				const parsed = parseRoutesArray(decl.init, routesFileDir, warnings, importMap);
 				routes.push(...parsed);
 			}
 		}
 		if (node.type === "ExportDefaultDeclaration" && node.declaration.type === "ArrayExpression") {
-			const parsed = parseRoutesArray(node.declaration, routesFileDir, warnings);
+			const parsed = parseRoutesArray(node.declaration, routesFileDir, warnings, importMap);
 			routes.push(...parsed);
 		}
 		if (node.type === "ExportDefaultDeclaration" && node.declaration.type === "TSSatisfiesExpression" && node.declaration.expression.type === "ArrayExpression") {
-			const parsed = parseRoutesArray(node.declaration.expression, routesFileDir, warnings);
+			const parsed = parseRoutesArray(node.declaration.expression, routesFileDir, warnings, importMap);
 			routes.push(...parsed);
 		}
 	}
@@ -3071,9 +3071,25 @@ function parseVueRouterConfig(filePath, preloadedContent) {
 	};
 }
 /**
+* Build a map of imported identifiers to their file paths
+*/
+function buildImportMap(body, baseDir) {
+	const importMap = /* @__PURE__ */ new Map();
+	for (const node of body) {
+		if (node.type !== "ImportDeclaration") continue;
+		const source = node.source.value;
+		if (typeof source !== "string") continue;
+		const resolvedPath = resolveImportPath(source, baseDir);
+		if (!resolvedPath) continue;
+		for (const specifier of node.specifiers) if (specifier.type === "ImportDefaultSpecifier") importMap.set(specifier.local.name, resolvedPath);
+		else if (specifier.type === "ImportSpecifier") importMap.set(specifier.local.name, resolvedPath);
+	}
+	return importMap;
+}
+/**
 * Parse an array expression containing route objects
 */
-function parseRoutesArray(arrayNode, baseDir, warnings) {
+function parseRoutesArray(arrayNode, baseDir, warnings, importMap) {
 	const routes = [];
 	for (const element of arrayNode.elements) {
 		if (!element) continue;
@@ -3083,7 +3099,7 @@ function parseRoutesArray(arrayNode, baseDir, warnings) {
 			continue;
 		}
 		if (element.type === "ObjectExpression") {
-			const route = parseRouteObject(element, baseDir, warnings);
+			const route = parseRouteObject(element, baseDir, warnings, importMap);
 			if (route) routes.push(route);
 		}
 	}
@@ -3092,14 +3108,18 @@ function parseRoutesArray(arrayNode, baseDir, warnings) {
 /**
 * Parse a single route object expression
 */
-function parseRouteObject(objectNode, baseDir, warnings) {
-	const route = { path: "" };
+function parseRouteObject(objectNode, baseDir, warnings, importMap) {
+	const route = {};
+	let hasPath = false;
 	for (const prop of objectNode.properties) {
 		if (prop.type !== "ObjectProperty") continue;
 		if (prop.key.type !== "Identifier") continue;
 		switch (prop.key.name) {
 			case "path":
-				if (prop.value.type === "StringLiteral") route.path = prop.value.value;
+				if (prop.value.type === "StringLiteral") {
+					route.path = prop.value.value;
+					hasPath = true;
+				}
 				break;
 			case "name":
 				if (prop.value.type === "StringLiteral") route.name = prop.value.value;
@@ -3108,21 +3128,21 @@ function parseRouteObject(objectNode, baseDir, warnings) {
 				if (prop.value.type === "StringLiteral") route.redirect = prop.value.value;
 				break;
 			case "component":
-				route.component = extractComponentPath(prop.value, baseDir);
+				route.component = extractComponentPath(prop.value, baseDir, importMap);
 				break;
 			case "children":
-				if (prop.value.type === "ArrayExpression") route.children = parseRoutesArray(prop.value, baseDir, warnings);
+				if (prop.value.type === "ArrayExpression") route.children = parseRoutesArray(prop.value, baseDir, warnings, importMap);
 				break;
 		}
 	}
-	if (!route.path) return null;
+	if (!hasPath) return null;
 	return route;
 }
 /**
 * Extract component path from various component definitions
 */
-function extractComponentPath(node, baseDir) {
-	if (node.type === "Identifier") return;
+function extractComponentPath(node, baseDir, importMap) {
+	if (node.type === "Identifier") return importMap.get(node.name);
 	if (node.type === "ArrowFunctionExpression") {
 		const body = node.body;
 		if (body.type === "CallExpression" && body.callee.type === "Import") {
@@ -3305,6 +3325,83 @@ function walkTemplateNodes(nodes, callback) {
 
 //#endregion
 //#region src/commands/generate.ts
+/**
+* Common paths where Vue Router configuration files are typically located
+*/
+const VUE_ROUTER_CONFIG_PATHS = [
+	"src/router/routes.ts",
+	"src/router/index.ts",
+	"src/router.ts",
+	"src/routes.ts",
+	"router/routes.ts",
+	"router/index.ts"
+];
+/**
+* Default patterns to exclude from screen.meta.ts generation.
+* These directories typically contain reusable components, not navigable screens.
+* @see https://github.com/wadakatu/screenbook/issues/170
+*/
+const DEFAULT_EXCLUDE_PATTERNS = [
+	"**/components/**",
+	"**/shared/**",
+	"**/utils/**",
+	"**/hooks/**",
+	"**/composables/**",
+	"**/stores/**",
+	"**/services/**",
+	"**/helpers/**",
+	"**/lib/**",
+	"**/common/**"
+];
+/**
+* Check if a path matches any of the exclude patterns
+*/
+function matchesExcludePattern(filePath, excludePatterns) {
+	for (const pattern of excludePatterns) {
+		const cleanPattern = pattern.replace(/\*\*/g, "").replace(/\*/g, "").replace(/^\//, "").replace(/\/$/, "");
+		if (cleanPattern && filePath.includes(`/${cleanPattern}/`)) return true;
+		if (cleanPattern && filePath.startsWith(`${cleanPattern}/`)) return true;
+	}
+	return false;
+}
+/**
+* Detect Vue Router configuration file in the project
+*/
+function detectVueRouterConfigFile(cwd) {
+	for (const configPath of VUE_ROUTER_CONFIG_PATHS) {
+		const absolutePath = join(cwd, configPath);
+		if (existsSync(absolutePath)) return absolutePath;
+	}
+	return null;
+}
+/**
+* Build a map from component file paths to their route information.
+* Normalizes paths for reliable matching.
+*/
+function buildRouteComponentMap(flatRoutes, cwd) {
+	const map = /* @__PURE__ */ new Map();
+	for (const route of flatRoutes) if (route.componentPath) {
+		const componentDir = dirname(relative(cwd, route.componentPath));
+		const componentNameWithoutExt = basename(route.componentPath).replace(/\.[^.]+$/, "");
+		map.set(componentDir, route);
+		map.set(basename(componentDir), route);
+		map.set(componentNameWithoutExt, route);
+	}
+	return map;
+}
+/**
+* Find matching route from the component map for a given route file
+*/
+function findMatchingRoute(routeFile, routeComponentMap) {
+	const routeDir = dirname(routeFile);
+	const routeDirName = basename(routeDir);
+	if (routeComponentMap.has(routeDir)) return routeComponentMap.get(routeDir) ?? null;
+	if (routeComponentMap.has(routeDirName)) return routeComponentMap.get(routeDirName) ?? null;
+	for (const [, route] of routeComponentMap) if (route.componentPath) {
+		if (basename(dirname(route.componentPath)) === routeDirName) return route;
+	}
+	return null;
+}
 const generateCommand = define({
 	name: "generate",
 	description: "Auto-generate screen.meta.ts files from route files",
@@ -3442,6 +3539,10 @@ async function generateFromRoutesFile(routesFile, cwd, options) {
 	for (const route of flatRoutes) {
 		const metaPath = determineMetaPath(route, cwd);
 		const absoluteMetaPath = resolve(cwd, metaPath);
+		if (matchesExcludePattern(metaPath, DEFAULT_EXCLUDE_PATTERNS)) {
+			skipped++;
+			continue;
+		}
 		if (!force && existsSync(absoluteMetaPath)) {
 			if (!interactive) {
 				skipped++;
@@ -3536,13 +3637,29 @@ async function generateFromRoutesPattern(routesPattern, cwd, options) {
 	logger.blank();
 	const routeFiles = await glob(routesPattern, {
 		cwd,
-		ignore
+		ignore: [...ignore, ...DEFAULT_EXCLUDE_PATTERNS]
 	});
 	if (routeFiles.length === 0) {
 		logger.warn(`No route files found matching: ${routesPattern}`);
 		return;
 	}
 	logger.log(`Found ${routeFiles.length} route files`);
+	let routeComponentMap = null;
+	if (routesPattern.includes(".vue")) {
+		const vueRouterConfig = detectVueRouterConfigFile(cwd);
+		if (vueRouterConfig) try {
+			const parseResult = parseVueRouterConfig(vueRouterConfig);
+			const flatRoutes = flattenRoutes(parseResult.routes);
+			if (flatRoutes.length > 0) {
+				routeComponentMap = buildRouteComponentMap(flatRoutes, cwd);
+				logger.log(`  ${logger.dim(`(using routes from ${relative(cwd, vueRouterConfig)})`)}`);
+			}
+			for (const warning of parseResult.warnings) logger.warn(warning);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			logger.warn(`Could not parse Vue Router config: ${message}`);
+		}
+	}
 	logger.blank();
 	let created = 0;
 	let skipped = 0;
@@ -3559,7 +3676,14 @@ async function generateFromRoutesPattern(routesPattern, cwd, options) {
 			skipped++;
 			continue;
 		}
-		const screenMeta = inferScreenMeta(routeDir, routesPattern);
+		let screenMeta;
+		const matchedRoute = routeComponentMap ? findMatchingRoute(routeFile, routeComponentMap) : null;
+		if (matchedRoute) screenMeta = {
+			id: matchedRoute.screenId,
+			title: matchedRoute.screenTitle,
+			route: matchedRoute.fullPath
+		};
+		else screenMeta = inferScreenMeta(routeDir, routesPattern);
 		let detectedApis = [];
 		if (detectApi && apiIntegration) {
 			const absoluteRouteFile = join(cwd, routeFile);