aes70 2.0.3 → 2.0.4

package/dist/AES70.es5.js

@@ -61,6 +61,10 @@
      * @param {Function} cb - Callback function.
      */
     on(name, cb) {
+      if (typeof name !== 'string')
+        throw new TypeError('Event name must be a string.');
+      if (typeof cb !== 'function')
+        throw new TypeError('Event handler must be a function.');
       let handlers = this.event_handlers.get(name);
 
       if (!handlers) {
@@ -90,12 +94,36 @@
       handlers.delete(cb);
     }
 
+    /**
+     * Removes an event handler.
+     *
+     * @param {strign} name
+     * @param {Function} cb
+     */
+    off(name, cb) {
+      this.removeEventListener(name, cb);
+    }
+
     /**
      * Removes all event listeners.
      */
     removeAllEventListeners() {
       this.event_handlers.clear();
     }
+
+    /**
+     *
+     * @param {string} name
+     * @param {Function} cb
+     */
+    subscribe(name, cb) {
+      this.on(name, cb);
+      return () => {
+        if (name === undefined) return;
+        this.off(name, cb);
+        name = undefined;
+      };
+    }
   }
 
   class PDU {
@@ -1185,6 +1213,12 @@
      *    Keepalive interval in seconds.
      */
     set_keepalive_interval(seconds) {
+      if (!(seconds <= 10)) {
+        console.warn(
+          'Unusually large keepalive interval %o seconds. Confusion of ms vs. seconds?'
+        );
+      }
+
       const t = seconds * 1000;
 
       if (this._keepalive_interval_id !== null) {
@@ -1782,11 +1816,45 @@
           if (!(o.time > 0)) {
             throw new Error('Bad keepalive timeout.');
           }
+          this.emit('keepalive', o);
         } else {
           throw new Error('Unexpected PDU');
         }
       }
     }
+
+    /**
+     * Activates keepalive handling (using set_keepalive_interval) and waits for
+     * at least one keepalive packet to arrive. If no keepalive message is received,
+     * the connection will be closed and the returned promise will reject.
+     * @param {number} interval
+     *   Keepalive interval in seconds.
+     */
+    wait_for_keepalive(interval) {
+      return new Promise((resolve, reject) => {
+        const subscriptions = [];
+
+        const cleanup = () => {
+          subscriptions.forEach((cb) => cb());
+          subscriptions.length = 0;
+        };
+        subscriptions.push(
+          this.subscribe('error', (error) => {
+            reject(error);
+            cleanup();
+          }),
+          this.subscribe('close', () => {
+            reject(new CloseError());
+            cleanup();
+          }),
+          this.subscribe('keepalive', () => {
+            resolve();
+            cleanup();
+          })
+        );
+        this.set_keepalive_interval(interval);
+      });
+    }
   }
 
   function getLengthEncoder(byteLength) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aes70",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "description": "A controller library for the AES70 protocol.",
   "type": "module",
   "main": "src/index.js",

package/src/connection.js

@@ -186,6 +186,12 @@ export class Connection extends Events {
    *    Keepalive interval in seconds.
    */
   set_keepalive_interval(seconds) {
+    if (!(seconds <= 10)) {
+      console.warn(
+        'Unusually large keepalive interval %o seconds. Confusion of ms vs. seconds?'
+      );
+    }
+
     const t = seconds * 1000;
 
     if (this._keepalive_interval_id !== null) {

package/src/controller/client_connection.d.ts

@@ -33,4 +33,13 @@ export interface PendingCommand {
  */
 export declare class ClientConnection extends Connection {
   constructor(options: IClientConnectionOptions);
+
+  /**
+   * Activates keepalive handling (using set_keepalive_interval) and waits for
+   * at least one keepalive packet to arrive. If no keepalive message is received,
+   * the connection will be closed and the returned promise will reject.
+   * @param {number} interval
+   *   Keepalive interval in seconds.
+   */
+  wait_for_keepalive(interval: number): Promise<void>;
 }

package/src/controller/client_connection.js

@@ -241,9 +241,43 @@ export class ClientConnection extends Connection {
         if (!(o.time > 0)) {
           throw new Error('Bad keepalive timeout.');
         }
+        this.emit('keepalive', o);
       } else {
         throw new Error('Unexpected PDU');
       }
     }
   }
+
+  /**
+   * Activates keepalive handling (using set_keepalive_interval) and waits for
+   * at least one keepalive packet to arrive. If no keepalive message is received,
+   * the connection will be closed and the returned promise will reject.
+   * @param {number} interval
+   *   Keepalive interval in seconds.
+   */
+  wait_for_keepalive(interval) {
+    return new Promise((resolve, reject) => {
+      const subscriptions = [];
+
+      const cleanup = () => {
+        subscriptions.forEach((cb) => cb());
+        subscriptions.length = 0;
+      };
+      subscriptions.push(
+        this.subscribe('error', (error) => {
+          reject(error);
+          cleanup();
+        }),
+        this.subscribe('close', () => {
+          reject(new CloseError());
+          cleanup();
+        }),
+        this.subscribe('keepalive', () => {
+          resolve();
+          cleanup();
+        })
+      );
+      this.set_keepalive_interval(interval);
+    });
+  }
 }

package/src/events.d.ts

@@ -24,8 +24,19 @@ export class Events {
    */
   removeEventListener(name: string, cb: (...args) => void): void;
 
+  /**
+   * Unsubscribe from an event.
+   */
+  off(name: string, cb: (...args) => void): void;
+
   /**
    * Removes all event listeners.
    */
   removeAllEventListeners(): void;
+
+  /**
+   * Subscribe to an event. Returns a cleanup function which can be called to
+   * unsubscribe.
+   */
+  subscribe(name: string, cb: (...args) => void): () => void;
 }

package/src/events.js

@@ -34,6 +34,10 @@ export class Events {
    * @param {Function} cb - Callback function.
    */
   on(name, cb) {
+    if (typeof name !== 'string')
+      throw new TypeError('Event name must be a string.');
+    if (typeof cb !== 'function')
+      throw new TypeError('Event handler must be a function.');
     let handlers = this.event_handlers.get(name);
 
     if (!handlers) {
@@ -63,10 +67,34 @@ export class Events {
     handlers.delete(cb);
   }
 
+  /**
+   * Removes an event handler.
+   *
+   * @param {strign} name
+   * @param {Function} cb
+   */
+  off(name, cb) {
+    this.removeEventListener(name, cb);
+  }
+
   /**
    * Removes all event listeners.
    */
   removeAllEventListeners() {
     this.event_handlers.clear();
   }
+
+  /**
+   *
+   * @param {string} name
+   * @param {Function} cb
+   */
+  subscribe(name, cb) {
+    this.on(name, cb);
+    return () => {
+      if (name === undefined) return;
+      this.off(name, cb);
+      name = undefined;
+    };
+  }
 }