a-calc 3.0.0-beta.20260130.1 → 3.0.0-beta.20260201.1

package/ts-plugin/dist/variable_extractor.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extract_variables_from_arg = void 0;
+/**
+ * 从第二个参数中提取所有可用变量
+ */
+function extract_variables_from_arg(ts_module, arg, type_checker, logger) {
+    const result = [];
+    const type = type_checker.getTypeAtLocation(arg);
+    logger.info(`a-calc-ts-plugin: extracting variables from arg, type=${type_checker.typeToString(type)}`);
+    // 检查是否是数组类型
+    if (is_array_type(ts_module, type, type_checker)) {
+        // 数组类型：提取元素类型的属性
+        const element_type = get_array_element_type(ts_module, type, type_checker);
+        if (element_type) {
+            extract_properties_from_type(ts_module, element_type, '', type_checker, result, logger, 0);
+        }
+    }
+    else {
+        // 对象类型：直接提取属性
+        extract_properties_from_type(ts_module, type, '', type_checker, result, logger, 0);
+    }
+    logger.info(`a-calc-ts-plugin: extracted ${result.length} variables`);
+    return result;
+}
+exports.extract_variables_from_arg = extract_variables_from_arg;
+/**
+ * 检查是否是数组类型
+ */
+function is_array_type(ts_module, type, type_checker) {
+    const type_str = type_checker.typeToString(type);
+    // 检查是否是数组字面量或 Array<T>
+    if (type_str.endsWith('[]') || type_str.startsWith('Array<')) {
+        return true;
+    }
+    // 检查 symbol
+    const symbol = type.getSymbol();
+    if (symbol && symbol.getName() === 'Array') {
+        return true;
+    }
+    // 检查是否有 length 属性和数字索引签名
+    if (type_checker.getIndexTypeOfType(type, ts_module.IndexKind.Number)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * 获取数组元素类型
+ */
+function get_array_element_type(ts_module, type, type_checker) {
+    // 尝试获取数字索引类型
+    const index_type = type_checker.getIndexTypeOfType(type, ts_module.IndexKind.Number);
+    if (index_type) {
+        return index_type;
+    }
+    // 尝试从类型参数获取
+    const type_args = type.typeArguments;
+    if (type_args && type_args.length > 0) {
+        return type_args[0];
+    }
+    return undefined;
+}
+/**
+ * 从类型中递归提取属性
+ */
+function extract_properties_from_type(ts_module, type, prefix, type_checker, result, logger, depth) {
+    // 限制递归深度，防止无限递归
+    const MAX_DEPTH = 5;
+    if (depth > MAX_DEPTH) {
+        return;
+    }
+    const properties = type.getProperties();
+    for (const prop of properties) {
+        const prop_name = prop.getName();
+        // 跳过以 _ 开头的内部属性（如 _error, _fmt 等配置项）
+        if (prop_name.startsWith('_')) {
+            continue;
+        }
+        // 跳过一些常见的内置属性
+        if (['__proto__', 'constructor', 'prototype'].includes(prop_name)) {
+            continue;
+        }
+        const full_path = prefix ? `${prefix}.${prop_name}` : prop_name;
+        // 获取属性类型
+        let prop_type;
+        try {
+            if (prop.valueDeclaration) {
+                prop_type = type_checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration);
+            }
+            else {
+                // 尝试从声明中获取
+                const declarations = prop.getDeclarations();
+                if (declarations && declarations.length > 0) {
+                    prop_type = type_checker.getTypeOfSymbolAtLocation(prop, declarations[0]);
+                }
+            }
+        }
+        catch (e) {
+            // 忽略获取类型失败的情况
+        }
+        const type_desc = prop_type ? type_checker.typeToString(prop_type) : 'unknown';
+        const has_children = prop_type ? has_object_properties(ts_module, prop_type, type_checker) : false;
+        result.push({
+            path: full_path,
+            type_desc,
+            has_children,
+        });
+        // 如果是对象类型，递归提取子属性
+        if (prop_type && has_children) {
+            extract_properties_from_type(ts_module, prop_type, full_path, type_checker, result, logger, depth + 1);
+        }
+    }
+}
+/**
+ * 检查类型是否有对象属性（用于判断是否需要深度补全）
+ */
+function has_object_properties(ts_module, type, type_checker) {
+    // 排除基本类型
+    const type_str = type_checker.typeToString(type);
+    const primitive_types = ['string', 'number', 'boolean', 'null', 'undefined', 'void', 'never', 'any', 'unknown'];
+    if (primitive_types.includes(type_str)) {
+        return false;
+    }
+    // 排除数组类型（不递归进入数组元素）
+    if (type_str.endsWith('[]') || type_str.startsWith('Array<')) {
+        return false;
+    }
+    // 排除函数类型
+    const call_signatures = type.getCallSignatures();
+    if (call_signatures && call_signatures.length > 0) {
+        return false;
+    }
+    // 检查是否有属性
+    const properties = type.getProperties();
+    // 过滤掉以 _ 开头的属性
+    const user_properties = properties.filter(p => !p.getName().startsWith('_'));
+    return user_properties.length > 0;
+}