like-thread 1.0.0 → 1.0.2

package/index.js

@@ -1,369 +1,296 @@
-const { isMainThread, Worker, workerData, parentPort } = require('worker_threads')
+const fs = require('fs')
+const path = require('path')
+const { Worker } = require('worker_threads')
+const promiseWithResolvers = require('promise-resolvers')
 
-if (isMainThread) {
-  const promiseWithResolvers = require('promise-resolvers')
+const WORKER_SCRIPT = fs.readFileSync(path.join(__dirname, 'worker.js'), 'utf8')
 
-  module.exports = class Thread {
-    static go (args, fn) {
-      const thread = new this(fn, args)
+module.exports = class Thread {
+  static go (args, fn) {
+    const thread = new this(fn, args)
 
-      if (!thread.isGenerator) {
-        const value = thread.call(...args)
+    if (!thread.isGenerator) {
+      const value = thread.call(...args)
 
-        return value.finally(() => thread.close())
-      }
+      return value.finally(() => thread.close())
+    }
 
-      const iterator = thread.call(...args)
+    const iterator = thread.call(...args)
 
-      return {
-        [Symbol.asyncIterator] () {
-          return this
-        },
+    return {
+      [Symbol.asyncIterator] () {
+        return this
+      },
 
-        async next () {
-          const result = await iterator.next()
+      async next () {
+        const result = await iterator.next()
 
-          if (result.done) {
-            await thread.close()
-          }
+        if (result.done) {
+          await thread.close()
+        }
 
-          return result
-        },
+        return result
+      },
 
-        async return (value) {
-          try {
-            return await iterator.return(value)
-          } finally {
-            await thread.close()
-          }
+      async return (value) {
+        try {
+          return await iterator.return(value)
+        } finally {
+          await thread.close()
         }
       }
     }
+  }
 
-    constructor (fn, opts = {}) {
-      const workerData = {
-        fn: fn.toString()
-      }
+  constructor (fn, opts = {}) {
+    const workerData = {
+      fn: fn.toString()
+    }
 
-      const entrypoint = workerData.fn.match(/(async )?function( ?\* ?)? ([a-zA-Z0-9]+)? ?\(([^)]*?)\)/i)
+    const entrypoint = workerData.fn.match(/(async )?function( ?\* ?)? ([a-zA-Z0-9]+)? ?\(([^)]*?)\)/i)
 
-      this.isAsync = !!entrypoint[1]
-      this.isGenerator = !!entrypoint[2]
+    this.isAsync = !!entrypoint[1]
+    this.isGenerator = !!entrypoint[2]
 
-      this.worker = new Worker(__filename, { workerData, argv: opts.argv || null })
+    this.worker = new Worker(WORKER_SCRIPT, { eval: true, workerData, argv: opts.argv || null })
 
-      this.id = 1
-      this.requests = new Map()
+    this.id = 1
+    this.requests = new Map()
 
-      this.worker.on('message', this._onMessage.bind(this))
+    this.worker.on('message', this._onMessage.bind(this))
 
-      this.promise = new Promise((resolve, reject) => {
-        let error = null
+    this.promise = new Promise((resolve, reject) => {
+      let error = null
 
-        this.worker.on('error', err => {
-          error = err
+      this.worker.on('error', err => {
+        error = err
 
-          for (const [id, req] of this.requests) {
-            this.requests.delete(id)
+        for (const [id, req] of this.requests) {
+          this.requests.delete(id)
 
-            if (req.resolver) {
-              req.resolver.reject(err)
-            } else {
-              req.iterator.fail(err)
-            }
+          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 + ')')
+        reject(err)
+      })
 
-          for (const [id, req] of this.requests) {
-            this.requests.delete(id)
+      this.worker.on('exit', (exitCode, signal) => {
+        if (error) return
 
-            if (req.resolver) {
-              req.resolver.reject(err)
-            } else {
-              req.iterator.fail(err)
-            }
-          }
+        const err = new Error('Worker closed (' + exitCode + ' and ' + signal + ')')
 
-          const success = exitCode === 0 || exitCode === 130 || signal === 'SIGINT' || signal === 'SIGTERM' || signal === 'SIGHUP'
+        for (const [id, req] of this.requests) {
+          this.requests.delete(id)
 
-          if (success) {
-            resolve()
+          if (req.resolver) {
+            req.resolver.reject(err)
           } else {
-            reject(err)
+            req.iterator.fail(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
-      }
+        const success = exitCode === 0 || exitCode === 130 || signal === 'SIGINT' || signal === 'SIGTERM' || signal === 'SIGHUP'
 
-      // msg.value can be a falsy value like 0 or null
-      if (msg.v) {
-        if (req.resolver) {
-          req.resolver.resolve(msg.value)
+        if (success) {
+          resolve()
         } else {
-          req.iterator.push(msg.value)
+          reject(err)
         }
+      })
+    })
 
-        return
-      }
+    this.promise.catch(noop)
+  }
 
-      if (msg.done) {
-        this.requests.delete(msg.id)
+  _onMessage (msg) {
+    const req = this.requests.get(msg.id)
 
-        req.iterator.close()
+    if (!req) {
+      return
+    }
 
-        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(new Error('Invalid message'))
+        req.resolver.reject(err)
       } else {
-        req.iterator.fail(new Error('Invalid message'))
+        req.iterator.fail(err)
       }
+
+      return
     }
 
-    call (...args) {
-      if (this.id === 0xffffffff) {
-        this.id = 1
+    // 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)
       }
 
-      const id = this.id++
+      return
+    }
 
-      const sab = new SharedArrayBuffer(4)
-      const control = new Int32Array(sab)
+    if (msg.done) {
+      this.requests.delete(msg.id)
 
-      Atomics.store(control, 0, 0)
+      req.iterator.close()
 
-      if (!this.isGenerator) {
-        const resolver = promiseWithResolvers()
+      return
+    }
 
-        this.requests.set(id, { resolver })
+    this.requests.delete(msg.id)
 
-        this.worker.postMessage({ id, args, sab })
+    if (req.resolver) {
+      req.resolver.reject(new Error('Invalid message'))
+    } else {
+      req.iterator.fail(new Error('Invalid message'))
+    }
+  }
 
-        return resolver.promise
-      }
+  call (...args) {
+    if (this.id === 0xffffffff) {
+      this.id = 1
+    }
 
-      const iterator = {
-        resolver: promiseWithResolvers(),
-        queue: [],
-        closed: false,
-        push: function (value) {
-          if (this.closed) {
-            return
-          }
+    const id = this.id++
 
-          this.queue.push({ value, done: false })
-          this.resolver.resolve()
-        },
-        fail: function (err) {
-          if (this.closed) {
-            return
-          }
+    const sab = new SharedArrayBuffer(4)
+    const control = new Int32Array(sab)
 
-          this.closed = true
-          this.resolver.resolve(err)
-        },
-        close: function () {
-          if (this.closed) {
-            return
-          }
+    Atomics.store(control, 0, 0)
 
-          this.closed = true
-          this.resolver.resolve()
-        }
-      }
+    if (!this.isGenerator) {
+      const resolver = promiseWithResolvers()
 
-      this.requests.set(id, { iterator })
+      this.requests.set(id, { resolver })
 
       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
+      return resolver.promise
+    }
 
-          if (err) {
-            throw err
-          }
+    const iterator = {
+      resolver: promiseWithResolvers(),
+      queue: [],
+      closed: false,
+      push: function (value) {
+        if (this.closed) {
+          return
+        }
 
-          if (iterator.queue.length === 0) {
-            return { done: true }
-          }
+        this.queue.push({ value, done: false })
+        this.resolver.resolve()
+      },
+      fail: function (err) {
+        if (this.closed) {
+          return
+        }
 
-          if (iterator.queue.length === 1) {
-            iterator.resolver = promiseWithResolvers()
-          }
+        this.closed = true
+        this.resolver.resolve(err)
+      },
+      close: function () {
+        if (this.closed) {
+          return
+        }
 
-          const item = iterator.queue.shift()
+        this.closed = true
+        this.resolver.resolve()
+      }
+    }
 
-          return item
-        },
+    this.requests.set(id, { iterator })
 
-        return: () => {
-          iterator.closed = true
+    this.worker.postMessage({ id, args, sab })
 
-          Atomics.store(control, 0, 2)
-          Atomics.notify(control, 0, 1)
+    return {
+      [Symbol.asyncIterator] () {
+        return this
+      },
 
-          // this.worker.postMessage({ id, command: 'stop' })
-          // return
+      async next () {
+        Atomics.store(control, 0, 1)
+        Atomics.notify(control, 0, 1)
 
-          // iterator.queue.length = 0
-          // iterator.resolver.resolve()
+        const err = await iterator.resolver.promise
 
-          return Promise.resolve({ done: true })
+        if (err) {
+          throw err
         }
-      }
-    }
 
-    async * [Symbol.asyncIterator] () {
-      for await (const [value] of this.iterator) {
-        yield value
-      }
-    }
+        if (iterator.queue.length === 0) {
+          return { done: true }
+        }
 
-    async next () {
-      const { done, value } = await this.iterator.next()
+        if (iterator.queue.length === 1) {
+          iterator.resolver = promiseWithResolvers()
+        }
 
-      return { done, value: done ? undefined : value[0] }
-    }
+        const item = iterator.queue.shift()
 
-    return () {
-      return this.iterator.return()
-    }
+        return item
+      },
 
-    then (onFulfilled, onRejected) {
-      return this.promise.then(onFulfilled, onRejected)
-    }
+      return: () => {
+        iterator.closed = true
 
-    catch (onRejected) {
-      return this.promise.catch(onRejected)
-    }
-
-    finally (onFinally) {
-      return this.promise.finally(onFinally)
-    }
+        Atomics.store(control, 0, 2)
+        Atomics.notify(control, 0, 1)
 
-    async close () {
-      this.worker.postMessage({ command: 'exit' })
+        // this.worker.postMessage({ id, command: 'stop' })
+        // return
 
-      await this.promise
+        // iterator.queue.length = 0
+        // iterator.resolver.resolve()
 
-      // await this.worker.terminate()
+        return Promise.resolve({ done: true })
+      }
     }
   }
-} 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
+  async * [Symbol.asyncIterator] () {
+    for await (const [value] of this.iterator) {
+      yield value
     }
+  }
 
-    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)
+  async next () {
+    const { done, value } = await this.iterator.next()
 
-          if (done) {
-            parentPort.postMessage({ id: msg.id, done: true })
-            break
-          }
+    return { done, value: done ? undefined : value[0] }
+  }
 
-          // Keep "v" because "value" can be falsy like 0 or null
-          parentPort.postMessage({ id: msg.id, value, v: true })
-        }
+  return () {
+    return this.iterator.return()
+  }
 
-        return
-      }
+  then (onFulfilled, onRejected) {
+    return this.promise.then(onFulfilled, onRejected)
+  }
 
-      if (isAsync) {
-        const value = await out
+  catch (onRejected) {
+    return this.promise.catch(onRejected)
+  }
 
-        parentPort.postMessage({ id: msg.id, value, v: true })
+  finally (onFinally) {
+    return this.promise.finally(onFinally)
+  }
 
-        return
-      }
+  async close () {
+    this.worker.postMessage({ command: 'exit' })
 
-      parentPort.postMessage({ id: msg.id, value: out, v: true })
-    } catch (err) {
-      parentPort.postMessage({ id: msg.id, error: err })
-    }
-  })
+    await this.promise.catch(noop)
+  }
 }
+
+function noop () {}

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "like-thread",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "",
   "main": "index.js",
-  "files": [],
+  "files": [
+    "worker.js"
+  ],
   "scripts": {
     "test": "standard && brittle test.js"
   },

package/worker.js

@@ -0,0 +1,77 @@
+const { workerData, parentPort } = require('worker_threads')
+
+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()
+    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 })
+  }
+})