Merge branch 'master' into 1.0.0-beta

Author: stephencookdev

WrappedPlugin/index.js

@@ -2,16 +2,31 @@ let idInc = 0;
 
 const genPluginMethod = (orig, pluginName, smp, type) =>
   function(method, func) {
-    const id = idInc++;
-    const timeEventName = type + "/" + method;
-
     const wrappedFunc = (...args) => {
+      const id = idInc++;
+      const timeEventName = pluginName + "/" + type + "/" + method;
+      // we don't know if there's going to be a callback applied to a particular
+      // call, so we just set it multiple times, letting each one override the last
+      let endCallCount = 0;
+      const addEndEvent = () => {
+        endCallCount++;
+        smp.addTimeEvent("plugins", timeEventName, "end", { id });
+      };
+
       smp.addTimeEvent("plugins", timeEventName, "start", {
         id,
         name: pluginName,
       });
-      const ret = func.apply(this, args.map(a => wrap(a, pluginName, smp)));
-      smp.addTimeEvent("plugins", timeEventName, "end", { id });
+      const ret = func.apply(
+        this,
+        args.map(a => wrap(a, pluginName, smp, addEndEvent))
+      );
+
+      // If the end event was invoked as a callback immediately, we can
+      // don't want to add another end event here (and it can actually cause
+      // errors, if webpack has finished compilation entirely)
+      if (!endCallCount) addEndEvent();
+
       return ret;
     };
 
@@ -27,27 +42,52 @@ const construcNamesToWrap = [
   "ContextModuleFactory",
 ];
 
-const wrap = (orig, pluginName, smp) => {
-  const origConstrucName = orig && orig.constructor && orig.constructor.name;
-  const shouldWrap = construcNamesToWrap.includes(origConstrucName);
-  if (!shouldWrap) return orig;
+const wrap = (orig, pluginName, smp, addEndEvent) => {
+  if (!orig) return orig;
+
+  const getOrigConstrucName = target =>
+    target && target.constructor && target.constructor.name;
+  const getShouldWrap = target => {
+    const origConstrucName = getOrigConstrucName(target);
+    return construcNamesToWrap.includes(origConstrucName);
+  };
+  const shouldWrap = getShouldWrap(orig);
+  const shouldSoftWrap = Object.keys(orig)
+    .map(k => orig[k])
+    .some(getShouldWrap);
+
+  if (!shouldWrap && !shouldSoftWrap) {
+    const vanillaFunc = orig.name === "next";
+    return vanillaFunc
+      ? function() {
+          // do this before calling the callback, since the callback can start
+          // the next plugin step
+          addEndEvent();
+
+          return orig.apply(this, arguments);
+        }
+      : orig;
+  }
 
   const proxy = new Proxy(orig, {
     get: (target, property) => {
-      if (property === "plugin")
-        return genPluginMethod(orig, pluginName, smp, origConstrucName).bind(
-          proxy
-        );
+      if (shouldWrap && property === "plugin")
+        return genPluginMethod(
+          orig,
+          pluginName,
+          smp,
+          getOrigConstrucName(target)
+        ).bind(proxy);
 
       if (typeof orig[property] === "function")
         return orig[property].bind(proxy);
       return wrap(orig[property], pluginName, smp);
     },
     set: (target, property, value) => {
-      target[property] = value;
+      return Reflect.set(target, property, value);
     },
     deleteProperty: (target, property) => {
-      delete target[property];
+      return Reflect.deleteProperty(target, property);
     },
   });
 

index.js

@@ -68,10 +68,15 @@ module.exports = class SpeedMeasurePlugin {
       data.start = curTime;
       eventList.push(data);
     } else if (eventType === "end") {
-      const matchingEvent = eventList.find(
-        e => !e.end && (e.id === data.id || e.name === data.name)
-      );
-      const eventToModify = matchingEvent || eventList.find(e => !e.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.log(
           "Could not find a matching event to end",
@@ -93,7 +98,7 @@ module.exports = class SpeedMeasurePlugin {
       this.addTimeEvent("misc", "compile", "start", { watch: false });
     });
     compiler.plugin("done", () => {
-      this.addTimeEvent("misc", "compile", "end");
+      this.addTimeEvent("misc", "compile", "end", { fillLast: true });
 
       const output = this.getOutput();
       if (typeof this.options.outputTarget === "string") {
@@ -119,6 +124,7 @@ module.exports = class SpeedMeasurePlugin {
         if (name) {
           this.addTimeEvent("loaders", "build", "start", {
             name,
+            fillLast: true,
             loaders: getLoaderNames(module.loaders),
           });
         }
@@ -127,7 +133,10 @@ module.exports = class SpeedMeasurePlugin {
       compilation.plugin("succeed-module", module => {
         const name = getModuleName(module);
         if (name) {
-          this.addTimeEvent("loaders", "build", "end", { name });
+          this.addTimeEvent("loaders", "build", "end", {
+            name,
+            fillLast: true,
+          });
         }
       });
     });

utils.js

@@ -47,7 +47,7 @@ const range = xs =>
 module.exports.getModuleName = module => module.userRequest;
 
 module.exports.getLoaderNames = loaders =>
-  loaders.length
+  loaders && loaders.length
     ? loaders
         .map(l => l.loader)
         .map(l => l.replace(/^.*\/node_modules\/([^\/]+).*$/, (_, m) => m))