linted

Signed-off-by: Matteo Collina <[email protected]>

Author: mcollina

doc/api/worker_threads.md

@@ -1550,12 +1550,12 @@ const { Worker, makeSync } = require('node:worker_threads');
 
 // Create a SharedArrayBuffer for communication
 const buffer = new SharedArrayBuffer(1024, {
-  maxByteLength: 64 * 1024 * 1024
+  maxByteLength: 64 * 1024 * 1024,
 });
 
 // Create a worker, passing the buffer
 const worker = new Worker('worker-script.js', {
-  workerData: { buffer }
+  workerData: { buffer },
 });
 
 // Create a synchronous API facade
@@ -1591,7 +1591,7 @@ wire(workerData.buffer, {
   syncMethod(arg) {
     // Do synchronous work
     return result;
-  }
+  },
 });
 ```
 

lib/internal/worker/everysync/index.js

@@ -1,5 +1,20 @@
 'use strict';
 
+const {
+  AtomicsNotify,
+  AtomicsStore,
+  AtomicsWait,
+  AtomicsWaitAsync,
+  Int32Array,
+  ObjectKeys,
+} = primordials;
+
+const {
+  codes: {
+    ERR_WORKER_MESSAGING_TIMEOUT,
+  },
+} = require('internal/errors');
+
 const { read, write } = require('internal/worker/everysync/objects');
 const {
   OFFSET,
@@ -11,18 +26,17 @@ const {
  * Creates a synchronous API facade from a shared memory buffer.
  * This function is meant to be used in the main thread to communicate with
  * a worker thread that has called `wire()` on the same shared memory.
- *
  * @param {SharedArrayBuffer} data - The shared memory buffer for communication
- * @param {Object} [opts={}] - Options object
+ * @param {object} [opts={}] - Options object
  * @param {number} [opts.timeout=1000] - Timeout in milliseconds for synchronous operations
- * @returns {Object} - An object with methods that match the ones exposed by the worker
+ * @returns {object} - An object with methods that match the ones exposed by the worker
  */
 function makeSync(data, opts = {}) {
   const timeout = opts.timeout || 1000;
   const metaView = new Int32Array(data);
 
-  const res = Atomics.wait(metaView, TO_WORKER, 0, timeout);
-  Atomics.store(metaView, TO_WORKER, 0);
+  const res = AtomicsWait(metaView, TO_WORKER, 0, timeout);
+  AtomicsStore(metaView, TO_WORKER, 0);
 
   if (res === 'ok') {
     const obj = read(data, OFFSET);
@@ -31,59 +45,56 @@ function makeSync(data, opts = {}) {
     for (const key of obj) {
       api[key] = (...args) => {
         write(data, { key, args }, OFFSET);
-        Atomics.store(metaView, TO_MAIN, 1);
-        Atomics.notify(metaView, TO_MAIN, 1);
-        const res = Atomics.wait(metaView, TO_WORKER, 0, timeout);
-        Atomics.store(metaView, TO_WORKER, 0);
+        AtomicsStore(metaView, TO_MAIN, 1);
+        AtomicsNotify(metaView, TO_MAIN, 1);
+        const res = AtomicsWait(metaView, TO_WORKER, 0, timeout);
+        AtomicsStore(metaView, TO_WORKER, 0);
         if (res === 'ok') {
           const obj = read(data, OFFSET);
           return obj;
-        } else {
-          throw new Error(`The response timed out after ${timeout}ms`);
         }
+        throw new ERR_WORKER_MESSAGING_TIMEOUT();
       };
     }
 
     return api;
-  } else {
-    throw new Error(`The initialization timed out after ${timeout}ms`);
   }
+  throw new ERR_WORKER_MESSAGING_TIMEOUT();
 }
 
 /**
  * Wires up a shared memory buffer to invoke methods on an object.
  * This function is meant to be used in a worker thread to expose methods
  * to the main thread that has called `makeSync()` on the same shared memory.
- *
  * @param {SharedArrayBuffer} data - The shared memory buffer for communication
- * @param {Object} obj - Object with methods to expose to the main thread
+ * @param {object} obj - Object with methods to expose to the main thread
  * @returns {Promise<void>} - A promise that never resolves unless there's an error
  */
 async function wire(data, obj) {
-  write(data, Object.keys(obj), OFFSET);
+  write(data, ObjectKeys(obj), OFFSET);
 
   const metaView = new Int32Array(data);
 
-  Atomics.store(metaView, TO_WORKER, 1);
-  Atomics.notify(metaView, TO_WORKER);
+  AtomicsStore(metaView, TO_WORKER, 1);
+  AtomicsNotify(metaView, TO_WORKER);
 
   while (true) {
-    const waitAsync = Atomics.waitAsync(metaView, TO_MAIN, 0);
+    const waitAsync = AtomicsWaitAsync(metaView, TO_MAIN, 0);
     const res = await waitAsync.value;
-    Atomics.store(metaView, TO_MAIN, 0);
+    AtomicsStore(metaView, TO_MAIN, 0);
 
     if (res === 'ok') {
       const { key, args } = read(data, OFFSET);
       // This is where the magic happens - invoke the requested method
       const result = await obj[key](...args);
       write(data, result, OFFSET);
-      Atomics.store(metaView, TO_WORKER, 1);
-      Atomics.notify(metaView, TO_WORKER, 1);
+      AtomicsStore(metaView, TO_WORKER, 1);
+      AtomicsNotify(metaView, TO_WORKER, 1);
     }
   }
 }
 
 module.exports = {
   makeSync,
-  wire
-};
+  wire,
+};

lib/internal/worker/everysync/indexes.js

@@ -23,5 +23,5 @@ const TO_MAIN = 1;
 module.exports = {
   OFFSET,
   TO_WORKER,
-  TO_MAIN
-};
+  TO_MAIN,
+};

lib/internal/worker/everysync/objects.js

@@ -1,10 +1,20 @@
 'use strict';
 
+const {
+  DataView,
+  Uint8Array,
+} = primordials;
+
+const {
+  codes: {
+    ERR_INVALID_BUFFER_SIZE,
+  },
+} = require('internal/errors');
+
 const { serialize, deserialize } = require('v8');
 
 /**
  * Reads an object from a shared memory buffer
- * 
  * @param {SharedArrayBuffer} buffer - The shared memory buffer containing serialized data
  * @param {number} [byteOffset=0] - Byte offset where the data begins
  * @returns {any} - The deserialized object
@@ -18,7 +28,6 @@ function read(buffer, byteOffset = 0) {
 
 /**
  * Writes an object to a shared memory buffer
- * 
  * @param {SharedArrayBuffer} buffer - The shared memory buffer to write to
  * @param {any} object - The object to serialize and write
  * @param {number} [byteOffset=0] - Byte offset where to write the data
@@ -30,18 +39,17 @@ function write(buffer, object, byteOffset = 0) {
   if (buffer.byteLength < data.byteLength + 4 + byteOffset) {
     // Check if buffer is growable (has grow method from ShareArrayBuffer.prototype)
     if (typeof buffer.grow !== 'function') {
-      throw new Error('Buffer is too small and not growable');
+      throw new ERR_INVALID_BUFFER_SIZE('Buffer is too small and not growable');
     }
-    
     buffer.grow(data.byteLength + 4 + byteOffset);
   }
-  
+
   const view = new DataView(buffer, byteOffset);
   view.setUint32(0, data.byteLength, true);
   new Uint8Array(buffer, byteOffset + 4).set(data);
 }
 
 module.exports = {
   read,
-  write
-};
+  write,
+};

lib/worker_threads.js

@@ -31,7 +31,7 @@ const {
 
 const {
   makeSync,
-  wire
+  wire,
 } = require('internal/worker/everysync/index');
 
 module.exports = {
@@ -55,5 +55,5 @@ module.exports = {
   setEnvironmentData,
   getEnvironmentData,
   makeSync,
-  wire
+  wire,
 };

test/parallel/test-worker-everysync-base.js

@@ -1,5 +1,6 @@
 'use strict';
 
+// eslint-disable-next-line no-unused-vars
 const common = require('../common');
 const assert = require('assert');
 const { join } = require('path');
@@ -39,7 +40,7 @@ const { Worker, makeSync } = require('worker_threads');
   const api = makeSync(buffer, { timeout: 100 });
 
   assert.throws(() => api.fail(), {
-    message: 'The response timed out after 100ms'
+    code: 'ERR_WORKER_MESSAGING_TIMEOUT'
   });
 
   worker.terminate();
@@ -52,6 +53,6 @@ const { Worker, makeSync } = require('worker_threads');
   });
 
   assert.throws(() => makeSync(buffer, { timeout: 100 }), {
-    message: 'The initialization timed out after 100ms'
+    code: 'ERR_WORKER_MESSAGING_TIMEOUT'
   });
 }

test/parallel/test-worker-everysync-objects.js

@@ -1,6 +1,7 @@
 // Flags: --expose-internals
 'use strict';
 
+// eslint-disable-next-line no-unused-vars
 const common = require('../common');
 const assert = require('assert');
 const { read, write } = require('internal/worker/everysync/objects');
@@ -32,27 +33,27 @@ const { read, write } = require('internal/worker/everysync/objects');
   });
 }
 
-  // Test with growable buffer
-  {
-    const obj = { foo: 'bar' };
-    const buffer = new SharedArrayBuffer(2, {
-      maxByteLength: 1024,
-    });
-    write(buffer, obj);
-    const obj2 = read(buffer);
-    assert.deepStrictEqual(obj, obj2);
-  }
+// Test with growable buffer
+{
+  const obj = { foo: 'bar' };
+  const buffer = new SharedArrayBuffer(2, {
+    maxByteLength: 1024,
+  });
+  write(buffer, obj);
+  const obj2 = read(buffer);
+  assert.deepStrictEqual(obj, obj2);
+}
 
-  // Test with growable buffer and offset
-  {
-    const obj = { foo: 'bar' };
-    const buffer = new SharedArrayBuffer(2, {
-      maxByteLength: 1024,
-    });
-    write(buffer, obj, 4);
-    const obj2 = read(buffer, 4);
-    assert.deepStrictEqual(obj, obj2);
-  }
+// Test with growable buffer and offset
+{
+  const obj = { foo: 'bar' };
+  const buffer = new SharedArrayBuffer(2, {
+    maxByteLength: 1024,
+  });
+  write(buffer, obj, 4);
+  const obj2 = read(buffer, 4);
+  assert.deepStrictEqual(obj, obj2);
+}
 
 // Test complex objects
 {