@zeus-js/component-analyzer 0.1.0-beta.2 → 0.1.0-beta.4

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

@@ -1,5 +1,5 @@
 /**
-* component-analyzer v0.1.0-beta.2
+* component-analyzer v0.1.0-beta.4
 * (c) 2026 baicie
 * Released under the MIT License.
 **/
@@ -29,9 +29,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-let _babel_parser = require("@babel/parser");
 let _babel_types = require("@babel/types");
 _babel_types = __toESM(_babel_types, 1);
+let _babel_parser = require("@babel/parser");
 let node_fs_promises = require("node:fs/promises");
 node_fs_promises = __toESM(node_fs_promises, 1);
 let node_path = require("node:path");
@@ -181,17 +181,145 @@ function uniqueSorted(values) {
 	return Array.from(new Set(values)).sort();
 }
 //#endregion
+//#region packages/web-c/component-analyzer/src/extractEmits.ts
+function extractEmits(options) {
+	const emitsNode = options ? getObjectProperty(options, "emits") : void 0;
+	if (!_babel_types.isObjectExpression(emitsNode)) return {};
+	const events = {};
+	for (const member of emitsNode.properties) {
+		if (!_babel_types.isObjectProperty(member) || member.computed) continue;
+		const key = getObjectKey(member.key);
+		if (!key) continue;
+		events[key] = extractEventDefinition(key, member.value);
+	}
+	return events;
+}
+function createComponentEvent(key, detail) {
+	return {
+		key,
+		name: toKebabCase$1(key),
+		reactName: toReactEventProp(key),
+		detail,
+		bubbles: true,
+		composed: true,
+		cancelable: false
+	};
+}
+function extractEventDefinition(key, node) {
+	var _extractEventDetailTy;
+	const result = createComponentEvent(key);
+	if (!_babel_types.isCallExpression(node)) return result;
+	if (!_babel_types.isIdentifier(node.callee, { name: "event" })) return result;
+	result.detail = (_extractEventDetailTy = extractEventDetailType(node)) !== null && _extractEventDetailTy !== void 0 ? _extractEventDetailTy : result.detail;
+	const first = node.arguments[0];
+	if (_babel_types.isStringLiteral(first)) {
+		result.name = first.value;
+		return result;
+	}
+	if (_babel_types.isObjectExpression(first)) {
+		const name = getObjectProperty(first, "name");
+		const bubbles = getObjectProperty(first, "bubbles");
+		const composed = getObjectProperty(first, "composed");
+		const cancelable = getObjectProperty(first, "cancelable");
+		const nameValue = staticValue(name);
+		const bubblesValue = staticValue(bubbles);
+		const composedValue = staticValue(composed);
+		const cancelableValue = staticValue(cancelable);
+		if (typeof nameValue === "string") result.name = nameValue;
+		if (typeof bubblesValue === "boolean") result.bubbles = bubblesValue;
+		if (typeof composedValue === "boolean") result.composed = composedValue;
+		if (typeof cancelableValue === "boolean") result.cancelable = cancelableValue;
+	}
+	return result;
+}
+function extractEventDetailType(node) {
+	var _node$typeParameters;
+	const first = (_node$typeParameters = node.typeParameters) === null || _node$typeParameters === void 0 ? void 0 : _node$typeParameters.params[0];
+	if (!_babel_types.isTSTypeLiteral(first)) return void 0;
+	const detail = {};
+	for (const member of first.members) {
+		var _member$typeAnnotatio;
+		if (!_babel_types.isTSPropertySignature(member)) continue;
+		const key = getObjectKey(member.key);
+		if (!key) continue;
+		detail[key] = inferTsType((_member$typeAnnotatio = member.typeAnnotation) === null || _member$typeAnnotatio === void 0 ? void 0 : _member$typeAnnotatio.typeAnnotation);
+	}
+	return Object.keys(detail).length > 0 ? detail : void 0;
+}
+function inferTsType(node) {
+	if (!node) return "unknown";
+	if (_babel_types.isTSStringKeyword(node)) return "string";
+	if (_babel_types.isTSNumberKeyword(node)) return "number";
+	if (_babel_types.isTSBooleanKeyword(node)) return "boolean";
+	if (_babel_types.isTSObjectKeyword(node) || _babel_types.isTSTypeLiteral(node)) return "object";
+	if (_babel_types.isTSArrayType(node) || _babel_types.isTSTupleType(node)) return "array";
+	if (_babel_types.isTSFunctionType(node)) return "function";
+	if (_babel_types.isTSTypeReference(node)) return inferTsTypeReference(node);
+	return "unknown";
+}
+function inferTsTypeReference(node) {
+	const name = _babel_types.isIdentifier(node.typeName) ? node.typeName.name : void 0;
+	switch (name) {
+		case "String": return "string";
+		case "Number": return "number";
+		case "Boolean": return "boolean";
+		case "Array":
+		case "ReadonlyArray": return "array";
+		case "Function": return "function";
+		case "Record": return "object";
+		default: return name !== null && name !== void 0 ? name : "unknown";
+	}
+}
+function toKebabCase$1(value) {
+	return value.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}
+function toReactEventProp(value) {
+	return `on${value.split("-").filter(Boolean).map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join("")}`;
+}
+//#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;
+	const result = {};
+	if (_babel_types.isObjectExpression(metaNode)) {
+		const value = staticValue(metaNode);
+		if (value && typeof value === "object" && !Array.isArray(value)) Object.assign(result, value);
+	}
+	assignTopLevelStaticValue(options, result, "slots");
+	assignTopLevelStaticValue(options, result, "parts");
+	assignTopLevelStaticValue(options, result, "cssVars");
+	assignTopLevelStaticValue(options, result, "methods");
+	assignTopLevelStaticValue(options, result, "models");
+	return result;
+}
+function assignTopLevelStaticValue(options, result, key) {
+	const node = getObjectProperty(options, key);
+	if (!node) return;
+	const value = staticValue(node);
+	if (key === "parts") {
+		result.cssParts = Array.isArray(value) ? value.filter((item) => typeof item === "string") : result.cssParts;
+		return;
+	}
+	result[key] = value;
 }
 //#endregion
 //#region packages/web-c/component-analyzer/src/extractProps.ts
+function extractComponentOptions(options) {
+	if (!options) return {};
+	const result = {};
+	const shadowNode = getObjectProperty(options, "shadow");
+	if (shadowNode) {
+		const value = staticValue(shadowNode);
+		if (typeof value === "boolean") result.shadow = value;
+	}
+	const formAssociatedNode = getObjectProperty(options, "formAssociated");
+	if (formAssociatedNode) {
+		const value = staticValue(formAssociatedNode);
+		if (typeof value === "boolean") result.formAssociated = value;
+	}
+	return result;
+}
 function extractRuntimeProps(options) {
 	if (!options) return {};
 	const propsNode = getObjectProperty(options, "props");
@@ -205,13 +333,98 @@ function extractRuntimeProps(options) {
 	}
 	return props;
 }
+function validateRuntimePropsDefinition(options, optionsArgument) {
+	const messages = [];
+	if (optionsArgument && !_babel_types.isObjectExpression(optionsArgument)) {
+		messages.push("defineElement() options must be an inline object literal so component metadata can be analyzed.");
+		return messages;
+	}
+	if (!options) return messages;
+	for (const member of options.properties) if (!_babel_types.isObjectProperty(member) || member.computed) messages.push("defineElement() options cannot contain spreads, methods, or computed keys in component output builds.");
+	const propsNode = getObjectProperty(options, "props");
+	if (!propsNode) return messages;
+	if (!_babel_types.isObjectExpression(propsNode)) {
+		messages.push("defineElement() props must be an inline object literal in component output builds.");
+		return messages;
+	}
+	for (const member of propsNode.properties) {
+		if (!_babel_types.isObjectProperty(member) || member.computed) {
+			messages.push("defineElement() props cannot contain spreads, methods, or computed keys.");
+			continue;
+		}
+		const propName = getObjectKey(member.key);
+		if (!propName) {
+			messages.push("defineElement() contains a prop with an unsupported key.");
+			continue;
+		}
+		if (_babel_types.isIdentifier(member.value)) {
+			if (!isPropConstructorName(member.value.name)) messages.push(`Prop "${propName}" must use String, Number, Boolean, Object, Array, Function, prop(values), prop(Constructor), or an inline prop options object.`);
+			continue;
+		}
+		if (isPropCall(member.value)) {
+			validatePropCall(propName, member.value, messages);
+			continue;
+		}
+		if (!_babel_types.isObjectExpression(member.value)) {
+			messages.push(`Prop "${propName}" must use an inline prop options object, prop(values), or prop(Constructor).`);
+			continue;
+		}
+		validatePropOptions(propName, member.value, messages);
+	}
+	return messages;
+}
+function validatePropOptions(propName, options, messages) {
+	for (const member of options.properties) {
+		if (!_babel_types.isObjectProperty(member) || member.computed) {
+			messages.push(`Prop "${propName}" options cannot contain spreads, methods, or computed keys.`);
+			continue;
+		}
+		const optionName = getObjectKey(member.key);
+		if (!optionName) {
+			messages.push(`Prop "${propName}" contains an unsupported option key.`);
+			continue;
+		}
+		if (optionName === "type") {
+			if (!_babel_types.isIdentifier(member.value) || !isPropConstructorName(member.value.name)) messages.push(`Prop "${propName}" type must be String, Number, Boolean, Object, Array, or Function.`);
+			continue;
+		}
+		if (optionName === "attr") {
+			const value = staticValue(member.value);
+			if (value === void 0 && !isExplicitUndefined(member.value)) {
+				messages.push(`Prop "${propName}" attr must be a static string, false, or undefined.`);
+				continue;
+			}
+			if (value !== void 0 && value !== false && typeof value !== "string") messages.push(`Prop "${propName}" attr must be a static string, false, or undefined.`);
+			continue;
+		}
+		if (optionName === "reflect") {
+			const value = staticValue(member.value);
+			if (value === void 0 && !isExplicitUndefined(member.value)) {
+				messages.push(`Prop "${propName}" reflect must be a static boolean.`);
+				continue;
+			}
+			if (value !== void 0 && typeof value !== "boolean") messages.push(`Prop "${propName}" reflect must be a static boolean.`);
+			continue;
+		}
+		if (optionName === "values") {
+			if (!isStaticStringArray(member.value)) messages.push(`Prop "${propName}" values must be a static string array.`);
+			continue;
+		}
+		if (optionName === "serialize" || optionName === "deserialize") {
+			if (!isFunctionLikeReference(member.value)) messages.push(`Prop "${propName}" ${optionName} must be a function.`);
+		}
+	}
+}
 function extractRuntimeProp(node) {
 	if (_babel_types.isIdentifier(node)) return { type: typeFromConstructorName(node.name) };
+	if (isPropCall(node)) return extractPropCall(node);
 	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 serializeNode = getObjectProperty(node, "serialize");
+		const deserializeNode = getObjectProperty(node, "deserialize");
 		const prop = { type: _babel_types.isIdentifier(typeNode) ? typeFromConstructorName(typeNode.name) : "unknown" };
 		if (attrNode) {
 			const attr = staticValue(attrNode);
@@ -224,10 +437,68 @@ function extractRuntimeProp(node) {
 		if (defaultNode) {
 			if (!_babel_types.isFunctionExpression(defaultNode) && !_babel_types.isArrowFunctionExpression(defaultNode)) prop.default = staticValue(defaultNode);
 		}
+		if (serializeNode) prop.serialize = true;
+		if (deserializeNode) prop.deserialize = true;
+		const values = extractStaticStringArray(getObjectProperty(node, "values"));
+		if (values) prop.values = values;
 		return prop;
 	}
 	return { type: "unknown" };
 }
+function isPropCall(node) {
+	return _babel_types.isCallExpression(node) && _babel_types.isIdentifier(node.callee, { name: "prop" });
+}
+function validatePropCall(propName, node, messages) {
+	if (!isStaticStringArray(node.arguments[0]) && !isPropConstructorArgument(node.arguments[0])) messages.push(`Prop "${propName}" prop() first argument must be a static string array or prop constructor.`);
+	const optionsNode = node.arguments[1];
+	if (optionsNode && !_babel_types.isObjectExpression(optionsNode)) {
+		messages.push(`Prop "${propName}" prop() options must be an inline object literal.`);
+		return;
+	}
+	if (_babel_types.isObjectExpression(optionsNode)) validatePropOptions(propName, optionsNode, messages);
+}
+function extractPropCall(node) {
+	var _extractStaticStringA;
+	const inputNode = node.arguments[0];
+	const optionsNode = node.arguments[1];
+	const prop = _babel_types.isObjectExpression(optionsNode) ? extractRuntimeProp(optionsNode) : { type: "string" };
+	if (isPropConstructorArgument(inputNode)) {
+		prop.type = typeFromConstructorName(inputNode.name);
+		if (inputNode.name === "Boolean") {
+			var _prop$default, _prop$reflect;
+			(_prop$default = prop.default) !== null && _prop$default !== void 0 || (prop.default = false);
+			(_prop$reflect = prop.reflect) !== null && _prop$reflect !== void 0 || (prop.reflect = true);
+		}
+		return prop;
+	}
+	prop.type = "string";
+	prop.values = (_extractStaticStringA = extractStaticStringArray(node.arguments[0])) !== null && _extractStaticStringA !== void 0 ? _extractStaticStringA : [];
+	return prop;
+}
+function isPropConstructorArgument(node) {
+	return _babel_types.isIdentifier(node) && isPropConstructorName(node.name);
+}
+function isStaticStringArray(node) {
+	return Boolean(extractStaticStringArray(node));
+}
+function extractStaticStringArray(node) {
+	if (!_babel_types.isArrayExpression(node)) return void 0;
+	const values = [];
+	for (const item of node.elements) {
+		if (!_babel_types.isStringLiteral(item)) return void 0;
+		values.push(item.value);
+	}
+	return values;
+}
+function isPropConstructorName(name) {
+	return name === "String" || name === "Number" || name === "Boolean" || name === "Object" || name === "Array" || name === "Function";
+}
+function isExplicitUndefined(node) {
+	return _babel_types.isIdentifier(node) && node.name === "undefined";
+}
+function isFunctionLikeReference(node) {
+	return _babel_types.isFunctionExpression(node) || _babel_types.isArrowFunctionExpression(node) || _babel_types.isIdentifier(node);
+}
 function typeFromConstructorName(name) {
 	switch (name) {
 		case "String": return "string";
@@ -235,6 +506,7 @@ function typeFromConstructorName(name) {
 		case "Boolean": return "boolean";
 		case "Object": return "object";
 		case "Array": return "array";
+		case "Function": return "function";
 		default: return "unknown";
 	}
 }
@@ -242,23 +514,27 @@ function typeFromConstructorName(name) {
 //#region packages/web-c/component-analyzer/src/extractSetup.ts
 function extractSetupMeta(setup) {
 	const events = {};
+	const methods = {};
 	const slots = {};
 	const hostAttributes = [];
 	const cssParts = [];
 	if (!setup || _babel_types.isSpreadElement(setup) || _babel_types.isArgumentPlaceholder(setup)) return {
 		events,
+		methods,
 		slots,
 		hostAttributes,
 		cssParts
 	};
 	walk(setup, (node) => {
 		extractEmit(node, events);
+		extractExpose(node, methods);
 		extractSlot(node, slots);
 		extractHostAttributes(node, hostAttributes);
 		extractCssParts(node, cssParts);
 	});
 	return {
 		events,
+		methods,
 		slots,
 		hostAttributes: uniqueSorted(hostAttributes),
 		cssParts: uniqueSorted(cssParts)
@@ -266,13 +542,21 @@ function extractSetupMeta(setup) {
 }
 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);
+	const emitKey = getEmitKey(node.callee);
+	if (!emitKey) return;
+	events[emitKey] || (events[emitKey] = createComponentEvent(emitKey));
+	const detailNode = node.arguments[0];
+	if (_babel_types.isObjectExpression(detailNode)) events[emitKey].detail = inferDetail(detailNode);
+}
+function getEmitKey(callee) {
+	if (_babel_types.isMemberExpression(callee)) {
+		if (_babel_types.isIdentifier(callee.object, { name: "emit" }) && !callee.computed) return getMemberPropertyName(callee.property);
+		if (_babel_types.isMemberExpression(callee.object) && _babel_types.isIdentifier(callee.object.property, { name: "emit" }) && !callee.computed) return getMemberPropertyName(callee.property);
+	}
+}
+function getMemberPropertyName(property) {
+	if (_babel_types.isIdentifier(property)) return property.name;
+	if (_babel_types.isStringLiteral(property)) return property.value;
 }
 function inferDetail(node) {
 	const result = {};
@@ -297,9 +581,111 @@ 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;
+	if (!_babel_types.isJSXIdentifier(name, { name: "Slot" }) && !_babel_types.isJSXIdentifier(name, { name: "slot" })) return;
 	const slotName = (_getJSXStringAttribut = getJSXStringAttribute(node, "name")) !== null && _getJSXStringAttribut !== void 0 ? _getJSXStringAttribut : "default";
-	slots[slotName] || (slots[slotName] = {});
+	slots[slotName] || (slots[slotName] = { name: slotName });
+}
+function extractExpose(node, methods) {
+	if (!_babel_types.isCallExpression(node)) return;
+	if (!isExposeCallee(node.callee)) return;
+	const first = node.arguments[0];
+	if (!_babel_types.isObjectExpression(first)) return;
+	for (const member of first.properties) {
+		if (!_babel_types.isObjectMethod(member) && !_babel_types.isObjectProperty(member)) continue;
+		const name = getObjectKey(member.key);
+		if (!name) continue;
+		methods[name] = extractMethod(member, name);
+	}
+}
+function extractMethod(member, name) {
+	var _unwrapPromiseType, _formatTsType;
+	const fn = _babel_types.isObjectMethod(member) ? member : _babel_types.isFunctionExpression(member.value) || _babel_types.isArrowFunctionExpression(member.value) ? member.value : void 0;
+	if (!fn) return { name };
+	const returnType = _babel_types.isTSTypeAnnotation(fn.returnType) ? fn.returnType.typeAnnotation : void 0;
+	const normalizedReturn = fn.async ? (_unwrapPromiseType = unwrapPromiseType(returnType)) !== null && _unwrapPromiseType !== void 0 ? _unwrapPromiseType : returnType : returnType;
+	return {
+		name,
+		parameters: fn.params.map((param, index) => extractMethodParameter(param, index)),
+		returns: (_formatTsType = formatTsType(normalizedReturn)) !== null && _formatTsType !== void 0 ? _formatTsType : "unknown",
+		async: fn.async
+	};
+}
+function extractMethodParameter(param, index) {
+	var _formatTsType4;
+	if (_babel_types.isTSParameterProperty(param)) return extractMethodParameter(param.parameter, index);
+	if (_babel_types.isAssignmentPattern(param)) {
+		var _formatTsType2;
+		return {
+			name: _babel_types.isIdentifier(param.left) ? param.left.name : `arg${index}`,
+			type: (_formatTsType2 = formatTsType(getPatternTypeAnnotation(param.left))) !== null && _formatTsType2 !== void 0 ? _formatTsType2 : inferExpressionType(param.right),
+			optional: true
+		};
+	}
+	if (_babel_types.isRestElement(param)) {
+		var _ref, _formatTsType3;
+		return {
+			name: _babel_types.isIdentifier(param.argument) ? param.argument.name : `args${index}`,
+			type: (_ref = (_formatTsType3 = formatTsType(getPatternTypeAnnotation(param))) !== null && _formatTsType3 !== void 0 ? _formatTsType3 : formatTsType(getPatternTypeAnnotation(param.argument))) !== null && _ref !== void 0 ? _ref : "unknown[]",
+			optional: false,
+			rest: true
+		};
+	}
+	return {
+		name: _babel_types.isIdentifier(param) ? param.name : `arg${index}`,
+		type: (_formatTsType4 = formatTsType(getPatternTypeAnnotation(param))) !== null && _formatTsType4 !== void 0 ? _formatTsType4 : "unknown",
+		optional: Boolean(_babel_types.isIdentifier(param) && param.optional)
+	};
+}
+function getPatternTypeAnnotation(node) {
+	if (_babel_types.isIdentifier(node) || _babel_types.isObjectPattern(node) || _babel_types.isArrayPattern(node) || _babel_types.isRestElement(node)) return _babel_types.isTSTypeAnnotation(node.typeAnnotation) ? node.typeAnnotation.typeAnnotation : void 0;
+}
+function unwrapPromiseType(node) {
+	if (_babel_types.isTSTypeReference(node) && _babel_types.isIdentifier(node.typeName, { name: "Promise" })) {
+		var _node$typeParameters;
+		return (_node$typeParameters = node.typeParameters) === null || _node$typeParameters === void 0 ? void 0 : _node$typeParameters.params[0];
+	}
+}
+function formatTsType(node) {
+	if (!node) return void 0;
+	if (_babel_types.isTSStringKeyword(node)) return "string";
+	if (_babel_types.isTSNumberKeyword(node)) return "number";
+	if (_babel_types.isTSBooleanKeyword(node)) return "boolean";
+	if (_babel_types.isTSVoidKeyword(node)) return "void";
+	if (_babel_types.isTSUnknownKeyword(node)) return "unknown";
+	if (_babel_types.isTSAnyKeyword(node)) return "any";
+	if (_babel_types.isTSNullKeyword(node)) return "null";
+	if (_babel_types.isTSArrayType(node)) {
+		var _formatTsType5;
+		return `${(_formatTsType5 = formatTsType(node.elementType)) !== null && _formatTsType5 !== void 0 ? _formatTsType5 : "unknown"}[]`;
+	}
+	if (_babel_types.isTSUnionType(node)) return node.types.map((type) => {
+		var _formatTsType6;
+		return (_formatTsType6 = formatTsType(type)) !== null && _formatTsType6 !== void 0 ? _formatTsType6 : "unknown";
+	}).join(" | ");
+	if (_babel_types.isTSLiteralType(node)) return staticLiteralType(node.literal);
+	if (_babel_types.isTSTypeReference(node)) {
+		var _node$typeParameters2;
+		const name = formatEntityName(node.typeName);
+		const params = (_node$typeParameters2 = node.typeParameters) === null || _node$typeParameters2 === void 0 ? void 0 : _node$typeParameters2.params;
+		return (params === null || params === void 0 ? void 0 : params.length) ? `${name}<${params.map((type) => {
+			var _formatTsType7;
+			return (_formatTsType7 = formatTsType(type)) !== null && _formatTsType7 !== void 0 ? _formatTsType7 : "unknown";
+		}).join(", ")}>` : name;
+	}
+	return "unknown";
+}
+function formatEntityName(name) {
+	return _babel_types.isIdentifier(name) ? name.name : `${formatEntityName(name.left)}.${name.right.name}`;
+}
+function staticLiteralType(node) {
+	if (_babel_types.isStringLiteral(node)) return JSON.stringify(node.value);
+	if (_babel_types.isNumericLiteral(node)) return String(node.value);
+	if (_babel_types.isBooleanLiteral(node)) return String(node.value);
+	return "unknown";
+}
+function isExposeCallee(callee) {
+	if (_babel_types.isIdentifier(callee, { name: "expose" })) return true;
+	return _babel_types.isMemberExpression(callee) && _babel_types.isIdentifier(callee.property, { name: "expose" });
 }
 function extractHostAttributes(node, hostAttributes) {
 	if (!_babel_types.isJSXElement(node)) return;
@@ -413,28 +799,71 @@ function inferType(node) {
 //#endregion
 //#region packages/web-c/component-analyzer/src/merge.ts
 function buildComponentRecord(options) {
-	const { file, call, runtimeProps, typeProps, setupMeta, inlineMeta } = options;
+	const { file, call, runtimeProps, runtimePropsDiagnostics, emits: declaredEvents, typeProps, setupMeta, inlineMeta, shadow, formAssociated } = options;
 	const props = mergeProps(runtimeProps, typeProps, inlineMeta.props);
-	const events = mergeEvents(setupMeta.events, inlineMeta.events);
+	const events = mergeEvents(declaredEvents, setupMeta.events, inlineMeta.events);
+	const methods = mergeMethods(setupMeta.methods, inlineMeta.methods);
+	const models = inlineMeta.models === void 0 ? inferModels(props, events) : normalizeModels(inlineMeta.models);
 	const slots = mergeSlots(setupMeta.slots, inlineMeta.slots);
 	const cssParts = unique([...setupMeta.cssParts, ...toStringArray(inlineMeta.cssParts)]);
-	const cssVars = unique(toStringArray(inlineMeta.cssVars));
+	const cssVars = toCssVarsRecord(inlineMeta.cssVars);
 	const hostAttributes = unique(setupMeta.hostAttributes);
+	const restMeta = stripKnownMetaFields(inlineMeta);
 	return {
 		tag: call.tag,
 		name: call.name,
 		exportName: call.exportName,
 		source: file,
 		props,
+		runtimeProps,
+		runtimePropsDiagnostics: (runtimePropsDiagnostics === null || runtimePropsDiagnostics === void 0 ? void 0 : runtimePropsDiagnostics.length) ? runtimePropsDiagnostics : void 0,
 		events,
+		methods,
+		models,
 		slots,
 		hostAttributes,
 		cssParts,
 		cssVars,
 		description: typeof inlineMeta.description === "string" ? inlineMeta.description : void 0,
-		meta: stripKnownMetaFields(inlineMeta)
+		meta: shadow !== void 0 || formAssociated !== void 0 || restMeta ? {
+			...restMeta,
+			shadow,
+			formAssociated
+		} : void 0
 	};
 }
+function normalizeModels(value) {
+	if (!Array.isArray(value)) return void 0;
+	const models = [];
+	for (const item of value) {
+		if (!item || typeof item !== "object") continue;
+		const record = item;
+		if (typeof record.prop !== "string" || typeof record.event !== "string") continue;
+		models.push({
+			prop: record.prop,
+			event: record.event,
+			eventPath: typeof record.eventPath === "string" ? record.eventPath : void 0
+		});
+	}
+	return models.length ? models : void 0;
+}
+function inferModels(props, events) {
+	const models = [];
+	for (const prop of Object.keys(props)) {
+		var _event$name, _event$key;
+		const eventKey = `${prop}Change`;
+		const event = events[eventKey];
+		if (!(event === null || event === void 0 ? void 0 : event.detail) || !Object.prototype.hasOwnProperty.call(event.detail, prop)) continue;
+		const eventName = (_event$name = event.name) !== null && _event$name !== void 0 ? _event$name : toKebabCase((_event$key = event.key) !== null && _event$key !== void 0 ? _event$key : eventKey);
+		if (eventName !== `${toKebabCase(prop)}-change`) continue;
+		models.push({
+			prop,
+			event: eventName,
+			eventPath: `detail.${prop}`
+		});
+	}
+	return models.length ? models : void 0;
+}
 function mergeProps(runtimeProps, typeProps, metaProps) {
 	const names = unique([
 		...Object.keys(runtimeProps),
@@ -443,40 +872,104 @@ function mergeProps(runtimeProps, typeProps, 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;
+		var _typeProps$name, _runtimeProps$name, _metaProps$name, _ref, _rp$type, _rp$values, _tp$description, _rp$default, _rp$reflect, _rp$attr, _rp$serialize, _rp$deserialize;
 		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,
+			values: (_rp$values = rp.values) !== null && _rp$values !== void 0 ? _rp$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
+			attr: (_rp$attr = rp.attr) !== null && _rp$attr !== void 0 ? _rp$attr : mp.attr,
+			serialize: (_rp$serialize = rp.serialize) !== null && _rp$serialize !== void 0 ? _rp$serialize : mp.serialize,
+			deserialize: (_rp$deserialize = rp.deserialize) !== null && _rp$deserialize !== void 0 ? _rp$deserialize : mp.deserialize
 		};
 	}
 	return result;
 }
-function mergeEvents(inferred, explicit) {
+function mergeEvents(declared, inferred, explicit) {
+	const result = {};
+	for (const [key, value] of Object.entries(declared)) result[key] = mergeEvent(value, inferred[key]);
+	for (const [key, value] of Object.entries(explicit !== null && explicit !== void 0 ? explicit : {})) if (result[key]) result[key] = normalizeExplicitEvent(key, value, result[key]);
+	return result;
+}
+function mergeEvent(primary, fallback) {
+	var _primary$key, _primary$name, _primary$reactName, _primary$detail, _primary$bubbles, _primary$composed, _primary$cancelable, _primary$description;
 	return {
-		...inferred,
-		...explicit !== null && explicit !== void 0 ? explicit : {}
+		key: (_primary$key = primary.key) !== null && _primary$key !== void 0 ? _primary$key : fallback === null || fallback === void 0 ? void 0 : fallback.key,
+		name: (_primary$name = primary.name) !== null && _primary$name !== void 0 ? _primary$name : fallback === null || fallback === void 0 ? void 0 : fallback.name,
+		reactName: (_primary$reactName = primary.reactName) !== null && _primary$reactName !== void 0 ? _primary$reactName : fallback === null || fallback === void 0 ? void 0 : fallback.reactName,
+		detail: (_primary$detail = primary.detail) !== null && _primary$detail !== void 0 ? _primary$detail : fallback === null || fallback === void 0 ? void 0 : fallback.detail,
+		bubbles: (_primary$bubbles = primary.bubbles) !== null && _primary$bubbles !== void 0 ? _primary$bubbles : fallback === null || fallback === void 0 ? void 0 : fallback.bubbles,
+		composed: (_primary$composed = primary.composed) !== null && _primary$composed !== void 0 ? _primary$composed : fallback === null || fallback === void 0 ? void 0 : fallback.composed,
+		cancelable: (_primary$cancelable = primary.cancelable) !== null && _primary$cancelable !== void 0 ? _primary$cancelable : fallback === null || fallback === void 0 ? void 0 : fallback.cancelable,
+		description: (_primary$description = primary.description) !== null && _primary$description !== void 0 ? _primary$description : fallback === null || fallback === void 0 ? void 0 : fallback.description
+	};
+}
+function normalizeExplicitEvent(key, value, base) {
+	var _value$key, _value$name, _value$reactName, _value$detail, _value$bubbles, _value$composed, _value$cancelable, _value$description;
+	const fallback = base !== null && base !== void 0 ? base : createComponentEvent(key);
+	return {
+		key: (_value$key = value.key) !== null && _value$key !== void 0 ? _value$key : fallback.key,
+		name: (_value$name = value.name) !== null && _value$name !== void 0 ? _value$name : fallback.name,
+		reactName: (_value$reactName = value.reactName) !== null && _value$reactName !== void 0 ? _value$reactName : fallback.reactName,
+		detail: (_value$detail = value.detail) !== null && _value$detail !== void 0 ? _value$detail : fallback.detail,
+		bubbles: (_value$bubbles = value.bubbles) !== null && _value$bubbles !== void 0 ? _value$bubbles : fallback.bubbles,
+		composed: (_value$composed = value.composed) !== null && _value$composed !== void 0 ? _value$composed : fallback.composed,
+		cancelable: (_value$cancelable = value.cancelable) !== null && _value$cancelable !== void 0 ? _value$cancelable : fallback.cancelable,
+		description: (_value$description = value.description) !== null && _value$description !== void 0 ? _value$description : fallback.description
 	};
 }
+function mergeMethods(inferred, explicit) {
+	const result = { ...inferred };
+	if (Array.isArray(explicit)) {
+		for (const name of explicit) if (typeof name === "string") result[name] = { name };
+	}
+	return result;
+}
 function mergeSlots(inferred, explicit) {
+	if (Array.isArray(explicit)) {
+		const result = { ...inferred };
+		for (const name of explicit) if (typeof name === "string") result[name] = { name };
+		return result;
+	}
+	if (!explicit || typeof explicit !== "object") return { ...inferred };
 	return {
 		...inferred,
-		...explicit !== null && explicit !== void 0 ? explicit : {}
+		...explicit
 	};
 }
 function toStringArray(value) {
 	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
+function toCssVarsRecord(value) {
+	if (Array.isArray(value)) {
+		const result = {};
+		for (const item of value) if (typeof item === "string") result[item] = { name: item };
+		return result;
+	}
+	if (value && typeof value === "object") {
+		const result = {};
+		for (const [name, item] of Object.entries(value)) if (item && typeof item === "object") {
+			const description = item.description;
+			result[name] = {
+				name,
+				description: typeof description === "string" ? description : void 0
+			};
+		} else result[name] = { name };
+		return result;
+	}
+	return {};
+}
 function unique(values) {
 	return Array.from(new Set(values)).sort();
 }
+function toKebabCase(value) {
+	return value.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}
 function stripKnownMetaFields(meta) {
 	const rest = { ...meta };
 	delete rest.description;
@@ -485,6 +978,10 @@ function stripKnownMetaFields(meta) {
 	delete rest.slots;
 	delete rest.cssVars;
 	delete rest.cssParts;
+	delete rest.shadow;
+	delete rest.formAssociated;
+	delete rest.methods;
+	delete rest.models;
 	return Object.keys(rest).length ? rest : void 0;
 }
 //#endregion
@@ -497,24 +994,37 @@ function analyzeFile(options) {
 		const ast = parseSource(code, file);
 		const calls = extractDefineElementCalls(ast);
 		const localPropTypes = collectLocalPropTypes(ast);
+		const localSetupBindings = collectLocalSetupBindings(ast);
 		for (const call of calls) {
-			var _localPropTypes$get;
+			var _localPropTypes$get, _componentOptions$sha, _componentOptions$for;
+			const runtimePropsDiagnostics = validateRuntimePropsDefinition(call.options, call.call.arguments[1]);
+			for (const message of runtimePropsDiagnostics) diagnostics.push({
+				level: "warning",
+				file,
+				message: `<${call.tag}> ${message}`
+			});
 			const runtimeProps = extractRuntimeProps(call.options);
+			const emits = extractEmits(call.options);
+			const componentOptions = extractComponentOptions(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 setupMeta = extractSetupMeta(resolveSetupBinding(call.setup, localSetupBindings));
 			const inlineMeta = extractInlineMeta(call.options);
 			components.push(buildComponentRecord({
 				file,
 				call,
 				runtimeProps,
+				runtimePropsDiagnostics,
+				emits,
 				typeProps,
 				setupMeta,
-				inlineMeta
+				inlineMeta,
+				shadow: (_componentOptions$sha = componentOptions.shadow) !== null && _componentOptions$sha !== void 0 ? _componentOptions$sha : typeof inlineMeta.shadow === "boolean" ? inlineMeta.shadow : void 0,
+				formAssociated: (_componentOptions$for = componentOptions.formAssociated) !== null && _componentOptions$for !== void 0 ? _componentOptions$for : typeof inlineMeta.formAssociated === "boolean" ? inlineMeta.formAssociated : void 0
 			}));
 		}
 	} catch (error) {
@@ -530,6 +1040,28 @@ function analyzeFile(options) {
 		diagnostics
 	};
 }
+function collectLocalSetupBindings(ast) {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const node of ast.program.body) {
+		if (_babel_types.isFunctionDeclaration(node) && node.id) {
+			bindings.set(node.id.name, node);
+			continue;
+		}
+		if (!_babel_types.isVariableDeclaration(node)) continue;
+		for (const declarator of node.declarations) {
+			if (!_babel_types.isIdentifier(declarator.id) || !declarator.init) continue;
+			if (_babel_types.isFunctionExpression(declarator.init) || _babel_types.isArrowFunctionExpression(declarator.init)) bindings.set(declarator.id.name, declarator.init);
+		}
+	}
+	return bindings;
+}
+function resolveSetupBinding(setup, bindings) {
+	if (_babel_types.isIdentifier(setup)) {
+		var _bindings$get;
+		return (_bindings$get = bindings.get(setup.name)) !== null && _bindings$get !== void 0 ? _bindings$get : setup;
+	}
+	return setup;
+}
 function isGlobalUtilityType(name) {
 	return GLOBAL_UTILITY_TYPES.has(name);
 }