hw-weapp-compiler 1.0.26 → 1.0.27

package/README.md

@@ -78,3 +78,31 @@ module.exports = {
   ]
 }
 ```
+
+## 独立分包（受限支持）
+
+在 `src/app.json` 中配置 `independent: true`，`subpackages` 和 `subPackages` 两种写法均可：
+
+```json
+{
+  "pages": ["pages/index/index"],
+  "subpackages": [{
+    "root": "activity",
+    "pages": ["pages/index/index"],
+    "independent": true
+  }]
+}
+```
+
+主包和普通分包沿用原有编译流程；每个独立分包单独编译，生成包内的 runtime、公共 JS/WXSS 和资源。
+页面及组件入口会自动加载所需的包内公共文件。没有独立分包时仍使用单份 webpack 配置。
+
+- 独立分包的原生组件、JSON、WXML、WXS、样式和本地资源必须位于自己的 `root` 内；跨包原生引用会在构建时报错。
+- `usingComponents` 需显式写在独立包的页面或组件 JSON 中，使用包内相对路径或 `/activity/...` 路径。不自动搬迁主包组件、npm 原生组件或插件组件。
+- 可以静态引用包外的普通 JS 模块和纯 JS npm 依赖，编译器会将它们编入该独立包。依赖若继续引用包外样式、JSON 等原生文件，也会报错。同一包内共享模块实例，不同包之间不共享模块缓存。
+- 本地资源自动输出到 `<root>/assets/`，引用使用小程序根路径；配置 CDN `publicPath` 时沿用 CDN。动态拼接的资源路径不能自动收集，需通过 `copyFiles` 将包内资源复制到同一包内，例如 `{ from: 'activity/images', to: 'activity/images' }`。
+- 业务代码不能假设主包的 `App` 已初始化，也不能依赖 `app.wxss` 的样式。本版不支持独立包内产生异步 chunk 的动态 `import()` 或分包异步化。
+- 修改已有 JS、模板、样式或资源可以增量构建；修改分包配置、增删页面或组件、改变组件依赖关系后，需要重启 `dev`。
+
+分包的 `root` 不能重复或互相嵌套。各包会重复编入自身使用的共享 JS/npm 依赖，因此可能增加总产物体积和编译耗时。
+多包构建只在启动时统一清理 `dist`；`-a` 分析模式会生成各包的 `bundle-report.html` 静态报告。

package/build/config/getAppConfig.js

@@ -7,6 +7,7 @@ let _appConfig = null;
 function getAppConfig() {
   if (!_appConfig) {
     _appConfig = fse.readJSONSync(path.resolve(SRC_DIR, 'app.json'));
+    _appConfig.subpackages = _appConfig.subpackages || _appConfig.subPackages || [];
   }
   return _appConfig;
 }

package/build/config/getEntries.js

@@ -4,8 +4,11 @@ const { addNodeModulesUsingComponent } = require('../utils/isNodeModulesUsingCom
 const { compatiblePath } = require('../utils/compatiblePath');
 const { getAppConfig } = require('./getAppConfig');
 const { PATTERNS, SRC_DIR } = require('./constants');
+const { getIndependentRoots, isWithinRoot } = require('../utils/independentPackages');
 
 const appConfig = getAppConfig();
+const independentRoots = getIndependentRoots(appConfig);
+const ownerOf = (file) => independentRoots.find((root) => isWithinRoot(path.relative(SRC_DIR, file), root));
 
 // 惰性异步初始化：entry / usingComponents 收集改为 Promise.all 并发读 json，
 // 避免在 webpack 启动前对深组件树做同步串行 readJSONSync/existsSync/require.resolve。
@@ -22,6 +25,9 @@ function buildBaseEntries() {
 
   // pages
   (appConfig.pages || []).forEach((page) => {
+    if (ownerOf(path.resolve(SRC_DIR, page))) {
+      throw new Error(`主包 pages 不能包含独立分包页面：${page}`);
+    }
     addEntry(page, path.resolve(SRC_DIR, page));
   });
 
@@ -33,6 +39,9 @@ function buildBaseEntries() {
   // subpackages
   (appConfig.subpackages || []).forEach((pkg) => {
     (pkg.pages || []).forEach((page) => {
+      if (pkg.independent && !isWithinRoot(compatiblePath(path.join(pkg.root, page)), compatiblePath(pkg.root).replace(/\/$/, ''))) {
+        throw new Error(`独立分包页面越界：${pkg.root}/${page}`);
+      }
       addEntry(path.join(pkg.root, page), path.resolve(SRC_DIR, pkg.root, page));
     });
   });
@@ -102,10 +111,18 @@ async function collectUsingComponents(entryFiles, entries) {
 
     // 同步解析路径（existsSync/require.resolve 不宜并发但单 round 内串行，正是被批处理掉的是 readJSON）
     newComponents.forEach(({ key, value, dir }) => {
+      const owner = ownerOf(dir);
+      if (owner && PATTERNS.PLUGIN_PATH.test(value)) {
+        throw new Error(`独立分包 ${owner} 仅支持包内原生组件：${value}`);
+      }
       const resolved = resolveUsingComponentPath(key, value, dir);
       if (!resolved) {
         return;
       }
+      const targetOwner = ownerOf(resolved);
+      if (owner !== targetOwner && (owner || targetOwner)) {
+        throw new Error(`独立分包组件引用越界：${dir} -> ${value}。请将原生组件及其依赖放在同一独立包内。`);
+      }
 
       if (fse.existsSync(`${resolved}.json`)) {
         jsonQueue.push(`${resolved}.json`);

package/build/plugin/index.js

@@ -9,7 +9,8 @@ const { RawSource } = require('webpack-sources');
 
 const { addToUploadQueue } = require('../utils/upload');
 const { compatiblePath } = require('../utils/compatiblePath');
-const { PATTERNS, ASSET_EXT_PATTERN, ASSETS_DIR } = require('../config/constants');
+const { isWithinRoot } = require('../utils/independentPackages');
+const { PATTERNS, ASSET_EXT_PATTERN, ASSETS_DIR, SRC_DIR } = require('../config/constants');
 
 const pluginName = 'WeappCompilerPlugin';
 
@@ -161,17 +162,148 @@ function injectSubpackageRequires(content, assetName, subpackages) {
   return result;
 }
 
+// 独立包没有 app.js/app.wxss，每个页面和组件都必须加载自己的入口依赖。
+function injectIndependentEntrypoints(compilation) {
+  compilation.entrypoints.forEach((entrypoint, name) => {
+    const jsName = `${name}.js`;
+    const wxssName = `${name}.wxss`;
+    const files = [...new Set(entrypoint.getFiles())];
+    const js = compilation.getAsset(jsName);
+    if (js) {
+      const requires = files.filter((file) => file !== jsName && PATTERNS.JS_EXT.test(file))
+        .map((file) => `require(${JSON.stringify(getRelativeModulePath(path.dirname(jsName), file))});\n`);
+      compilation.updateAsset(jsName, new RawSource(requires.join('') + js.source.source().toString()));
+    }
+    const imports = files.filter((file) => file !== wxssName && PATTERNS.WXSS_EXT.test(file))
+      .map((file) => `@import ${JSON.stringify(getRelativeModulePath(path.dirname(wxssName), file))};\n`);
+    if (imports.length) {
+      const wxss = compilation.getAsset(wxssName);
+      const source = new RawSource(imports.join('') + (wxss ? wxss.source.source().toString() : ''));
+      if (wxss) compilation.updateAsset(wxssName, source);
+      else compilation.emitAsset(wxssName, source);
+    }
+  });
+}
+
+function validatePackageBoundary(compilation, independentRoot, independentRoots) {
+  const errors = new Set();
+  const checkFile = (file, native) => {
+    if (!file) return;
+    const relative = compatiblePath(path.relative(SRC_DIR, file.split('?')[0]));
+    if (independentRoot) {
+      if (native && !isWithinRoot(relative, independentRoot)) {
+        errors.add(`独立分包 ${independentRoot} 原生文件引用越界：${relative}。请将组件、模板、样式和本地资源放在包内。`);
+      }
+    } else if (independentRoots.some((root) => isWithinRoot(relative, root))) {
+      errors.add(`主包或普通分包不能引用独立分包源文件：${relative}`);
+    }
+  };
+  const checkNativeDependencies = (files) => {
+    for (const file of files || []) {
+      if (/\.(wxml|wxs|wxss|css|less)$/i.test(file) || ASSET_EXT_PATTERN.test(file)) checkFile(file, true);
+    }
+  };
+  for (const module of compilation.modules) {
+    // 普通 JS 可以从共享源码/npm 编入包内；原生文件不能自动搬迁。
+    checkFile(module.resource, module.resource && !/\.[cm]?js(?:\?|$)/i.test(module.resource));
+  }
+  // less 的 @import 等依赖不一定是 webpack module；不检查 package.json 等构建元数据。
+  checkNativeDependencies(compilation.fileDependencies);
+  if (independentRoot) {
+    for (const chunk of compilation.chunks) {
+      if (!chunk.canBeInitial()) errors.add(`独立分包 ${independentRoot} 暂不支持动态 import 或其他异步 chunk。请使用静态依赖。`);
+    }
+  }
+  compilation.getAssets().forEach(({ name, source }) => {
+    const owner = independentRoots.find((root) => isWithinRoot(name, root)) || '';
+    if (owner !== independentRoot) errors.add(`分包产物越界：${independentRoot || '主包'} -> ${name}`);
+    if (!independentRoot || !PATTERNS.JSON_EXT.test(name)) return;
+    let json;
+    try { json = JSON.parse(source.source().toString()); } catch (_) { return; }
+    Object.values(json.usingComponents || {}).forEach((request) => {
+      const target = path.posix.normalize(request.startsWith('/')
+        ? request.slice(1) : path.posix.join(path.posix.dirname(compatiblePath(name)), request));
+      if (!isWithinRoot(target, independentRoot) || !compilation.getAsset(`${target}.js`)) {
+        errors.add(`独立分包组件引用无效：${name} -> ${request}。仅支持包内组件，新增组件后请重启 dev。`);
+      }
+    });
+  });
+  errors.forEach((message) => compilation.errors.push(new Error(message)));
+}
+
 class WeappPlugin {
-  constructor() {}
+  constructor({
+    quiet = false,
+    waitForUpload = false,
+    independentRoot = '',
+    independentRoots = [],
+    uploadBarrier = null,
+  } = {}) {
+    this.quiet = quiet;
+    this.waitForUpload = waitForUpload;
+    this.independentRoot = independentRoot;
+    this.independentRoots = independentRoots;
+    this.uploadBarrier = uploadBarrier;
+  }
 
   apply(compiler) {
     let obsAssets = [];
 
-    compiler.hooks.done.tap(pluginName, () => {
-      addToUploadQueue([...obsAssets]);
+    const enqueueAssets = (stats) => {
+      const assets = [...obsAssets];
       obsAssets = [];
-    });
 
+      // production MultiCompiler 共享同一个屏障：所有 child 都成功后才统一上传。
+      // fatal error 不会触发 done，remaining 也就不会归零，其他 child 不会误上传。
+      if (this.uploadBarrier) {
+        const barrier = this.uploadBarrier;
+        const hasErrors = !!(stats && stats.hasErrors());
+        barrier.remaining -= 1;
+        barrier.failed = barrier.failed || hasErrors;
+        if (!hasErrors) barrier.assets.push(...assets);
+
+        if (barrier.remaining !== 0 || barrier.failed) {
+          return Promise.resolve();
+        }
+
+        const completedAssets = [...barrier.assets];
+        barrier.assets = [];
+        return addToUploadQueue(completedAssets, {
+          quiet: this.quiet,
+          logWhenIdle: this.waitForUpload,
+          failOnError: this.waitForUpload,
+        });
+      }
+
+      // 编译产物不完整时不上传资源，并让 webpack 保留原始 stats 错误详情。
+      // 若此处再抛上传错误，done hook 会只把该错误传给最终回调，遮蔽编译错误。
+      if (stats && stats.hasErrors()) {
+        return Promise.resolve();
+      }
+
+      return addToUploadQueue(assets, {
+        quiet: this.quiet,
+        logWhenIdle: this.waitForUpload,
+        failOnError: this.waitForUpload,
+      });
+    };
+
+    if (this.waitForUpload) {
+      compiler.hooks.done.tapPromise(pluginName, enqueueAssets);
+    } else {
+      compiler.hooks.done.tap(pluginName, (stats) => {
+        enqueueAssets(stats).catch((error) => {
+          console.error(error);
+        });
+      });
+    }
+
+    if (this.independentRoots.length) {
+      // afterCompile 时 loader/子编译的 fileDependencies 已完整汇总，且尚未写入产物。
+      compiler.hooks.afterCompile.tap(pluginName, (compilation) => {
+        validatePackageBoundary(compilation, this.independentRoot, this.independentRoots);
+      });
+    }
     compiler.hooks.compilation.tap(pluginName, (compilation) => {
       compilation.hooks.afterProcessAssets.tap(
         {
@@ -213,14 +345,15 @@ class WeappPlugin {
               }
 
               const before = content;
-              const after = injectGlobalModules(content, assetName, flags);
-              const finalContent = injectSubpackageRequires(after, assetName, subpackages);
+              const after = injectGlobalModules(content, assetName, this.independentRoot ? {} : flags);
+              const finalContent = this.independentRoot ? after : injectSubpackageRequires(after, assetName, subpackages);
 
               if (finalContent !== before) {
                 compilation.updateAsset(asset.name, new RawSource(finalContent));
               }
             }),
           );
+          if (this.independentRoot) injectIndependentEntrypoints(compilation);
         },
       );
     });

package/build/prod.js

@@ -4,35 +4,37 @@ const CssMinimizerPlugin = require('css-minimizer-webpack-plugin');
 const { ENV } = require('./config/constants');
 const webpackConfig = require('./webpack.config');
 const { createCompilerHandler } = require('./utils/createCompilerHandler');
+const { cleanDistForDev } = require('./utils/cleanDistForDev');
 
 module.exports = async (opts) => {
   // 生产环境禁用 filesystem cache，与 dev 同源：output.clean 后复用旧缓存会导致副作用产物漏生成，
   // 注入逻辑（plugin/index.js 的 PROCESS_ASSETS_STAGE_ADDITIONS）要求每次从干净的 source 重做。
   // production 单次构建本就是冷构建，命中收益低，移除以换确定性。
-  const compiler = webpack(
-    await webpackConfig(
-      {
-        mode: ENV.PROD,
-        devtool: false,
-        output: {
-          clean: {
-            keep: /^(project\.config\.json|weapp\.env\.json)$/,
-          },
-        },
-        optimization: {
-          minimizer: [
-            new TerserPlugin({
-              extractComments: false,
-            }),
-            new CssMinimizerPlugin({
-              test: /\.(css|wxss)(\?.*)?$/i,
-            }),
-          ],
+  const config = await webpackConfig(
+    {
+      mode: ENV.PROD,
+      devtool: false,
+      output: {
+        clean: {
+          keep: /^(project\.config\.json|weapp\.env\.json)$/,
         },
       },
-      opts || {},
-    ),
+      optimization: {
+        minimizer: [
+          new TerserPlugin({
+            extractComments: false,
+          }),
+          new CssMinimizerPlugin({
+            test: /\.(css|wxss)(\?.*)?$/i,
+          }),
+        ],
+      },
+    },
+    opts || {},
   );
+  // 多份配置共用 dist，只在启动前清理，禁止子编译互相删除产物。
+  if (Array.isArray(config)) await cleanDistForDev();
+  const compiler = webpack(config);
 
   compiler.run(createCompilerHandler('build'));
 };

package/build/utils/createCompilerHandler.js

@@ -5,6 +5,7 @@ const chalk = require('chalk');
  * @param {string} label - 构建阶段标签，如 'dev' 或 'build'
  */
 function createCompilerHandler(label, { failOnError = label === 'build' } = {}) {
+  let lastBuildEnd = 0;
   const markFailed = () => {
     if (failOnError) {
       process.exitCode = 1;
@@ -44,10 +45,16 @@ function createCompilerHandler(label, { failOnError = label === 'build' } = {})
       );
     }
 
-    console.log(chalk.green(`${label} completed in ${(stats.endTime - stats.startTime) / 1000} seconds`));
+    const children = stats.stats || [stats];
+    // MultiStats 在局部 watch 重建时还包含未重建子编译的旧 stats。
+    const rebuilt = children.filter((child) => child.endTime > lastBuildEnd);
+    const start = Math.min(...(rebuilt.length ? rebuilt : children).map((child) => child.startTime));
+    const end = Math.max(...children.map((child) => child.endTime));
+    lastBuildEnd = end;
+    console.log(chalk.green(`${label} completed in ${(end - start) / 1000} seconds`));
   };
 }
 
 module.exports = {
   createCompilerHandler,
-};
+};

package/build/utils/independentPackages.js

@@ -0,0 +1,31 @@
+const path = require('path');
+const { compatiblePath } = require('./compatiblePath');
+
+function isWithinRoot(file, root) {
+  const name = path.posix.normalize(compatiblePath(file));
+  return name === root || name.startsWith(`${root}/`);
+}
+
+function getIndependentRoots(appConfig) {
+  const packages = appConfig.subpackages || [];
+  const roots = packages.filter((pkg) => pkg.independent === true).map((pkg) => {
+    const root = compatiblePath(pkg.root || '').replace(/\/$/, '');
+    if (!root || path.posix.isAbsolute(root) || /^[A-Za-z]:/.test(root)
+      || root === '.' || root.split('/').some((part) => !part || part === '..' || part === '.')) {
+      throw new Error(`独立分包 root 必须是 src 内的相对目录：${pkg.root}`);
+    }
+    return root;
+  });
+  roots.forEach((root) => {
+    const overlaps = packages.filter((pkg) => {
+      const other = compatiblePath(pkg.root || '').replace(/\/$/, '');
+      return other && (isWithinRoot(root, other) || isWithinRoot(other, root));
+    });
+    if (overlaps.length !== 1) {
+      throw new Error(`独立分包 root 重复或与其他分包目录重叠：${root}`);
+    }
+  });
+  return roots;
+}
+
+module.exports = { getIndependentRoots, isWithinRoot };

package/build/utils/upload.js

@@ -29,6 +29,79 @@ let ossClient;
 let progress;
 let uploadQueue = {};
 let uploadRunner;
+let uploadSummary;
+
+function getProvider() {
+  return ossConfig ? 'OSS' : 'OBS';
+}
+
+function createUploadSummary({ quiet, failOnError }) {
+  return {
+    provider: getProvider(),
+    startedAt: Date.now(),
+    assets: new Set(),
+    localCached: new Set(),
+    pending: new Set(),
+    remoteCached: 0,
+    uploaded: 0,
+    failed: 0,
+    failedFiles: [],
+    quiet,
+    failOnError,
+  };
+}
+
+function getUploadResult(summary) {
+  return {
+    provider: summary.provider,
+    total: summary.assets.size,
+    localCached: summary.localCached.size,
+    pending: summary.pending.size,
+    remoteCached: summary.remoteCached,
+    uploaded: summary.uploaded,
+    failed: summary.failed,
+    failedFiles: [...summary.failedFiles],
+    durationMs: Date.now() - summary.startedAt,
+  };
+}
+
+function logUploadQueue({ provider, total, localCached, pending }, quiet) {
+  if (quiet) {
+    return;
+  }
+
+  console.log(
+    `[assets] upload queue: provider=${provider}, total=${total}, ` +
+      `localCached=${localCached}, pending=${pending}`,
+  );
+}
+
+function logUploadResult(result, quiet) {
+  if (quiet) {
+    return;
+  }
+
+  const message =
+    `[assets] upload completed: provider=${result.provider}, total=${result.total}, ` +
+    `localCached=${result.localCached}, remoteCached=${result.remoteCached}, ` +
+    `uploaded=${result.uploaded}, failed=${result.failed}, ` +
+    `duration=${(result.durationMs / 1000).toFixed(2)}s`;
+
+  if (result.failed > 0) {
+    console.error(message);
+  } else {
+    console.log(message);
+  }
+}
+
+function getUploadError(result) {
+  const error = new Error(
+    `Asset upload failed: provider=${result.provider}, failed=${result.failed}`,
+  );
+  error.code = 'ASSET_UPLOAD_FAILED';
+  error.failedFiles = result.failedFiles;
+  return error;
+}
 
 function getRemoteKey(config, file) {
   return compatiblePath(path.join(config.dir, path.relative(DIST_DIR, file)));
@@ -323,11 +396,15 @@ function doUpload(file) {
 }
 
 function updateProgress() {
+  if (uploadSummary && uploadSummary.quiet) {
+    return;
+  }
+
   const completed = Object.values(uploadQueue).filter((status) => status === 'completed').length;
   const total = Object.keys(uploadQueue).length;
 
   if (!progress) {
-    progress = new Progress('uploading assets [:bar] :current/:total', {
+    progress = new Progress('syncing assets [:bar] :current/:total', {
       total,
       width: 40,
       clear: true,
@@ -348,11 +425,15 @@ async function uploadFile(file) {
   try {
     await getStat(file);
     setStorage(file, true);
+    uploadSummary.remoteCached += 1;
   } catch (error) {
     try {
       await doUpload(file);
       setStorage(file, true);
+      uploadSummary.uploaded += 1;
     } catch (uploadError) {
+      uploadSummary.failed += 1;
+      uploadSummary.failedFiles.push(getDisplayFile(file));
       const detail = `file=${getDisplayFile(file)}, ${formatObsError(uploadError)}`;
 
       if (ossConfig) {
@@ -392,13 +473,23 @@ function checkUpload() {
 
       await Promise.all(files.map(uploadFile));
     }
-  })().finally(() => {
+  })().then(() => {
+    const result = getUploadResult(uploadSummary);
+    logUploadResult(result, uploadSummary.quiet);
+
+    if (uploadSummary.failOnError && result.failed > 0) {
+      throw getUploadError(result);
+    }
+
+    return result;
+  }).finally(() => {
     uploadRunner = null;
 
     // 文件状态已经写完后再清空，避免旧实现最后一个文件把已清空的队列重新写回。
     if (!Object.values(uploadQueue).includes('pending')) {
       progress = null;
       uploadQueue = {};
+      uploadSummary = null;
       return;
     }
 
@@ -409,17 +500,20 @@ function checkUpload() {
   return uploadRunner;
 }
 
-function addToUploadQueue(assets) {
+function addToUploadQueue(
+  assets,
+  { quiet = false, logWhenIdle = false, failOnError = false } = {},
+) {
   if (!obsConfig && !ossConfig) {
     console.warn('请配置obsConfig 或 ossConfig，否则无法上传文件到obs 或 oss');
-    return;
+    return Promise.resolve();
   }
 
+  const uniqueFiles = [...new Set(assets.map((asset) => path.resolve(DIST_DIR, asset)))];
   let cachedCount = 0;
   let pendingCount = 0;
 
-  assets.forEach((asset) => {
-    const file = path.resolve(DIST_DIR, asset);
+  uniqueFiles.forEach((file) => {
     if (getStorage(file)) {
       cachedCount += 1;
       return;
@@ -430,14 +524,64 @@ function addToUploadQueue(assets) {
     }
   });
 
-  if (ossConfig) {
-    console.log(
-      `[assets] upload queue: provider=OSS, total=${assets.length}, ` +
-        `cached=${cachedCount}, pending=${pendingCount}`,
+  if (pendingCount > 0) {
+    if (!uploadSummary) {
+      uploadSummary = createUploadSummary({ quiet, failOnError });
+    } else {
+      // 同一个 watch 上传批次可能由多次编译共同追加；任一调用要求严格失败或正常日志时，
+      // 整个批次都采用更严格、可见的配置。
+      uploadSummary.failOnError = uploadSummary.failOnError || failOnError;
+      uploadSummary.quiet = uploadSummary.quiet && quiet;
+    }
+
+    uniqueFiles.forEach((file) => {
+      uploadSummary.assets.add(file);
+      if (getStorage(file) && !uploadSummary.pending.has(file)) {
+        uploadSummary.localCached.add(file);
+      }
+      if (uploadQueue[file] !== undefined) {
+        uploadSummary.pending.add(file);
+      }
+    });
+  }
+
+  if (!quiet && (pendingCount > 0 || logWhenIdle)) {
+    logUploadQueue(
+      {
+        provider: getProvider(),
+        total: uniqueFiles.length,
+        localCached: cachedCount,
+        pending: pendingCount,
+      },
+      false,
     );
   }
 
-  return pendingCount ? checkUpload() : Promise.resolve();
+  if (pendingCount > 0) {
+    return checkUpload();
+  }
+
+  if (uploadRunner) {
+    return uploadRunner;
+  }
+
+  const result = {
+    provider: getProvider(),
+    total: uniqueFiles.length,
+    localCached: cachedCount,
+    pending: 0,
+    remoteCached: 0,
+    uploaded: 0,
+    failed: 0,
+    failedFiles: [],
+    durationMs: 0,
+  };
+
+  if (logWhenIdle) {
+    logUploadResult(result, quiet);
+  }
+
+  return Promise.resolve(result);
 }
 
 module.exports = {