amqplib 0.10.2 → 0.10.4

package/lib/format.js

@@ -8,7 +8,6 @@
 
 var defs = require('./defs');
 var format = require('util').format;
-var inherits = require('util').inherits;
 var HEARTBEAT = require('./frame').HEARTBEAT;
 
 module.exports.closeMessage = function(close) {

package/lib/frame.js

@@ -8,7 +8,7 @@ var defs = require('./defs');
 var constants = defs.constants;
 var decode = defs.decode;
 
-var Bits = require('bitsyntax');
+var Bits = require('@acuminous/bitsyntax');
 
 module.exports.PROTOCOL_HEADER = "AMQP" + String.fromCharCode(0, 0, 9, 1);
 

package/lib/heartbeat.js

@@ -47,43 +47,46 @@
 
 'use strict';
 
-var inherits = require('util').inherits;
-var EventEmitter = require('events').EventEmitter;
+var EventEmitter = require('events');
 
 // Exported so that we can mess with it in tests
 module.exports.UNITS_TO_MS = 1000;
 
-function Heart(interval, checkSend, checkRecv) {
-  EventEmitter.call(this);
-  this.interval = interval;
+class Heart extends EventEmitter {
+  constructor (interval, checkSend, checkRecv) {
+    super();
 
-  var intervalMs = interval * module.exports.UNITS_TO_MS;
-  // Function#bind is my new best friend
-  var beat = this.emit.bind(this, 'beat');
-  var timeout = this.emit.bind(this, 'timeout');
+    this.interval = interval;
 
-  this.sendTimer = setInterval(
-    this.runHeartbeat.bind(this, checkSend, beat), intervalMs / 2);
+    var intervalMs = interval * module.exports.UNITS_TO_MS;
+    // Function#bind is my new best friend
+    var beat = this.emit.bind(this, 'beat');
+    var timeout = this.emit.bind(this, 'timeout');
 
-  // A timeout occurs if I see nothing for *two consecutive* intervals
-  var recvMissed = 0;
-  function missedTwo() {
-    if (!checkRecv()) return (++recvMissed < 2);
-    else { recvMissed = 0; return true; }
+    this.sendTimer = setInterval(
+      this.runHeartbeat.bind(this, checkSend, beat), intervalMs / 2);
+
+    // A timeout occurs if I see nothing for *two consecutive* intervals
+    var recvMissed = 0;
+    function missedTwo () {
+      if (!checkRecv())
+        return (++recvMissed < 2);
+      else { recvMissed = 0; return true; }
+    }
+    this.recvTimer = setInterval(
+      this.runHeartbeat.bind(this, missedTwo, timeout), intervalMs);
   }
-  this.recvTimer = setInterval(
-    this.runHeartbeat.bind(this, missedTwo, timeout), intervalMs);
-}
-inherits(Heart, EventEmitter);
 
-module.exports.Heart = Heart;
+  clear () {
+    clearInterval(this.sendTimer);
+    clearInterval(this.recvTimer);
+  }
 
-Heart.prototype.clear = function() {
-  clearInterval(this.sendTimer);
-  clearInterval(this.recvTimer);
-};
+  runHeartbeat (check, fail) {
+    // Have we seen activity?
+    if (!check())
+      fail();
+  }
+}
 
-Heart.prototype.runHeartbeat = function(check, fail) {
-  // Have we seen activity?
-  if (!check()) fail();
-};
+module.exports.Heart = Heart;

package/lib/mux.js

@@ -13,117 +13,114 @@ var assert = require('assert');
 var schedule = (typeof setImmediate === 'function') ?
   setImmediate : process.nextTick;
 
-function Mux(downstream) {
-  this.newStreams = [];
-  this.oldStreams = [];
-  this.blocked = false;
-  this.scheduledRead = false;
-
-  this.out = downstream;
-  var self = this;
-  downstream.on('drain', function() {
-    self.blocked = false;
-    self._readIncoming();
-  });
-}
-
-// There are 2 states we can be in:
-
-// - waiting for outbound capacity, which will be signalled by a
-// - 'drain' event on the downstream; or,
-
-// - no packets to send, waiting for an inbound buffer to have
-//   packets, which will be signalled by a 'readable' event
-
-// If we write all packets available whenever there is outbound
-// capacity, we will either run out of outbound capacity (`#write`
-// returns false), or run out of packets (all calls to an
-// `inbound.read()` have returned null).
+class Mux {
+  constructor (downstream) {
+    this.newStreams = [];
+    this.oldStreams = [];
+    this.blocked = false;
+    this.scheduledRead = false;
+
+    this.out = downstream;
+    var self = this;
+    downstream.on('drain', function () {
+      self.blocked = false;
+      self._readIncoming();
+    });
+  }
 
-Mux.prototype._readIncoming = function() {
+  // There are 2 states we can be in:
+  // - waiting for outbound capacity, which will be signalled by a
+  // - 'drain' event on the downstream; or,
+  // - no packets to send, waiting for an inbound buffer to have
+  //   packets, which will be signalled by a 'readable' event
+  // If we write all packets available whenever there is outbound
+  // capacity, we will either run out of outbound capacity (`#write`
+  // returns false), or run out of packets (all calls to an
+  // `inbound.read()` have returned null).
+  _readIncoming () {
+
+    // We may be sent here speculatively, if an incoming stream has
+    // become readable
+    if (this.blocked) return;
+
+    var accepting = true;
+    var out = this.out;
+
+    // Try to read a chunk from each stream in turn, until all streams
+    // are empty, or we exhaust our ability to accept chunks.
+    function roundrobin (streams) {
+      var s;
+      while (accepting && (s = streams.shift())) {
+        var chunk = s.read();
+        if (chunk !== null) {
+          accepting = out.write(chunk);
+          streams.push(s);
+        }
+      }
+    }
 
-  // We may be sent here speculatively, if an incoming stream has
-  // become readable
-  if (this.blocked) return;
+    roundrobin(this.newStreams);
+
+    // Either we exhausted the new queues, or we ran out of capacity. If
+    // we ran out of capacity, all the remaining new streams (i.e.,
+    // those with packets left) become old streams. This effectively
+    // prioritises streams that keep their buffers close to empty over
+    // those that are constantly near full.
+    if (accepting) { // all new queues are exhausted, write as many as
+      // we can from the old streams
+      assert.equal(0, this.newStreams.length);
+      roundrobin(this.oldStreams);
+    }
+    else { // ran out of room
+      assert(this.newStreams.length > 0, "Expect some new streams to remain");
+      Array.prototype.push.apply(this.oldStreams, this.newStreams);
+      this.newStreams = [];
+    }
+    // We may have exhausted all the old queues, or run out of room;
+    // either way, all we need to do is record whether we have capacity
+    // or not, so any speculative reads will know
+    this.blocked = !accepting;
+  }
 
-  var accepting = true;
-  var out = this.out;
+  _scheduleRead () {
+    var self = this;
 
-  // Try to read a chunk from each stream in turn, until all streams
-  // are empty, or we exhaust our ability to accept chunks.
-  function roundrobin(streams) {
-    var s;
-    while (accepting && (s = streams.shift())) {
-      var chunk = s.read();
-      if (chunk !== null) {
-        accepting = out.write(chunk);
-        streams.push(s);
-      }
+    if (!self.scheduledRead) {
+      schedule(function () {
+        self.scheduledRead = false;
+        self._readIncoming();
+      });
+      self.scheduledRead = true;
     }
   }
 
-  roundrobin(this.newStreams);
+  pipeFrom (readable) {
+    var self = this;
 
-  // Either we exhausted the new queues, or we ran out of capacity. If
-  // we ran out of capacity, all the remaining new streams (i.e.,
-  // those with packets left) become old streams. This effectively
-  // prioritises streams that keep their buffers close to empty over
-  // those that are constantly near full.
-
-  if (accepting) { // all new queues are exhausted, write as many as
-                   // we can from the old streams
-    assert.equal(0, this.newStreams.length);
-    roundrobin(this.oldStreams);
-  }
-  else { // ran out of room
-    assert(this.newStreams.length > 0, "Expect some new streams to remain");
-    Array.prototype.push.apply(this.oldStreams, this.newStreams);
-    this.newStreams = [];
-  }
-  // We may have exhausted all the old queues, or run out of room;
-  // either way, all we need to do is record whether we have capacity
-  // or not, so any speculative reads will know
-  this.blocked = !accepting;
-};
-
-Mux.prototype._scheduleRead = function() {
-  var self = this;
-
-  if (!self.scheduledRead) {
-    schedule(function() {
-      self.scheduledRead = false;
-      self._readIncoming();
-    });
-    self.scheduledRead = true;
-  }
-};
+    function enqueue () {
+      self.newStreams.push(readable);
+      self._scheduleRead();
+    }
 
-Mux.prototype.pipeFrom = function(readable) {
-  var self = this;
+    function cleanup () {
+      readable.removeListener('readable', enqueue);
+      readable.removeListener('error', cleanup);
+      readable.removeListener('end', cleanup);
+      readable.removeListener('unpipeFrom', cleanupIfMe);
+    }
+    function cleanupIfMe (dest) {
+      if (dest === self) cleanup();
+    }
 
-  function enqueue() {
-    self.newStreams.push(readable);
-    self._scheduleRead();
+    readable.on('unpipeFrom', cleanupIfMe);
+    readable.on('end', cleanup);
+    readable.on('error', cleanup);
+    readable.on('readable', enqueue);
   }
 
-  function cleanup() {
-    readable.removeListener('readable', enqueue);
-    readable.removeListener('error', cleanup);
-    readable.removeListener('end', cleanup);
-    readable.removeListener('unpipeFrom', cleanupIfMe);
-  }
-  function cleanupIfMe(dest) {
-    if (dest === self) cleanup();
+  unpipeFrom (readable) {
+    readable.emit('unpipeFrom', this);
   }
-
-  readable.on('unpipeFrom', cleanupIfMe);
-  readable.on('end', cleanup);
-  readable.on('error', cleanup);
-  readable.on('readable', enqueue);
-};
-
-Mux.prototype.unpipeFrom = function(readable) {
-  readable.emit('unpipeFrom', this);
-};
+}
 
 module.exports.Mux = Mux;

package/package.json

@@ -2,7 +2,7 @@
   "name": "amqplib",
   "homepage": "http://amqp-node.github.io/amqplib/",
   "main": "./channel_api.js",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "description": "An AMQP 0-9-1 (e.g., RabbitMQ) library and client.",
   "repository": {
     "type": "git",
@@ -12,7 +12,7 @@
     "node": ">=10"
   },
   "dependencies": {
-    "bitsyntax": "~0.1.0",
+    "@acuminous/bitsyntax": "^0.1.2",
     "buffer-more-ints": "~1.0.0",
     "readable-stream": "1.x >=1.1.9",
     "url-parse": "~1.5.10"