@zeus-js/component-analyzer 0.1.0-beta.0

package/dist/component-analyzer.cjs.prod.js

@@ -0,0 +1,592 @@
+/**
+* component-analyzer v0.1.0-beta.0
+* (c) 2026 baicie
+* Released under the MIT License.
+**/
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _babel_parser = require("@babel/parser");
+let _babel_types = require("@babel/types");
+_babel_types = __toESM(_babel_types, 1);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises, 1);
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let fast_glob = require("fast-glob");
+fast_glob = __toESM(fast_glob, 1);
+//#region packages/web-c/component-analyzer/src/ast.ts
+function parseSource(code, file) {
+	return (0, _babel_parser.parse)(code, {
+		sourceType: "module",
+		sourceFilename: file,
+		plugins: [
+			"typescript",
+			"jsx",
+			"decorators-legacy",
+			"classProperties",
+			"objectRestSpread"
+		]
+	});
+}
+function walk(node, visitor, parent = null) {
+	var _t$VISITOR_KEYS$node$;
+	if (!node) return;
+	visitor(node, parent);
+	const keys = (_t$VISITOR_KEYS$node$ = _babel_types.VISITOR_KEYS[node.type]) !== null && _t$VISITOR_KEYS$node$ !== void 0 ? _t$VISITOR_KEYS$node$ : [];
+	for (const key of keys) {
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const child of value) if (child && typeof child === "object" && "type" in child) walk(child, visitor, node);
+		} else if (value && typeof value === "object" && "type" in value) walk(value, visitor, node);
+	}
+}
+//#endregion
+//#region packages/web-c/component-analyzer/src/extractDefineElement.ts
+function extractDefineElementCalls(ast) {
+	const defineElementLocalNames = collectDefineElementLocalNames(ast);
+	const exportedNames = collectExportedNames(ast);
+	const records = [];
+	walk(ast.program, (node) => {
+		if (!_babel_types.isVariableDeclarator(node)) return;
+		if (!_babel_types.isIdentifier(node.id)) return;
+		if (!_babel_types.isCallExpression(node.init)) return;
+		const call = node.init;
+		if (!isDefineElementCall(call, defineElementLocalNames)) return;
+		const tag = extractTag(call);
+		if (!tag) return;
+		const name = node.id.name;
+		const options = extractOptions(call);
+		const setup = call.arguments[2];
+		const propsTypeName = extractPropsTypeName(call);
+		if (!exportedNames.has(name)) return;
+		records.push({
+			name,
+			exportName: name,
+			tag,
+			propsTypeName,
+			options,
+			setup,
+			call
+		});
+	});
+	return records;
+}
+function collectDefineElementLocalNames(ast) {
+	const names = /* @__PURE__ */ new Set();
+	for (const node of ast.program.body) {
+		if (!_babel_types.isImportDeclaration(node)) continue;
+		const source = node.source.value;
+		if (source !== "@zeus-js/zeus" && source !== "@zeus-js/runtime-dom") continue;
+		for (const spec of node.specifiers) {
+			if (!_babel_types.isImportSpecifier(spec)) continue;
+			const imported = spec.imported;
+			if (_babel_types.isIdentifier(imported) && imported.name === "defineElement" || _babel_types.isStringLiteral(imported) && imported.value === "defineElement") names.add(spec.local.name);
+		}
+	}
+	return names;
+}
+function collectExportedNames(ast) {
+	const names = /* @__PURE__ */ new Set();
+	for (const node of ast.program.body) if (_babel_types.isExportNamedDeclaration(node)) {
+		if (_babel_types.isVariableDeclaration(node.declaration)) {
+			for (const declarator of node.declaration.declarations) if (_babel_types.isIdentifier(declarator.id)) names.add(declarator.id.name);
+		}
+		for (const spec of node.specifiers) if (_babel_types.isExportSpecifier(spec) && _babel_types.isIdentifier(spec.local)) names.add(spec.local.name);
+	}
+	return names;
+}
+function isDefineElementCall(call, localNames) {
+	return _babel_types.isIdentifier(call.callee) && localNames.has(call.callee.name);
+}
+function extractTag(call) {
+	const first = call.arguments[0];
+	if (_babel_types.isStringLiteral(first)) return first.value;
+}
+function extractOptions(call) {
+	const second = call.arguments[1];
+	if (_babel_types.isObjectExpression(second)) return second;
+}
+function extractPropsTypeName(call) {
+	var _call$typeParameters;
+	const first = (_call$typeParameters = call.typeParameters) === null || _call$typeParameters === void 0 ? void 0 : _call$typeParameters.params[0];
+	if (!first) return void 0;
+	if (_babel_types.isTSTypeReference(first) && _babel_types.isIdentifier(first.typeName)) return first.typeName.name;
+}
+//#endregion
+//#region packages/web-c/component-analyzer/src/utils.ts
+function getObjectKey(key) {
+	if (_babel_types.isIdentifier(key)) return key.name;
+	if (_babel_types.isStringLiteral(key)) return key.value;
+	if (_babel_types.isNumericLiteral(key)) return String(key.value);
+}
+function getObjectProperty(object, name) {
+	for (const prop of object.properties) {
+		if (!_babel_types.isObjectProperty(prop)) continue;
+		if (getObjectKey(prop.key) === name) return prop.value;
+	}
+}
+function staticValue(node) {
+	if (!node) return void 0;
+	if (_babel_types.isStringLiteral(node)) return node.value;
+	if (_babel_types.isNumericLiteral(node)) return node.value;
+	if (_babel_types.isBooleanLiteral(node)) return node.value;
+	if (_babel_types.isNullLiteral(node)) return null;
+	if (_babel_types.isIdentifier(node) && node.name === "undefined") return void 0;
+	if (_babel_types.isArrayExpression(node)) return node.elements.map((element) => {
+		if (!element) return null;
+		if (_babel_types.isSpreadElement(element)) return void 0;
+		return staticValue(element);
+	});
+	if (_babel_types.isObjectExpression(node)) {
+		const result = {};
+		for (const prop of node.properties) {
+			if (!_babel_types.isObjectProperty(prop)) continue;
+			const key = getObjectKey(prop.key);
+			if (!key) continue;
+			result[key] = staticValue(prop.value);
+		}
+		return result;
+	}
+}
+function getLeadingDescription(node) {
+	const comments = node.leadingComments;
+	if (!(comments === null || comments === void 0 ? void 0 : comments.length)) return void 0;
+	return comments.map((comment) => comment.value).join("\n").replace(/\*/g, "").split("\n").map((line) => line.trim()).filter(Boolean).join("\n") || void 0;
+}
+function uniqueSorted(values) {
+	return Array.from(new Set(values)).sort();
+}
+//#endregion
+//#region packages/web-c/component-analyzer/src/extractMeta.ts
+function extractInlineMeta(options) {
+	if (!options) return {};
+	const metaNode = getObjectProperty(options, "meta");
+	if (!_babel_types.isObjectExpression(metaNode)) return {};
+	const value = staticValue(metaNode);
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	return value;
+}
+//#endregion
+//#region packages/web-c/component-analyzer/src/extractProps.ts
+function extractRuntimeProps(options) {
+	if (!options) return {};
+	const propsNode = getObjectProperty(options, "props");
+	if (!_babel_types.isObjectExpression(propsNode)) return {};
+	const props = {};
+	for (const prop of propsNode.properties) {
+		if (!_babel_types.isObjectProperty(prop)) continue;
+		const key = getObjectKey(prop.key);
+		if (!key) continue;
+		props[key] = extractRuntimeProp(prop.value);
+	}
+	return props;
+}
+function extractRuntimeProp(node) {
+	if (_babel_types.isIdentifier(node)) return { type: typeFromConstructorName(node.name) };
+	if (_babel_types.isObjectExpression(node)) {
+		const typeNode = getObjectProperty(node, "type");
+		const attrNode = getObjectProperty(node, "attr");
+		const reflectNode = getObjectProperty(node, "reflect");
+		const defaultNode = getObjectProperty(node, "default");
+		const prop = { type: _babel_types.isIdentifier(typeNode) ? typeFromConstructorName(typeNode.name) : "unknown" };
+		if (attrNode) {
+			const attr = staticValue(attrNode);
+			if (attr === false || typeof attr === "string") prop.attr = attr;
+		}
+		if (reflectNode) {
+			const reflect = staticValue(reflectNode);
+			if (typeof reflect === "boolean") prop.reflect = reflect;
+		}
+		if (defaultNode) {
+			if (!_babel_types.isFunctionExpression(defaultNode) && !_babel_types.isArrowFunctionExpression(defaultNode)) prop.default = staticValue(defaultNode);
+		}
+		return prop;
+	}
+	return { type: "unknown" };
+}
+function typeFromConstructorName(name) {
+	switch (name) {
+		case "String": return "string";
+		case "Number": return "number";
+		case "Boolean": return "boolean";
+		case "Object": return "object";
+		case "Array": return "array";
+		default: return "unknown";
+	}
+}
+//#endregion
+//#region packages/web-c/component-analyzer/src/extractSetup.ts
+function extractSetupMeta(setup) {
+	const events = {};
+	const slots = {};
+	const hostAttributes = [];
+	const cssParts = [];
+	if (!setup || _babel_types.isSpreadElement(setup) || _babel_types.isArgumentPlaceholder(setup)) return {
+		events,
+		slots,
+		hostAttributes,
+		cssParts
+	};
+	walk(setup, (node) => {
+		extractEmit(node, events);
+		extractSlot(node, slots);
+		extractHostAttributes(node, hostAttributes);
+		extractCssParts(node, cssParts);
+	});
+	return {
+		events,
+		slots,
+		hostAttributes: uniqueSorted(hostAttributes),
+		cssParts: uniqueSorted(cssParts)
+	};
+}
+function extractEmit(node, events) {
+	if (!_babel_types.isCallExpression(node)) return;
+	if (!_babel_types.isIdentifier(node.callee, { name: "emit" })) return;
+	const first = node.arguments[0];
+	if (!_babel_types.isStringLiteral(first)) return;
+	const eventName = first.value;
+	events[eventName] || (events[eventName] = {});
+	const detailNode = node.arguments[1];
+	if (_babel_types.isObjectExpression(detailNode)) events[eventName].detail = inferDetail(detailNode);
+}
+function inferDetail(node) {
+	const result = {};
+	for (const prop of node.properties) {
+		if (!_babel_types.isObjectProperty(prop)) continue;
+		const key = getObjectKey(prop.key);
+		if (!key) continue;
+		result[key] = inferExpressionType(prop.value);
+	}
+	return result;
+}
+function inferExpressionType(node) {
+	if (_babel_types.isStringLiteral(node)) return "string";
+	if (_babel_types.isNumericLiteral(node)) return "number";
+	if (_babel_types.isBooleanLiteral(node)) return "boolean";
+	if (_babel_types.isObjectExpression(node)) return "object";
+	if (_babel_types.isArrayExpression(node)) return "array";
+	if (_babel_types.isIdentifier(node)) return "unknown";
+	return "unknown";
+}
+function extractSlot(node, slots) {
+	var _getJSXStringAttribut;
+	if (!_babel_types.isJSXElement(node)) return;
+	const name = node.openingElement.name;
+	if (!_babel_types.isJSXIdentifier(name, { name: "Slot" })) return;
+	const slotName = (_getJSXStringAttribut = getJSXStringAttribute(node, "name")) !== null && _getJSXStringAttribut !== void 0 ? _getJSXStringAttribut : "default";
+	slots[slotName] || (slots[slotName] = {});
+}
+function extractHostAttributes(node, hostAttributes) {
+	if (!_babel_types.isJSXElement(node)) return;
+	const name = node.openingElement.name;
+	if (!_babel_types.isJSXIdentifier(name, { name: "Host" })) return;
+	for (const attr of node.openingElement.attributes) {
+		if (!_babel_types.isJSXAttribute(attr)) continue;
+		if (!_babel_types.isJSXIdentifier(attr.name)) continue;
+		const attrName = normalizeJsxAttrName(attr.name.name);
+		if (attrName.startsWith("data-") || attrName.startsWith("aria-") || attrName === "role" || attrName === "part" || attrName === "class" || attrName === "style" || attrName === "id" || attrName === "tabindex") hostAttributes.push(attrName);
+	}
+}
+function extractCssParts(node, cssParts) {
+	if (!_babel_types.isJSXElement(node)) return;
+	const value = getJSXStringAttribute(node, "part");
+	if (!value) return;
+	for (const part of value.split(/\s+/)) if (part) cssParts.push(part);
+}
+function getJSXStringAttribute(node, attrName) {
+	for (const attr of node.openingElement.attributes) {
+		if (!_babel_types.isJSXAttribute(attr)) continue;
+		if (!_babel_types.isJSXIdentifier(attr.name, { name: attrName })) continue;
+		if (!attr.value) return "";
+		if (_babel_types.isStringLiteral(attr.value)) return attr.value.value;
+		if (_babel_types.isJSXExpressionContainer(attr.value) && _babel_types.isExpression(attr.value.expression)) {
+			const value = staticValue(attr.value.expression);
+			if (typeof value === "string") return value;
+		}
+	}
+}
+function normalizeJsxAttrName(name) {
+	switch (name) {
+		case "className": return "class";
+		case "tabIndex": return "tabindex";
+		default: return name;
+	}
+}
+//#endregion
+//#region packages/web-c/component-analyzer/src/extractTypeProps.ts
+function collectLocalPropTypes(ast) {
+	const map = /* @__PURE__ */ new Map();
+	for (const node of ast.program.body) {
+		if (_babel_types.isExportNamedDeclaration(node)) {
+			const declaration = node.declaration;
+			if (_babel_types.isTSInterfaceDeclaration(declaration)) map.set(declaration.id.name, extractInterfaceProps(declaration));
+			if (_babel_types.isTSTypeAliasDeclaration(declaration)) {
+				const props = extractTypeAliasProps(declaration);
+				if (props) map.set(declaration.id.name, props);
+			}
+			continue;
+		}
+		if (_babel_types.isTSInterfaceDeclaration(node)) map.set(node.id.name, extractInterfaceProps(node));
+		if (_babel_types.isTSTypeAliasDeclaration(node)) {
+			const props = extractTypeAliasProps(node);
+			if (props) map.set(node.id.name, props);
+		}
+	}
+	return map;
+}
+function extractInterfaceProps(node) {
+	const result = {};
+	for (const member of node.body.body) {
+		if (!_babel_types.isTSPropertySignature(member)) continue;
+		const key = getObjectKey(member.key);
+		if (!key) continue;
+		result[key] = extractTsProperty(member);
+	}
+	return result;
+}
+function extractTypeAliasProps(node) {
+	if (!_babel_types.isTSTypeLiteral(node.typeAnnotation)) return void 0;
+	const result = {};
+	for (const member of node.typeAnnotation.members) {
+		if (!_babel_types.isTSPropertySignature(member)) continue;
+		const key = getObjectKey(member.key);
+		if (!key) continue;
+		result[key] = extractTsProperty(member);
+	}
+	return result;
+}
+function extractTsProperty(node) {
+	var _node$typeAnnotation;
+	const prop = { required: !node.optional };
+	const annotation = (_node$typeAnnotation = node.typeAnnotation) === null || _node$typeAnnotation === void 0 ? void 0 : _node$typeAnnotation.typeAnnotation;
+	if (annotation) {
+		const inferred = inferType(annotation);
+		Object.assign(prop, inferred);
+	}
+	const description = getLeadingDescription(node);
+	if (description) prop.description = description;
+	return prop;
+}
+function inferType(node) {
+	if (_babel_types.isTSStringKeyword(node)) return { type: "string" };
+	if (_babel_types.isTSNumberKeyword(node)) return { type: "number" };
+	if (_babel_types.isTSBooleanKeyword(node)) return { type: "boolean" };
+	if (_babel_types.isTSArrayType(node)) return { type: "array" };
+	if (_babel_types.isTSTypeLiteral(node)) return { type: "object" };
+	if (_babel_types.isTSUnionType(node)) {
+		const values = [];
+		let allStringLiteral = true;
+		for (const type of node.types) if (_babel_types.isTSLiteralType(type) && _babel_types.isStringLiteral(type.literal)) values.push(type.literal.value);
+		else allStringLiteral = false;
+		if (allStringLiteral && values.length > 0) return {
+			type: "string",
+			values
+		};
+	}
+	return { type: "unknown" };
+}
+//#endregion
+//#region packages/web-c/component-analyzer/src/merge.ts
+function buildComponentRecord(options) {
+	const { file, call, runtimeProps, typeProps, setupMeta, inlineMeta } = options;
+	const props = mergeProps(runtimeProps, typeProps, inlineMeta.props);
+	const events = mergeEvents(setupMeta.events, inlineMeta.events);
+	const slots = mergeSlots(setupMeta.slots, inlineMeta.slots);
+	const cssParts = unique([...setupMeta.cssParts, ...toStringArray(inlineMeta.cssParts)]);
+	const cssVars = unique(toStringArray(inlineMeta.cssVars));
+	const hostAttributes = unique(setupMeta.hostAttributes);
+	return {
+		tag: call.tag,
+		name: call.name,
+		exportName: call.exportName,
+		source: file,
+		props,
+		events,
+		slots,
+		hostAttributes,
+		cssParts,
+		cssVars,
+		description: typeof inlineMeta.description === "string" ? inlineMeta.description : void 0,
+		meta: stripKnownMetaFields(inlineMeta)
+	};
+}
+function mergeProps(runtimeProps, typeProps, metaProps) {
+	const names = unique([
+		...Object.keys(runtimeProps),
+		...Object.keys(typeProps),
+		...Object.keys(metaProps !== null && metaProps !== void 0 ? metaProps : {})
+	]);
+	const result = {};
+	for (const name of names) {
+		var _typeProps$name, _runtimeProps$name, _metaProps$name, _ref, _rp$type, _tp$description, _rp$default, _rp$reflect, _rp$attr;
+		const tp = (_typeProps$name = typeProps[name]) !== null && _typeProps$name !== void 0 ? _typeProps$name : {};
+		const rp = (_runtimeProps$name = runtimeProps[name]) !== null && _runtimeProps$name !== void 0 ? _runtimeProps$name : {};
+		const mp = (_metaProps$name = metaProps === null || metaProps === void 0 ? void 0 : metaProps[name]) !== null && _metaProps$name !== void 0 ? _metaProps$name : {};
+		result[name] = {
+			type: (_ref = (_rp$type = rp.type) !== null && _rp$type !== void 0 ? _rp$type : tp.type) !== null && _ref !== void 0 ? _ref : "unknown",
+			required: tp.required,
+			values: tp.values,
+			description: (_tp$description = tp.description) !== null && _tp$description !== void 0 ? _tp$description : mp.description,
+			default: (_rp$default = rp.default) !== null && _rp$default !== void 0 ? _rp$default : mp.default,
+			reflect: (_rp$reflect = rp.reflect) !== null && _rp$reflect !== void 0 ? _rp$reflect : mp.reflect,
+			attr: (_rp$attr = rp.attr) !== null && _rp$attr !== void 0 ? _rp$attr : mp.attr
+		};
+	}
+	return result;
+}
+function mergeEvents(inferred, explicit) {
+	return {
+		...inferred,
+		...explicit !== null && explicit !== void 0 ? explicit : {}
+	};
+}
+function mergeSlots(inferred, explicit) {
+	return {
+		...inferred,
+		...explicit !== null && explicit !== void 0 ? explicit : {}
+	};
+}
+function toStringArray(value) {
+	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function unique(values) {
+	return Array.from(new Set(values)).sort();
+}
+function stripKnownMetaFields(meta) {
+	const rest = { ...meta };
+	delete rest.description;
+	delete rest.props;
+	delete rest.events;
+	delete rest.slots;
+	delete rest.cssVars;
+	delete rest.cssParts;
+	return Object.keys(rest).length ? rest : void 0;
+}
+//#endregion
+//#region packages/web-c/component-analyzer/src/analyzeFile.ts
+function analyzeFile(options) {
+	const { file, code } = options;
+	const diagnostics = [];
+	const components = [];
+	try {
+		const ast = parseSource(code, file);
+		const calls = extractDefineElementCalls(ast);
+		const localPropTypes = collectLocalPropTypes(ast);
+		for (const call of calls) {
+			var _localPropTypes$get;
+			const runtimeProps = extractRuntimeProps(call.options);
+			const typeProps = call.propsTypeName ? (_localPropTypes$get = localPropTypes.get(call.propsTypeName)) !== null && _localPropTypes$get !== void 0 ? _localPropTypes$get : {} : {};
+			if (call.propsTypeName && !localPropTypes.has(call.propsTypeName) && !isGlobalUtilityType(call.propsTypeName)) diagnostics.push({
+				level: "warning",
+				file,
+				message: `Cannot resolve local props type "${call.propsTypeName}".`
+			});
+			const setupMeta = extractSetupMeta(call.setup);
+			const inlineMeta = extractInlineMeta(call.options);
+			components.push(buildComponentRecord({
+				file,
+				call,
+				runtimeProps,
+				typeProps,
+				setupMeta,
+				inlineMeta
+			}));
+		}
+	} catch (error) {
+		diagnostics.push({
+			level: "error",
+			file,
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+	return {
+		file,
+		components,
+		diagnostics
+	};
+}
+function isGlobalUtilityType(name) {
+	return GLOBAL_UTILITY_TYPES.has(name);
+}
+const GLOBAL_UTILITY_TYPES = new Set([
+	"Awaited",
+	"ConstructorParameters",
+	"Exclude",
+	"Extract",
+	"InstanceType",
+	"NonNullable",
+	"Omit",
+	"Parameters",
+	"Partial",
+	"Pick",
+	"Readonly",
+	"Record",
+	"Required",
+	"ReturnType",
+	"ThisParameterType",
+	"ThisType",
+	"Uppercase",
+	"Lowercase",
+	"Capitalize",
+	"Uncapitalize"
+]);
+//#endregion
+//#region packages/web-c/component-analyzer/src/analyzeComponents.ts
+async function analyzeComponents(options) {
+	var _options$root, _options$exclude;
+	const root = (_options$root = options.root) !== null && _options$root !== void 0 ? _options$root : process.cwd();
+	const files = await (0, fast_glob.default)(options.include, {
+		cwd: root,
+		absolute: true,
+		ignore: (_options$exclude = options.exclude) !== null && _options$exclude !== void 0 ? _options$exclude : ["node_modules/**", "**/dist/**"]
+	});
+	const components = [];
+	const diagnostics = [];
+	for (const file of files) {
+		const code = await node_fs_promises.default.readFile(file, "utf-8");
+		const result = analyzeFile({
+			file: normalizePath(node_path.default.relative(root, file)),
+			code
+		});
+		components.push(...result.components);
+		diagnostics.push(...result.diagnostics);
+	}
+	return {
+		manifest: {
+			version: 1,
+			components
+		},
+		diagnostics
+	};
+}
+function normalizePath(value) {
+	return value.split(node_path.default.sep).join("/");
+}
+//#endregion
+exports.analyzeComponents = analyzeComponents;
+exports.analyzeFile = analyzeFile;

package/dist/component-analyzer.d.ts

@@ -0,0 +1,64 @@
+export type ComponentPropType = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'unknown';
+export interface ComponentManifest {
+    version: 1;
+    components: ComponentRecord[];
+}
+export interface ComponentRecord {
+    tag: string;
+    name: string;
+    exportName: string;
+    source: string;
+    props: Record<string, ComponentProp>;
+    events: Record<string, ComponentEvent>;
+    slots: Record<string, ComponentSlot>;
+    hostAttributes: string[];
+    cssParts: string[];
+    cssVars: string[];
+    description?: string;
+    meta?: Record<string, unknown>;
+}
+export interface ComponentProp {
+    type: ComponentPropType;
+    required?: boolean;
+    values?: string[];
+    default?: unknown;
+    reflect?: boolean;
+    attr?: string | false;
+    description?: string;
+}
+export interface ComponentEvent {
+    detail?: Record<string, string>;
+    description?: string;
+}
+export interface ComponentSlot {
+    description?: string;
+}
+export interface AnalyzeFileResult {
+    file: string;
+    components: ComponentRecord[];
+    diagnostics: AnalyzerDiagnostic[];
+}
+export interface AnalyzeComponentsResult {
+    manifest: ComponentManifest;
+    diagnostics: AnalyzerDiagnostic[];
+}
+export interface AnalyzerDiagnostic {
+    level: 'warning' | 'error';
+    file: string;
+    message: string;
+}
+export interface AnalyzeFileOptions {
+    file: string;
+    code: string;
+}
+export interface AnalyzeComponentsOptions {
+    root?: string;
+    include: string[];
+    exclude?: string[];
+}
+
+export declare function analyzeFile(options: AnalyzeFileOptions): AnalyzeFileResult;
+
+export declare function analyzeComponents(options: AnalyzeComponentsOptions): Promise<AnalyzeComponentsResult>;
+
+