compmark-vue 0.2.5 → 0.3.0

package/dist/index.mjs

@@ -1,6 +1,320 @@
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { compileScript, parse } from "@vue/compiler-sfc";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { babelParse, compileScript, parse } from "@vue/compiler-sfc";
+import { glob } from "tinyglobby";
+//#region src/resolver.ts
+function resolveImportPath(importSource, sfcDir) {
+	try {
+		if (!importSource.startsWith(".") && !importSource.startsWith("@/") && !importSource.startsWith("~/")) return null;
+		if (importSource.startsWith("./") || importSource.startsWith("../")) return tryResolveFile(resolve(sfcDir, importSource));
+		const tsconfig = findTsConfig(sfcDir);
+		if (!tsconfig) return null;
+		const { paths, baseUrl } = readTsConfigPaths(tsconfig);
+		if (!paths) return null;
+		const configDir = dirname(tsconfig);
+		const resolvedBaseUrl = baseUrl ? resolve(configDir, baseUrl) : configDir;
+		for (const [pattern, targets] of Object.entries(paths)) {
+			const prefix = pattern.replace(/\*$/, "");
+			if (!importSource.startsWith(prefix)) continue;
+			const remainder = importSource.slice(prefix.length);
+			for (const target of targets) {
+				const result = tryResolveFile(resolve(resolvedBaseUrl, target.replace(/\*$/, "") + remainder));
+				if (result) return result;
+			}
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+function tryResolveFile(basePath) {
+	if (existsSync(basePath) && !isDirectory$1(basePath)) return basePath;
+	for (const ext of [".ts", ".js"]) {
+		const candidate = basePath + ext;
+		if (existsSync(candidate)) return candidate;
+	}
+	for (const ext of ["/index.ts", "/index.js"]) {
+		const candidate = basePath + ext;
+		if (existsSync(candidate)) return candidate;
+	}
+	return null;
+}
+function isDirectory$1(filePath) {
+	try {
+		return statSync(filePath).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function findTsConfig(startDir) {
+	let dir = resolve(startDir);
+	const root = resolve("/");
+	while (dir !== root) {
+		const tsconfig = join(dir, "tsconfig.json");
+		if (existsSync(tsconfig)) return tsconfig;
+		const jsconfig = join(dir, "jsconfig.json");
+		if (existsSync(jsconfig)) return jsconfig;
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return null;
+}
+function readTsConfigPaths(configPath) {
+	try {
+		const content = JSON.parse(readFileSync(configPath, "utf-8"));
+		let paths = content.compilerOptions?.paths ?? null;
+		let baseUrl = content.compilerOptions?.baseUrl;
+		if (content.extends) {
+			const parentPath = resolve(dirname(configPath), content.extends);
+			const parentConfigFile = parentPath.endsWith(".json") ? parentPath : parentPath + ".json";
+			if (existsSync(parentConfigFile)) try {
+				const parentContent = JSON.parse(readFileSync(parentConfigFile, "utf-8"));
+				const parentPaths = parentContent.compilerOptions?.paths;
+				const parentBaseUrl = parentContent.compilerOptions?.baseUrl;
+				if (!paths && parentPaths) paths = parentPaths;
+				if (!baseUrl && parentBaseUrl) baseUrl = parentBaseUrl;
+			} catch {}
+		}
+		return {
+			paths,
+			baseUrl
+		};
+	} catch {
+		return {
+			paths: null,
+			baseUrl: void 0
+		};
+	}
+}
+function resolveComposableTypes(filePath, exportName, variableNames) {
+	try {
+		const funcNode = findExportedFunction(babelParse(readFileSync(filePath, "utf-8"), {
+			plugins: ["typescript", "jsx"],
+			sourceType: "module"
+		}).program.body, exportName);
+		if (!funcNode) return /* @__PURE__ */ new Map();
+		const body = getFunctionBody(funcNode);
+		if (!body) return /* @__PURE__ */ new Map();
+		const returnProps = findReturnProperties(body);
+		if (!returnProps) return /* @__PURE__ */ new Map();
+		const result = /* @__PURE__ */ new Map();
+		const nameSet = new Set(variableNames);
+		for (const prop of returnProps) {
+			let propName = null;
+			if (prop.type === "ObjectProperty") propName = prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "StringLiteral" ? prop.key.value : null;
+			else if (prop.type === "ObjectMethod") {
+				propName = prop.key.type === "Identifier" ? prop.key.name : null;
+				if (propName && nameSet.has(propName)) result.set(propName, inferFunctionSignature(prop));
+				continue;
+			} else if (prop.type === "SpreadElement") continue;
+			if (!propName || !nameSet.has(propName)) continue;
+			if (prop.type === "ObjectProperty" && prop.shorthand) {
+				const type = traceVariableType(propName, body);
+				result.set(propName, type);
+			} else if (prop.type === "ObjectProperty") {
+				const type = inferType(prop.value);
+				result.set(propName, type);
+			}
+		}
+		return result;
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+}
+function findExportedFunction(stmts, exportName) {
+	for (const stmt of stmts) {
+		if (stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "FunctionDeclaration" && stmt.declaration.id?.name === exportName) return stmt.declaration;
+		if (stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "VariableDeclaration") {
+			for (const decl of stmt.declaration.declarations) if (decl.id.type === "Identifier" && decl.id.name === exportName && decl.init && (decl.init.type === "ArrowFunctionExpression" || decl.init.type === "FunctionExpression")) return decl.init;
+		}
+		if (stmt.type === "ExportDefaultDeclaration" && stmt.declaration.type === "FunctionDeclaration" && stmt.declaration.id?.name === exportName) return stmt.declaration;
+		if (stmt.type === "ExportDefaultDeclaration" && stmt.declaration.type === "FunctionDeclaration" && !stmt.declaration.id) return stmt.declaration;
+		if (stmt.type === "ExportDefaultDeclaration" && (stmt.declaration.type === "ArrowFunctionExpression" || stmt.declaration.type === "FunctionExpression")) return stmt.declaration;
+		if (stmt.type === "FunctionDeclaration" && stmt.id?.name === exportName) {
+			if (stmts.some((s) => s.type === "ExportNamedDeclaration" && !s.declaration && s.specifiers.some((spec) => spec.type === "ExportSpecifier" && (spec.local.type === "Identifier" && spec.local.name === exportName || spec.exported.type === "Identifier" && spec.exported.name === exportName)))) return stmt;
+		}
+		if (stmt.type === "VariableDeclaration") {
+			for (const decl of stmt.declarations) if (decl.id.type === "Identifier" && decl.id.name === exportName && decl.init && (decl.init.type === "ArrowFunctionExpression" || decl.init.type === "FunctionExpression")) {
+				if (stmts.some((s) => s.type === "ExportNamedDeclaration" && !s.declaration && s.specifiers.some((spec) => spec.type === "ExportSpecifier" && (spec.local.type === "Identifier" && spec.local.name === exportName || spec.exported.type === "Identifier" && spec.exported.name === exportName)))) return decl.init;
+			}
+		}
+	}
+	return null;
+}
+function getFunctionBody(node) {
+	if (node.body.type === "BlockStatement") return node.body.body;
+	return null;
+}
+function findReturnProperties(body) {
+	for (let i = body.length - 1; i >= 0; i--) {
+		const stmt = body[i];
+		if (stmt.type === "ReturnStatement" && stmt.argument?.type === "ObjectExpression") return stmt.argument.properties;
+	}
+	return null;
+}
+function traceVariableType(name, body) {
+	for (let i = body.length - 1; i >= 0; i--) {
+		const stmt = body[i];
+		if (stmt.type === "FunctionDeclaration" && stmt.id?.name === name) return inferFunctionSignature(stmt);
+		if (stmt.type === "VariableDeclaration") {
+			for (const decl of stmt.declarations) if (decl.id.type === "Identifier" && decl.id.name === name && decl.init) return inferType(decl.init);
+		}
+	}
+	return "unknown";
+}
+function inferType(node) {
+	if (node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "ref") {
+		const typeParams = node.typeParameters;
+		if (typeParams?.params?.length > 0) return `Ref<${resolveTypeAnnotation(typeParams.params[0])}>`;
+		const arg = node.arguments[0];
+		if (!arg) return "Ref<unknown>";
+		return `Ref<${inferLiteralType(arg)}>`;
+	}
+	if (node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "computed") return "ComputedRef";
+	if (node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "reactive") return "Object";
+	if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") return inferFunctionSignature(node);
+	if (node.type === "CallExpression" && node.callee.type === "Identifier" && /^use[A-Z]/.test(node.callee.name)) return "unknown";
+	return inferLiteralType(node);
+}
+function inferLiteralType(node) {
+	switch (node.type) {
+		case "NumericLiteral": return "number";
+		case "StringLiteral": return "string";
+		case "BooleanLiteral": return "boolean";
+		case "NullLiteral": return "null";
+		case "TemplateLiteral": return "string";
+		case "ArrayExpression": return "Array";
+		case "ObjectExpression": return "Object";
+		default: return "unknown";
+	}
+}
+function inferFunctionSignature(node) {
+	return `(${extractParams(node.params ?? [])}) => ${extractReturnType(node)}`;
+}
+function extractParams(params) {
+	return params.map((param) => {
+		if (param.type === "Identifier") {
+			const annotation = param.typeAnnotation?.typeAnnotation;
+			if (annotation) return `${param.name}: ${resolveTypeAnnotation(annotation)}`;
+			return param.name;
+		}
+		if (param.type === "AssignmentPattern") {
+			const left = param.left;
+			if (left.type === "Identifier") {
+				const annotation = left.typeAnnotation?.typeAnnotation;
+				if (annotation) return `${left.name}: ${resolveTypeAnnotation(annotation)}`;
+				return left.name;
+			}
+			return "arg";
+		}
+		if (param.type === "RestElement") {
+			const arg = param.argument;
+			if (arg.type === "Identifier") {
+				const annotation = arg.typeAnnotation?.typeAnnotation;
+				if (annotation) return `...${arg.name}: ${resolveTypeAnnotation(annotation)}`;
+				return `...${arg.name}`;
+			}
+			return "...args";
+		}
+		if (param.type === "ObjectPattern") return "options";
+		if (param.type === "ArrayPattern") return "args";
+		return "arg";
+	}).join(", ");
+}
+function extractReturnType(node) {
+	const annotation = node.returnType?.typeAnnotation ?? node.typeAnnotation?.typeAnnotation;
+	let baseType;
+	if (annotation) baseType = resolveTypeAnnotation(annotation);
+	else baseType = "void";
+	if (node.async && baseType !== "void") return `Promise<${baseType}>`;
+	if (node.async) return "Promise<void>";
+	return baseType;
+}
+function resolveTypeAnnotation(node) {
+	if (!node) return "unknown";
+	switch (node.type) {
+		case "TSStringKeyword": return "string";
+		case "TSNumberKeyword": return "number";
+		case "TSBooleanKeyword": return "boolean";
+		case "TSVoidKeyword": return "void";
+		case "TSAnyKeyword": return "any";
+		case "TSNullKeyword": return "null";
+		case "TSUndefinedKeyword": return "undefined";
+		case "TSObjectKeyword": return "object";
+		case "TSNeverKeyword": return "never";
+		case "TSUnknownKeyword": return "unknown";
+		case "TSTypeReference": {
+			const name = node.typeName?.type === "Identifier" ? node.typeName.name : node.typeName?.type === "TSQualifiedName" ? `${node.typeName.left?.name ?? ""}.${node.typeName.right?.name ?? ""}` : "unknown";
+			if (node.typeParameters?.params?.length > 0) return `${name}<${node.typeParameters.params.map((p) => resolveTypeAnnotation(p)).join(", ")}>`;
+			return name;
+		}
+		case "TSUnionType": return node.types.map((t) => resolveTypeAnnotation(t)).join(" | ");
+		case "TSIntersectionType": return node.types.map((t) => resolveTypeAnnotation(t)).join(" & ");
+		case "TSArrayType": return `${resolveTypeAnnotation(node.elementType)}[]`;
+		case "TSLiteralType":
+			if (node.literal.type === "StringLiteral") return `'${node.literal.value}'`;
+			if (node.literal.type === "NumericLiteral") return String(node.literal.value);
+			if (node.literal.type === "BooleanLiteral") return String(node.literal.value);
+			return "unknown";
+		case "TSFunctionType": return "Function";
+		case "TSTupleType": return `[${(node.elementTypes ?? []).map((t) => resolveTypeAnnotation(t)).join(", ")}]`;
+		case "TSParenthesizedType": return resolveTypeAnnotation(node.typeAnnotation);
+		case "TSTypeLiteral": return "object";
+		default: return "unknown";
+	}
+}
+//#endregion
+//#region src/type-resolver.ts
+function resolveImportedPropsType(typeName, importMap, sfcDir) {
+	const source = importMap.get(typeName);
+	if (!source) return null;
+	const resolvedPath = resolveImportPath(source, sfcDir);
+	if (!resolvedPath) return null;
+	try {
+		return findExportedType(babelParse(readFileSync(resolvedPath, "utf-8"), {
+			plugins: ["typescript"],
+			sourceType: "module"
+		}).program.body, typeName, 0);
+	} catch {
+		return null;
+	}
+}
+function findExportedType(stmts, typeName, depth) {
+	if (depth > 5) return null;
+	for (const stmt of stmts) {
+		if (stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "TSInterfaceDeclaration" && stmt.declaration.id.name === typeName) return resolveInterfaceMembers(stmt.declaration, stmts, depth);
+		if (stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "TSTypeAliasDeclaration" && stmt.declaration.id.name === typeName && stmt.declaration.typeAnnotation.type === "TSTypeLiteral") return { members: [...stmt.declaration.typeAnnotation.members] };
+	}
+	if (hasNamedExport(stmts, typeName)) return findTypeInFile(stmts, typeName, depth);
+	return null;
+}
+function findTypeInFile(stmts, typeName, depth) {
+	if (depth > 5) return null;
+	for (const stmt of stmts) {
+		if (stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "TSInterfaceDeclaration" && stmt.declaration.id.name === typeName) return resolveInterfaceMembers(stmt.declaration, stmts, depth);
+		if (stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "TSTypeAliasDeclaration" && stmt.declaration.id.name === typeName && stmt.declaration.typeAnnotation.type === "TSTypeLiteral") return { members: [...stmt.declaration.typeAnnotation.members] };
+		if (stmt.type === "TSInterfaceDeclaration" && stmt.id.name === typeName) return resolveInterfaceMembers(stmt, stmts, depth);
+		if (stmt.type === "TSTypeAliasDeclaration" && stmt.id.name === typeName && stmt.typeAnnotation.type === "TSTypeLiteral") return { members: [...stmt.typeAnnotation.members] };
+	}
+	return null;
+}
+function resolveInterfaceMembers(decl, stmts, depth) {
+	const members = [];
+	if (decl.extends) for (const ext of decl.extends) {
+		const parentName = ext.expression?.type === "Identifier" ? ext.expression.name : null;
+		if (parentName) {
+			const parent = findTypeInFile(stmts, parentName, depth + 1);
+			if (parent) members.push(...parent.members);
+		}
+	}
+	members.push(...decl.body.body);
+	return { members };
+}
+function hasNamedExport(stmts, name) {
+	return stmts.some((s) => s.type === "ExportNamedDeclaration" && !s.declaration && s.specifiers.some((spec) => spec.type === "ExportSpecifier" && (spec.local.type === "Identifier" && spec.local.name === name || spec.exported.type === "Identifier" && spec.exported.name === name)));
+}
+//#endregion
 //#region src/parser.ts
 function parseJSDocTags(comments) {
 	const result = { description: "" };
@@ -21,35 +335,61 @@ function parseJSDocTags(comments) {
 	result.description = descLines.join(" ");
 	return result;
 }
-function parseSFC(source, filename) {
+function parseSFC(source, filename, sfcDir) {
 	const doc = {
 		name: filename.replace(/\.vue$/, "").split("/").pop() ?? "Unknown",
 		props: [],
 		emits: []
 	};
-	const { descriptor } = parse(source, { filename });
+	const fullPath = sfcDir ? `${sfcDir}/${filename}` : filename;
+	const { descriptor } = parse(source, { filename: fullPath });
+	doc.scriptSetup = !!descriptor.scriptSetup;
 	if (descriptor.template?.ast) {
 		const templateSlots = extractTemplateSlots(descriptor.template.ast);
 		if (templateSlots.length > 0) doc.slots = templateSlots;
 	}
 	if (!descriptor.scriptSetup && !descriptor.script) return doc;
-	const compiled = compileScript(descriptor, { id: filename });
+	let compiled;
+	try {
+		compiled = compileScript(descriptor, {
+			id: fullPath,
+			fs: {
+				fileExists: (file) => existsSync(file),
+				readFile: (file) => {
+					try {
+						return readFileSync(file, "utf-8");
+					} catch {
+						return;
+					}
+				}
+			}
+		});
+	} catch {
+		return doc;
+	}
 	const componentJSDoc = extractComponentJSDoc(compiled.scriptSetupAst ?? compiled.scriptAst ?? []);
 	doc.description = componentJSDoc.description;
 	doc.internal = componentJSDoc.internal;
 	const setupAst = compiled.scriptSetupAst;
 	if (setupAst) {
 		const scriptSource = descriptor.scriptSetup?.content ?? compiled.content;
+		const importMap = buildImportMap(setupAst);
 		for (const stmt of setupAst) {
 			const calls = extractDefineCalls(stmt);
 			for (const { callee, args, leadingComments, typeParams, defaultsArg } of calls) if (callee === "defineProps" && args[0]?.type === "ObjectExpression") doc.props = extractProps(args[0], scriptSource);
 			else if (callee === "defineProps" && typeParams?.params[0]?.type === "TSTypeLiteral") doc.props = extractTypeProps(typeParams.params[0], defaultsArg, scriptSource);
-			else if (callee === "defineEmits" && args[0]?.type === "ArrayExpression") doc.emits = extractEmits(args[0], leadingComments);
+			else if (callee === "defineProps" && typeParams?.params[0]?.type === "TSTypeReference") {
+				const typeName = typeParams.params[0].typeName?.name;
+				if (typeName && sfcDir) {
+					const resolved = resolveImportedPropsType(typeName, importMap, sfcDir);
+					if (resolved) doc.props = extractTypeProps(resolved, defaultsArg, scriptSource);
+				}
+			} else if (callee === "defineEmits" && args[0]?.type === "ArrayExpression") doc.emits = extractEmits(args[0], leadingComments);
 			else if (callee === "defineEmits" && typeParams?.params[0]?.type === "TSTypeLiteral") doc.emits = extractTypeEmits(typeParams.params[0]);
 			else if (callee === "defineSlots" && typeParams?.params[0]?.type === "TSTypeLiteral") doc.slots = extractTypeSlots(typeParams.params[0]);
 			else if (callee === "defineExpose" && args[0]?.type === "ObjectExpression") doc.exposes = extractExposes(args[0], scriptSource);
 		}
-		doc.composables = extractComposables(setupAst);
+		doc.composables = extractComposables(setupAst, importMap, sfcDir);
 	}
 	const scriptAst = compiled.scriptAst;
 	if (scriptAst && doc.props.length === 0 && doc.emits.length === 0) {
@@ -330,26 +670,94 @@ function extractExposes(obj, _source) {
 	}
 	return exposes;
 }
-function extractComposables(ast) {
+function buildImportMap(ast) {
+	const map = /* @__PURE__ */ new Map();
+	for (const stmt of ast) if (stmt.type === "ImportDeclaration") {
+		for (const spec of stmt.specifiers ?? []) if (spec.type === "ImportSpecifier" || spec.type === "ImportDefaultSpecifier") map.set(spec.local.name, stmt.source.value);
+	}
+	return map;
+}
+function extractVariablesFromPattern(decl) {
+	const id = decl.id;
+	if (!id) return [];
+	if (id.type === "Identifier") {
+		const v = { name: id.name };
+		if (id.typeAnnotation?.typeAnnotation) v.type = resolveTypeString(id.typeAnnotation.typeAnnotation);
+		return [v];
+	}
+	if (id.type === "ObjectPattern") {
+		const vars = [];
+		const typeAnnotation = id.typeAnnotation?.typeAnnotation;
+		const typeMembers = typeAnnotation?.type === "TSTypeLiteral" ? typeAnnotation.members : null;
+		for (const prop of id.properties) if (prop.type === "RestElement") {
+			const name = prop.argument?.name ?? "rest";
+			vars.push({ name });
+		} else if (prop.type === "ObjectProperty") {
+			const name = prop.value?.type === "Identifier" ? prop.value.name : prop.value?.type === "AssignmentPattern" && prop.value.left?.type === "Identifier" ? prop.value.left.name : prop.key?.type === "Identifier" ? prop.key.name : "";
+			if (!name) continue;
+			const v = { name };
+			if (typeMembers) {
+				const keyName = prop.key?.type === "Identifier" ? prop.key.name : "";
+				for (const member of typeMembers) if (member.type === "TSPropertySignature" && member.key?.type === "Identifier" && member.key.name === keyName && member.typeAnnotation?.typeAnnotation) {
+					v.type = resolveTypeString(member.typeAnnotation.typeAnnotation);
+					break;
+				}
+			}
+			vars.push(v);
+		}
+		return vars;
+	}
+	if (id.type === "ArrayPattern") {
+		const vars = [];
+		for (const el of id.elements) {
+			if (!el) continue;
+			if (el.type === "Identifier") vars.push({ name: el.name });
+			else if (el.type === "RestElement" && el.argument?.type === "Identifier") vars.push({ name: el.argument.name });
+			else if (el.type === "AssignmentPattern" && el.left?.type === "Identifier") vars.push({ name: el.left.name });
+		}
+		return vars;
+	}
+	return [];
+}
+function extractComposables(ast, importMap, sfcDir) {
 	const seen = /* @__PURE__ */ new Set();
 	const composables = [];
 	for (const stmt of ast) {
-		const callNames = extractComposableCallNames(stmt);
-		for (const name of callNames) if (!seen.has(name)) {
-			seen.add(name);
-			composables.push({ name });
+		if (stmt.type === "ExpressionStatement" && stmt.expression.type === "CallExpression" && stmt.expression.callee.type === "Identifier" && /^use[A-Z]/.test(stmt.expression.callee.name)) {
+			const name = stmt.expression.callee.name;
+			if (!seen.has(name)) {
+				seen.add(name);
+				composables.push({
+					name,
+					source: importMap.get(name),
+					variables: []
+				});
+			}
+		}
+		if (stmt.type === "VariableDeclaration") {
+			for (const decl of stmt.declarations) if (decl.init?.type === "CallExpression" && decl.init.callee.type === "Identifier" && /^use[A-Z]/.test(decl.init.callee.name)) {
+				const name = decl.init.callee.name;
+				if (seen.has(name)) continue;
+				seen.add(name);
+				const variables = extractVariablesFromPattern(decl);
+				const source = importMap.get(name);
+				if (variables.some((v) => !v.type) && sfcDir && source) {
+					const resolvedPath = resolveImportPath(source, sfcDir);
+					if (resolvedPath) {
+						const typeMap = resolveComposableTypes(resolvedPath, name, variables.filter((v) => !v.type).map((v) => v.name));
+						for (const v of variables) if (!v.type && typeMap.has(v.name)) v.type = typeMap.get(v.name);
+					}
+				}
+				composables.push({
+					name,
+					source,
+					variables
+				});
+			}
 		}
 	}
 	return composables;
 }
-function extractComposableCallNames(stmt) {
-	const names = [];
-	if (stmt.type === "ExpressionStatement" && stmt.expression.type === "CallExpression" && stmt.expression.callee.type === "Identifier" && /^use[A-Z]/.test(stmt.expression.callee.name)) names.push(stmt.expression.callee.name);
-	if (stmt.type === "VariableDeclaration") {
-		for (const decl of stmt.declarations) if (decl.init?.type === "CallExpression" && decl.init.callee.type === "Identifier" && /^use[A-Z]/.test(decl.init.callee.name)) names.push(decl.init.callee.name);
-	}
-	return names;
-}
 function extractTemplateSlots(templateAst) {
 	const slots = [];
 	walkTemplate(templateAst.children ?? [], slots);
@@ -447,9 +855,13 @@ function stringifyDefault(node, source) {
 function esc(value) {
 	return value.replaceAll("|", "\\|");
 }
+function escHtml(value) {
+	return value.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
 function generateMarkdown(doc) {
 	const sections = [`# ${doc.name}`];
 	if (doc.description) sections.push("", doc.description);
+	if (doc.scriptSetup) sections.push("", "**Note:** Uses `<script setup>` syntax.");
 	const hasProps = doc.props.length > 0;
 	const hasEmits = doc.emits.length > 0;
 	const hasSlots = (doc.slots?.length ?? 0) > 0;
@@ -517,16 +929,113 @@ function generateMarkdown(doc) {
 		}
 	}
 	if (hasComposables) {
-		sections.push("", "## Composables Used", "");
-		for (const c of doc.composables) sections.push(`- \`${c.name}\``);
+		sections.push("", "## Composables Used");
+		for (const c of doc.composables) {
+			sections.push("", `### \`${c.name}\``);
+			if (c.source && (c.source.startsWith(".") || c.source.startsWith("@/"))) sections.push("", `*Source: \`${c.source}\`*`);
+			if (c.variables.length === 0) sections.push("", "Called for side effects.");
+			else if (!c.variables.some((v) => v.type) && c.variables.length <= 3) {
+				const vars = c.variables.map((v) => `\`${v.name}\``).join(", ");
+				sections.push("", `**Returns:** ${vars}`);
+			} else {
+				sections.push("");
+				sections.push("| Variable | Type |");
+				sections.push("| --- | --- |");
+				for (const v of c.variables) {
+					const type = v.type ? escHtml(esc(v.type)) : "-";
+					sections.push(`| ${esc(v.name)} | ${type} |`);
+				}
+			}
+		}
 	}
 	return sections.join("\n") + "\n";
 }
+function adjustHeadingLevel(md, increment) {
+	return md.replace(/^(#{1,6})\s/gm, (_, hashes) => {
+		const newLevel = Math.min(hashes.length + increment, 6);
+		return "#".repeat(newLevel) + " ";
+	});
+}
+//#endregion
+//#region src/discovery.ts
+async function discoverFiles(inputs, ignore) {
+	const baseIgnore = ["**/node_modules/**"];
+	const userIgnore = (ignore ?? []).map(normalizeIgnorePattern);
+	const allIgnore = [...baseIgnore, ...userIgnore];
+	const found = /* @__PURE__ */ new Set();
+	for (const input of inputs) {
+		const resolved = resolve(input);
+		if (input.endsWith(".vue") && existsSync(resolved)) found.add(resolved);
+		else if (isDirectory(resolved)) {
+			const files = await glob("**/*.vue", {
+				cwd: resolved,
+				absolute: true,
+				ignore: allIgnore
+			});
+			for (const f of files) found.add(f);
+		} else {
+			const files = await glob(input, {
+				absolute: true,
+				ignore: allIgnore
+			});
+			for (const f of files) found.add(f);
+		}
+	}
+	return [...found].sort();
+}
+function isDirectory(path) {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function normalizeIgnorePattern(pattern) {
+	if (pattern.includes("*") || pattern.includes("/")) return pattern;
+	return `**/${pattern}/**`;
+}
+//#endregion
+//#region src/runner.ts
+function processFiles(filePaths, options) {
+	const summary = {
+		documented: 0,
+		skipped: 0,
+		errors: 0,
+		files: [],
+		errorDetails: []
+	};
+	for (const filePath of filePaths) try {
+		const doc = parseComponent(filePath);
+		if (doc.internal) {
+			summary.skipped++;
+			if (!options.silent) {
+				const name = filePath.split("/").pop() ?? filePath;
+				console.log(`  Skipped ${name} (marked @internal)`);
+			}
+			continue;
+		}
+		summary.documented++;
+		summary.files.push({
+			path: filePath,
+			doc
+		});
+	} catch (err) {
+		summary.errors++;
+		const name = filePath.split("/").pop() ?? filePath;
+		const message = err instanceof Error ? err.message : String(err);
+		summary.errorDetails.push({
+			path: filePath,
+			error: message
+		});
+		if (!options.silent) console.warn(`  Warning: Could not parse ${name}: ${message}`);
+	}
+	return summary;
+}
 //#endregion
 //#region src/index.ts
 function parseComponent(filePath) {
 	const abs = resolve(filePath);
-	return parseSFC(readFileSync(abs, "utf-8"), abs.split("/").pop() ?? "Unknown.vue");
+	return parseSFC(readFileSync(abs, "utf-8"), abs.split("/").pop() ?? "Unknown.vue", abs.substring(0, abs.lastIndexOf("/")));
 }
 //#endregion
-export { generateMarkdown, parseComponent, parseSFC };
+export { adjustHeadingLevel, discoverFiles, generateMarkdown, parseComponent, parseSFC, processFiles, resolveImportedPropsType };

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "compmark-vue",
-  "version": "0.2.5",
+  "version": "0.3.0",
   "description": "Auto-generate Markdown documentation from Vue 3 SFCs",
   "license": "MIT",
   "repository": "noopurphalak/compmark-vue",
   "bin": {
-    "compmark": "./dist/cli.mjs"
+    "compmark": "./dist/cli.mjs",
+    "compmark-vue": "./dist/cli.mjs"
   },
   "files": [
     "dist"
@@ -28,7 +29,9 @@
     "prepare": "husky"
   },
   "dependencies": {
-    "@vue/compiler-sfc": "^3.5.0"
+    "@vue/compiler-sfc": "^3.5.0",
+    "citty": "^0.2.1",
+    "tinyglobby": "^0.2.15"
   },
   "devDependencies": {
     "@babel/types": "latest",
@@ -51,5 +54,8 @@
       "oxfmt"
     ]
   },
+  "engines": {
+    "node": ">=20"
+  },
   "packageManager": "pnpm@10.29.3"
 }