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

package/ts-plugin/dist/utils.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detect_trigger = exports.get_text_before_cursor = exports.is_in_acalc_string = void 0;
+/**
+ * 检测位置是否在 calc/fmt 等函数的字符串参数内
+ */
+function is_in_acalc_string(ts_module, source_file, position, type_checker, logger) {
+    const result = { in_string: false, string_content: '', offset_in_string: 0 };
+    // 目标函数名
+    const target_functions = ['calc', 'fmt', 'calc_sum', 'calc_wrap', 'calc_space', 'calc_avg', 'calc_max', 'calc_min', 'calc_count'];
+    function visit(node) {
+        // 检查是否是函数调用
+        if (ts_module.isCallExpression(node)) {
+            const func_name = get_function_name(ts_module, node);
+            if (func_name && target_functions.includes(func_name)) {
+                // 验证函数是否来自 a-calc 库
+                if (!is_from_acalc(ts_module, node, type_checker, logger)) {
+                    return ts_module.forEachChild(node, visit) || false;
+                }
+                // 检查第一个参数是否是字符串
+                const first_arg = node.arguments[0];
+                if (first_arg && is_string_literal(ts_module, first_arg)) {
+                    const start = first_arg.getStart(source_file) + 1; // 跳过引号
+                    const end = first_arg.getEnd() - 1; // 跳过引号
+                    if (position >= start && position <= end) {
+                        result.in_string = true;
+                        result.string_content = get_string_content(ts_module, first_arg);
+                        result.offset_in_string = position - start;
+                        result.func_name = func_name;
+                        // 保存第二个参数
+                        if (node.arguments.length > 1) {
+                            result.second_arg = node.arguments[1];
+                        }
+                        return true;
+                    }
+                }
+            }
+        }
+        return ts_module.forEachChild(node, visit) || false;
+    }
+    visit(source_file);
+    return result;
+}
+exports.is_in_acalc_string = is_in_acalc_string;
+/**
+ * 检查函数是否来自 a-calc 库
+ */
+function is_from_acalc(ts_module, node, type_checker, logger) {
+    var _a, _b;
+    if (!type_checker)
+        return true;
+    try {
+        const expr = node.expression;
+        const symbol = type_checker.getSymbolAtLocation(expr);
+        if (!symbol) {
+            logger === null || logger === void 0 ? void 0 : logger.info('a-calc-ts-plugin: is_from_acalc - no symbol found');
+            return false;
+        }
+        // 获取声明
+        const declarations = symbol.getDeclarations();
+        if (!declarations || declarations.length === 0) {
+            logger === null || logger === void 0 ? void 0 : logger.info('a-calc-ts-plugin: is_from_acalc - no declarations found');
+            return false;
+        }
+        for (const decl of declarations) {
+            const source_file = decl.getSourceFile();
+            const file_name = source_file.fileName.replace(/\\/g, '/');
+            logger === null || logger === void 0 ? void 0 : logger.info(`a-calc-ts-plugin: is_from_acalc - checking file: ${file_name}`);
+            // 匹配 node_modules 中的 a-calc 包
+            if (file_name.includes('node_modules/a-calc/')) {
+                logger === null || logger === void 0 ? void 0 : logger.info('a-calc-ts-plugin: is_from_acalc - matched node_modules/a-calc');
+                return true;
+            }
+            // 检查是否是 ImportSpecifier（从模块导入的）
+            if (ts_module.isImportSpecifier(decl)) {
+                const import_decl = (_b = (_a = decl.parent) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.parent;
+                if (import_decl && ts_module.isImportDeclaration(import_decl)) {
+                    const module_specifier = import_decl.moduleSpecifier;
+                    if (ts_module.isStringLiteral(module_specifier)) {
+                        const module_name = module_specifier.text;
+                        logger === null || logger === void 0 ? void 0 : logger.info(`a-calc-ts-plugin: is_from_acalc - import from: ${module_name}`);
+                        if (module_name === 'a-calc') {
+                            logger === null || logger === void 0 ? void 0 : logger.info('a-calc-ts-plugin: is_from_acalc - matched import from a-calc');
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        logger === null || logger === void 0 ? void 0 : logger.info('a-calc-ts-plugin: is_from_acalc - no match found');
+        return false;
+    }
+    catch (e) {
+        logger === null || logger === void 0 ? void 0 : logger.info(`a-calc-ts-plugin: is_from_acalc - error: ${e}`);
+        return true;
+    }
+}
+/**
+ * 获取函数调用的函数名
+ */
+function get_function_name(ts_module, node) {
+    const expr = node.expression;
+    // 直接调用: calc(...)
+    if (ts_module.isIdentifier(expr)) {
+        return expr.text;
+    }
+    // 属性访问: obj.calc(...)
+    if (ts_module.isPropertyAccessExpression(expr)) {
+        return expr.name.text;
+    }
+    return undefined;
+}
+/**
+ * 检查节点是否是字符串字面量
+ */
+function is_string_literal(ts_module, node) {
+    return ts_module.isStringLiteral(node) ||
+        ts_module.isNoSubstitutionTemplateLiteral(node);
+}
+/**
+ * 获取字符串内容
+ */
+function get_string_content(ts_module, node) {
+    if (ts_module.isStringLiteral(node)) {
+        return node.text;
+    }
+    if (ts_module.isNoSubstitutionTemplateLiteral(node)) {
+        return node.text;
+    }
+    return '';
+}
+/**
+ * 获取光标前的文本，用于判断触发条件
+ */
+function get_text_before_cursor(content, offset) {
+    return content.slice(0, offset);
+}
+exports.get_text_before_cursor = get_text_before_cursor;
+/**
+ * 检测补全触发类型
+ */
+function detect_trigger(text_before) {
+    // 检测 !xxx: 后的预设值补全 (如 !t:ind, !c:c)
+    const value_match = text_before.match(/!(t|c|i|g|u|ua|ub|um|uh):([\w]*)$/);
+    if (value_match) {
+        return { type: 'preset_value', preset: value_match[1], prefix: value_match[2] };
+    }
+    // 检测 ! 后的预设名补全 (如 !t, !c)
+    const name_match = text_before.match(/!([\w]*)$/);
+    if (name_match) {
+        return { type: 'preset_name', prefix: name_match[1] };
+    }
+    // 检测快捷语法 : 后的补全 (需要前面是空格或 |)
+    const shortcut_match = text_before.match(/(?:^|[\s|]):([\w]*)$/);
+    if (shortcut_match) {
+        return { type: 'shortcut', prefix: shortcut_match[1] };
+    }
+    // 检测是否在格式化区域 (| 后面)
+    if (is_in_format_area(text_before)) {
+        // 格式化区域内的变量补全
+        // 检测 @ 后的变量补全（用于单位、预设等）
+        const at_var_match = text_before.match(/@([\w.]*)$/);
+        if (at_var_match) {
+            return { type: 'format_variable', prefix: at_var_match[1] };
+        }
+        // 检测 = 后的变量补全（用于小数位数）
+        const eq_var_match = text_before.match(/=([\w.]*)$/);
+        if (eq_var_match) {
+            const prefix = eq_var_match[1];
+            // 空前缀或以字母开头时触发变量补全，纯数字是精度值不触发
+            if (prefix === '' || /^[a-zA-Z]/.test(prefix)) {
+                return { type: 'format_variable', prefix };
+            }
+        }
+        // 检测 > 或 < 后的变量补全（用于范围限制）
+        const range_var_match = text_before.match(/[><]([\w.]*)$/);
+        if (range_var_match) {
+            const prefix = range_var_match[1];
+            if (prefix === '' || /^[a-zA-Z]/.test(prefix)) {
+                return { type: 'format_variable', prefix };
+            }
+        }
+        // 其他情况显示格式化语法
+        return { type: 'format_syntax' };
+    }
+    // 表达式区域：检测变量补全
+    // 匹配变量名前缀，需要前面是分隔符（空格、运算符、括号等）或字符串开头
+    const var_match = text_before.match(/(?:^|[\s+\-*/%(),:])([a-zA-Z_][\w.]*)$/);
+    if (var_match) {
+        return { type: 'variable', prefix: var_match[1] };
+    }
+    // 检测刚开始输入变量名（光标前是分隔符）
+    if (/(?:^|[\s+\-*/%(),:])$/.test(text_before)) {
+        return { type: 'variable', prefix: '' };
+    }
+    return null;
+}
+exports.detect_trigger = detect_trigger;
+/**
+ * 检测是否在格式化区域
+ */
+function is_in_format_area(text_before) {
+    return text_before.includes('|');
+}

package/ts-plugin/dist/variable_extractor.d.ts

@@ -0,0 +1,16 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+/**
+ * 变量信息
+ */
+export interface VariableInfo {
+    /** 变量路径，如 "user.name" */
+    path: string;
+    /** 变量类型描述 */
+    type_desc: string;
+    /** 是否有子属性（用于深度补全） */
+    has_children: boolean;
+}
+/**
+ * 从第二个参数中提取所有可用变量
+ */
+export declare function extract_variables_from_arg(ts_module: typeof ts, arg: ts.Expression, type_checker: ts.TypeChecker, logger: ts.server.Logger): VariableInfo[];

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;
+}