thread-stream 3.1.0 → 4.1.0

package/test/thread-management.test.js

@@ -1,6 +1,7 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
+const assert = require('node:assert')
 const { fork } = require('child_process')
 const { join } = require('path')
 const { readFile } = require('fs').promises
@@ -13,10 +14,10 @@ test('exits with 0', async function (t) {
   const child = fork(join(__dirname, 'create-and-exit.js'), [dest])
 
   const [code] = await once(child, 'exit')
-  t.equal(code, 0)
+  assert.strictEqual(code, 0)
 
   const data = await readFile(dest, 'utf8')
-  t.equal(data, 'hello world\n')
+  assert.strictEqual(data, 'hello world\n')
 })
 
 test('emit error if thread exits', async function (t) {
@@ -25,20 +26,27 @@ test('emit error if thread exits', async function (t) {
     sync: true
   })
 
+  const closed = once(stream, 'close').catch(() => {})
+  // Keep a persistent error listener to avoid unhandled late error events
+  // reported as asynchronous activity by stricter test runners.
+  stream.on('error', () => {})
+
   stream.on('ready', () => {
     stream.write('hello world\n')
   })
 
   let [err] = await once(stream, 'error')
-  t.equal(err.message, 'the worker thread exited')
+  assert.strictEqual(err.message, 'the worker thread exited')
 
   stream.write('noop');
   [err] = await once(stream, 'error')
-  t.equal(err.message, 'the worker has exited')
+  assert.strictEqual(err.message, 'the worker has exited')
 
   stream.write('noop');
   [err] = await once(stream, 'error')
-  t.equal(err.message, 'the worker has exited')
+  assert.strictEqual(err.message, 'the worker has exited')
+
+  await closed
 })
 
 test('emit error if thread have unhandledRejection', async function (t) {
@@ -47,20 +55,27 @@ test('emit error if thread have unhandledRejection', async function (t) {
     sync: true
   })
 
+  const closed = once(stream, 'close').catch(() => {})
+  // Keep a persistent error listener to avoid unhandled late error events
+  // reported as asynchronous activity by stricter test runners.
+  stream.on('error', () => {})
+
   stream.on('ready', () => {
     stream.write('hello world\n')
   })
 
   let [err] = await once(stream, 'error')
-  t.equal(err.message, 'kaboom')
+  assert.strictEqual(err.message, 'kaboom')
 
   stream.write('noop');
   [err] = await once(stream, 'error')
-  t.equal(err.message, 'the worker has exited')
+  assert.strictEqual(err.message, 'the worker has exited')
 
   stream.write('noop');
   [err] = await once(stream, 'error')
-  t.equal(err.message, 'the worker has exited')
+  assert.strictEqual(err.message, 'the worker has exited')
+
+  await closed
 })
 
 test('emit error if worker stream emit error', async function (t) {
@@ -69,20 +84,27 @@ test('emit error if worker stream emit error', async function (t) {
     sync: true
   })
 
+  const closed = once(stream, 'close').catch(() => {})
+  // Keep a persistent error listener to avoid unhandled late error events
+  // reported as asynchronous activity by stricter test runners.
+  stream.on('error', () => {})
+
   stream.on('ready', () => {
     stream.write('hello world\n')
   })
 
   let [err] = await once(stream, 'error')
-  t.equal(err.message, 'kaboom')
+  assert.strictEqual(err.message, 'kaboom')
 
   stream.write('noop');
   [err] = await once(stream, 'error')
-  t.equal(err.message, 'the worker has exited')
+  assert.strictEqual(err.message, 'the worker has exited')
 
   stream.write('noop');
   [err] = await once(stream, 'error')
-  t.equal(err.message, 'the worker has exited')
+  assert.strictEqual(err.message, 'the worker has exited')
+
+  await closed
 })
 
 test('emit error if thread have uncaughtException', async function (t) {
@@ -91,20 +113,27 @@ test('emit error if thread have uncaughtException', async function (t) {
     sync: true
   })
 
+  const closed = once(stream, 'close').catch(() => {})
+  // Keep a persistent error listener to avoid unhandled late error events
+  // reported as asynchronous activity by stricter test runners.
+  stream.on('error', () => {})
+
   stream.on('ready', () => {
     stream.write('hello world\n')
   })
 
   let [err] = await once(stream, 'error')
-  t.equal(err.message, 'kaboom')
+  assert.strictEqual(err.message, 'kaboom')
 
   stream.write('noop');
   [err] = await once(stream, 'error')
-  t.equal(err.message, 'the worker has exited')
+  assert.strictEqual(err.message, 'the worker has exited')
 
   stream.write('noop');
   [err] = await once(stream, 'error')
-  t.equal(err.message, 'the worker has exited')
+  assert.strictEqual(err.message, 'the worker has exited')
+
+  await closed
 })
 
 test('close the work if out of scope on gc', { skip: !global.WeakRef }, async function (t) {
@@ -114,8 +143,8 @@ test('close the work if out of scope on gc', { skip: !global.WeakRef }, async fu
   })
 
   const [code] = await once(child, 'exit')
-  t.equal(code, 0)
+  assert.strictEqual(code, 0)
 
   const data = await readFile(dest, 'utf8')
-  t.equal(data, 'hello world\n')
+  assert.strictEqual(data, 'hello world\n')
 })

package/test/transpiled.test.js

@@ -1,14 +1,13 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
+const assert = require('node:assert')
 const { join } = require('path')
 const { file } = require('./helper')
 const ThreadStream = require('..')
 
 function basic (esVersion) {
-  test(`transpiled-ts-to-${esVersion}`, function (t) {
-    t.plan(2)
-
+  test(`transpiled-ts-to-${esVersion}`, function () {
     const dest = file()
     const stream = new ThreadStream({
       filename: join(__dirname, 'ts', `to-file.${esVersion}.cjs`),
@@ -18,9 +17,9 @@ function basic (esVersion) {
 
     // There are arbitrary checks, the important aspect of this test is to ensure
     // that we can properly load the transpiled file into our worker thread.
-    t.same(stream.writableEnded, false)
+    assert.deepStrictEqual(stream.writableEnded, false)
     stream.end()
-    t.same(stream.writableEnded, true)
+    assert.deepStrictEqual(stream.writableEnded, true)
   })
 }
 

package/test/ts-native.test.mjs

@@ -0,0 +1,35 @@
+import { test } from 'node:test'
+import assert from 'node:assert'
+import { readFile } from 'fs/promises'
+import ThreadStream from '../index.js'
+import { join } from 'desm'
+import { file } from './helper.js'
+
+const nodeVersion = parseInt(process.versions.node.split('.')[0], 10)
+
+// Native TypeScript stripping (--experimental-strip-types) is only available in Node 22.6+
+test('typescript module with native type stripping', { skip: nodeVersion < 22 }, async function (t) {
+  const dest = file()
+  const stream = new ThreadStream({
+    filename: join(import.meta.url, 'ts', 'to-file.ts'),
+    workerData: { dest },
+    workerOpts: {
+      execArgv: ['--experimental-strip-types', '--disable-warning=ExperimentalWarning']
+    },
+    sync: false
+  })
+
+  t.after(() => stream.end())
+
+  assert.ok(stream.write('hello world\n'))
+  assert.ok(stream.write('something else\n'))
+
+  stream.end()
+
+  await new Promise((resolve) => {
+    stream.on('close', resolve)
+  })
+
+  const data = await readFile(dest, 'utf8')
+  assert.strictEqual(data, 'hello world\nsomething else\n')
+})

package/test/ts-node-fallback.test.js

@@ -0,0 +1,35 @@
+'use strict'
+
+const { test } = require('node:test')
+const assert = require('node:assert')
+const { readFile } = require('fs/promises')
+const { join } = require('path')
+const { file } = require('./helper')
+const ThreadStream = require('..')
+
+// This test verifies that TypeScript files can be loaded via ts-node
+// when native type stripping is not enabled in the worker thread.
+// Unlike ts.test.ts which passes --experimental-strip-types via execArgv,
+// this test does NOT pass that flag, so the worker will fall back to ts-node.
+test('typescript module with ts-node fallback', async function (t) {
+  const dest = file()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'ts', 'to-file.ts'),
+    workerData: { dest },
+    sync: false
+  })
+
+  t.after(() => stream.end())
+
+  assert.ok(stream.write('hello world\n'))
+  assert.ok(stream.write('something else\n'))
+
+  stream.end()
+
+  await new Promise((resolve) => {
+    stream.on('close', resolve)
+  })
+
+  const data = await readFile(dest, 'utf8')
+  assert.strictEqual(data, 'hello world\nsomething else\n')
+})

package/test/watch-mode.test.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const { test } = require('node:test')
+const assert = require('node:assert')
+const { once } = require('events')
+const { join } = require('path')
+const ThreadStream = require('..')
+
+test('ignores worker messages without a protocol code', async function () {
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'message-without-code.js'),
+    sync: false
+  })
+
+  const errors = []
+  stream.on('error', err => {
+    errors.push(err)
+  })
+
+  const ready = once(stream, 'ready')
+  const close = once(stream, 'close')
+
+  assert.ok(stream.write('hello world\n'))
+  stream.end()
+
+  await ready
+  await close
+
+  assert.deepStrictEqual(errors, [])
+})

package/test/worker-name.test.js

@@ -0,0 +1,43 @@
+'use strict'
+
+const { test } = require('node:test')
+const assert = require('node:assert')
+const { join } = require('path')
+const { once } = require('events')
+const { MessageChannel } = require('worker_threads')
+const ThreadStream = require('..')
+
+// threadName was added in Node.js v22.20.0 and v24.6.0
+const [major, minor] = process.versions.node.split('.').map(Number)
+const supportsThreadName = (major === 22 && minor >= 20) || major >= 24
+
+test('worker has default name "thread-stream"', { skip: !supportsThreadName }, async function (t) {
+  const { port1, port2 } = new MessageChannel()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'report-thread-name.js'),
+    sync: true
+  })
+
+  t.after(() => stream.end())
+
+  stream.emit('message', { port: port1 }, [port1])
+  const [{ threadName }] = await once(port2, 'message')
+  assert.strictEqual(threadName, 'thread-stream')
+})
+
+test('worker name can be overridden via workerOpts', { skip: !supportsThreadName }, async function (t) {
+  const { port1, port2 } = new MessageChannel()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'report-thread-name.js'),
+    workerOpts: {
+      name: 'my-custom-worker'
+    },
+    sync: true
+  })
+
+  t.after(() => stream.end())
+
+  stream.emit('message', { port: port1 }, [port1])
+  const [{ threadName }] = await once(port2, 'message')
+  assert.strictEqual(threadName, 'my-custom-worker')
+})

package/.husky/pre-commit

@@ -1,4 +0,0 @@
-#!/usr/bin/env sh
-. "$(dirname -- "$0")/_/husky.sh"
-
-npm test

package/.taprc

@@ -1,4 +0,0 @@
-jobs: 1
-check-coverage: false
-# in seconds
-timeout: 60

package/test/never-drain.test.js

@@ -1,57 +0,0 @@
-const { test } = require('tap')
-const ThreadStream = require('../index')
-const { join } = require('path')
-
-function retryUntilTimeout (fn, timeout) {
-  const start = Date.now()
-  return new Promise((resolve, reject) => {
-    async function run () {
-      if (fn()) {
-        resolve()
-        return
-      }
-
-      if (Date.now() - start >= timeout) {
-        reject(new Error('timeout'))
-        return
-      }
-      setTimeout(run, 10)
-    }
-
-    run()
-  })
-}
-
-const isNode18 = process.version.indexOf('v18') === 0
-
-test('emit warning when the worker gracefully exit without the stream ended', { skip: !isNode18 }, async function (t) {
-  const expectedWarning = 'ThreadStream: process exited before destination stream was drained. this may indicate that the destination stream try to write to a another missing stream'
-  const stream = new ThreadStream({
-    filename: join(__dirname, 'to-next.js')
-  })
-  stream.unref()
-
-  let streamWarning
-  function saveWarning (e) {
-    if (e.message === expectedWarning) {
-      streamWarning = e
-    }
-  }
-  process.on('warning', saveWarning)
-
-  const data = 'hello'.repeat(10)
-  for (let i = 0; i < 1000; i++) {
-    if (streamWarning?.message === expectedWarning) {
-      break
-    }
-    stream.write(data)
-    await new Promise((resolve) => {
-      setTimeout(resolve, 1)
-    })
-  }
-
-  process.off('warning', saveWarning)
-  t.equal(streamWarning?.message, expectedWarning)
-
-  await retryUntilTimeout(() => stream.worker.exited === true, 3000)
-})

package/test/ts.test.ts

@@ -1,33 +0,0 @@
-import { test } from 'tap'
-import { readFile } from 'fs'
-import ThreadStream from '../index.js'
-import { join } from 'path'
-import { file } from './helper.js'
-
-
-test('typescript module', function (t) {
-  t.plan(5)
-
-  const dest = file()
-  const stream = new ThreadStream({
-    filename: join(__dirname, 'ts', 'to-file.ts'),
-    workerData: { dest },
-    sync: true
-  })
-
-  stream.on('finish', () => {
-    readFile(dest, 'utf8', (err, data) => {
-      t.error(err)
-      t.equal(data, 'hello world\nsomething else\n')
-    })
-  })
-
-  stream.on('close', () => {
-    t.pass('close emitted')
-  })
-
-  t.ok(stream.write('hello world\n'))
-  t.ok(stream.write('something else\n'))
-
-  stream.end()
-})