add virtual fs logic to loader

Author: Rich-Harris

index.js

@@ -1,7 +1,7 @@
 const { basename, extname, relative } = require('path');
 const { compile, preprocess } = require('svelte');
 const { getOptions } = require('loader-utils');
-const VirtualModulesPlugin = require('webpack-virtual-modules');
+const VirtualModulesPlugin = require('./lib/virtual');
 
 const hotApi = require.resolve('./lib/hot-api.js');
 const virtualModules = new VirtualModulesPlugin();
@@ -80,7 +80,14 @@ function deprecatePreprocessOptions(options) {
 	options.preprocess = options.preprocess || preprocessOptions;
 }
 
+const compilers = new Set();
+
 module.exports = function(source, map) {
+	if (!compilers.has(this._compiler)) {
+		virtualModules.apply(this._compiler);
+		compilers.add(this._compiler);
+	}
+
 	this.cacheable();
 
 	const options = Object.assign({}, this.options, getOptions(this));
@@ -130,6 +137,7 @@ module.exports = function(source, map) {
 
 		callback(null, js.code, js.map);
 	}, err => callback(err)).catch(err => {
+		console.log(err.stack);
 		// wrap error to provide correct
 		// context when logging to console
 		callback(new Error(`${err.name}: ${err.toString()}`));

lib/virtual-stats.js

@@ -0,0 +1,96 @@
+/**
+ * Used to cache a stats object for the virtual file.
+ * Extracted from the `mock-fs` package.
+ *
+ * @author Tim Schaub http://tschaub.net/
+ * @link https://github.com/tschaub/mock-fs/blob/master/lib/binding.js
+ * @link https://github.com/tschaub/mock-fs/blob/master/license.md
+ */
+
+/* eslint-disable no-restricted-syntax, no-prototype-builtins, no-continue */
+/* eslint-disable no-bitwise, no-underscore-dangle */
+
+'use strict';
+
+var constants = require('constants');
+
+/**
+ * Create a new stats object.
+ * @param {Object} config Stats properties.
+ * @constructor
+ */
+function VirtualStats(config) {
+  for (var key in config) {
+    if (!config.hasOwnProperty(key)) {
+      continue;
+    }
+    this[key] = config[key];
+  }
+}
+
+/**
+ * Check if mode indicates property.
+ * @param {number} property Property to check.
+ * @return {boolean} Property matches mode.
+ */
+VirtualStats.prototype._checkModeProperty = function(property) {
+  return ((this.mode & constants.S_IFMT) === property);
+};
+
+
+/**
+ * @return {Boolean} Is a directory.
+ */
+VirtualStats.prototype.isDirectory = function() {
+  return this._checkModeProperty(constants.S_IFDIR);
+};
+
+
+/**
+ * @return {Boolean} Is a regular file.
+ */
+VirtualStats.prototype.isFile = function() {
+  return this._checkModeProperty(constants.S_IFREG);
+};
+
+
+/**
+ * @return {Boolean} Is a block device.
+ */
+VirtualStats.prototype.isBlockDevice = function() {
+  return this._checkModeProperty(constants.S_IFBLK);
+};
+
+
+/**
+ * @return {Boolean} Is a character device.
+ */
+VirtualStats.prototype.isCharacterDevice = function() {
+  return this._checkModeProperty(constants.S_IFCHR);
+};
+
+
+/**
+ * @return {Boolean} Is a symbolic link.
+ */
+VirtualStats.prototype.isSymbolicLink = function() {
+  return this._checkModeProperty(constants.S_IFLNK);
+};
+
+
+/**
+ * @return {Boolean} Is a named pipe.
+ */
+VirtualStats.prototype.isFIFO = function() {
+  return this._checkModeProperty(constants.S_IFIFO);
+};
+
+
+/**
+ * @return {Boolean} Is a socket.
+ */
+VirtualStats.prototype.isSocket = function() {
+  return this._checkModeProperty(constants.S_IFSOCK);
+};
+
+module.exports = VirtualStats;

lib/virtual.js

@@ -0,0 +1,95 @@
+var VirtualStats = require('./virtual-stats');
+var path = require('path');
+// var debug = require('debug')('webpack-virtual-modules');
+
+var inode = 45000000;
+
+function VirtualModulesPlugin() {}
+
+VirtualModulesPlugin.prototype.writeModule = function(filePath, contents) {
+  var len = contents ? contents.length : 0;
+  var time = Date.now();
+
+  var stats = new VirtualStats({
+    dev: 8675309,
+    nlink: 0,
+    uid: 1000,
+    gid: 1000,
+    rdev: 0,
+    blksize: 4096,
+    ino: inode++,
+    mode: 33188,
+    size: len,
+    blocks: Math.floor(len / 4096),
+    atime: time,
+    mtime: time,
+    ctime: time,
+    birthtime: time
+  });
+
+  // debug(this._compiler.name, "Write module:", modulePath, contents);
+
+  this._compiler.inputFileSystem._writeVirtualFile(filePath, stats, contents);
+  if (this._watcher && this._watcher.watchFileSystem.watcher.fileWatchers.length) {
+    this._watcher.watchFileSystem.watcher.fileWatchers.forEach((fileWatcher) => {
+      if (fileWatcher.path === filePath) {
+        // debug(this._compiler.name, "Emit file change:", filePath, time);
+        fileWatcher.emit("change", time, null);
+      }
+    });
+  }
+};
+
+function setData(storage, key, value) {
+  if (storage.data instanceof Map) {
+    storage.data.set(key, value);
+  } else {
+    storage.data[key] = value;
+  }
+}
+
+VirtualModulesPlugin.prototype.apply = function(compiler) {
+  this._compiler = compiler;
+
+  // var afterEnvironmentHook = function() {
+    if (!compiler.inputFileSystem._writeVirtualFile) {
+      var originalPurge = compiler.inputFileSystem.purge;
+
+      compiler.inputFileSystem.purge = function() {
+        originalPurge.call(this, arguments);
+        if (this._virtualFiles) {
+          Object.keys(this._virtualFiles).forEach(function(file) {
+            var data = this._virtualFiles[file];
+            setData(this._statStorage, file, [null, data.stats]);
+            setData(this._readFileStorage, file, [null, data.contents]);
+          }.bind(this));
+        }
+      };
+
+      compiler.inputFileSystem._writeVirtualFile = function(file, stats, contents) {
+        this._virtualFiles = this._virtualFiles || {};
+        this._virtualFiles[file] = {stats: stats, contents: contents};
+        setData(this._statStorage, file, [null, stats]);
+        setData(this._readFileStorage, file, [null, contents]);
+      };
+    }
+  // }
+
+  const watchRunHook = (watcher, callback) => {
+    this._watcher = watcher.compiler || watcher;
+    callback();
+  }
+
+  if(compiler.hooks) {
+    console.log('>>>1')
+    // compiler.hooks.afterEnvironment.tap('VirtualModulesPlugin', afterEnvironmentHook);
+    // compiler.hooks.afterResolvers.tap('VirtualModulesPlugin', afterResolversHook);
+    compiler.hooks.watchRun.tapAsync('VirtualModulesPlugin', watchRunHook);
+  } else {
+    // compiler.plugin("after-environment", afterEnvironmentHook);
+    // compiler.plugin("after-resolvers", afterResolversHook);
+    // compiler.plugin("watch-run", watchRunHook);
+  }
+};
+
+module.exports = VirtualModulesPlugin;