In other words, plugins shouldn't need to worry about recreating their watch streams when the subscription root is deleted. When a plugin only cares about file events within the root (and not the root itself), the watch stream should be abstracted away.

Possible solutions:

• add a new option to Package:stream
• add a new method to Package.prototype
• make this behavior the default

When two projects share the same watched root, using wch -u on either of the project roots results in an error. We should track which projects belong to consolidated roots.

Providing a simple copy function that projects can use in their project.js files to copy files from one directory to another (potentially renaming files as well) is a must, and the project shouldn't need a plugin dependency to get such functionality.

Sometimes, all you need is a foreground process that watches until you decide to stop it.

wch . -f

The server is heavy enough to warrant this.

Have wch start kick off the Watchman process, if necessary.

Make the plugin API more declarative and less verbose.

• wrap plugin modules in a function where this is the plugin instance
• all plugin configuration is hot-swapped (no more restarting every plugin)
• setup each plugin instance in its own VM context

API design

// Validated option types.
this.options = {
  sourceMaps: '?boolean|string',
};

// Global `warn` function
warn('something bad could happen');

// Global `print` function
print('something just happened');

// Watch a package.
this.watch = (pack, opts) => {
  // File matchers react to file changes (in watch mode).
  const files = pack.match(glob, opts);

  // Do something with every file that exists.
  files.each(file => {
    console.info(file); // Files are transient objects.
  });

  // Do something when a file is removed.
  files.on('unlink', (file) => {});

  // Do something when a file is added or changed.
  files.on('change', (file) => {});

  // Return a cleanup function. (optional)
  return () => {};
};

// Build a package.
this.build = (pack, opts) => {};

// The returned object serves as the prototype for
// the object exposed to "wch.config.js" as the plugin's name.
return {
  constructor() {
    // The `constructor` method is called automatically for each package.
    this.sources = new Map();
  },
  compile(src, dest) {
    // `this` is the `opts` object passed to `watch` and `build`.
    this.sources.set(src, dest);
  }
};

Inside a wch.config.js module, all exposed plugins have a set method that is used to pass an options object, which is validated by the plugin's option types.

When wch.config.js is updated, plugins are only restarted if the arguments to method calls are not deeply equal with the previous configuration. For set calls, plugins are never restarted, because those options are meant to be hot-swappable.

"File matchers" are cleaned up automatically. The pack.match method creates a file stream during the "watch" phase and a list of files during the "build" phase. This implementation detail is meant to be hidden from the plugin developer.

Beyond the warn and print functions, there are other implicitly exposed helpers:

• fs is the saxon library
• path is the built-in path module
• assert is the built-in assert module
• lazyRequire is a function that installs packages that aren't available

It will be clearer what the configuration is used by/for if we change the name to wch.config.js.

The project.js convention will be deprecated when the plugin API is reworked (#7).

Renaming a project root will probably always crash the wch server. Upon server restart, the old path is unwatched, so you'll need to use wch . in the project root after renaming it. Apart from the crashing, this isn't terrible, but also not ideal.

A simple Electron application for managing the wch daemon and its components.

• ability to start/stop the daemon

• toggle for starting the daemon on system startup

• view logs

  • filter by warn, error, or all
  • filter by plugin
     

• list of watched roots

• click a watched root to inspect it

  • generate a wch.config.js module
  • view/upgrade its plugins
  • unwatch it
     

• install/upgrade global plugins

• customize plugin defaults

• menu bar icon