thread-stream 3.0.2 → 4.0.0

package/test/indexes.test.js

@@ -1,11 +1,11 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
+const assert = require('node:assert')
 const indexes = require('../lib/indexes')
 
 for (const index of Object.keys(indexes)) {
-  test(`${index} is lock free`, function (t) {
-    t.equal(Atomics.isLockFree(indexes[index]), true)
-    t.end()
+  test(`${index} is lock free`, function () {
+    assert.strictEqual(Atomics.isLockFree(indexes[index]), true)
   })
 }

package/test/multibyte-chars.test.mjs

@@ -1,11 +1,11 @@
-import { test } from 'tap'
+import { test } from 'node:test'
+import assert from 'node:assert'
 import { readFile } from 'fs'
 import ThreadStream from '../index.js'
 import { join } from 'desm'
 import { file } from './helper.js'
 
-test('break up utf8 multibyte (sync)', (t) => {
-  t.plan(2)
+test('break up utf8 multibyte (sync)', (t, done) => {
   const longString = '\u03A3'.repeat(16)
 
   const dest = file()
@@ -18,8 +18,9 @@ test('break up utf8 multibyte (sync)', (t) => {
 
   stream.on('finish', () => {
     readFile(dest, 'utf8', (err, data) => {
-      t.error(err)
-      t.equal(data, longString)
+      assert.ifError(err)
+      assert.strictEqual(data, longString)
+      done()
     })
   })
 
@@ -27,8 +28,7 @@ test('break up utf8 multibyte (sync)', (t) => {
   stream.end()
 })
 
-test('break up utf8 multibyte (async)', (t) => {
-  t.plan(2)
+test('break up utf8 multibyte (async)', (t, done) => {
   const longString = '\u03A3'.repeat(16)
 
   const dest = file()
@@ -41,8 +41,9 @@ test('break up utf8 multibyte (async)', (t) => {
 
   stream.on('finish', () => {
     readFile(dest, 'utf8', (err, data) => {
-      t.error(err)
-      t.equal(data, longString)
+      assert.ifError(err)
+      assert.strictEqual(data, longString)
+      done()
     })
   })
 
@@ -50,8 +51,7 @@ test('break up utf8 multibyte (async)', (t) => {
   stream.end()
 })
 
-test('break up utf8 multibyte several times bigger than write buffer', (t) => {
-  t.plan(2)
+test('break up utf8 multibyte several times bigger than write buffer', (t, done) => {
   const longString = '\u03A3'.repeat(32)
 
   const dest = file()
@@ -64,8 +64,9 @@ test('break up utf8 multibyte several times bigger than write buffer', (t) => {
 
   stream.on('finish', () => {
     readFile(dest, 'utf8', (err, data) => {
-      t.error(err)
-      t.equal(data, longString)
+      assert.ifError(err)
+      assert.strictEqual(data, longString)
+      done()
     })
   })
 

package/test/pkg/index.js

@@ -1,37 +1,37 @@
 'use strict'
 
 /**
- * This file is packaged using pkg in order to test if worker.js works in that context
+ * This file is packaged using pkg in order to test if worker.js works in that context.
+ * Note: We can't use node:test here because it crashes inside pkg bundles due to V8 internals.
  */
 
-const { test } = require('tap')
+const assert = require('node:assert')
 const { join } = require('path')
 const { file } = require('../helper')
 const ThreadStream = require('../..')
 
-test('bundlers support with .js file', function (t) {
-  t.plan(1)
+globalThis.__bundlerPathsOverrides = {
+  'thread-stream-worker': join(__dirname, '..', 'custom-worker.js')
+}
 
-  globalThis.__bundlerPathsOverrides = {
-    'thread-stream-worker': join(__dirname, '..', 'custom-worker.js')
-  }
+const dest = file()
 
-  const dest = file()
-
-  process.on('uncaughtException', (error) => {
-    console.log(error)
-  })
-
-  const stream = new ThreadStream({
-    filename: join(__dirname, '..', 'to-file.js'),
-    workerData: { dest },
-    sync: true
-  })
+process.on('uncaughtException', (error) => {
+  console.error(error)
+  process.exit(1)
+})
 
-  stream.worker.removeAllListeners('message')
-  stream.worker.once('message', (message) => {
-    t.equal(message.code, 'CUSTOM-WORKER-CALLED')
-  })
+const stream = new ThreadStream({
+  filename: join(__dirname, '..', 'to-file.js'),
+  workerData: { dest },
+  sync: true
+})
 
-  stream.end()
+stream.worker.removeAllListeners('message')
+stream.worker.once('message', (message) => {
+  assert.strictEqual(message.code, 'CUSTOM-WORKER-CALLED')
+  console.log('pkg test passed')
+  process.exit(0)
 })
+
+stream.end()

package/test/pkg/pkg.config.json

@@ -5,10 +5,9 @@
             "../to-file.js"
         ],
         "targets": [
-            "node14",
-            "node16",
-            "node18",
-            "node20"
+            "node20",
+            "node22",
+            "node24"
         ],
         "outputPath": "test/pkg"
     }

package/test/pkg/pkg.test.js

@@ -1,6 +1,7 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
+const assert = require('node:assert')
 const config = require('./pkg.config.json')
 const { promisify } = require('util')
 const { unlink } = require('fs/promises')
@@ -8,7 +9,7 @@ const { join } = require('path')
 const { platform } = require('process')
 const exec = promisify(require('child_process').exec)
 
-test('worker test when packaged into executable using pkg', async (t) => {
+test('worker test when packaged into executable using pkg', async () => {
   const packageName = 'index'
 
   // package the app into several node versions, check config for more info
@@ -19,7 +20,7 @@ test('worker test when packaged into executable using pkg', async (t) => {
   const { stderr } = await exec(`npx pkg ${filePath} --config ${configPath}`)
 
   // there should be no error when packaging
-  t.equal(stderr, '')
+  assert.strictEqual(stderr, '')
 
   // pkg outputs files in the following format by default: {filename}-{node version}
   for (const target of config.pkg.targets) {
@@ -36,11 +37,9 @@ test('worker test when packaged into executable using pkg', async (t) => {
     const { stderr } = await exec(executablePath)
 
     // check if there were no errors
-    t.equal(stderr, '')
+    assert.strictEqual(stderr, '')
 
     // clean up afterwards
     await unlink(executablePath)
   }
-
-  t.end()
 })

package/test/post-message.test.js

@@ -1,24 +1,23 @@
 'use strict'
 
-const { test } = require('tap')
+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('..')
 
 test('message events emitted on the stream are posted to the worker', async function (t) {
-  t.plan(1)
-
   const { port1, port2 } = new MessageChannel()
   const stream = new ThreadStream({
     filename: join(__dirname, 'on-message.js'),
     sync: false
   })
-  t.teardown(() => {
+  t.after(() => {
     stream.end()
   })
 
   stream.emit('message', { text: 'hello', takeThisPortPlease: port1 }, [port1])
   const [confirmation] = await once(port2, 'message')
-  t.equal(confirmation, 'received: hello')
+  assert.strictEqual(confirmation, 'received: hello')
 })

package/test/string-limit-2.test.js

@@ -1,12 +1,7 @@
 'use strict'
 
-const t = require('tap')
-
-if (process.env.CI) {
-  t.skip('skip on CI')
-  process.exit(0)
-}
-
+const { test } = require('node:test')
+const assert = require('node:assert')
 const { join } = require('path')
 const { file } = require('./helper')
 const { createReadStream } = require('fs')
@@ -15,27 +10,26 @@ const buffer = require('buffer')
 
 const MAX_STRING = buffer.constants.MAX_STRING_LENGTH
 
-t.plan(1)
-
-const dest = file()
-const stream = new ThreadStream({
-  filename: join(__dirname, 'to-file.js'),
-  workerData: { dest },
-  sync: false
-})
-
-stream.on('close', async () => {
-  t.comment('close emitted')
-  let buf
-  for await (const chunk of createReadStream(dest)) {
-    buf = chunk
-  }
-  t.equal('asd', buf.toString().slice(-3))
-})
-
-stream.on('ready', () => {
-  t.comment('open emitted')
-  stream.write('a'.repeat(MAX_STRING - 2))
-  stream.write('asd')
-  stream.end()
+test('string limit 2', { skip: process.env.CI }, (t, done) => {
+  const dest = file()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'to-file.js'),
+    workerData: { dest },
+    sync: false
+  })
+
+  stream.on('close', async () => {
+    let buf
+    for await (const chunk of createReadStream(dest)) {
+      buf = chunk
+    }
+    assert.strictEqual('asd', buf.toString().slice(-3))
+    done()
+  })
+
+  stream.on('ready', () => {
+    stream.write('a'.repeat(MAX_STRING - 2))
+    stream.write('asd')
+    stream.end()
+  })
 })

package/test/string-limit.test.js

@@ -1,42 +1,37 @@
 'use strict'
 
-const t = require('tap')
-
-if (process.env.CI) {
-  t.skip('skip on CI')
-  process.exit(0)
-}
-
+const { test } = require('node:test')
+const assert = require('node:assert')
 const { join } = require('path')
 const { file } = require('./helper')
 const { stat } = require('fs')
 const ThreadStream = require('..')
 
-t.setTimeout(30000)
-
-const dest = file()
-const stream = new ThreadStream({
-  filename: join(__dirname, 'to-file.js'),
-  workerData: { dest },
-  sync: false
-})
+test('string limit', { skip: process.env.CI, timeout: 30000 }, (t, done) => {
+  const dest = file()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'to-file.js'),
+    workerData: { dest },
+    sync: false
+  })
 
-let length = 0
+  let length = 0
 
-stream.on('close', () => {
-  stat(dest, (err, f) => {
-    t.error(err)
-    t.equal(f.size, length)
-    t.end()
+  stream.on('close', () => {
+    stat(dest, (err, f) => {
+      assert.ifError(err)
+      assert.strictEqual(f.size, length)
+      done()
+    })
   })
-})
 
-const buf = Buffer.alloc(1024).fill('x').toString() // 1 KB
+  const buf = Buffer.alloc(1024).fill('x').toString() // 1 KB
 
-// This writes 1 GB of data
-for (let i = 0; i < 1024 * 1024; i++) {
-  length += buf.length
-  stream.write(buf)
-}
+  // This writes 1 GB of data
+  for (let i = 0; i < 1024 * 1024; i++) {
+    length += buf.length
+    stream.write(buf)
+  }
 
-stream.end()
+  stream.end()
+})

package/test/syntax-error.mjs

@@ -0,0 +1,2 @@
+// this is a syntax error
+import

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,24 @@ test('emit error if thread exits', async function (t) {
     sync: true
   })
 
+  const closed = once(stream, 'close').catch(() => {})
+
   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 +52,24 @@ test('emit error if thread have unhandledRejection', async function (t) {
     sync: true
   })
 
+  const closed = once(stream, 'close').catch(() => {})
+
   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 +78,24 @@ test('emit error if worker stream emit error', async function (t) {
     sync: true
   })
 
+  const closed = once(stream, 'close').catch(() => {})
+
   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 +104,24 @@ test('emit error if thread have uncaughtException', async function (t) {
     sync: true
   })
 
+  const closed = once(stream, 'close').catch(() => {})
+
   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 +131,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/.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)
-})