compmark-vue 0.2.4 → 0.2.6

package/README.md

@@ -17,25 +17,64 @@ npx compmark-vue ./src/components/Button.vue
 
 This parses the component and creates `Button.md` in your current directory.
 
-### Example Output
+## Features
 
-Given a component like:
+- [Props](#props) — runtime and TypeScript generic syntax
+- [Emits](#emits) — array, TypeScript property, and call signature syntax
+- [Slots](#slots) — `defineSlots` with typed bindings, template `<slot>` fallback
+- [Expose](#expose) — `defineExpose` with JSDoc descriptions
+- [Composables](#composables) — auto-detects `useX()` calls in `<script setup>`
+- [JSDoc tags](#jsdoc-tags) — `@deprecated`, `@since`, `@example`, `@see`, `@default`
+- [`@internal`](#internal-components) — exclude components from output
+- [Options API](#options-api) — `export default { props, emits }` support
+- Empty sections are skipped cleanly — no placeholder noise
+
+## Examples
+
+### Props
+
+Runtime syntax, TypeScript generics, and `withDefaults` are all supported:
 
 ```vue
-<script setup>
-/**
- * @emit submit Emitted on form submit
- * @emit cancel Emitted on cancel
- */
-const emit = defineEmits(["submit", "cancel"]);
+<script setup lang="ts">
+const props = withDefaults(
+  defineProps<{
+    /** The label text */
+    label: string;
+    /** Visual theme */
+    theme?: "filled" | "outline";
+    disabled?: boolean;
+  }>(),
+  {
+    theme: "filled",
+    disabled: false,
+  },
+);
+</script>
+```
 
-const props = defineProps({
+Output:
+
+```md
+## Props
+
+| Name     | Type                  | Required | Default    | Description    |
+| -------- | --------------------- | -------- | ---------- | -------------- |
+| label    | string                | Yes      | -          | The label text |
+| theme    | 'filled' \| 'outline' | No       | `"filled"` | Visual theme   |
+| disabled | boolean               | No       | `false`    | -              |
+```
+
+Runtime object syntax is also supported:
+
+```vue
+<script setup>
+defineProps({
   /** Title of the dialog */
   title: {
     type: String,
     required: true,
   },
-  /** Whether the dialog is visible */
   visible: {
     type: Boolean,
     default: false,
@@ -44,24 +83,224 @@ const props = defineProps({
 </script>
 ```
 
-compmark-vue generates:
+### Emits
+
+TypeScript generic syntax with payloads:
+
+```vue
+<script setup lang="ts">
+const emit = defineEmits<{
+  /** Emitted on save */
+  save: [data: Record<string, unknown>];
+  /** Emitted on cancel */
+  cancel: [];
+}>();
+</script>
+```
+
+Output:
+
+```md
+## Emits
+
+| Name   | Payload                       | Description       |
+| ------ | ----------------------------- | ----------------- |
+| save   | data: Record<string, unknown> | Emitted on save   |
+| cancel | -                             | Emitted on cancel |
+```
+
+Call signature syntax is also supported:
+
+```vue
+<script setup lang="ts">
+defineEmits<{
+  (e: "click", payload: MouseEvent): void;
+  (e: "submit"): void;
+}>();
+</script>
+```
+
+Array syntax works too: `defineEmits(["click", "submit"])`.
+
+### Slots
+
+`defineSlots` provides typed bindings:
+
+```vue
+<script setup lang="ts">
+defineSlots<{
+  /** Main content */
+  default(props: { msg: string }): any;
+  /** Header area */
+  header(props: { title: string; count: number }): any;
+}>();
+</script>
+```
+
+Output:
 
 ```md
-# Dialog
+## Slots
+
+| Name    | Bindings                     | Description  |
+| ------- | ---------------------------- | ------------ |
+| default | msg: string                  | Main content |
+| header  | title: string, count: number | Header area  |
+```
+
+If `defineSlots` is not used, slots are extracted from template `<slot>` elements as a fallback:
+
+```vue
+<template>
+  <div>
+    <slot />
+    <slot name="header" :title="title" />
+    <slot name="footer" />
+  </div>
+</template>
+```
+
+### Expose
+
+```vue
+<script setup lang="ts">
+defineExpose({
+  /** Focus the component */
+  focus,
+  /** Reset the component state */
+  reset,
+});
+</script>
+```
 
+Output:
+
+```md
+## Exposed
+
+| Name  | Type    | Description               |
+| ----- | ------- | ------------------------- |
+| focus | unknown | Focus the component       |
+| reset | unknown | Reset the component state |
+```
+
+### Composables
+
+Any `useX()` calls in `<script setup>` are automatically detected:
+
+```vue
+<script setup lang="ts">
+import { useRouter } from "vue-router";
+import { useMouse } from "@vueuse/core";
+
+const router = useRouter();
+const { x, y } = useMouse();
+</script>
+```
+
+Output:
+
+```md
+## Composables Used
+
+- `useRouter`
+- `useMouse`
+```
+
+### JSDoc Tags
+
+Props support `@deprecated`, `@since`, `@example`, and `@see`:
+
+```vue
+<script setup lang="ts">
+defineProps<{
+  /**
+   * The label text
+   * @deprecated Use `text` instead
+   * @since 1.0.0
+   * @example "Hello World"
+   * @see https://example.com/docs
+   */
+  label: string;
+}>();
+</script>
+```
+
+Output:
+
+````md
 ## Props
 
-| Name    | Type    | Required | Default | Description                   |
-| ------- | ------- | -------- | ------- | ----------------------------- |
-| title   | String  | Yes      | -       | Title of the dialog           |
-| visible | Boolean | No       | `false` | Whether the dialog is visible |
+| Name  | Type   | Required | Default | Description                                                                                     |
+| ----- | ------ | -------- | ------- | ----------------------------------------------------------------------------------------------- |
+| label | string | Yes      | -       | The label text **Deprecated**: Use `text` instead _(since 1.0.0)_ See: https://example.com/docs |
+
+**`label` example:**
+
+```
+"Hello World"
+```
+````
+
+### Internal Components
+
+Mark a component with `@internal` to skip it during generation:
+
+```vue
+<script setup lang="ts">
+/**
+ * @internal
+ */
+defineProps<{
+  value: string;
+}>();
+</script>
+```
+
+```sh
+$ compmark InternalHelper.vue
+Skipped InternalHelper.vue (marked @internal)
+```
+
+### Options API
+
+Components using `export default {}` are supported:
+
+```vue
+<script>
+export default {
+  props: {
+    /** The title text */
+    title: {
+      type: String,
+      required: true,
+    },
+    count: {
+      type: Number,
+      default: 10,
+    },
+  },
+  emits: ["click", "update"],
+};
+</script>
+```
+
+Output:
+
+```md
+## Props
+
+| Name  | Type   | Required | Default | Description    |
+| ----- | ------ | -------- | ------- | -------------- |
+| title | String | Yes      | -       | The title text |
+| count | Number | No       | `10`    | -              |
 
 ## Emits
 
-| Name   | Description            |
-| ------ | ---------------------- |
-| submit | Emitted on form submit |
-| cancel | Emitted on cancel      |
+| Name   | Description |
+| ------ | ----------- |
+| click  | -           |
+| update | -           |
 ```
 
 ## Programmatic API
@@ -86,14 +325,6 @@ const doc = parseSFC(source, "Button.vue");
 const md = generateMarkdown(doc);
 ```
 
-## Supported Syntax
-
-- `defineProps({ ... })` — shorthand (`String`), array type (`[String, Number]`), and full object syntax
-- `defineEmits([...])` — array syntax
-- JSDoc comments on props and emits (`/** ... */`)
-- `const props = defineProps(...)` variable assignment pattern
-- Default value extraction (string, number, boolean literals, arrow functions)
-
 ## Development
 
 <details>

package/dist/cli.mjs

@@ -1,7 +1,270 @@
 #!/usr/bin/env node
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { compileScript, parse } from "@vue/compiler-sfc";
+import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { babelParse, compileScript, parse } from "@vue/compiler-sfc";
+//#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(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(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/parser.ts
 function parseJSDocTags(comments) {
 	const result = { description: "" };
@@ -22,7 +285,7 @@ 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: [],
@@ -50,7 +313,7 @@ function parseSFC(source, filename) {
 			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, buildImportMap(setupAst), sfcDir);
 	}
 	const scriptAst = compiled.scriptAst;
 	if (scriptAst && doc.props.length === 0 && doc.emits.length === 0) {
@@ -331,26 +594,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);
@@ -448,6 +779,9 @@ 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);
@@ -518,8 +852,24 @@ 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";
 }
@@ -527,7 +877,7 @@ function generateMarkdown(doc) {
 //#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
 //#region src/cli.ts

package/dist/index.d.mts

@@ -25,8 +25,14 @@ interface ExposeDoc {
   type: string;
   description: string;
 }
+interface ComposableVariable {
+  name: string;
+  type?: string;
+}
 interface ComposableDoc {
   name: string;
+  source?: string;
+  variables: ComposableVariable[];
 }
 interface ComponentDoc {
   name: string;
@@ -40,7 +46,7 @@ interface ComponentDoc {
 }
 //#endregion
 //#region src/parser.d.ts
-declare function parseSFC(source: string, filename: string): ComponentDoc;
+declare function parseSFC(source: string, filename: string, sfcDir?: string): ComponentDoc;
 //#endregion
 //#region src/markdown.d.ts
 declare function generateMarkdown(doc: ComponentDoc): string;
@@ -48,4 +54,4 @@ declare function generateMarkdown(doc: ComponentDoc): string;
 //#region src/index.d.ts
 declare function parseComponent(filePath: string): ComponentDoc;
 //#endregion
-export { type ComponentDoc, type ComposableDoc, type EmitDoc, type ExposeDoc, type PropDoc, type SlotDoc, generateMarkdown, parseComponent, parseSFC };
+export { type ComponentDoc, type ComposableDoc, type ComposableVariable, type EmitDoc, type ExposeDoc, type PropDoc, type SlotDoc, generateMarkdown, parseComponent, parseSFC };

package/dist/index.mjs

@@ -1,6 +1,269 @@
-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";
+//#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(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(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/parser.ts
 function parseJSDocTags(comments) {
 	const result = { description: "" };
@@ -21,7 +284,7 @@ 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: [],
@@ -49,7 +312,7 @@ function parseSFC(source, filename) {
 			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, buildImportMap(setupAst), sfcDir);
 	}
 	const scriptAst = compiled.scriptAst;
 	if (scriptAst && doc.props.length === 0 && doc.emits.length === 0) {
@@ -330,26 +593,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,6 +778,9 @@ 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);
@@ -517,8 +851,24 @@ 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";
 }
@@ -526,7 +876,7 @@ function generateMarkdown(doc) {
 //#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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "compmark-vue",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Auto-generate Markdown documentation from Vue 3 SFCs",
   "license": "MIT",
   "repository": "noopurphalak/compmark-vue",