chrome-plugin/lib/zlExpressEditor/singleRowModel/SingleRowEditor.js

/**
 * 单行表达式编辑器
 * @author hjh
 */

//表达式编辑器的唯一对外接口
window.zlExpressEditor = {};

//采用闭包的方式进行隔离
(function () {
    //表达式执行器
    let expressExecutor;

    /**
     * 资源信息
     * */
    let resourceInfo = [];

    /**
     * 所有的叶子节点
     * */
    let allLeafNodes = [];

    /**
     * 枚举选项的所有配置信息
     * key:name
     * value:setting
     */
    let enumSettings = {};

    /**
     * 初始化编辑器环境[只以最后一次调用生效]
     * @param {any} setting
     */
    window.zlExpressEditor.InitEditorEnvironment = function (setting, runtime = false) {
        //资源信息
        let resource = setting.resource;

        allLeafNodes = [];

        //解析资源信息
        resourceInfo = EnvironmentHelper.ParseResource(resource);
        //提取叶子节点
        for (let info of resourceInfo) {
            let nodes = EnvironmentHelper.ExtractLeafNodes(info);
            allLeafNodes.push(...nodes);
        }
        //将所有的叶子节点按照文本的长度进行排序
        allLeafNodes = allLeafNodes.sort((a, b) => b._path.length - a._path.length);

        //将JS代码添加库到monaco
        let jscode = EnvironmentHelper.ChangeToJsLib(resourceInfo);

        //仅设计时才添加库
        if (!runtime && monaco != null) {
            monaco.languages.typescript.javascriptDefaults.addExtraLib(jscode, 'resource.js');
        }

        expressExecutor = new ExpressExecutor(jscode);
    };


    /**
     * 根据设置获取脚本环境配置
     * @param {any} setting
     * @returns
     */
    window.zlExpressEditor.GetEditorEnvironment = function (setting) {
        let env = {};

        //资源信息
        let resource = setting.resource;


        env.allLeafNodes = [];

        //解析资源信息
        env.resourceInfo = EnvironmentHelper.ParseResource(resource);
        //提取叶子节点
        for (let info of env.resourceInfo) {
            let nodes = EnvironmentHelper.ExtractLeafNodes(info);
            env.allLeafNodes.push(...nodes);
        }
        //将所有的叶子节点按照文本的长度进行排序
        env.allLeafNodes = env.allLeafNodes.sort((a, b) => b._path.length - a._path.length);

        //将JS代码添加库到monaco
        let jscode = EnvironmentHelper.ChangeToJsLib(env.resourceInfo);

        //仅设计时才添加库
        if (monaco != null) {
            monaco.languages.typescript.javascriptDefaults.addExtraLib(jscode, 'resource.js');
        }

        env.expressExecutor = new ExpressExecutor(jscode);

        return env;
    };

    /**
     * 创建单行表达式编辑器
     * @param {any} node html节点(div)
     * @param {any} setting 配置信息
     */
    window.zlExpressEditor.CreateSingleRowEditor = function (node, setting, changeCallback, env) {
        //debugger;

        //初始化资源树
        let _editor = monaco.editor.create(node, {
            minimap: {
                enabled: false
            },
            fontSize: 20,
            lineNumbers: 'off',
            language: setting.language ?? "javascript"
        });

        //将公共环境私有化【用于适配每个单行表达式不同的环境】

        _editor.resourceInfo = resourceInfo;
        _editor.allLeafNodes = allLeafNodes;
        _editor.expressExecutor = expressExecutor;

        if (env) {
            _editor.resourceInfo = env.resourceInfo;
            _editor.allLeafNodes = env.allLeafNodes;
            _editor.expressExecutor = env.expressExecutor;
        }

        if (setting.useCommonFunctions) {
            //启用基础函数库
            EnvironmentHelper.LoadExtraJsSource("./extra/commonFunctions.js");
        }

        //获取值
        _editor.GetJsCode = function () {
            return EnvironmentHelper.ChangeDisplayToCode(_editor.getModel().getValue(), _editor.allLeafNodes, enumSettings);
            //return _editor.getModel().getValue();
        };

        //设置值
        _editor.SetJsCode = function (jscode) {
            _editor.getModel().setValue(EnvironmentHelper.ChangeCodeToDisplay(jscode, _editor.allLeafNodes, enumSettings));
            //_editor.getModel().setValue(jscode);
            //todo：如果含有选项内容，则设置为只读，反之则设置为可写
        };

        //设置值
        _editor.GetFullJsCode = function () {
            return { display: _editor.getModel().getValue(), code: _editor.GetJsCode() };
        };

        //当内容变化的时候，调用内容变化回调
        if (changeCallback) {
            _editor.getModel().onDidChangeContent(e => changeCallback(e));
        }

        _editor.SetJsCode(setting.value);

        return _editor;
    };

    /**
     * 执行表达式代码
     * @param {any} jsCode
     */
    window.zlExpressEditor.ExecExpress = function (jsCode) {
        jsCode = EnvironmentHelper.ChangeCodeToDisplay(jsCode, allLeafNodes, enumSettings);
        return expressExecutor.Run(jsCode);
    };

    /**
     * 更新环境资源信息
     * @param {Array} updateData 
     * 
     * [{
     * paths:["path","path","path"],
     * value:obj
     * },{
     * paths:["path","path","path"],
     * value:obj
     * }]
     * 
     */
    window.zlExpressEditor.UpdateResourceInfo = function (updateData) {
        if (updateData == null) {
            return;
        }

        //更新环境的JS
        let jsCode = "";

        updateData.forEach(p => {
            let target = resourceInfo;
            p.paths.forEach(pt => {
                target = target.find(i => i.id == pt);
                if (target == null) {
                    //忽略并警告
                    console.warn(`更新资源环境出错，找不到对应的path，${p.paths.join(".")}`);
                    return;
                }
                if (target.children != null) {
                    target = target.children;
                }
            });

            if (target != null) {
                target.propertyValue = p.value;
                jsCode += (target._path + " = " + target.GetValueDisplayString(target.propertyValue, target.propertType) + ";");
            }
        });

        //执行更新代码
        zlExpressEditor.ExecExpress(jsCode);
    };
})();