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

package/ts-plugin/dist/constants.js

@@ -0,0 +1,274 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORMAT_SYNTAX = exports.COMPACT_PRESETS = exports.THOUSANDS_PRESETS = exports.ACALC_PRESETS = void 0;
+/**
+ * a-calc ! 系统预设
+ */
+exports.ACALC_PRESETS = [
+    {
+        name: 't',
+        description: '千分位预设',
+        has_value: true,
+        value_required: false,
+        example: '!t 或 !t:indian'
+    },
+    {
+        name: 'c',
+        description: '紧凑格式',
+        has_value: true,
+        value_required: false,
+        example: '!c 或 !c:cn'
+    },
+    {
+        name: 'i',
+        description: '整数补零',
+        has_value: true,
+        value_required: true,
+        example: '!i:3'
+    },
+    {
+        name: 'g',
+        description: '格式化分组',
+        has_value: true,
+        value_required: true,
+        example: '!g:money'
+    },
+    {
+        name: 'u',
+        description: '单位（默认位置）',
+        has_value: true,
+        value_required: true,
+        example: '!u:元'
+    },
+    {
+        name: 'ua',
+        description: '单位在数字后',
+        has_value: true,
+        value_required: true,
+        example: '!ua:元'
+    },
+    {
+        name: 'ub',
+        description: '单位在数字前',
+        has_value: true,
+        value_required: true,
+        example: '!ub:$'
+    },
+    {
+        name: 'um',
+        description: '单位在符号后',
+        has_value: true,
+        value_required: true,
+        example: '!um:元'
+    },
+    {
+        name: 'uh',
+        description: '转换但隐藏单位',
+        has_value: true,
+        value_required: false,
+        example: '!uh 或 !uh:元'
+    },
+];
+/**
+ * 千分位预设值
+ */
+exports.THOUSANDS_PRESETS = [
+    { name: 'en', description: '英文/国际 (1,234,567)' },
+    { name: 'eu', description: '欧洲 (1.234.567)' },
+    { name: 'swiss', description: "瑞士 (1'234'567)" },
+    { name: 'space', description: '空格分隔 (1 234 567)' },
+    { name: 'fr', description: '法国 (1 234 567,89)' },
+    { name: 'indian', description: '印度 (12,34,567)' },
+    { name: 'wan', description: '万进制 (1234,5678)' },
+];
+/**
+ * 紧凑格式预设值
+ */
+exports.COMPACT_PRESETS = [
+    { name: 'en', description: '英文 (K/M/B/T)' },
+    { name: 'cn', description: '中文千进制 (千/百万/十亿)' },
+    { name: 'wan', description: '万进制 (万/亿)' },
+    { name: 'storage', description: '存储单位 (KB/MB/GB)' },
+    { name: 'indian', description: '印度 (K/L/Cr)' },
+];
+/**
+ * 格式化语法列表（用于 | 后的补全）
+ * insert_text: 实际插入的文本（不含占位符）
+ */
+exports.FORMAT_SYNTAX = [
+    // 小数位控制
+    {
+        name: '=N',
+        insert_text: '=',
+        description: '精确 N 位小数',
+        example: '=2 → 1.50',
+    },
+    {
+        name: '<=N',
+        insert_text: '<=',
+        description: '最多 N 位小数（不补零）',
+        example: '<=2 → 1.5',
+    },
+    {
+        name: '>=N',
+        insert_text: '>=',
+        description: '最少 N 位小数（补零）',
+        example: '>=3 → 1.500',
+    },
+    {
+        name: '>=N<=M',
+        insert_text: '>=',
+        description: '小数位数范围',
+        example: '>=2<=4 → 1.5 ~ 1.5000',
+    },
+    // 舍入规则
+    {
+        name: '~5',
+        insert_text: '~5',
+        description: '四舍五入',
+        example: '~5=2: 1.125 → 1.13',
+    },
+    {
+        name: '~6',
+        insert_text: '~6',
+        description: '银行家舍入（四舍六入五取偶）',
+        example: '~6=2: 1.125 → 1.12',
+    },
+    {
+        name: '~+',
+        insert_text: '~+',
+        description: '进位（向上取整）',
+        example: '~+=2: 1.121 → 1.13',
+    },
+    {
+        name: '~-',
+        insert_text: '~-',
+        description: '截断（向下取整，默认）',
+        example: '~-=2: 1.129 → 1.12',
+    },
+    // 千分位
+    {
+        name: ',',
+        insert_text: ',',
+        description: '千分位分隔',
+        example: '1234567 → 1,234,567',
+    },
+    {
+        name: '!t',
+        insert_text: '!t',
+        description: '千分位（默认预设）',
+        example: '1234567 → 1,234,567',
+    },
+    {
+        name: '!t:preset',
+        insert_text: '!t:',
+        description: '千分位预设',
+        example: '!t:indian → 12,34,567',
+    },
+    // 紧凑格式
+    {
+        name: '!c',
+        insert_text: '!c',
+        description: '紧凑格式（默认 K/M/B/T）',
+        example: '1500 → 1.5K',
+    },
+    {
+        name: '!c:preset',
+        insert_text: '!c:',
+        description: '紧凑格式预设',
+        example: '!c:wan → 1万',
+    },
+    // 百分比
+    {
+        name: '%',
+        insert_text: '%',
+        description: '百分比格式',
+        example: '0.1234 → 12.34%',
+    },
+    // 正负号
+    {
+        name: '+',
+        insert_text: '+',
+        description: '显示正号',
+        example: '100 → +100',
+    },
+    // 整数补零
+    {
+        name: '!i:N',
+        insert_text: '!i:',
+        description: '整数部分补零到 N 位',
+        example: '!i:3: 5 → 005',
+    },
+    // 科学计数法
+    {
+        name: '!e',
+        insert_text: '!e',
+        description: '科学计数法',
+        example: '123456789 → 1.23e+8',
+    },
+    // 分数
+    {
+        name: '/',
+        insert_text: '/',
+        description: '分数形式',
+        example: '0.5 → 1/2',
+    },
+    // 返回类型
+    {
+        name: '!n',
+        insert_text: '!n',
+        description: '返回数字类型',
+        example: '"3" → 3 (number)',
+    },
+    {
+        name: '!s',
+        insert_text: '!s',
+        description: '返回字符串类型（默认）',
+        example: '3 → "3" (string)',
+    },
+    // 单位
+    {
+        name: '!u:unit',
+        insert_text: '!u:',
+        description: '单位（默认位置）',
+        example: '!u:元 → 100元',
+    },
+    {
+        name: '!ua:unit',
+        insert_text: '!ua:',
+        description: '单位在数字后',
+        example: '!ua:$ → 100$',
+    },
+    {
+        name: '!ub:unit',
+        insert_text: '!ub:',
+        description: '单位在数字前',
+        example: '!ub:$ → $100',
+    },
+    {
+        name: '!um:unit',
+        insert_text: '!um:',
+        description: '单位在符号后',
+        example: '!um:$ → +$100',
+    },
+    {
+        name: '!uh:unit',
+        insert_text: '!uh:',
+        description: '转换但隐藏单位',
+        example: '!uh:元 → 100',
+    },
+    // 范围限制
+    {
+        name: '[min,max]',
+        insert_text: '[',
+        description: '范围限制',
+        example: '[0,100]: 150 → 100',
+    },
+    // 格式化分组
+    {
+        name: '!g:name',
+        insert_text: '!g:',
+        description: '格式化分组',
+        example: '!g:money → 预设格式',
+    },
+];

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

@@ -0,0 +1,7 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+declare function init(modules: {
+    typescript: typeof ts;
+}): {
+    create: (info: ts.server.PluginCreateInfo) => ts.LanguageService;
+};
+export = init;

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;