amqplib 0.10.8 → 1.0.0

package/examples/tutorials/worker.js

@@ -8,7 +8,7 @@ const queue = 'task_queue';
 (async () => {
   try {
     const connection = await amqp.connect('amqp://localhost');
-    process.once('SIGINT', async () => { 
+    process.once('SIGINT', async () => {
       await connection.close();
     });
 
@@ -16,19 +16,22 @@ const queue = 'task_queue';
     await channel.assertQueue(queue, { durable: true });
 
     channel.prefetch(1);
-    await channel.consume(queue, (message) => {
-      const text = message.content.toString();
-      console.log(" [x] Received '%s'", text);
-      const seconds = text.split('.').length - 1;
-      setTimeout(() => {
-        console.log(" [x] Done");
-        channel.ack(message);
-      }, seconds * 1000);      
-    }, { noAck: false });
-      
-    console.log(" [*] Waiting for messages. To exit press CTRL+C");
-  }
-  catch (err) {
+    await channel.consume(
+      queue,
+      (message) => {
+        const text = message.content.toString();
+        console.log(" [x] Received '%s'", text);
+        const seconds = text.split('.').length - 1;
+        setTimeout(() => {
+          console.log(' [x] Done');
+          channel.ack(message);
+        }, seconds * 1000);
+      },
+      { noAck: false },
+    );
+
+    console.log(' [*] Waiting for messages. To exit press CTRL+C');
+  } catch (err) {
     console.warn(err);
   }
 })();

package/examples/waitForConfirms.js

@@ -6,9 +6,9 @@ const amqp = require('../');
     connection = await amqp.connect();
     const channel = await connection.createConfirmChannel();
 
-    for (var i=0; i < 20; i++) {
+    for (let i = 0; i < 20; i++) {
       channel.publish('amq.topic', 'whatever', Buffer.from('blah'));
-    };
+    }
 
     await channel.waitForConfirms();
     console.log('All messages done');

package/lefthook.yml

@@ -0,0 +1,14 @@
+pre-commit:
+  commands:
+    format:
+      glob: "**/*.js"
+      exclude:
+        - "test/*.js"
+      run: npx biome format {staged_files} --write
+      stage_fixed: true
+    lint:
+      glob: "**/*.js"
+      run: npx biome lint {staged_files} --write
+      stage_fixed: true
+    test:
+      run: npm test

package/lib/api_args.js

@@ -1,9 +1,3 @@
-//
-//
-//
-
-'use strict';
-
 /*
 The channel (promise) and callback APIs have similar signatures, and
 in particular, both need AMQP fields prepared from the same arguments
@@ -38,24 +32,22 @@ fields for handing to the encoder.
 // NB the `arguments` field already has a default value of `{}`, so
 // there's no need to explicitly default it unless I'm setting values.
 function setIfDefined(obj, prop, value) {
-  if (value != undefined) obj[prop] = value;
+  if (value !== undefined) obj[prop] = value;
 }
 
-var EMPTY_OPTIONS = Object.freeze({});
+const EMPTY_OPTIONS = Object.freeze({});
 
-var Args = {};
+const Args = {};
 
-Args.assertQueue = function(queue, options) {
+Args.assertQueue = (queue, options) => {
   queue = queue || '';
   options = options || EMPTY_OPTIONS;
 
-  var argt = Object.create(options.arguments || null);
+  const argt = Object.create(options.arguments || null);
   setIfDefined(argt, 'x-expires', options.expires);
   setIfDefined(argt, 'x-message-ttl', options.messageTtl);
-  setIfDefined(argt, 'x-dead-letter-exchange',
-               options.deadLetterExchange);
-  setIfDefined(argt, 'x-dead-letter-routing-key',
-               options.deadLetterRoutingKey);
+  setIfDefined(argt, 'x-dead-letter-exchange', options.deadLetterExchange);
+  setIfDefined(argt, 'x-dead-letter-routing-key', options.deadLetterRoutingKey);
   setIfDefined(argt, 'x-max-length', options.maxLength);
   setIfDefined(argt, 'x-max-priority', options.maxPriority);
   setIfDefined(argt, 'x-overflow', options.overflow);
@@ -64,126 +56,124 @@ Args.assertQueue = function(queue, options) {
   return {
     queue: queue,
     exclusive: !!options.exclusive,
-    durable: (options.durable === undefined) ? true : options.durable,
+    durable: options.durable === undefined ? true : options.durable,
     autoDelete: !!options.autoDelete,
     arguments: argt,
     passive: false,
     // deprecated but we have to include it
     ticket: 0,
-    nowait: false
-  };
-};
-
-Args.checkQueue = function(queue) {
-  return {
-    queue: queue,
-    passive: true, // switch to "completely different" mode
     nowait: false,
-    durable: true, autoDelete: false, exclusive: false, // ignored
-    ticket: 0,
   };
 };
 
-Args.deleteQueue = function(queue, options) {
+Args.checkQueue = (queue) => ({
+  queue: queue,
+  passive: true, // switch to "completely different" mode
+  nowait: false,
+  durable: true,
+  autoDelete: false,
+  exclusive: false, // ignored
+  ticket: 0,
+});
+
+Args.deleteQueue = (queue, options) => {
   options = options || EMPTY_OPTIONS;
   return {
     queue: queue,
     ifUnused: !!options.ifUnused,
     ifEmpty: !!options.ifEmpty,
-    ticket: 0, nowait: false
-  };
-};
-
-Args.purgeQueue = function(queue) {
-  return {
-    queue: queue,
-    ticket: 0, nowait: false
-  };
-};
-
-Args.bindQueue = function(queue, source, pattern, argt) {
-  return {
-    queue: queue,
-    exchange: source,
-    routingKey: pattern,
-    arguments: argt,
-    ticket: 0, nowait: false
-  };
-};
-
-Args.unbindQueue = function(queue, source, pattern, argt) {
-  return {
-    queue: queue,
-    exchange: source,
-    routingKey: pattern,
-    arguments: argt,
-    ticket: 0, nowait: false
+    ticket: 0,
+    nowait: false,
   };
 };
 
-Args.assertExchange = function(exchange, type, options) {
+Args.purgeQueue = (queue) => ({
+  queue: queue,
+  ticket: 0,
+  nowait: false,
+});
+
+Args.bindQueue = (queue, source, pattern, argt) => ({
+  queue: queue,
+  exchange: source,
+  routingKey: pattern,
+  arguments: argt,
+  ticket: 0,
+  nowait: false,
+});
+
+Args.unbindQueue = (queue, source, pattern, argt) => ({
+  queue: queue,
+  exchange: source,
+  routingKey: pattern,
+  arguments: argt,
+  ticket: 0,
+  nowait: false,
+});
+
+Args.assertExchange = (exchange, type, options) => {
   options = options || EMPTY_OPTIONS;
-  var argt = Object.create(options.arguments || null);
+  const argt = Object.create(options.arguments || null);
   setIfDefined(argt, 'alternate-exchange', options.alternateExchange);
   return {
     exchange: exchange,
     ticket: 0,
     type: type,
     passive: false,
-    durable: (options.durable === undefined) ? true : options.durable,
+    durable: options.durable === undefined ? true : options.durable,
     autoDelete: !!options.autoDelete,
     internal: !!options.internal,
     nowait: false,
-    arguments: argt
-  };
-};
-
-Args.checkExchange = function(exchange) {
-  return {
-    exchange: exchange,
-    passive: true, // switch to 'may as well be another method' mode
-    nowait: false,
-    // ff are ignored
-    durable: true, internal: false,  type: '',  autoDelete: false,
-    ticket: 0
+    arguments: argt,
   };
 };
 
-Args.deleteExchange = function(exchange, options) {
+Args.checkExchange = (exchange) => ({
+  exchange: exchange,
+  passive: true, // switch to 'may as well be another method' mode
+  nowait: false,
+  // ff are ignored
+  durable: true,
+  internal: false,
+  type: '',
+  autoDelete: false,
+  ticket: 0,
+});
+
+Args.deleteExchange = (exchange, options) => {
   options = options || EMPTY_OPTIONS;
   return {
     exchange: exchange,
     ifUnused: !!options.ifUnused,
-    ticket: 0, nowait: false
-  };
-};
-
-Args.bindExchange = function(dest, source, pattern, argt) {
-  return {
-    source: source,
-    destination: dest,
-    routingKey: pattern,
-    arguments: argt,
-    ticket: 0, nowait: false
+    ticket: 0,
+    nowait: false,
   };
 };
 
-Args.unbindExchange = function(dest, source, pattern, argt) {
-  return {
-    source: source,
-    destination: dest,
-    routingKey: pattern,
-    arguments: argt,
-    ticket: 0, nowait: false
-  };
-};
+Args.bindExchange = (dest, source, pattern, argt) => ({
+  source: source,
+  destination: dest,
+  routingKey: pattern,
+  arguments: argt,
+  ticket: 0,
+  nowait: false,
+});
+
+Args.unbindExchange = (dest, source, pattern, argt) => ({
+  source: source,
+  destination: dest,
+  routingKey: pattern,
+  arguments: argt,
+  ticket: 0,
+  nowait: false,
+});
 
 // It's convenient to construct the properties and the method fields
 // at the same time, since in the APIs, values for both can appear in
 // `options`. Since the property or mthod field names don't overlap, I
 // just return one big object that can be used for both purposes, and
 // the encoder will pick out what it wants.
-Args.publish = function(exchange, routingKey, options) {
+Args.publish = (exchange, routingKey, options) => {
   options = options || EMPTY_OPTIONS;
 
   // The CC and BCC fields expect an array of "longstr", which would
@@ -193,31 +183,28 @@ Args.publish = function(exchange, routingKey, options) {
   function convertCC(cc) {
     if (cc === undefined) {
       return undefined;
-    }
-    else if (Array.isArray(cc)) {
+    } else if (Array.isArray(cc)) {
       return cc.map(String);
-    }
-    else return [String(cc)];
+    } else return [String(cc)];
   }
 
-  var headers = Object.create(options.headers || null);
+  const headers = Object.create(options.headers || null);
   setIfDefined(headers, 'CC', convertCC(options.CC));
   setIfDefined(headers, 'BCC', convertCC(options.BCC));
 
-  var deliveryMode; // undefined will default to 1 (non-persistent)
+  let deliveryMode; // undefined will default to 1 (non-persistent)
 
   // Previously I overloaded deliveryMode be a boolean meaning
   // 'persistent or not'; better is to name this option for what it
   // is, but I need to have backwards compatibility for applications
   // that either supply a numeric or boolean value.
-  if (options.persistent !== undefined)
-    deliveryMode = (options.persistent) ? 2 : 1;
-  else if (typeof options.deliveryMode === 'number')
-    deliveryMode = options.deliveryMode;
-  else if (options.deliveryMode) // is supplied and truthy
+  if (options.persistent !== undefined) deliveryMode = options.persistent ? 2 : 1;
+  else if (typeof options.deliveryMode === 'number') deliveryMode = options.deliveryMode;
+  else if (options.deliveryMode)
+    // is supplied and truthy
     deliveryMode = 2;
 
-  var expiration = options.expiration;
+  let expiration = options.expiration;
   if (expiration !== undefined) expiration = expiration.toString();
 
   return {
@@ -241,13 +228,13 @@ Args.publish = function(exchange, routingKey, options) {
     type: options.type,
     userId: options.userId,
     appId: options.appId,
-    clusterId: undefined
+    clusterId: undefined,
   };
 };
 
-Args.consume = function(queue, options) {
+Args.consume = (queue, options) => {
   options = options || EMPTY_OPTIONS;
-  var argt = Object.create(options.arguments || null);
+  const argt = Object.create(options.arguments || null);
   setIfDefined(argt, 'x-priority', options.priority);
   return {
     ticket: 0,
@@ -257,58 +244,46 @@ Args.consume = function(queue, options) {
     noAck: !!options.noAck,
     exclusive: !!options.exclusive,
     nowait: false,
-    arguments: argt
+    arguments: argt,
   };
 };
 
-Args.cancel = function(consumerTag) {
-  return {
-    consumerTag: consumerTag,
-    nowait: false
-  };
-};
+Args.cancel = (consumerTag) => ({
+  consumerTag: consumerTag,
+  nowait: false,
+});
 
-Args.get = function(queue, options) {
+Args.get = (queue, options) => {
   options = options || EMPTY_OPTIONS;
   return {
     ticket: 0,
     queue: queue,
-    noAck: !!options.noAck
-  };
-};
-
-Args.ack = function(tag, allUpTo) {
-  return {
-    deliveryTag: tag,
-    multiple: !!allUpTo
-  };
-};
-
-Args.nack = function(tag, allUpTo, requeue) {
-  return {
-    deliveryTag: tag,
-    multiple: !!allUpTo,
-    requeue: (requeue === undefined) ? true : requeue
-  };
-};
-
-Args.reject = function(tag, requeue) {
-  return {
-    deliveryTag: tag,
-    requeue: (requeue === undefined) ? true : requeue
-  };
-};
-
-Args.prefetch = function(count, global) {
-  return {
-    prefetchCount: count || 0,
-    prefetchSize: 0,
-    global: !!global
+    noAck: !!options.noAck,
   };
 };
 
-Args.recover = function() {
-  return {requeue: true};
-};
+Args.ack = (tag, allUpTo) => ({
+  deliveryTag: tag,
+  multiple: !!allUpTo,
+});
+
+Args.nack = (tag, allUpTo, requeue) => ({
+  deliveryTag: tag,
+  multiple: !!allUpTo,
+  requeue: requeue === undefined ? true : requeue,
+});
+
+Args.reject = (tag, requeue) => ({
+  deliveryTag: tag,
+  requeue: requeue === undefined ? true : requeue,
+});
+
+Args.prefetch = (count, global) => ({
+  prefetchCount: count || 0,
+  prefetchSize: 0,
+  global: !!global,
+});
+
+Args.recover = () => ({ requeue: true });
 
 module.exports = Object.freeze(Args);

package/lib/bitset.js

@@ -1,9 +1,3 @@
-//
-//
-//
-
-'use strict';
-
 /**
  * A bitset implementation, after that in java.util.  Yes there
  * already exist such things, but none implement next{Clear|Set}Bit or
@@ -17,8 +11,7 @@ class BitSet {
     if (size) {
       const numWords = Math.ceil(size / 32);
       this.words = new Array(numWords);
-    }
-    else {
+    } else {
       this.words = [];
     }
     this.wordsInUse = 0; // = number, not index
@@ -80,7 +73,7 @@ class BitSet {
     // word that are > fromIndex
     let word = this.words[w] & (0xffffffff << fromIndex);
     while (true) {
-      if (word) return (w * 32) + trailingZeros(word);
+      if (word) return w * 32 + trailingZeros(word);
       w++;
       if (w === this.wordsInUse) return -1;
       word = this.words[w];
@@ -94,12 +87,12 @@ class BitSet {
     let w = wordIndex(fromIndex);
     if (w >= this.wordsInUse) return fromIndex;
 
-    let word = ~(this.words[w]) & (0xffffffff << fromIndex);
+    let word = ~this.words[w] & (0xffffffff << fromIndex);
     while (true) {
-      if (word) return (w * 32) + trailingZeros(word);
+      if (word) return w * 32 + trailingZeros(word);
       w++;
-      if (w == this.wordsInUse) return w * 32;
-      word = ~(this.words[w]);
+      if (w === this.wordsInUse) return w * 32;
+      word = ~this.words[w];
     }
   }
 }
@@ -119,11 +112,28 @@ function trailingZeros(i) {
   // since bit ops are not necessarily the quick way to do things in
   // JS.
   if (i === 0) return 32;
-  let y, n = 31;
-  y = i << 16; if (y != 0) { n = n -16; i = y; }
-  y = i << 8;  if (y != 0) { n = n - 8; i = y; }
-  y = i << 4;  if (y != 0) { n = n - 4; i = y; }
-  y = i << 2;  if (y != 0) { n = n - 2; i = y; }
+  let y;
+  let n = 31;
+  y = i << 16;
+  if (y !== 0) {
+    n = n - 16;
+    i = y;
+  }
+  y = i << 8;
+  if (y !== 0) {
+    n = n - 8;
+    i = y;
+  }
+  y = i << 4;
+  if (y !== 0) {
+    n = n - 4;
+    i = y;
+  }
+  y = i << 2;
+  if (y !== 0) {
+    n = n - 2;
+    i = y;
+  }
   return n - ((i << 1) >>> 31);
 }