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

package/ts-plugin/dist/index.js

@@ -0,0 +1,294 @@
+"use strict";
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+const config_extractor_1 = require("./config_extractor");
+const variable_extractor_1 = require("./variable_extractor");
+function init(modules) {
+    const ts_module = modules.typescript;
+    // 缓存提取的配置
+    let cached_config = null;
+    function create(info) {
+        const logger = info.project.projectService.logger;
+        logger.info('a-calc-ts-plugin: initializing');
+        const ls = info.languageService;
+        // 获取或更新配置
+        function get_config() {
+            const program = ls.getProgram();
+            // 简单的缓存策略：每次都重新提取（后续可优化）
+            if (program) {
+                cached_config = (0, config_extractor_1.extract_config_from_project)(ts_module, program, logger);
+            }
+            return cached_config || { units: [], shortcut_prefix: '!u' };
+        }
+        const original_get_completions = ls.getCompletionsAtPosition.bind(ls);
+        ls.getCompletionsAtPosition = (file_name, position, options) => {
+            const completions = get_acalc_completions(ts_module, ls, file_name, position, logger, get_config);
+            if (completions)
+                return completions;
+            return original_get_completions(file_name, position, options);
+        };
+        return ls;
+    }
+    return { create };
+}
+/**
+ * 获取 a-calc 表达式的补全
+ */
+function get_acalc_completions(ts_module, ls, file_name, position, logger, get_config) {
+    const program = ls.getProgram();
+    if (!program)
+        return undefined;
+    const source_file = program.getSourceFile(file_name);
+    if (!source_file)
+        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}`);
+    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);
+    logger.info(`a-calc-ts-plugin: trigger=${JSON.stringify(trigger)}`);
+    // 在 a-calc 字符串内，如果没有特定触发，返回空补全列表
+    // 避免原始 TypeScript 补全显示奇怪的内容
+    if (!trigger) {
+        return {
+            isGlobalCompletion: false,
+            isMemberCompletion: false,
+            isNewIdentifierLocation: false,
+            entries: [],
+        };
+    }
+    if (trigger.type === 'preset_name') {
+        return create_preset_name_completions(ts_module, trigger.prefix);
+    }
+    if (trigger.type === 'preset_value') {
+        return create_preset_value_completions(ts_module, trigger.preset, trigger.prefix, get_config());
+    }
+    if (trigger.type === 'shortcut') {
+        return create_shortcut_completions(ts_module, trigger.prefix, get_config());
+    }
+    if (trigger.type === 'format_syntax') {
+        const result = create_format_syntax_completions(ts_module, position);
+        logger.info(`a-calc-ts-plugin: format_syntax entries count=${result.entries.length}`);
+        return result;
+    }
+    if (trigger.type === 'format_variable') {
+        logger.info(`a-calc-ts-plugin: format_variable trigger, prefix="${trigger.prefix}"`);
+        const program = ls.getProgram();
+        if (program && context.second_arg) {
+            const type_checker = program.getTypeChecker();
+            const variables = (0, variable_extractor_1.extract_variables_from_arg)(ts_module, context.second_arg, type_checker, logger);
+            logger.info(`a-calc-ts-plugin: extracted ${variables.length} variables for format area`);
+            if (variables.length > 0) {
+                const result = create_variable_completions(ts_module, variables, trigger.prefix, position);
+                logger.info(`a-calc-ts-plugin: returning ${result.entries.length} format variable completions`);
+                return result;
+            }
+        }
+        return undefined;
+    }
+    if (trigger.type === 'variable') {
+        logger.info(`a-calc-ts-plugin: variable trigger, prefix="${trigger.prefix}"`);
+        logger.info(`a-calc-ts-plugin: context.second_arg exists=${!!context.second_arg}`);
+        const program = ls.getProgram();
+        if (program && context.second_arg) {
+            const type_checker = program.getTypeChecker();
+            const variables = (0, variable_extractor_1.extract_variables_from_arg)(ts_module, context.second_arg, type_checker, logger);
+            logger.info(`a-calc-ts-plugin: extracted ${variables.length} variables`);
+            if (variables.length > 0) {
+                const result = create_variable_completions(ts_module, variables, trigger.prefix, position);
+                logger.info(`a-calc-ts-plugin: returning ${result.entries.length} variable completions`);
+                return result;
+            }
+        }
+        else {
+            logger.info(`a-calc-ts-plugin: no program or second_arg, skipping variable completion`);
+        }
+        return undefined;
+    }
+    return undefined;
+}
+/**
+ * 创建预设名补全 (! 后)
+ */
+function create_preset_name_completions(ts_module, prefix) {
+    const entries = constants_1.ACALC_PRESETS
+        .filter(p => p.name.startsWith(prefix))
+        .map((p, i) => ({
+        name: p.name,
+        kind: ts_module.ScriptElementKind.keyword,
+        kindModifiers: '',
+        sortText: String(i).padStart(2, '0'),
+        labelDetails: { description: p.description },
+    }));
+    return {
+        isGlobalCompletion: false,
+        isMemberCompletion: false,
+        isNewIdentifierLocation: false,
+        entries,
+    };
+}
+/**
+ * 创建预设值补全 (!t: 后)
+ */
+function create_preset_value_completions(ts_module, preset, prefix, config) {
+    // 千分位预设
+    if (preset === 't') {
+        return create_completions_from_list(ts_module, constants_1.THOUSANDS_PRESETS, prefix);
+    }
+    // 紧凑格式预设
+    if (preset === 'c') {
+        return create_completions_from_list(ts_module, constants_1.COMPACT_PRESETS, prefix);
+    }
+    // 单位相关预设 (u, ua, ub, um, uh)
+    if (['u', 'ua', 'ub', 'um', 'uh'].includes(preset)) {
+        return create_unit_completions(ts_module, config.units, prefix);
+    }
+    return undefined;
+}
+/**
+ * 创建快捷语法补全 (: 后)
+ */
+function create_shortcut_completions(ts_module, prefix, config) {
+    const shortcut_prefix = config.shortcut_prefix;
+    // 根据 shortcut_prefix 决定补全内容
+    if (shortcut_prefix === '!t') {
+        return create_completions_from_list(ts_module, constants_1.THOUSANDS_PRESETS, prefix);
+    }
+    if (shortcut_prefix === '!c') {
+        return create_completions_from_list(ts_module, constants_1.COMPACT_PRESETS, prefix);
+    }
+    // 默认 !u 或其他单位相关前缀
+    return create_unit_completions(ts_module, config.units, prefix);
+}
+/**
+ * 从列表创建补全
+ */
+function create_completions_from_list(ts_module, list, prefix) {
+    const entries = list
+        .filter(item => item.name.startsWith(prefix))
+        .map((item, i) => ({
+        name: item.name,
+        kind: ts_module.ScriptElementKind.string,
+        kindModifiers: '',
+        sortText: String(i).padStart(2, '0'),
+        labelDetails: { description: item.description },
+    }));
+    return {
+        isGlobalCompletion: false,
+        isMemberCompletion: false,
+        isNewIdentifierLocation: false,
+        entries,
+    };
+}
+/**
+ * 创建单位补全
+ */
+function create_unit_completions(ts_module, units, prefix) {
+    const entries = units
+        .filter(u => u.startsWith(prefix))
+        .map((u, i) => ({
+        name: u,
+        kind: ts_module.ScriptElementKind.string,
+        kindModifiers: '',
+        sortText: String(i).padStart(2, '0'),
+    }));
+    return {
+        isGlobalCompletion: false,
+        isMemberCompletion: false,
+        isNewIdentifierLocation: false,
+        entries,
+    };
+}
+/**
+ * 创建格式化语法补全（| 后）
+ */
+function create_format_syntax_completions(ts_module, position) {
+    const entries = constants_1.FORMAT_SYNTAX.map((item, i) => ({
+        name: item.name,
+        insertText: item.insert_text,
+        kind: ts_module.ScriptElementKind.keyword,
+        kindModifiers: '',
+        sortText: String(i).padStart(2, '0'),
+        labelDetails: {
+            description: `${item.description} (${item.example})`,
+        },
+        replacementSpan: {
+            start: position,
+            length: 0,
+        },
+    }));
+    return {
+        isGlobalCompletion: false,
+        isMemberCompletion: false,
+        isNewIdentifierLocation: true,
+        entries,
+    };
+}
+/**
+ * 创建变量补全（表达式区域）
+ */
+function create_variable_completions(ts_module, variables, prefix, position) {
+    // 解析前缀，支持深度路径如 "user.na"
+    const prefix_parts = prefix.split('.');
+    const parent_path = prefix_parts.slice(0, -1).join('.');
+    const current_prefix = prefix_parts[prefix_parts.length - 1] || '';
+    // 过滤变量
+    let filtered_variables;
+    if (parent_path) {
+        // 有父路径：只显示该路径下的直接子属性
+        filtered_variables = variables.filter(v => {
+            // 检查是否是 parent_path 的直接子属性
+            if (!v.path.startsWith(parent_path + '.'))
+                return false;
+            const remaining = v.path.slice(parent_path.length + 1);
+            // 只要直接子属性（不包含更深的路径）
+            if (remaining.includes('.'))
+                return false;
+            // 匹配当前前缀
+            return remaining.startsWith(current_prefix);
+        });
+    }
+    else {
+        // 无父路径：只显示顶层属性
+        filtered_variables = variables.filter(v => {
+            // 只要顶层属性
+            if (v.path.includes('.'))
+                return false;
+            // 匹配前缀
+            return v.path.startsWith(current_prefix);
+        });
+    }
+    // 计算需要替换的文本长度
+    const replace_length = current_prefix.length;
+    const entries = filtered_variables.map((v, i) => {
+        // 获取要显示和插入的名称（只是当前层级的名称）
+        const display_name = parent_path
+            ? v.path.slice(parent_path.length + 1)
+            : v.path;
+        return {
+            name: display_name,
+            kind: v.has_children
+                ? ts_module.ScriptElementKind.moduleElement
+                : ts_module.ScriptElementKind.memberVariableElement,
+            kindModifiers: '',
+            sortText: String(i).padStart(3, '0'),
+            labelDetails: {
+                description: v.type_desc,
+            },
+            replacementSpan: {
+                start: position - replace_length,
+                length: replace_length,
+            },
+        };
+    });
+    return {
+        isGlobalCompletion: false,
+        isMemberCompletion: parent_path.length > 0,
+        isNewIdentifierLocation: false,
+        entries,
+    };
+}
+module.exports = init;

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

@@ -0,0 +1,49 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+/**
+ * a-calc 字符串上下文信息
+ */
+export interface AcalcStringContext {
+    in_string: boolean;
+    string_content: string;
+    offset_in_string: number;
+    /** 第二个参数的 AST 节点（用于提取变量） */
+    second_arg?: ts.Expression;
+    /** 函数名 */
+    func_name?: string;
+}
+/**
+ * 检测位置是否在 calc/fmt 等函数的字符串参数内
+ */
+export declare function is_in_acalc_string(ts_module: typeof ts, source_file: ts.SourceFile, position: number, type_checker?: ts.TypeChecker, logger?: {
+    info: (msg: string) => void;
+}): AcalcStringContext;
+/**
+ * 获取光标前的文本，用于判断触发条件
+ */
+export declare function get_text_before_cursor(content: string, offset: number): string;
+/**
+ * 补全触发类型
+ */
+export type TriggerType = {
+    type: 'preset_name';
+    prefix: string;
+} | {
+    type: 'preset_value';
+    preset: string;
+    prefix: string;
+} | {
+    type: 'shortcut';
+    prefix: string;
+} | {
+    type: 'format_syntax';
+} | {
+    type: 'variable';
+    prefix: string;
+} | {
+    type: 'format_variable';
+    prefix: string;
+} | null;
+/**
+ * 检测补全触发类型
+ */
+export declare function detect_trigger(text_before: string): TriggerType;

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[];