@tntd/monaco-editor 1.0.1 → 1.0.3

package/src/plugins/converter/index.js

@@ -0,0 +1,606 @@
+import { findNearestLeftParenthesisIndex } from '../../utils';
+export class ConverterPlugin {
+    constructor(options = {}) {
+        this.name = 'converter';
+        this.options = options;
+        this.regExpState = '@[^\\+\\*\\/#%\\(\\),;\\!\\<\\>\\-=@]*';
+        this.regExps = {
+            field: null,
+            method: null,
+            methodGlobal: null,
+            normalGlobal: null
+        };
+        this.modeField = null;
+        this.baseEditor = null;
+    }
+
+    apply(baseEditor) {
+        this.baseEditor = baseEditor;
+
+        // 1. 初始化正则和模式字段
+        this.initRegExps();
+
+        // 2. 更新编辑器语言配置
+        if (this.baseEditor.options.isFormula) {
+            this.baseEditor.updateLanguage(this.modeField);
+        }
+
+        // 3. 绑定方法到编辑器实例
+        Object.assign(this.baseEditor, {
+            CnCodeToEn: this.CnCodeToEn.bind(this),
+            EnCodeToCn: this.EnCodeToCn.bind(this),
+            getRegExps: this.getRegExps.bind(this),
+            getModeField: this.getModeField.bind(this),
+            updateRegExps: this.initRegExps.bind(this),
+            updateConverterData: this.updateData.bind(this)
+        });
+    }
+
+    // 初始化各种正则表达式和模式字段
+    initRegExps() {
+        const { fieldList = [], methodList = [], normalList = [], keyWords = [], regExpState } = this.options;
+
+        // 处理字段列表
+        const fArr = fieldList.map((item) => `@${item.name.replace(/\[/g, '\\[').replace(/\]/g, '\\]')}`).sort(this.sortByLength);
+
+        // 处理方法列表
+        const mArr = methodList.map((item) => `#${item.name}`).sort(this.sortByLength);
+
+        // 处理普通列表（转义特殊字符）
+        const nArr = normalList.map((item) => item.name.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')).sort(this.sortByLength);
+
+        const pattern = `(^|['"][^'"]*)(${nArr.join('|')})`;
+
+        // 设置正则表达式
+        this.regExps = {
+            field: new RegExp(`(${fArr.join('|')})`),
+            method: new RegExp(`(${mArr.join('|')})`),
+            methodGlobal: new RegExp(`(${mArr.join('|')})`, 'g'),
+            // normal 不能以引号开头
+            // normalGlobal: new RegExp(`(?<!['"])(${nArr.join('|')})`, 'g')
+            normalGlobal: new RegExp(pattern, 'g')
+        };
+
+        if (regExpState) {
+            this.regExpState = regExpState;
+        }
+
+        // 设置模式字段（供分词高亮使用）
+        this.modeField = {
+            codemirrorFieldList: this.getLocalList(fieldList, '@'),
+            codemirrorMethodList: this.getLocalList(methodList, '#'),
+            codemirrorNormalList: this.getLocalList(normalList, ''),
+            codemirrorKeywordList: keyWords
+        };
+    }
+
+    // 获取本地列表
+    getLocalList(list, type) {
+        if (!list?.length) return [];
+
+        let copyList = [...list];
+        if (type === '@') {
+            copyList = this.formatLocalFieldList(copyList, []);
+        }
+        const nameKey = this.options.fieldNames?.label || 'name';
+        // 排序，把长的放前面
+        return copyList.sort((a, b) => b[nameKey].length - a[nameKey].length).map((item) => `${type}${item[nameKey]}`);
+    }
+
+    // 获取正则表达式
+    getRegExps() {
+        return {
+            regExpState: this.regExpState,
+            ...this.regExps
+        };
+    }
+
+    // 获取模式字段
+    /**
+     * Gets the mode field value
+     * @returns {string} The current mode field value
+     */
+    getModeField() {
+        return this.modeField;
+    }
+
+    // 提取所有[]内部的原始字符串（正则匹配）
+    extractBracketContent = (expr) => {
+        const results = [];
+        let bracketCount = 0;
+        let startIdx = -1;
+        for (let i = 0; i < expr.length; i++) {
+            const char = expr[i];
+            if (char === '[') {
+                bracketCount++;
+                if (startIdx === -1) startIdx = i + 1;
+            } else if (char === ']' && bracketCount > 0) {
+                bracketCount--;
+                if (bracketCount === 0) {
+                    results.push(expr.slice(startIdx, i));
+                    startIdx = -1;
+                }
+            }
+        }
+        return results;
+    };
+
+    // 3. 步骤2：动态映射（支持多个动态索引源，自动分配别名）
+    mapBracketContent = (originalContents) => {
+        // 存储：别名 → 原始动态索引源（如 x1 → "@xxx.@年龄【整数】"）
+        const aliasToSourceMap = new Map();
+        // 统计动态索引源数量，用于分配别名（x1、x2...）
+        let dynamicIndexCount = 0;
+
+        const mappedIndexes = originalContents.map((content) => {
+            // 规则1：匹配「@字段名【类型】」格式（动态索引源）
+            const isNumberStr = /^\d+$/.test(content);
+            if (!isNumberStr && content) {
+                dynamicIndexCount++;
+                const alias = `$x${dynamicIndexCount}$`; // 分配唯一别名 x1、x2...
+                aliasToSourceMap.set(alias, content); // 记录别名与原始路径的映射
+                return alias;
+            }
+
+            // 规则2：纯数字字符串 → 转为整数（固定索引）
+            if (isNumberStr) {
+                return parseInt(content, 10);
+            }
+
+            // 规则3：其他情况 → 保留原始值
+            return content;
+        });
+
+        return { mappedIndexes, aliasToSourceMap };
+    };
+
+    replaceBracketContent = (expr, replacements) => {
+        let result = '';
+        let bracketCount = 0;
+        let startPosInResult = -1; // 记录「[」在result中的位置（而非原始expr的索引）
+        let replaceIdx = 0; // 替换值的指针
+
+        for (let i = 0; i < expr.length; i++) {
+            const char = expr[i];
+
+            if (char === '[') {
+                bracketCount++;
+                if (startPosInResult === -1) {
+                    // 记录「[」在result中的位置（此时还未拼接char，所以是当前result长度）
+                    startPosInResult = result.length;
+                }
+                result += char; // 拼接「[」
+            } else if (char === ']' && bracketCount > 0) {
+                bracketCount--;
+                result += char; // 拼接「]」，此时result中已包含完整的「[]」
+
+                // 括号平衡 + 有对应替换值：执行替换
+                if (bracketCount === 0 && replaceIdx < replacements.length) {
+                    const replacement = replacements[replaceIdx];
+                    const replacementStr = typeof replacement === 'number' ? replacement.toString() : replacement;
+
+                    // 关键：基于result自身的索引截取（而非原始expr的i）
+                    const leftBracketPos = startPosInResult; // 「[」在result中的位置
+                    const rightBracketPos = result.length - 1; // 「]」在result中的位置（刚拼接完「]」）
+
+                    // 重构result：左括号前的内容 + [替换值] + 右括号后的内容
+                    const before = result.slice(0, leftBracketPos + 1); // 包含「[」
+                    const after = result.slice(rightBracketPos); // 包含「]」
+                    result = before + replacementStr + after;
+
+                    // 推进指针，重置状态
+                    replaceIdx++;
+                    startPosInResult = -1;
+                } else if (bracketCount === 0) {
+                    // 无对应替换值，重置状态
+                    startPosInResult = -1;
+                }
+            }
+
+            // 非括号字符：直接拼接
+            else {
+                result += char;
+            }
+        }
+
+        return result;
+    };
+
+    // 还原[]内部
+    restoreToOriginalExpr = (replacedExpr, aliasToSourceMap) => {
+        let result = '';
+        let bracketCount = 0; // 括号平衡计数器
+        let startPosInResult = -1; // 记录「[」在result中的位置（避免索引错位）
+
+        for (let i = 0; i < replacedExpr.length; i++) {
+            const char = replacedExpr[i];
+
+            // 遇到左括号：计数+1，记录其在result中的位置
+            if (char === '[') {
+                bracketCount++;
+                if (startPosInResult === -1) {
+                    // 此时未拼接当前char，result长度即为「[」即将插入的位置
+                    startPosInResult = result.length;
+                }
+                result += char; // 拼接「[」
+            }
+
+            // 遇到右括号：计数-1，拼接后检查是否平衡
+            else if (char === ']' && bracketCount > 0) {
+                bracketCount--;
+                result += char; // 拼接「]」，此时result中已包含完整「[]」
+
+                // 括号平衡：提取别名，执行还原
+                if (bracketCount === 0) {
+                    const leftBracketPos = startPosInResult; // 「[」在result中的位置
+                    const rightBracketPos = result.length - 1; // 「]」在result中的位置（刚拼接完）
+
+                    // 提取当前[]内的别名（如$x1$）
+                    const alias = result.slice(leftBracketPos + 1, rightBracketPos);
+
+                    // 从映射表获取原始内容：有映射则还原，无映射则保留原别名
+                    const originalContent = aliasToSourceMap.get(alias) || alias;
+
+                    // 重构result：左括号前内容 + [原始内容] + 右括号后内容
+                    const before = result.slice(0, leftBracketPos + 1); // 包含「[」
+                    const after = result.slice(rightBracketPos); // 包含「]」
+                    result = before + originalContent + after;
+
+                    // 重置状态，准备下一个完整[]
+                    startPosInResult = -1;
+                }
+            }
+
+            // 非括号字符：直接拼接
+            else {
+                result += char;
+            }
+        }
+
+        return result;
+    };
+
+    QuoteHandle(cnCode) {
+        // 执行提取
+        const originalBracketContents = this.extractBracketContent(cnCode);
+        // 转换成对应的标识
+        const { mappedIndexes, aliasToSourceMap } = this.mapBracketContent(originalBracketContents);
+        // 执行替换
+        const finalContent = this.replaceBracketContent(cnCode, mappedIndexes);
+
+        return { finalContent, aliasToSourceMap };
+    }
+
+    CnCodeToEnHandle(cnCode) {
+        const { finalContent, aliasToSourceMap } = this.QuoteHandle(cnCode);
+        const aliasQuote = Object.fromEntries(aliasToSourceMap);
+
+        Object.keys(aliasQuote).forEach((key) => {
+            const newCode = this.CnCodeToEn(aliasQuote[key], 'isSub');
+            aliasToSourceMap.set(key, newCode);
+        });
+        return {
+            finalContent,
+            aliasToSourceMap
+        };
+    }
+
+    // 英文转中文
+    EnCodeToCnHandle(enCode) {
+        const { finalContent, aliasToSourceMap } = this.QuoteHandle(enCode);
+        const aliasQuote = Object.fromEntries(aliasToSourceMap);
+
+        Object.keys(aliasQuote).forEach((key) => {
+            const newCode = this.EnCodeToCn(aliasQuote[key], 'isSub');
+            aliasToSourceMap.set(key, newCode);
+        });
+        return {
+            finalContent,
+            aliasToSourceMap
+        };
+    }
+
+    // 中文转英文
+    CnCodeToEn(cnCode, isSub) {
+        const { fieldList, methodList, normalList, cnCodeToEnExtraLogic, cnCodeToEnUniqueLogic } = this.options;
+        // 1. 处理字段转换
+        const reg = new RegExp(this.regExpState, 'g');
+        let [childList] = [];
+
+        // 统一处理[]中的对象
+        let aliasToSourceMap = new Set();
+        ({ finalContent: cnCode, aliasToSourceMap } = this.CnCodeToEnHandle(cnCode));
+
+        let enCode = cnCode.replace(reg, (match, group1, group2) => {
+            const preStr = group2.substring(0, group1);
+
+            //[@ 获取 前序字符串没有以. 结尾 这种childList清空 重新从fieldList匹配
+            const endMatch = preStr.match(/\[[/s]*/);
+            if ((endMatch && preStr.endsWith(endMatch[0])) || !preStr?.endsWith('.')) {
+                childList = null;
+            }
+
+            let fList = childList || fieldList || [];
+            let { turnStr, leadingSpaces, trailingSpaces } = this.matchLetter(match, fList);
+
+            let fItem;
+            if (cnCodeToEnUniqueLogic) {
+                fItem = cnCodeToEnUniqueLogic({ group1, group2, fItem, list: fList, turnStr });
+            }
+
+            if (!fItem) {
+                fItem = fList.find((item) => `@${item.name}` === turnStr);
+            }
+
+            // group2 之前的字符串 group1 匹配的索引 [@a - 1]. 这种无法match到对应的 - 1]. 所以需要特殊处理
+            const specialMatch = preStr?.endsWith('].');
+            // 需要截取上一个@对象
+            if (specialMatch) {
+                if (childList?.length) {
+                    fItem = childList.find((item) => `@${item.name}` === turnStr);
+                    childList = fItem?.children || fItem?.data || null;
+                }
+                if (!fItem) {
+                    const preIndex = findNearestLeftParenthesisIndex(preStr, preStr?.length - 2);
+                    let parentObj = preStr.substring(0, preIndex);
+                    parentObj = parentObj.substring(parentObj.lastIndexOf('@'), preIndex);
+                    if (parentObj) {
+                        const parentObjItem = (fieldList || []).find((item) => `@${item.name}` === parentObj);
+                        if (parentObjItem) {
+                            fItem = parentObjItem?.children?.find((item) => `@${item.name}` === turnStr);
+                            childList = parentObjItem?.children ? parentObjItem?.children : parentObjItem?.data;
+                        }
+                    }
+                }
+            } else {
+                if (trailingSpaces?.includes('.')) {
+                    childList = fItem?.children || fItem?.data || null;
+                }
+            }
+            if (fItem) {
+                turnStr = `@${fItem.value}`;
+                if (cnCodeToEnExtraLogic) {
+                    const cnCodeTemp = cnCodeToEnExtraLogic(fItem);
+                    if (cnCodeTemp) {
+                        turnStr = cnCodeTemp + turnStr;
+                    }
+                }
+            } else {
+                childList = null;
+            }
+            return leadingSpaces + turnStr + trailingSpaces;
+        });
+
+        enCode = enCode.replace(this.regExps?.methodGlobal, (match) => {
+            let turnStr = match;
+            const mItem = (methodList || []).find((item) => `#${item.name}` === match);
+            if (mItem) turnStr = `#${mItem.realValue}`;
+            return turnStr;
+        });
+
+        enCode = enCode.replace(this.regExps?.normalGlobal, (match) => {
+            let turnStr = match;
+            const nItem = (normalList || []).find((item) => item.name === match);
+            if (nItem) turnStr = nItem.value;
+            return turnStr;
+        });
+
+        const subInfo = Object.fromEntries(aliasToSourceMap);
+        if (!isSub && Object.keys(subInfo)?.length) {
+            enCode = this.restoreToOriginalExpr(enCode, aliasToSourceMap);
+        }
+        return enCode;
+    }
+
+    // 英文转中文
+    EnCodeToCn(enCode, isSub) {
+        if (!enCode) {
+            return enCode;
+        }
+
+        // 统一处理[]中的对象
+        let aliasToSourceMap = new Set();
+        ({ finalContent: enCode, aliasToSourceMap } = this.EnCodeToCnHandle(enCode));
+
+        let [childList] = [];
+        const reg = new RegExp(this.regExpState, 'g');
+
+        const { fieldList, methodList, normalList, enCodeToCnExtraLogic } = this.options;
+
+        const mValueArr = (methodList || []).map((item) => `#${item.realValue}`).sort(this.sortByLength);
+        const nValueArr = (normalList || []).map((item) => item.value).sort(this.sortByLength);
+
+        const keywords = [...mValueArr, ...nValueArr].join('|');
+        const curRegExp = new RegExp(`(${keywords})`, 'g');
+
+        let cnCode = enCode.replace(reg, (match, group1, group2) => {
+            let { turnStr, leadingSpaces, trailingSpaces } = this.matchLetter(match);
+
+            const preStr = group2.substring(0, group1);
+            //[αString 或者 没有以.αOBJECT 结尾的 重新设置子项目的列表
+            const endMatchNew = /\[\α?[a-zA-Z]*$/;
+            const endNormalMatchNew = /\.\α?[a-zA-Z]*$/;
+            if (endMatchNew?.test(preStr) || !endNormalMatchNew?.test(preStr)) {
+                childList = null;
+            }
+
+            let fItem = (childList || fieldList || []).find((item) => `@${item.value}` === turnStr);
+
+            // 特殊处理：处理 以 ].αString 结尾的情况
+            const regexEnd = /\]\.\α?[a-zA-Z]*$/;
+            const specialMatch = regexEnd.test(preStr);
+            if (specialMatch) {
+                const matchResult = preStr.match(regexEnd);
+                if (!matchResult) return null;
+                const preIndex = findNearestLeftParenthesisIndex(preStr, matchResult.index);
+                if (preIndex === -1) return null;
+                let parentObj = preStr.substring(0, preIndex);
+                parentObj = parentObj.substring(parentObj.lastIndexOf('@'), preIndex);
+
+                if (parentObj) {
+                    if (childList?.length) {
+                        fItem = childList.find((item) => `@${item.value}` === turnStr);
+                    } else {
+                        const parentObjItemArr = (fieldList || []).filter((item) => `@${item.value}` === parentObj);
+
+                        parentObjItemArr?.forEach((parentObjItem) => {
+                            if (!fItem) {
+                                fItem = parentObjItem?.children?.find((item) => `@${item.value}` === turnStr);
+                            }
+                        });
+                    }
+                }
+            }
+
+            // 更新子列表并替换字符串
+            if (fItem) {
+                if (trailingSpaces?.includes('.')) {
+                    childList = fItem?.children || fItem?.data || null;
+                } else {
+                    childList = null;
+                }
+                turnStr = `@${fItem.name}`;
+            } else {
+                childList = null;
+            }
+
+            return leadingSpaces + turnStr + trailingSpaces;
+        });
+
+        if (enCodeToCnExtraLogic) {
+            const cnCodeTemp = enCodeToCnExtraLogic(cnCode);
+            if (cnCodeTemp) {
+                cnCode = cnCodeTemp;
+            }
+        }
+
+        cnCode = cnCode.replace(curRegExp, (match) => {
+            let turnStr = match;
+            const mItem = (methodList || []).find((item) => `#${item.realValue}` === match);
+            if (mItem) turnStr = `#${mItem.name}`;
+            const nItem = (normalList || []).find((item) => item.value === match);
+            if (nItem) turnStr = nItem.name;
+            return turnStr;
+        });
+
+        const subInfo = Object.fromEntries(aliasToSourceMap);
+        if (!isSub && Object.keys(subInfo)?.length) {
+            cnCode = this.restoreToOriginalExpr(cnCode, aliasToSourceMap);
+        }
+
+        return cnCode;
+    }
+
+    // 工具方法：按长度排序（长的在前）
+    sortByLength(a, b) {
+        return b.length - a.length;
+    }
+
+    // 工具方法：处理空格
+    matchLetter(match) {
+        let turnStr = match.replace(/^\s*|\s*$/g, '');
+
+        const leadingSpacesMatch = match.match(/^\s*/);
+        let leadingSpaces = '';
+        if (leadingSpacesMatch && leadingSpacesMatch.length) {
+            leadingSpaces = leadingSpacesMatch[0];
+        }
+
+        const trailingSpacesMatch = match.match(/\s*$/);
+        let trailingSpaces = '';
+        if (trailingSpacesMatch && trailingSpacesMatch.length) {
+            trailingSpaces = trailingSpacesMatch[0];
+        }
+
+        // 解析存在[0-9],或者. 的场景
+        //中文（@a[0].@b）、（@a.@b）、（@a[@b]）、
+        //英文 （αSTRING@a[0].αSTRING@b）、（αSTRING@a.αSTRING@b）、(αSTRIN@a[αSTRING@b])
+        if (turnStr) {
+            // 如果名称中就带点则直接返回
+            if (this.fieldList?.length && turnStr?.endsWith('.')) {
+                const findItem = this.fieldList.find((item) => `@${item.name}` === turnStr);
+                if (findItem && !findItem?.children) {
+                    return {
+                        turnStr,
+                        leadingSpaces,
+                        trailingSpaces
+                    };
+                }
+            }
+
+            // turnStr?.includes('[α')
+            const regex1 = /\[[\s]*α?/;
+            const matched = turnStr.match(regex1);
+
+            if (turnStr?.endsWith('.') || turnStr?.endsWith(']') || turnStr?.endsWith('[') || turnStr?.includes('.α') || matched) {
+                const lastEndDot = turnStr.lastIndexOf('.');
+                const lastLQuote = turnStr.lastIndexOf('[');
+                const firstRQuote = turnStr.indexOf(']');
+                // [xxx].  [xx]
+                if ((lastLQuote > -1 && lastLQuote < lastEndDot) || (lastLQuote > -1 && lastEndDot < 0)) {
+                    trailingSpaces = (turnStr.substring(lastLQuote) || '') + trailingSpaces;
+                    turnStr = turnStr.substring(0, lastLQuote);
+                }
+                // ]. αSTRIN@a[αSTRING@b]
+                else if (firstRQuote > -1 && lastEndDot > -1 && firstRQuote < lastEndDot) {
+                    trailingSpaces = (turnStr.substring(firstRQuote) || '') + trailingSpaces;
+                    turnStr = turnStr.substring(0, firstRQuote);
+                } else if (lastEndDot > -1) {
+                    trailingSpaces = (turnStr.substring(lastEndDot) || '') + trailingSpaces;
+                    turnStr = turnStr.substring(0, lastEndDot);
+                } else if (firstRQuote > -1) {
+                    trailingSpaces = (turnStr.substring(firstRQuote) || '') + trailingSpaces;
+                    turnStr = turnStr.substring(0, firstRQuote);
+                }
+            }
+        }
+
+        return {
+            turnStr,
+            leadingSpaces,
+            trailingSpaces
+        };
+    }
+
+    // 工具方法：处理嵌套字段
+    formatLocalFieldList(list, newList = []) {
+        const { fieldNames } = this.options;
+        const { children, label = 'name', value = 'value' } = fieldNames || {};
+
+        list.forEach((item) => {
+            if (item?.[children]?.length) {
+                this.formatLocalFieldList(item[children], newList);
+            }
+            newList.push({
+                type: item.type,
+                [label]: item[label],
+                [value]: item[value]
+            });
+        });
+
+        return newList;
+    }
+
+    // 更新数据
+    updateData(newData = {}) {
+        // 1. 更新选项
+        this.options = {
+            ...this.options,
+            ...newData
+        };
+
+        // 2. 重新初始化
+        this.initRegExps();
+
+        // 3. 如果需要，更新编辑器语言配置
+        this.baseEditor.updateLanguage(this.modeField);
+
+        return this;
+    }
+
+    dispose() {
+        // 清理资源
+        this.regExps = null;
+        this.modeField = null;
+    }
+}