@weapp-vite/ast 6.8.0

package/dist/operations/jsxAutoComponents.d.mts

@@ -0,0 +1,36 @@
+import { AstEngineName } from "../types.mjs";
+import * as t from "@babel/types";
+import { Expression, ObjectExpression } from "@babel/types";
+
+//#region src/operations/jsxAutoComponents.d.ts
+interface JsxImportedComponent {
+  localName: string;
+  importSource: string;
+  importedName?: string;
+  kind: 'default' | 'named';
+}
+interface JsxAutoComponentContext {
+  templateTags: Set<string>;
+  importedComponents: JsxImportedComponent[];
+}
+interface JsxAutoComponentAnalysisOptions {
+  astEngine?: AstEngineName;
+  isCollectableTag: (tag: string) => boolean;
+  isDefineComponentSource?: (source: string) => boolean;
+  resolveBabelComponentExpression?: (declaration: t.Declaration | t.Expression | null, defineComponentDecls: Map<string, ObjectExpression>, defineComponentAliases: Set<string>) => Expression | null;
+  resolveBabelRenderExpression?: (componentExpr: Expression) => Expression | null;
+}
+interface JsxBabelModuleAnalysisOptions {
+  isDefineComponentSource?: (source: string) => boolean;
+  resolveBabelComponentExpression?: (declaration: t.Declaration | t.Expression | null, defineComponentDecls: Map<string, ObjectExpression>, defineComponentAliases: Set<string>) => Expression | null;
+}
+declare function collectJsxImportedComponentsAndDefaultExportFromBabelAst(ast: t.File, options?: JsxBabelModuleAnalysisOptions): {
+  importedComponents: JsxImportedComponent[];
+  exportDefaultExpression: null;
+};
+/**
+ * 从 JSX 源码中收集自动 usingComponents 所需的导入组件与模板标签。
+ */
+declare function collectJsxAutoComponentsFromCode(source: string, options: JsxAutoComponentAnalysisOptions): JsxAutoComponentContext;
+//#endregion
+export { JsxAutoComponentAnalysisOptions, JsxAutoComponentContext, JsxBabelModuleAnalysisOptions, JsxImportedComponent, collectJsxAutoComponentsFromCode, collectJsxImportedComponentsAndDefaultExportFromBabelAst };

package/dist/operations/jsxAutoComponents.mjs

@@ -0,0 +1,305 @@
+import { BABEL_TS_MODULE_PARSER_OPTIONS, parse, traverse } from "../babel.mjs";
+import { getObjectPropertyByKey, resolveRenderableExpression } from "../babelNodes.mjs";
+import * as t from "@babel/types";
+import { parseSync } from "oxc-parser";
+import { walk } from "oxc-walker";
+//#region src/operations/jsxAutoComponents.ts
+function defaultIsDefineComponentSource(source) {
+	return source === "vue";
+}
+function defaultResolveBabelComponentExpression(declaration, defineComponentDecls, defineComponentAliases) {
+	if (!declaration) return null;
+	if (t.isObjectExpression(declaration)) return declaration;
+	if (t.isCallExpression(declaration) && t.isIdentifier(declaration.callee) && defineComponentAliases.has(declaration.callee.name)) {
+		const arg = declaration.arguments[0];
+		if (t.isObjectExpression(arg)) return arg;
+		if (t.isIdentifier(arg)) return defineComponentDecls.get(arg.name) ?? null;
+	}
+	if (t.isIdentifier(declaration)) return defineComponentDecls.get(declaration.name) ?? null;
+	return null;
+}
+function defaultResolveBabelRenderExpression(componentExpr) {
+	if (!t.isObjectExpression(componentExpr)) return null;
+	const renderNode = getObjectPropertyByKey(componentExpr, "render");
+	if (!renderNode) return null;
+	if (!t.isObjectMethod(renderNode) && !t.isObjectProperty(renderNode)) return null;
+	return resolveRenderableExpression(renderNode);
+}
+function collectJsxImportedComponentsAndDefaultExportFromBabelAst(ast, options = {}) {
+	const resolvedOptions = {
+		isDefineComponentSource: options.isDefineComponentSource ?? defaultIsDefineComponentSource,
+		resolveBabelComponentExpression: options.resolveBabelComponentExpression ?? defaultResolveBabelComponentExpression
+	};
+	const defineComponentAliases = new Set(["defineComponent", "_defineComponent"]);
+	const defineComponentDecls = /* @__PURE__ */ new Map();
+	const imports = /* @__PURE__ */ new Map();
+	let exportDefaultExpression = null;
+	traverse(ast, {
+		ImportDeclaration(path) {
+			const source = path.node.source.value;
+			if (resolvedOptions.isDefineComponentSource(source)) for (const specifier of path.node.specifiers) {
+				if (!t.isImportSpecifier(specifier)) continue;
+				if (!t.isIdentifier(specifier.imported, { name: "defineComponent" })) continue;
+				defineComponentAliases.add(specifier.local.name);
+			}
+			if (path.node.importKind === "type") return;
+			if (!t.isStringLiteral(path.node.source)) return;
+			const importSource = path.node.source.value;
+			for (const specifier of path.node.specifiers) {
+				if ("importKind" in specifier && specifier.importKind === "type") continue;
+				if (!("local" in specifier) || !t.isIdentifier(specifier.local)) continue;
+				const localName = specifier.local.name;
+				if (t.isImportDefaultSpecifier(specifier)) {
+					imports.set(localName, {
+						localName,
+						importSource,
+						importedName: "default",
+						kind: "default"
+					});
+					continue;
+				}
+				if (!t.isImportSpecifier(specifier)) continue;
+				const importedName = t.isIdentifier(specifier.imported) ? specifier.imported.name : t.isStringLiteral(specifier.imported) ? specifier.imported.value : void 0;
+				imports.set(localName, {
+					localName,
+					importSource,
+					importedName,
+					kind: "named"
+				});
+			}
+		},
+		VariableDeclarator(path) {
+			if (!t.isIdentifier(path.node.id) || !path.node.init) return;
+			if (t.isObjectExpression(path.node.init)) {
+				defineComponentDecls.set(path.node.id.name, t.cloneNode(path.node.init, true));
+				return;
+			}
+			if (!t.isCallExpression(path.node.init)) return;
+			const callee = path.node.init.callee;
+			if (!t.isIdentifier(callee) || !defineComponentAliases.has(callee.name)) return;
+			const first = path.node.init.arguments[0];
+			if (t.isObjectExpression(first)) defineComponentDecls.set(path.node.id.name, t.cloneNode(first, true));
+		},
+		ExportDefaultDeclaration(path) {
+			const declaration = path.node.declaration;
+			if (t.isDeclaration(declaration)) return;
+			exportDefaultExpression = resolvedOptions.resolveBabelComponentExpression(declaration, defineComponentDecls, defineComponentAliases);
+		}
+	});
+	return {
+		importedComponents: [...imports.values()],
+		exportDefaultExpression
+	};
+}
+function collectJsxTemplateTags(renderExpression, isCollectableTag) {
+	const tags = /* @__PURE__ */ new Set();
+	function walk(node) {
+		if (t.isJSXElement(node)) {
+			const { name } = node.openingElement;
+			if (!t.isJSXMemberExpression(name)) {
+				let tag = null;
+				if (t.isJSXIdentifier(name)) tag = name.name;
+				else if (t.isJSXNamespacedName(name)) tag = `${name.namespace.name}:${name.name.name}`;
+				if (tag && isCollectableTag(tag)) tags.add(tag);
+			}
+			for (const child of node.children) walk(child);
+			return;
+		}
+		if (t.isJSXFragment(node)) {
+			for (const child of node.children) walk(child);
+			return;
+		}
+		if (t.isJSXExpressionContainer(node) && !t.isJSXEmptyExpression(node.expression)) {
+			walk(node.expression);
+			return;
+		}
+		if (t.isConditionalExpression(node)) {
+			walk(node.consequent);
+			walk(node.alternate);
+			return;
+		}
+		if (t.isLogicalExpression(node)) {
+			walk(node.left);
+			walk(node.right);
+			return;
+		}
+		if (t.isCallExpression(node)) {
+			for (const arg of node.arguments) if (t.isExpression(arg)) walk(arg);
+			return;
+		}
+		if (t.isArrowFunctionExpression(node) || t.isFunctionExpression(node)) {
+			if (t.isBlockStatement(node.body)) {
+				for (const stmt of node.body.body) if (t.isReturnStatement(stmt) && stmt.argument) walk(stmt.argument);
+			} else walk(node.body);
+			return;
+		}
+		if (t.isArrayExpression(node)) {
+			for (const element of node.elements) if (element && t.isExpression(element)) walk(element);
+			return;
+		}
+		if (t.isParenthesizedExpression(node) || t.isTSAsExpression(node) || t.isTSSatisfiesExpression(node) || t.isTSNonNullExpression(node)) walk(node.expression);
+	}
+	walk(renderExpression);
+	return tags;
+}
+function unwrapOxcExpression(node) {
+	let current = node;
+	while (current && (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSNonNullExpression" || current.type === "ParenthesizedExpression")) current = current.expression;
+	return current;
+}
+function getOxcStaticPropertyName(node) {
+	const current = unwrapOxcExpression(node);
+	if (!current) return;
+	if (current.type === "Identifier") return current.name;
+	if (current.type === "StringLiteral") return current.value;
+	if (current.type === "Literal" && typeof current.value === "string") return current.value;
+}
+function resolveOxcComponentExpression(declaration, defineComponentDecls, defineComponentAliases) {
+	const normalized = unwrapOxcExpression(declaration);
+	if (!normalized) return null;
+	if (normalized.type === "ObjectExpression") return normalized;
+	if (normalized.type === "Identifier") return defineComponentDecls.get(normalized.name) ?? null;
+	if (normalized.type === "CallExpression" && normalized.callee?.type === "Identifier" && defineComponentAliases.has(normalized.callee.name)) {
+		const first = normalized.arguments?.[0];
+		const unwrappedFirst = unwrapOxcExpression(first);
+		if (unwrappedFirst?.type === "ObjectExpression") return unwrappedFirst;
+		if (unwrappedFirst?.type === "Identifier") return defineComponentDecls.get(unwrappedFirst.name) ?? null;
+	}
+	return null;
+}
+function resolveOxcRenderExpression(componentExpr) {
+	if (componentExpr?.type !== "ObjectExpression") return null;
+	let renderProperty = null;
+	for (const property of componentExpr.properties ?? []) if (getOxcStaticPropertyName(property?.key) === "render") {
+		renderProperty = property;
+		break;
+	}
+	if (!renderProperty) return null;
+	const normalizedValue = unwrapOxcExpression(renderProperty.value ?? renderProperty);
+	if (!normalizedValue || normalizedValue.type !== "FunctionExpression" && normalizedValue.type !== "ArrowFunctionExpression") return null;
+	if (normalizedValue.body?.type === "BlockStatement") {
+		for (const statement of normalizedValue.body.body ?? []) if (statement.type === "ReturnStatement" && statement.argument) return unwrapOxcExpression(statement.argument);
+		return null;
+	}
+	return unwrapOxcExpression(normalizedValue.body);
+}
+function collectJsxTemplateTagsFromOxc(renderExpression, isCollectableTag) {
+	const tags = /* @__PURE__ */ new Set();
+	walk(renderExpression, { enter(node) {
+		if (node.type === "JSXElement") {
+			const name = node.openingElement?.name;
+			if (!name || name.type === "JSXMemberExpression") return;
+			let tag = null;
+			if (name.type === "JSXIdentifier") tag = name.name;
+			else if (name.type === "JSXNamespacedName") tag = `${name.namespace.name}:${name.name.name}`;
+			if (tag && isCollectableTag(tag)) tags.add(tag);
+		}
+	} });
+	return tags;
+}
+function collectWithBabel(source, options) {
+	const { importedComponents, exportDefaultExpression } = collectJsxImportedComponentsAndDefaultExportFromBabelAst(parse(source, BABEL_TS_MODULE_PARSER_OPTIONS), options);
+	if (!exportDefaultExpression) return {
+		templateTags: /* @__PURE__ */ new Set(),
+		importedComponents
+	};
+	const renderExpression = options.resolveBabelRenderExpression(exportDefaultExpression);
+	if (!renderExpression) return {
+		templateTags: /* @__PURE__ */ new Set(),
+		importedComponents
+	};
+	return {
+		templateTags: collectJsxTemplateTags(renderExpression, options.isCollectableTag),
+		importedComponents
+	};
+}
+function collectWithOxc(source, options) {
+	const ast = parseSync("inline.tsx", source).program;
+	const defineComponentAliases = new Set(["defineComponent", "_defineComponent"]);
+	const defineComponentDecls = /* @__PURE__ */ new Map();
+	const imports = /* @__PURE__ */ new Map();
+	let exportDefaultExpression = null;
+	for (const statement of ast.body ?? []) {
+		if (statement?.type === "ImportDeclaration") {
+			const importSource = statement.source?.value;
+			if (typeof importSource === "string" && options.isDefineComponentSource(importSource)) {
+				for (const specifier of statement.specifiers ?? []) if (specifier?.type === "ImportSpecifier" && specifier.imported?.type === "Identifier" && specifier.imported.name === "defineComponent" && specifier.local?.type === "Identifier") defineComponentAliases.add(specifier.local.name);
+			}
+			if (statement.importKind === "type" || typeof importSource !== "string") continue;
+			for (const specifier of statement.specifiers ?? []) {
+				if (specifier?.importKind === "type" || specifier?.local?.type !== "Identifier") continue;
+				const localName = specifier.local.name;
+				if (specifier.type === "ImportDefaultSpecifier") {
+					imports.set(localName, {
+						localName,
+						importSource,
+						importedName: "default",
+						kind: "default"
+					});
+					continue;
+				}
+				if (specifier.type !== "ImportSpecifier") continue;
+				const importedName = specifier.imported?.type === "Identifier" ? specifier.imported.name : specifier.imported?.type === "StringLiteral" ? specifier.imported.value : void 0;
+				imports.set(localName, {
+					localName,
+					importSource,
+					importedName,
+					kind: "named"
+				});
+			}
+			continue;
+		}
+		if (statement?.type === "VariableDeclaration") {
+			for (const declaration of statement.declarations ?? []) {
+				if (declaration?.id?.type !== "Identifier" || !declaration.init) continue;
+				const init = unwrapOxcExpression(declaration.init);
+				if (init?.type === "ObjectExpression") {
+					defineComponentDecls.set(declaration.id.name, init);
+					continue;
+				}
+				if (init?.type === "CallExpression" && init.callee?.type === "Identifier" && defineComponentAliases.has(init.callee.name)) {
+					const first = unwrapOxcExpression(init.arguments?.[0]);
+					if (first?.type === "ObjectExpression") defineComponentDecls.set(declaration.id.name, first);
+				}
+			}
+			continue;
+		}
+		if (statement?.type === "ExportDefaultDeclaration") exportDefaultExpression = resolveOxcComponentExpression(statement.declaration, defineComponentDecls, defineComponentAliases);
+	}
+	const importedComponents = [...imports.values()];
+	if (!exportDefaultExpression) return {
+		templateTags: /* @__PURE__ */ new Set(),
+		importedComponents
+	};
+	const renderExpression = resolveOxcRenderExpression(exportDefaultExpression);
+	if (!renderExpression) return {
+		templateTags: /* @__PURE__ */ new Set(),
+		importedComponents
+	};
+	return {
+		templateTags: collectJsxTemplateTagsFromOxc(renderExpression, options.isCollectableTag),
+		importedComponents
+	};
+}
+/**
+* 从 JSX 源码中收集自动 usingComponents 所需的导入组件与模板标签。
+*/
+function collectJsxAutoComponentsFromCode(source, options) {
+	const normalizedOptions = {
+		astEngine: options.astEngine ?? "babel",
+		isCollectableTag: options.isCollectableTag,
+		isDefineComponentSource: options.isDefineComponentSource ?? defaultIsDefineComponentSource,
+		resolveBabelComponentExpression: options.resolveBabelComponentExpression ?? defaultResolveBabelComponentExpression,
+		resolveBabelRenderExpression: options.resolveBabelRenderExpression ?? defaultResolveBabelRenderExpression
+	};
+	try {
+		return normalizedOptions.astEngine === "oxc" ? collectWithOxc(source, normalizedOptions) : collectWithBabel(source, normalizedOptions);
+	} catch {
+		return {
+			templateTags: /* @__PURE__ */ new Set(),
+			importedComponents: []
+		};
+	}
+}
+//#endregion
+export { collectJsxAutoComponentsFromCode, collectJsxImportedComponentsAndDefaultExportFromBabelAst };

package/dist/operations/platformApi.d.mts

@@ -0,0 +1,13 @@
+import { AstEngineName, AstParserLike } from "../types.mjs";
+
+//#region src/operations/platformApi.d.ts
+declare const platformApiIdentifiers: Set<string>;
+/**
+ * 使用统一 AST 入口做平台 API 访问预判。
+ */
+declare function mayContainPlatformApiAccess(code: string, options?: {
+  engine?: AstEngineName;
+  parserLike?: AstParserLike;
+}): boolean;
+//#endregion
+export { mayContainPlatformApiAccess, platformApiIdentifiers };

package/dist/operations/platformApi.mjs

@@ -0,0 +1,35 @@
+import { t as parseJsLikeWithEngine } from "../engine-DHqNPCDA.mjs";
+import { walk } from "oxc-walker";
+//#region src/operations/platformApi.ts
+const platformApiIdentifiers = new Set([
+	"wx",
+	"my",
+	"tt",
+	"swan",
+	"jd",
+	"xhs"
+]);
+/**
+* 使用统一 AST 入口做平台 API 访问预判。
+*/
+function mayContainPlatformApiAccess(code, options) {
+	const engine = options?.engine ?? "babel";
+	if (engine !== "oxc") return true;
+	try {
+		const ast = parseJsLikeWithEngine(code, {
+			engine,
+			filename: "inline.ts",
+			parserLike: options?.parserLike
+		});
+		let found = false;
+		walk(ast, { enter(node) {
+			if (found) return;
+			if (node.type === "MemberExpression" && node.object.type === "Identifier" && platformApiIdentifiers.has(node.object.name)) found = true;
+		} });
+		return found;
+	} catch {
+		return true;
+	}
+}
+//#endregion
+export { mayContainPlatformApiAccess, platformApiIdentifiers };

package/dist/operations/require.d.mts

@@ -0,0 +1,24 @@
+import { AstEngineName, AstParserLike } from "../types.mjs";
+
+//#region src/operations/require.d.ts
+interface RequireToken {
+  start: number;
+  end: number;
+  value: string;
+  async?: boolean;
+}
+/**
+ * 收集 `require.async()` 依赖字面量。
+ */
+declare function collectRequireTokens(ast: unknown): {
+  requireTokens: RequireToken[];
+};
+/**
+ * 使用统一 AST 入口预判是否存在可静态分析的 `require("...")` / ``require(`...`)``。
+ */
+declare function mayContainStaticRequireLiteral(code: string, options?: {
+  engine?: AstEngineName;
+  parserLike?: AstParserLike;
+}): boolean;
+//#endregion
+export { RequireToken, collectRequireTokens, mayContainStaticRequireLiteral };

package/dist/operations/require.mjs

@@ -0,0 +1,54 @@
+import { t as parseJsLikeWithEngine } from "../engine-DHqNPCDA.mjs";
+import { walk } from "oxc-walker";
+//#region src/operations/require.ts
+function getStaticRequireLiteralValue(node) {
+	if (!node) return null;
+	if (node.type === "Literal" || node.type === "StringLiteral") return typeof node.value === "string" ? node.value : null;
+	if (node.type === "TemplateLiteral" && Array.isArray(node.expressions) && node.expressions.length === 0 && Array.isArray(node.quasis) && node.quasis.length === 1) return node.quasis[0]?.value?.cooked ?? node.quasis[0]?.value?.raw ?? null;
+	return null;
+}
+/**
+* 收集 `require.async()` 依赖字面量。
+*/
+function collectRequireTokens(ast) {
+	const requireTokens = [];
+	walk(ast, { enter(node) {
+		if (node.type === "CallExpression") {
+			if (node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && node.callee.object.name === "require" && node.callee.property.type === "Identifier" && node.callee.property.name === "async") {
+				const argv0 = node.arguments[0];
+				if (argv0 && argv0.type === "Literal" && typeof argv0.value === "string") requireTokens.push({
+					start: argv0.start,
+					end: argv0.end,
+					value: argv0.value,
+					async: true
+				});
+			}
+		}
+	} });
+	return { requireTokens };
+}
+/**
+* 使用统一 AST 入口预判是否存在可静态分析的 `require("...")` / ``require(`...`)``。
+*/
+function mayContainStaticRequireLiteral(code, options) {
+	const engine = options?.engine ?? "babel";
+	if (engine !== "oxc") return true;
+	try {
+		const ast = parseJsLikeWithEngine(code, {
+			engine,
+			filename: "inline.ts",
+			parserLike: options?.parserLike
+		});
+		let found = false;
+		walk(ast, { enter(node) {
+			if (found || node.type !== "CallExpression") return;
+			if (node.callee.type !== "Identifier" || node.callee.name !== "require") return;
+			if (typeof getStaticRequireLiteralValue(node.arguments?.[0]) === "string") found = true;
+		} });
+		return found;
+	} catch {
+		return true;
+	}
+}
+//#endregion
+export { collectRequireTokens, mayContainStaticRequireLiteral };

package/dist/operations/scriptSetupImports.d.mts

@@ -0,0 +1,17 @@
+import { AstEngineName } from "../types.mjs";
+
+//#region src/operations/scriptSetupImports.d.ts
+interface ScriptSetupImport {
+  localName: string;
+  importSource: string;
+  importedName?: string;
+  kind: 'default' | 'named';
+}
+/**
+ * 收集 `<script setup>` 中会参与自动 usingComponents 的导入声明。
+ */
+declare function collectScriptSetupImportsFromCode(scriptSetup: string, templateComponentNames: Set<string>, options?: {
+  astEngine?: AstEngineName;
+}): ScriptSetupImport[];
+//#endregion
+export { ScriptSetupImport, collectScriptSetupImportsFromCode };

package/dist/operations/scriptSetupImports.mjs

@@ -0,0 +1,80 @@
+import { BABEL_TS_MODULE_PARSER_OPTIONS, parse } from "../babel.mjs";
+import { t as parseJsLikeWithEngine } from "../engine-DHqNPCDA.mjs";
+//#region src/operations/scriptSetupImports.ts
+function collectWithOxc(scriptSetup, templateComponentNames) {
+	const results = [];
+	const ast = parseJsLikeWithEngine(scriptSetup, {
+		engine: "oxc",
+		filename: "inline.ts"
+	});
+	for (const node of ast.body ?? []) {
+		if (node?.type !== "ImportDeclaration" || node.importKind === "type") continue;
+		const importSource = node.source?.value;
+		if (typeof importSource !== "string") continue;
+		for (const specifier of node.specifiers ?? []) {
+			if (specifier?.importKind === "type" || specifier?.local?.type !== "Identifier") continue;
+			const localName = specifier.local.name;
+			if (!templateComponentNames.has(localName)) continue;
+			if (specifier.type === "ImportDefaultSpecifier") results.push({
+				localName,
+				importSource,
+				importedName: "default",
+				kind: "default"
+			});
+			else if (specifier.type === "ImportSpecifier") {
+				const importedName = specifier.imported?.type === "Identifier" ? specifier.imported.name : specifier.imported?.type === "StringLiteral" ? specifier.imported.value : void 0;
+				results.push({
+					localName,
+					importSource,
+					importedName,
+					kind: "named"
+				});
+			}
+		}
+	}
+	return results;
+}
+function collectWithBabel(scriptSetup, templateComponentNames) {
+	const results = [];
+	const ast = parse(scriptSetup, BABEL_TS_MODULE_PARSER_OPTIONS);
+	for (const node of ast.program.body) {
+		if (node.type !== "ImportDeclaration") continue;
+		if (node.importKind === "type") continue;
+		const importSource = node.source.value;
+		for (const specifier of node.specifiers) {
+			if (specifier.importKind === "type") continue;
+			const localName = specifier.local?.name;
+			if (!localName || !templateComponentNames.has(localName)) continue;
+			if (specifier.type === "ImportDefaultSpecifier") results.push({
+				localName,
+				importSource,
+				importedName: "default",
+				kind: "default"
+			});
+			else if (specifier.type === "ImportSpecifier") {
+				const imported = specifier.imported;
+				const importedName = imported?.type === "Identifier" ? imported.name : imported?.type === "StringLiteral" ? imported.value : void 0;
+				results.push({
+					localName,
+					importSource,
+					importedName,
+					kind: "named"
+				});
+			}
+		}
+	}
+	return results;
+}
+/**
+* 收集 `<script setup>` 中会参与自动 usingComponents 的导入声明。
+*/
+function collectScriptSetupImportsFromCode(scriptSetup, templateComponentNames, options) {
+	const engine = options?.astEngine ?? "babel";
+	try {
+		return engine === "oxc" ? collectWithOxc(scriptSetup, templateComponentNames) : collectWithBabel(scriptSetup, templateComponentNames);
+	} catch {
+		return [];
+	}
+}
+//#endregion
+export { collectScriptSetupImportsFromCode };

package/dist/types.d.mts

@@ -0,0 +1,24 @@
+//#region src/types.d.ts
+/**
+ * AST 引擎名称。
+ */
+type AstEngineName = 'babel' | 'oxc';
+/**
+ * AST 相关配置。
+ */
+interface WeappAstConfig {
+  /**
+   * AST 引擎。
+   * - `babel`: 默认兼容模式
+   * - `oxc`: 优先使用 Oxc 做解析/分析
+   */
+  engine?: AstEngineName;
+}
+/**
+ * 兼容 Rolldown/Vite `this.parse` 形状的解析器。
+ */
+interface AstParserLike {
+  parse?: (input: string, options?: unknown) => unknown;
+}
+//#endregion
+export { AstEngineName, AstParserLike, WeappAstConfig };

package/dist/types.mjs

@@ -0,0 +1 @@
+export {};