thread-stream 3.1.0 → 4.0.0

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/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)
-})

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()
-})