wip(mp): pages.json

packages/uni-app-vite/src/plugin/configResolved.ts

+import fs from 'fs'
 import { Plugin } from 'vite'
 
 import {
@@ -10,6 +11,11 @@ import {
 export const configResolved: Plugin['configResolved'] = (config) => {
   removePlugins('vite:import-analysis', config)
   injectCssPlugin(config)
-  injectCssPostPlugin(config)
+  injectCssPostPlugin(config, {
+    appCss: fs.readFileSync(
+      require.resolve('@dcloudio/uni-app-plus/dist/style.css'),
+      'utf8'
+    ),
+  })
   injectAssetPlugin(config)
 }

packages/uni-cli-shared/src/checkUpdate.ts

-import fs from 'fs'
+import fs from 'fs-extra'
 import os from 'os'
 import path from 'path'
 import debug from 'debug'
@@ -10,7 +10,7 @@ import { hasOwn, isString, isPlainObject } from '@vue/shared'
 import { parseManifestJsonOnce } from './json'
 import { isInHBuilderX } from './hbx'
 
-const debugCheckUpdate = debug('uni:check-update')
+const debugCheckUpdate = debug('vite:uni:check-update')
 
 interface CheckUpdateOptions {
   inputDir: string
@@ -63,6 +63,7 @@ export async function checkUpdate(options: CheckUpdateOptions) {
   }
   const { inputDir, compilerVersion } = options
   const updateCache = readCheckUpdateCache(inputDir)
+  debugCheckUpdate('read.cache', updateCache)
   const res = checkLocalCache(updateCache, compilerVersion)
   if (res) {
     if (isString(res)) {
@@ -104,10 +105,12 @@ function normalizeUpdateCache(
 }
 
 function statUpdateCache(updateCache: CheckUpdateCache) {
+  debugCheckUpdate('stat.before', updateCache)
   const platform = process.env.UNI_PLATFORM
   const type = process.env.NODE_ENV === 'production' ? 'build' : 'dev'
   const platformOptions = updateCache[platform] as CheckUpdatePlatform
   platformOptions[type] = (platformOptions[type] || 0) + 1
+  debugCheckUpdate('stat.after', updateCache)
   return updateCache
 }
 
@@ -140,7 +143,9 @@ function readCheckUpdateCache(inputDir: string) {
   if (fs.existsSync(updateFilepath)) {
     try {
       return require(updateFilepath) as CheckUpdateCache
-    } catch (e) {}
+    } catch (e) {
+      debugCheckUpdate('read.error', e)
+    }
   }
   return createCheckUpdateCache()
 }
@@ -182,8 +187,10 @@ function writeCheckUpdateCache(
   const filepath = getCheckUpdateFilepath(inputDir)
   debugCheckUpdate('write:', filepath, updateCache)
   try {
-    fs.writeFileSync(filepath, JSON.stringify(updateCache))
-  } catch (e) {}
+    fs.outputFileSync(filepath, JSON.stringify(updateCache))
+  } catch (e: any) {
+    debugCheckUpdate('write.error', e)
+  }
 }
 
 export function md5(str: string) {
@@ -265,37 +272,49 @@ function checkVersion(
   options: CheckUpdateOptions,
   updateCache: CheckUpdateCache
 ) {
-  const postData = createPostData(
-    options,
-    parseManifestJsonOnce(options.inputDir),
-    updateCache
-  )
-  let responseData = ''
-  const req = request(
-    {
-      hostname: HOSTNAME,
-      path: PATH,
-      port: 443,
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Content-Length': postData.length,
+  return new Promise((resolve) => {
+    const postData = JSON.stringify({
+      id: createPostData(
+        options,
+        parseManifestJsonOnce(options.inputDir),
+        updateCache
+      ),
+    })
+    let responseData = ''
+    const req = request(
+      {
+        hostname: HOSTNAME,
+        path: PATH,
+        port: 443,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': postData.length,
+        },
       },
-    },
-    (res) => {
-      res.setEncoding('utf8')
-      res.on('data', (chunk) => {
-        responseData += chunk
-      })
-      res.on('end', () => {
-        debugCheckUpdate('response: ', responseData)
-        try {
-          handleCheckVersion(JSON.parse(responseData), updateCache)
-        } catch (e) {}
-      })
-    }
-  )
-  debugCheckUpdate('request: ', postData)
-  req.write(postData)
-  req.end()
+      (res) => {
+        res.setEncoding('utf8')
+        res.on('data', (chunk) => {
+          responseData += chunk
+        })
+        res.on('end', () => {
+          debugCheckUpdate('response: ', responseData)
+          try {
+            handleCheckVersion(JSON.parse(responseData), updateCache)
+          } catch (e) {}
+          resolve(true)
+        })
+        res.on('error', (e) => {
+          debugCheckUpdate('response.error:', e)
+          resolve(false)
+        })
+      }
+    ).on('error', (e) => {
+      debugCheckUpdate('request.error:', e)
+      resolve(false)
+    })
+    debugCheckUpdate('request: ', postData)
+    req.write(postData)
+    req.end()
+  })
 }

packages/uni-cli-shared/src/vite/index.ts

 import type { Plugin } from 'vite'
 import type { ParserOptions } from '@vue/compiler-core'
-import type { CompilerOptions } from '@vue/compiler-sfc'
+import type { CompilerOptions, TemplateCompiler } from '@vue/compiler-sfc'
 import { UniViteCopyPluginOptions } from './plugins/copy'
 export interface CopyOptions {
   /**
@@ -11,6 +11,7 @@ export interface CopyOptions {
 }
 
 interface UniVitePluginUniOptions {
+  compiler?: TemplateCompiler
   compilerOptions?: {
     isNativeTag: ParserOptions['isNativeTag']
     isCustomElement: ParserOptions['isCustomElement']

packages/uni-cli-shared/src/vite/plugins/css.ts

-import path from 'path'
-import debug from 'debug'
-import { Plugin } from 'vite'
-import { normalizePath, resolveMainPathOnce } from '../../utils'
-import { EXTNAME_VUE_RE } from '../../constants'
-
-const cssLangs = `\\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\\?)`
-const cssLangRE = new RegExp(cssLangs)
-// const cssModuleRE = new RegExp(`\\.module${cssLangs}`)
-// const directRequestRE = /(\?|&)direct\b/
-const commonjsProxyRE = /\?commonjs-proxy/
-
-const debugCss = debug('vite:uni:css')
-
-// const isCSSRequest = (request: string): boolean =>
-//   cssLangRE.test(request) && !directRequestRE.test(request)
-
-const isCss = (id: string): boolean =>
-  cssLangRE.test(id) && !commonjsProxyRE.test(id)
-
-function normalizeCssChunkFilename(id: string) {
-  return normalizePath(
-    path.relative(
-      process.env.UNI_INPUT_DIR,
-      id.split('?')[0].replace(EXTNAME_VUE_RE, '.css')
-    )
-  )
-}
-
-interface UniCssPluginOptions {
-  /**
-   * 额外的全局样式
-   */
-  app: string
-}
-
-export function uniCssPlugin({ app }: UniCssPluginOptions): Plugin {
-  const styles: Map<string, string> = new Map<string, string>()
-  let cssChunks: Map<string, Set<string>>
-  return {
-    name: 'vite:uni-app-css',
-    buildStart() {
-      cssChunks = new Map<string, Set<string>>()
-    },
-    transform(css, id) {
-      if (!isCss(id)) {
-        return
-      }
-      debugCss(id)
-      styles.set(id, css)
-      return {
-        code: '',
-        map: { mappings: '' },
-        moduleSideEffects: 'no-treeshake',
-      }
-    },
-    async generateBundle() {
-      const findCssModuleIds = (
-        moduleId: string,
-        cssModuleIds?: Set<string>
-      ) => {
-        if (!cssModuleIds) {
-          cssModuleIds = new Set<string>()
-        }
-        const moduleInfo = this.getModuleInfo(moduleId)
-        if (moduleInfo) {
-          moduleInfo.importedIds.forEach((id) => {
-            if (id.includes('pages.json.js')) {
-              // 查询main.js时，需要忽略pages.json.js，否则会把所有页面样式加进来
-              return
-            }
-            if (isCss(id)) {
-              cssModuleIds!.add(id)
-            } else {
-              findCssModuleIds(id, cssModuleIds)
-            }
-          })
-        }
-        return cssModuleIds
-      }
-      const moduleIds = Array.from(this.getModuleIds())
-      const mainPath = resolveMainPathOnce(process.env.UNI_INPUT_DIR)
-      moduleIds.forEach((id) => {
-        if (id === mainPath) {
-          // 全局样式
-          cssChunks.set('app.css', findCssModuleIds(id))
-        } else if (id.includes('mpType=page')) {
-          // 页面样式
-          cssChunks.set(normalizeCssChunkFilename(id), findCssModuleIds(id))
-        }
-      })
-      if (!cssChunks.size) {
-        return
-      }
-      const genCssCode = (fileName: string) => {
-        return [...cssChunks.get(fileName)!]
-          .map((id) => styles.get(id) || '')
-          .join('\n')
-      }
-      for (const fileName of cssChunks.keys()) {
-        let source =
-          (fileName === 'app.css' ? app + '\n' : '') + genCssCode(fileName)
-        // if (resolvedConfig.build.minify) {
-        //   source = await minifyCSS(source, resolvedConfig)
-        // }
-        this.emitFile({
-          fileName,
-          type: 'asset',
-          source,
-        })
-      }
-    },
-  }
-}

packages/uni-cli-shared/src/vite/plugins/index.ts

-export * from './css'
 export * from './cssScoped'
 export * from './copy'
 export * from './inject'
@@ -7,4 +6,4 @@ export * from './jsonJs'
 export * from './console'
 
 export { assetPlugin } from './vitejs/plugins/asset'
-export { cssPlugin, cssPostPlugin } from './vitejs/plugins/css'
+export { isCSSRequest, cssPlugin, cssPostPlugin } from './vitejs/plugins/css'

packages/uni-cli-shared/src/vite/plugins/vitejs/plugins/css.ts

@@ -226,14 +226,13 @@ function findCssModuleIds(
 /**
  * Plugin applied after user plugins
  */
-export function cssPostPlugin(config: ResolvedConfig): Plugin {
+export function cssPostPlugin(
+  config: ResolvedConfig,
+  { appCss }: { appCss?: string }
+): Plugin {
   // styles initialization in buildStart causes a styling loss in watch
   const styles: Map<string, string> = new Map<string, string>()
   let cssChunks: Map<string, Set<string>>
-  const viewCssCode = fs.readFileSync(
-    require.resolve('@dcloudio/uni-app-plus/dist/style.css'),
-    'utf8'
-  )
   return {
     name: 'vite:css-post',
     buildStart() {
@@ -305,7 +304,7 @@ export function cssPostPlugin(config: ResolvedConfig): Plugin {
       }
       for (const filename of cssChunks.keys()) {
         let source = await processChunkCSS(
-          (filename === 'app.css' ? viewCssCode + '\n' : '') +
+          (filename === 'app.css' ? (appCss || '') + '\n' : '') +
             genCssCode(filename),
           { dirname: path.dirname(filename), inlined: false, minify: true }
         )

packages/uni-cli-shared/src/vite/utils/plugin.ts

@@ -17,8 +17,11 @@ export function injectCssPlugin(config: ResolvedConfig) {
   replacePlugins([cssPlugin(config)], config)
 }
 
-export function injectCssPostPlugin(config: ResolvedConfig) {
-  replacePlugins([cssPostPlugin(config)], config)
+export function injectCssPostPlugin(
+  config: ResolvedConfig,
+  { appCss }: { appCss?: string }
+) {
+  replacePlugins([cssPostPlugin(config, { appCss })], config)
 }
 
 export function replacePlugins(plugins: Plugin[], config: ResolvedConfig) {

packages/uni-mp-compiler/src/codegen.ts

@@ -32,7 +32,7 @@ export function generate(
   if (isSetupInlined) {
     codes.push(`(${signature}) => {`)
   } else {
-    codes.push(`function ${functionName}(${signature}) {`)
+    codes.push(`\nexport function ${functionName}(${signature}) {`)
   }
   codes.push(
     `return ` +

packages/uni-mp-vite/package.json

@@ -17,11 +17,6 @@
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "uni-app": {
-    "name": "uni-mp",
-    "apply": "^mp-",
-    "main": "dist/index.js"
-  },
   "license": "Apache-2.0",
   "gitHead": "453a3e6ead807864087692f4339ea3d667045fe7"
 }

packages/uni-mp-vite/src/index.ts

-import { UniMpPlugin } from './plugin'
+import { uniMiniProgramPlugin, UniMiniProgramPluginOptions } from './plugin'
 import { uniMainJsPlugin } from './plugins/mainJs'
 import { uniManifestJsonPlugin } from './plugins/manifestJson'
 import { uniPagesJsonPlugin } from './plugins/pagesJson'
-export default [
-  uniMainJsPlugin(),
-  uniManifestJsonPlugin(),
-  uniPagesJsonPlugin(),
-  UniMpPlugin,
-]
+import { uniVirtualPlugin } from './plugins/virtual'
+export default (options: UniMiniProgramPluginOptions) => {
+  return [
+    uniMainJsPlugin(),
+    uniManifestJsonPlugin(),
+    uniPagesJsonPlugin(),
+    uniVirtualPlugin(options),
+    uniMiniProgramPlugin(options),
+  ]
+}

packages/uni-mp-vite/src/plugin/build.ts

 import path from 'path'
 import { UserConfig } from 'vite'
 
-import { normalizePath, resolveMainPathOnce } from '@dcloudio/uni-cli-shared'
+import {
+  isCSSRequest,
+  normalizePath,
+  resolveMainPathOnce,
+} from '@dcloudio/uni-cli-shared'
+import { GetManualChunk, GetModuleInfo } from 'rollup'
+import {
+  isUniComponentUrl,
+  isUniPageUrl,
+  parseVirtualComponentPath,
+  parseVirtualPagePath,
+} from '../plugins/virtual'
 
 export function buildOptions(): UserConfig['build'] {
+  const inputDir = process.env.UNI_INPUT_DIR
   return {
     // sourcemap: 'inline', // TODO
     assetsInlineLimit: 0, // TODO
+    lib: {
+      entry: resolveMainPathOnce(inputDir),
+      formats: ['cjs'],
+    },
     rollupOptions: {
-      input: resolveMainPathOnce(process.env.UNI_INPUT_DIR),
       output: {
-        format: 'cjs',
-        entryFileNames: 'main.js',
+        entryFileNames: 'app.js',
+        manualChunks: createMoveToVendorChunkFn(),
         chunkFileNames(chunk) {
           if (chunk.isDynamicEntry && chunk.facadeModuleId) {
-            const filepath = path.relative(
-              process.env.UNI_INPUT_DIR,
-              chunk.facadeModuleId
-            )
+            let id = chunk.facadeModuleId
+            if (isUniPageUrl(id)) {
+              id = path.resolve(
+                process.env.UNI_INPUT_DIR,
+                parseVirtualPagePath(id)
+              )
+            } else if (isUniComponentUrl(id)) {
+              id = path.resolve(
+                process.env.UNI_INPUT_DIR,
+                parseVirtualComponentPath(id)
+              )
+            }
+            const filepath = path.relative(inputDir, id)
             return normalizePath(
               filepath.replace(path.extname(filepath), '.js')
             )
@@ -29,3 +53,53 @@ export function buildOptions(): UserConfig['build'] {
     },
   }
 }
+
+function createMoveToVendorChunkFn(): GetManualChunk {
+  const cache = new Map<string, boolean>()
+  return (id, { getModuleInfo }) => {
+    if (
+      (id.includes('node_modules') ||
+        id.includes('plugin-vue:export-helper')) &&
+      !isCSSRequest(id) &&
+      staticImportedByEntry(id, getModuleInfo, cache)
+    ) {
+      return 'vendor'
+    }
+  }
+}
+
+function staticImportedByEntry(
+  id: string,
+  getModuleInfo: GetModuleInfo,
+  cache: Map<string, boolean>,
+  importStack: string[] = []
+): boolean {
+  if (cache.has(id)) {
+    return cache.get(id) as boolean
+  }
+  if (importStack.includes(id)) {
+    // circular deps!
+    cache.set(id, false)
+    return false
+  }
+  const mod = getModuleInfo(id)
+  if (!mod) {
+    cache.set(id, false)
+    return false
+  }
+
+  if (mod.isEntry) {
+    cache.set(id, true)
+    return true
+  }
+  const someImporterIs = mod.importers.some((importer) =>
+    staticImportedByEntry(
+      importer,
+      getModuleInfo,
+      cache,
+      importStack.concat(id)
+    )
+  )
+  cache.set(id, someImporterIs)
+  return someImporterIs
+}

packages/uni-mp-vite/src/plugin/configResolved.ts

@@ -10,6 +10,8 @@ import {
 export const configResolved: Plugin['configResolved'] = (config) => {
   removePlugins('vite:import-analysis', config)
   injectCssPlugin(config)
-  injectCssPostPlugin(config)
+  injectCssPostPlugin(config, {
+    appCss: '',
+  })
   injectAssetPlugin(config)
 }

packages/uni-mp-vite/src/plugin/index.ts

+import { AliasOptions } from 'vite'
 import { resolveBuiltIn, UniVitePlugin } from '@dcloudio/uni-cli-shared'
 
 import { uniOptions } from './uni'
 import { buildOptions } from './build'
 import { configResolved } from './configResolved'
 
-export const UniMpPlugin: UniVitePlugin = {
-  name: 'vite:uni-mp',
-  uni: uniOptions(),
-  config() {
-    return {
-      resolve: {
-        alias: {
-          vue: resolveBuiltIn('@dcloudio/uni-mp-vue'),
+export interface UniMiniProgramPluginOptions {
+  global: string
+  alias?: AliasOptions
+}
+
+export function uniMiniProgramPlugin({
+  alias,
+}: UniMiniProgramPluginOptions): UniVitePlugin {
+  return {
+    name: 'vite:uni-mp',
+    uni: uniOptions(),
+    config() {
+      return {
+        resolve: {
+          alias: {
+            vue: resolveBuiltIn('@dcloudio/uni-mp-vue'),
+            ...alias,
+          },
         },
-      },
-      build: buildOptions(),
-    }
-  },
-  configResolved,
+        build: buildOptions(),
+      }
+    },
+    configResolved,
+  }
 }

packages/uni-mp-vite/src/plugin/uni/index.ts

@@ -3,9 +3,13 @@ import {
   isServiceCustomElement,
 } from '@dcloudio/uni-shared'
 import { UniVitePlugin } from '@dcloudio/uni-cli-shared'
+import { TemplateCompiler } from '@vue/compiler-sfc'
+
+import * as compiler from '@dcloudio/uni-mp-compiler'
 
 export function uniOptions(): UniVitePlugin['uni'] {
   return {
+    compiler: compiler as TemplateCompiler,
     compilerOptions: {
       isNativeTag: isServiceNativeTag,
       isCustomElement: isServiceCustomElement,

packages/uni-mp-vite/src/plugins/mainJs.ts

@@ -11,7 +11,9 @@ export function uniMainJsPlugin() {
             ? createApp(code)
             : createLegacyApp(code)
           return {
-            code: `import './pages.json.js';` + code,
+            code:
+              `import 'plugin-vue:export-helper';import 'uni-mp-runtime';import './pages.json.js';` +
+              code,
             map: this.getCombinedSourcemap(),
           }
         }

packages/uni-mp-vite/src/plugins/pagesJson.ts

@@ -3,12 +3,11 @@ import { Plugin } from 'vite'
 
 import {
   defineUniPagesJsonPlugin,
-  normalizeAppPagesJson,
-  // normalizeAppConfigService,
   normalizePagesJson,
-  // parseManifestJsonOnce,
   getLocaleFiles,
+  normalizePagePath,
 } from '@dcloudio/uni-cli-shared'
+import { virtualPagePath } from './virtual'
 
 export function uniPagesJsonPlugin(): Plugin {
   let pagesJson: UniApp.PagesJson
@@ -35,7 +34,8 @@ export function uniPagesJsonPlugin(): Plugin {
         })
         return {
           code:
-            `import './manifest.json.js'\n` + normalizeAppPagesJson(pagesJson),
+            `import './manifest.json.js'\n` +
+            normalizeMiniProgramPagesJson(pagesJson),
           map: this.getCombinedSourcemap(),
         }
       },
@@ -52,3 +52,17 @@ export function uniPagesJsonPlugin(): Plugin {
     }
   })
 }
+
+function normalizeMiniProgramPagesJson(pagesJson: Record<string, any>) {
+  const importPagesCode: string[] = []
+  pagesJson.pages.forEach((page: UniApp.PagesJsonPageOptions) => {
+    const pagePath = page.path
+    const pagePathWithExtname = normalizePagePath(pagePath, 'app')
+    if (pagePathWithExtname) {
+      importPagesCode.push(`import('${virtualPagePath(pagePathWithExtname)}')`)
+    }
+  })
+  return `if(!Math){
+${importPagesCode.join('\n')}
+}`
+}

packages/uni-mp-vite/src/plugins/virtual.ts

+import path from 'path'
+import { normalizePath } from '@dcloudio/uni-cli-shared'
+import { Plugin } from 'vite'
+import { UniMiniProgramPluginOptions } from '../plugin'
+
+function encode(str: string) {
+  return Buffer.from(str).toString('base64url')
+}
+
+function decode(str: string) {
+  return Buffer.from(str, 'base64url').toString()
+}
+
+const uniPagePrefix = 'uniPage://'
+const uniComponentPrefix = 'uniComponent://'
+
+export function virtualPagePath(filepath: string) {
+  return uniPagePrefix + encode(filepath)
+}
+export function virtualComponentPath(filepath: string) {
+  return uniComponentPrefix + encode(filepath)
+}
+
+export function parseVirtualPagePath(uniPageUrl: string) {
+  return decode(uniPageUrl.replace(uniPagePrefix, ''))
+}
+
+export function parseVirtualComponentPath(uniComponentUrl: string) {
+  return decode(uniComponentUrl.replace(uniComponentPrefix, ''))
+}
+
+export function isUniPageUrl(id: string) {
+  return id.startsWith(uniPagePrefix)
+}
+
+export function isUniComponentUrl(id: string) {
+  return id.startsWith(uniComponentPrefix)
+}
+
+export function uniVirtualPlugin({
+  global,
+}: UniMiniProgramPluginOptions): Plugin {
+  const inputDir = process.env.UNI_INPUT_DIR
+  return {
+    name: 'vite:uni-virtual',
+    enforce: 'pre',
+    resolveId(id) {
+      if (isUniPageUrl(id) || isUniComponentUrl(id)) {
+        return id
+      }
+    },
+    load(id) {
+      if (isUniPageUrl(id)) {
+        const filepath = normalizePath(
+          path.resolve(inputDir, parseVirtualPagePath(id))
+        )
+        return {
+          code: `import Page from '${filepath}?mpType=page'
+${global}.createPage(Page)`,
+        }
+      } else if (isUniComponentUrl(id)) {
+        const filepath = normalizePath(
+          path.resolve(inputDir, parseVirtualComponentPath(id))
+        )
+        return {
+          code: `import Component from '${filepath}'
+${global}.createComponent(Component)`,
+        }
+      }
+    },
+  }
+}

packages/uni-mp-weixin/build.json

-{
-  "input": {
-    "src/runtime/index.ts": "dist/uni.mp.esm.js",
-    "src/api/index.ts": "dist/uni.api.esm.js"
+[
+  {
+    "input": {
+      "src/plugin/index.ts": "dist/uni.compiler.js"
+    },
+    "output": {
+      "format": "cjs"
+    },
+    "external": ["@dcloudio/uni-cli-shared", "@dcloudio/uni-mp-vite"]
   },
-  "alias": {
-    "entries": [
-      {
-        "find": "@dcloudio/uni-platform",
-        "replacement": "packages/uni-mp-weixin/src/platform/index.ts"
-      },
-      {
-        "find": "@dcloudio/uni-mp-platform",
-        "replacement": "packages/uni-mp-core/src/platform/index.ts"
-      }
-    ]
-  },
-  "replacements": {
-    "global": "global",
-    "__GLOBAL__": "wx",
-    "__PLATFORM__": "\"mp-weixin\"",
-    "__PLATFORM_TITLE__": "微信小程序"
-  },
-  "external": ["@dcloudio/uni-i18n", "@vue/shared", "vue"]
-}
+  {
+    "input": {
+      "src/runtime/index.ts": "dist/uni.mp.esm.js",
+      "src/api/index.ts": "dist/uni.api.esm.js"
+    },
+    "alias": {
+      "entries": [
+        {
+          "find": "@dcloudio/uni-platform",
+          "replacement": "packages/uni-mp-weixin/src/platform/index.ts"
+        },
+        {
+          "find": "@dcloudio/uni-mp-platform",
+          "replacement": "packages/uni-mp-core/src/platform/index.ts"
+        }
+      ]
+    },
+    "replacements": {
+      "global": "global",
+      "__GLOBAL__": "wx",
+      "__PLATFORM__": "\"mp-weixin\"",
+      "__PLATFORM_TITLE__": "微信小程序"
+    },
+    "external": ["@dcloudio/uni-i18n", "@vue/shared", "vue"]
+  }
+]

packages/uni-mp-weixin/dist/uni.compiler.js

+'use strict';
+
+var uniCliShared = require('@dcloudio/uni-cli-shared');
+var initMiniProgramPlugin = require('@dcloudio/uni-mp-vite');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var initMiniProgramPlugin__default = /*#__PURE__*/_interopDefaultLegacy(initMiniProgramPlugin);
+
+var index = initMiniProgramPlugin__default["default"]({
+    global: 'wx',
+    alias: {
+        'uni-mp-runtime': uniCliShared.resolveBuiltIn('@dcloudio/uni-mp-weixin/dist/uni.mp.esm.js'),
+    },
+});
+
+module.exports = index;

packages/uni-mp-weixin/package.json

@@ -18,7 +18,9 @@
   "license": "Apache-2.0",
   "uni-app": {
     "name": "mp-weixin",
-    "title": "微信小程序"
+    "title": "微信小程序",
+    "apply": "mp-weixin",
+    "main": "dist/uni.compiler.js"
   },
   "gitHead": "453a3e6ead807864087692f4339ea3d667045fe7"
 }

packages/uni-mp-weixin/src/plugin/index.ts

+import { resolveBuiltIn } from '@dcloudio/uni-cli-shared'
+import initMiniProgramPlugin from '@dcloudio/uni-mp-vite'
+
+export default initMiniProgramPlugin({
+  global: 'wx',
+  alias: {
+    'uni-mp-runtime': resolveBuiltIn(
+      '@dcloudio/uni-mp-weixin/dist/uni.mp.esm.js'
+    ),
+  },
+})

packages/vite-plugin-uni/src/utils/plugin.ts

@@ -7,6 +7,7 @@ import type {
   UniViteCopyPluginTarget,
   UniVitePlugin,
 } from '@dcloudio/uni-cli-shared'
+import { TemplateCompiler } from '@vue/compiler-sfc'
 
 interface PluginConfig {
   id: string
@@ -26,12 +27,17 @@ export function initPluginUniOptions(UniVitePlugins: UniVitePlugin[]) {
     isNativeTag,
     isCustomElement,
   }
+  let compiler: TemplateCompiler | undefined
   UniVitePlugins.forEach((plugin) => {
     const {
+      compiler: pluginTemplateCompiler,
       copyOptions: pluginCopyOptions,
       compilerOptions: pluginCompilerOptions,
       transformEvent: pluginTransformEvent,
     } = plugin.uni || {}
+    if (pluginTemplateCompiler) {
+      compiler = pluginTemplateCompiler
+    }
     if (pluginCompilerOptions) {
       if (pluginCompilerOptions.isNativeTag) {
         compilerOptions.isNativeTag = pluginCompilerOptions.isNativeTag
@@ -61,6 +67,7 @@ export function initPluginUniOptions(UniVitePlugins: UniVitePlugin[]) {
     }
   })
   return {
+    compiler,
     copyOptions: {
       assets,
       targets,

packages/vite-plugin-uni/src/vue/options.ts

 import { extend, hasOwn, isArray, isPlainObject } from '@vue/shared'
-import { SFCTemplateCompileOptions } from '@vue/compiler-sfc'
+import { SFCTemplateCompileOptions, TemplateCompiler } from '@vue/compiler-sfc'
 import { isCustomElement } from '@dcloudio/uni-shared'
 import {
   EXTNAME_VUE_RE,
@@ -38,7 +38,11 @@ function createUniVueTransformAssetUrls(
 export function initPluginVueOptions(
   options: VitePluginUniResolvedOptions,
   UniVitePlugins: UniVitePlugin[],
-  uniPluginOptions: Required<Required<UniVitePlugin>['uni']>
+  uniPluginOptions: Required<
+    Omit<Required<UniVitePlugin>['uni'], 'compiler'>
+  > & {
+    compiler?: TemplateCompiler
+  }
 ) {
   const vueOptions = options.vueOptions || (options.vueOptions = {})
   if (!vueOptions.include) {
@@ -66,6 +70,7 @@ export function initPluginVueOptions(
     templateOptions.compilerOptions || (templateOptions.compilerOptions = {})
 
   const {
+    compiler,
     compilerOptions: {
       isNativeTag,
       isCustomElement,
@@ -73,6 +78,9 @@ export function initPluginVueOptions(
       directiveTransforms,
     },
   } = uniPluginOptions
+  if (compiler) {
+    templateOptions.compiler = compiler
+  }
   compilerOptions.isNativeTag = isNativeTag
   compilerOptions.isCustomElement = isCustomElement
   if (directiveTransforms) {