like-thread 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Lucas Barrena
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,55 @@
+# like-thread
+
+Simple threads for Node.js
+
+```
+npm i like-thread
+```
+
+## Usage
+
+Create a thread and reuse it:
+
+```js
+import Thread from 'like-thread'
+
+const thread = new Thread(function (a, b) {
+  return a + b
+})
+
+console.log(await thread.call(1, 1)) // => 2
+console.log(await thread.call(2, 2)) // => 4
+
+await thread.close()
+```
+
+Iterators:
+
+```js
+const thread = new Thread(async function * (n) {
+  for (let i = 1; i <= n; i++) {
+    yield i
+  }
+})
+
+for await (const value of thread.call(3)) {
+  console.log(value) // 1, 2, 3
+}
+
+await thread.close()
+```
+
+New temporary thread on each call:
+
+```js
+console.log(await Thread.go([1, 1], sum)) // => 2
+console.log(await Thread.go([2, 2], sum)) // => 4
+
+function sum (a, b) {
+  return a + b
+}
+```
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,369 @@
+const { isMainThread, Worker, workerData, parentPort } = require('worker_threads')
+
+if (isMainThread) {
+  const promiseWithResolvers = require('promise-resolvers')
+
+  module.exports = class Thread {
+    static go (args, fn) {
+      const thread = new this(fn, args)
+
+      if (!thread.isGenerator) {
+        const value = thread.call(...args)
+
+        return value.finally(() => thread.close())
+      }
+
+      const iterator = thread.call(...args)
+
+      return {
+        [Symbol.asyncIterator] () {
+          return this
+        },
+
+        async next () {
+          const result = await iterator.next()
+
+          if (result.done) {
+            await thread.close()
+          }
+
+          return result
+        },
+
+        async return (value) {
+          try {
+            return await iterator.return(value)
+          } finally {
+            await thread.close()
+          }
+        }
+      }
+    }
+
+    constructor (fn, opts = {}) {
+      const workerData = {
+        fn: fn.toString()
+      }
+
+      const entrypoint = workerData.fn.match(/(async )?function( ?\* ?)? ([a-zA-Z0-9]+)? ?\(([^)]*?)\)/i)
+
+      this.isAsync = !!entrypoint[1]
+      this.isGenerator = !!entrypoint[2]
+
+      this.worker = new Worker(__filename, { workerData, argv: opts.argv || null })
+
+      this.id = 1
+      this.requests = new Map()
+
+      this.worker.on('message', this._onMessage.bind(this))
+
+      this.promise = new Promise((resolve, reject) => {
+        let error = null
+
+        this.worker.on('error', err => {
+          error = err
+
+          for (const [id, req] of this.requests) {
+            this.requests.delete(id)
+
+            if (req.resolver) {
+              req.resolver.reject(err)
+            } else {
+              req.iterator.fail(err)
+            }
+          }
+
+          reject(err)
+        })
+
+        this.worker.on('exit', (exitCode, signal) => {
+          if (error) return
+
+          const err = new Error('Worker closed (' + exitCode + ' and ' + signal + ')')
+
+          for (const [id, req] of this.requests) {
+            this.requests.delete(id)
+
+            if (req.resolver) {
+              req.resolver.reject(err)
+            } else {
+              req.iterator.fail(err)
+            }
+          }
+
+          const success = exitCode === 0 || exitCode === 130 || signal === 'SIGINT' || signal === 'SIGTERM' || signal === 'SIGHUP'
+
+          if (success) {
+            resolve()
+          } else {
+            reject(err)
+          }
+        })
+      })
+    }
+
+    _onMessage (msg) {
+      const req = this.requests.get(msg.id)
+
+      if (!req) {
+        return
+      }
+
+      // console.log('_onMessage', msg, !!req.iterator ? 'iterator' : 'promise')
+
+      if (msg.error) {
+        this.requests.delete(msg.id)
+
+        const err = new Error(msg.error)
+
+        if (req.resolver) {
+          req.resolver.reject(err)
+        } else {
+          req.iterator.fail(err)
+        }
+
+        return
+      }
+
+      // msg.value can be a falsy value like 0 or null
+      if (msg.v) {
+        if (req.resolver) {
+          req.resolver.resolve(msg.value)
+        } else {
+          req.iterator.push(msg.value)
+        }
+
+        return
+      }
+
+      if (msg.done) {
+        this.requests.delete(msg.id)
+
+        req.iterator.close()
+
+        return
+      }
+
+      this.requests.delete(msg.id)
+
+      if (req.resolver) {
+        req.resolver.reject(new Error('Invalid message'))
+      } else {
+        req.iterator.fail(new Error('Invalid message'))
+      }
+    }
+
+    call (...args) {
+      if (this.id === 0xffffffff) {
+        this.id = 1
+      }
+
+      const id = this.id++
+
+      const sab = new SharedArrayBuffer(4)
+      const control = new Int32Array(sab)
+
+      Atomics.store(control, 0, 0)
+
+      if (!this.isGenerator) {
+        const resolver = promiseWithResolvers()
+
+        this.requests.set(id, { resolver })
+
+        this.worker.postMessage({ id, args, sab })
+
+        return resolver.promise
+      }
+
+      const iterator = {
+        resolver: promiseWithResolvers(),
+        queue: [],
+        closed: false,
+        push: function (value) {
+          if (this.closed) {
+            return
+          }
+
+          this.queue.push({ value, done: false })
+          this.resolver.resolve()
+        },
+        fail: function (err) {
+          if (this.closed) {
+            return
+          }
+
+          this.closed = true
+          this.resolver.resolve(err)
+        },
+        close: function () {
+          if (this.closed) {
+            return
+          }
+
+          this.closed = true
+          this.resolver.resolve()
+        }
+      }
+
+      this.requests.set(id, { iterator })
+
+      this.worker.postMessage({ id, args, sab })
+
+      return {
+        [Symbol.asyncIterator] () {
+          return this
+        },
+
+        async next () {
+          Atomics.store(control, 0, 1)
+          Atomics.notify(control, 0, 1)
+
+          const err = await iterator.resolver.promise
+
+          if (err) {
+            throw err
+          }
+
+          if (iterator.queue.length === 0) {
+            return { done: true }
+          }
+
+          if (iterator.queue.length === 1) {
+            iterator.resolver = promiseWithResolvers()
+          }
+
+          const item = iterator.queue.shift()
+
+          return item
+        },
+
+        return: () => {
+          iterator.closed = true
+
+          Atomics.store(control, 0, 2)
+          Atomics.notify(control, 0, 1)
+
+          // this.worker.postMessage({ id, command: 'stop' })
+          // return
+
+          // iterator.queue.length = 0
+          // iterator.resolver.resolve()
+
+          return Promise.resolve({ done: true })
+        }
+      }
+    }
+
+    async * [Symbol.asyncIterator] () {
+      for await (const [value] of this.iterator) {
+        yield value
+      }
+    }
+
+    async next () {
+      const { done, value } = await this.iterator.next()
+
+      return { done, value: done ? undefined : value[0] }
+    }
+
+    return () {
+      return this.iterator.return()
+    }
+
+    then (onFulfilled, onRejected) {
+      return this.promise.then(onFulfilled, onRejected)
+    }
+
+    catch (onRejected) {
+      return this.promise.catch(onRejected)
+    }
+
+    finally (onFinally) {
+      return this.promise.finally(onFinally)
+    }
+
+    async close () {
+      this.worker.postMessage({ command: 'exit' })
+
+      await this.promise
+
+      // await this.worker.terminate()
+    }
+  }
+} else {
+  const entrypoint = workerData.fn.match(/(async )?function( ?\* ?)? ([a-zA-Z0-9]+)? ?\(([^)]*?)\)/i)
+
+  const isAsync = !!entrypoint[1]
+  const isGenerator = !!entrypoint[2]
+  const functionName = entrypoint[3] || '_WORKER_MAIN_'
+  const functionArgs = entrypoint[4] || ''
+
+  const fn = workerData.fn.replace(entrypoint[0], (isAsync ? 'async ' : '') + 'function ' + (isGenerator ? '* ' : '') + functionName + ' (' + (functionArgs) + ')')
+
+  parentPort.on('message', async (msg) => {
+    if (msg.command === 'exit') {
+      process.exit(0)
+      return
+    }
+
+    try {
+      // TODO: Optimize by creating the function only once by fixing the args
+      const source = fn + '\n\nmodule.exports = ' + functionName + '(...' + JSON.stringify(msg.args || []) + ')'
+
+      const wrap = new Function('require', '__dirname', '__filename', 'module', 'exports', 'parentPort', source) // eslint-disable-line no-new-func
+
+      const mod = { exports: {} }
+
+      wrap(require, __dirname, __filename, mod, mod.exports, parentPort)
+
+      const out = mod.exports
+
+      if (isGenerator) {
+        const control = new Int32Array(msg.sab)
+        const it = out[Symbol.asyncIterator] ? out[Symbol.asyncIterator]() : out[Symbol.iterator]()
+
+        while (true) {
+          while (Atomics.load(control, 0) === 0) {
+            const res = Atomics.waitAsync(control, 0, 0)
+
+            if (res.async) {
+              await res.value
+            } else {
+              break
+            }
+          }
+
+          if (Atomics.load(control, 0) === 2) {
+            break
+          }
+
+          const { value, done } = await it.next()
+
+          Atomics.store(control, 0, 0)
+
+          if (done) {
+            parentPort.postMessage({ id: msg.id, done: true })
+            break
+          }
+
+          // Keep "v" because "value" can be falsy like 0 or null
+          parentPort.postMessage({ id: msg.id, value, v: true })
+        }
+
+        return
+      }
+
+      if (isAsync) {
+        const value = await out
+
+        parentPort.postMessage({ id: msg.id, value, v: true })
+
+        return
+      }
+
+      parentPort.postMessage({ id: msg.id, value: out, v: true })
+    } catch (err) {
+      parentPort.postMessage({ id: msg.id, error: err })
+    }
+  })
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "like-thread",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "files": [],
+  "scripts": {
+    "test": "standard && brittle test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lukks/like-thread.git"
+  },
+  "author": "Lucas Barrena (LuKks)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/lukks/like-thread/issues"
+  },
+  "homepage": "https://github.com/lukks/like-thread#readme",
+  "devDependencies": {
+    "brittle": "^3.3.2",
+    "same-object": "^1.0.2",
+    "standard": "^17.1.0"
+  },
+  "dependencies": {
+    "promise-resolvers": "^1.0.0"
+  }
+}