astroturf/VirtualModulePlugin.js

"use strict";

exports.__esModule = true;
exports.default = void 0;

var _memoryFs = _interopRequireDefault(require("./memory-fs"));

var _proxyFileSystem = _interopRequireDefault(require("./proxyFileSystem"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const PLUGIN = 'css-literal-loader';

let VirtualModulePlugin =
/*#__PURE__*/
function () {
  /**
   * Apply an instance of the plugin to compilation.
   * helpful for adding the plugin inside a loader.
   */
  VirtualModulePlugin.bootstrap = function bootstrap(compilation, files) {
    const {
      compiler
    } = compilation;
    const plugin = new VirtualModulePlugin(files);
    plugin.augmentCompilerFileSystem(compiler);
    compilation.inputFileSystem = compiler.inputFileSystem; // v3

    if (!compiler.resolverFactory) return plugin; // this is suuuch a hack
    // we need to ensure that resolvers are rebuilt with the new filesystem, and
    // I don't know the right way to do that.
    // pre 4.36.1 this cache also existed

    if (compiler.resolverFactory.cache1) compiler.resolverFactory.cache1 = new WeakMap(); // >=4.36.1 this one is needed

    if (compiler.resolverFactory.cache2) compiler.resolverFactory.cache2.clear();
    return plugin;
  };

  function VirtualModulePlugin(files) {
    this.addFile = (virtualPath, content) => {
      this.fs.addFile(virtualPath, content);
    };

    this.fs = new _memoryFs.default();

    if (files) {
      Object.keys(files).forEach(key => {
        this.addFile(key, files[key]);
      });
    }
  }

  var _proto = VirtualModulePlugin.prototype;

  _proto.augmentCompilerFileSystem = function augmentCompilerFileSystem(compiler) {
    if (this.augmented === true) {
      return;
    }

    const fs = (0, _proxyFileSystem.default)(compiler.inputFileSystem, this.fs);
    compiler.inputFileSystem = fs;

    if (!compiler.hooks) {
      compiler.resolvers.normal.fileSystem = fs;
      compiler.resolvers.context.fileSystem = fs;
      compiler.resolvers.loader.fileSystem = fs;
    } else {
      /**
       * When webpack is in watch mode, the map of file timestamps is computed
       * from the watcher instance, which uses the real filesystem and as a
       * result the virtual css files are not found in this map.
       * To correct this, we manually add these files to the map here.
       * @see https://github.com/4Catalyzer/astroturf/pull/381
       */
      compiler.hooks.watchRun.tapAsync('astroturf', ({
        fileTimestamps
      }, callback) => {
        this.fs.getPaths().forEach((value, key) => {
          const mtime = +value.mtime;
          fileTimestamps.set(key, mtime);
        });
        callback();
      });
    }

    this.augmented = true;
  };

  _proto.apply = function apply(compiler) {
    const augmentOnCompile = () => {
      this.augmentCompilerFileSystem(compiler);
    };

    const augmentLoaderContext = loaderContext => {
      loaderContext.emitVirtualFile = this.addFile;
    }; // if the fs is already present then immediately augment it


    if (compiler.inputFileSystem) this.augmentCompilerFileSystem(compiler);

    if (compiler.hooks) {
      compiler.hooks.compile.tap(PLUGIN, augmentOnCompile);
      compiler.hooks.compilation.tap(PLUGIN, compilation => {
        compilation.hooks.normalModuleLoader.tap(PLUGIN, augmentLoaderContext);
      });
    } else {
      compiler.plugin('compile', augmentOnCompile);
      compiler.plugin('compilation', compilation => {
        compilation.plugin('normal-module-loader', augmentLoaderContext);
      });
    }
  };

  return VirtualModulePlugin;
}();

var _default = VirtualModulePlugin;
exports.default = _default;