index.js

const path = require("path");
const fs = require("fs");
const chalk = require("chalk");
const { fg } = require("./colours");
const exec = require("child_process").exec;
const { WrappedPlugin, clear } = require("./WrappedPlugin");
const {
  getModuleName,
  getLoaderNames,
  prependLoader,
  tap,
} = require("./utils");
const {
  getHumanOutput,
  getMiscOutput,
  getPluginsOutput,
  getLoadersOutput,
  smpTag,
} = require("./output");

const NS = path.dirname(fs.realpathSync(__filename));

module.exports = class SpeedMeasurePlugin {
  constructor(options) {
    this.options = options || {};

    this.timeEventData = {};
    this.smpPluginAdded = false;

    this.wrap = this.wrap.bind(this);
    this.getOutput = this.getOutput.bind(this);
    this.addTimeEvent = this.addTimeEvent.bind(this);
    this.apply = this.apply.bind(this);
    this.provideLoaderTiming = this.provideLoaderTiming.bind(this);
    this.getLoadersBuildComparison = this.getLoadersBuildComparison.bind(this);
  }

  wrap(config) {
    if (this.options.disable) return config;
    if (Array.isArray(config)) return config.map(this.wrap);
    if (typeof config === "function")
      return (...args) => this.wrap(config(...args));

    config.plugins = (config.plugins || []).map((plugin) => {
      const pluginName =
        Object.keys(this.options.pluginNames || {}).find(
          (pluginName) => plugin === this.options.pluginNames[pluginName]
        ) ||
        (plugin.constructor && plugin.constructor.name) ||
        "(unable to deduce plugin name)";
      return new WrappedPlugin(plugin, pluginName, this);
    });

    if (config.optimization && config.optimization.minimizer) {
      config.optimization.minimizer = config.optimization.minimizer.map(
        (plugin) => {
          return new WrappedPlugin(plugin, plugin.constructor.name, this);
        }
      );
    }

    if (config.module && this.options.granularLoaderData) {
      config.module = prependLoader(config.module);
    }

    if (!this.smpPluginAdded) {
      config.plugins = config.plugins.concat(this);
      this.smpPluginAdded = true;
    }

    return config;
  }

  getLoadersBuildComparison() {
    let objBuildData = { loaderInfo: [] };
    let loaderFile = this.options.compareLoadersBuild.filePath || "";
    const outputObj = getLoadersOutput(this.timeEventData.loaders);

    if (outputObj && loaderFile && fs.existsSync(loaderFile)) {
      let buildDetails = fs.readFileSync(loaderFile);
      buildDetails =
        buildDetails.toString() !== "" ? JSON.parse(buildDetails) : [];
      const buildCount = buildDetails.length;
      const buildNo =
        buildCount > 0 ? buildDetails[buildCount - 1]["buildNo"] + 1 : 1;

      /*********************** Code to create object format of current loader and write in the file. ************************/
      outputObj.build.forEach((loaderObj, loaderIndex) => {
        const loaderInfo = {};
        loaderInfo["Name"] = loaderObj.loaders.join(",") || "";
        loaderInfo["Time"] = loaderObj.activeTime || "";
        loaderInfo["Count"] =
          this.options.outputFormat === "humanVerbose"
            ? loaderObj.averages.dataPoints
            : "";
        loaderInfo[`Comparison`] = "";

        // Getting the comparison from the previous build by default only in case if build data is more then one.
        if (buildCount > 0) {
          const prevBuildIndex = buildCount - 1;
          for (
            var y = 0;
            y < buildDetails[prevBuildIndex]["loaderInfo"].length;
            y++
          ) {
            const prevloaderDetails =
              buildDetails[prevBuildIndex]["loaderInfo"][y];
            if (
              loaderInfo["Name"] == prevloaderDetails["Name"] &&
              prevloaderDetails["Time"]
            ) {
              let previousBuildTime =
                buildDetails[prevBuildIndex]["loaderInfo"][y]["Time"];
              loaderInfo[`Comparison`] = `buildDiff--> ${Math.abs(
                previousBuildTime - loaderObj.activeTime
              )}|${previousBuildTime > loaderObj.activeTime ? "Good" : "Bad"}`;
            }
          }
        }

        objBuildData["loaderInfo"].push(loaderInfo);
      });

      buildDetails.push({ buildNo, loaderInfo: objBuildData["loaderInfo"] });
      fs.writeFileSync(loaderFile, JSON.stringify(buildDetails));
      /****************************************************************************************/

      let outputTable = [];
      let objCurrentBuild = {};

      for (let i = 0; i < buildDetails.length; i++) {
        outputTable = [];
        console.log("--------------------------------------------");
        console.log("Build No ", buildDetails[i]["buildNo"]);
        console.log("--------------------------------------------");

        if (buildDetails[i]["loaderInfo"]) {
          buildDetails[i]["loaderInfo"].forEach(
            (buildIndex, buildInfoIndex) => {
              const buildInfo = buildDetails[i]["loaderInfo"][buildInfoIndex];
              objCurrentBuild = {};
              objCurrentBuild["Name"] = buildInfo["Name"] || "";
              objCurrentBuild["Time"] = buildInfo["Time"] || "";
              if (this.options.outputFormat === "humanVerbose")
                objCurrentBuild["Count"] = buildInfo["Count"] || 0;
              objCurrentBuild["Comparison"] = buildInfo["Comparison"] || "";
              outputTable.push(objCurrentBuild);
            }
          );
        }
        console.table(outputTable);
      }
    }
  }

  getOutput() {
    const outputObj = {};
    if (this.timeEventData.misc)
      outputObj.misc = getMiscOutput(this.timeEventData.misc);
    if (this.timeEventData.plugins)
      outputObj.plugins = getPluginsOutput(this.timeEventData.plugins);
    if (this.timeEventData.loaders)
      outputObj.loaders = getLoadersOutput(this.timeEventData.loaders);

    if (this.options.outputFormat === "json")
      return JSON.stringify(outputObj, null, 2);
    if (typeof this.options.outputFormat === "function")
      return this.options.outputFormat(outputObj);
    return getHumanOutput(outputObj, Object.assign(
      { verbose: this.options.outputFormat === "humanVerbose" },
      this.options)
    );
  }

  addTimeEvent(category, event, eventType, data = {}) {
    const allowFailure = data.allowFailure;
    delete data.allowFailure;

    const tED = this.timeEventData;
    if (!tED[category]) tED[category] = {};
    if (!tED[category][event]) tED[category][event] = [];
    const eventList = tED[category][event];
    const curTime = new Date().getTime();

    if (eventType === "start") {
      data.start = curTime;
      eventList.push(data);
    } else if (eventType === "end") {
      const matchingEvent = eventList.find((e) => {
        const allowOverwrite = !e.end || !data.fillLast;
        const idMatch = e.id !== undefined && e.id === data.id;
        const nameMatch =
          !data.id && e.name !== undefined && e.name === data.name;
        return allowOverwrite && (idMatch || nameMatch);
      });
      const eventToModify =
        matchingEvent || (data.fillLast && eventList.find((e) => !e.end));
      if (!eventToModify) {
        console.error(
          "Could not find a matching event to end",
          category,
          event,
          data
        );
        if (allowFailure) return;
        throw new Error("No matching event!");
      }

      eventToModify.end = curTime;
    }
  }

  apply(compiler) {
    if (this.options.disable) return;

    tap(compiler, "compile", () => {
      this.addTimeEvent("misc", "compile", "start", { watch: false });
    });
    tap(compiler, "done", () => {
      clear();
      this.addTimeEvent("misc", "compile", "end", { fillLast: true });

      const outputToFile = typeof this.options.outputTarget === "string";
      chalk.enabled = !outputToFile;
      const output = this.getOutput();
      chalk.enabled = true;
      if (outputToFile) {
        const writeMethod = fs.existsSync(this.options.outputTarget)
          ? fs.appendFileSync
          : fs.writeFileSync;
        writeMethod(this.options.outputTarget, output + "\n");
        console.log(
          smpTag() + "Outputted timing info to " + this.options.outputTarget
        );
      } else {
        const outputFunc = this.options.outputTarget || console.log;
        outputFunc(output);
      }
      // Build Comparison functionality.
      if (this.options.compareLoadersBuild) this.getLoadersBuildComparison();
      this.timeEventData = {};
    });

    tap(compiler, "compilation", (compilation) => {
      tap(compilation, "normal-module-loader", (loaderContext) => {
        loaderContext[NS] = this.provideLoaderTiming;
      });

      tap(compilation, "build-module", (module) => {
        const name = getModuleName(module);
        if (name) {
          this.addTimeEvent("loaders", "build", "start", {
            name,
            fillLast: true,
            loaders: getLoaderNames(module.loaders),
          });
        }
      });

      tap(compilation, "succeed-module", (module) => {
        const name = getModuleName(module);
        if (name) {
          this.addTimeEvent("loaders", "build", "end", {
            name,
            fillLast: true,
          });
        }
      });
    });
  }

  provideLoaderTiming(info) {
    const infoData = { id: info.id };
    if (info.type !== "end") {
      infoData.loader = info.loaderName;
      infoData.name = info.module;
    }

    this.addTimeEvent("loaders", "build-specific", info.type, infoData);
  }
};