@weapp-vite/ast 6.8.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ice breaker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,79 @@
+# @weapp-vite/ast
+
+## 简介
+
+`@weapp-vite/ast` 提供 weapp-vite 体系内可复用的 AST 解析与静态分析能力，统一封装 Babel 与 Oxc 两套后端，并抽出跨包共享的分析操作，供 `weapp-vite`、`wevu`、`@wevu/compiler` 等包复用。
+
+## 特性
+
+- 统一的 Babel / Oxc 解析入口
+- JS / TS / JSX / TSX 源码解析
+- 平台 API、`require`、`script setup import` 等轻量分析
+- 组件 `props`、特性标记、JSX 自动组件等共享分析操作
+- 面向业务包的可参数化分析器，避免重复实现
+
+## 安装
+
+```bash
+pnpm add @weapp-vite/ast
+```
+
+## 使用
+
+解析源码：
+
+```ts
+import { parseJsLikeWithEngine } from '@weapp-vite/ast'
+
+const babelAst = parseJsLikeWithEngine('export const value = 1')
+const oxcAst = parseJsLikeWithEngine('export const value = 1', {
+  engine: 'oxc',
+  filename: 'inline.ts',
+})
+```
+
+收集通用特性标记：
+
+```ts
+import { collectFeatureFlagsFromCode } from '@weapp-vite/ast'
+
+const flags = collectFeatureFlagsFromCode(code, {
+  astEngine: 'oxc',
+  moduleId: 'wevu',
+  hookToFeature: {
+    onLoad: 'enableShare',
+    onShow: 'enableShow',
+  },
+})
+```
+
+收集 JSX 自动组件：
+
+```ts
+import { collectJsxAutoComponentsFromCode } from '@weapp-vite/ast'
+
+const result = collectJsxAutoComponentsFromCode(code, {
+  astEngine: 'babel',
+  isCollectableTag(tag) {
+    return !['view', 'text'].includes(tag)
+  },
+  isDefineComponentSource(source) {
+    return source === 'vue' || source === 'wevu'
+  },
+})
+```
+
+## 导出能力
+
+- `parseJsLikeWithEngine`
+- `collectComponentPropsFromCode`
+- `collectFeatureFlagsFromCode`
+- `collectJsxAutoComponentsFromCode`
+- `mayContainPlatformApiAccess`
+- `collectRequireTokens`
+- `collectScriptSetupImportsFromCode`
+
+## 相关链接
+
+- 文档：https://vite.icebreaker.top/
+- 仓库：https://github.com/weapp-vite/weapp-vite

package/dist/babel.d.mts

@@ -0,0 +1,21 @@
+import * as _babel_types0 from "@babel/types";
+import * as _babel_traverse0 from "@babel/traverse";
+import * as _babel_generator0 from "@babel/generator";
+import * as _babel_parser0 from "@babel/parser";
+import { ParserOptions, ParserPlugin } from "@babel/parser";
+
+//#region src/babel.d.ts
+declare const BABEL_TS_MODULE_PLUGINS: ParserPlugin[];
+declare const BABEL_TS_MODULE_PARSER_OPTIONS: ParserOptions;
+type BabelTraverse = typeof _babel_traverse0.default;
+type BabelGenerate = typeof _babel_generator0.default;
+type BabelParse = typeof _babel_parser0.parse;
+type TraverseFn = (...args: Parameters<BabelTraverse>) => ReturnType<BabelTraverse>;
+type GenerateFn = (...args: Parameters<BabelGenerate>) => ReturnType<BabelGenerate>;
+declare const traverse: TraverseFn;
+declare const generate: GenerateFn;
+declare const parse: BabelParse;
+declare function getVisitorKeys(): typeof _babel_types0.VISITOR_KEYS;
+declare function parseJsLike(source: string): _babel_types0.File;
+//#endregion
+export { BABEL_TS_MODULE_PARSER_OPTIONS, BABEL_TS_MODULE_PLUGINS, generate, getVisitorKeys, parse, parseJsLike, traverse };

package/dist/babel.mjs

@@ -0,0 +1,64 @@
+import { createRequire } from "node:module";
+//#region src/babel.ts
+const BABEL_TS_MODULE_PLUGINS = [
+	"typescript",
+	"decorators-legacy",
+	"classProperties",
+	"classPrivateProperties",
+	"classPrivateMethods",
+	"jsx"
+];
+const BABEL_TS_MODULE_PARSER_OPTIONS = {
+	sourceType: "module",
+	plugins: BABEL_TS_MODULE_PLUGINS
+};
+const nodeRequire = createRequire(import.meta.url);
+let cachedTraverse;
+let cachedGenerate;
+let cachedParse;
+function requireCallableDefault(id) {
+	const mod = nodeRequire(id);
+	if (typeof mod === "function") return mod;
+	if (mod && (typeof mod === "object" || typeof mod === "function") && "default" in mod) {
+		const candidate = mod.default;
+		if (typeof candidate === "function") return candidate;
+	}
+	throw new TypeError(`Invalid module shape for ${id}`);
+}
+function getTraverse() {
+	if (!cachedTraverse) cachedTraverse = requireCallableDefault("@babel/traverse");
+	return cachedTraverse;
+}
+function getGenerate() {
+	if (!cachedGenerate) cachedGenerate = requireCallableDefault("@babel/generator");
+	return cachedGenerate;
+}
+function getParse() {
+	if (!cachedParse) cachedParse = nodeRequire("@babel/parser").parse;
+	return cachedParse;
+}
+const traverse = (...args) => {
+	return getTraverse()(...args);
+};
+const generate = (...args) => {
+	return getGenerate()(...args);
+};
+const parse = ((...args) => {
+	return getParse()(...args);
+});
+function getVisitorKeys() {
+	return nodeRequire("@babel/types").VISITOR_KEYS;
+}
+function parseJsLike(source) {
+	return parse(source, {
+		sourceType: "module",
+		plugins: [
+			...BABEL_TS_MODULE_PLUGINS,
+			"dynamicImport",
+			"optionalChaining",
+			"nullishCoalescingOperator"
+		]
+	});
+}
+//#endregion
+export { BABEL_TS_MODULE_PARSER_OPTIONS, BABEL_TS_MODULE_PLUGINS, generate, getVisitorKeys, parse, parseJsLike, traverse };

package/dist/babelNodes.d.mts

@@ -0,0 +1,10 @@
+import * as t from "@babel/types";
+import { Expression, ObjectExpression, ObjectMethod, ObjectProperty, PrivateName } from "@babel/types";
+
+//#region src/babelNodes.d.ts
+declare function unwrapTypeScriptExpression(exp: Expression): Expression;
+declare function toStaticObjectKey(key: Expression | PrivateName | t.Identifier): string | null;
+declare function getObjectPropertyByKey(node: ObjectExpression, key: string): ObjectMethod | ObjectProperty | null;
+declare function resolveRenderableExpression(node: ObjectMethod | ObjectProperty): Expression | null;
+//#endregion
+export { getObjectPropertyByKey, resolveRenderableExpression, toStaticObjectKey, unwrapTypeScriptExpression };

package/dist/babelNodes.mjs

@@ -0,0 +1,54 @@
+import * as t from "@babel/types";
+//#region src/babelNodes.ts
+function unwrapTypeScriptExpression(exp) {
+	let current = exp;
+	while (t.isTSAsExpression(current) || t.isTSTypeAssertion(current) || t.isTSNonNullExpression(current) || t.isParenthesizedExpression(current) || t.isTSInstantiationExpression(current)) {
+		if (t.isTSAsExpression(current) || t.isTSTypeAssertion(current) || t.isTSNonNullExpression(current)) {
+			current = current.expression;
+			continue;
+		}
+		if (t.isParenthesizedExpression(current)) {
+			current = current.expression;
+			continue;
+		}
+		if (t.isTSInstantiationExpression(current)) current = current.expression;
+	}
+	return current;
+}
+function toStaticObjectKey(key) {
+	if (t.isIdentifier(key)) return key.name;
+	if (t.isStringLiteral(key)) return key.value;
+	return null;
+}
+function getObjectPropertyByKey(node, key) {
+	for (const prop of node.properties) {
+		if (t.isObjectMethod(prop)) {
+			if (toStaticObjectKey(prop.key) === key) return prop;
+			continue;
+		}
+		if (!t.isObjectProperty(prop) || prop.computed) continue;
+		if (toStaticObjectKey(prop.key) === key) return prop;
+	}
+	return null;
+}
+function resolveRenderableExpression(node) {
+	if (t.isObjectMethod(node)) {
+		for (const statement of node.body.body) if (t.isReturnStatement(statement) && statement.argument) return unwrapTypeScriptExpression(statement.argument);
+		return null;
+	}
+	if (!node.value) return null;
+	const value = node.value;
+	if (t.isArrowFunctionExpression(value)) {
+		if (t.isBlockStatement(value.body)) {
+			for (const statement of value.body.body) if (t.isReturnStatement(statement) && statement.argument) return unwrapTypeScriptExpression(statement.argument);
+			return null;
+		}
+		return unwrapTypeScriptExpression(value.body);
+	}
+	if (t.isFunctionExpression(value)) {
+		for (const statement of value.body.body) if (t.isReturnStatement(statement) && statement.argument) return unwrapTypeScriptExpression(statement.argument);
+	}
+	return null;
+}
+//#endregion
+export { getObjectPropertyByKey, resolveRenderableExpression, toStaticObjectKey, unwrapTypeScriptExpression };

package/dist/engine-DHqNPCDA.mjs

@@ -0,0 +1,37 @@
+import { parseJsLike } from "./babel.mjs";
+import { parseSync } from "oxc-parser";
+//#region src/engines/babel.ts
+/**
+* Babel AST 引擎。
+*/
+const babelAstEngine = {
+	name: "babel",
+	parseJsLike(code) {
+		return parseJsLike(code);
+	}
+};
+//#endregion
+//#region src/engines/oxc.ts
+/**
+* Oxc AST 引擎。
+*/
+const oxcAstEngine = {
+	name: "oxc",
+	parseJsLike(code, filename = "inline.ts") {
+		return parseSync(filename, code).program;
+	}
+};
+//#endregion
+//#region src/engine.ts
+/**
+* 统一解析 JS-like 源码，供 analysis 型 operation 复用。
+*/
+function parseJsLikeWithEngine(code, options) {
+	if ((options?.engine ?? "babel") === "oxc") {
+		if (typeof options?.parserLike?.parse === "function") return options.parserLike.parse(code);
+		return oxcAstEngine.parseJsLike(code, options?.filename);
+	}
+	return babelAstEngine.parseJsLike(code);
+}
+//#endregion
+export { oxcAstEngine as n, babelAstEngine as r, parseJsLikeWithEngine as t };

package/dist/engine.d.mts

@@ -0,0 +1,13 @@
+import { AstEngineName, AstParserLike } from "./types.mjs";
+
+//#region src/engine.d.ts
+/**
+ * 统一解析 JS-like 源码，供 analysis 型 operation 复用。
+ */
+declare function parseJsLikeWithEngine(code: string, options?: {
+  engine?: AstEngineName;
+  filename?: string;
+  parserLike?: AstParserLike;
+}): unknown;
+//#endregion
+export { parseJsLikeWithEngine };

package/dist/engine.mjs

@@ -0,0 +1,2 @@
+import { t as parseJsLikeWithEngine } from "./engine-DHqNPCDA.mjs";
+export { parseJsLikeWithEngine };

package/dist/index.d.mts

@@ -0,0 +1,32 @@
+import { BABEL_TS_MODULE_PARSER_OPTIONS, BABEL_TS_MODULE_PLUGINS, generate, getVisitorKeys, parse, parseJsLike, traverse } from "./babel.mjs";
+import { getObjectPropertyByKey, resolveRenderableExpression, toStaticObjectKey, unwrapTypeScriptExpression } from "./babelNodes.mjs";
+import { AstEngineName, AstParserLike, WeappAstConfig } from "./types.mjs";
+import { parseJsLikeWithEngine } from "./engine.mjs";
+import { ComponentPropMap, collectComponentPropsFromCode } from "./operations/componentProps.mjs";
+import { FeatureFlagOptions, collectFeatureFlagsFromCode } from "./operations/featureFlags.mjs";
+import { JsxAutoComponentAnalysisOptions, JsxAutoComponentContext, JsxBabelModuleAnalysisOptions, JsxImportedComponent, collectJsxAutoComponentsFromCode, collectJsxImportedComponentsAndDefaultExportFromBabelAst } from "./operations/jsxAutoComponents.mjs";
+import { mayContainPlatformApiAccess, platformApiIdentifiers } from "./operations/platformApi.mjs";
+import { RequireToken, collectRequireTokens, mayContainStaticRequireLiteral } from "./operations/require.mjs";
+import { ScriptSetupImport, collectScriptSetupImportsFromCode } from "./operations/scriptSetupImports.mjs";
+import * as _babel_types0 from "@babel/types";
+import * as oxc_parser0 from "oxc-parser";
+
+//#region src/engines/babel.d.ts
+/**
+ * Babel AST 引擎。
+ */
+declare const babelAstEngine: {
+  name: "babel";
+  parseJsLike(code: string): _babel_types0.File;
+};
+//#endregion
+//#region src/engines/oxc.d.ts
+/**
+ * Oxc AST 引擎。
+ */
+declare const oxcAstEngine: {
+  name: "oxc";
+  parseJsLike(code: string, filename?: string): oxc_parser0.Program;
+};
+//#endregion
+export { type AstEngineName, type AstParserLike, BABEL_TS_MODULE_PARSER_OPTIONS, BABEL_TS_MODULE_PLUGINS, type ComponentPropMap, type FeatureFlagOptions, type JsxAutoComponentAnalysisOptions, type JsxAutoComponentContext, type JsxBabelModuleAnalysisOptions, type JsxImportedComponent, type RequireToken, type ScriptSetupImport, type WeappAstConfig, babelAstEngine, collectComponentPropsFromCode, collectFeatureFlagsFromCode, collectJsxAutoComponentsFromCode, collectJsxImportedComponentsAndDefaultExportFromBabelAst, collectRequireTokens, collectScriptSetupImportsFromCode, generate, getObjectPropertyByKey, getVisitorKeys, mayContainPlatformApiAccess, mayContainStaticRequireLiteral, oxcAstEngine, parse, parseJsLike, parseJsLikeWithEngine, platformApiIdentifiers, resolveRenderableExpression, toStaticObjectKey, traverse, unwrapTypeScriptExpression };

package/dist/index.mjs

@@ -0,0 +1,10 @@
+import { BABEL_TS_MODULE_PARSER_OPTIONS, BABEL_TS_MODULE_PLUGINS, generate, getVisitorKeys, parse, parseJsLike, traverse } from "./babel.mjs";
+import { getObjectPropertyByKey, resolveRenderableExpression, toStaticObjectKey, unwrapTypeScriptExpression } from "./babelNodes.mjs";
+import { n as oxcAstEngine, r as babelAstEngine, t as parseJsLikeWithEngine } from "./engine-DHqNPCDA.mjs";
+import { collectComponentPropsFromCode } from "./operations/componentProps.mjs";
+import { collectFeatureFlagsFromCode } from "./operations/featureFlags.mjs";
+import { collectJsxAutoComponentsFromCode, collectJsxImportedComponentsAndDefaultExportFromBabelAst } from "./operations/jsxAutoComponents.mjs";
+import { mayContainPlatformApiAccess, platformApiIdentifiers } from "./operations/platformApi.mjs";
+import { collectRequireTokens, mayContainStaticRequireLiteral } from "./operations/require.mjs";
+import { collectScriptSetupImportsFromCode } from "./operations/scriptSetupImports.mjs";
+export { BABEL_TS_MODULE_PARSER_OPTIONS, BABEL_TS_MODULE_PLUGINS, babelAstEngine, collectComponentPropsFromCode, collectFeatureFlagsFromCode, collectJsxAutoComponentsFromCode, collectJsxImportedComponentsAndDefaultExportFromBabelAst, collectRequireTokens, collectScriptSetupImportsFromCode, generate, getObjectPropertyByKey, getVisitorKeys, mayContainPlatformApiAccess, mayContainStaticRequireLiteral, oxcAstEngine, parse, parseJsLike, parseJsLikeWithEngine, platformApiIdentifiers, resolveRenderableExpression, toStaticObjectKey, traverse, unwrapTypeScriptExpression };

package/dist/operations/componentProps.d.mts

@@ -0,0 +1,12 @@
+import { AstEngineName } from "../types.mjs";
+
+//#region src/operations/componentProps.d.ts
+type ComponentPropMap = Map<string, string>;
+/**
+ * 从源码中提取组件属性类型映射。
+ */
+declare function collectComponentPropsFromCode(code: string, options?: {
+  astEngine?: AstEngineName;
+}): ComponentPropMap;
+//#endregion
+export { ComponentPropMap, collectComponentPropsFromCode };

package/dist/operations/componentProps.mjs

@@ -0,0 +1,170 @@
+import { BABEL_TS_MODULE_PARSER_OPTIONS, parse, traverse } from "../babel.mjs";
+import { t as parseJsLikeWithEngine } from "../engine-DHqNPCDA.mjs";
+import { walk } from "oxc-walker";
+//#region src/operations/componentProps.ts
+const CONSTRUCTOR_TYPE_MAP = {
+	String: "string",
+	StringConstructor: "string",
+	Number: "number",
+	NumberConstructor: "number",
+	Boolean: "boolean",
+	BooleanConstructor: "boolean",
+	Object: "Record<string, any>",
+	ObjectConstructor: "Record<string, any>",
+	Array: "any[]",
+	ArrayConstructor: "any[]",
+	null: "any",
+	Null: "any",
+	NullConstructor: "any"
+};
+function mapConstructorName(name) {
+	if (Object.hasOwn(CONSTRUCTOR_TYPE_MAP, name)) return CONSTRUCTOR_TYPE_MAP[name];
+	return CONSTRUCTOR_TYPE_MAP[name.endsWith("Constructor") ? name.slice(0, -11) : name] ?? "any";
+}
+function resolveTypeFromNode(node) {
+	if (!node) return "any";
+	if (node.type === "Identifier") return mapConstructorName(node.name);
+	if (node.type === "StringLiteral" || node.type === "Literal") {
+		if (typeof node.value === "string") return mapConstructorName(node.value);
+		if (typeof node.value === "number") return "number";
+		if (typeof node.value === "boolean") return "boolean";
+	}
+	if (node.type === "NullLiteral") return "any";
+	if (node.type === "NumericLiteral") return "number";
+	if (node.type === "BooleanLiteral") return "boolean";
+	if (node.type === "MemberExpression") {
+		const property = node.property;
+		if (property?.type === "Identifier") return mapConstructorName(property.name);
+		if (property?.type === "StringLiteral" || property?.type === "Literal" && typeof property.value === "string") return mapConstructorName(property.value);
+		return "any";
+	}
+	if (node.type === "TSExpressionWithTypeArguments") return resolveTypeFromNode(node.expression);
+	if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSNonNullExpression") return resolveTypeFromNode(node.expression);
+	if (node.type === "ArrayExpression") {
+		const types = (Array.isArray(node.elements) ? node.elements : []).map((element) => {
+			if (!element) return;
+			if (element.type === "SpreadElement") return "any";
+			return resolveTypeFromNode(element);
+		}).filter((value) => Boolean(value));
+		if (types.length === 0) return "any";
+		return [...new Set(types)].join(" | ");
+	}
+	return "any";
+}
+function getStaticPropertyName(node) {
+	if (!node) return;
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "StringLiteral" || node.type === "Literal") {
+		if (typeof node.value === "string") return node.value;
+	}
+	if (node.type === "NumericLiteral") return String(node.value);
+	if (node.type === "Literal" && typeof node.value === "number") return String(node.value);
+}
+function extractPropertiesObject(node) {
+	if (!node || node.type !== "ObjectExpression") return;
+	const propMap = /* @__PURE__ */ new Map();
+	for (const property of node.properties ?? []) {
+		if (property?.type !== "ObjectProperty" && property?.type !== "Property") continue;
+		const name = getStaticPropertyName(property.key);
+		if (!name) continue;
+		const value = property.value;
+		if (value?.type === "ObjectExpression") {
+			let primaryType;
+			const optionalTypes = [];
+			for (const option of value.properties ?? []) {
+				if (option?.type !== "ObjectProperty" && option?.type !== "Property") continue;
+				const optionName = getStaticPropertyName(option.key);
+				if (!optionName) continue;
+				if (optionName === "type") primaryType = resolveTypeFromNode(option.value);
+				else if (optionName === "optionalTypes" && option.value?.type === "ArrayExpression") for (const element of option.value.elements ?? []) {
+					if (!element) continue;
+					optionalTypes.push(resolveTypeFromNode(element));
+				}
+			}
+			const typeCandidates = [primaryType, ...optionalTypes].filter((candidate) => Boolean(candidate && candidate.trim().length > 0));
+			const deduped = [...new Set(typeCandidates)];
+			propMap.set(name, deduped.length > 0 ? deduped.join(" | ") : "any");
+			continue;
+		}
+		propMap.set(name, resolveTypeFromNode(value));
+	}
+	return propMap;
+}
+function resolveOptionsObjectExpression(node, bindings) {
+	if (!node) return;
+	if (node.type === "ObjectExpression") return node;
+	if (node.type === "Identifier") return bindings.get(node.name);
+	if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSNonNullExpression") return resolveOptionsObjectExpression(node.expression, bindings);
+}
+function resolveOptionsObjectExpressionWithBabel(path, node) {
+	if (!node) return;
+	if (node.type === "ObjectExpression") return node;
+	if (node.type === "Identifier") {
+		const bindingPath = path.scope.getBinding(node.name)?.path;
+		if (bindingPath?.isVariableDeclarator()) {
+			const init = bindingPath.node.init;
+			if (init?.type === "ObjectExpression") return init;
+		}
+		return;
+	}
+	if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSNonNullExpression") return resolveOptionsObjectExpressionWithBabel(path, node.expression);
+}
+function extractComponentProperties(optionsNode) {
+	for (const property of optionsNode?.properties ?? []) {
+		if (property?.type !== "ObjectProperty" && property?.type !== "Property") continue;
+		const name = getStaticPropertyName(property.key);
+		if (name !== "properties" && name !== "props") continue;
+		if (property.value?.type === "ObjectExpression") return extractPropertiesObject(property.value) ?? /* @__PURE__ */ new Map();
+		return /* @__PURE__ */ new Map();
+	}
+	return /* @__PURE__ */ new Map();
+}
+function collectComponentPropsWithBabel(code) {
+	const ast = parse(code, BABEL_TS_MODULE_PARSER_OPTIONS);
+	let props = /* @__PURE__ */ new Map();
+	traverse(ast, { CallExpression(path) {
+		if (props.size > 0) return;
+		const [options] = path.node.arguments;
+		const optionsObject = resolveOptionsObjectExpressionWithBabel(path, options);
+		if (!optionsObject) return;
+		props = extractComponentProperties(optionsObject);
+	} });
+	return props;
+}
+function collectComponentPropsWithOxc(code) {
+	const ast = parseJsLikeWithEngine(code, {
+		engine: "oxc",
+		filename: "inline.ts"
+	});
+	const props = /* @__PURE__ */ new Map();
+	const bindings = /* @__PURE__ */ new Map();
+	let resolved = false;
+	walk(ast, { enter(node) {
+		if (resolved) return;
+		if (node.type === "VariableDeclarator" && node.id?.type === "Identifier") {
+			const optionsObject = resolveOptionsObjectExpression(node.init, bindings);
+			if (optionsObject) bindings.set(node.id.name, optionsObject);
+			return;
+		}
+		if (node.type !== "CallExpression") return;
+		const [options] = node.arguments ?? [];
+		const optionsObject = resolveOptionsObjectExpression(options, bindings);
+		if (!optionsObject) return;
+		resolved = true;
+		for (const [key, value] of extractComponentProperties(optionsObject)) props.set(key, value);
+	} });
+	return props;
+}
+/**
+* 从源码中提取组件属性类型映射。
+*/
+function collectComponentPropsFromCode(code, options) {
+	const engine = options?.astEngine ?? "babel";
+	try {
+		return engine === "oxc" ? collectComponentPropsWithOxc(code) : collectComponentPropsWithBabel(code);
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+}
+//#endregion
+export { collectComponentPropsFromCode };

package/dist/operations/featureFlags.d.mts

@@ -0,0 +1,14 @@
+import { AstEngineName } from "../types.mjs";
+
+//#region src/operations/featureFlags.d.ts
+interface FeatureFlagOptions<TFeature extends string> {
+  astEngine?: AstEngineName;
+  moduleId: string;
+  hookToFeature: Record<string, TFeature>;
+}
+/**
+ * 根据模块 ID 与 hook 映射表，从源码中收集启用的特性标识。
+ */
+declare function collectFeatureFlagsFromCode<TFeature extends string>(code: string, options: FeatureFlagOptions<TFeature>): Set<TFeature>;
+//#endregion
+export { FeatureFlagOptions, collectFeatureFlagsFromCode };

package/dist/operations/featureFlags.mjs

@@ -0,0 +1,97 @@
+import { parseJsLike, traverse } from "../babel.mjs";
+import { t as parseJsLikeWithEngine } from "../engine-DHqNPCDA.mjs";
+import * as t from "@babel/types";
+import { walk } from "oxc-walker";
+//#region src/operations/featureFlags.ts
+function collectWithBabel(code, moduleId, hookToFeature) {
+	const ast = parseJsLike(code);
+	const namedHookLocals = /* @__PURE__ */ new Map();
+	const namespaceLocals = /* @__PURE__ */ new Set();
+	for (const stmt of ast.program.body) {
+		if (!t.isImportDeclaration(stmt) || stmt.source.value !== moduleId) continue;
+		for (const specifier of stmt.specifiers) if (t.isImportSpecifier(specifier) && t.isIdentifier(specifier.imported)) {
+			const matched = hookToFeature[specifier.imported.name];
+			if (matched) namedHookLocals.set(specifier.local.name, matched);
+		} else if (t.isImportNamespaceSpecifier(specifier)) namespaceLocals.add(specifier.local.name);
+	}
+	if (namedHookLocals.size === 0 && namespaceLocals.size === 0) return /* @__PURE__ */ new Set();
+	const enabled = /* @__PURE__ */ new Set();
+	function consumeHookCallByName(name) {
+		const matched = namedHookLocals.get(name);
+		if (matched) enabled.add(matched);
+	}
+	function consumeNamespaceHookCall(namespace, hookName) {
+		if (!namespaceLocals.has(namespace)) return;
+		const matched = hookToFeature[hookName];
+		if (matched) enabled.add(matched);
+	}
+	traverse(ast, {
+		CallExpression(path) {
+			const callee = path.node.callee;
+			if (t.isIdentifier(callee)) {
+				consumeHookCallByName(callee.name);
+				return;
+			}
+			if (t.isMemberExpression(callee) && !callee.computed && t.isIdentifier(callee.object)) {
+				const property = callee.property;
+				if (t.isIdentifier(property)) consumeNamespaceHookCall(callee.object.name, property.name);
+			}
+		},
+		OptionalCallExpression(path) {
+			const callee = path.node.callee;
+			if (t.isIdentifier(callee)) {
+				consumeHookCallByName(callee.name);
+				return;
+			}
+			if (t.isMemberExpression(callee) && !callee.computed && t.isIdentifier(callee.object)) {
+				const property = callee.property;
+				if (t.isIdentifier(property)) consumeNamespaceHookCall(callee.object.name, property.name);
+			}
+		}
+	});
+	return enabled;
+}
+function collectWithOxc(code, moduleId, hookToFeature) {
+	const ast = parseJsLikeWithEngine(code, {
+		engine: "oxc",
+		filename: "inline.ts"
+	});
+	const namedHookLocals = /* @__PURE__ */ new Map();
+	const namespaceLocals = /* @__PURE__ */ new Set();
+	for (const statement of ast.body ?? []) {
+		if (statement?.type !== "ImportDeclaration" || statement.source?.value !== moduleId) continue;
+		for (const specifier of statement.specifiers ?? []) if (specifier.type === "ImportSpecifier" && specifier.imported?.type === "Identifier") {
+			const matched = hookToFeature[specifier.imported.name];
+			if (matched && specifier.local?.type === "Identifier") namedHookLocals.set(specifier.local.name, matched);
+		} else if (specifier.type === "ImportNamespaceSpecifier" && specifier.local?.type === "Identifier") namespaceLocals.add(specifier.local.name);
+	}
+	if (namedHookLocals.size === 0 && namespaceLocals.size === 0) return /* @__PURE__ */ new Set();
+	const enabled = /* @__PURE__ */ new Set();
+	walk(ast, { enter(node) {
+		if (node.type !== "CallExpression") return;
+		const callee = node.callee;
+		if (callee?.type === "Identifier") {
+			const matched = namedHookLocals.get(callee.name);
+			if (matched) enabled.add(matched);
+			return;
+		}
+		if (callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && callee.property?.type === "Identifier" && namespaceLocals.has(callee.object.name)) {
+			const matched = hookToFeature[callee.property.name];
+			if (matched) enabled.add(matched);
+		}
+	} });
+	return enabled;
+}
+/**
+* 根据模块 ID 与 hook 映射表，从源码中收集启用的特性标识。
+*/
+function collectFeatureFlagsFromCode(code, options) {
+	const engine = options.astEngine ?? "babel";
+	try {
+		return engine === "oxc" ? collectWithOxc(code, options.moduleId, options.hookToFeature) : collectWithBabel(code, options.moduleId, options.hookToFeature);
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+//#endregion
+export { collectFeatureFlagsFromCode };