Port to ESM

.eslintrc

@@ -6,20 +6,13 @@
  "extends": ["eslint:recommended", "plugin:import/errors", "plugin:import/warnings"],
  "plugins": ["import"],
  "parserOptions": {
- "ecmaVersion": 11
+ "ecmaVersion": 13,
+ "sourceType": "module"
  },
  "rules": {
  "eqeqeq": "error",
  "no-trailing-spaces": "error",
  "prefer-arrow-callback": "error",
  "semi": "error"
- },
- "overrides": [
- {
- "files": ["./**/*.mjs"],
- "parserOptions": {
- "sourceType": "module"
- }
- }
- ]
+ }
 }

README.md

@@ -48,6 +48,7 @@ There are a couple of command-line options that can be used to control which fil
 - `--respawn` - Keep watching for changes after the script has exited
 - `--timestamp` - The timestamp format to use for logging restarts
 - `--vm` - Load files using Node's VM
+- `--worker` - Hook into worker_threads.Worker constructor
 
 ## Passing arguments to node
 

bin/node-dev.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import dev from '../lib/index.js';
+import cli from '../lib/cli.js';
+
+const { script, scriptArgs, nodeArgs, opts } = cli(process.argv);
+
+dev(script, scriptArgs, nodeArgs, opts);

lib/cfg.js → lib/cfg.cjs

@@ -19,7 +19,8 @@ const defaultConfig = {
  poll: false,
  respawn: false,
  timestamp: 'HH:MM:ss',
- vm: true
+ vm: true,
+ worker: true
 };
 
 function read(dir) {

lib/clear.js

@@ -1,4 +1,2 @@
-const control = '\u001bc';
-const clearFactory = clear => (clear ? () => process.stdout.write(control) : () => {});
-
-module.exports = { clearFactory, control };
+export const control = '\u001bc';
+export const clearFactory = clear => (clear ? () => process.stdout.write(control) : () => {});

lib/cli.js

@@ -1,8 +1,8 @@
-const assert = require('assert');
-const minimist = require('minimist');
-const { resolve } = require('path');
+import assert from 'assert';
+import minimist from 'minimist';
+import { resolve } from 'path';
 
-const { getConfig } = require('./cfg');
+import { getConfig } from './cfg.cjs';
 
 const arrayify = v => (Array.isArray(v) ? [...v] : [v]);
 const argify = key => ({ arg: `--${key}`, key });
@@ -55,7 +55,7 @@ const unknownFactory = args => arg => {
  key && !nodeDevNumber.includes(key) && args.push({ arg, key });
 };
 
-module.exports = argv => {
+export default argv => {
  const nodeCustomArgs = [];
  const args = argv.slice(2).filter(nodeCustomFactory(nodeCustomArgs));
 

lib/ignore.js

@@ -18,7 +18,5 @@ const getPrefix = mod => {
 
 const isPrefixOf = value => prefix => value.startsWith(prefix);
 
-const configureDeps = deps => required => deps !== -1 && getLevel(required) > deps;
-const configureIgnore = ignore => required => ignore.some(isPrefixOf(required));
-
-module.exports = { configureDeps, configureIgnore };
+export const configureDeps = deps => required => deps !== -1 && getLevel(required) > deps;
+export const configureIgnore = ignore => required => ignore.some(isPrefixOf(required));

lib/index.js

@@ -1,15 +1,18 @@
-const { fork } = require('child_process');
-const filewatcher = require('filewatcher');
-const semver = require('semver');
-const { pathToFileURL } = require('url');
-
-const { clearFactory } = require('./clear');
-const { configureDeps, configureIgnore } = require('./ignore');
-const ipc = require('./ipc');
-const logFactory = require('./log');
-const notifyFactory = require('./notify');
-
-module.exports = function (
+import { fork } from 'child_process';
+import filewatcher from 'filewatcher';
+import { createRequire } from 'module';
+import semver from 'semver';
+
+import { clearFactory } from './clear.js';
+import { configureDeps, configureIgnore } from './ignore.js';
+import ipc from './ipc.cjs';
+import logFactory from './log.cjs';
+import notifyFactory from './notify.js';
+
+const require = createRequire(import.meta.url);
+const resolveHook = hook => require.resolve('./require/' + hook);
+
+export default function (
  script,
  scriptArgs,
  nodeArgs,
@@ -18,13 +21,16 @@ module.exports = function (
  debounce,
  dedupe,
  deps,
+ fork: patchFork,
  graceful_ipc: gracefulIPC,
  ignore,
  interval,
  notify: notifyEnabled,
  poll: forcePolling,
  respawn,
- timestamp
+ timestamp,
+ vm: patchVm,
+ worker: patchWorker
  }
 ) {
  if (!script) {
@@ -52,9 +58,6 @@ module.exports = function (
  const isIgnored = configureIgnore(ignore);
  const isTooDeep = configureDeps(deps);
 
- // Run ./dedupe.js as preload script
- if (dedupe) process.env.NODE_DEV_PRELOAD = require.resolve('./dedupe');
-
  const watcher = filewatcher({ debounce, forcePolling, interval });
  let isPaused = false;
 
@@ -89,20 +92,25 @@ module.exports = function (
  function start() {
  isPaused = false;
 
- const args = nodeArgs.slice();
+ const execArgv = nodeArgs.slice();
 
- args.push(`--require=${require.resolve('./wrap')}`);
+ execArgv.push(`--require=${resolveHook('suppress-experimental-warnings')}`);
+ if (dedupe) execArgv.push(`--require=${resolveHook('dedupe')}`);
+ execArgv.push(`--require=${resolveHook('patch')}`);
+ if (patchFork) execArgv.push(`--require=${resolveHook('patch-fork')}`);
+ if (patchVm) execArgv.push(`--require=${resolveHook('patch-vm')}`);
+ if (patchWorker) execArgv.push(`--require=${resolveHook('patch-worker')}`);
 
  const loaderName = semver.satisfies(process.version, '>=16.12.0') ? 'load' : 'get-format';
 
- const loaderURL = pathToFileURL(require.resolve(`./loaders/${loaderName}.mjs`));
+ const loaderURL = new URL(`./loaders/${loaderName}.mjs`, import.meta.url);
 
- args.push(`--experimental-loader=${loaderURL.href}`);
+ execArgv.push(`--experimental-loader=${loaderURL.href}`);
 
  child = fork(script, scriptArgs, {
  cwd: process.cwd(),
  env: process.env,
- execArgv: args
+ execArgv
  });
 
  if (respawn) {
@@ -155,4 +163,4 @@ module.exports = function (
 
  clearOutput();
  start();
-};
+}

lib/ipc.cjs

@@ -0,0 +1,52 @@
+const { once } = require('events');
+const { Worker } = require('worker_threads');
+
+const logFactory = require('./log.cjs');
+
+const cmd = 'NODE_DEV';
+const log = logFactory({});
+let nodeDevPort;
+
+exports.on = (src, prop, cb) => {
+ src.on('internalMessage', m => {
+ if (m.cmd === cmd && prop in m) cb(m);
+ });
+};
+
+exports.relay = src => {
+ if (src instanceof Worker) {
+ // create a separate message channel for node-dev
+ const { port1, port2 } = new MessageChannel();
+ port1.unref();
+ port1.on('message', exports.send);
+ src.postMessage({ cmd, port: port2 }, [port2]);
+ } else {
+ src.on('internalMessage', m => {
+ if (process.connected && m.cmd === cmd) process.send(m);
+ });
+ }
+};
+
+exports.send = m => {
+ if (process.connected) {
+ process.send({ ...m, cmd });
+ } else if (nodeDevPort) {
+ // this has doesn't seem to have a race condition in testing
+ // but just in case, the log statement below should notify of it
+ nodeDevPort.postMessage({ ...m, cmd });
+ } else {
+ log.warn(
+ `node-dev: The module ${m.required} was imported from an orphaned child process or worker thread`
+ );
+ }
+};
+
+exports.receiveMessagePort = async src => {
+ // the first message received by this thread should contain the parent port
+ const [m] = await once(src, 'message');
+ if (m && m.cmd === cmd) {
+ nodeDevPort = m.port;
+ } else {
+ log.warn('node-dev: unexpected message on the parentPort', m);
+ }
+};

lib/ipc.js

@@ -1,4 +1,11 @@
+const { once } = require('events');
+const { MessageChannel, Worker } = require('worker_threads');
+
+const logFactory = require('./log.cjs');
+
+let nodeDevPort;
 const cmd = 'NODE_DEV';
+const log = logFactory({});
 
 exports.on = (src, prop, cb) => {
  src.on('internalMessage', m => {
@@ -7,11 +14,39 @@ exports.on = (src, prop, cb) => {
 };
 
 exports.relay = src => {
- src.on('internalMessage', m => {
- if (process.connected && m.cmd === cmd) process.send(m);
- });
+ if (src instanceof Worker) {
+ // create a separate message channel for node-dev
+ const { port1, port2 } = new MessageChannel();
+ port1.unref();
+ port1.on('message', exports.send);
+ src.postMessage({ cmd, port: port2 }, [port2]);
+ } else {
+ src.on('internalMessage', m => {
+ if (process.connected && m.cmd === cmd) process.send(m);
+ });
+ }
 };
 
 exports.send = m => {
- if (process.connected) process.send({ ...m, cmd });
+ if (nodeDevPort) {
+ // this has doesn't seem to have a race condition in testing
+ // but just in case, the log statement below should notify of it
+ nodeDevPort.postMessage({ ...m, cmd });
+ } else if (process.connected) {
+ process.send({ ...m, cmd });
+ } else {
+ log.warn(
+ `node-dev: The module ${m.required} was imported from an orphaned child process or worker thread`
+ );
+ }
+};
+
+exports.receiveMessagePort = async src => {
+ // the first message received by this thread should contain the parent port
+ const [m] = await once(src, 'message');
+ if (m && m.cmd === cmd) {
+ nodeDevPort = m.port;
+ } else {
+ log.warn('node-dev: unexpected message on the parentPort', m);
+ }
 };

lib/loaders/get-format.mjs

@@ -1,6 +1,6 @@
 import { createRequire } from 'module';
 import { fileURLToPath } from 'url';
-import { send } from './ipc.mjs';
+import { send } from '../ipc.cjs';
 
 const require = createRequire(import.meta.url);
 

lib/loaders/load.mjs

@@ -1,6 +1,6 @@
 import { createRequire } from 'module';
 import { fileURLToPath } from 'url';
-import { send } from './ipc.mjs';
+import { send } from '../ipc.cjs';
 
 const require = createRequire(import.meta.url);