Need an approach to invalidate built modules about hard-source-webpack-plugin HOT 3 CLOSED

var walkDependencyBlock = function(block, callback) {
  console.log(block);
  block.dependencies.forEach(callback);
  block.variables.forEach(function(variable) {
    variable.dependencies.forEach(callback);
  });
  block.blocks.forEach(function(block) {
    walkDependencyBlock(block, callback);
  });
};

// Invalidate any dependencies that request this resolution. For
// normal modules nothing needs to be done. But cached modules
// depending on this need to be busted, removed from the
// compilation, reasons for it re-processed, and the cache entry
// removed.
var willBust = [];
compilation.modules.forEach(function(module) {
  if (module instanceof CacheModule) {
    var dependsOnRequest = true;
    walkDependencyBlock(module, function(dependency) {
      dependsOnRequest = dependsOnRequest &&
        module.context === request.context &&
        dependency.request === request.request;
    });
    if (dependsOnRequest) {
      willBust.push(module);
    }
  }
});
var addModuleDependencies = Promise.promisify(compilation.addModuleDependencies, {context: compilation});
var whenBusted = Promise.all(willBust.map(function(module) {
  var reasons = module.reasons.slice();
  module.disconnect();
  compilation._modules[module.identifier()] = null;
  compilation.modules.splice(compilation.modules.indexOf(module), 1);
  return Promise.all(reasons.map(function(reason) {
    reason.dependency.module = null;
    return addModuleDependencies(reason.module, [[reason.dependency]], compilation.bail, null, true);
  }));
}));

// Remove the out of date cache modules.
Object.keys(moduleCache).forEach(function(key) {
  if (key === 'fileDependencies') {return;}
  var module = moduleCache[key];
  if (typeof module === 'string') {
    module = JSON.parse(module);
    moduleCache[key] = module;
  }
  var dependsOnRequest = true;
  walkDependencyBlock(module, function(cacheDependency) {
    dependsOnRequest = dependsOnRequest &&
      module.context === request.context &&
      cacheDependency.request === request.request;
  });
  if (dependsOnRequest) {
    moduleCache[key] = null;
  }
});

// Remove the out of date resolution.
resolveCache[cacheId] = null;

// Resolve normally.
whenBusted.then(next);

    .then(function() {
      var childCompiler = compiler.createChildCompiler();

      var params = childCompiler.newCompilationParams();
      childCompiler.applyPlugins("compile", params);

      var compilation = childCompiler.newCompilation(params);

      var entries = moduleCache.entries;

      return Promise.all(entries.map(function(entry) {
        return Promise.promisify(compilation.addEntry, {context: compilation})('', new SingleEntryDependency(entry), '');
      }))
      .then(function() {
        return Promise.promisify(compilation.seal, {context: compilation})();
      })
      .then(function() {return compilation;});
    })
    .then(function(compilation) {
      // console.log(compilation.modules);
      compilation.modules.forEach(function(module) {
        if (!(module instanceof HardModule)) {
          return;
        }

        var cacheItem = moduleCache[module.request];
        if (!cacheItem) {
          return;
        }

        if (
          !lodash.isEqual(cacheItem.used, module.used) ||
          !lodash.isEqual(cacheItem.usedExports, module.usedExports)
        ) {
          cacheItem.invalid = true;
          moduleCache[module.request] = null;
        }
      });
    })