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

package/dist/component-analyzer.esm-bundler.js

@@ -0,0 +1,648 @@
+/**
+* component-analyzer v0.1.0-beta.0
+* (c) 2026 baicie
+* Released under the MIT License.
+**/
+import { parse } from "@babel/parser";
+import * as t from "@babel/types";
+import fs from "node:fs/promises";
+import path from "node:path";
+import fg from "fast-glob";
+//#region packages/web-c/component-analyzer/src/ast.ts
+function parseSource(code, file) {
+	return 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$ = t.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 (!t.isVariableDeclarator(node)) return;
+		if (!t.isIdentifier(node.id)) return;
+		if (!t.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 (!t.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 (!t.isImportSpecifier(spec)) continue;
+			const imported = spec.imported;
+			if (t.isIdentifier(imported) && imported.name === "defineElement" || t.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 (t.isExportNamedDeclaration(node)) {
+		if (t.isVariableDeclaration(node.declaration)) {
+			for (const declarator of node.declaration.declarations) if (t.isIdentifier(declarator.id)) names.add(declarator.id.name);
+		}
+		for (const spec of node.specifiers) if (t.isExportSpecifier(spec) && t.isIdentifier(spec.local)) names.add(spec.local.name);
+	}
+	return names;
+}
+function isDefineElementCall(call, localNames) {
+	return t.isIdentifier(call.callee) && localNames.has(call.callee.name);
+}
+function extractTag(call) {
+	const first = call.arguments[0];
+	if (t.isStringLiteral(first)) return first.value;
+}
+function extractOptions(call) {
+	const second = call.arguments[1];
+	if (t.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 (t.isTSTypeReference(first) && t.isIdentifier(first.typeName)) return first.typeName.name;
+}
+//#endregion
+//#region packages/web-c/component-analyzer/src/utils.ts
+function getObjectKey(key) {
+	if (t.isIdentifier(key)) return key.name;
+	if (t.isStringLiteral(key)) return key.value;
+	if (t.isNumericLiteral(key)) return String(key.value);
+}
+function getObjectProperty(object, name) {
+	for (const prop of object.properties) {
+		if (!t.isObjectProperty(prop)) continue;
+		if (getObjectKey(prop.key) === name) return prop.value;
+	}
+}
+function staticValue(node) {
+	if (!node) return void 0;
+	if (t.isStringLiteral(node)) return node.value;
+	if (t.isNumericLiteral(node)) return node.value;
+	if (t.isBooleanLiteral(node)) return node.value;
+	if (t.isNullLiteral(node)) return null;
+	if (t.isIdentifier(node) && node.name === "undefined") return void 0;
+	if (t.isArrayExpression(node)) return node.elements.map((element) => {
+		if (!element) return null;
+		if (t.isSpreadElement(element)) return void 0;
+		return staticValue(element);
+	});
+	if (t.isObjectExpression(node)) {
+		const result = {};
+		for (const prop of node.properties) {
+			if (!t.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 (!t.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 (!t.isObjectExpression(propsNode)) return {};
+	const props = {};
+	for (const prop of propsNode.properties) {
+		if (!t.isObjectProperty(prop)) continue;
+		const key = getObjectKey(prop.key);
+		if (!key) continue;
+		props[key] = extractRuntimeProp(prop.value);
+	}
+	return props;
+}
+function extractRuntimeProp(node) {
+	if (t.isIdentifier(node)) return { type: typeFromConstructorName(node.name) };
+	if (t.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: t.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 (!t.isFunctionExpression(defaultNode) && !t.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 || t.isSpreadElement(setup) || t.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 (!t.isCallExpression(node)) return;
+	if (!t.isIdentifier(node.callee, { name: "emit" })) return;
+	const first = node.arguments[0];
+	if (!t.isStringLiteral(first)) return;
+	const eventName = first.value;
+	events[eventName] || (events[eventName] = {});
+	const detailNode = node.arguments[1];
+	if (t.isObjectExpression(detailNode)) events[eventName].detail = inferDetail(detailNode);
+}
+function inferDetail(node) {
+	const result = {};
+	for (const prop of node.properties) {
+		if (!t.isObjectProperty(prop)) continue;
+		const key = getObjectKey(prop.key);
+		if (!key) continue;
+		result[key] = inferExpressionType(prop.value);
+	}
+	return result;
+}
+function inferExpressionType(node) {
+	if (t.isStringLiteral(node)) return "string";
+	if (t.isNumericLiteral(node)) return "number";
+	if (t.isBooleanLiteral(node)) return "boolean";
+	if (t.isObjectExpression(node)) return "object";
+	if (t.isArrayExpression(node)) return "array";
+	if (t.isIdentifier(node)) return "unknown";
+	return "unknown";
+}
+function extractSlot(node, slots) {
+	var _getJSXStringAttribut;
+	if (!t.isJSXElement(node)) return;
+	const name = node.openingElement.name;
+	if (!t.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 (!t.isJSXElement(node)) return;
+	const name = node.openingElement.name;
+	if (!t.isJSXIdentifier(name, { name: "Host" })) return;
+	for (const attr of node.openingElement.attributes) {
+		if (!t.isJSXAttribute(attr)) continue;
+		if (!t.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 (!t.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 (!t.isJSXAttribute(attr)) continue;
+		if (!t.isJSXIdentifier(attr.name, { name: attrName })) continue;
+		if (!attr.value) return "";
+		if (t.isStringLiteral(attr.value)) return attr.value.value;
+		if (t.isJSXExpressionContainer(attr.value) && t.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 (t.isExportNamedDeclaration(node)) {
+			const declaration = node.declaration;
+			if (t.isTSInterfaceDeclaration(declaration)) map.set(declaration.id.name, extractInterfaceProps(declaration));
+			if (t.isTSTypeAliasDeclaration(declaration)) {
+				const props = extractTypeAliasProps(declaration);
+				if (props) map.set(declaration.id.name, props);
+			}
+			continue;
+		}
+		if (t.isTSInterfaceDeclaration(node)) map.set(node.id.name, extractInterfaceProps(node));
+		if (t.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 (!t.isTSPropertySignature(member)) continue;
+		const key = getObjectKey(member.key);
+		if (!key) continue;
+		result[key] = extractTsProperty(member);
+	}
+	return result;
+}
+function extractTypeAliasProps(node) {
+	if (!t.isTSTypeLiteral(node.typeAnnotation)) return void 0;
+	const result = {};
+	for (const member of node.typeAnnotation.members) {
+		if (!t.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 (t.isTSStringKeyword(node)) return { type: "string" };
+	if (t.isTSNumberKeyword(node)) return { type: "number" };
+	if (t.isTSBooleanKeyword(node)) return { type: "boolean" };
+	if (t.isTSArrayType(node)) return { type: "array" };
+	if (t.isTSTypeLiteral(node)) return { type: "object" };
+	if (t.isTSUnionType(node)) {
+		const values = [];
+		let allStringLiteral = true;
+		for (const type of node.types) if (t.isTSLiteralType(type) && t.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 \0@oxc-project+runtime@0.133.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/objectSpread2.js
+function ownKeys(e, r) {
+	var t = Object.keys(e);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(e);
+		r && (o = o.filter(function(r) {
+			return Object.getOwnPropertyDescriptor(e, r).enumerable;
+		})), t.push.apply(t, o);
+	}
+	return t;
+}
+function _objectSpread2(e) {
+	for (var r = 1; r < arguments.length; r++) {
+		var t = null != arguments[r] ? arguments[r] : {};
+		r % 2 ? ownKeys(Object(t), !0).forEach(function(r) {
+			_defineProperty(e, r, t[r]);
+		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
+			Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+		});
+	}
+	return e;
+}
+//#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 _objectSpread2(_objectSpread2({}, inferred), explicit !== null && explicit !== void 0 ? explicit : {});
+}
+function mergeSlots(inferred, explicit) {
+	return _objectSpread2(_objectSpread2({}, 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 = _objectSpread2({}, 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 \0@oxc-project+runtime@0.133.0/helpers/esm/asyncToGenerator.js
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+	try {
+		var i = n[a](c), u = i.value;
+	} catch (n) {
+		e(n);
+		return;
+	}
+	i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+	return function() {
+		var t = this, e = arguments;
+		return new Promise(function(r, o) {
+			var a = n.apply(t, e);
+			function _next(n) {
+				asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+			}
+			function _throw(n) {
+				asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+			}
+			_next(void 0);
+		});
+	};
+}
+//#endregion
+//#region packages/web-c/component-analyzer/src/analyzeComponents.ts
+function analyzeComponents(_x) {
+	return _analyzeComponents.apply(this, arguments);
+}
+function _analyzeComponents() {
+	_analyzeComponents = _asyncToGenerator(function* (options) {
+		var _options$root, _options$exclude;
+		const root = (_options$root = options.root) !== null && _options$root !== void 0 ? _options$root : process.cwd();
+		const files = yield fg(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 = yield fs.readFile(file, "utf-8");
+			const result = analyzeFile({
+				file: normalizePath(path.relative(root, file)),
+				code
+			});
+			components.push(...result.components);
+			diagnostics.push(...result.diagnostics);
+		}
+		return {
+			manifest: {
+				version: 1,
+				components
+			},
+			diagnostics
+		};
+	});
+	return _analyzeComponents.apply(this, arguments);
+}
+function normalizePath(value) {
+	return value.split(path.sep).join("/");
+}
+//#endregion
+export { analyzeComponents, analyzeFile };

package/index.js

@@ -0,0 +1,2 @@
+// Re-export from bundled dist
+export * from './dist/component-analyzer.esm-bundler.js'

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@zeus-js/component-analyzer",
+  "version": "0.1.0-beta.0",
+  "description": "Zeus component analyzer",
+  "type": "module",
+  "main": "index.js",
+  "module": "dist/component-analyzer.esm-bundler.js",
+  "types": "dist/component-analyzer.d.ts",
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/component-analyzer.d.ts",
+      "node": {
+        "production": "./dist/component-analyzer.cjs.prod.js",
+        "development": "./dist/component-analyzer.cjs.js",
+        "default": "./index.js"
+      },
+      "module": "./dist/component-analyzer.esm-bundler.js",
+      "import": "./dist/component-analyzer.esm-bundler.js",
+      "require": "./index.js"
+    },
+    "./*": "./*"
+  },
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/baicie/zeus"
+  },
+  "buildOptions": {
+    "name": "ZeusComponentAnalyzer",
+    "formats": [
+      "esm-bundler",
+      "cjs"
+    ]
+  },
+  "dependencies": {
+    "@babel/parser": "^7.29.0",
+    "@babel/types": "^7.29.0",
+    "fast-glob": "^3.3.3"
+  },
+  "keywords": [
+    "zeus",
+    "web-components",
+    "component-analyzer"
+  ],
+  "author": "Baicie",
+  "license": "MIT"
+}