weapp-vite 1.4.1 → 1.4.3

package/dist/{chunk-W74CVQPU.mjs → chunk-X633662H.mjs}

@@ -3,7 +3,7 @@ import logger from "@weapp-core/logger";
 var logger_default = logger;
 
 // package.json
-var version = "1.4.1";
+var version = "1.4.3";
 
 // src/constants.ts
 var VERSION = version;
@@ -13,10 +13,10 @@ var supportedCssLangs = ["wxss", "scss", "less", "sass", "styl"];
 // src/context.ts
 import { createRequire } from "node:module";
 import process from "node:process";
-import { addExtension as addExtension2, defu, isObject, removeExtension as removeExtension2 } from "@weapp-core/shared";
+import { addExtension as addExtension2, defu, isObject as isObject2, objectHash, removeExtension as removeExtension2 } from "@weapp-core/shared";
 import { watch } from "chokidar";
 import fs6 from "fs-extra";
-import path4 from "pathe";
+import path5 from "pathe";
 import { build as tsupBuild } from "tsup";
 import { build, loadConfigFromFile } from "vite";
 import tsconfigPaths from "vite-tsconfig-paths";
@@ -37,7 +37,7 @@ function getWeappWatchOptions() {
 import { fdir as Fdir } from "fdir";
 import fs5 from "fs-extra";
 import MagicString from "magic-string";
-import path3 from "pathe";
+import path4 from "pathe";
 import { isCSSRequest } from "vite";
 
 // src/debugger.ts
@@ -82,8 +82,10 @@ async function findJsEntry(filepath) {
 }
 
 // src/utils/json.ts
+import { get, isObject, set } from "@weapp-core/shared";
 import { parse as parseJson, stringify } from "comment-json";
 import fs2 from "fs-extra";
+import path2 from "pathe";
 function parseCommentJson(json) {
   return parseJson(json, void 0, true);
 }
@@ -97,16 +99,84 @@ async function readCommentJson(filepath) {
 function stringifyJson(value, replacer) {
   return stringify(value, replacer, 2);
 }
-function resolveJson(value) {
-  return stringifyJson(value);
+function matches(pattern, importee) {
+  if (pattern instanceof RegExp) {
+    return pattern.test(importee);
+  }
+  if (importee.length < pattern.length) {
+    return false;
+  }
+  if (importee === pattern) {
+    return true;
+  }
+  return importee.startsWith(pattern + "/");
+}
+function getAliasEntries({ entries } = {}) {
+  if (!entries) {
+    return [];
+  }
+  if (Array.isArray(entries)) {
+    return entries.map((entry) => {
+      return {
+        find: entry.find,
+        replacement: entry.replacement
+      };
+    });
+  }
+  return Object.entries(entries).map(([key, value]) => {
+    return { find: key, replacement: value };
+  });
+}
+function resolveImportee(importee, entry, aliasEntries) {
+  if (Array.isArray(aliasEntries)) {
+    if (!entry.jsonPath) {
+      return importee;
+    }
+    const matchedEntry = aliasEntries.find((x) => matches(x.find, importee));
+    if (!matchedEntry) {
+      return importee;
+    }
+    const updatedId = importee.replace(matchedEntry.find, matchedEntry.replacement);
+    return path2.relative(path2.dirname(entry.jsonPath), updatedId);
+  }
+  return importee;
+}
+function resolveJson(entry, aliasEntries) {
+  if (entry.json) {
+    const json = structuredClone(entry.json);
+    if (entry.jsonPath && Array.isArray(aliasEntries)) {
+      const usingComponents = get(json, "usingComponents");
+      if (isObject(usingComponents)) {
+        for (const [key, importee] of Object.entries(usingComponents)) {
+          const resolvedId = resolveImportee(importee, entry, aliasEntries);
+          set(json, `usingComponents.${key}`, resolvedId);
+        }
+        set(json, "usingComponents", usingComponents);
+      }
+      if (entry.type === "app") {
+        const fields = ["subPackages", "subpackages"];
+        for (const field of fields) {
+          const subPackages = get(json, field);
+          if (Array.isArray(subPackages)) {
+            for (const subPackage of subPackages) {
+              if (subPackage.entry) {
+                subPackage.entry = changeFileExtension(subPackage.entry, "js");
+              }
+            }
+          }
+        }
+      }
+    }
+    return stringifyJson(json);
+  }
 }
 
 // src/utils/projectConfig.ts
 import fs3 from "fs-extra";
-import path2 from "pathe";
+import path3 from "pathe";
 function getProjectConfig(root, options) {
-  const baseJsonPath = path2.resolve(root, "project.config.json");
-  const privateJsonPath = path2.resolve(root, "project.private.config.json");
+  const baseJsonPath = path3.resolve(root, "project.config.json");
+  const privateJsonPath = path3.resolve(root, "project.private.config.json");
   let baseJson = {};
   let privateJson = {};
   if (fs3.existsSync(baseJsonPath)) {
@@ -158,10 +228,10 @@ var debug = createDebugger("weapp-vite:plugin");
 function vitePluginWeapp(ctx, subPackageMeta) {
   let configResolved;
   function relative(p) {
-    return path3.relative(configResolved.root, p);
+    return path4.relative(configResolved.root, p);
   }
   function transformAbsoluteToRelative(p) {
-    if (path3.isAbsolute(p)) {
+    if (path4.isAbsolute(p)) {
       return relative(p);
     }
     return p;
@@ -206,13 +276,13 @@ function vitePluginWeapp(ctx, subPackageMeta) {
         ];
         if (!subPackageMeta) {
           for (const root of Object.keys(ctx.subPackageMeta)) {
-            ignore.push(path3.join(root, "**"));
+            ignore.push(path4.join(root, "**"));
           }
         }
         const baseDir = ctx.srcRoot ?? "";
-        const targetDir = subPackageMeta ? path3.join(baseDir, subPackageMeta.subPackage.root) : baseDir;
+        const targetDir = subPackageMeta ? path4.join(baseDir, subPackageMeta.subPackage.root) : baseDir;
         const patterns = [
-          path3.join(
+          path4.join(
             targetDir,
             "**/*.{wxml,wxs,png,jpg,jpeg,gif,svg,webp}"
           )
@@ -225,7 +295,7 @@ function vitePluginWeapp(ctx, subPackageMeta) {
           }
         ).crawl(ctx.cwd).withPromise();
         for (const file of relFiles) {
-          const filepath = path3.resolve(ctx.cwd, file);
+          const filepath = path4.resolve(ctx.cwd, file);
           this.addWatchFile(filepath);
           const isMedia = !/\.(?:wxml|wxs)$/.test(file);
           this.emitFile({
@@ -238,11 +308,11 @@ function vitePluginWeapp(ctx, subPackageMeta) {
           if (entry.jsonPath) {
             this.addWatchFile(entry.jsonPath);
             if (entry.json) {
-              const fileName = ctx.relativeSrcRoot(path3.relative(ctx.cwd, entry.jsonPath));
+              const fileName = ctx.relativeSrcRoot(path4.relative(ctx.cwd, entry.jsonPath));
               this.emitFile({
                 type: "asset",
                 fileName,
-                source: resolveJson(entry.json)
+                source: resolveJson(entry, ctx.aliasEntries)
               });
             }
           }
@@ -334,9 +404,9 @@ var require2 = createRequire(import.meta.url);
 var logBuildAppFinishOnlyShowOnce = false;
 function logBuildAppFinish() {
   if (!logBuildAppFinishOnlyShowOnce) {
-    logger_default.success("\u5E94\u7528\u6784\u5EFA\u5B8C\u6210\uFF01\u9884\u89C8\u65B9\u5F0F\uFF1A");
+    logger_default.success("\u5E94\u7528\u6784\u5EFA\u5B8C\u6210\uFF01\u9884\u89C8\u65B9\u5F0F ( `2` \u79CD\u9009\u5176\u4E00\u5373\u53EF)\uFF1A");
     logger_default.info("\u6267\u884C `npm run open` / `yarn open` / `pnpm open` \u76F4\u63A5\u5728 `\u5FAE\u4FE1\u5F00\u53D1\u8005\u5DE5\u5177` \u91CC\u6253\u5F00\u5F53\u524D\u5E94\u7528");
-    logger_default.info("\u624B\u52A8\u6253\u5F00\u5FAE\u4FE1\u5F00\u53D1\u8005\u5DE5\u5177,\u5BFC\u5165\u6839\u76EE\u5F55(`project.config.json` \u6587\u4EF6\u6240\u5728\u7684\u76EE\u5F55),\u5373\u53EF\u9884\u89C8\u6548\u679C");
+    logger_default.info("\u6216\u624B\u52A8\u6253\u5F00\u5FAE\u4FE1\u5F00\u53D1\u8005\u5DE5\u5177,\u5BFC\u5165\u6839\u76EE\u5F55(`project.config.json` \u6587\u4EF6\u6240\u5728\u7684\u76EE\u5F55),\u5373\u53EF\u9884\u89C8\u6548\u679C");
     logBuildAppFinishOnlyShowOnce = true;
   }
 }
@@ -359,6 +429,7 @@ var CompilerContext = class {
   entries;
   appEntry;
   subPackageMeta;
+  aliasEntries;
   constructor(options) {
     const { cwd, isDev, inlineConfig, projectConfig, mode, packageJson } = defu(options, {
       cwd: process.cwd(),
@@ -378,13 +449,14 @@ var CompilerContext = class {
     this.subPackageMeta = {};
     this.entriesSet = /* @__PURE__ */ new Set();
     this.entries = [];
+    this.aliasEntries = [];
   }
   get srcRoot() {
     return this.inlineConfig?.weapp?.srcRoot ?? "";
   }
   relativeSrcRoot(p) {
     if (this.srcRoot) {
-      return path4.relative(this.srcRoot, p);
+      return path5.relative(this.srcRoot, p);
     }
     return p;
   }
@@ -436,7 +508,7 @@ var CompilerContext = class {
       inlineConfig.weapp?.watch,
       {
         ignored: [
-          path4.join(this.mpDistRoot, "**")
+          path5.join(this.mpDistRoot, "**")
         ],
         cwd: this.cwd
       },
@@ -459,7 +531,7 @@ var CompilerContext = class {
             watch: {
               exclude: [
                 ...defaultExcluded,
-                this.mpDistRoot ? path4.join(this.mpDistRoot, "**") : "dist/**"
+                this.mpDistRoot ? path5.join(this.mpDistRoot, "**") : "dist/**"
               ],
               chokidar: {
                 ignored: [...defaultExcluded]
@@ -502,7 +574,7 @@ var CompilerContext = class {
   async loadDefaultConfig() {
     const projectConfig = getProjectConfig(this.cwd);
     this.projectConfig = projectConfig;
-    const packageJsonPath = path4.resolve(this.cwd, "package.json");
+    const packageJsonPath = path5.resolve(this.cwd, "package.json");
     const external = [];
     if (await fs6.exists(packageJsonPath)) {
       const localPackageJson = await fs6.readJson(packageJsonPath, {
@@ -550,12 +622,37 @@ var CompilerContext = class {
       ],
       logLevel: "warn"
     });
+    this.aliasEntries = getAliasEntries(this.inlineConfig.weapp?.jsonAlias);
+  }
+  get dependenciesCacheFilePath() {
+    return path5.resolve(this.cwd, "node_modules/weapp-vite/.cache/npm.json");
+  }
+  get dependenciesCacheHash() {
+    return objectHash(this.packageJson.dependencies ?? {});
+  }
+  writeDependenciesCache() {
+    return fs6.outputJSON(this.dependenciesCacheFilePath, {
+      "/": this.dependenciesCacheHash
+    });
+  }
+  async readDependenciesCache() {
+    if (await fs6.exists(this.dependenciesCacheFilePath)) {
+      return await fs6.readJson(this.dependenciesCacheFilePath, { throws: false });
+    }
+  }
+  async checkDependenciesCacheOutdate() {
+    const json = await this.readDependenciesCache();
+    if (isObject2(json)) {
+      return this.dependenciesCacheHash !== json["/"];
+    }
+    return true;
   }
   // https://cn.vitejs.dev/guide/build.html#library-mode
   // miniprogram_dist
   // miniprogram
   // https://developers.weixin.qq.com/miniprogram/dev/devtools/npm.html#%E8%87%AA%E5%AE%9A%E4%B9%89%E7%BB%84%E4%BB%B6%E7%9B%B8%E5%85%B3%E7%A4%BA%E4%BE%8B
   async buildNpm(options) {
+    const isDependenciesCacheOutdate = await this.checkDependenciesCacheOutdate();
     const { sourcemap } = defu(options, { sourcemap: true });
     let packNpmRelationList = [];
     if (this.projectConfig.setting?.packNpmManually && Array.isArray(this.projectConfig.setting.packNpmRelationList)) {
@@ -569,10 +666,10 @@ var CompilerContext = class {
       ];
     }
     for (const relation of packNpmRelationList) {
-      const packageJsonPath = path4.resolve(this.cwd, relation.packageJsonPath);
+      const packageJsonPath = path5.resolve(this.cwd, relation.packageJsonPath);
       if (await fs6.exists(packageJsonPath)) {
         const pkgJson = await fs6.readJson(packageJsonPath);
-        const outDir = path4.resolve(this.cwd, relation.miniprogramNpmDistDir, "miniprogram_npm");
+        const outDir = path5.resolve(this.cwd, relation.miniprogramNpmDistDir, "miniprogram_npm");
         if (pkgJson.dependencies) {
           const dependencies = Object.keys(pkgJson.dependencies);
           if (dependencies.length > 0) {
@@ -581,20 +678,30 @@ var CompilerContext = class {
               const targetJson = require2(id);
               if (Reflect.has(targetJson, "miniprogram") && targetJson.miniprogram) {
                 const targetJsonPath = require2.resolve(id);
+                const dest = path5.join(outDir, dep);
+                if (!isDependenciesCacheOutdate && await fs6.exists(dest)) {
+                  logger_default.success(`${dep} \u4F9D\u8D56\u672A\u53D1\u751F\u53D8\u5316\uFF0C\u8DF3\u8FC7\u5904\u7406!`);
+                  continue;
+                }
                 await fs6.copy(
-                  path4.resolve(
-                    path4.dirname(targetJsonPath),
+                  path5.resolve(
+                    path5.dirname(targetJsonPath),
                     targetJson.miniprogram
                   ),
-                  path4.join(outDir, dep)
+                  dest
                 );
               } else {
+                const destOutDir = path5.join(outDir, dep);
+                if (!isDependenciesCacheOutdate && await fs6.exists(destOutDir)) {
+                  logger_default.success(`${dep} \u4F9D\u8D56\u672A\u53D1\u751F\u53D8\u5316\uFF0C\u8DF3\u8FC7\u5904\u7406!`);
+                  continue;
+                }
                 await tsupBuild({
                   entry: {
                     index: require2.resolve(dep)
                   },
                   format: ["cjs"],
-                  outDir: path4.join(outDir, dep),
+                  outDir: destOutDir,
                   silent: true,
                   shims: true,
                   outExtension: () => {
@@ -612,20 +719,23 @@ var CompilerContext = class {
         }
       }
     }
+    await this.writeDependenciesCache();
   }
-  async usingComponentsHandler(usingComponents, dirname) {
+  async usingComponentsHandler(entry, relDir) {
+    const { usingComponents } = entry.json;
     if (usingComponents) {
-      for (const componentUrl of Object.values(usingComponents)) {
+      for (const [, componentUrl] of Object.entries(usingComponents)) {
         if (/plugin:\/\//.test(componentUrl)) {
           continue;
         }
         const tokens = componentUrl.split("/");
-        if (tokens[0] && isObject(this.packageJson.dependencies) && Reflect.has(this.packageJson.dependencies, tokens[0])) {
+        if (tokens[0] && isObject2(this.packageJson.dependencies) && Reflect.has(this.packageJson.dependencies, tokens[0])) {
           continue;
         } else if (tokens[0] === "") {
-          await this.scanComponentEntry(componentUrl.substring(1), path4.resolve(this.cwd, this.srcRoot));
+          await this.scanComponentEntry(componentUrl.substring(1), path5.resolve(this.cwd, this.srcRoot));
         } else {
-          await this.scanComponentEntry(componentUrl, dirname);
+          const importee = resolveImportee(componentUrl, entry, this.aliasEntries);
+          await this.scanComponentEntry(importee, relDir);
         }
       }
     }
@@ -637,22 +747,24 @@ var CompilerContext = class {
   }
   async scanAppEntry() {
     this.resetEntries();
-    const appDirname = path4.resolve(this.cwd, this.srcRoot);
-    const appConfigFile = path4.resolve(appDirname, "app.json");
-    const appEntry = await findJsEntry(appConfigFile);
-    if (appEntry && await fs6.exists(appConfigFile)) {
+    const appDirname = path5.resolve(this.cwd, this.srcRoot);
+    const appConfigFile = path5.resolve(appDirname, "app.json");
+    const appEntryPath = await findJsEntry(appConfigFile);
+    if (appEntryPath && await fs6.exists(appConfigFile)) {
       const config = await readCommentJson(appConfigFile);
-      if (isObject(config)) {
-        this.entriesSet.add(appEntry);
-        this.appEntry = {
-          path: appEntry,
+      if (isObject2(config)) {
+        this.entriesSet.add(appEntryPath);
+        const appEntry = {
+          path: appEntryPath,
           json: config,
-          jsonPath: appConfigFile
+          jsonPath: appConfigFile,
+          type: "app"
         };
-        this.entries.push(this.appEntry);
-        const { pages, usingComponents, subpackages = [], subPackages = [] } = config;
+        this.entries.push(appEntry);
+        this.appEntry = appEntry;
+        const { pages, subpackages = [], subPackages = [] } = config;
         const subs = [...subpackages, ...subPackages];
-        await this.usingComponentsHandler(usingComponents, appDirname);
+        await this.usingComponentsHandler(appEntry, appDirname);
         if (Array.isArray(pages)) {
           for (const page of pages) {
             await this.scanComponentEntry(page, appDirname);
@@ -668,21 +780,21 @@ var CompilerContext = class {
             const scanComponentEntry = this.scanComponentEntry.bind(meta);
             if (Array.isArray(sub.pages)) {
               for (const page of sub.pages) {
-                await scanComponentEntry(path4.join(sub.root, page), appDirname);
+                await scanComponentEntry(path5.join(sub.root, page), appDirname);
               }
             }
             if (sub.entry) {
-              await scanComponentEntry(path4.join(sub.root, sub.entry), appDirname);
+              await scanComponentEntry(path5.join(sub.root, sub.entry), appDirname);
             }
             this.subPackageMeta[sub.root] = meta;
           } else {
             if (Array.isArray(sub.pages)) {
               for (const page of sub.pages) {
-                await this.scanComponentEntry(path4.join(sub.root, page), appDirname);
+                await this.scanComponentEntry(path5.join(sub.root, page), appDirname);
               }
             }
             if (sub.entry) {
-              await this.scanComponentEntry(path4.join(sub.root, sub.entry), appDirname);
+              await this.scanComponentEntry(path5.join(sub.root, sub.entry), appDirname);
             }
           }
         }
@@ -697,29 +809,29 @@ var CompilerContext = class {
   // https://developers.weixin.qq.com/miniprogram/dev/framework/structure.html
   // 页面可以没有 JSON
   async scanComponentEntry(componentEntry, dirname) {
-    const entry = path4.resolve(dirname, componentEntry);
+    const entry = path5.resolve(dirname, componentEntry);
     const jsEntry = await findJsEntry(entry);
-    if (jsEntry) {
+    const partialEntry = {
+      path: jsEntry
+    };
+    if (jsEntry && !this.entriesSet.has(jsEntry)) {
       this.entriesSet.add(jsEntry);
+      this.entries.push(partialEntry);
     }
     const configFile = changeFileExtension(entry, "json");
     if (await fs6.exists(configFile)) {
       const config = await readCommentJson(configFile);
+      const jsonFragment = {
+        json: config,
+        jsonPath: configFile
+      };
       if (jsEntry) {
-        this.entries.push({
-          path: jsEntry,
-          json: config,
-          jsonPath: configFile
-        });
+        partialEntry.json = jsonFragment.json;
+        partialEntry.jsonPath = jsonFragment.jsonPath;
       }
-      if (isObject(config)) {
-        const { usingComponents } = config;
-        await this.usingComponentsHandler(usingComponents, path4.dirname(configFile));
+      if (isObject2(config)) {
+        await this.usingComponentsHandler(jsonFragment, path5.dirname(configFile));
       }
-    } else if (jsEntry) {
-      this.entries.push({
-        path: jsEntry
-      });
     }
   }
   setRollupWatcher(watcher, root = "/") {