feat(v3): renderjs

packages/vue-cli-plugin-hbuilderx/module-alias.js

@@ -9,8 +9,8 @@ const {
 // nvue override
 moduleAlias.addAlias('weex-styler', path.resolve(__dirname, 'packages/weex-styler'))
 moduleAlias.addAlias('weex-template-compiler', path.resolve(__dirname, 'packages/weex-template-compiler'))
-moduleAlias.addAlias('./compileTemplate', require.resolve(
-  '@dcloudio/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/compileTemplate'))
+moduleAlias.addAlias('@vue/component-compiler-utils', require.resolve('@dcloudio/vue-cli-plugin-uni/packages/@vue/component-compiler-utils'))
+moduleAlias.addAlias('@vue/component-compiler-utils/package.json', require.resolve('@dcloudio/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/package.json'))
 
 if (isInHBuilderX) {
   moduleAlias.addAlias('typescript', path.resolve(process.env.UNI_HBUILDERX_PLUGINS,

packages/vue-cli-plugin-hbuilderx/packages/weex-template-compiler/build.js

@@ -555,7 +555,7 @@ function parseHTML (html, options) {
 var splitRE = /\r?\n/g;
 var replaceRE = /./g;
 var isSpecialTag = makeMap('script,style,template', true);
-var isCustomBlock = makeMap('wxs,filter,sjs', true);// fixed by xxxxxx
+var isCustomBlock = makeMap('wxs,filter,sjs,renderjs', true);// fixed by xxxxxx
 
 /**
  * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
@@ -2779,7 +2779,13 @@ var uid = 0;
  * directives subscribing to it.
  */
 var Dep = function Dep () {
-  this.id = uid++;
+  // fixed by xxxxxx (nvue vuex)
+  /* eslint-disable no-undef */
+  if(typeof SharedObject !== 'undefined'){
+    this.id = SharedObject.uid++;
+  } else {
+    this.id = uid++;
+  }
   this.subs = [];
 };
 

packages/vue-cli-plugin-uni/lib/app-plus/index.js

@@ -88,6 +88,13 @@ const v3 = {
         loader: path.resolve(__dirname,
           '../../packages/webpack-uni-app-loader/view/script')
       })
+      // view 层 renderjs
+      rules.push({
+        resourceQuery: [/lang=renderjs/, /blockType=renderjs/],
+        use: [{
+          loader: path.resolve(__dirname, '../../packages/webpack-uni-app-loader/view/renderjs')
+        }]
+      })
     }
     scriptLoaders.push({
       loader: path.resolve(__dirname,
@@ -245,11 +252,13 @@ const v3 = {
         compilerOptions
       }, cacheConfig))
       .end()
-      .use('uniapp-custom-block-loader')
-      .loader(require.resolve('@dcloudio/vue-cli-plugin-uni/packages/webpack-custom-block-loader'))
-      .options({
-        compiler: getPlatformCompiler()
-      })
+      // .use('uniapp-custom-block-loader')
+      // .loader(require.resolve('@dcloudio/vue-cli-plugin-uni/packages/webpack-custom-block-loader'))
+      // .options({
+      //   isAppService,
+      //   isAppView,
+      //   compiler: getPlatformCompiler()
+      // })
 
     // 是否启用 cache
     if (process.env.UNI_USING_CACHE) {

packages/vue-cli-plugin-uni/lib/vue-loader.js

@@ -35,11 +35,11 @@ module.exports = function modifyVueLoader (webpackConfig, compilerOptions, api)
       }, compilerOptions)
     }, cacheConfig))
     .end()
-    .use('uniapp-custom-block-loader')
-    .loader(require.resolve('@dcloudio/vue-cli-plugin-uni/packages/webpack-custom-block-loader'))
-    .options({
-      compiler: getPlatformCompiler()
-    })
+    // .use('uniapp-custom-block-loader')
+    // .loader(require.resolve('@dcloudio/vue-cli-plugin-uni/packages/webpack-custom-block-loader'))
+    // .options({
+    //   compiler: getPlatformCompiler()
+    // })
 
   // h5 框架需要使用 scoped 样式,其他平台编译时识别是否 nvue 文件且注入 flex 相关样式
   if (process.env.UNI_PLATFORM === 'h5') {

packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/CHANGELOG.md

+# [3.1.0](https://github.com/vuejs/component-compiler-utils/compare/v3.0.2...v3.1.0) (2019-12-08)
+
+
+### Features
+
+* include filename in `finalCompilerOptions` ([#74](https://github.com/vuejs/component-compiler-utils/issues/74)) ([3dda72d](https://github.com/vuejs/component-compiler-utils/commit/3dda72d))
+* support AST for template compile ([#68](https://github.com/vuejs/component-compiler-utils/issues/68)) ([ed44d6f](https://github.com/vuejs/component-compiler-utils/commit/ed44d6f))
+* support audio src in `transformAssetUrls` option by default ([#72](https://github.com/vuejs/component-compiler-utils/issues/72)) ([47f1341](https://github.com/vuejs/component-compiler-utils/commit/47f1341))
+
+
+
+## [3.0.2](https://github.com/vuejs/component-compiler-utils/compare/v3.0.1...v3.0.2) (2019-11-06)
+
+
+### Bug Fixes
+
+* also include "lib" folder for type definitions ([dd42df1](https://github.com/vuejs/component-compiler-utils/commit/dd42df1)), closes [#73](https://github.com/vuejs/component-compiler-utils/issues/73)
+
+
+
+## [3.0.1](https://github.com/vuejs/component-compiler-utils/compare/v3.0.0...v3.0.1) (2019-11-04)
+
+
+### Bug Fixes
+
+* should not crash when prettier failed ([89e7900](https://github.com/vuejs/component-compiler-utils/commit/89e7900))
+* unpin prettier version ([59a01bb](https://github.com/vuejs/component-compiler-utils/commit/59a01bb))
+
+
+# [3.0.0](https://github.com/vuejs/component-compiler-utils/compare/v2.6.0...v3.0.0) (2019-04-11)
+
+
+### Features
+
+* Replace node-sass to sass ([#56](https://github.com/vuejs/component-compiler-utils/issues/56)) ([3e4e3fc](https://github.com/vuejs/component-compiler-utils/commit/3e4e3fc)), closes [#50](https://github.com/vuejs/component-compiler-utils/issues/50)
+
+
+### BREAKING CHANGES
+
+* Using `sass` instead of `node-sass` package.
+
+
+
+# [2.6.0](https://github.com/vuejs/component-compiler-utils/compare/v2.5.2...v2.6.0) (2019-02-21)
+
+
+### Features
+
+* implement ::v-deep as a shadow piercing combinator ([#54](https://github.com/vuejs/component-compiler-utils/issues/54)) ([8b2c646](https://github.com/vuejs/component-compiler-utils/commit/8b2c646))
+
+
+
+# [2.6.0](https://github.com/vuejs/component-compiler-utils/compare/v2.5.2...v2.6.0) (2019-02-21)
+
+
+### Features
+
+* implement ::v-deep as a shadow piercing combinator ([#54](https://github.com/vuejs/component-compiler-utils/issues/54)) ([8b2c646](https://github.com/vuejs/component-compiler-utils/commit/8b2c646))
+
+
+
+## [2.5.2](https://github.com/vuejs/component-compiler-utils/compare/v2.5.0...v2.5.2) (2019-01-31)
+
+
+### Bug Fixes
+
+* fix sourceMap path separator on Windows, default sourceRoot to "" ([#51](https://github.com/vuejs/component-compiler-utils/issues/51)) ([df32cd9](https://github.com/vuejs/component-compiler-utils/commit/df32cd9)), closes [#47](https://github.com/vuejs/component-compiler-utils/issues/47)
+* generate correct source-map when content is not padded ([#52](https://github.com/vuejs/component-compiler-utils/issues/52)) ([81be0ca](https://github.com/vuejs/component-compiler-utils/commit/81be0ca))
+
+
+
+## [2.5.1](https://github.com/vuejs/component-compiler-utils/compare/v2.5.0...v2.5.1) (2019-01-25)
+
+
+### Bug Fixes
+
+* fix sourceMap path separator on Windows, default sourceRoot to "" ([#51](https://github.com/vuejs/component-compiler-utils/issues/51)) ([df32cd9](https://github.com/vuejs/component-compiler-utils/commit/df32cd9)), closes [#47](https://github.com/vuejs/component-compiler-utils/issues/47)
+
+
+
+# [2.5.0](https://github.com/vuejs/component-compiler-utils/compare/v2.4.0...v2.5.0) (2019-01-08)
+
+
+### Features
+
+* add 'use' tag of SVG to 'transformAssetUrls' option as default ([#45](https://github.com/vuejs/component-compiler-utils/issues/45)) ([f4e3336](https://github.com/vuejs/component-compiler-utils/commit/f4e3336))
+
+
+
+# [2.4.0](https://github.com/vuejs/component-compiler-utils/compare/v2.0.0...v2.4.0) (2019-01-02)
+
+
+### Bug Fixes
+
+* do not insert newline if style is already minified ([2603ee2](https://github.com/vuejs/component-compiler-utils/commit/2603ee2))
+* Forward preprocessor options to less ([#25](https://github.com/vuejs/component-compiler-utils/issues/25)) ([3b19c1e](https://github.com/vuejs/component-compiler-utils/commit/3b19c1e)), closes [#24](https://github.com/vuejs/component-compiler-utils/issues/24)
+* Move trim and scoped postcss plugins at the start of plugin list ([#36](https://github.com/vuejs/component-compiler-utils/issues/36)) ([0d52d86](https://github.com/vuejs/component-compiler-utils/commit/0d52d86))
+* pin prettier version ([5f138a6](https://github.com/vuejs/component-compiler-utils/commit/5f138a6))
+* remove space after selector when inserting scoped attribute ([5b299ed](https://github.com/vuejs/component-compiler-utils/commit/5b299ed)), closes [vue-loader/#1370](https://github.com/vuejs/component-compiler-utils/issues/1370)
+* should work with variable named render (close [#23](https://github.com/vuejs/component-compiler-utils/issues/23)) ([273827b](https://github.com/vuejs/component-compiler-utils/commit/273827b))
+* support standalone pseudo element selectors ([#33](https://github.com/vuejs/component-compiler-utils/issues/33)) ([d6cfbbf](https://github.com/vuejs/component-compiler-utils/commit/d6cfbbf))
+* Typings for SFCDescriptor and SFCCustomBlock ([#29](https://github.com/vuejs/component-compiler-utils/issues/29)) ([bb09115](https://github.com/vuejs/component-compiler-utils/commit/bb09115))
+
+
+### Features
+
+* **scoped-css:** support leading >>> or /deep/ in selectors ([1a3b5bb](https://github.com/vuejs/component-compiler-utils/commit/1a3b5bb))
+* add `prettify ` option ([#42](https://github.com/vuejs/component-compiler-utils/issues/42)) ([db3655b](https://github.com/vuejs/component-compiler-utils/commit/db3655b))
+* Support `stylus` as `<style>` lang ([#18](https://github.com/vuejs/component-compiler-utils/issues/18)) ([986084e](https://github.com/vuejs/component-compiler-utils/commit/986084e))
+
+
+
+<a name="2.3.1"></a>
+## [2.3.1](https://github.com/vuejs/component-compiler-utils/compare/v2.3.0...v2.3.1) (2018-12-11)
+
+
+### Bug Fixes
+
+* do not insert newline if style is already minified ([2603ee2](https://github.com/vuejs/component-compiler-utils/commit/2603ee2))
+* Move trim and scoped postcss plugins at the start of plugin list ([#36](https://github.com/vuejs/component-compiler-utils/issues/36)) ([0d52d86](https://github.com/vuejs/component-compiler-utils/commit/0d52d86))
+
+
+
+<a name="2.3.0"></a>
+# [2.3.0](https://github.com/vuejs/component-compiler-utils/compare/v2.2.0...v2.3.0) (2018-10-22)
+
+
+### Bug Fixes
+
+* support standalone pseudo element selectors ([#33](https://github.com/vuejs/component-compiler-utils/issues/33)) ([d6cfbbf](https://github.com/vuejs/component-compiler-utils/commit/d6cfbbf))
+* Typings for SFCDescriptor and SFCCustomBlock ([#29](https://github.com/vuejs/component-compiler-utils/issues/29)) ([bb09115](https://github.com/vuejs/component-compiler-utils/commit/bb09115))
+
+
+
+<a name="2.2.0"></a>
+# [2.2.0](https://github.com/vuejs/component-compiler-utils/compare/v2.1.2...v2.2.0) (2018-08-16)
+
+
+### Features
+
+* **scoped-css:** support leading >>> or /deep/ in selectors ([1a3b5bb](https://github.com/vuejs/component-compiler-utils/commit/1a3b5bb))
+
+
+
+<a name="2.1.2"></a>
+## [2.1.2](https://github.com/vuejs/component-compiler-utils/compare/v2.1.1...v2.1.2) (2018-08-09)
+
+
+### Bug Fixes
+
+* pin prettier version ([5f138a6](https://github.com/vuejs/component-compiler-utils/commit/5f138a6))
+
+
+
+<a name="2.1.1"></a>
+## [2.1.1](https://github.com/vuejs/component-compiler-utils/compare/v2.1.0...v2.1.1) (2018-08-07)
+
+
+### Bug Fixes
+
+* remove space after selector when inserting scoped attribute ([5b299ed](https://github.com/vuejs/component-compiler-utils/commit/5b299ed)), closes [vue-loader/#1370](https://github.com/vuejs/component-compiler-utils/issues/1370)
+
+
+
+<a name="2.1.0"></a>
+# [2.1.0](https://github.com/vuejs/component-compiler-utils/compare/v2.0.0...v2.1.0) (2018-07-03)
+
+
+### Bug Fixes
+
+* Forward preprocessor options to less ([#25](https://github.com/vuejs/component-compiler-utils/issues/25)) ([3b19c1e](https://github.com/vuejs/component-compiler-utils/commit/3b19c1e)), closes [#24](https://github.com/vuejs/component-compiler-utils/issues/24)
+* should work with variable named render (close [#23](https://github.com/vuejs/component-compiler-utils/issues/23)) ([273827b](https://github.com/vuejs/component-compiler-utils/commit/273827b))
+
+
+### Features
+
+* Support `stylus` as `<style>` lang ([#18](https://github.com/vuejs/component-compiler-utils/issues/18)) ([986084e](https://github.com/vuejs/component-compiler-utils/commit/986084e))
+
+
+
+<a name="2.0.0"></a>
+# [2.0.0](https://github.com/vuejs/component-compiler-utils/compare/v1.3.1...v2.0.0) (2018-06-03)
+
+
+### Features
+
+* Add async style compilation support ([#13](https://github.com/vuejs/component-compiler-utils/issues/13)) ([54464d6](https://github.com/vuejs/component-compiler-utils/commit/54464d6))
+* allow/require compiler to be passed in for `parse` ([caa1538](https://github.com/vuejs/component-compiler-utils/commit/caa1538))
+
+
+### BREAKING CHANGES
+
+* vue template compiler must now be passed to `parse`
+via options.
+
+
+
+<a name="1.3.1"></a>
+## [1.3.1](https://github.com/vuejs/component-compiler-utils/compare/v1.3.0...v1.3.1) (2018-05-28)
+
+
+### Bug Fixes
+
+* default parser was removed from prettier ([#15](https://github.com/vuejs/component-compiler-utils/issues/15)) ([598224d](https://github.com/vuejs/component-compiler-utils/commit/598224d))
+
+
+
+<a name="1.3.0"></a>
+# [1.3.0](https://github.com/vuejs/component-compiler-utils/compare/v1.2.1...v1.3.0) (2018-05-22)
+
+
+### Features
+
+* include href for <image> in transformAssetUrls (close [#12](https://github.com/vuejs/component-compiler-utils/issues/12)) ([86fddc2](https://github.com/vuejs/component-compiler-utils/commit/86fddc2))
+* Provide installation instructions on missing language preprocessors ([#10](https://github.com/vuejs/component-compiler-utils/issues/10)) ([97e772c](https://github.com/vuejs/component-compiler-utils/commit/97e772c))
+
+
+
+<a name="1.2.1"></a>
+## [1.2.1](https://github.com/vuejs/component-compiler-utils/compare/v1.2.0...v1.2.1) (2018-04-26)
+
+
+### Bug Fixes
+
+* postcss import ([c845a80](https://github.com/vuejs/component-compiler-utils/commit/c845a80))
+
+
+
+<a name="1.2.0"></a>
+# [1.2.0](https://github.com/vuejs/component-compiler-utils/compare/v1.1.0...v1.2.0) (2018-04-26)
+
+
+### Bug Fixes
+
+* compile only lib directory ([#6](https://github.com/vuejs/component-compiler-utils/issues/6)) ([4f787b3](https://github.com/vuejs/component-compiler-utils/commit/4f787b3))
+
+
+### Features
+
+* accept postcss options and plugins ([#7](https://github.com/vuejs/component-compiler-utils/issues/7)) ([1456e3d](https://github.com/vuejs/component-compiler-utils/commit/1456e3d))
+
+
+
+<a name="1.1.0"></a>
+# [1.1.0](https://github.com/vuejs/component-compiler-utils/compare/9204f16...v1.1.0) (2018-04-24)
+
+
+### Bug Fixes
+
+* use more strict regex for matching css animation rules ([4644727](https://github.com/vuejs/component-compiler-utils/commit/4644727))
+
+
+### Features
+
+* adds stylus & less preprocessor ([#5](https://github.com/vuejs/component-compiler-utils/issues/5)) ([f2fd8b9](https://github.com/vuejs/component-compiler-utils/commit/f2fd8b9))
+* preprocess scss/sass styles with node-sass ([#4](https://github.com/vuejs/component-compiler-utils/issues/4)) ([9204f16](https://github.com/vuejs/component-compiler-utils/commit/9204f16))
+
+
+

packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/MODIFY.md

+dist/compileTemplate
+dist/parse
+dist/parseCustomBlocks
\ No newline at end of file

packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/README.md

+# @vue/component-compiler-utils [![Build Status](https://circleci.com/gh/vuejs/component-compiler-utils/tree/master.svg?style=shield)](https://circleci.com/gh/vuejs/component-compiler-utils/)
+
+> Lower level utilities for compiling Vue single file components
+
+This package contains lower level utilities that you can use if you are writing a plugin / transform for a bundler or module system that compiles Vue single file components into JavaScript. It is used in [vue-loader](https://github.com/vuejs/vue-loader) version 15 and above.
+
+The API surface is intentionally minimal - the goal is to reuse as much as possible while being as flexible as possible.
+
+## Why isn't `vue-template-compiler` a peerDependency?
+
+Since this package is more often used as a low-level utility, it is usually a transitive dependency in an actual Vue project. It is therefore the responsibility of the higher-level package (e.g. `vue-loader`) to inject `vue-template-compiler` via options when calling the `parse` and `compileTemplate` methods.
+
+Not listing it as a peer depedency also allows tooling authors to use a non-default template compiler instead of `vue-template-compiler` without having to include it just to fullfil the peer dep requirement.
+
+## API
+
+### parse(ParseOptions): SFCDescriptor
+
+Parse raw single file component source into a descriptor with source maps. The actual compiler (`vue-template-compiler`) must be passed in via the `compiler` option so that the specific version used can be determined by the end user.
+
+``` ts
+interface ParseOptions {
+  source: string
+  filename?: string
+  compiler: VueTemplateCompiler
+  // https://github.com/vuejs/vue/tree/dev/packages/vue-template-compiler#compilerparsecomponentfile-options
+  // default: { pad: 'line' }
+  compilerParseOptions?: VueTemplateCompilerParseOptions
+  sourceRoot?: string
+  needMap?: boolean
+}
+
+interface SFCDescriptor {
+  template: SFCBlock | null
+  script: SFCBlock | null
+  styles: SFCBlock[]
+  customBlocks: SFCCustomBlock[]
+}
+
+interface SFCCustomBlock {
+  type: string
+  content: string
+  attrs: { [key: string]: string | true }
+  start: number
+  end: number
+  map?: RawSourceMap
+}
+
+interface SFCBlock extends SFCCustomBlock {
+  lang?: string
+  src?: string
+  scoped?: boolean
+  module?: string | boolean
+}
+```
+
+### compileTemplate(TemplateCompileOptions): TemplateCompileResults
+
+Takes raw template source and compile it into JavaScript code. The actual compiler (`vue-template-compiler`) must be passed in via the `compiler` option so that the specific version used can be determined by the end user.
+
+It can also optionally perform pre-processing for any templating engine supported by [consolidate](https://github.com/tj/consolidate.js/).
+
+``` ts
+interface TemplateCompileOptions {
+  source: string
+  filename: string
+
+  compiler: VueTemplateCompiler
+  // https://github.com/vuejs/vue/tree/dev/packages/vue-template-compiler#compilercompiletemplate-options
+  // default: {}
+  compilerOptions?: VueTemplateCompilerOptions
+
+  // Template preprocessor
+  preprocessLang?: string
+  preprocessOptions?: any
+
+  // Transform asset urls found in the template into `require()` calls
+  // This is off by default. If set to true, the default value is
+  // {
+  //   audio: 'src',
+  //   video: ['src', 'poster'],
+  //   source: 'src',
+  //   img: 'src',
+  //   image: ['xlink:href', 'href'],
+  //   use: ['xlink:href', 'href']
+  // }
+  transformAssetUrls?: AssetURLOptions | boolean
+
+  // For vue-template-es2015-compiler, which is a fork of Buble
+  transpileOptions?: any
+
+  isProduction?: boolean  // default: false
+  isFunctional?: boolean  // default: false
+  optimizeSSR?: boolean   // default: false
+
+  // Whether prettify compiled render function or not (development only)
+  // default: true
+  prettify?: boolean
+}
+
+interface TemplateCompileResult {
+  ast: Object | undefined
+  code: string
+  source: string
+  tips: string[]
+  errors: string[]
+}
+
+interface AssetURLOptions {
+  [name: string]: string | string[]
+}
+```
+
+#### Handling the Output
+
+The resulting JavaScript code will look like this:
+
+``` js
+var render = function (h) { /* ... */}
+var staticRenderFns = [function (h) { /* ... */}, function (h) { /* ... */}]
+```
+
+It **does NOT** assume any module system. It is your responsibility to handle the exports, if needed.
+
+### compileStyle(StyleCompileOptions)
+
+Take input raw CSS and applies scoped CSS transform. It does NOT handle pre-processors. If the component doesn't use scoped CSS then this step can be skipped.
+
+``` ts
+interface StyleCompileOptions {
+  source: string
+  filename: string
+  id: string
+  map?: any
+  scoped?: boolean
+  trim?: boolean
+  preprocessLang?: string
+  preprocessOptions?: any
+  postcssOptions?: any
+  postcssPlugins?: any[]
+}
+
+interface StyleCompileResults {
+  code: string
+  map: any | void
+  rawResult: LazyResult | void // raw lazy result from PostCSS
+  errors: string[]
+}
+```
+
+### compileStyleAsync(StyleCompileOptions)
+
+Same as `compileStyle(StyleCompileOptions)` but it returns a Promise resolving to `StyleCompileResults`. It can be used with async postcss plugins.

packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/compileTemplate.js

+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assetUrl_1 = __importDefault(require("./templateCompilerModules/assetUrl"));
+const srcset_1 = __importDefault(require("./templateCompilerModules/srcset"));
+const consolidate = require('consolidate');
+const transpile = require('vue-template-es2015-compiler');
+function compileTemplate(options) {
+    const { preprocessLang } = options;
+    const preprocessor = preprocessLang && consolidate[preprocessLang];
+    if (preprocessor) {
+        return actuallyCompile(Object.assign({}, options, {
+            source: preprocess(options, preprocessor)
+        }));
+    }
+    else if (preprocessLang) {
+        return { // fixed by xxxxxx recyclableRender,components
+            code: `var render = function () {}\n` + `var staticRenderFns = []\n` + `var recyclableRender\n` + `var components\n`,
+            source: options.source,
+            tips: [
+                `Component ${options.filename} uses lang ${preprocessLang} for template. Please install the language preprocessor.`
+            ],
+            errors: [
+                `Component ${options.filename} uses lang ${preprocessLang} for template, however it is not installed.`
+            ]
+        };
+    }
+    else {
+        return actuallyCompile(options);
+    }
+}
+exports.compileTemplate = compileTemplate;
+function preprocess(options, preprocessor) {
+    const { source, filename, preprocessOptions } = options;
+    const finalPreprocessOptions = Object.assign({
+        filename
+    }, preprocessOptions);
+    // Consolidate exposes a callback based API, but the callback is in fact
+    // called synchronously for most templating engines. In our case, we have to
+    // expose a synchronous API so that it is usable in Jest transforms (which
+    // have to be sync because they are applied via Node.js require hooks)
+    let res, err;
+    preprocessor.render(source, finalPreprocessOptions, (_err, _res) => {
+        if (_err)
+            err = _err;
+        res = _res;
+    });
+    if (err)
+        throw err;
+    return res;
+}
+function actuallyCompile(options) {
+    const { source, compiler, compilerOptions = {}, transpileOptions = {}, transformAssetUrls, isProduction = process.env.NODE_ENV === 'production', isFunctional = false, optimizeSSR = false, prettify = true } = options;
+    const compile = optimizeSSR && compiler.ssrCompile ? compiler.ssrCompile : compiler.compile;
+    let finalCompilerOptions = compilerOptions;
+    if (transformAssetUrls) {
+        const builtInModules = [
+            transformAssetUrls === true
+                ? assetUrl_1.default()
+                : assetUrl_1.default(transformAssetUrls),
+            srcset_1.default()
+        ];
+        finalCompilerOptions = Object.assign({}, compilerOptions, {
+            modules: [...builtInModules, ...(compilerOptions.modules || [])]
+        });
+    }
+    // fixed by xxxxxx
+    const { render, staticRenderFns, tips, errors, '@render': recyclableRender, components } = compile(source, finalCompilerOptions);
+    if (errors && errors.length) {
+        return { // fixed by xxxxxx recyclableRender,components
+            code: `var render = function () {}\n` + `var staticRenderFns = []\n` + `var recyclableRender\n` + `var components\n`,
+            source,
+            tips,
+            errors
+        };
+    }
+    else {
+        const finalTranspileOptions = Object.assign({}, transpileOptions, {
+            transforms: Object.assign({}, transpileOptions.transforms, {
+                stripWithFunctional: isFunctional
+            })
+        });
+        const toFunction = (code) => {
+            return `function (${isFunctional ? `_h,_vm` : ``}) {${code}}`;
+        };
+         // fixed by xxxxxx
+        // transpile code with vue-template-es2015-compiler, which is a forked
+        // version of Buble that applies ES2015 transforms + stripping `with` usage
+        let code = transpile(`var __render__ = ${toFunction(render)}\n` +
+            `var __recyclableRender__ = ${recyclableRender ? toFunction(recyclableRender) : 'false'}\n` +
+            `var __staticRenderFns__ = [${staticRenderFns.map(toFunction)}]`, finalTranspileOptions) + `\n`;
+        // #23 we use __render__ to avoid `render` not being prefixed by the
+        // transpiler when stripping with, but revert it back to `render` to
+        // maintain backwards compat
+        code = code.replace(/\s__(render|recyclableRender|staticRenderFns)__\s/g, ' $1 ');
+        code = (components || '') + '\n' + code // fixed by xxxxxx
+        if (!isProduction) {
+            // mark with stripped (this enables Vue to use correct runtime proxy
+            // detection)
+            code += `render._withStripped = true`;
+            if (prettify) {
+                code = require('prettier').format(code, {
+                    semi: false,
+                    parser: 'babel'
+                });
+            }
+        }
+        return {
+            code,
+            source,
+            tips,
+            errors
+        };
+    }
+}

packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/dist/parse.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const source_map_1 = require("source-map");
+const hash = require('hash-sum');
+const cache = require('lru-cache')(100);
+const splitRE = /\r?\n/g;
+const emptyRE = /^(?:\/\/)?\s*$/;
+function parse(options) {
+    const { source, filename = '', compiler, compilerParseOptions = { pad: 'line' }, sourceRoot = '', needMap = true } = options;
+    const cacheKey = hash(filename + source);
+    let output = cache.get(cacheKey);
+    if (output)
+        return output;
+    // fixed by xxxxxx    
+    output = require('./parseCustomBlocks')(compiler.parseComponent(source, compilerParseOptions), options);
+    if (needMap) {
+        if (output.script && !output.script.src) {
+            output.script.map = generateSourceMap(filename, source, output.script.content, sourceRoot, compilerParseOptions.pad);
+        }
+        if (output.styles) {
+            output.styles.forEach(style => {
+                if (!style.src) {
+                    style.map = generateSourceMap(filename, source, style.content, sourceRoot, compilerParseOptions.pad);
+                }
+            });
+        }
+    }
+    cache.set(cacheKey, output);
+    return output;
+}
+exports.parse = parse;
+function generateSourceMap(filename, source, generated, sourceRoot, pad) {
+    const map = new source_map_1.SourceMapGenerator({
+        file: filename.replace(/\\/g, '/'),
+        sourceRoot: sourceRoot.replace(/\\/g, '/')
+    });
+    let offset = 0;
+    if (!pad) {
+        offset =
+            source
+                .split(generated)
+                .shift()
+                .split(splitRE).length - 1;
+    }
+    map.setSourceContent(filename, source);
+    generated.split(splitRE).forEach((line, index) => {
+        if (!emptyRE.test(line)) {
+            map.addMapping({
+                source: filename,
+                original: {
+                    line: index + 1 + offset,
+                    column: 0
+                },
+                generated: {
+                    line: index + 1,
+                    column: 0
+                }
+            });
+        }
+    });
+    return JSON.parse(map.toString());
+}

packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/lib/compileStyle.ts

+const postcss = require('postcss')
+import { ProcessOptions, LazyResult } from 'postcss'
+import trimPlugin from './stylePlugins/trim'
+import scopedPlugin from './stylePlugins/scoped'
+import {
+  processors,
+  StylePreprocessor,
+  StylePreprocessorResults
+} from './styleProcessors'
+
+export interface StyleCompileOptions {
+  source: string
+  filename: string
+  id: string
+  map?: any
+  scoped?: boolean
+  trim?: boolean
+  preprocessLang?: string
+  preprocessOptions?: any
+  postcssOptions?: any
+  postcssPlugins?: any[]
+}
+
+export interface AsyncStyleCompileOptions extends StyleCompileOptions {
+  isAsync?: boolean
+}
+
+export interface StyleCompileResults {
+  code: string
+  map: any | void
+  rawResult: LazyResult | void
+  errors: string[]
+}
+
+export function compileStyle(
+  options: StyleCompileOptions
+): StyleCompileResults {
+  return doCompileStyle({ ...options, isAsync: false })
+}
+
+export function compileStyleAsync(
+  options: StyleCompileOptions
+): Promise<StyleCompileResults> {
+  return Promise.resolve(doCompileStyle({ ...options, isAsync: true }))
+}
+
+export function doCompileStyle(
+  options: AsyncStyleCompileOptions
+): StyleCompileResults {
+  const {
+    filename,
+    id,
+    scoped = true,
+    trim = true,
+    preprocessLang,
+    postcssOptions,
+    postcssPlugins
+  } = options
+  const preprocessor = preprocessLang && processors[preprocessLang]
+  const preProcessedSource = preprocessor && preprocess(options, preprocessor)
+  const map = preProcessedSource ? preProcessedSource.map : options.map
+  const source = preProcessedSource ? preProcessedSource.code : options.source
+
+  const plugins = (postcssPlugins || []).slice()
+  if (trim) {
+    plugins.push(trimPlugin())
+  }
+  if (scoped) {
+    plugins.push(scopedPlugin(id))
+  }
+
+  const postCSSOptions: ProcessOptions = {
+    ...postcssOptions,
+    to: filename,
+    from: filename
+  }
+  if (map) {
+    postCSSOptions.map = {
+      inline: false,
+      annotation: false,
+      prev: map
+    }
+  }
+
+  let result, code, outMap
+  const errors: any[] = []
+  if (preProcessedSource && preProcessedSource.errors.length) {
+    errors.push(...preProcessedSource.errors)
+  }
+  try {
+    result = postcss(plugins).process(source, postCSSOptions)
+
+    // In async mode, return a promise.
+    if (options.isAsync) {
+      return result
+        .then(
+          (result: LazyResult): StyleCompileResults => ({
+            code: result.css || '',
+            map: result.map && result.map.toJSON(),
+            errors,
+            rawResult: result
+          })
+        )
+        .catch(
+          (error: Error): StyleCompileResults => ({
+            code: '',
+            map: undefined,
+            errors: [...errors, error.message],
+            rawResult: undefined
+          })
+        )
+    }
+
+    // force synchronous transform (we know we only have sync plugins)
+    code = result.css
+    outMap = result.map
+  } catch (e) {
+    errors.push(e)
+  }
+
+  return {
+    code: code || ``,
+    map: outMap && outMap.toJSON(),
+    errors,
+    rawResult: result
+  }
+}
+
+function preprocess(
+  options: StyleCompileOptions,
+  preprocessor: StylePreprocessor
+): StylePreprocessorResults {
+  return preprocessor.render(
+    options.source,
+    options.map,
+    Object.assign(
+      {
+        filename: options.filename
+      },
+      options.preprocessOptions
+    )
+  )
+}

packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/lib/compileTemplate.ts

+import {
+  VueTemplateCompiler,
+  VueTemplateCompilerOptions,
+  ErrorWithRange
+} from './types'
+
+import assetUrlsModule, {
+  AssetURLOptions
+} from './templateCompilerModules/assetUrl'
+import srcsetModule from './templateCompilerModules/srcset'
+
+const consolidate = require('consolidate')
+const transpile = require('vue-template-es2015-compiler')
+
+export interface TemplateCompileOptions {
+  source: string
+  filename: string
+  compiler: VueTemplateCompiler
+  compilerOptions?: VueTemplateCompilerOptions
+  transformAssetUrls?: AssetURLOptions | boolean
+  preprocessLang?: string
+  preprocessOptions?: any
+  transpileOptions?: any
+  isProduction?: boolean
+  isFunctional?: boolean
+  optimizeSSR?: boolean
+  prettify?: boolean
+}
+
+export interface TemplateCompileResult {
+  ast: Object | undefined
+  code: string
+  source: string
+  tips: (string | ErrorWithRange)[]
+  errors: (string | ErrorWithRange)[]
+}
+
+export function compileTemplate(
+  options: TemplateCompileOptions
+): TemplateCompileResult {
+  const { preprocessLang } = options
+  const preprocessor = preprocessLang && consolidate[preprocessLang]
+  if (preprocessor) {
+    return actuallyCompile(
+      Object.assign({}, options, {
+        source: preprocess(options, preprocessor)
+      })
+    )
+  } else if (preprocessLang) {
+    return {
+      ast: {},
+      code: `var render = function () {}\n` + `var staticRenderFns = []\n`,
+      source: options.source,
+      tips: [
+        `Component ${options.filename} uses lang ${preprocessLang} for template. Please install the language preprocessor.`
+      ],
+      errors: [
+        `Component ${options.filename} uses lang ${preprocessLang} for template, however it is not installed.`
+      ]
+    }
+  } else {
+    return actuallyCompile(options)
+  }
+}
+
+function preprocess(
+  options: TemplateCompileOptions,
+  preprocessor: any
+): string {
+  const { source, filename, preprocessOptions } = options
+
+  const finalPreprocessOptions = Object.assign(
+    {
+      filename
+    },
+    preprocessOptions
+  )
+
+  // Consolidate exposes a callback based API, but the callback is in fact
+  // called synchronously for most templating engines. In our case, we have to
+  // expose a synchronous API so that it is usable in Jest transforms (which
+  // have to be sync because they are applied via Node.js require hooks)
+  let res: any, err
+  preprocessor.render(
+    source,
+    finalPreprocessOptions,
+    (_err: Error | null, _res: string) => {
+      if (_err) err = _err
+      res = _res
+    }
+  )
+
+  if (err) throw err
+  return res
+}
+
+function actuallyCompile(
+  options: TemplateCompileOptions
+): TemplateCompileResult {
+  const {
+    source,
+    compiler,
+    compilerOptions = {},
+    transpileOptions = {},
+    transformAssetUrls,
+    isProduction = process.env.NODE_ENV === 'production',
+    isFunctional = false,
+    optimizeSSR = false,
+    prettify = true
+  } = options
+
+  const compile =
+    optimizeSSR && compiler.ssrCompile ? compiler.ssrCompile : compiler.compile
+
+  let finalCompilerOptions = compilerOptions
+  if (transformAssetUrls) {
+    const builtInModules = [
+      transformAssetUrls === true
+        ? assetUrlsModule()
+        : assetUrlsModule(transformAssetUrls),
+      srcsetModule()
+    ]
+    finalCompilerOptions = Object.assign({}, compilerOptions, {
+      modules: [...builtInModules, ...(compilerOptions.modules || [])],
+      filename: options.filename
+    })
+  }
+
+  const { ast, render, staticRenderFns, tips, errors } = compile(
+    source,
+    finalCompilerOptions
+  )
+
+  if (errors && errors.length) {
+    return {
+      ast,
+      code: `var render = function () {}\n` + `var staticRenderFns = []\n`,
+      source,
+      tips,
+      errors
+    }
+  } else {
+    const finalTranspileOptions = Object.assign({}, transpileOptions, {
+      transforms: Object.assign({}, transpileOptions.transforms, {
+        stripWithFunctional: isFunctional
+      })
+    })
+
+    const toFunction = (code: string): string => {
+      return `function (${isFunctional ? `_h,_vm` : ``}) {${code}}`
+    }
+
+    // transpile code with vue-template-es2015-compiler, which is a forked
+    // version of Buble that applies ES2015 transforms + stripping `with` usage
+    let code =
+      transpile(
+        `var __render__ = ${toFunction(render)}\n` +
+          `var __staticRenderFns__ = [${staticRenderFns.map(toFunction)}]`,
+        finalTranspileOptions
+      ) + `\n`
+
+    // #23 we use __render__ to avoid `render` not being prefixed by the
+    // transpiler when stripping with, but revert it back to `render` to
+    // maintain backwards compat
+    code = code.replace(/\s__(render|staticRenderFns)__\s/g, ' $1 ')
+
+    if (!isProduction) {
+      // mark with stripped (this enables Vue to use correct runtime proxy
+      // detection)
+      code += `render._withStripped = true`
+
+      if (prettify) {
+        try {
+          code = require('prettier').format(code, {
+            semi: false,
+            parser: 'babel'
+          })
+        } catch (e) {
+          tips.push(
+            `Failed to prettify component ${options.filename} template source after compilation.`
+          )
+        }
+      }
+    }
+
+    return {
+      ast,
+      code,
+      source,
+      tips,
+      errors
+    }
+  }
+}

packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/lib/index.ts

+import { parse, SFCBlock, SFCCustomBlock, SFCDescriptor } from './parse'
+
+import {
+  compileTemplate,
+  TemplateCompileOptions,
+  TemplateCompileResult
+} from './compileTemplate'
+
+import {
+  compileStyle,
+  compileStyleAsync,
+  StyleCompileOptions,
+  StyleCompileResults
+} from './compileStyle'
+
+// API
+export { parse, compileTemplate, compileStyle, compileStyleAsync }
+
+// types
+export {
+  SFCBlock,
+  SFCCustomBlock,
+  SFCDescriptor,
+  TemplateCompileOptions,
+  TemplateCompileResult,
+  StyleCompileOptions,
+  StyleCompileResults
+}

packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/lib/parse.ts

+import { SourceMapGenerator } from 'source-map'
+import {
+  RawSourceMap,
+  VueTemplateCompiler,
+  VueTemplateCompilerParseOptions
+} from './types'
+
+const hash = require('hash-sum')
+const cache = require('lru-cache')(100)
+
+const splitRE = /\r?\n/g
+const emptyRE = /^(?:\/\/)?\s*$/
+
+export interface ParseOptions {
+  source: string
+  filename?: string
+  compiler: VueTemplateCompiler
+  compilerParseOptions?: VueTemplateCompilerParseOptions
+  sourceRoot?: string
+  needMap?: boolean
+}
+
+export interface SFCCustomBlock {
+  type: string
+  content: string
+  attrs: { [key: string]: string | true }
+  start: number
+  end: number
+  map?: RawSourceMap
+}
+
+export interface SFCBlock extends SFCCustomBlock {
+  lang?: string
+  src?: string
+  scoped?: boolean
+  module?: string | boolean
+}
+
+export interface SFCDescriptor {
+  template: SFCBlock | null
+  script: SFCBlock | null
+  styles: SFCBlock[]
+  customBlocks: SFCCustomBlock[]
+}
+
+export function parse(options: ParseOptions): SFCDescriptor {
+  const {
+    source,
+    filename = '',
+    compiler,
+    compilerParseOptions = { pad: 'line' } as VueTemplateCompilerParseOptions,
+    sourceRoot = '',
+    needMap = true
+  } = options
+  const cacheKey = hash(filename + source)
+  let output: SFCDescriptor = cache.get(cacheKey)
+  if (output) return output
+  output = compiler.parseComponent(source, compilerParseOptions)
+  if (needMap) {
+    if (output.script && !output.script.src) {
+      output.script.map = generateSourceMap(
+        filename,
+        source,
+        output.script.content,
+        sourceRoot,
+        compilerParseOptions.pad
+      )
+    }
+    if (output.styles) {
+      output.styles.forEach(style => {
+        if (!style.src) {
+          style.map = generateSourceMap(
+            filename,
+            source,
+            style.content,
+            sourceRoot,
+            compilerParseOptions.pad
+          )
+        }
+      })
+    }
+  }
+  cache.set(cacheKey, output)
+  return output
+}
+
+function generateSourceMap(
+  filename: string,
+  source: string,
+  generated: string,
+  sourceRoot: string,
+  pad?: 'line' | 'space'
+): RawSourceMap {
+  const map = new SourceMapGenerator({
+    file: filename.replace(/\\/g, '/'),
+    sourceRoot: sourceRoot.replace(/\\/g, '/')
+  })
+  let offset = 0
+  if (!pad) {
+    offset =
+      source
+        .split(generated)
+        .shift()!
+        .split(splitRE).length - 1
+  }
+  map.setSourceContent(filename, source)
+  generated.split(splitRE).forEach((line, index) => {
+    if (!emptyRE.test(line)) {
+      map.addMapping({
+        source: filename,
+        original: {
+          line: index + 1 + offset,
+          column: 0
+        },
+        generated: {
+          line: index + 1,
+          column: 0
+        }
+      })
+    }
+  })
+  return JSON.parse(map.toString())
+}

packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/lib/stylePlugins/scoped.ts

+import { Root } from 'postcss'
+import * as postcss from 'postcss'
+// postcss-selector-parser does have typings but it's problematic to work with.
+const selectorParser = require('postcss-selector-parser')
+
+export default postcss.plugin('add-id', (options: any) => (root: Root) => {
+  const id: string = options
+  const keyframes = Object.create(null)
+
+  root.each(function rewriteSelector(node: any) {
+    if (!node.selector) {
+      // handle media queries
+      if (node.type === 'atrule') {
+        if (node.name === 'media' || node.name === 'supports') {
+          node.each(rewriteSelector)
+        } else if (/-?keyframes$/.test(node.name)) {
+          // register keyframes
+          keyframes[node.params] = node.params = node.params + '-' + id
+        }
+      }
+      return
+    }
+    node.selector = selectorParser((selectors: any) => {
+      selectors.each((selector: any) => {
+        let node: any = null
+
+        // find the last child node to insert attribute selector
+        selector.each((n: any) => {
+          // ">>>" combinator
+          // and /deep/ alias for >>>, since >>> doesn't work in SASS
+          if (
+            n.type === 'combinator' &&
+            (n.value === '>>>' || n.value === '/deep/')
+          ) {
+            n.value = ' '
+            n.spaces.before = n.spaces.after = ''
+            return false
+          }
+
+          // in newer versions of sass, /deep/ support is also dropped, so add a ::v-deep alias
+          if (n.type === 'pseudo' && n.value === '::v-deep') {
+            n.value = n.spaces.before = n.spaces.after = ''
+            return false
+          }
+
+          if (n.type !== 'pseudo' && n.type !== 'combinator') {
+            node = n
+          }
+        })
+
+        if (node) {
+          node.spaces.after = ''
+        } else {
+          // For deep selectors & standalone pseudo selectors,
+          // the attribute selectors are prepended rather than appended.
+          // So all leading spaces must be eliminated to avoid problems.
+          selector.first.spaces.before = ''
+        }
+
+        selector.insertAfter(
+          node,
+          selectorParser.attribute({
+            attribute: id
+          })
+        )
+      })
+    }).processSync(node.selector)
+  })
+
+  // If keyframes are found in this <style>, find and rewrite animation names
+  // in declarations.
+  // Caveat: this only works for keyframes and animation rules in the same
+  // <style> element.
+  if (Object.keys(keyframes).length) {
+    root.walkDecls(decl => {
+      // individual animation-name declaration
+      if (/^(-\w+-)?animation-name$/.test(decl.prop)) {
+        decl.value = decl.value
+          .split(',')
+          .map(v => keyframes[v.trim()] || v.trim())
+          .join(',')
+      }
+      // shorthand
+      if (/^(-\w+-)?animation$/.test(decl.prop)) {
+        decl.value = decl.value
+          .split(',')
+          .map(v => {
+            const vals = v.trim().split(/\s+/)
+            const i = vals.findIndex(val => keyframes[val])
+            if (i !== -1) {
+              vals.splice(i, 1, keyframes[vals[i]])
+              return vals.join(' ')
+            } else {
+              return v
+            }
+          })
+          .join(',')
+      }
+    })
+  }
+})

packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/lib/stylePlugins/trim.ts

+import { Root } from 'postcss'
+import * as postcss from 'postcss'
+
+export default postcss.plugin('trim', () => (css: Root) => {
+  css.walk(({ type, raws }) => {
+    if (type === 'rule' || type === 'atrule') {
+      if (raws.before) raws.before = '\n'
+      if (raws.after) raws.after = '\n'
+    }
+  })
+})

packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/lib/styleProcessors/index.ts

+const merge = require('merge-source-map')
+
+export interface StylePreprocessor {
+  render(
+    source: string,
+    map: any | null,
+    options: any
+  ): StylePreprocessorResults
+}
+
+export interface StylePreprocessorResults {
+  code: string
+  map?: any
+  errors: Array<Error>
+}
+
+// .scss/.sass processor
+const scss: StylePreprocessor = {
+  render(
+    source: string,
+    map: any | null,
+    options: any
+  ): StylePreprocessorResults {
+    const nodeSass = require('sass')
+    const finalOptions = Object.assign({}, options, {
+      data: source,
+      file: options.filename,
+      outFile: options.filename,
+      sourceMap: !!map
+    })
+
+    try {
+      const result = nodeSass.renderSync(finalOptions)
+
+      if (map) {
+        return {
+          code: result.css.toString(),
+          map: merge(map, JSON.parse(result.map.toString())),
+          errors: []
+        }
+      }
+
+      return { code: result.css.toString(), errors: [] }
+    } catch (e) {
+      return { code: '', errors: [e] }
+    }
+  }
+}
+
+const sass = {
+  render(
+    source: string,
+    map: any | null,
+    options: any
+  ): StylePreprocessorResults {
+    return scss.render(
+      source,
+      map,
+      Object.assign({}, options, { indentedSyntax: true })
+    )
+  }
+}
+
+// .less
+const less = {
+  render(
+    source: string,
+    map: any | null,
+    options: any
+  ): StylePreprocessorResults {
+    const nodeLess = require('less')
+
+    let result: any
+    let error: Error | null = null
+    nodeLess.render(
+      source,
+      Object.assign({}, options, { syncImport: true }),
+      (err: Error | null, output: any) => {
+        error = err
+        result = output
+      }
+    )
+
+    if (error) return { code: '', errors: [error] }
+
+    if (map) {
+      return {
+        code: result.css.toString(),
+        map: merge(map, result.map),
+        errors: []
+      }
+    }
+
+    return { code: result.css.toString(), errors: [] }
+  }
+}
+
+// .styl
+const styl = {
+  render(
+    source: string,
+    map: any | null,
+    options: any
+  ): StylePreprocessorResults {
+    const nodeStylus = require('stylus')
+    try {
+      const ref = nodeStylus(source)
+      Object.keys(options).forEach(key => ref.set(key, options[key]))
+      if (map) ref.set('sourcemap', { inline: false, comment: false })
+
+      const result = ref.render()
+      if (map) {
+        return {
+          code: result,
+          map: merge(map, ref.sourcemap),
+          errors: []
+        }
+      }
+
+      return { code: result, errors: [] }
+    } catch (e) {
+      return { code: '', errors: [e] }
+    }
+  }
+}
+
+export const processors: { [key: string]: StylePreprocessor } = {
+  less,
+  sass,
+  scss,
+  styl,
+  stylus: styl
+}

packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/lib/templateCompilerModules/assetUrl.ts

+// vue compiler module for transforming `<tag>:<attribute>` to `require`
+
+import { urlToRequire, ASTNode, Attr } from './utils'
+
+export interface AssetURLOptions {
+  [name: string]: string | string[]
+}
+
+const defaultOptions: AssetURLOptions = {
+  audio: 'src',
+  video: ['src', 'poster'],
+  source: 'src',
+  img: 'src',
+  image: ['xlink:href', 'href'],
+  use: ['xlink:href', 'href']
+}
+
+export default (userOptions?: AssetURLOptions) => {
+  const options = userOptions
+    ? Object.assign({}, defaultOptions, userOptions)
+    : defaultOptions
+
+  return {
+    postTransformNode: (node: ASTNode) => {
+      transform(node, options)
+    }
+  }
+}
+
+function transform(node: ASTNode, options: AssetURLOptions) {
+  for (const tag in options) {
+    if ((tag === '*' || node.tag === tag) && node.attrs) {
+      const attributes = options[tag]
+      if (typeof attributes === 'string') {
+        node.attrs.some(attr => rewrite(attr, attributes))
+      } else if (Array.isArray(attributes)) {
+        attributes.forEach(item => node.attrs.some(attr => rewrite(attr, item)))
+      }
+    }
+  }
+}
+
+function rewrite(attr: Attr, name: string) {
+  if (attr.name === name) {
+    const value = attr.value
+    // only transform static URLs
+    if (value.charAt(0) === '"' && value.charAt(value.length - 1) === '"') {
+      attr.value = urlToRequire(value.slice(1, -1))
+      return true
+    }
+  }
+  return false
+}

packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/lib/templateCompilerModules/srcset.ts

+// vue compiler module for transforming `img:srcset` to a number of `require`s
+
+import { urlToRequire, ASTNode } from './utils'
+
+interface ImageCandidate {
+  require: string
+  descriptor: string
+}
+
+export default () => ({
+  postTransformNode: (node: ASTNode) => {
+    transform(node)
+  }
+})
+
+// http://w3c.github.io/html/semantics-embedded-content.html#ref-for-image-candidate-string-5
+const escapedSpaceCharacters = /( |\\t|\\n|\\f|\\r)+/g
+
+function transform(node: ASTNode) {
+  const tags = ['img', 'source']
+
+  if (tags.indexOf(node.tag) !== -1 && node.attrs) {
+    node.attrs.forEach(attr => {
+      if (attr.name === 'srcset') {
+        // same logic as in transform-require.js
+        const value = attr.value
+        const isStatic =
+          value.charAt(0) === '"' && value.charAt(value.length - 1) === '"'
+        if (!isStatic) {
+          return
+        }
+
+        const imageCandidates: ImageCandidate[] = value
+          .substr(1, value.length - 2)
+          .split(',')
+          .map(s => {
+            // The attribute value arrives here with all whitespace, except
+            // normal spaces, represented by escape sequences
+            const [url, descriptor] = s
+              .replace(escapedSpaceCharacters, ' ')
+              .trim()
+              .split(' ', 2)
+            return { require: urlToRequire(url), descriptor }
+          })
+
+        // "require(url1)"
+        // "require(url1) 1x"
+        // "require(url1), require(url2)"
+        // "require(url1), require(url2) 2x"
+        // "require(url1) 1x, require(url2)"
+        // "require(url1) 1x, require(url2) 2x"
+        const code = imageCandidates
+          .map(
+            ({ require, descriptor }) =>
+              `${require} + "${descriptor ? ' ' + descriptor : ''}, " + `
+          )
+          .join('')
+          .slice(0, -6)
+          .concat('"')
+          .replace(/ \+ ""$/, '')
+
+        attr.value = code
+      }
+    })
+  }
+}

packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/lib/templateCompilerModules/utils.ts

+export interface Attr {
+  name: string
+  value: string
+}
+
+export interface ASTNode {
+  tag: string
+  attrs: Attr[]
+}
+
+import { UrlWithStringQuery, parse as uriParse } from 'url'
+
+export function urlToRequire(url: string): string {
+  const returnValue = `"${url}"`
+  // same logic as in transform-require.js
+  const firstChar = url.charAt(0)
+  if (firstChar === '.' || firstChar === '~' || firstChar === '@') {
+    if (firstChar === '~') {
+      const secondChar = url.charAt(1)
+      url = url.slice(secondChar === '/' ? 2 : 1)
+    }
+
+    const uriParts = parseUriParts(url)
+
+    if (!uriParts.hash) {
+      return `require("${url}")`
+    } else {
+      // support uri fragment case by excluding it from
+      // the require and instead appending it as string;
+      // assuming that the path part is sufficient according to
+      // the above caseing(t.i. no protocol-auth-host parts expected)
+      return `require("${uriParts.path}") + "${uriParts.hash}"`
+    }
+  }
+  return returnValue
+}
+
+/**
+ * vuejs/component-compiler-utils#22 Support uri fragment in transformed require
+ * @param urlString an url as a string
+ */
+function parseUriParts(urlString: string): UrlWithStringQuery {
+  // initialize return value
+  const returnValue: UrlWithStringQuery = uriParse('')
+  if (urlString) {
+    // A TypeError is thrown if urlString is not a string
+    // @see https://nodejs.org/api/url.html#url_url_parse_urlstring_parsequerystring_slashesdenotehost
+    if ('string' === typeof urlString) {
+      // check is an uri
+      return uriParse(urlString) // take apart the uri
+    }
+  }
+  return returnValue
+}

packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/lib/types.ts

+import { SFCDescriptor } from './parse'
+
+export interface StartOfSourceMap {
+  file?: string
+  sourceRoot?: string
+}
+
+export interface RawSourceMap extends StartOfSourceMap {
+  version: string
+  sources: string[]
+  names: string[]
+  sourcesContent?: string[]
+  mappings: string
+}
+
+export interface VueTemplateCompiler {
+  parseComponent(source: string, options?: any): SFCDescriptor
+
+  compile(
+    template: string,
+    options: VueTemplateCompilerOptions
+  ): VueTemplateCompilerResults
+
+  ssrCompile(
+    template: string,
+    options: VueTemplateCompilerOptions
+  ): VueTemplateCompilerResults
+}
+
+// we'll just shim this much for now - in the future these types
+// should come from vue-template-compiler directly, or this package should be
+// part of the vue monorepo.
+export interface VueTemplateCompilerOptions {
+  modules?: Object[]
+  outputSourceRange?: boolean
+  whitespace?: 'preserve' | 'condense'
+  directives?: { [key: string]: Function }
+}
+
+export interface VueTemplateCompilerParseOptions {
+  pad?: 'line' | 'space'
+}
+
+export interface ErrorWithRange {
+  msg: string
+  start: number
+  end: number
+}
+
+export interface VueTemplateCompilerResults {
+  ast: Object | undefined
+  render: string
+  staticRenderFns: string[]
+  errors: (string | ErrorWithRange)[]
+  tips: (string | ErrorWithRange)[]
+}

packages/vue-cli-plugin-uni/packages/@vue/component-compiler-utils/package.json

+{
+  "name": "@vue/component-compiler-utils",
+  "version": "3.1.0",
+  "description": "Lower level utilities for compiling Vue single file components",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "lib"
+  ],
+  "scripts": {
+    "lint": "prettier --write \"{lib,test}/**/*.ts\"",
+    "test": "prettier --list-different \"{lib,test}/**/*.ts\" && jest --coverage",
+    "build": "rm -rf dist && tsc",
+    "prepublishOnly": "yarn build && conventional-changelog -p angular -r 2 -i CHANGELOG.md -s"
+  },
+  "gitHooks": {
+    "pre-commit": "lint-staged"
+  },
+  "lint-staged": {
+    "*.{ts,js}": [
+      "prettier --write",
+      "git add"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/component-compiler-utils.git"
+  },
+  "keywords": [
+    "vue",
+    "sfc",
+    "component",
+    "compiler"
+  ],
+  "author": "Evan You",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vuejs/component-compiler-utils/issues"
+  },
+  "homepage": "https://github.com/vuejs/component-compiler-utils#readme",
+  "devDependencies": {
+    "@types/jest": "^22.2.3",
+    "@types/node": "^10.12.20",
+    "conventional-changelog-cli": "^2.0.11",
+    "jest": "^24.0.0",
+    "less": "^3.9.0",
+    "lint-staged": "^8.1.1",
+    "pug": "^2.0.3",
+    "sass": "^1.17.3",
+    "stylus": "^0.54.5",
+    "ts-jest": "^24.0.0",
+    "typescript": "^3.3.0",
+    "vue": "^2.6.6",
+    "vue-template-compiler": "^2.6.6",
+    "yorkie": "^2.0.0"
+  },
+  "dependencies": {
+    "consolidate": "^0.15.1",
+    "hash-sum": "^1.0.2",
+    "lru-cache": "^4.1.2",
+    "merge-source-map": "^1.1.0",
+    "postcss": "^7.0.14",
+    "postcss-selector-parser": "^5.0.0",
+    "prettier": "^1.18.2",
+    "source-map": "~0.6.1",
+    "vue-template-es2015-compiler": "^1.9.0"
+  }
+}

packages/vue-cli-plugin-uni/packages/vue-loader/lib/index.js

@@ -69,7 +69,10 @@ module.exports = function (source) {
     compiler: options.compiler || loadTemplateCompiler(loaderContext),
     filename,
     sourceRoot,
-    needMap: sourceMap
+    needMap: sourceMap,
+    isAppService: options.isAppService,
+    isAppView: options.isAppView,
+    isAppNVue: options.isAppNVue
   })
 
   // if the query has a type field, this is a language block request

packages/vue-cli-plugin-uni/packages/vue-template-compiler/browser.js

@@ -599,7 +599,7 @@
   var splitRE$1 = /\r?\n/g;
   var replaceRE = /./g;
   var isSpecialTag = makeMap('script,style,template', true);
-  var isCustomBlock = makeMap('wxs,filter,sjs', true);// fixed by xxxxxx
+  var isCustomBlock = makeMap('wxs,filter,sjs,renderjs', true);// fixed by xxxxxx
 
   /**
    * Parse a single-file component (*.vue) file into an SFC Descriptor Object.

packages/vue-cli-plugin-uni/packages/vue-template-compiler/build.js

@@ -557,7 +557,7 @@ function parseHTML (html, options) {
 var splitRE = /\r?\n/g;
 var replaceRE = /./g;
 var isSpecialTag = makeMap('script,style,template', true);
-var isCustomBlock = makeMap('wxs,filter,sjs', true);// fixed by xxxxxx
+var isCustomBlock = makeMap('wxs,filter,sjs,renderjs', true);// fixed by xxxxxx
 
 /**
  * Parse a single-file component (*.vue) file into an SFC Descriptor Object.

packages/vue-cli-plugin-uni/packages/webpack-custom-block-loader/index.js → packages/vue-cli-plugin-uni/packages/webpack-custom-block-loader/index.bak.js

@@ -14,7 +14,7 @@ const {
 
 const FILTER_TAG = getPlatformFilterTag()
 
-module.exports = function (source) {
+module.exports = function(source) {
   const loaderContext = this
 
   const {
@@ -56,6 +56,15 @@ module.exports = function (source) {
       modules[block.attrs.module] = block
       return true
     }
+    if ( // renderjs
+      options.isAppView &&
+      (
+        block.type === 'renderjs' ||
+        block.attrs.lang === 'renderjs'
+      )
+    ) {
+      return true
+    }
   })
 
   if (Object.keys(modules).length) {

packages/vue-cli-plugin-uni/packages/webpack-uni-app-loader/view/renderjs.js

+const path = require('path')
+
+const loaderUtils = require('loader-utils')
+
+module.exports = function(source, map) {
+  const params = loaderUtils.parseQuery(this.resourceQuery)
+  // v3 app-plus
+  if (process.env.UNI_PLATFORM === 'app-plus' && process.env.UNI_USING_V3) {
+    this.callback(
+      null,
+      `export default function (Component) {
+${source.trim()}
+}`,
+      map
+    )
+  }
+  return source
+}