hw-weapp-compiler 1.0.8 → 1.0.10

package/README.md

@@ -16,14 +16,14 @@ npm i weapp-compiler@2.x -D
 
 ```bash
 # 开发调试
-npm run dev           # 测试环境
-npm run dev -- -s     # 预发环境
-npm run dev -- -p     # 生产环境
+npm run dev        # 测试环境
+npm run dev -s     # 预发环境
+npm run dev -p     # 生产环境
 
 # 生产发布
-npm run build -- -d   # 测试环境
-npm run build -- -s   # 预发环境
-npm run build         # 生产环境
+npm run build -d   # 测试环境
+npm run build -s   # 预发环境
+npm run build      # 生产环境
 ```
 
 ## 配置

package/build/config/getEntries.js

@@ -4,110 +4,139 @@ const { addNodeModulesUsingComponent } = require('../utils/isNodeModulesUsingCom
 const { compatiblePath } = require('../utils/compatiblePath');
 const { getAppConfig } = require('./getAppConfig');
 const { PATTERNS, SRC_DIR } = require('./constants');
-const appConfig = getAppConfig();
 
-const entries = {
-  app: path.resolve(SRC_DIR, 'app'),
-};
-const visitedJsonFiles = new Set();
-const entryFiles = [entries.app];
+const appConfig = getAppConfig();
 
-const addEntry = (entryKey, filePath) => {
-  entries[compatiblePath(entryKey)] = filePath;
-  entryFiles.push(filePath);
-};
+// 惰性异步初始化：entry / usingComponents 收集改为 Promise.all 并发读 json，
+// 避免在 webpack 启动前对深组件树做同步串行 readJSONSync/existsSync/require.resolve。
+let entriesPromise = null;
 
-const addUsingComponents = (components, parent) => {
-  Object.keys(components).forEach((key) => {
-    const originalFilePath = components[key];
-    let filePath = components[key];
+function buildBaseEntries() {
+  const entries = { app: path.resolve(SRC_DIR, 'app') };
+  const entryFiles = [entries.app];
 
-    if (!PATTERNS.PLUGIN_PATH.test(filePath)) {
-      if (PATTERNS.ABSOLUTE_PATH.test(filePath)) {
-        filePath = path.resolve(SRC_DIR, filePath.replace(PATTERNS.ABSOLUTE_PATH, ''));
-      }
+  const addEntry = (entryKey, filePath) => {
+    entries[compatiblePath(entryKey)] = filePath;
+    entryFiles.push(filePath);
+  };
 
-      if (fse.existsSync(`${path.resolve(parent, filePath)}.js`)) {
-        filePath = path.resolve(parent, filePath);
-      } else {
-        try {
-          filePath = require.resolve(filePath);
-          filePath = filePath.replace(PATTERNS.JS_EXT, '');
-        } catch (error) {
-          throw new Error(
-            `解析 usingComponents "${key}" 的组件路径 "${originalFilePath}" 失败，父级目录：${parent}\n${error.message}`,
-          );
-        }
-      }
+  // pages
+  (appConfig.pages || []).forEach((page) => {
+    addEntry(page, path.resolve(SRC_DIR, page));
+  });
 
-      if (fse.existsSync(`${filePath}.json`)) {
-        // eslint-disable-next-line
-        readUsingComponents(`${filePath}.json`);
-      }
+  // tabbar
+  if (fse.existsSync(path.resolve(SRC_DIR, 'custom-tab-bar/index.js'))) {
+    addEntry('custom-tab-bar/index', path.resolve(SRC_DIR, 'custom-tab-bar/index'));
+  }
 
-      let entryKey = filePath;
+  // subpackages
+  (appConfig.subpackages || []).forEach((pkg) => {
+    (pkg.pages || []).forEach((page) => {
+      addEntry(path.join(pkg.root, page), path.resolve(SRC_DIR, pkg.root, page));
+    });
+  });
 
-      if (PATTERNS.NODE_MODULES.test(filePath)) {
-        entryKey = compatiblePath(filePath).split('/node_modules/')[1];
+  return { entries, entryFiles };
+}
 
-        addNodeModulesUsingComponent(entryKey);
-      } else {
-        entryKey = path.relative(SRC_DIR, filePath);
-      }
+function resolveUsingComponentPath(componentKey, componentPath, parent) {
+  let filePath = componentPath;
+  const originalFilePath = componentPath;
 
-      entryKey = compatiblePath(entryKey);
+  if (!PATTERNS.PLUGIN_PATH.test(filePath)) {
+    if (PATTERNS.ABSOLUTE_PATH.test(filePath)) {
+      filePath = path.resolve(SRC_DIR, filePath.replace(PATTERNS.ABSOLUTE_PATH, ''));
+    }
 
-      entries[entryKey] = filePath;
+    if (fse.existsSync(`${path.resolve(parent, filePath)}.js`)) {
+      filePath = path.resolve(parent, filePath);
+    } else {
+      try {
+        filePath = require.resolve(filePath);
+        filePath = filePath.replace(PATTERNS.JS_EXT, '');
+      } catch (error) {
+        throw new Error(
+          `解析 usingComponents "${componentKey}" 的组件路径 "${originalFilePath}" 失败，父级目录：${parent}\n${error.message}`,
+        );
+      }
     }
-  });
-};
-const readUsingComponents = (file) => {
-  const jsonFile = path.resolve(file);
 
-  if (visitedJsonFiles.has(jsonFile)) {
-    return;
+    return filePath;
   }
+  return null;
+}
 
-  visitedJsonFiles.add(jsonFile);
-
-  const json = fse.readJSONSync(file);
+async function collectUsingComponents(entryFiles, entries) {
+  const visitedJsonFiles = new Set();
+  const jsonQueue = [];
 
-  if (json.usingComponents) {
-    addUsingComponents(json.usingComponents, path.parse(file).dir);
-  }
-};
-const readEntryUsingComponents = (filePath) => {
-  const jsonFile = `${filePath}.json`;
+  entryFiles.forEach((filePath) => {
+    const jsonFile = `${filePath}.json`;
+    if (fse.existsSync(jsonFile)) {
+      jsonQueue.push(jsonFile);
+    }
+  });
 
-  if (fse.existsSync(jsonFile)) {
-    readUsingComponents(jsonFile);
-  }
-};
+  // 并发读 json，结果中新的 usingComponents 继续入队，直到队列空
+  while (jsonQueue.length > 0) {
+    const batch = jsonQueue.splice(0);
+    const results = await Promise.all(
+      batch.map(async (file) => {
+        const jsonFile = path.resolve(file);
+        if (visitedJsonFiles.has(jsonFile)) {
+          return null;
+        }
+        visitedJsonFiles.add(jsonFile);
+        const json = await fse.readJSON(jsonFile);
+        return { dir: path.parse(jsonFile).dir, usingComponents: json.usingComponents || {} };
+      }),
+    );
+
+    const newComponents = [];
+    results.filter(Boolean).forEach(({ dir, usingComponents }) => {
+      Object.keys(usingComponents).forEach((key) => {
+        newComponents.push({ key, value: usingComponents[key], dir });
+      });
+    });
+
+    // 同步解析路径（existsSync/require.resolve 不宜并发但单 round 内串行，正是被批处理掉的是 readJSON）
+    newComponents.forEach(({ key, value, dir }) => {
+      const resolved = resolveUsingComponentPath(key, value, dir);
+      if (!resolved) {
+        return;
+      }
 
-// pages
-(appConfig.pages || []).forEach((page) => {
-  addEntry(page, path.resolve(SRC_DIR, page));
-});
+      if (fse.existsSync(`${resolved}.json`)) {
+        jsonQueue.push(`${resolved}.json`);
+      }
 
-// tabbar
-if (fse.existsSync(path.resolve(SRC_DIR, 'custom-tab-bar/index.js'))) {
-  addEntry('custom-tab-bar/index', path.resolve(SRC_DIR, 'custom-tab-bar/index'));
+      let entryKey;
+      if (PATTERNS.NODE_MODULES.test(resolved)) {
+        entryKey = compatiblePath(resolved).split('/node_modules/')[1];
+        addNodeModulesUsingComponent(entryKey);
+      } else {
+        entryKey = path.relative(SRC_DIR, resolved);
+      }
+      entryKey = compatiblePath(entryKey);
+      entries[entryKey] = resolved;
+    });
+  }
 }
 
-// subpackages
-(appConfig.subpackages || []).forEach((pkg) => {
-  (pkg.pages || []).forEach((page) => {
-    addEntry(path.join(pkg.root, page), path.resolve(SRC_DIR, pkg.root, page));
-  });
-});
-
-// usingComponents
-entryFiles.forEach((filePath) => {
-  readEntryUsingComponents(filePath);
-});
-
 function getEntries() {
-  return entries;
+  if (!entriesPromise) {
+    const { entries, entryFiles } = buildBaseEntries();
+    // 收集失败时清空缓存，允许下次 getEntries() 重新尝试，
+    // 避免模块级单例永久持有 rejected promise 导致整个进程卡死。
+    entriesPromise = collectUsingComponents(entryFiles, entries)
+      .then(() => entries)
+      .catch((error) => {
+        entriesPromise = null;
+        throw error;
+      });
+  }
+  return entriesPromise;
 }
 
 module.exports = {

package/build/dev.js

@@ -1,28 +1,38 @@
 const path = require('path');
-const fse = require('fs-extra');
 const webpack = require('webpack');
-const { ENV, DIST_DIR } = require('./config/constants');
+const { ENV } = require('./config/constants');
 const webpackConfig = require('./webpack.config');
 const { createCompilerHandler } = require('./utils/createCompilerHandler');
 
-module.exports = (opts) => {
-  // 开发模式启动时清理一次 dist 目录
-  if (fse.existsSync(DIST_DIR)) {
-    const files = fse.readdirSync(DIST_DIR);
-    files.forEach((item) => {
-      if (!/^(project\.config\.json|weapp\.env\.json)$/.test(item)) {
-        fse.removeSync(path.resolve(DIST_DIR, item));
-      }
-    });
-  } else {
-    fse.mkdirSync(DIST_DIR);
-  }
-
+module.exports = async (opts) => {
+  // dev 同样启用 filesystem cache，watch 重建复用缓存，二次启动显著提速
   const compiler = webpack(
-    webpackConfig(
+    await webpackConfig(
       {
         mode: ENV.DEV,
         devtool: 'cheap-module-source-map',
+        output: {
+          clean: {
+            keep: /^(project\.config\.json|weapp\.env\.json)$/,
+          },
+        },
+        cache: {
+          type: 'filesystem',
+          cacheDirectory: path.resolve(process.cwd(), 'node_modules/.cache/webpack'),
+          buildDependencies: {
+            // webpack.config.js 及其 require 的 getEntries.js / loader / plugin 都作为
+            // 缓存依赖，本编译器自身代码改动后即时整体失效，避免复用旧 loader 输出。
+            config: [
+              path.resolve(__dirname, 'webpack.config.js'),
+              path.resolve(__dirname, 'config/getEntries.js'),
+              path.resolve(__dirname, 'plugin/index.js'),
+              path.resolve(__dirname, 'loader/js-loader.js'),
+              path.resolve(__dirname, 'loader/wxs-loader.js'),
+              path.resolve(__dirname, 'loader/wxml-loader.js'),
+            ],
+          },
+          name: `dev-${process.version.slice(0, 6)}`,
+        },
       },
       opts || {},
     ),

package/build/loader/js-loader.js

@@ -9,8 +9,6 @@ const fse = require('fs-extra');
 const { getEntries } = require('../config/getEntries');
 const { loadModule } = require('../utils/loadModule');
 
-const entries = getEntries();
-
 module.exports = async function loader(source) {
   this.cacheable(true);
   const filePath = this.resourcePath;
@@ -19,6 +17,8 @@ module.exports = async function loader(source) {
 
   const imports = [sourceStr];
 
+  const entries = await getEntries();
+
   if (Object.values(entries).indexOf(path.resolve(fileInfo.dir, fileInfo.name)) !== -1) {
     const exts = ['.less', '.wxss', '.css', '.json', '.wxml'];
     const checks = await Promise.all(

package/build/loader/wxs-loader.js

@@ -3,24 +3,81 @@
  *
  * 解析 wxs 文件中的 require 调用，将被引用的模块加入 webpack 依赖图，
  * 确保构建时 wxs 的依赖被正确追踪。
+ *
+ * 实现说明：用 acorn 做 AST 解析后再遍历 CallExpression，仅收集 require 的
+ * 字面量参数。相比原先的正则 `require\(("|').*?("|')\)`，可避免误匹配注释、
+ * 字符串里的 require(...)，也不受跨行/模板字符串影响。
+ *
+ * 注意：wxs 以 script 语法解析，若含 import/export 等 module 语法 parse 会失败 ——
+ * 此时不能直接丢依赖（会静默让运行时找不到模块），必须回退到正则兜底，并 emitWarning
+ * 暴露问题，绝不静默吞掉。
  */
 const path = require('path');
+const acorn = require('acorn');
+const walk = require('acorn-walk');
 const { loadModule } = require('../utils/loadModule');
 
+const REQUIRE_RE = /require\(("|')(.*?)\1\)/g;
+
+function collectStaticRequires(content) {
+  const requires = [];
+  let ast;
+  let parseError = null;
+  try {
+    ast = acorn.parse(content, { ecmaVersion: 'latest', sourceType: 'script' });
+  } catch (error) {
+    parseError = error;
+    return { requires, parseError };
+  }
+
+  walk.simple(ast, {
+    CallExpression(node) {
+      if (node.callee.type !== 'Identifier' || node.callee.name !== 'require') {
+        return;
+      }
+      const arg = node.arguments[0];
+      if (arg && arg.type === 'Literal' && typeof arg.value === 'string') {
+        requires.push(arg.value);
+      }
+    },
+  });
+
+  return { requires, parseError };
+}
+
+function collectRequiresByRegex(content) {
+  const result = [];
+  let match;
+  // eslint-disable-next-line no-cond-assign
+  while ((match = REQUIRE_RE.exec(content)) !== null) {
+    result.push(match[2]);
+  }
+  return result;
+}
+
 module.exports = async function loader(source) {
   this.cacheable(true);
   const filePath = this.resourcePath;
   const content = source.toString();
   const fileInfo = path.parse(filePath);
 
-  const requires = content.match(/require\(("|').*?("|')\)/g) || [];
+  let { requires, parseError } = collectStaticRequires(content);
+  if (parseError) {
+    // AST 解析失败（如含 module 语法），回退正则兜底，避免静默丢依赖致运行时缺模块。
+    this.emitWarning(
+      new Error(
+        `wxs-loader: AST 解析失败，已回退正则匹配 require。建议改写为合法 script 语法。\n文件：${filePath}\n原因：${parseError.message}`,
+      ),
+    );
+    requires = collectRequiresByRegex(content);
+  } else if (requires.length === 0) {
+    // AST 未收集到任何 require（极少见但稳妥），同样正则兜底一次。
+    requires = collectRequiresByRegex(content);
+  }
 
   await Promise.all(
-    requires.map(async (item) => {
-      const file = path.resolve(
-        fileInfo.dir,
-        item.replace(/^((require\(')|(require\("))/g, '').replace(/(('\))|("\)))$/g, ''),
-      );
+    requires.map(async (reqPath) => {
+      const file = path.resolve(fileInfo.dir, reqPath);
       await loadModule.call(this, file);
     }),
   );

package/build/plugin/index.js

@@ -198,6 +198,11 @@ class WeappPlugin {
 
           const { flags, subpackages } = detectCommonModules(items);
 
+          // 注入逻辑必须对每个 JS/WXSS chunk 都跑（每个 chunk 都要 `var self = global`，
+          // 分包内 chunk 都要 `require(subpackage_common)`，app.js 的公共引用序等）；
+          // 这些注入依赖每次从干净的 webpack module source 重做，不能按 changedAssets 增量跳过，
+          // 否则增量 rebuild 后会漏注入。
+          // 优化点：比较注入前后内容，仅在确实变化时才 updateAsset，减少无谓的 asset 重写与下游 hash 抖动。
           await Promise.all(
             items.map(async (asset) => {
               const assetName = compatiblePath(asset.name);
@@ -207,10 +212,13 @@ class WeappPlugin {
                 content = content.toString();
               }
 
-              content = injectGlobalModules(content, assetName, flags);
-              content = injectSubpackageRequires(content, assetName, subpackages);
+              const before = content;
+              const after = injectGlobalModules(content, assetName, flags);
+              const finalContent = injectSubpackageRequires(after, assetName, subpackages);
 
-              compilation.updateAsset(asset.name, new RawSource(content));
+              if (finalContent !== before) {
+                compilation.updateAsset(asset.name, new RawSource(finalContent));
+              }
             }),
           );
         },

package/build/prod.js

@@ -7,9 +7,9 @@ const webpackConfig = require('./webpack.config');
 const { createCompilerHandler } = require('./utils/createCompilerHandler');
 const { getBuildEnv } = require('./utils/buildEnv');
 
-module.exports = (opts) => {
+module.exports = async (opts) => {
   const compiler = webpack(
-    webpackConfig(
+    await webpackConfig(
       {
         mode: ENV.PROD,
         devtool: false,
@@ -32,7 +32,16 @@ module.exports = (opts) => {
           type: 'filesystem',
           cacheDirectory: path.resolve(process.cwd(), 'node_modules/.cache/webpack'),
           buildDependencies: {
-            config: [path.resolve(__dirname, 'webpack.config.js')],
+            // webpack.config.js 及其 require 的 getEntries.js / loader / plugin 都作为
+            // 缓存依赖，本编译器自身代码改动后即时整体失效，避免复用旧 loader 输出。
+            config: [
+              path.resolve(__dirname, 'webpack.config.js'),
+              path.resolve(__dirname, 'config/getEntries.js'),
+              path.resolve(__dirname, 'plugin/index.js'),
+              path.resolve(__dirname, 'loader/js-loader.js'),
+              path.resolve(__dirname, 'loader/wxs-loader.js'),
+              path.resolve(__dirname, 'loader/wxml-loader.js'),
+            ],
           },
           name: `${getBuildEnv()}-${process.version.slice(0, 6)}`,
         },

package/build/utils/createCompilerHandler.js

@@ -35,6 +35,8 @@ function createCompilerHandler(label, { failOnError = label === 'build' } = {})
       console.warn(
         stats.toString({
           chunks: false,
+          modules: false,
+          entrypoints: false,
           colors: true,
           warnings: true,
           errors: false,

package/build/utils/isSubpackage.js

@@ -3,21 +3,25 @@ const { getAppConfig } = require('../config/getAppConfig');
 
 const appConfig = getAppConfig();
 
-function isSubpackage(file) {
-  let isSub = false;
-
-  (appConfig.subpackages || []).forEach((pkg) => {
-    let { root } = pkg;
-
-    if (!/\/$/.test(root)) {
-      root = `${root}/`;
-    }
+// 预归一化分包 root 为带尾斜杠的相对路径集合，让 isSubpackage 退化为 O(subpackages) 前缀判断
+// （splitChunks 的 cacheGroup.test 会对每个 module 调用，原实现线性扫描且每次重新 normalize）。
+// root 为空视为「不分包」，跳过该 pkg，否则 '' 会被归一化成 '/'，导致所有主包文件被误判为子包。
+const subpackageRoots = (appConfig.subpackages || [])
+  .map((pkg) => pkg.root || '')
+  .filter(Boolean)
+  .map((root) => {
+    const normalized = compatiblePath(root);
+    return normalized.endsWith('/') ? normalized : `${normalized}/`;
+  });
 
-    if (compatiblePath(file).indexOf(root) === 0) {
-      isSub = true;
+function isSubpackage(file) {
+  const f = compatiblePath(file);
+  for (let i = 0; i < subpackageRoots.length; i += 1) {
+    if (subpackageRoots[i] && f.indexOf(subpackageRoots[i]) === 0) {
+      return true;
     }
-  });
-  return isSub;
+  }
+  return false;
 }
 module.exports = {
   isSubpackage,

package/build/webpack.config.js

@@ -20,10 +20,15 @@ const { ENV, PATTERNS, ASSET_EXT_PATTERN, SRC_DIR, DIST_DIR, ASSETS_DIR } = requ
 
 const defaultCopyFiles = ['project.config.json', 'sitemap.json'];
 
-module.exports = (options, { analyzer, quiet } = {}) => {
+module.exports = async (options, { analyzer, quiet } = {}) => {
   const appConfig = getAppConfig();
-  const { alias, publicPath = 'auto', copyFiles = [] } = getConfig();
-  const entries = getEntries();
+  const { alias = {}, publicPath = 'auto', copyFiles = [] } = getConfig();
+
+  // swc externalHelpers 产物里有 require("@swc/helpers/..."),本包作为编译器被 npm 安装到
+  // 用户项目时,@swc/helpers 通常落在本包内层 node_modules 而非用户项目顶层,用户源码
+  // 所在目录向上解析不到 → 构建直接 Module not found。固定指到本包内的绝对路径。
+  alias['@swc/helpers'] = path.dirname(require.resolve('@swc/helpers/package.json'));
+  const entries = await getEntries();
 
   const assetsName = (resourcePath) => {
     if (PATTERNS.NODE_MODULES.test(resourcePath)) {
@@ -206,6 +211,9 @@ module.exports = (options, { analyzer, quiet } = {}) => {
       stats: {
         errorDetails: true,
       },
+      performance: {
+        hints: false,
+      },
       output: {
         path: DIST_DIR,
         publicPath,
@@ -306,20 +314,20 @@ module.exports = (options, { analyzer, quiet } = {}) => {
             test: /\.(js)$/i,
             use: [
               {
-                loader: 'babel-loader',
+                loader: require.resolve('swc-loader'),
                 options: {
                   cacheDirectory: true,
-                  cacheCompression: false,
-                  presets: [
-                    [
-                      '@babel/preset-env',
-                      {
-                        targets: { chrome: 53 },
-                        modules: 'commonjs',
-                      },
-                    ],
-                  ],
-                  plugins: ['@babel/plugin-transform-runtime'],
+                  // 用 env 模式按 chrome 53 降级，等价原 babel preset-env targets.chrome53。
+                  // swc 不再产出 regeneratorRuntime,而是 require("@swc/helpers/...") 配原生生
+                  // 成器（chrome 53 原生支持 function*）,由上方 resolve.alias 固定解析到本包内。
+                  env: {
+                    targets: { chrome: '53' },
+                  },
+                  jsc: {
+                    parser: { syntax: 'ecmascript' },
+                    externalHelpers: true,
+                  },
+                  module: { type: 'commonjs' },
                 },
               },
               {
@@ -342,4 +350,4 @@ module.exports = (options, { analyzer, quiet } = {}) => {
     },
     options,
   );
-};
+};

package/index.js

@@ -34,14 +34,20 @@ program.command('dev').action(() => {
     mode: ENV.DEV,
     ...program.opts(),
   });
-  compiler.dev(program.opts());
+  compiler.dev(program.opts()).catch((err) => {
+    console.error(err);
+    process.exitCode = 1;
+  });
 });
 program.command('build').action(() => {
   setBuildEnv({
     mode: ENV.PROD,
     ...program.opts(),
   });
-  compiler.prod(program.opts());
+  compiler.prod(program.opts()).catch((err) => {
+    console.error(err);
+    process.exitCode = 1;
+  });
 });
 
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hw-weapp-compiler",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "基于 webpack5 的小程序构建工具，兼容 Node.js 14~24",
   "main": "index.js",
   "bin": {
@@ -15,12 +15,12 @@
     "node": ">=14.17.1"
   },
   "dependencies": {
-    "@babel/core": "^7.13.14",
-    "@babel/plugin-transform-runtime": "^7.13.10",
-    "@babel/preset-env": "^7.13.12",
+    "@swc/core": "^1.15.43",
+    "@swc/helpers": "^0.5.23",
+    "acorn": "^8.17.0",
+    "acorn-walk": "^8.3.5",
     "ali-oss": "^6.15.2",
     "autoprefixer": "^10.3.4",
-    "babel-loader": "^8.2.2",
     "chalk": "^4.1.0",
     "commander": "^7.2.0",
     "copy-webpack-plugin": "^8.1.0",
@@ -37,6 +37,7 @@
     "postcss-loader": "^5.2.0",
     "postcss-preset-env": "^9.6.0",
     "progress": "^2.0.3",
+    "swc-loader": "^0.2.7",
     "terser-webpack-plugin": "^5.6.1",
     "throttle-debounce": "^3.0.1",
     "url-loader": "^4.1.1",