aes70 1.6.0 → 1.6.2

package/src/controller/make_control_class.js

@@ -52,11 +52,11 @@ function createPropertySync(control_class) {
   return constructor;
 }
 
-// method = [ name, level, index, argumentTypes, returnTypes ]
+// method = [ name, level, index, argumentTypes, returnTypes, aliases ]
 function implement_method(cls, method) {
   if (!method || !method.length) return;
 
-  const [name, level, index, argumentTypes, returnTypes] = method;
+  const [name, level, index, argumentTypes, returnTypes, aliases] = method;
 
   cls.prototype[name] = function (...args) {
     const argumentCount = argumentTypes.length;
@@ -88,6 +88,14 @@ function implement_method(cls, method) {
     );
     return this.device.send_command(cmd, returnTypes, callback);
   };
+
+  if (aliases) {
+    aliases.forEach((alias) => {
+      cls.prototype[alias] = function (...args) {
+        return this[name](...args);
+      };
+    });
+  }
 }
 
 // event = [ name, level, index, argumentTypes ]
@@ -110,13 +118,19 @@ function implement_event(cls, event) {
   });
 }
 
+function property_event_name(propertyName) {
+  return 'On' + propertyName + 'Changed';
+}
+
 function implement_property_event(cls, property) {
   if (property.static) return;
   if (property.name === 'ObjectNumber') return;
 
-  Object.defineProperty(cls.prototype, 'On' + property.name + 'Changed', {
+  const event_name = property_event_name(property.name);
+
+  Object.defineProperty(cls.prototype, event_name, {
     get: function () {
-      const ev_name = '_On' + property.name + 'Changed';
+      const ev_name = '_' + event_name;
       const event = this[ev_name];
 
       if (event) return event;
@@ -128,6 +142,18 @@ function implement_property_event(cls, property) {
       ));
     },
   });
+
+  if (property.aliases) {
+    property.aliases.forEach((alias) => {
+      const ev_name = property_event_name(alias);
+      if (cls.prototype[ev_name]) return;
+      Object.defineProperty(cls.prototype, ev_name, {
+        get: function () {
+          return this[event_name];
+        },
+      });
+    });
+  }
 }
 
 function make_property(o) {

package/src/controller/object_base.d.ts

@@ -0,0 +1,34 @@
+import { RemoteDevice } from './remote_device';
+import { IOcaPropertyID, OcaPropertyID } from '../types/OcaPropertyID';
+
+export class ObjectBase {
+  readonly device: RemoteDevice;
+  readonly ono: number;
+
+  constructor(ObjectNumber: number, device: RemoteDevice);
+
+  /**
+   * Returns the object number.
+   */
+  get ObjectNumber(): number;
+
+  /**
+   * Returns the class version of this implementation.
+   */
+  get ClassVersion(): number;
+
+  /**
+   * Returns the class id of this implementation.
+   */
+  get ClassID(): string;
+
+  /**
+   * Returns the name of this class.
+   */
+  get ClassName(): string;
+
+  GetPropertyName(id: IOcaPropertyID): string | undefined;
+  GetPropertyID(name: string): OcaPropertyID;
+
+  Dispose(): void;
+}

package/src/controller/tcp_connection.d.ts

@@ -2,11 +2,15 @@ import {
   ClientConnection,
   IClientConnectionOptions,
 } from './client_connection.js';
-import { Socket, TcpSocketConnectOpts } from 'net';
+import { Socket, NetConnectOpts } from 'node:net';
 
-export interface ITCPConnectionOptions
-  extends IClientConnectionOptions,
-    TcpSocketConnectOpts {}
+export type ITCPConnectionOptions = IClientConnectionOptions &
+  NetConnectOpts & {
+    /**
+     * This AbortSignal can be used to abort a connection attempt.
+     */
+    connectSignal?: AbortSignal;
+  };
 
 /**
  * :class:`ClientConnection` subclass which implements OCP.1 with TCP

package/src/controller/tcp_connection.js

@@ -1,6 +1,6 @@
 /* eslint-env node */
 
-import { Socket } from 'net';
+import { createConnection } from 'net';
 import { Buffer } from 'buffer';
 import { performance } from 'perf_hooks';
 
@@ -41,28 +41,45 @@ export class TCPConnection extends ClientConnection {
 
   /**
    * Connect to the given endpoint.
-   *
+   * @param {net.NetConnectOpts} options
    * @param {String} options.host
    *    Hostname or ip address.
    * @param {number} options.port
    *    Port number.
+   * @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<TCPConnection>}
    *    The connection.
    */
   static connect(options) {
     return new Promise((resolve, reject) => {
-      const socket = new Socket();
+      const connectSignal = options.connectSignal;
+      if (connectSignal) connectSignal.throwIfAborted();
+      const socket = new createConnection(options);
       const onerror = function (ev) {
         reject(ev);
+        cleanup();
       };
+      const onabort = function (ev) {
+        const err = connectSignal.reason;
+        reject(err);
+        socket.destroy(err);
+      };
+      const cleanup = function () {
+        socket.removeListener('error', onerror);
+        socket.removeListener('timeout', onerror);
+        if (connectSignal) connectSignal.removeEventListener('abort', onabort);
+      };
+
+      if (connectSignal) connectSignal.addEventListener('abort', onabort);
       socket.on('error', onerror);
       socket.on('timeout', onerror);
       socket.on('connect', () => {
-        socket.removeListener('error', onerror);
-        socket.removeListener('timeout', onerror);
         resolve(new this(socket, options));
+        cleanup();
       });
-      socket.connect(options);
     });
   }