hw-weapp-compiler 1.0.18 → 1.0.20

package/README.md

@@ -14,6 +14,8 @@
 npm install hw-weapp-compiler@1 -D
 ```
 
+升级版本后如果出现 `Cannot find module`，请删除业务项目中旧的安装产物并重新执行 `npm install`，确保传递依赖与 lockfile 同步。
+
 在业务项目的 `package.json` 中添加：
 
 ```json

package/build/prod.js

@@ -3,7 +3,7 @@ const TerserPlugin = require('terser-webpack-plugin');
 const CssMinimizerPlugin = require('css-minimizer-webpack-plugin');
 const { ENV } = require('./config/constants');
 const webpackConfig = require('./webpack.config');
-const { createCompilerHandler } = require('./utils/createCompilerHandler');
+const { createCompilerHandler, runCompilerOnce } = require('./utils/createCompilerHandler');
 
 module.exports = async (opts) => {
   // 生产环境禁用 filesystem cache，与 dev 同源：output.clean 后复用旧缓存会导致副作用产物漏生成，
@@ -34,5 +34,5 @@ module.exports = async (opts) => {
     ),
   );
 
-  compiler.run(createCompilerHandler('build'));
+  await runCompilerOnce(compiler, createCompilerHandler('build'));
 };

package/build/utils/createCompilerHandler.js

@@ -48,6 +48,26 @@ function createCompilerHandler(label, { failOnError = label === 'build' } = {})
   };
 }
 
+/**
+ * 运行一次 webpack 编译，并等待异步 done 钩子及 compiler.close 完成。
+ * 上传任务挂在 done.tapPromise 上，生产命令必须等待这里结束，才能可靠输出上传错误。
+ */
+function runCompilerOnce(compiler, handler) {
+  return new Promise((resolve, reject) => {
+    compiler.run((runError, stats) => {
+      compiler.close((closeError) => {
+        try {
+          handler(runError || closeError, stats);
+          resolve(stats);
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+  });
+}
+
 module.exports = {
   createCompilerHandler,
-};
+  runCompilerOnce,
+};

package/build/utils/getWxmlAssets.js

@@ -20,25 +20,26 @@ function extractStyleUrls(style) {
 
 function getWxmlAssets(filePath, content) {
   const resolvePath = (attr, dir) => {
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
       const isAbsolutePath = PATTERNS.ABSOLUTE_PATH.test(attr);
       const request = isAbsolutePath ? attr.replace(PATTERNS.ABSOLUTE_PATH, '') : attr;
       const resolveContext = isAbsolutePath ? SRC_DIR : dir;
 
       this.resolve(resolveContext, request, async (err, result) => {
-        let res = result;
-        if (err) {
-          const fallbackPath = path.resolve(resolveContext, request);
+        try {
+          let res = result;
+          if (err) {
+            const fallbackPath = path.resolve(resolveContext, request);
 
-          if (await fse.pathExists(fallbackPath)) {
-            res = fallbackPath;
-            resolve(res);
-          } else {
-            this.emitError(err);
-            resolve(res);
+            if (await fse.pathExists(fallbackPath)) {
+              res = fallbackPath;
+            } else {
+              this.emitError(err);
+            }
           }
-        } else {
           resolve(res);
+        } catch (error) {
+          reject(error);
         }
       });
     });
@@ -46,7 +47,7 @@ function getWxmlAssets(filePath, content) {
   return new Promise((resolve, reject) => {
     let allAttrs = [];
     const parser = new htmlparser2.Parser({
-      onopentag: async (name, attributes) => {
+      onopentag: (name, attributes) => {
         const { style } = attributes;
 
         allAttrs = allAttrs.concat(
@@ -64,42 +65,46 @@ function getWxmlAssets(filePath, content) {
         reject(err);
       },
       onend: async () => {
-        const filteredAttrs = allAttrs
-          .filter((item) => !!item)
-          .map((item) => item.split('?')[0])
-          .filter((item) => !/^(?:https?:)?\/\//i.test(item))
-          .filter((item) => !/{{.*}}/.test(item))
-          .filter((item) => !/\+.*\+/.test(item));
+        try {
+          const filteredAttrs = allAttrs
+            .filter((item) => !!item)
+            .map((item) => item.split('?')[0])
+            .filter((item) => !/^(?:https?:)?\/\//i.test(item))
+            .filter((item) => !/{{.*}}/.test(item))
+            .filter((item) => !/\+.*\+/.test(item));
 
-        const assets = filteredAttrs.filter((item) => ASSET_EXT_PATTERN.test(item));
-        const wxmls = filteredAttrs.filter((item) => PATTERNS.WXS_EXT.test(item) || PATTERNS.WXML_EXT.test(item));
+          const assets = filteredAttrs.filter((item) => ASSET_EXT_PATTERN.test(item));
+          const wxmls = filteredAttrs.filter((item) => PATTERNS.WXS_EXT.test(item) || PATTERNS.WXML_EXT.test(item));
 
-        const assetsImports = [];
-        const wxmlsImports = [];
+          const assetsImports = [];
+          const wxmlsImports = [];
 
-        // 并行解析 wxml 路径
-        const wxmlResults = await Promise.all(
-          wxmls.map(async (attr) => {
-            const result = await resolvePath(attr, path.parse(filePath).dir);
-            return result ? [attr, result] : null;
-          }),
-        );
-        for (let index = 0; index < wxmlResults.length; index += 1) {
-          if (wxmlResults[index]) wxmlsImports.push(wxmlResults[index]);
-        }
+          // 并行解析 wxml 路径
+          const wxmlResults = await Promise.all(
+            wxmls.map(async (attr) => {
+              const result = await resolvePath(attr, path.parse(filePath).dir);
+              return result ? [attr, result] : null;
+            }),
+          );
+          for (let index = 0; index < wxmlResults.length; index += 1) {
+            if (wxmlResults[index]) wxmlsImports.push(wxmlResults[index]);
+          }
 
-        // 并行解析 asset 路径
-        const assetResults = await Promise.all(
-          assets.map(async (attr) => {
-            const result = await resolvePath(attr, path.parse(filePath).dir);
-            return result ? [attr, result] : null;
-          }),
-        );
-        for (let index = 0; index < assetResults.length; index += 1) {
-          if (assetResults[index]) assetsImports.push(assetResults[index]);
-        }
+          // 并行解析 asset 路径
+          const assetResults = await Promise.all(
+            assets.map(async (attr) => {
+              const result = await resolvePath(attr, path.parse(filePath).dir);
+              return result ? [attr, result] : null;
+            }),
+          );
+          for (let index = 0; index < assetResults.length; index += 1) {
+            if (assetResults[index]) assetsImports.push(assetResults[index]);
+          }
 
-        resolve([assetsImports, wxmlsImports]);
+          resolve([assetsImports, wxmlsImports]);
+        } catch (error) {
+          reject(error);
+        }
       },
     });
     parser.write(content);

package/build/utils/upload.js

@@ -19,6 +19,47 @@ const { obsConfig, ossConfig } = getConfig();
 let obsClient;
 let ossClient;
 
+function getObsResponseError(action, result) {
+  const commonMsg = result && result.CommonMsg;
+  const rawStatus = commonMsg && commonMsg.Status;
+  const status = Number(rawStatus);
+
+  if (
+    rawStatus === undefined ||
+    rawStatus === null ||
+    (typeof rawStatus === 'string' && rawStatus.trim() === '') ||
+    !Number.isFinite(status)
+  ) {
+    return new Error(`OBS ${action} failed: invalid response`);
+  }
+  if (status >= 200 && status < 300) {
+    return null;
+  }
+
+  const details = [
+    `status ${status}`,
+    commonMsg.Code && `code ${commonMsg.Code}`,
+    commonMsg.Message && commonMsg.Message,
+  ].filter(Boolean);
+  return new Error(`OBS ${action} failed with ${details.join(', ')}`);
+}
+
+function createObsCallback(action, resolve, reject) {
+  return (error, result) => {
+    if (error) {
+      reject(error);
+      return;
+    }
+
+    const responseError = getObsResponseError(action, result);
+    if (responseError) {
+      reject(responseError);
+    } else {
+      resolve(result);
+    }
+  };
+}
+
 function getObsClient() {
   if (!obsClient) {
     obsClient = new OBSClient({
@@ -56,15 +97,7 @@ function doObsUpload(file) {
         Key: compatiblePath(path.join(obsConfig.dir, path.relative(DIST_DIR, file))),
         SourceFile: file,
       },
-      (err, result) => {
-        if (err) {
-          reject(err);
-        } else if (result.CommonMsg.Status >= 300) {
-          reject(new Error(`OBS upload failed with status ${result.CommonMsg.Status}`));
-        } else {
-          resolve(result);
-        }
-      },
+      createObsCallback('upload', resolve, reject),
     );
   });
 }
@@ -75,15 +108,7 @@ async function getObsStat(file) {
         Bucket: obsConfig.bucket,
         Key: compatiblePath(path.join(obsConfig.dir, path.relative(DIST_DIR, file))),
       },
-      (err, result) => {
-        if (err) {
-          reject(err);
-        } else if (result.CommonMsg.Status < 300) {
-          resolve(result);
-        } else {
-          reject(result);
-        }
-      },
+      createObsCallback('metadata request', resolve, reject),
     );
   });
 }
@@ -162,6 +187,8 @@ async function addToUploadQueue(assets) {
 module.exports = {
   addToUploadQueue,
   _internals: {
+    createObsCallback,
+    getObsResponseError,
     uploadFile,
     uploadFiles,
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hw-weapp-compiler",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "description": "基于 webpack5 的小程序构建工具，兼容 Node.js 18~24",
   "main": "index.js",
   "bin": {
@@ -30,6 +30,7 @@
     "file-loader": "^6.2.0",
     "fs-extra": "^9.1.0",
     "htmlparser2": "^6.0.1",
+    "isobject": "3.0.1",
     "less": "4.6.7",
     "less-loader": "^8.0.0",
     "loader-utils": "^2.0.0",

package/test-support/mini-program.js

@@ -0,0 +1,49 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+
+function executeMiniProgramDist(dist, entries = ['app.js', 'pages/index/index.js']) {
+  const sandbox = {
+    console,
+    appConfig: null,
+    pageConfig: null,
+  };
+  sandbox.global = sandbox;
+  sandbox.App = (config) => {
+    sandbox.appConfig = config;
+  };
+  sandbox.Page = (config) => {
+    sandbox.pageConfig = config;
+  };
+
+  const context = vm.createContext(sandbox);
+  const moduleCache = new Map();
+
+  const load = (request, from = 'app.js') => {
+    let filename = path.posix.normalize(path.posix.join(path.posix.dirname(from), request));
+    if (!path.posix.extname(filename)) {
+      filename += '.js';
+    }
+    if (moduleCache.has(filename)) {
+      return moduleCache.get(filename).exports;
+    }
+
+    const loadedModule = { exports: {} };
+    moduleCache.set(filename, loadedModule);
+    const source = fs.readFileSync(path.join(dist, ...filename.split('/')), 'utf8');
+    const wrapper = vm.runInContext(
+      `(function (require, module, exports) { ${source}\n })`,
+      context,
+      { filename },
+    );
+    wrapper((child) => load(child, filename), loadedModule, loadedModule.exports);
+    return loadedModule.exports;
+  };
+
+  for (const entry of entries) {
+    load(`./${entry}`);
+  }
+  return sandbox;
+}
+
+module.exports = { executeMiniProgramDist };

package/test-support/project.js

@@ -0,0 +1,25 @@
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+function createTempProject(prefix = 'hw-weapp-test-') {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+
+  return {
+    root,
+    resolve(...segments) {
+      return path.join(root, ...segments);
+    },
+    write(relativePath, content) {
+      const filename = path.join(root, relativePath);
+      fs.mkdirSync(path.dirname(filename), { recursive: true });
+      fs.writeFileSync(filename, content);
+      return filename;
+    },
+    cleanup() {
+      fs.rmSync(root, { recursive: true, force: true });
+    },
+  };
+}
+
+module.exports = { createTempProject };

package/test-support/webpack.js

@@ -0,0 +1,80 @@
+const Module = require('node:module');
+const webpack = require('webpack');
+
+function runCompiler(config) {
+  const compiler = webpack(config);
+
+  return new Promise((resolve, reject) => {
+    compiler.run((runError, stats) => {
+      compiler.close((closeError) => {
+        if (runError || closeError) {
+          reject(runError || closeError);
+        } else {
+          resolve(stats);
+        }
+      });
+    });
+  });
+}
+
+function installMissingLoaderFallbacks(fallbacks) {
+  const originalResolveFilename = Module._resolveFilename;
+  const missingFallbacks = new Map();
+
+  for (const [request, fallback] of Object.entries(fallbacks)) {
+    try {
+      originalResolveFilename.call(Module, request, module, false);
+    } catch (error) {
+      missingFallbacks.set(request, fallback);
+    }
+  }
+
+  Module._resolveFilename = function resolveFilename(request, parent, isMain, options) {
+    if (missingFallbacks.has(request)) {
+      return missingFallbacks.get(request);
+    }
+    return originalResolveFilename.call(this, request, parent, isMain, options);
+  };
+
+  return () => {
+    Module._resolveFilename = originalResolveFilename;
+  };
+}
+
+function createAssetLoaderFallbacks(project) {
+  const fileLoader = project.write(
+    'test-file-loader.js',
+    [
+      "const path = require('path');",
+      'module.exports = function loader(content) {',
+      "  const name = path.relative(this.rootContext, this.resourcePath).replace(/\\\\/g, '/');",
+      '  this.emitFile(name, content);',
+      '  return `module.exports = ${JSON.stringify(name)};`;',
+      '};',
+      'module.exports.raw = true;',
+    ].join('\n'),
+  );
+  const urlLoader = project.write(
+    'test-url-loader.js',
+    [
+      "const crypto = require('crypto');",
+      "const path = require('path');",
+      'module.exports = function loader(content) {',
+      "  const hash = crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);",
+      '  const info = path.parse(this.resourcePath);',
+      '  const name = `assets/${info.name}.${hash}${info.ext}`;',
+      '  this.emitFile(name, content);',
+      '  return `module.exports = ${JSON.stringify(name)};`;',
+      '};',
+      'module.exports.raw = true;',
+    ].join('\n'),
+  );
+
+  return { 'file-loader': fileLoader, 'url-loader': urlLoader };
+}
+
+module.exports = {
+  createAssetLoaderFallbacks,
+  installMissingLoaderFallbacks,
+  runCompiler,
+};