@zuplo/cli 7.0.2 → 7.1.1

package/node_modules/@zuplo/editor/node_modules/thread-stream/lib/worker.js

@@ -0,0 +1,186 @@
+'use strict'
+
+const { realImport, realRequire } = require('real-require')
+const { workerData, parentPort } = require('worker_threads')
+const { WRITE_INDEX, READ_INDEX, SEQ_INDEX } = require('./indexes')
+const { waitDiff } = require('./wait')
+
+const {
+  dataBuf,
+  filename,
+  stateBuf
+} = workerData
+
+let destination
+
+const state = new Int32Array(stateBuf)
+const data = Buffer.from(dataBuf)
+
+async function start () {
+  let worker
+  try {
+    if (filename.endsWith('.ts') || filename.endsWith('.cts')) {
+      // TODO: add support for the TSM modules loader ( https://github.com/lukeed/tsm ).
+      if (!process[Symbol.for('ts-node.register.instance')]) {
+        realRequire('ts-node/register')
+      } else if (process.env.TS_NODE_DEV) {
+        realRequire('ts-node-dev')
+      }
+      // TODO: Support ES imports once tsc, tap & ts-node provide better compatibility guarantees.
+      // Remove extra forwardslash on Windows
+      worker = realRequire(decodeURIComponent(filename.replace(process.platform === 'win32' ? 'file:///' : 'file://', '')))
+    } else {
+      worker = (await realImport(filename))
+    }
+  } catch (error) {
+    // A yarn user that tries to start a ThreadStream for an external module
+    // provides a filename pointing to a zip file.
+    // eg. require.resolve('pino-elasticsearch') // returns /foo/pino-elasticsearch-npm-6.1.0-0c03079478-6915435172.zip/bar.js
+    // The `import` will fail to try to load it.
+    // This catch block executes the `require` fallback to load the module correctly.
+    // In fact, yarn modifies the `require` function to manage the zipped path.
+    // More details at https://github.com/pinojs/pino/pull/1113
+    // The error codes may change based on the node.js version (ENOTDIR > 12, ERR_MODULE_NOT_FOUND <= 12 )
+    if ((error.code === 'ENOTDIR' || error.code === 'ERR_MODULE_NOT_FOUND') &&
+     filename.startsWith('file://')) {
+      worker = realRequire(decodeURIComponent(filename.replace('file://', '')))
+    } else if (error.code === undefined || error.code === 'ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING') {
+      // When bundled with pkg, an undefined error is thrown when called with realImport
+      // When bundled with pkg and using node v20, an ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING error is thrown when called with realImport
+      // More info at: https://github.com/pinojs/thread-stream/issues/143
+      try {
+        worker = realRequire(decodeURIComponent(filename.replace(process.platform === 'win32' ? 'file:///' : 'file://', '')))
+      } catch {
+        throw error
+      }
+    } else {
+      throw error
+    }
+  }
+
+  // Depending on how the default export is performed, and on how the code is
+  // transpiled, we may find cases of two nested "default" objects.
+  // See https://github.com/pinojs/pino/issues/1243#issuecomment-982774762
+  if (typeof worker === 'object') worker = worker.default
+  if (typeof worker === 'object') worker = worker.default
+
+  destination = await worker(workerData.workerData)
+
+  destination.on('error', function (err) {
+    Atomics.store(state, WRITE_INDEX, -2)
+    Atomics.notify(state, WRITE_INDEX)
+
+    Atomics.store(state, READ_INDEX, -2)
+    Atomics.notify(state, READ_INDEX)
+
+    parentPort.postMessage({
+      code: 'ERROR',
+      err
+    })
+  })
+
+  destination.on('close', function () {
+    // process._rawDebug('worker close emitted')
+    const end = Atomics.load(state, WRITE_INDEX)
+    Atomics.store(state, READ_INDEX, end)
+    Atomics.notify(state, READ_INDEX)
+    setImmediate(() => {
+      process.exit(0)
+    })
+  })
+}
+
+// No .catch() handler,
+// in case there is an error it goes
+// to unhandledRejection
+start().then(function () {
+  parentPort.postMessage({
+    code: 'READY'
+  })
+
+  process.nextTick(run)
+})
+
+function readState () {
+  while (true) {
+    const seq = Atomics.load(state, SEQ_INDEX)
+
+    if ((seq & 1) !== 0) {
+      continue
+    }
+
+    const current = Atomics.load(state, READ_INDEX)
+    const end = Atomics.load(state, WRITE_INDEX)
+
+    if (seq === Atomics.load(state, SEQ_INDEX)) {
+      return { current, end, seq }
+    }
+  }
+}
+
+function run () {
+  const { current, end, seq } = readState()
+
+  // process._rawDebug(`pre state ${current} ${end}`)
+
+  if (end === current) {
+    waitDiff(state, SEQ_INDEX, seq, Infinity, run)
+    return
+  }
+
+  // process._rawDebug(`post state ${current} ${end}`)
+
+  if (end === -1) {
+    // process._rawDebug('end')
+    destination.end()
+    return
+  }
+
+  const toWrite = data.toString('utf8', current, end)
+  // process._rawDebug('worker writing: ' + toWrite)
+
+  const res = destination.write(toWrite)
+
+  if (res) {
+    Atomics.store(state, READ_INDEX, end)
+    Atomics.notify(state, READ_INDEX)
+    setImmediate(run)
+  } else {
+    destination.once('drain', function () {
+      Atomics.store(state, READ_INDEX, end)
+      Atomics.notify(state, READ_INDEX)
+      run()
+    })
+  }
+}
+
+process.on('unhandledRejection', function (err) {
+  parentPort.postMessage({
+    code: 'ERROR',
+    err
+  })
+  process.exit(1)
+})
+
+process.on('uncaughtException', function (err) {
+  parentPort.postMessage({
+    code: 'ERROR',
+    err
+  })
+  process.exit(1)
+})
+
+process.once('exit', exitCode => {
+  if (exitCode !== 0) {
+    process.exit(exitCode)
+    return
+  }
+  if (destination?.writableNeedDrain && !destination?.writableEnded) {
+    parentPort.postMessage({
+      code: 'WARNING',
+      err: new Error('ThreadStream: process exited before destination stream was drained. this may indicate that the destination stream try to write to a another missing stream')
+    })
+  }
+
+  process.exit(0)
+})

package/node_modules/@zuplo/editor/node_modules/thread-stream/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "thread-stream",
+  "version": "3.2.0",
+  "description": "A streaming way to send data to a Node.js Worker Thread",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "dependencies": {
+    "real-require": "^0.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.1.0",
+    "@types/tap": "^15.0.0",
+    "@yao-pkg/pkg": "^5.11.5",
+    "desm": "^1.3.0",
+    "fastbench": "^1.0.1",
+    "husky": "^9.0.6",
+    "pino-elasticsearch": "^8.0.0",
+    "sonic-boom": "^4.0.1",
+    "standard": "^17.0.0",
+    "tap": "^16.2.0",
+    "ts-node": "^10.8.0",
+    "typescript": "^5.3.2",
+    "why-is-node-running": "^2.2.2"
+  },
+  "scripts": {
+    "build": "tsc --noEmit",
+    "test": "standard && npm run build && npm run transpile && tap \"test/**/*.test.*js\" && tap --ts test/*.test.*ts",
+    "test:ci": "standard && npm run transpile && npm run test:ci:js && npm run test:ci:ts",
+    "test:ci:js": "tap --no-check-coverage --timeout=120 --coverage-report=lcovonly \"test/**/*.test.*js\"",
+    "test:ci:ts": "tap --ts --no-check-coverage --coverage-report=lcovonly \"test/**/*.test.*ts\"",
+    "test:yarn": "npm run transpile && tap \"test/**/*.test.js\" --no-check-coverage",
+    "transpile": "sh ./test/ts/transpile.sh",
+    "prepare": "husky install"
+  },
+  "standard": {
+    "ignore": [
+      "test/ts/**/*",
+      "test/syntax-error.mjs"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mcollina/thread-stream.git"
+  },
+  "keywords": [
+    "worker",
+    "thread",
+    "threads",
+    "stream"
+  ],
+  "author": "Matteo Collina <hello@matteocollina.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mcollina/thread-stream/issues"
+  },
+  "homepage": "https://github.com/mcollina/thread-stream#readme"
+}

package/node_modules/@zuplo/editor/node_modules/thread-stream/test/base.test.js

@@ -0,0 +1,258 @@
+'use strict'
+
+const { test } = require('tap')
+const { join } = require('path')
+const { readFile } = require('fs')
+const { file } = require('./helper')
+const ThreadStream = require('..')
+const { MessageChannel } = require('worker_threads')
+const { once } = require('events')
+
+function readFileAsync (path) {
+  return new Promise((resolve, reject) => {
+    readFile(path, 'utf8', (err, data) => {
+      if (err) {
+        reject(err)
+        return
+      }
+      resolve(data)
+    })
+  })
+}
+
+test('base sync=true', async function (t) {
+  const dest = file()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'to-file.js'),
+    workerData: { dest },
+    sync: true
+  })
+
+  const finish = once(stream, 'finish')
+  const close = once(stream, 'close')
+
+  t.same(stream.writableObjectMode, false)
+  t.same(stream.writableFinished, false)
+  t.same(stream.closed, false)
+  t.same(stream.writableNeedDrain, false)
+  t.ok(stream.write('hello world\n'))
+  t.ok(stream.write('something else\n'))
+  t.ok(stream.writable)
+
+  t.same(stream.writableEnded, false)
+  stream.end()
+  t.same(stream.writableEnded, true)
+
+  await finish
+  t.same(stream.writableFinished, true)
+
+  await close
+  t.same(stream.closed, true)
+  t.notOk(stream.writable)
+
+  const data = await readFileAsync(dest)
+  t.equal(data, 'hello world\nsomething else\n')
+})
+
+test('overflow sync=true', async function (t) {
+  const dest = file()
+  const stream = new ThreadStream({
+    bufferSize: 128,
+    filename: join(__dirname, 'to-file.js'),
+    workerData: { dest },
+    sync: true
+  })
+
+  const close = once(stream, 'close')
+  let count = 0
+
+  function write () {
+    if (count++ === 20) {
+      stream.end()
+      return
+    }
+
+    stream.write('aaaaaaaaaa')
+    setImmediate(write)
+  }
+
+  write()
+
+  await close
+  const data = await readFileAsync(dest)
+  t.equal(data.length, 200)
+})
+
+test('overflow sync=false', async function (t) {
+  const dest = file()
+  const stream = new ThreadStream({
+    bufferSize: 128,
+    filename: join(__dirname, 'to-file.js'),
+    workerData: { dest },
+    sync: false
+  })
+
+  const close = once(stream, 'close')
+  let count = 0
+
+  t.same(stream.writableNeedDrain, false)
+
+  function write () {
+    if (count++ === 20) {
+      stream.end()
+      return
+    }
+
+    if (!stream.write('aaaaaaaaaa')) {
+      t.same(stream.writableNeedDrain, true)
+    }
+    setImmediate(write)
+  }
+
+  write()
+
+  stream.on('drain', () => {
+    t.same(stream.writableNeedDrain, false)
+  })
+
+  await close
+  const data = await readFileAsync(dest)
+  t.equal(data.length, 200)
+})
+
+test('over the bufferSize at startup', function (t) {
+  t.plan(5)
+
+  const dest = file()
+  const stream = new ThreadStream({
+    bufferSize: 10,
+    filename: join(__dirname, 'to-file.js'),
+    workerData: { dest },
+    sync: true
+  })
+
+  stream.on('finish', () => {
+    readFile(dest, 'utf8', (err, data) => {
+      t.error(err)
+      t.equal(data, 'hello world\nsomething else\n')
+    })
+  })
+
+  t.ok(stream.write('hello'))
+  t.ok(stream.write(' world\n'))
+  t.ok(stream.write('something else\n'))
+
+  stream.end()
+})
+
+test('over the bufferSize at startup (async)', function (t) {
+  t.plan(5)
+
+  const dest = file()
+  const stream = new ThreadStream({
+    bufferSize: 10,
+    filename: join(__dirname, 'to-file.js'),
+    workerData: { dest },
+    sync: false
+  })
+
+  t.ok(stream.write('hello'))
+  t.notOk(stream.write(' world\n'))
+  t.notOk(stream.write('something else\n'))
+
+  stream.end()
+
+  stream.on('finish', () => {
+    readFile(dest, 'utf8', (err, data) => {
+      t.error(err)
+      t.equal(data, 'hello world\nsomething else\n')
+    })
+  })
+})
+
+test('flushSync sync=false', function (t) {
+  t.plan(2)
+
+  const dest = file()
+  const stream = new ThreadStream({
+    bufferSize: 128,
+    filename: join(__dirname, 'to-file.js'),
+    workerData: { dest },
+    sync: false
+  })
+
+  stream.on('ready', () => {
+    for (let count = 0; count < 20; count++) {
+      stream.write('aaaaaaaaaa')
+    }
+
+    stream.flushSync()
+    setImmediate(() => {
+      stream.end()
+    })
+  })
+
+  stream.on('finish', () => {
+    readFile(dest, 'utf8', (err, data) => {
+      t.error(err)
+      t.equal(data.length, 200)
+    })
+  })
+})
+
+test('pass down MessagePorts', async function (t) {
+  const { port1, port2 } = new MessageChannel()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'port.js'),
+    workerData: { port: port1 },
+    workerOpts: {
+      transferList: [port1]
+    },
+    sync: false
+  })
+
+  t.teardown(() => {
+    stream.end()
+  })
+
+  t.ok(stream.write('hello world\n'))
+  t.ok(stream.write('something else\n'))
+
+  const [strings] = await once(port2, 'message')
+  t.equal(strings, 'hello world\nsomething else\n')
+})
+
+test('destroy does not error', async function (t) {
+  const dest = file()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'to-file.js'),
+    workerData: { dest },
+    sync: false
+  })
+
+  stream.on('ready', () => {
+    stream.worker.terminate()
+  })
+
+  const [err] = await once(stream, 'error')
+  t.equal(err.message, 'the worker thread exited')
+
+  await new Promise((resolve) => {
+    stream.flush((err) => {
+      t.equal(err.message, 'the worker has exited')
+      resolve()
+    })
+  })
+
+  t.doesNotThrow(() => stream.flushSync())
+  t.doesNotThrow(() => stream.end())
+})
+
+test('syntax error', async function (t) {
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'syntax-error.mjs')
+  })
+
+  const [err] = await once(stream, 'error')
+  t.equal(err.message, 'Unexpected end of input')
+})

package/node_modules/@zuplo/editor/node_modules/thread-stream/test/bench.test.js

@@ -0,0 +1,38 @@
+'use strict'
+
+const { test } = require('tap')
+const { join } = require('path')
+const ThreadStream = require('..')
+const { file } = require('./helper')
+
+const MAX = 1000
+
+let str = ''
+
+for (let i = 0; i < 10; i++) {
+  str += 'hello'
+}
+
+test('base', function (t) {
+  const dest = file()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'to-file.js'),
+    workerData: { dest }
+  })
+  let runs = 0
+  function benchThreadStream () {
+    if (++runs === 1000) {
+      stream.end()
+      return
+    }
+
+    for (let i = 0; i < MAX; i++) {
+      stream.write(str)
+    }
+    setImmediate(benchThreadStream)
+  }
+  benchThreadStream()
+  stream.on('finish', function () {
+    t.end()
+  })
+})

package/node_modules/@zuplo/editor/node_modules/thread-stream/test/bundlers.test.js

@@ -0,0 +1,60 @@
+'use strict'
+
+const { test } = require('tap')
+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')
+  }
+
+  const dest = file()
+
+  process.on('uncaughtException', error => {
+    console.log(error)
+  })
+
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'to-file.js'),
+    workerData: { dest },
+    sync: true
+  })
+
+  stream.worker.removeAllListeners('message')
+  stream.worker.once('message', message => {
+    t.equal(message.code, 'CUSTOM-WORKER-CALLED')
+  })
+
+  stream.end()
+})
+
+test('bundlers support with .mjs file', function (t) {
+  t.plan(1)
+
+  globalThis.__bundlerPathsOverrides = {
+    'thread-stream-worker': join(__dirname, 'custom-worker.js')
+  }
+
+  const dest = file()
+
+  process.on('uncaughtException', error => {
+    console.log(error)
+  })
+
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'to-file.mjs'),
+    workerData: { dest },
+    sync: true
+  })
+
+  stream.worker.removeAllListeners('message')
+  stream.worker.once('message', message => {
+    t.equal(message.code, 'CUSTOM-WORKER-CALLED')
+  })
+
+  stream.end()
+})

package/node_modules/@zuplo/editor/node_modules/thread-stream/test/close-on-gc.js

@@ -0,0 +1,37 @@
+'use strict'
+
+const { join } = require('path')
+const ThreadStream = require('..')
+const assert = require('assert')
+
+let worker = null
+
+function setup () {
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'to-file.js'),
+    workerData: { dest: process.argv[2] },
+    sync: true
+  })
+
+  worker = stream.worker
+
+  stream.write('hello')
+  stream.write(' ')
+  stream.write('world\n')
+  stream.flushSync()
+  stream.unref()
+
+  // the stream object goes out of scope here
+  setImmediate(gc) // eslint-disable-line
+}
+
+setup()
+
+let exitEmitted = false
+worker.on('exit', function () {
+  exitEmitted = true
+})
+
+process.on('exit', function () {
+  assert.strictEqual(exitEmitted, true)
+})