Get all entrypoints referenced by a webpack configuration

getEntrypointsFromWebpackConfig.js

// @ts-check
const { resolve } = require('path');

/** @typedef {import('webpack/declarations/WebpackOptions').WebpackOptions} WebpackOptions */
/** @typedef {import('webpack/declarations/WebpackOptions').Entry} Entry */

/**
 * @param {string} webpackConfigPath
 */
module.exports = async function getEntrypointsFromWebpackConfig(
  webpackConfigPath
) {
  const configs = await resolveConfig(require(webpackConfigPath));

  const entryPoints = (await Promise.all(
    configs.map(async ({ context, entry }) => {
      if (typeof entry === 'undefined') {
        throw new Error(`Webpack configuration must contain 'entry' property`);
      }

      const paths = await resolveEntry(entry);

      if (context) {
        return paths.map(p => resolve(webpackConfigPath, context, p));
      } else {
        return paths.map(p => resolve(webpackConfigPath, p));
      }
    })
  )).flat();

  return [...new Set(entryPoints.sort())];
};

/**
 * @param {Entry} entry
 * @returns {Promise<string[]>}
 */
async function resolveEntry(entry) {
  if (typeof entry === 'function') {
    return resolveEntry(await entry());
  }

  if (Array.isArray(entry)) {
    return entry;
  }

  if (typeof entry === 'string') {
    return [entry];
  }

  // By this point we can assume entry to be an Object
  const objectValues = await Promise.all(
    Object.values(entry).map(resolveEntry)
  );
  return objectValues.flat();
}

/**
 * @param {WebpackOptions | WebpackOptions[] | function() : (WebpackOptions | WebpackOptions[] | Promise<WebpackOptions> | Promise<WebpackOptions[]>)} config
 * @returns {Promise<WebpackOptions[]>}
 */
async function resolveConfig(config) {
  if (typeof config === 'function') {
    return await resolveConfig(await config());
  }

  if (Array.isArray(config)) {
    const results = await Promise.all(config.map(resolveConfig));

    return results.flat();
  }

  return [config];
}