chore(deps-dev): bump karma from 6.3.8 to 6.3.14

Bumps [karma](https://github.com/karma-runner/karma) from 6.3.8 to 6.3.14.
- [Release notes](https://github.com/karma-runner/karma/releases)
- [Changelog](https://github.com/karma-runner/karma/blob/master/CHANGELOG.md)
- [Commits](https://github.com/karma-runner/karma/compare/v6.3.8...v6.3.14)

---
updated-dependencies:
- dependency-name: karma
  dependency-type: direct:development
...

Signed-off-by: dependabot[bot] <support@github.com>

.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

.github/workflows/node-js-ci.yml

@@ -0,0 +1,27 @@
+name: node-js-ci
+
+on:
+  pull_request:
+    branches:
+      - master
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ${{matrix.os}}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        node: ['14', '16']
+
+    name: Node ${{ matrix.node }} on ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v2
+      - name: Test
+        uses: actions/setup-node@v2.4.1
+        with:
+          node-version: ${{ matrix.node }}
+      - run: npm install
+      - run: npm test

.gitignore

@@ -2,6 +2,7 @@ node_modules
 .env
 *~
 .vscode
+.idea
 
 # Parcel build dirs
 .cache

.release-it.json

@@ -5,14 +5,13 @@
   },
   "git": {
     "pushRepo": "git@github.com:filerjs/filer.git",
-    "tagName": "v%s"
+    "tagName": "v${version}"
   },
   "npm": {
     "publish": true
   },
   "github": {
     "pushRepo": "git@github.com:filerjs/filer.git",
-    "release": true,
-    "releaseName": "Filer.js %s Released"
+    "release": true
   }
 }

AUTHORS

@@ -5,4 +5,5 @@ Barry Tulchinsky <barry.tulchinsky@gmail.com> (@btulchinsky)
 Kieran Sedgwick <kieran.sedgwick@gmail.com> (@sedge)
 Yoav Gurevich <ygurevich@ymail.com>
 Gideon Thomas <r.gideonthomas@gmail.com>
-Abdirahman Guled <aguled2@myseneca.ca>
+Abdirahman Guled <aguled2@myseneca.ca>
+Ben Heidemann <ben@heidemann.co.uk>

README.md

@@ -54,6 +54,78 @@ requirejs(['filer'], function(Filer) {...}
 var Filer = window.Filer;
 ```
 
+### Webpack Plugin
+
+Filer can be used as a drop-in replacement for the node.js [fs](http://nodejs.org/api/fs.html) and
+[path](http://nodejs.org/api/path.html) modules. For convenience, filer provides a webpack plugin which
+will shim the desired node.js functionality. This plugin can be used by inserting the following into
+your webpack config:
+
+```javascript
+// webpack.config.js
+var { FilerWebpackPlugin } = require('filer/webpack');
+
+module.exports = {
+  plugins: [
+    new FilerWebpackPlugin(),
+  ],
+}
+```
+
+---
+**NOTE**
+
+Previously it was recommended to access the `FilerWebpackPlugin` class by importing the main filer module. This was depracated due [this issue](https://github.com/filerjs/filer/issues/790). For anyone using ***filer version 1.4.0 or earlier***, please import the plugin class like this:
+
+```javascript
+var FilerWebpackPlugin = require('filer/src/webpack-plugin');
+```
+
+---
+
+You can then import the node.js [fs](http://nodejs.org/api/fs.html) and [path](http://nodejs.org/api/path.html)
+modules as normal and `FilerWebpackPlugin` will ensure that webpack will resolve references to these modules to
+the appropriate filer shims. You will then be able to use these modules as normal (with the exception of the
+synchronous fs methods e.g. `mkdirSync()`).
+
+```javascript
+import fs from 'fs';
+import path from 'path';
+```
+
+The filer webpack plugin will, by default, shim the [fs](http://nodejs.org/api/fs.html) and
+[path](http://nodejs.org/api/path.html) modules. However, it's behaviour can be customised by passing an
+options object.
+
+```javascript
+// webpack.config.js
+module.exports = {
+  plugins: [
+    new FilerWebpackPlugin({
+      // Options
+    }),
+  ],
+}
+```
+
+The following options can be passed to the filer webpack plugin:
+
+| Option        | Type    | Optional | Default                                          | Description                                                                                                                                      |
+|---------------|---------|----------|--------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|
+| filerDir      | string  | yes      | '\<rootDir\>/node_modules/filer'                 | The directory in which filer is installed.                                                                                                       |
+| shimsDir      | string  | yes      | '\<rootDir\>/node_modules/filer/shims'           | The directory in which the shims are installed.                                                                                                  |
+| fsProviderDir | string  | yes      | '\<rootDir\>/node_modules/filer/shims/providers' | The directory in which the shims are located. This option is required when using a custom provider.                                              |
+| shimFs        | boolean | yes      | true                                             | Should the fs module be shimmed.                                                                                                                 |
+| shimPath      | boolean | yes      | true                                             | Should the path module be shimmed.                                                                                                               |
+| fsProvider    | string  | yes      | 'default'                                        | The file system provider to use. Should be one of 'default', 'indexeddb', 'memory', 'custom'. The 'default' option is equivalent to 'indexeddb'. |
+
+NOTE: '\<rootDir\>' will be resolved to the current working directory.
+
+Though filer also exposes the Buffer object, it is left up to the user to shim this as appropriate. This is because filer offers
+no custom implementation. Currently, filer uses the [node-libs-browser](https://github.com/webpack/node-libs-browser) Buffer implementation
+internally, though any faithful implementation of the [node.js Buffer object](http://nodejs.org/api/buffer.html) should play nicely
+with filer.
+
 ### Getting Started
 
 Filer is as close to the node.js [fs module](http://nodejs.org/api/fs.html) as possible,
@@ -788,7 +860,7 @@ fs.mkdtemp("/myDir/tmp", function (error, path) {
 });
 ```
 
-#### fs.readdir(path, callback)<a name="readdir"></a>
+#### fs.readdir(path, [options], callback)<a name="readdir"></a>
 
 Reads the contents of a directory. Asynchronous [readdir(3)](http://pubs.opengroup.org/onlinepubs/009695399/functions/readdir.html).
 Callback gets `(error, files)`, where `files` is an array containing the names of each directory entry (i.e., file, directory, link) in the directory, excluding `.` and `..`.
@@ -809,6 +881,12 @@ fs.readdir('/docs', function(err, files) {
 });
 ```
 
+Optionally accepts an options parameter, which can be either an encoding (e.g. "utf8") or an object with optional properties `encoding` and `withFileTypes`.
+
+The `encoding` property is a `string` which will determine the character encoding to use for the names of each directory entry. The `withFileTypes` property is a `boolean` which defaults to `false`. If `true`, this method will return an array of [fs.Dirent](https://nodejs.org/api/fs.html#fs_class_fs_dirent) objects.
+
+The `name` property on the [fs.Dirent](https://nodejs.org/api/fs.html#fs_class_fs_dirent) objects will be encoded using the specified character encoding.
+
 #### fs.close(fd, callback)<a name="close"></a>
 
 Closes a file descriptor. Asynchronous [close(2)](http://pubs.opengroup.org/onlinepubs/009695399/functions/close.html).

karma.conf.js

@@ -2,10 +2,14 @@ module.exports = function(config) {
   config.set({
     singleRun: true,
     basePath: '',
-    files: ['tests/dist/index.js'],
+    files: [
+      'node_modules/regenerator-runtime/runtime.js',
+      'tests/dist/index.js'
+    ],
     frameworks: ['mocha', 'chai'],
     reporters: ['mocha', 'summary'],
     client: {
+      captureConsole: true,
       mocha: {
         ui: 'bdd',
         timeout: 5000,

package.json

@@ -10,7 +10,7 @@
     "indexeddb",
     "idb"
   ],
-  "version": "1.2.0",
+  "version": "1.4.1",
   "author": "Alan K <ack@modeswitch.org> (http://blog.modeswitch.org)",
   "homepage": "http://filerjs.github.io/filer",
   "bugs": "https://github.com/filerjs/filer/issues",
@@ -45,37 +45,41 @@
     "url": "https://github.com/filerjs/filer.git"
   },
   "dependencies": {
-    "es6-promisify": "^6.1.0",
-    "minimatch": "^3.0.4"
+    "es6-promisify": "^7.0.0",
+    "minimatch": "^3.0.4",
+    "schema-utils": "^3.1.1"
   },
   "devDependencies": {
-    "chai": "^4.2.0",
-    "chai-datetime": "^1.5.0",
-    "eslint": "^6.8.0",
-    "fake-indexeddb": "^3.0.0",
-    "karma": "^5.0.1",
+    "regenerator-runtime": "^0.13.9",
+    "chai": "^4.3.4",
+    "chai-datetime": "^1.8.0",
+    "eslint": "^7.32.0",
+    "fake-indexeddb": "^3.1.7",
+    "karma": "^6.3.8",
     "karma-chai": "^0.1.0",
     "karma-chrome-launcher": "^3.1.0",
-    "karma-firefox-launcher": "^1.3.0",
-    "karma-mocha": "^1.3.0",
+    "karma-firefox-launcher": "^2.1.2",
+    "karma-mocha": "^2.0.1",
     "karma-mocha-reporter": "^2.2.5",
-    "karma-summary-reporter": "^1.7.2",
-    "meow": "^6.1.0",
-    "mocha": "^7.1.1",
-    "nyc": "^15.0.1",
-    "parcel-bundler": "^1.12.4",
-    "pretty-bytes": "^5.3.0",
-    "release-it": "^13.5.2",
+    "karma-summary-reporter": "^3.0.0",
+    "meow": "^10.0.1",
+    "mocha": "^9.1.3",
+    "nyc": "^15.1.0",
+    "parcel-bundler": "^1.12.5",
+    "pretty-bytes": "^5.6.0",
+    "release-it": "^14.11.6",
     "run.env": "^1.1.0",
-    "unused-filename": "^2.1.0",
-    "walk": "^2.3.14"
+    "unused-filename": "^3.0.1",
+    "walk": "^2.3.15"
   },
   "main": "./src/index.js",
   "browser": "./dist/filer.min.js",
   "files": [
     "src",
     "lib",
-    "dist"
+    "dist",
+    "shims",
+    "webpack"
   ],
   "nyc": {
     "exclude": [

shims/fs.js

@@ -0,0 +1,65 @@
+const { FileSystem } = require('../src/index');
+
+let Provider;
+try {
+  Provider = require('fsProvider');
+}
+catch (err) {
+  Provider = require('./providers/default');
+}
+
+const provider = new Provider();
+
+let onFsReady;
+let onFsError;
+
+let fsReady = new Promise((resolve, reject) => {
+  onFsReady = resolve;
+  onFsError = reject;
+});
+
+var fsInstance = new FileSystem({ provider }, (err) => {
+  if (err) {
+    onFsError(err);
+  } else {
+    onFsReady(true);
+  }
+});
+
+function proxyHasProp(target, prop) {
+  return prop in target;
+}
+
+const fsPromises = new Proxy(fsInstance.promises, {
+  get(target, prop) {
+    if (!proxyHasProp(target, prop)) {
+      return;
+    }
+
+    return async (...args) => {
+      await fsReady;
+      return await target[prop](...args);
+    };
+  },
+});
+
+const fs = new Proxy(fsInstance, {
+  get(target, prop) {
+    if (!proxyHasProp(target, prop)) {
+      return;
+    }
+
+    if (prop === 'promises') {
+      return fsPromises;
+    }
+
+    return (...args) => {
+      (async () => {
+        await fsReady;
+        target[prop](...args);
+      })();
+    };
+  },
+});
+
+module.exports = fs;

shims/path.js

@@ -0,0 +1,3 @@
+const { path } = require('../src/index');
+
+module.exports = path;

shims/providers/default.js

@@ -0,0 +1,2 @@
+const { Default } = require('../../src/providers/index');
+module.exports = Default;

shims/providers/indexeddb.js

@@ -0,0 +1,2 @@
+const IndexedDB = require('../../src/providers/indexeddb');
+module.exports = IndexedDB;

shims/providers/memory.js

@@ -0,0 +1,2 @@
+const Memory = require('../../src/providers/memory');
+module.exports = Memory;

src/dirent.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const Stats = require('./stats.js');
+
+function Dirent(path, fileNode, devName) {
+  this.constructor = Dirent;
+  Stats.call(this, path, fileNode, devName);
+}
+
+Dirent.prototype = Stats.prototype;
+
+module.exports = Dirent;

src/filesystem/implementation.js

@@ -4,6 +4,7 @@ var dirname = Path.dirname;
 var basename = Path.basename;
 var isAbsolutePath = Path.isAbsolute;
 var shared = require('../shared.js');
+var async = require('../../lib/async.js');
 
 var Constants = require('../constants.js');
 var NODE_TYPE_FILE = Constants.NODE_TYPE_FILE;
@@ -35,6 +36,7 @@ var openFiles = require('../open-files.js');
 var OpenFileDescription = require('../open-file-description.js');
 var SuperNode = require('../super-node.js');
 var Node = require('../node.js');
+var Dirent = require('../dirent.js');
 var Stats = require('../stats.js');
 
 /**
@@ -478,7 +480,7 @@ function access_file(context, path, mode, callback) {
     }
 
     // In any other case, the file isn't accessible
-    callback(new Errors.EACCES('permission denied',path)) ; 
+    callback(new Errors.EACCES('permission denied',path)) ;
   });
 }
 
@@ -1077,7 +1079,7 @@ function unlink_node(context, path, callback) {
         context.putObject(fileNode.id, fileNode, function(error) {
           if(error) {
             callback(error);
-          } else {          
+          } else {
             update_node_times(context, path, fileNode, { ctime: Date.now() }, update_directory_data);
           }
         });
@@ -1120,26 +1122,72 @@ function unlink_node(context, path, callback) {
   find_node(context, parentPath, read_directory_data);
 }
 
-function read_directory(context, path, callback) {
+function read_directory(context, path, options, callback) {
   path = normalize(path);
 
+  if (typeof options === 'function') {
+    callback = options;
+    options = {};
+  }
+  options = validate_directory_options(options);
+
   var directoryNode;
   var directoryData;
 
   function handle_directory_data(error, result) {
-    if(error) {
+    if (error) {
       callback(error);
     } else {
       directoryData = result;
       var files = Object.keys(directoryData);
-      callback(null, files);
+
+      if (options.encoding) {
+        var fileBuffers = files.map(function (file) {
+          return Buffer.from(file);
+        });
+
+        if (options.encoding === 'buffer') {
+          files = fileBuffers;
+        }
+        else {
+          files = fileBuffers.map(function (fileBuffer) {
+            return fileBuffer.toString(options.encoding);
+          });
+        }
+      }
+
+      if (options.withFileTypes) {
+        var dirEnts = [];
+
+        // eslint-disable-next-line no-inner-declarations
+        function to_dir_entry(file, callback) {
+          const filename = Buffer.from(file, options.encoding).toString();
+          const filepath = Path.join(path, filename);
+          get_dir_entry(context, filepath, function(error, dirEnt) {
+            if (error) {
+              callback(error);
+            }
+            dirEnt.name = file;
+            dirEnts.push(dirEnt);
+            callback();
+          });
+        }
+
+        async.eachSeries(files, to_dir_entry, function (error) {
+          callback(error, dirEnts);
+        });
+      }
+
+      else {
+        callback(null, files);
+      }
     }
   }
 
   function read_directory_data(error, result) {
-    if(error) {
+    if (error) {
       callback(error);
-    } else if(result.type !== NODE_TYPE_DIRECTORY) {
+    } else if (result.type !== NODE_TYPE_DIRECTORY) {
       callback(new Errors.ENOTDIR(null, path));
     } else {
       directoryNode = result;
@@ -1150,6 +1198,30 @@ function read_directory(context, path, callback) {
   find_node(context, path, read_directory_data);
 }
 
+function get_dir_entry(context, path, callback) {
+  function check_result(error, result) {
+    if(error) {
+      callback(error);
+    } else {
+      var stats = new Dirent(path, result, context.name);
+      callback(null, stats);
+    }
+  }
+
+  lstat_file(context, path, check_result);
+}
+
+function validate_directory_options(options, enc) {
+  if (!options) {
+    options = { encoding: enc };
+  } else if (typeof options === 'function') {
+    options = { encoding: enc };
+  } else if (typeof options === 'string') {
+    options = { encoding: options };
+  }
+  return options;
+}
+
 function make_symbolic_link(context, srcpath, dstpath, callback) {
   dstpath = normalize(dstpath);
   var name = basename(dstpath);
@@ -1203,12 +1275,12 @@ function make_symbolic_link(context, srcpath, dstpath, callback) {
       // but store both versions, since we'll use the relative one in readlink().
       if(!isAbsolutePath(srcpath)) {
         fileNode.symlink_relpath = srcpath;
-        srcpath = Path.resolve(parentPath, srcpath); 
+        srcpath = Path.resolve(parentPath, srcpath);
       }
 
       fileNode.size = srcpath.length;
       fileNode.data = srcpath;
-      
+
       context.putObject(fileNode.id, fileNode, update_directory_data);
     });
   }
@@ -1686,7 +1758,7 @@ function mkdir(context, path, mode, callback) {
     mode = validateAndMaskMode(mode, FULL_READ_WRITE_EXEC_PERMISSIONS, callback);
     if(!mode) return;
   }
- 
+
   make_directory(context, path, callback);
 }
 
@@ -1704,14 +1776,14 @@ function mkdtemp(context, prefix, options, callback) {
   callback = arguments[arguments.length - 1];
   if(!prefix) {
     return callback(new Error('filename prefix is required'));
-  } 
+  }
 
   let random = shared.randomChars(6);
-  var path = prefix + '-' + random; 
+  var path = prefix + '-' + random;
 
   make_directory(context, path, function(error) {
     callback(error, path);
-  });  
+  });
 }
 
 function rmdir(context, path, callback) {
@@ -1869,12 +1941,17 @@ function writeFile(context, path, data, options, callback) {
     return callback(new Errors.EINVAL('flags is not valid', path));
   }
 
-  data = data || '';
-  if(typeof data === 'number') {
-    data = '' + data;
-  }
-  if(typeof data === 'string' && options.encoding === 'utf8') {
-    data = Buffer.from(data);
+  if(!Buffer.isBuffer(data)) {
+    if(typeof data === 'number') {
+      data = '' + data;
+    }
+    data = data || '';
+    if(typeof data !== 'string') {
+      data = Buffer.from(data.toString());
+    }
+    else {
+      data = Buffer.from(data || '', options.encoding || 'utf8');
+    }
   }
 
   open_file(context, path, flags, function(err, fileNode) {
@@ -2158,8 +2235,8 @@ function lseek(context, fd, offset, whence, callback) {
   }
 }
 
-function readdir(context, path, callback) {
-  read_directory(context, path, callback);
+function readdir(context, path, options, callback) {
+  read_directory(context, path, options, callback);
 }
 
 function toUnixTimestamp(time) {
@@ -2249,7 +2326,7 @@ function rename(context, oldpath, newpath, callback) {
   newpath = normalize(newpath);
 
   var oldParentPath = Path.dirname(oldpath);
-  var newParentPath = Path.dirname(oldpath);
+  var newParentPath = Path.dirname(newpath);
   var oldName = Path.basename(oldpath);
   var newName = Path.basename(newpath);
   var oldParentDirectory, oldParentData;

src/index.js

@@ -8,7 +8,17 @@ module.exports = Filer = {
   Path: require('./path.js'),
   path: require('./path.js'),
   Errors: require('./errors.js'),
-  Shell: require('./shell/shell.js')
+  Shell: require('./shell/shell.js'),
+  /**
+   * @deprecated Importing filer from your webpack config is not recommended.
+   * 
+   * The filer `FilerWebpackPlugin` class is exposed directly. 
+   * 
+   * ```
+   * const { FilerWebpackPlugin } = require('filer/webpack');
+   * ```
+   */
+  FilerWebpackPlugin: require('./webpack-plugin'),
 };
 
 // Add a getter for the `fs` instance, which returns

src/path.js

@@ -10,7 +10,7 @@ process.cwd = () => '/';
  * a few things we need for the browser environment.
  */
 const nodePath = require('path');
-const filerPath = Object.create(nodePath);
+const filerPath = Object.assign({}, nodePath);
 
 /**
  * Patch path.basename() to return / vs. ''

src/webpack-plugin/index.js

@@ -0,0 +1,81 @@
+var path = require('path');
+var utils = require('./utils');
+
+const PLUGIN_NAME = 'filer-webpack-plugin';
+
+const OPTIONS_SCHEMA = require('./schema');
+const OPTIONS_PROCESSORS = require('./processors');
+
+module.exports = class FilerWebpackPlugin {
+
+  constructor(options = {}) {
+    utils.validateOptions(options, OPTIONS_SCHEMA);
+    this.options = utils.processOptions(options, OPTIONS_PROCESSORS);
+  }
+
+  apply(compiler) {
+    compiler.hooks.normalModuleFactory.tap(
+      PLUGIN_NAME,
+      (factory) => {
+        factory.hooks.resolve.tap(
+          PLUGIN_NAME,
+          (resolveData) => {
+            // Resolve fsProvider if required
+            if (
+              resolveData.request === 'fsProvider'
+              && resolveData.context === this.options.shimsDir
+            ) {
+              return this.resolveFsProvider(resolveData);
+            }
+
+            // Ignore filer files (these should resolve modules normally)
+            if (resolveData.context.startsWith(this.options.filerDir)) return;
+
+            // Apply fs, path and buffer shims if required
+            switch (resolveData.request) {
+            case 'fs':
+              if (!this.options.shimFs) return;
+              return this.applyFsShim(resolveData);
+            case 'path':
+              if (!this.options.shimPath) return;
+              return this.applyPathShim(resolveData);
+            default:
+              return;
+            }
+          }
+        );
+      },
+    );
+  }
+
+  resolveFsProvider(resolveData) {
+    switch (this.options.fsProvider) {
+    case 'default':
+      resolveData.request = path.join(this.options.fsProviderDir, 'default.js');
+      break;
+    case 'indexeddb':
+      resolveData.request = path.join(this.options.fsProviderDir, 'indexeddb.js');
+      break;
+    case 'memory':
+      resolveData.request = path.join(this.options.fsProviderDir, 'memory.js');
+      break;
+    case 'custom':
+      resolveData.request = path.join(this.options.fsProviderDir, 'custom.js');
+      break;
+    default:
+      throw new Error([
+        'Invalid option for fsProvider.',
+        'fsProvider must be one of \'default\', \'indexeddb\', \'memory\' or \'custom\'.',
+        'If using a custom fsProvider, you must also provide the fsProviderDir option.'
+      ].join(' '));
+    }
+  }
+
+  applyFsShim(resolveData) {
+    resolveData.request = path.join(this.options.shimsDir, 'fs.js');
+  }
+    
+  applyPathShim(resolveData) {
+    resolveData.request = path.join(this.options.shimsDir, 'path.js');
+  }
+};

src/webpack-plugin/processors.js

@@ -0,0 +1,34 @@
+var path = require('path');
+
+const ROOT_DIR_TAG = '<rootDir>';
+const CWD = process.cwd();
+
+module.exports = {
+  filerDir: {
+    process: function(value) {
+      if (!value) {
+        return path.join(CWD, 'node_modules', 'filer');
+      }
+      return path.resolve(value.replace(ROOT_DIR_TAG, CWD));
+    },
+  },
+  shimsDir: {
+    process: function(value) {
+      if (!value) {
+        return path.join(CWD, 'node_modules', 'filer', 'shims');
+      }
+      return path.resolve(value.replace(ROOT_DIR_TAG, CWD));
+    }
+  },
+  fsProviderDir: {
+    process: function(value) {
+      if (!value) {
+        return path.join(CWD, 'node_modules', 'filer', 'shims', 'providers');
+      }
+      return path.resolve(value.replace(ROOT_DIR_TAG, CWD));
+    },
+  },
+  shimFs: { default: true },
+  shimPath: { default: true},
+  fsProvider: { default: 'default'},
+};

src/webpack-plugin/schema.js

@@ -0,0 +1,23 @@
+module.exports = {
+  type: 'object',
+  properties: {
+    filerDir: {
+      type: 'string',
+    },
+    shimsDir: {
+      type: 'string',
+    },
+    shimFs: {
+      type: 'boolean',
+    },
+    shimPath: {
+      type: 'boolean',
+    },
+    fsProvider: {
+      type: 'string',
+    },
+    fsProviderDir: {
+      type: 'string',
+    },
+  }
+};

src/webpack-plugin/utils.js

@@ -0,0 +1,26 @@
+var { validate } = require('schema-utils');
+
+function validateOptions(options, schema) {
+  validate(schema, options);
+}
+
+function processOptions(options, processors) {
+  const processedOptions = {};
+    
+  for (const [property, processor] of Object.entries(processors)) {
+    processedOptions[property] = options[property];
+    if (processedOptions[property] === undefined) {
+      processedOptions[property] = processor.default;
+    }
+    if (processor.process) {
+      processedOptions[property] = processor.process(processedOptions[property]);
+    }
+  }
+
+  return processedOptions;
+}
+
+module.exports = {
+  validateOptions,
+  processOptions,
+};

tests/bugs/issue773.js

@@ -0,0 +1,12 @@
+'use strict';
+const util = require('../lib/test-utils.js');
+
+describe('unexpected failures when calling fs functions (e.g. writeFile) with empty options object, issue 773', function() {
+  beforeEach(util.setup);
+  afterEach(util.cleanup);
+
+  it('should call fs.writeFile with an empty options object', function(done) {
+    const fs = util.fs();
+    fs.writeFile('/a', 'trololol', {}, done);
+  });
+});

tests/bugs/issue775.js

@@ -0,0 +1,115 @@
+'use strict';
+var util = require('../lib/test-utils.js');
+var expect = require('chai').expect;
+
+describe('fs.readdir fails when passing options, issue775', function () {
+  beforeEach(util.setup);
+  afterEach(util.cleanup);
+
+  function setup(fs, dir, cb) {
+    fs.mkdir(dir, undefined, (err) => {
+      if (err) {
+        cb(err);
+      }
+      else {
+        fs.writeFile(dir + '/file', '', (err) => {
+          if (err) {
+            cb(err);
+          }
+          else {
+            fs.mkdir(dir + '/folder', (err) => {
+              if (err) {
+                cb(err);
+              }
+              else {
+                fs.symlink(dir + '/file', dir + '/symlink', (err) => {
+                  if (err) {
+                    cb(err);
+                  }
+                  else {
+                    cb();
+                  }
+                });
+              }
+            });
+          }
+        });
+      }
+    });
+  }
+
+  it('should create a directory, add a file, folder and symbolic link then call fs.readdir with buffer encoding', function (done) {
+    var fs = util.fs();
+    setup(fs, '/test_dir', (err) => {
+      if (err) {
+        done(err);
+      }
+      fs.readdir('/test_dir', 'buffer', (err, data) => {
+        if (err) {
+          done(err);
+        }
+        else {
+          expect(data).to.have.length(3);
+
+          expect(data[0].toString()).to.equal('file');
+          expect(data[1].toString()).to.equal('folder');
+          expect(data[2].toString()).to.equal('symlink');
+
+          done();
+        }
+      });
+    });
+  });
+
+  it('should create a directory, add a file, folder and symbolic link then call fs.readdir with withFileTypes and encoding options', function (done) {
+    var fs = util.fs();
+    setup(fs, '/test_dir', (err) => {
+      if (err) {
+        done(err);
+      }
+      fs.readdir('/test_dir', { encoding: 'base64', withFileTypes: true }, (err, data) => {
+        if (err) {
+          done(err);
+        }
+        else {
+          expect(data).to.have.length(3);
+
+          expect(Buffer.from(data[0].name, 'base64').toString()).to.equal('file');
+          expect(Buffer.from(data[1].name, 'base64').toString()).to.equal('folder');
+          expect(Buffer.from(data[2].name, 'base64').toString()).to.equal('symlink');
+
+          expect(data[0].isFile()).to.be.true;
+          expect(data[1].isDirectory()).to.be.true;
+          expect(data[2].isSymbolicLink()).to.be.true;
+
+          done();
+        }
+      });
+    });
+  });
+
+  it('should create a directory then call fs.readdir without options', function (done) {
+    var fs = util.fs();
+    setup(fs, '/test_dir', (err) => {
+      if (err) {
+        done(err);
+      }
+      else {
+        fs.readdir('/test_dir', (err, data) => {
+          if (err) {
+            done(err);
+          }
+          else {
+            expect(data).to.have.length(3);
+
+            expect(data[0]).to.equal('file');
+            expect(data[1]).to.equal('folder');
+            expect(data[2]).to.equal('symlink');
+
+            done();
+          }
+        });
+      }
+    });
+  });
+});

tests/bugs/issue776.js

@@ -0,0 +1,12 @@
+'use strict';
+const util = require('../lib/test-utils.js');
+
+describe('fs.mkdir does not recursively create parent directories when called with { recursive: true }, issue776', function() {
+  beforeEach(util.setup);
+  afterEach(util.cleanup);
+
+  it.skip('should not throw when calling fs.mkdir with recursive flag set', function(done) {
+    const fs = util.fs();
+    fs.mkdir('/test_dir/a/b', { recursive: true }, done);
+  });
+});

tests/index.js

@@ -3,6 +3,13 @@
  * get them running by default.
  */
 
+// Shims
+require('./spec/shims/fs.spec');
+require('./spec/shims/path.spec');
+
+// Webpack Plugin
+require('./spec/webpack-plugin/webpack-plugin.spec');
+
 // Filer
 require('./spec/filer.spec');
 require('./spec/filer.buffer.spec.js');
@@ -84,6 +91,9 @@ require('./bugs/issue267.js');
 require('./bugs/issue270.js');
 require('./bugs/rename-dir-trailing-slash.js');
 require('./bugs/issue357.js');
+require('./bugs/issue773.js');
+require('./bugs/issue775.js');
+require('./bugs/issue776.js');
 
 // Sample code from README
 require('./spec/readme.example.spec');

tests/lib/test-utils.js

@@ -52,11 +52,13 @@ function shimIndexedDB(fn) {
     global.indexedDB = require('fake-indexeddb');
   }
 
-  fn();
+  var result = fn();
 
   if(addShim) {
     delete global.indexedDB;
   }
+
+  return result;
 }
 
 function setup(callback) {
@@ -157,6 +159,24 @@ const parseBJSON = json =>
       value
   );
 
+function createMockFn(implementation = undefined) {
+  const calls = [];
+  const mockFn = function(...args) {
+    calls.push({
+      args,
+    });
+    if (typeof implementation === 'function') {
+      return implementation(...args);
+    }
+  };
+  Object.defineProperty(mockFn, 'calls', {
+    get() {
+      return calls;
+    }
+  });
+  return mockFn;
+}
+
 module.exports = {
   uniqueName: uniqueName,
   setup: setup,
@@ -170,5 +190,6 @@ module.exports = {
   cleanup: cleanup,
   typedArrayEqual: typedArrayEqual,
   parseBJSON,
-  shimIndexedDB
+  shimIndexedDB,
+  createMockFn
 };

tests/spec/fs.rename.spec.js

@@ -20,7 +20,7 @@ describe('fs.rename', function() {
         if(error) throw error;
 
         fs.rename('/myfile', '/myfile', function(error) {
-          expect(error).not.to.exist; 
+          expect(error).not.to.exist;
           done();
         });
       });
@@ -108,6 +108,35 @@ describe('fs.rename', function() {
       });
   });
 
+  it('should rename an existing directory into another sub directory', () => {
+    var fsPromises = util.fs().promises;
+
+    return fsPromises.mkdir('/mydir')
+      .then(() => fsPromises.mkdir('/mydir/subdir'))
+      .then(() => fsPromises.mkdir('/anotherdir'))
+      .then(() => fsPromises.rename('/mydir', '/anotherdir/originaldir'))
+      .then(() => { fsPromises.stat('/mydir')
+        .catch((error) => {
+          expect(error).to.exist;
+          expect(error.code).to.equal('ENOENT');
+        });
+      })
+      .then(() => { fsPromises.stat('/anotherdir/mydir')
+        .catch((error) => {
+          expect(error).to.exist;
+          expect(error.code).to.equal('ENOENT');
+        });
+      })
+      .then(() => { fsPromises.stat('/anotherdir/originaldir/subdir')
+        .then(result => {
+          expect(result.nlinks).to.equal(1);
+        });
+      })
+      .catch((error) => {
+        if (error) throw error;
+      });
+  });
+
   it('should rename an existing directory if the new path points to an existing directory', function(done) {
     var fs = util.fs();
 

tests/spec/shims/fs.spec.js

@@ -0,0 +1,44 @@
+'use strict';
+const expect = require('chai').expect;
+const utils = require('../../lib/test-utils');
+const fs = utils.shimIndexedDB(() => require('../../../shims/fs'));
+
+describe('fs shim', () => {
+  it('should be defined', () => {
+    expect(fs).to.not.be.undefined;
+  });
+
+  it('should be an object', () => {
+    expect(typeof fs).to.equal('object');
+  });
+
+  it('should return a function when accessing fs.writeFile', () => {
+    expect(typeof fs.writeFile).to.equal('function');
+  });
+
+  it('should call callback when calling fs.writeFile', (done) => {
+    fs.writeFile('/test.txt', 'test', function(err) {
+      if(err) throw err;
+
+      done();
+    });
+  });
+
+  it('should return an object when accessing fs.promises', () => {
+    expect(typeof fs.promises).to.equal('object');
+  });
+
+  it('should return a function when accessing fs.promises.writeFile', () => {
+    expect(typeof fs.promises.writeFile).to.equal('function');
+  });
+
+  it('should return a promise which resolves when calling fs.promises.writeFile', (done) => {
+    const writeFilePromise = fs.promises.writeFile('/test2.txt', '');
+    expect(writeFilePromise instanceof Promise).to.equal(true);
+    writeFilePromise.then(() => {
+      done();
+    }).catch((err) => {
+      done(err);
+    });
+  });
+});

tests/spec/shims/path.spec.js

@@ -0,0 +1,14 @@
+'use strict';
+const expect = require('chai').expect;
+const path = require('../../../shims/path');
+const pathActual = require('../../../src/index').path;
+
+describe('path shim', () => {
+  it('should be defined', () => {
+    expect(path).to.not.be.undefined;
+  });
+
+  it('should be re-exposing path', () => {
+    expect(path).to.equal(pathActual);
+  });
+});

tests/spec/webpack-plugin/webpack-plugin.spec.js

@@ -0,0 +1,528 @@
+'use strict';
+const expect = require('chai').expect;
+const utils = require('../../lib/test-utils');
+const FilerWebpackPlugin = require('../../../src/webpack-plugin');
+
+function createNMFResolveCompilerObject(resolveData) {
+
+  const normalModuleFactory_resolve_tap = utils.createMockFn(function (name, callback) {
+    callback(resolveData);
+  });
+
+  const normalModuleFactory = {
+    hooks: {
+      resolve: {
+        tap: normalModuleFactory_resolve_tap
+      }
+    }
+  };
+
+  const normalModuleFactory_tap = utils.createMockFn(function (name, callback) {
+    callback(normalModuleFactory);
+  });
+
+  const compiler = {
+    hooks: {
+      normalModuleFactory: {
+        tap: normalModuleFactory_tap,
+      }
+    }
+  };
+
+  return {
+    compiler,
+    normalModuleFactory_tap,
+    normalModuleFactory_resolve_tap,
+  };
+}
+
+describe('path shim', () => {
+  it('should instantiate the plugin with valid options', () => {
+    // Arrange
+    const options = {
+      filerDir: '/filer',
+      shimsDir: '/shims',
+      fsProviderDir: '/fsProvider',
+      shimFs: false,
+      shimPath: false,
+      fsProvider: 'custom',
+    };
+
+    // Act
+    const plugin = new FilerWebpackPlugin(options);
+
+    // Assert
+    expect(plugin.options).to.not.be.undefined;
+
+    expect(plugin.options.filerDir).to.equal(options.filerDir);
+    expect(plugin.options.shimsDir).to.equal(options.shimsDir);
+    expect(plugin.options.fsProviderDir).to.equal(options.fsProviderDir);
+    expect(plugin.options.shimFs).to.equal(options.shimFs);
+    expect(plugin.options.shimPath).to.equal(options.shimPath);
+    expect(plugin.options.fsProvider).to.equal(options.fsProvider);
+  });
+
+  it('should instantiate the plugin with default options', () => {
+    // Act
+    const plugin = new FilerWebpackPlugin();
+
+    // Assert
+    expect(plugin.options).to.not.be.undefined;
+
+    expect(plugin.options.filerDir).to.equal('/node_modules/filer');
+    expect(plugin.options.shimsDir).to.equal('/node_modules/filer/shims');
+    expect(plugin.options.fsProviderDir).to.equal('/node_modules/filer/shims/providers');
+    expect(plugin.options.shimFs).to.equal(true);
+    expect(plugin.options.shimPath).to.equal(true);
+    expect(plugin.options.fsProvider).to.equal('default');
+  });
+
+  it('should throw if provided invalid options', () => {
+    // Arrange
+    const options = {
+      filerDir: 123,
+      shimsDir: 456,
+      fsProviderDir: 789,
+      shimFs: 'false',
+      shimPath: 'false',
+      fsProvider: false,
+    };
+
+    // Act // Assert
+    expect(() => {
+      new FilerWebpackPlugin(options);
+    }).to.throw();
+  });
+
+  it('should instantiate the plugin with options and the <rootDir> tag should be replaced', () => {
+    // Arrange
+    const options = {
+      filerDir: '<rootDir>/filer',
+      shimsDir: '<rootDir>/shims',
+      fsProviderDir: '<rootDir>/fsProvider',
+    };
+
+    // Act
+    const plugin = new FilerWebpackPlugin(options);
+
+    // Assert
+    expect(plugin.options).to.not.be.undefined;
+
+    expect(plugin.options.filerDir).to.equal(options.filerDir.replace('<rootDir>', ''));
+    expect(plugin.options.shimsDir).to.equal(options.shimsDir.replace('<rootDir>', ''));
+    expect(plugin.options.fsProviderDir).to.equal(options.fsProviderDir.replace('<rootDir>', ''));
+  });
+
+  describe('should instantiate the plugin with valid options and invoke the apply method', () => {
+    it('should ignore an unrelated module', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: false,
+        shimPath: false,
+        fsProvider: 'custom',
+      };
+
+      const resolveData = {
+        request: 'aModuleWeDontCareAbout',
+        context: '/some/random/directory',
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+        normalModuleFactory_tap,
+        normalModuleFactory_resolve_tap,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+      plugin.apply(compiler);
+
+      // Assert
+      expect(normalModuleFactory_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(normalModuleFactory_resolve_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_resolve_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(resolveDataIn.request).to.equal(resolveData.request);
+    });
+
+    it('should resolve fsProvider to <fsProviderDir>/default.js when fsProvider options is default', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: false,
+        shimPath: false,
+        fsProvider: 'default',
+      };
+
+      const resolveData = {
+        request: 'fsProvider',
+        context: options.shimsDir,
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+        normalModuleFactory_tap,
+        normalModuleFactory_resolve_tap,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+      plugin.apply(compiler);
+
+      // Assert
+      expect(normalModuleFactory_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(normalModuleFactory_resolve_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_resolve_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(resolveDataIn.request).to.equal(`${options.fsProviderDir}/default.js`);
+    });
+
+    it('should resolve fsProvider to <fsProviderDir>/indexeddb.js when fsProvider options is indexeddb', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: false,
+        shimPath: false,
+        fsProvider: 'indexeddb',
+      };
+
+      const resolveData = {
+        request: 'fsProvider',
+        context: options.shimsDir,
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+        normalModuleFactory_tap,
+        normalModuleFactory_resolve_tap,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+      plugin.apply(compiler);
+
+      // Assert
+      expect(normalModuleFactory_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(normalModuleFactory_resolve_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_resolve_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(resolveDataIn.request).to.equal(`${options.fsProviderDir}/indexeddb.js`);
+    });
+
+    it('should resolve fsProvider to <fsProviderDir>/memory.js when fsProvider options is memory', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: false,
+        shimPath: false,
+        fsProvider: 'memory',
+      };
+
+      const resolveData = {
+        request: 'fsProvider',
+        context: options.shimsDir,
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+        normalModuleFactory_tap,
+        normalModuleFactory_resolve_tap,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+      plugin.apply(compiler);
+
+      // Assert
+      expect(normalModuleFactory_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(normalModuleFactory_resolve_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_resolve_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(resolveDataIn.request).to.equal(`${options.fsProviderDir}/memory.js`);
+    });
+
+    it('should resolve fsProvider to <fsProviderDir>/custom.js when fsProvider options is custom', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: false,
+        shimPath: false,
+        fsProvider: 'custom',
+      };
+
+      const resolveData = {
+        request: 'fsProvider',
+        context: options.shimsDir,
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+        normalModuleFactory_tap,
+        normalModuleFactory_resolve_tap,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+      plugin.apply(compiler);
+
+      // Assert
+      expect(normalModuleFactory_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(normalModuleFactory_resolve_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_resolve_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(resolveDataIn.request).to.equal(`${options.fsProviderDir}/custom.js`);
+    });
+
+    it('should throw an error when an invalid options is provided for fsProvider', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: false,
+        shimPath: false,
+        fsProvider: 'invalid_fs_provider_option',
+      };
+
+      const resolveData = {
+        request: 'fsProvider',
+        context: options.shimsDir,
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+
+      // Act // Assert
+      expect(() => {
+        plugin.apply(compiler);
+      }).to.throw();
+    });
+
+    it('should ignore a request for fs when the context is in the filer directory', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: false,
+        shimPath: false,
+        fsProvider: 'custom',
+      };
+
+      const resolveData = {
+        request: 'fs',
+        context: options.filerDir + '/src',
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+        normalModuleFactory_tap,
+        normalModuleFactory_resolve_tap,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+      plugin.apply(compiler);
+
+      // Assert
+      expect(normalModuleFactory_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(normalModuleFactory_resolve_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_resolve_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(resolveDataIn.request).to.equal(resolveData.request);
+    });
+
+    it('should resolve a request for fs to the fs shim when the context is not in the filer directory', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: true,
+        shimPath: true,
+        fsProvider: 'custom',
+      };
+
+      const resolveData = {
+        request: 'fs',
+        context: '/some/random/directory',
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+        normalModuleFactory_tap,
+        normalModuleFactory_resolve_tap,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+      plugin.apply(compiler);
+
+      // Assert
+      expect(normalModuleFactory_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(normalModuleFactory_resolve_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_resolve_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(resolveDataIn.request).to.equal(`${options.shimsDir}/fs.js`);
+    });
+
+    it('should not resolve a request for fs to the fs shim when the context is not in the filer directory but shimFs is false', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: false,
+        shimPath: false,
+        fsProvider: 'custom',
+      };
+
+      const resolveData = {
+        request: 'fs',
+        context: '/some/random/directory',
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+        normalModuleFactory_tap,
+        normalModuleFactory_resolve_tap,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+      plugin.apply(compiler);
+
+      // Assert
+      expect(normalModuleFactory_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(normalModuleFactory_resolve_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_resolve_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(resolveDataIn.request).to.equal(resolveData.request);
+    });
+
+    it('should resolve a request for path to the path shim when the context is not in the filer directory', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: true,
+        shimPath: true,
+        fsProvider: 'custom',
+      };
+
+      const resolveData = {
+        request: 'path',
+        context: '/some/random/directory',
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+        normalModuleFactory_tap,
+        normalModuleFactory_resolve_tap,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+      plugin.apply(compiler);
+
+      // Assert
+      expect(normalModuleFactory_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(normalModuleFactory_resolve_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_resolve_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(resolveDataIn.request).to.equal(`${options.shimsDir}/path.js`);
+    });
+
+    it('should not resolve a request for path to the path shim when the context is not in the filer directory but shimPath is false', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: false,
+        shimPath: false,
+        fsProvider: 'custom',
+      };
+
+      const resolveData = {
+        request: 'path',
+        context: '/some/random/directory',
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+        normalModuleFactory_tap,
+        normalModuleFactory_resolve_tap,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+      plugin.apply(compiler);
+
+      // Assert
+      expect(normalModuleFactory_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(normalModuleFactory_resolve_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_resolve_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(resolveDataIn.request).to.equal(resolveData.request);
+    });
+  });
+});

webpack/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+  FilerWebpackPlugin: require('../src/webpack-plugin'),
+};