@codecov/nextjs-webpack-plugin/dist/index.cjs

Official Codecov NextJS (Webpack) plugin

'use strict';

const unplugin = require('unplugin');
const bundlerPluginCore = require('@codecov/bundler-plugin-core');
const webpackPlugin = require('@codecov/webpack-plugin');

const nextJSWebpackBundleAnalysisPlugin = ({ output, pluginName, pluginVersion, options }) => ({
  version: output.version,
  name: pluginName,
  pluginVersion,
  buildStart: () => {
    output.start();
    output.setPlugin(pluginName, pluginVersion);
  },
  buildEnd: () => {
    output.end();
  },
  writeBundle: async () => {
    await output.write();
  },
  webpack(compiler) {
    compiler.hooks.thisCompilation.tap(pluginName, (compilation) => {
      if (!options.webpack) {
        bundlerPluginCore.red(
          "Unable to run bundle analysis, Webpack wasn't passed successfully."
        );
        return;
      }
      compilation.hooks.processAssets.tapPromise(
        {
          name: pluginName,
          stage: options.webpack.Compilation.PROCESS_ASSETS_STAGE_REPORT
        },
        async () => {
          if (!options.webpack) {
            bundlerPluginCore.red(
              "Unable to run bundle analysis, Webpack wasn't passed successfully."
            );
            return;
          }
          output.setBundleName(output.originalBundleName);
          if (typeof compilation.outputOptions.chunkFormat === "string") {
            if (compilation.name && compilation.name !== "") {
              output.setBundleName(`${output.bundleName}-${compilation.name}`);
            }
            let chunkFormat = compilation.outputOptions.chunkFormat;
            if (chunkFormat === "commonjs") {
              chunkFormat = "cjs";
            } else if (chunkFormat === "module") {
              chunkFormat = "esm";
            }
            output.setBundleName(`${output.bundleName}-${chunkFormat}`);
          }
          const compilationStats = compilation.getStats().toJson({
            assets: true,
            chunks: true,
            modules: true,
            builtAt: true,
            hash: true
          });
          output.bundler = {
            name: "webpack",
            version: options.webpack.version
          };
          const outputOptions = compilation.outputOptions;
          const { assets, chunks, modules } = compilationStats;
          if (assets) {
            const collectedAssets = await webpackPlugin._internal_processAssets({
              assets,
              compilation,
              metaFramework: output.metaFramework
            });
            output.assets = collectedAssets;
          }
          const chunkIdMap = /* @__PURE__ */ new Map();
          if (chunks) {
            output.chunks = webpackPlugin._internal_processChunks({ chunks, chunkIdMap });
          }
          if (modules) {
            output.modules = webpackPlugin._internal_processModules({ modules, chunkIdMap });
          }
          output.duration = Date.now() - (output.builtAt ?? 0);
          output.outputPath = outputOptions.path ?? "";
          if (output.dryRun) {
            const { RawSource } = options.webpack.sources;
            compilation.emitAsset(
              `${output.bundleName}-stats.json`,
              new RawSource(output.bundleStatsToJson())
            );
          }
        }
      );
    });
  }
});

const PLUGIN_NAME = "@codecov/nextjs-webpack-plugin";
const PLUGIN_VERSION = "1.9.0";
const codecovNextJSWebpackPluginFactory = unplugin.createWebpackPlugin((userOptions, unpluginMetaContext) => {
  if (bundlerPluginCore.checkNodeVersion(unpluginMetaContext)) {
    return [];
  }
  const normalizedOptions = bundlerPluginCore.normalizeOptions(userOptions);
  if (!normalizedOptions.success) {
    const { shouldExit } = bundlerPluginCore.handleErrors(normalizedOptions);
    if (shouldExit) {
      process.exit(1);
    }
    return [];
  }
  const plugins = [];
  const options = normalizedOptions.options;
  const sentryConfig = bundlerPluginCore.createSentryInstance({
    telemetry: options.telemetry,
    isDryRun: options.dryRun,
    pluginName: PLUGIN_NAME,
    pluginVersion: PLUGIN_VERSION,
    options,
    bundler: unpluginMetaContext.framework,
    metaFramework: "nextjs"
  });
  const output = new bundlerPluginCore.Output(
    options,
    { metaFramework: unpluginMetaContext.framework },
    sentryConfig
  );
  if (options.enableBundleAnalysis) {
    plugins.push(
      bundlerPluginCore.telemetryPlugin({
        sentryClient: sentryConfig.sentryClient,
        sentryScope: sentryConfig.sentryScope,
        telemetry: options.telemetry
      }),
      nextJSWebpackBundleAnalysisPlugin({
        output,
        options: { webpack: userOptions.webpack },
        pluginName: PLUGIN_NAME,
        pluginVersion: PLUGIN_VERSION
      })
    );
  }
  return plugins;
});
const codecovNextJSWebpackPlugin = codecovNextJSWebpackPluginFactory;

exports.codecovNextJSWebpackPlugin = codecovNextJSWebpackPlugin;
//# sourceMappingURL=index.cjs.map