perf: parallelize lwc build based on rollup input (#2441)

* perf: parallelize lwc build based on rollup input

* fix: respond to PR comments

Author: nolanlawson

packages/lwc/scripts/utils/child_worker.js

@@ -4,16 +4,25 @@
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
+const { rollup } = require('rollup');
 const { rollupConfig, generateTarget } = require('./rollup');
 
-module.exports = function (config, callback) {
-    const targetConfig = rollupConfig(config);
+module.exports = async function (targets, callback) {
+    const targetConfigs = targets.map((config) => rollupConfig(config));
 
-    generateTarget(targetConfig)
-        .then(() => {
-            callback(null, { config, pid: `${process.pid}` });
-        })
-        .catch((err) => {
-            callback(err);
-        });
+    try {
+        const bundle = await rollup(targetConfigs[0].inputOptions); // inputOptions are all the same
+        await Promise.all(
+            targetConfigs.map(async ({ outputOptions, display }) => {
+                await generateTarget({
+                    bundle,
+                    outputOptions,
+                    display,
+                });
+            })
+        );
+        callback();
+    } catch (err) {
+        callback(err);
+    }
 };

packages/lwc/scripts/utils/generate_targets.js

@@ -13,14 +13,31 @@ const DEFAULT_FARM_OPTS = {
     maxConcurrentCallsPerWorker: 2,
 };
 
+// Group the targets based on their input configuration, which allows us to run
+// rollup.rollup() once per unique input combination, and then bundle.generate
+// multiple times for each unique output combination.
+function groupByInputOptions(configs) {
+    const keysToConfigs = {};
+    for (const config of configs) {
+        const { input, prod, target } = config;
+        // These are the only input options that matter for rollup.rollup()
+        const key = [input, !!prod, target].join('-');
+        keysToConfigs[key] = keysToConfigs[key] || [];
+        keysToConfigs[key].push(config);
+    }
+    return Object.values(keysToConfigs);
+}
+
 module.exports = async function generateTargets(targets, opts = {}) {
     const workers = workerFarm(
         { ...DEFAULT_FARM_OPTS, ...opts },
         require.resolve('./child_worker')
     );
 
+    const targetGroups = groupByInputOptions(targets);
+
     try {
-        await Promise.all(targets.map((config) => promisify(workers)(config)));
+        await Promise.all(targetGroups.map((targetGroup) => promisify(workers)(targetGroup)));
     } finally {
         workerFarm.end(workers);
     }

packages/lwc/scripts/utils/rollup.js

@@ -5,7 +5,6 @@
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
 const path = require('path');
-const { rollup } = require('rollup');
 const rollupReplace = require('@rollup/plugin-replace');
 const { terser: rollupTerser } = require('rollup-plugin-terser');
 const babel = require('@babel/core');
@@ -61,19 +60,19 @@ function rollupConfig(config) {
                     }),
                 rollupFeaturesPlugin(prod),
                 compatMode && babelCompatPlugin(),
-                prod && !debug && rollupTerser(),
             ],
         },
         outputOptions: {
             name,
             file: path.join(targetDirectory, target, generateTargetName(config)),
             format,
+            plugins: [prod && !debug && rollupTerser()],
         },
         display: { name, dir, format, target, prod, debug },
     };
 }
 
-async function generateTarget({ inputOptions, outputOptions, display }) {
+async function generateTarget({ bundle, outputOptions, display }) {
     const msg = [
         `module: ${path.basename(display.dir)}`.padEnd(25, ' '),
         `format: ${display.format}`.padEnd(12, ' '),
@@ -83,8 +82,8 @@ async function generateTarget({ inputOptions, outputOptions, display }) {
         `pid: ${process.pid}`.padEnd(10, ' '),
     ].join(' | ');
 
-    const bundle = await rollup(inputOptions);
     await bundle.write(outputOptions);
+
     process.stdout.write(`${msg} ✓\n`);
 }