feat: Optionally only wrap modules hooked in --import

hook.js

@@ -250,6 +250,16 @@ function createHook (meta) {
     if (data) {
       includeModules = ensureArrayWithBareSpecifiersAndFileUrls(data.include, 'include')
       excludeModules = ensureArrayWithBareSpecifiersAndFileUrls(data.exclude, 'exclude')
+
+      if (data.addHookMessagePort) {
+        data.addHookMessagePort.on('message', (modules) => {
+          if (includeModules === undefined) {
+            includeModules = []
+          }
+
+          includeModules.push(...modules)
+        })
+      }
     }
   }
 

index.d.ts

@@ -84,3 +84,21 @@ export declare function addHook(hookFn: HookFunction): void
  * @param {HookFunction} hookFn The function to be removed.
  */
 export declare function removeHook(hookFn: HookFunction): void
+
+/**
+ * Creates a message channel with a port that can be used to add hooks to the
+ * list of exclusively included modules.
+ *
+ * This can be used to only wrap modules that are Hook'ed, however modules need
+ * to be hooked before they are imported.
+ *
+ * ```ts
+ * import { register } from 'module'
+ * import { createAddHookMessageChannel } from 'import-in-the-middle'
+ *
+ * const addHookMessagePort = createAddHookMessageChannel()
+ *
+ * register('import-in-the-middle/hook.mjs', import.meta.url, { data: { addHookMessagePort }, transferList: [addHookMessagePort] })
+ * ```
+ */
+export declare function createAddHookMessageChannel(): MessagePort;

index.js

@@ -5,6 +5,7 @@
 const path = require('path')
 const parse = require('module-details-from-path')
 const { fileURLToPath } = require('url')
+const { MessageChannel } = require('worker_threads')
 
 const {
   importHooks,
@@ -31,6 +32,18 @@ function callHookFn (hookFn, namespace, name, baseDir) {
   }
 }
 
+let sendToMessageChannel
+
+function createAddHookMessageChannel () {
+  const { port1, port2 } = new MessageChannel()
+
+  sendToMessageChannel = (modules) => {
+    port1.postMessage(modules)
+  }
+
+  return port2
+}
+
 function Hook (modules, options, hookFn) {
   if ((this instanceof Hook) === false) return new Hook(modules, options, hookFn)
   if (typeof modules === 'function') {
@@ -43,6 +56,10 @@ function Hook (modules, options, hookFn) {
   }
   const internals = options ? options.internals === true : false
 
+  if (sendToMessageChannel && Array.isArray(modules)) {
+    sendToMessageChannel(modules)
+  }
+
   this._iitmHook = (name, namespace) => {
     const filename = name
     const isBuiltin = name.startsWith('node:')
@@ -92,3 +109,4 @@ module.exports = Hook
 module.exports.Hook = Hook
 module.exports.addHook = addHook
 module.exports.removeHook = removeHook
+module.exports.createAddHookMessageChannel = createAddHookMessageChannel

test/fixtures/import-after.mjs

@@ -0,0 +1,13 @@
+import { strictEqual } from 'assert'
+import { sep } from 'path'
+import { Hook } from '../../index.js'
+
+const hooked = []
+
+Hook((_, name) => {
+  hooked.push(name)
+})
+
+strictEqual(hooked.length, 1)
+strictEqual(hooked[0], 'path')
+strictEqual(sep, '@')

test/fixtures/import.mjs

@@ -0,0 +1,14 @@
+import { register } from 'module'
+import { Hook, createAddHookMessageChannel } from '../../index.js'
+// We've imported path here to ensure that the hook is still applied later.
+import * as path from 'path'
+
+const addHookMessagePort = createAddHookMessageChannel()
+
+register('../../hook.mjs', import.meta.url, { data: { addHookMessagePort }, transferList: [addHookMessagePort] })
+
+Hook(['path'], (exports) => {
+  exports.sep = '@'
+})
+
+console.assert(path.sep !== '@')

test/register/v18.19-include-message-port.mjs

@@ -0,0 +1,7 @@
+import { spawnSync } from 'child_process'
+
+const out = spawnSync(process.execPath,
+  ['--import', './test/fixtures/import.mjs', './test/fixtures/import-after.mjs'],
+  { stdio: 'inherit', env: {} }
+)
+process.exit(out.status)