weapp-vite 1.4.0 → 1.4.2

package/dist/{chunk-XHRIGOEG.mjs → chunk-NXUOOZQA.mjs}

@@ -3,7 +3,7 @@ import logger from "@weapp-core/logger";
 var logger_default = logger;
 
 // package.json
-var version = "1.4.0";
+var version = "1.4.2";
 
 // 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,71 @@ 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);
+      }
+    }
+    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 +215,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 +263,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 +282,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 +295,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)
               });
             }
           }
@@ -282,25 +339,39 @@ function vitePluginWeapp(ctx, subPackageMeta) {
       watchChange(id, change) {
         logger_default.success(`[${change.event}] ${transformAbsoluteToRelative(id)}`);
       },
+      // transform(code, id, options) {
+      //   console.log(id)
+      // },
+      // 调试监听
+      buildEnd() {
+        const watchFiles = this.getWatchFiles();
+        debug?.("watchFiles count: ", watchFiles.length);
+      },
       generateBundle(_options, bundle) {
         const bundleKeys = Object.keys(bundle);
         for (const bundleKey of bundleKeys) {
           const asset = bundle[bundleKey];
-          if (bundleKey.endsWith(".css") && asset.type === "asset" && typeof asset.originalFileName === "string" && isJsOrTs(asset.originalFileName)) {
-            const newFileName = ctx.relativeSrcRoot(
-              changeFileExtension(asset.originalFileName, "wxss")
-            );
-            this.emitFile({
-              type: "asset",
-              fileName: newFileName,
-              source: asset.source
-            });
+          if (bundleKey.endsWith(".css") && asset.type === "asset") {
+            for (const originalFileName of asset.originalFileNames) {
+              if (isJsOrTs(originalFileName)) {
+                const newFileName = ctx.relativeSrcRoot(
+                  changeFileExtension(originalFileName, "wxss")
+                );
+                this.emitFile({
+                  type: "asset",
+                  fileName: newFileName,
+                  source: asset.source
+                });
+              }
+            }
             delete bundle[bundleKey];
           }
         }
       }
       // writeBundle(options, bundle) {
-      //   console.log(options, bundle)
+      //   // console.log(options, bundle)
+      //   const watchFiles = this.getWatchFiles()
+      //   console.log(watchFiles)
       // },
     },
     {
@@ -345,6 +416,7 @@ var CompilerContext = class {
   entries;
   appEntry;
   subPackageMeta;
+  aliasEntries;
   constructor(options) {
     const { cwd, isDev, inlineConfig, projectConfig, mode, packageJson } = defu(options, {
       cwd: process.cwd(),
@@ -364,13 +436,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;
   }
@@ -422,7 +495,7 @@ var CompilerContext = class {
       inlineConfig.weapp?.watch,
       {
         ignored: [
-          path4.join(this.mpDistRoot, "**")
+          path5.join(this.mpDistRoot, "**")
         ],
         cwd: this.cwd
       },
@@ -443,7 +516,13 @@ var CompilerContext = class {
           plugins: [vitePluginWeapp(this, subPackageMeta)],
           build: {
             watch: {
-              exclude: ["node_modules/**", this.mpDistRoot ? path4.join(this.mpDistRoot, "**") : "dist/**"]
+              exclude: [
+                ...defaultExcluded,
+                this.mpDistRoot ? path5.join(this.mpDistRoot, "**") : "dist/**"
+              ],
+              chokidar: {
+                ignored: [...defaultExcluded]
+              }
             },
             minify: false,
             emptyOutDir: false
@@ -482,7 +561,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, {
@@ -510,11 +589,11 @@ var CompilerContext = class {
               if (name.endsWith(".ts")) {
                 const baseFileName = removeExtension2(name);
                 if (baseFileName.endsWith(".wxs")) {
-                  return path4.normalize(baseFileName);
+                  return baseFileName;
                 }
-                return path4.normalize(addExtension2(baseFileName, ".js"));
+                return addExtension2(baseFileName, ".js");
               }
-              return path4.normalize(name);
+              return name;
             }
           },
           external
@@ -530,12 +609,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)) {
@@ -549,10 +653,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) {
@@ -561,20 +665,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: () => {
@@ -592,20 +706,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);
         }
       }
     }
@@ -617,22 +734,23 @@ 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
         };
-        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);
@@ -648,21 +766,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);
             }
           }
         }
@@ -677,29 +795,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 = "/") {