aes70 2.0.14 → 2.0.16

package/dist/AES70.es5.js

@@ -31,12 +31,13 @@
   class Events {
     constructor() {
       this.event_handlers = new Map();
+      this.event_handlers_cleared = false;
     }
 
     /**
      * Emit an event.
      *
-     * @param {String} name - Name of the event.
+     * @param {string} name - Name of the event.
      * @param {...*} args - Extra arguments.
      */
     emit(name) {
@@ -57,7 +58,7 @@
     /**
      * Subscribe to an event.
      *
-     * @param {String} name - Name of the event.
+     * @param {string} name - Name of the event.
      * @param {Function} cb - Callback function.
      */
     on(name, cb) {
@@ -81,14 +82,17 @@
     /**
      * Removes an event handler.
      *
-     * @param {String} name - Name of the event.
+     * @param {string} name - Name of the event.
      * @param {Function} cb - Callback function.
      */
     removeEventListener(name, cb) {
       const handlers = this.event_handlers.get(name);
 
       if (!handlers || !handlers.has(cb)) {
-        throw new Error('removeEventListeners(): not installed.');
+        if (!this.event_handlers_cleared) {
+          console.warn('removeEventListeners(): not installed:', name, cb);
+        }
+        return;
       }
 
       handlers.delete(cb);
@@ -97,7 +101,7 @@
     /**
      * Removes an event handler.
      *
-     * @param {strign} name
+     * @param {string} name
      * @param {Function} cb
      */
     off(name, cb) {
@@ -109,6 +113,7 @@
      */
     removeAllEventListeners() {
       this.event_handlers.clear();
+      this.event_handlers_cleared = true;
     }
 
     /**
@@ -934,6 +939,14 @@
       };
     }
 
+    get bufferedAmount() {
+      return this._currentSize;
+    }
+
+    get batchSize() {
+      return this._batchSize;
+    }
+
     add(pdu) {
       const currentSize = this._currentSize;
       const encodedLength = pdu.encoded_length();
@@ -966,7 +979,7 @@
       /* Keepalive packets are never combined into one message. */
       this._lastMessageType = messageType;
 
-      if (this._currentSize > this._batchSize) {
+      if (this._currentSize + additionalSize > this._batchSize) {
         this.flush();
       } else if (this._pdus.length === 1) {
         this.scheduleFlush();
@@ -1031,6 +1044,130 @@
     }
   }
 
+  function isItTime(target, now) {
+    // We are ok with 1ms accuracy.
+    return target - now < 1;
+  }
+
+  class Timer {
+    constructor(callback, getNow) {
+      this._callback = callback;
+      this._getNow = getNow;
+      this._targetTime = undefined;
+      this._timerId = undefined;
+      this._timerAt = undefined;
+    }
+
+    poll() {
+      const now = this._getNow();
+
+      if (this._targetTime === undefined) return;
+
+      if (isItTime(this._targetTime, now)) {
+        this._targetTime = undefined;
+        try {
+          this._callback();
+        } catch (err) {
+          console.error('Timer callback threw an exception', err);
+        }
+      } else {
+        this._reschedule();
+      }
+    }
+
+    _reschedule() {
+      const target = this._targetTime;
+      const interval = target - this._getNow();
+
+      if (this._timerId !== undefined) {
+        if (target >= this._timerAt) {
+          // The timer will fire before target. We will then reschedule it.
+          return;
+        }
+
+        clearTimeout(this._timerId);
+        this._timerId = undefined;
+      }
+
+      this._timerAt = target;
+      this._timerId = setTimeout(() => {
+        this._timerId = undefined;
+        this._timerAt = undefined;
+        this.poll();
+      }, Math.max(0, interval));
+    }
+
+    /**
+     *
+     * @param {number} interval
+     *   Interval in milliseconds.
+     */
+    scheduleIn(interval) {
+      if (!(interval >= 0)) {
+        throw new TypeError(`Expected positive interval.`);
+      }
+
+      this._targetTime = this._getNow() + interval;
+      this._reschedule();
+    }
+
+    /**
+     * Schedule the timer in a given number of milliseconds. If the timer
+     * is already running and scheduled to run before, do not modify it.
+     *
+     * @param {number} interval
+     */
+    scheduleDeadlineIn(interval) {
+      if (!(interval >= 0)) {
+        throw new TypeError(`Expected positive interval.`);
+      }
+
+      const target = this._getNow() + interval;
+
+      if (this._targetTime !== undefined && this._targetTime <= target) {
+        this.poll();
+        return;
+      }
+
+      this.scheduleAt(target);
+    }
+
+    /**
+     *
+     * @param {number} target
+     *   Target time in milliseconds.
+     */
+    scheduleAt(target) {
+      if (!(target >= 0)) {
+        throw new TypeError();
+      }
+
+      this._targetTime = target;
+      this._reschedule();
+    }
+
+    stop() {
+      this._targetTime = undefined;
+    }
+
+    cancel() {
+      this.stop();
+      this._clearTimeout();
+    }
+
+    _clearTimeout() {
+      if (this._timerId) {
+        clearTimeout(this._timerId);
+        this._timerId = undefined;
+        this._timerAt = undefined;
+      }
+    }
+
+    dispose() {
+      this.cancel();
+    }
+  }
+
   /**
    * Connection base class. It extends :class:`Events` and defines two events:
    *
@@ -1067,8 +1204,11 @@
       this.last_tx_time = now;
       this.rx_bytes = 0;
       this.tx_bytes = 0;
+      this._keepalive_timer = new Timer(
+        () => this._check_keepalive(),
+        () => this._now()
+      );
       this.keepalive_interval = -1;
-      this._keepalive_interval_id = null;
       this._closed = false;
       this.on('close', () => {
         if (this._closed) return;
@@ -1087,6 +1227,18 @@
       return true;
     }
 
+    get bufferedAmount() {
+      return this._message_generator.bufferedAmount;
+    }
+
+    get batchSize() {
+      return this._message_generator.batchSize;
+    }
+
+    get pendingWrites() {
+      return this._message_generator.bufferedAmount > 0 ? 1 : 0;
+    }
+
     send(pdu) {
       if (this.is_closed()) throw new Error('Connection is closed.');
       this.emit('send', pdu);
@@ -1144,7 +1296,7 @@
         }
       }
 
-      this._check_keepalive();
+      this.poll();
     }
 
     incoming(a) {}
@@ -1175,16 +1327,18 @@
       if (this.is_closed()) throw new Error('cleanup() called twice.');
 
       // disable keepalive
-      this.set_keepalive_interval(0);
+      this._keepalive_timer.dispose();
       this._message_generator.dispose();
       this._message_generator = null;
       this.removeAllEventListeners();
     }
 
     _check_keepalive() {
-      if (!(this.keepalive_interval > 0)) return;
-
+      if (this.is_closed()) return;
       const t = this.keepalive_interval;
+      if (!(t > 0)) return;
+
+      this._keepalive_timer.scheduleIn(t / 2 + 10);
 
       if (this.rx_idle_time() > t * 3) {
         this.emit('timeout');
@@ -1196,6 +1350,13 @@
       }
     }
 
+    /**
+     * Check if some regular internal timers must run.
+     */
+    poll() {
+      this._keepalive_timer.poll();
+    }
+
     /**
      * Flush write buffers. This are usually PDUs or may also be unwritten
      * buffers.
@@ -1221,11 +1382,6 @@
 
       const t = seconds * 1000;
 
-      if (this._keepalive_interval_id !== null) {
-        clearInterval(this._keepalive_interval_id);
-        this._keepalive_interval_id = null;
-      }
-
       this.keepalive_interval = t;
 
       // Notify the other side about our new keepalive
@@ -1233,12 +1389,12 @@
 
       this.send(new KeepAlive(t));
 
-      if (!(t > 0)) return;
-
-      // we check twice as often to make sure we stay within the timers
-      this._keepalive_interval_id = setInterval(() => {
-        this._check_keepalive();
-      }, t / 2);
+      if (t > 0) {
+        // we check twice as often to make sure we stay within the timers
+        this._keepalive_timer.scheduleIn(t / 2 + 10);
+      } else {
+        this._keepalive_timer.stop();
+      }
     }
   }
 
@@ -1585,6 +1741,67 @@
     }
   }
 
+  class Subscriptions {
+    constructor() {
+      this._callbacks = [];
+    }
+
+    /**
+     * Add a subscription.
+     *
+     * @param {Function[]} cbs
+     */
+    add(...cbs) {
+      cbs.forEach((cb) => {
+        this._callbacks.push(cb);
+      });
+    }
+
+    unsubscribe() {
+      this._callbacks.forEach((cb) => {
+        try {
+          cb();
+        } catch (err) {
+          console.error(err);
+        }
+      });
+      this._callbacks.length = 0;
+    }
+  }
+
+  function addEvent(target, name, callback) {
+    if (target.addEventListener) {
+      target.addEventListener(name, callback);
+    } else if (target.on) {
+      target.on(name, callback);
+    } else {
+      throw new TypeError('Unsupported event target ', target);
+    }
+  }
+
+  function removeEvent(target, name, callback) {
+    if (target.removeEventListener) {
+      target.removeEventListener(name, callback);
+    } else if (target.off) {
+      target.off(name, callback);
+    } else {
+      throw new TypeError('Unsupported event target ', target);
+    }
+  }
+
+  /**
+   *
+   * @param {EventTarget|Events} target
+   * @param {string} name
+   * @param {callback} callback
+   */
+  function subscribeEvent(target, name, callback) {
+    addEvent(target, name, callback);
+    return () => {
+      removeEvent(target, name, callback);
+    };
+  }
+
   class PendingCommand {
     get handle() {
       return this.command.handle;
@@ -1663,17 +1880,57 @@
   class ClientConnection extends Connection {
     constructor(options) {
       super(options);
+      // All pending commands by id/handle
       this._pendingCommands = new Map();
+      // All pending commands scheduled to be sent.
+      this._scheduledPendingCommands = new Set();
+      // All pending commands wich have been sent.
+      this._sentPendingCommands = new Set();
       this._nextCommandHandle = 0;
       this._subscribers = new Map();
+      this._sendCommandsTimer = new Timer(
+        () => {
+          this.sendCommands();
+        },
+        () => this._now()
+      );
+    }
+
+    shouldSendMoreCommands() {
+      return this.is_reliable;
+    }
+
+    sendCommands() {
+      const { _scheduledPendingCommands, _sentPendingCommands } = this;
+
+      for (const pendingCommand of _scheduledPendingCommands) {
+        if (!this.shouldSendMoreCommands()) break;
+        _scheduledPendingCommands.delete(pendingCommand);
+        _sentPendingCommands.add(pendingCommand);
+        this.send(pendingCommand.command);
+        pendingCommand.lastSent = this._now();
+        pendingCommand.retries++;
+      }
+    }
+
+    scheduleSendCommands() {
+      this._sendCommandsTimer.scheduleDeadlineIn(5);
+    }
+
+    poll() {
+      super.poll();
+      this._sendCommandsTimer.poll();
     }
 
     cleanup(error) {
       super.cleanup(error);
+      this._sendCommandsTimer.dispose();
       const subscribers = this._subscribers;
       this._subscribers = null;
       const pendingCommands = this._pendingCommands;
       this._pendingCommands = null;
+      this._scheduledPendingCommands.clear();
+      this._sentPendingCommands.clear();
 
       const e = new CloseError(error);
       pendingCommands.forEach((pendingCommand, id) => {
@@ -1752,9 +2009,8 @@
         );
 
         this._pendingCommands.set(handle, pendingCommand);
-
-        pendingCommand.lastSent = this._estimate_next_tx_time();
-        this.send(command);
+        this._scheduledPendingCommands.add(pendingCommand);
+        this.scheduleSendCommands();
       };
 
       if (callback) {
@@ -1775,6 +2031,9 @@
 
       pendingCommands.delete(handle);
 
+      if (!this._sentPendingCommands.delete(pendingCommand))
+        this._scheduledPendingCommands.delete(pendingCommand);
+
       return pendingCommand;
     }
 
@@ -1829,35 +2088,34 @@
      * the connection will be closed and the returned promise will reject.
      * @param {number} interval
      *   Keepalive interval in seconds.
+     * @param {AbortSignal} [signal]
+     *   Optional abort signal which can be used to abort
+     *   the process.
      */
-    wait_for_keepalive(interval) {
-      return new Promise((resolve, reject) => {
-        const subscriptions = [];
+    wait_for_keepalive(interval, signal) {
+      const subscriptions = new Subscriptions();
 
-        const cleanup = () => {
-          subscriptions.forEach((cb) => {
-            try {
-              cb();
-            } catch (e) {}
-          });
-          subscriptions.length = 0;
-        };
-        subscriptions.push(
+      return new Promise((resolve, reject) => {
+        if (signal) {
+          subscriptions.add(
+            subscribeEvent(signal, 'abort', () => {
+              reject(signal.reason);
+            })
+          );
+        }
+        subscriptions.add(
           this.subscribe('error', (error) => {
             reject(error);
-            cleanup();
           }),
           this.subscribe('close', () => {
             reject(new CloseError());
-            cleanup();
           }),
           this.subscribe('keepalive', () => {
             resolve();
-            cleanup();
           })
         );
         this.set_keepalive_interval(interval);
-      });
+      }).finally(() => subscriptions.unsubscribe());
     }
   }
 
@@ -3486,8 +3744,7 @@
      * @returns {Function} The getter. If none could be found, null is returned.
      */
     getter(o, no_bind) {
-      let name = this.name;
-      let i = 0;
+      const name = this.name;
       const aliases = this.aliases;
       const accessors = this.accessors;
 
@@ -3529,10 +3786,13 @@
         return no_bind ? fun : fun.bind(o);
       }
 
-      do {
+      // iterate all possible names
+      const possibleNames = aliases ? [name, ...aliases] : [name];
+
+      for (const possibleName of possibleNames) {
         if (this.static) {
           const c = o.constructor;
-          const v = c[name];
+          const v = c[possibleName];
 
           if (v !== void 0) {
             return function () {
@@ -3540,16 +3800,11 @@
             };
           }
         } else {
-          const fun = o['Get' + name];
+          const fun = o['Get' + possibleName];
 
           if (fun) return no_bind ? fun : fun.bind(o);
         }
-
-        if (aliases && i < aliases.length) {
-          name = aliases[i++];
-          continue;
-        }
-      } while (false);
+      }
 
       return null;
     }
@@ -3565,20 +3820,15 @@
     setter(o, no_bind) {
       if (this.readonly || this.static) return null;
 
-      let name = this.name,
-        i = 0;
+      const name = this.name;
       const aliases = this.aliases;
+      const possibleNames = aliases ? [name, ...aliases] : [name];
 
-      do {
-        const fun = o['Set' + name];
+      for (const possibleName of possibleNames) {
+        const fun = o['Set' + possibleName];
 
         if (fun) return no_bind ? fun : fun.bind(o);
-
-        if (aliases && i < aliases.length) {
-          name = aliases[i++];
-          continue;
-        }
-      } while (false);
+      }
 
       return null;
     }
@@ -28733,35 +28983,6 @@
 
   /* eslint-env node */
 
-
-  function delay(n) {
-    return new Promise((resolve) => setTimeout(resolve, n));
-  }
-
-  async function waitForKeepalive(socket, options) {
-    const waiter = socket.receiveMessage().then((buffer) => {
-      const pdus = [];
-      const pos = decodeMessage(new DataView(buffer), 0, pdus);
-
-      if (pdus.length !== 1) throw new Error('Expected keepalive response.');
-      if (pos !== buffer.byteLength)
-        throw new Error('Trailing data in initial keepalive pdu.');
-
-      return true;
-    });
-
-    const msg = encodeMessage(new KeepAlive(1000));
-    const t = 5 * (options.retry_interval || 250);
-
-    for (let i = 0; i < 3; i++) {
-      socket.send(msg);
-
-      if (await Promise.race([waiter, delay(t)])) return;
-    }
-
-    throw new Error('Failed to connect.');
-  }
-
   /**
    * :class:`ClientConnection` subclass which implements OCP.1 with UDP
    * transport.
@@ -28778,15 +28999,20 @@
       this.retry_interval =
         options.retry_interval >= 0 ? options.retry_interval : 250;
       this.retry_count = options.retry_count >= 0 ? options.retry_count : 3;
-      this._write_out_id = -1;
-      this._write_out_callback = () => {
-        this._write_out_id = -1;
-        this._write_out();
-      };
-      this._retry_id =
-        this.retry_interval > 0
-          ? setInterval(() => this._retryCommands(), this.retry_interval)
-          : -1;
+      this._write_out_timer = new Timer(
+        () => {
+          this._write_out();
+        },
+        () => this._now()
+      );
+      this._retry_timer = new Timer(
+        () => {
+          this._retryCommands();
+          this._retry_timer.scheduleIn(this.retry_interval);
+        },
+        () => this._now()
+      );
+      this._retry_timer.scheduleIn(this.retry_interval);
       this.q = [];
       socket.onmessage = (buffer) => {
         try {
@@ -28804,11 +29030,33 @@
       return false;
     }
 
+    get bufferedAmount() {
+      let amount = super.bufferedAmount;
+
+      for (const buf of this.q) {
+        amount += buf.byteLength;
+      }
+
+      return amount;
+    }
+
+    get pendingWrites() {
+      return super.pendingWrites + this.q.length;
+    }
+
+    shouldSendMoreCommands() {
+      return this.q.length < 3;
+    }
+
     /**
      * Connect to the given endpoint.
      *
-     * @param {String} options.host - hostname or ip
-     * @param {number} options.port - port number
+     * @param {String} options.host
+     *  Hostname or ip address.
+     * @param {number} options.port
+     *  Port number.
+     * @param {'udp4' | 'udp6'} [options.type]
+     *  Optional ip protocol type.
      * @param {number} [options.delay=10] - Delay in ms between individual packets.
      *    This can be a useful strategy when communicating with devices which
      *    cannot handle high packet rates.
@@ -28822,23 +29070,33 @@
      *    in an individual UDP packet. Note that AES70 messages which are larger
      *    than this limit are sent anyway. This only limits how many seperate
      *    messages are batched into a single packet.
-     * @returns {Promise<UDPConnection>}
+     * @param {AbortSignal} [options.connectSignal]
+     *    An optional AbortSignal which can be used to abort the connect attempt.
+     *    Note that this is different from the `signal` option which will destroy
+     *    the socket also after the connect attempt has been successful.
+     * @returns {Promise<AbstractUDPConnection>}
      *    The connection.
      */
     static async connect(udpApi, options) {
-      const socket = await udpApi.connect(
-        options.host,
-        options.port,
-        options.type
-      );
+      const { host, port, type, connectSignal } = options;
+      const socket = await udpApi.connect({
+        host,
+        port,
+        type,
+        signal: connectSignal,
+      });
+
+      const connection = new this(socket, options);
 
       try {
-        await waitForKeepalive(socket, options);
-        return new this(socket, options);
+        await connection.wait_for_keepalive(1, connectSignal);
+        connectSignal?.throwIfAborted();
       } catch (err) {
-        socket.close();
+        connection.close();
         throw err;
       }
+
+      return connection;
     }
 
     write(buf) {
@@ -28859,14 +29117,8 @@
         this.socket.close();
         this.socket = null;
       }
-      if (this._write_out_id !== -1) {
-        clearTimeout(this._write_out_id);
-        this._write_out_id = -1;
-      }
-      if (this._retry_id !== -1) {
-        clearInterval(this._retry_id);
-        this._retry_id = -1;
-      }
+      this._write_out_timer.dispose();
+      this._retry_timer.dispose();
     }
 
     _estimate_next_tx_time() {
@@ -28885,6 +29137,13 @@
       super.write(buf);
 
       if (q.length) this._schedule_write_out();
+      this.scheduleSendCommands();
+    }
+
+    poll() {
+      super.poll();
+      this._write_out_timer.poll();
+      this._retry_timer.poll();
     }
 
     _schedule_write_out() {
@@ -28896,38 +29155,36 @@
         return;
       }
 
-      // Already scheduled.
-      if (this._write_out_id !== -1) return;
-
-      this._write_out_id = setTimeout(
-        this._write_out_callback,
-        delay - tx_idle_time
-      );
+      this._write_out_timer.scheduleIn(delay - tx_idle_time);
     }
 
     _retryCommands() {
       const now = this._now();
       const retryTime = now - this.retry_interval;
-      // This is an estimate for how many commands we would manage to send
-      // off.
-      const max = 5 * (this.retry_interval / this.delay) - this.q.length;
       const pendingCommands = this._pendingCommands;
+      const _sentPendingCommands = this._sentPendingCommands;
+      const _scheduledPendingCommands = this._scheduledPendingCommands;
 
-      const retries = [];
+      let scheduledCount = 0;
       const failed = [];
 
-      for (const entry of pendingCommands) {
-        const [, pendingCommand] = entry;
-
-        // All later commands are newer than the cutoff.
+      for (const pendingCommand of _sentPendingCommands) {
         if (pendingCommand.lastSent > retryTime) break;
+
+        _sentPendingCommands.delete(pendingCommand);
+
         if (pendingCommand.retries >= this.retry_count) {
-          failed.push(entry);
-        } else if (retries.length < max) {
-          retries.push(entry);
+          failed.push(pendingCommand);
+        } else {
+          _scheduledPendingCommands.add(pendingCommand);
+          scheduledCount++;
         }
       }
 
+      if (scheduledCount) {
+        this.scheduleSendCommands();
+      }
+
       if (failed.length) {
         const timeoutError = new Error('Timeout.');
 
@@ -28936,14 +29193,6 @@
           pendingCommand.reject(timeoutError);
         });
       }
-
-      retries.forEach(([handle, pendingCommand]) => {
-        pendingCommands.delete(handle);
-        pendingCommands.set(handle, pendingCommand);
-        this.send(pendingCommand.command);
-        pendingCommand.lastSent = now;
-        pendingCommand.retries++;
-      });
     }
   }
 
@@ -29072,6 +29321,10 @@
         }
         return value;
       }
+    } else if (typeof value === 'bigint') {
+      return value >= Number.MIN_SAFE_INTEGER && value <= Number.MAX_SAFE_INTEGER
+        ? Number(value)
+        : value.toString();
     } else {
       return value;
     }