a-calc 3.0.0-beta.20260201.2 → 3.0.0-beta.20260201.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "a-calc",
-    "version": "3.0.0-beta.20260201.2",
+    "version": "3.0.0-beta.20260201.3",
     "description": "A very powerful and easy-to-use number precision calculation and formatting library.",
     "main": "./cjs/index.js",
     "exports": {

package/ts-plugin/dist/index.js

@@ -43,12 +43,12 @@ function get_acalc_completions(ts_module, ls, file_name, position, logger, get_c
         return undefined;
     const type_checker = program.getTypeChecker();
     const context = (0, utils_1.is_in_acalc_string)(ts_module, source_file, position, type_checker, logger);
-    logger.info(`a-calc-ts-plugin: in_string=${context.in_string}, offset=${context.offset_in_string}, has_second_arg=${!!context.second_arg}`);
+    logger.info(`a-calc-ts-plugin: in_string=${context.in_string}, offset=${context.offset_in_string}, has_second_arg=${!!context.second_arg}, is_format_only=${context.is_format_only}`);
     if (!context.in_string)
         return undefined;
     const text_before = (0, utils_1.get_text_before_cursor)(context.string_content, context.offset_in_string);
     logger.info(`a-calc-ts-plugin: text_before="${text_before}"`);
-    const trigger = (0, utils_1.detect_trigger)(text_before);
+    const trigger = (0, utils_1.detect_trigger)(text_before, context.is_format_only);
     logger.info(`a-calc-ts-plugin: trigger=${JSON.stringify(trigger)}`);
     // 在 a-calc 字符串内，如果没有特定触发，返回空补全列表
     // 避免原始 TypeScript 补全显示奇怪的内容

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

@@ -10,6 +10,8 @@ export interface AcalcStringContext {
     second_arg?: ts.Expression;
     /** 函数名 */
     func_name?: string;
+    /** 是否在纯格式化区域（fmt 第二参数、链式调用第二括号） */
+    is_format_only?: boolean;
 }
 /**
  * 检测位置是否在 calc/fmt 等函数的字符串参数内
@@ -45,5 +47,7 @@ export type TriggerType = {
 } | null;
 /**
  * 检测补全触发类型
+ * @param text_before 光标前的文本
+ * @param is_format_only 是否在纯格式化区域（fmt 第二参数、链式调用第二括号）
  */
-export declare function detect_trigger(text_before: string): TriggerType;
+export declare function detect_trigger(text_before: string, is_format_only?: boolean): TriggerType;

package/ts-plugin/dist/utils.js

@@ -17,6 +17,22 @@ function is_in_acalc_string(ts_module, source_file, position, type_checker, logg
                 if (!is_from_acalc(ts_module, node, type_checker, logger)) {
                     return ts_module.forEachChild(node, visit) || false;
                 }
+                // fmt 函数：检查第二个参数是否是格式化字符串
+                if (func_name === 'fmt' && node.arguments.length >= 2) {
+                    const second_arg = node.arguments[1];
+                    if (is_string_literal(ts_module, second_arg)) {
+                        const start = second_arg.getStart(source_file) + 1;
+                        const end = second_arg.getEnd() - 1;
+                        if (position >= start && position <= end) {
+                            result.in_string = true;
+                            result.string_content = get_string_content(ts_module, second_arg);
+                            result.offset_in_string = position - start;
+                            result.func_name = func_name;
+                            result.is_format_only = true;
+                            return true;
+                        }
+                    }
+                }
                 // 检查第一个参数是否是字符串
                 const first_arg = node.arguments[0];
                 if (first_arg && is_string_literal(ts_module, first_arg)) {
@@ -35,6 +51,22 @@ function is_in_acalc_string(ts_module, source_file, position, type_checker, logg
                     }
                 }
             }
+            // 链式调用检测: cadd(1, 2)("=2") 或 cadd(1).mul(2)("=2")
+            if (is_chain_call_format_arg(ts_module, node, type_checker, logger)) {
+                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 = 'chain_format';
+                        result.is_format_only = true;
+                        return true;
+                    }
+                }
+            }
         }
         return ts_module.forEachChild(node, visit) || false;
     }
@@ -42,49 +74,106 @@ function is_in_acalc_string(ts_module, source_file, position, type_checker, logg
     return result;
 }
 exports.is_in_acalc_string = is_in_acalc_string;
+/**
+ * 检测是否是链式调用的格式化参数
+ * cadd(1, 2).mul(3)("=2") 中最后的括号
+ */
+function is_chain_call_format_arg(ts_module, node, type_checker, logger) {
+    if (!type_checker)
+        return false;
+    try {
+        // 获取被调用表达式的类型
+        const expr = node.expression;
+        const expr_type = type_checker.getTypeAtLocation(expr);
+        const type_str = type_checker.typeToString(expr_type);
+        logger === null || logger === void 0 ? void 0 : logger.info(`a-calc-ts-plugin: chain check - expr type: ${type_str}`);
+        // 检查类型是否是 ChainValue
+        if (type_str === 'ChainValue') {
+            return true;
+        }
+        // 也检查类型的调用签名
+        const call_signatures = expr_type.getCallSignatures();
+        for (const sig of call_signatures) {
+            const return_type = type_checker.typeToString(sig.getReturnType());
+            logger === null || logger === void 0 ? void 0 : logger.info(`a-calc-ts-plugin: chain check - call sig return: ${return_type}`);
+            // ChainValue 调用后返回 string
+            if (return_type === 'string') {
+                // 检查参数是否是可选的 format 字符串
+                const params = sig.getParameters();
+                if (params.length <= 1) {
+                    // 进一步验证：检查表达式是否来自链式调用
+                    if (is_chain_expression(ts_module, expr, type_checker, logger)) {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    catch (e) {
+        logger === null || logger === void 0 ? void 0 : logger.info(`a-calc-ts-plugin: chain check error: ${e}`);
+    }
+    return false;
+}
+/**
+ * 检测表达式是否是链式调用表达式
+ */
+function is_chain_expression(ts_module, expr, type_checker, logger) {
+    // 链式方法调用: cadd(1).sub(2)
+    if (ts_module.isCallExpression(expr)) {
+        const call_expr = expr.expression;
+        // 检查是否是属性访问 (如 .sub, .mul)
+        if (ts_module.isPropertyAccessExpression(call_expr)) {
+            const method_name = call_expr.name.text;
+            const chain_methods = ['add', 'sub', 'mul', 'div', 'mod', 'pow', 'idiv'];
+            if (chain_methods.includes(method_name)) {
+                return true;
+            }
+        }
+        // 检查是否是链式起始函数 (cadd, csub 等)
+        if (ts_module.isIdentifier(call_expr)) {
+            const func_name = call_expr.text;
+            const chain_starters = ['cadd', 'csub', 'cmul', 'cdiv', 'cmod', 'cpow', 'cidiv'];
+            if (chain_starters.includes(func_name)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 /**
  * 检查函数是否来自 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;
+        const type = type_checker.getTypeAtLocation(expr);
+        const type_str = type_checker.typeToString(type);
+        logger === null || logger === void 0 ? void 0 : logger.info(`a-calc-ts-plugin: is_from_acalc - type: ${type_str}`);
+        // 检查是否匹配 a-calc 的函数类型签名
+        // calc: Calc 类型
+        // fmt: Fmt 类型
+        // cadd/csub 等: 返回 ChainValue
+        if (type_str === 'Calc' || type_str === 'Fmt') {
+            logger === null || logger === void 0 ? void 0 : logger.info('a-calc-ts-plugin: is_from_acalc - matched Calc/Fmt type');
+            return true;
         }
-        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');
+        // 检查调用签名的返回类型
+        const signatures = type.getCallSignatures();
+        for (const sig of signatures) {
+            const return_type = type_checker.typeToString(sig.getReturnType());
+            logger === null || logger === void 0 ? void 0 : logger.info(`a-calc-ts-plugin: is_from_acalc - return type: ${return_type}`);
+            // ChainValue 是链式调用的返回类型
+            if (return_type === 'ChainValue') {
+                logger === null || logger === void 0 ? void 0 : logger.info('a-calc-ts-plugin: is_from_acalc - matched ChainValue return');
                 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;
-                        }
-                    }
-                }
+            // CalcResult 是 calc 的返回类型
+            if (return_type.includes('CalcResult') || return_type.includes('& string')) {
+                logger === null || logger === void 0 ? void 0 : logger.info('a-calc-ts-plugin: is_from_acalc - matched CalcResult return');
+                return true;
             }
         }
         logger === null || logger === void 0 ? void 0 : logger.info('a-calc-ts-plugin: is_from_acalc - no match found');
@@ -138,8 +227,10 @@ function get_text_before_cursor(content, offset) {
 exports.get_text_before_cursor = get_text_before_cursor;
 /**
  * 检测补全触发类型
+ * @param text_before 光标前的文本
+ * @param is_format_only 是否在纯格式化区域（fmt 第二参数、链式调用第二括号）
  */
-function detect_trigger(text_before) {
+function detect_trigger(text_before, is_format_only) {
     // 检测 !xxx: 后的预设值补全 (如 !t:ind, !c:c)
     const value_match = text_before.match(/!(t|c|i|g|u|ua|ub|um|uh):([\w]*)$/);
     if (value_match) {
@@ -150,11 +241,16 @@ function detect_trigger(text_before) {
     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] };
     }
+    // 纯格式化区域（fmt 第二参数、链式调用第二括号）
+    // 整个字符串都是格式化语法，不需要 | 分隔符
+    if (is_format_only) {
+        return { type: 'format_syntax' };
+    }
     // 检测是否在格式化区域 (| 后面)
     if (is_in_format_area(text_before)) {
         // 格式化区域内的变量补全