乐趣区

关于javascript:如何手动解析vue单文件并预览

jiezi

结尾

笔者之前的文章里介绍过一个代码在线编辑预览工具的实现（传送门：疾速搭建一个代码在线编辑预览工具），实现了 css、html、js 的编辑，然而对于 demo 场景来说，vue单文件也是一个比拟好的代码组织形式，至多笔者就常常在写 vue 我的项目的同时顺便写写各种 demo，然而分享不太不便，因为单文件不能间接运行看成果，基于此，笔者决定在之前的根底上再减少一个vue 单文件的编辑及预览性能。

ps. 如果没看过之前的文章也没关系，这里简略介绍一下该我的项目：code-run，根本框架应用的是 vue3.x 版本，构建工具应用的是 vite，代码编辑器应用的是 monaco-editor，基本原理就是把 css、js、html 拼接成残缺的 html 字符串扔到 iframe 里进行预览。

另外我的项目目前存在一些坑：

1.vite不反对应用 commonjs 模块（笔者尚未找到解决办法，晓得的敌人在评论区留个言？）。

2. 三方模块目前都放在我的项目的 public 文件夹下，作为动态资源按需加载：

另外因为 Monaco Editor 自带的模块零碎和 defined/require 抵触，导致目前须要手动批改各个三方模块，让它只反对全局对象的形式来应用，比方：

基本思路

想要预览 vue 单文件，其实就是要想方法转成浏览器能意识的 css、js、html。首先想到的是应用vue-loader 来转换，然而看了它的文档，发现还是必须要配合 webpack 能力应用，不过笔者发现了一个配套的模块 vue-template-compiler，它提供了一些办法，其中有一个 parseComponent 办法能够用来解析vue 单文件，输入各个局部的内容，输入构造如下：

所以思路就很清晰了：

1.html局部，构造固定为：

<div id="app"></div>

2.css局部，首先判断有没有应用 css 预处理器，有的话就先应用对应的解析器转换成 css，而后再通过style 标签插入到页面。

3.js局部，以 vue2.x 版本为例，咱们最终须要生成如下所示的构造：

new Vue({
    el: '#app',
    template: '',// 模板局部内容
    // ... 其余选项
})

其余选项 就是 vue-template-compiler 解析出的 script.content 内容，然而单文件里根本都是 export default {} 模式的；template选项很简略，就是 template.content 的内容。

这里的解决思路是通过 babel 来将 export default {} 的模式转换成 new Vue 的模式，而后再增加上 el 和template两个属性即可，这会通过写一个 babel 插件来实现。

装置及应用 vue-template-compiler

首先 vue-template-compiler 模块咱们也会把它放到 public 文件夹下，那么它的浏览器应用版本在哪呢？咱们能够先装置它：npm i vue-template-compiler，而后在 node_modules 里找到它，会发现其中有一个文件：

这个就是咱们要的，间接把它复制到 public 文件夹下（当然也要正文掉它的模块导出），而后再把该模块删除即可，之后咱们便能够通过全局对象应用它：

// code 就是 vue 单文件内容字符串
let componentData = window.VueTemplateCompiler.parseComponent(code)
// 解决 style、script、template 三局部的内容，最初生成 css 字符串、js 字符串、html 字符串
parseVueComponentData(componentData)

生成 html 字符串

html局部咱们要做的就是写死一个 div，用它来挂载vue 实例即可：

const parseVueComponentData = async (data) => {
    // html 就间接渲染一个挂载 vue 实例的节点
    let htmlStr = `<div id="app"></div>`
    
    return {html: htmlStr}
}

生成 css 字符串

style局部如果没有应用 css 预处理器的话那么也很简略，间接返回款式内容即可，否则须要先应用对应的预处理器把它转换成css：

const parseVueComponentData = async (data) => {
    // 编译 css
    let cssStr = []
    // vue 单文件的 style 块能够存在多个，所以解析出的 styles 是个数组
    for(let i = 0; i < data.styles.length; i++) {let style = data.styles[i]
        // 如果应用了 css 预处理器，lang 字段不为空
        let preprocessor = style.lang || 'css'
        if (preprocessor !== 'css') {
            // load 办法会去加载对应的三方解析模块，详情请浏览上一篇文章
            await load([preprocessor])
        }
        // css 办法会应用对应的解析器来解析，可参考之前的文章
        let cssData = await css(preprocessor, style.content)
        // 把解析后的 css 字符串增加到后果数组里
        cssStr.push(cssData)
    }
    return {
        // 最初把多个 style 块的 css 拼接成一个
        css: cssStr.join('\r\n')
    }
}

下面的 css 会调用对应的 css 预处理器的解析模块来编译，比方 less 的解决如下：

const css = (preprocessor, code) => {return new Promise((resolve, reject) => {switch (preprocessor) {
            case 'css':
                resolve(code)
                break;
            case 'less':
                window.less.render(code)
                    .then((output) => {resolve(output.css)
                    },
                    (error) => {reject(error)
                    });
                break;
        }
    })
}

生成 js 字符串

script局部的内容咱们会应用 babel 来编译：

const parseVueComponentData = async (data, parseVueScriptPlugin) => {
    // babel 编译，通过编写插件来实现对 ast 的批改
    let jsStr = data.script ? window.Babel.transform(data.script.content, {
        presets: [
            'es2015',
            'es2016',
            'es2017',
        ],
        plugins: [
            // 插件
            parseVue2ScriptPlugin(data)
        ]
    }).code : ''

    return {js: jsStr}
}

babel插件其实就是一个函数，接管一个 babel 对象作为参数，而后须要返回一个对象，咱们能够在该对象的 visitor 属性里拜访到 AST 节点，并进行一些批改，visitor中的每个函数都接管 2 个参数：path 和 state，path示意两个节点之间连贯的对象，蕴含节点信息及一些操作方法，插件开发的具体文档请参考：plugin-handbook。

根本构造如下：

const parseVue2ScriptPlugin = (data) => {return function (babel) {
        let t = babel.types
        return {visitor: {}
        }
    }
}

转换 export default 语法

接下来再次明确咱们的需要，咱们要把 export default {} 的模式转换成 new Vue 的模式，具体怎么做呢，咱们能够应用 astexplorer 这个工具先看看这两种构造的 AST 的差异是什么：

能够发现黄色局部都是一样的，只是外层的节点不一样，所以咱们能够拜访 ExportDefaultDeclaration 节点，而后把它替换成 ExpressionStatement 就行了，创立新节点也很简略，参考 AST 及 babel-types 文档即可。

const parseVue2ScriptPlugin = (data) => {return function (babel) {
        let t = babel.types
        return {
            visitor: {
                // 拜访 export default 节点，把 export default 转换成 new Vue
                ExportDefaultDeclaration(path) {
                    // 替换本身
                    path.replaceWith(
                        // 创立一个表达式语句
                        t.expressionStatement(
                            // 创立一个 new 表达式
                            t.newExpression(
                                // 创立名称为 Vue 的标识符，即函数名
                                t.identifier('Vue'),
                                // 函数参数
                                [
                                    // 参数就是 ExportDefaultDeclaration 节点的 declaration 属性对应的节点
                                    path.get('declaration').node
                                ]
                            )
                        )
                    );
                }
            }
        }
    }
}

成果如下：

到这里还没完结，el和 template 属性咱们还没有给它加上，同样能够先在 AST 工具外面尝试一下：

很显著咱们须要拜访 ObjectExpression 节点，而后给它的 properties 属性增加两个节点，首先想到的做法是这样的：

const parseVue2ScriptPlugin = (data) => {return function (babel) {
        let t = babel.types
        return {
            visitor: {ExportDefaultDeclaration(path) {// ...},
                ObjectExpression(path) {
                    // 如果父节点是 new 语句，那么就增加该节点的 properties
                    if (path.parent && path.parent.type === 'NewExpression') {
                        path.node.properties.push(
                            // el
                            t.objectProperty(t.identifier('el'),
                                t.stringLiteral('#app')
                            ),
                            // template
                            t.objectProperty(t.identifier('template'),
                                t.stringLiteral(data.template.content)
                            )
                        )
                    }
                }
            }
        }
    }
}

这样做的问题是什么呢，假如咱们要转换的代码是这样的：

new Vue({});
export default {created() {new Vue({});
    },
    data() {
        return {msg: "Hello world!",};
    },
    mounted() {new Vue({});
    },
};

咱们想要的应该只是给 export default 这个对象增加这两个属性，然而实际效果如下：

能够看到所有的 new 语句的对象都被批改了，这显然不是咱们想要的，那么正确的办法是什么呢，咱们应该在替换完 ExportDefaultDeclaration 节点后立马递归遍历该节点，并且增加完这两个属性后立刻进行遍历：

const parseVue2ScriptPlugin = (data) => {return function (babel) {
        let t = babel.types
        return {
            visitor: {ExportDefaultDeclaration(path) {
                    // export default -> new Vue
                    // ...
                    // 增加 el 和 template 属性
                    path.traverse({ObjectExpression(path2) {if (path2.parent && path2.parent.type === 'NewExpression') {
                                path2.node.properties.push(
                                    // el
                                    t.objectProperty(t.identifier('el'),
                                        t.stringLiteral('#app')
                                    ),
                                    // template
                                    t.objectProperty(t.identifier('template'),
                                        t.stringLiteral(data.template.content)
                                    ),
                                )
                                path2.stop()}
                        }
                    });
                }
            }
        }
    }
}

成果如下：

到这里，html、js、css三局部的内容都解决完了，咱们把它们拼成残缺的 html 字符串，而后扔到 iframe 里即可预览，成果如下：

转换 module.exports 语法

除了应用 export default 语法导出，也是可用应用 module.exports = {} 的，所以咱们也须要适配一下这种状况，根本套路都一样，先剖析 AST 节点树的差别，而后替换节点：

module.exports自身就是一个 ExpressionStatement，所以咱们只须要拜访AssignmentExpression 节点，并替换成 new Vue 的newExpression节点即可：

const parseVue2ScriptPlugin = (data) => {return function (babel) {
        let t = babel.types
        return {
            visitor: {
                // 解析 export default 模块语法
                ExportDefaultDeclaration(path) {// ...},
                // 解析 module.exports 模块语法
                AssignmentExpression(path) {
                    try {let objectNode = path.get('left.object.name')
                        let propertyNode = path.get('left.property.name')
                        if (
                            objectNode 
                            && objectNode.node === 'module' 
                            && propertyNode 
                            && propertyNode.node === 'exports'
                        ) {
                            path.replaceWith(
                                t.newExpression(t.identifier('Vue'),
                                    [path.get('right').node
                                    ]
                                )
                            )
                            // 增加 el 和 template 属性
                            // 逻辑同上
                        }
                    } catch (error) {console.log(error)
                    }
                }
            }
        }
    }
}

当然，这样写如果存在多个 module.exports = {} 语句是会出错的，不过这种场景应该不常见，咱们就不论了。

其余工具的做法

社区上有一些工具能够用来在浏览器端反对 .vue 文件的加载及应用，比方 http-vue-loader，应用形式如下：

<!doctype html>
<html lang="en">
  <head>
    <script src="https://unpkg.com/vue"></script>
    <script src="https://unpkg.com/http-vue-loader"></script>
  </head>

  <body>
    <div id="my-app">
      <my-component></my-component>
    </div>

    <script type="text/javascript">
      new Vue({
        el: '#my-app',
        components: {'my-component': httpVueLoader('my-component.vue')
        }
      });
    </script>
  </body>
</html>

接下来按它的原理咱们再来实现一遍。

咱们先不论款式，看一下根本的 html 和js局部：

const parseVueComponentData2 = (data) => {
    let htmlStr = `
        <div id="app">
            <vue-component></vue-component>
        </div>
    `
    // 把 vue 单文件字符串里的 / 转成 \/ 是因为如果不转，那么浏览器会错把模板里的标签当成页面的理论标签，会造成页面解析谬误
    let jsStr = `
        new Vue({
            el: '#app',
            components: {'vue-component': VueLoader(\`${data.replaceAll('/', '\\/')}\`)
            }
        });
    `
    return {
        html: htmlStr,
        js: jsStr,
        css: ''
    }
}

能够看到咱们这次把 vue 单文件当成一个组件来应用，而后咱们要实现一个全局办法VueLoader，接管单文件的内容，返回一个组件选项对象。

接下来咱们不应用 vue-template-compiler，而是本人来解析，原理是创立一个新的HTML 文档，而后把 vue 单文件的内容扔到该文档的 body 节点，而后再遍历 body 节点的子节点，依据标签名来判断各个局部：

// 全局办法
window.VueLoader = (str) => {
    let {
        templateEl,
        scriptEl,
        styleEls
    } = parseBlock(str)
}

// 解析出 vue 单文件的各个局部，返回对应的节点 
const parseBlock = (str) => {
    // 创立一个新的 HTML 文档
    let doc = document.implementation.createHTMLDocument('');
    // vue 单文件的内容增加到 body 节点下
    doc.body.innerHTML = str
    let templateEl = null
    let scriptEl = null
    let styleEls = []
    // 遍历 body 节点的子节点
    for (let node = doc.body.firstChild; node; node = node.nextSibling) {switch (node.nodeName) {
            case 'TEMPLATE':
                templateEl = node
                break;
            case 'SCRIPT':
                scriptEl = node
                break;
            case 'STYLE':
                styleEls.push(node)
                break;
        }
    }
    return {
        templateEl,
        scriptEl,
        styleEls
    }
}

接下来解析 script 块的内容，咱们最终是要返回一个选项对象，也就是这样的：

{
    name: 'vue-component',
    data () {
        return {msg: 'Hello world!'}
    },
    template: ''
}

而后再看看下面的截图，你应该有想法了，咱们能够手动创立一个 module.exports 对象，而后让 script 的代码运行时能拜访到该对象，那么不就相当于把这个选项对象赋值到咱们定义的 module.exports 对象上了吗。

window.VueLoader = (str) => {
    // ...
    let options = parseScript(scriptEl)
}

// 解析 script
const parseScript = (el) => {
    let str = el.textContent
    let module = {exports: {}
    }
    let fn = new Function('exports', 'module', str)
    fn(module.exports, module)
    return module.exports
}

接下来再把模板选项和组件名称增加到该对象上，最初返回该对象即可：

window.VueLoader = (str) => {
    // ...
    options.template = parseTemplate(templateEl)
    options.name = 'vue-component'
    return options
}

// 返回模板内容字符串
const parseTemplate = (el) => {return el.innerHTML}

css局部的解析和之前咱们的做法是一样的，这里不再赘述，然而 http-vue-loader 还实现了款式的 scoped 解决。

这个工具的一个毛病是不反对 export default 模块语法。

参考链接

最终成果预览：https://wanglin2.github.io/code-run-online/。

残缺代码请移步我的项目仓库：https://github.com/wanglin2/code-run。

疾速搭建一个代码在线编辑预览工具

astexplorer

http-vue-loader

Babel plugin-handbook

vue-template-compiler

babel-types

退出移动版