aes70 2.0.17 → 2.0.19

package/Changelog

@@ -2,6 +2,104 @@
 
 All notable changes and version updates will be documented in this file.
 
+## [2.0.19] - 2026-03-13
+
+- Remove ws dependency. WebSocket connections can use a compatible
+  constructor passed to WebSocketConnection.connect() when needed.
+
+- ClientConnection: Do not log unsubscribe errors when the connection
+  has been closed (CloseError).
+
+- TypeScript: Add name property to error class declarations.
+
+## [2.0.18] - 2026-03-11
+
+- ClientConnection: Add command duration for UDP. Set expected duration
+  on the last command when the device needs time to process.
+
+- Connection: Make set_keepalive_interval idempotent when called
+  multiple times with the same interval.
+
+- printDevice: Add --progress.
+
+- fetchDeviceContent: Handle BigInt and OcaStatus.BadMethod.
+
+- AbstractUdpConnection: Fix retry logic.
+
+## [2.0.17] - 2025-12-02
+
+- Connection: Do not send keepalive after close.
+
+- fetchDeviceContent: Handle BigInt data in JSON output.
+
+- Refactor UDP command retry handling; batch commands and avoid spurious
+  timeouts with large write buffers.
+
+## [2.0.15] - 2025-11-26
+
+- Property: Fix and test alias lookup for renamed properties (e.g. 2023).
+
+- Refactor UDP support: connection attempt can be aborted with AbortSignal;
+  DNS lookup configurable for IPv4 or IPv6.
+
+- Events: Do not throw from removeEventHandler (fixes cleanup with
+  removeAllEventHandlers).
+
+- OCP1/OcaInterval: Fix template class decoder.
+
+## [2.0.9] - 2025-11-25
+
+- AbstractUdpConnection: Close socket on failure when device does not
+  respond with keepalive in time.
+
+## [2.0.8] - 2025-11-24
+
+- RemoteDevice: Fix EV2 detection when implementations return status
+  codes other than NotImplemented for new EV2 methods.
+
+- wait_for_keepalive: Handle error in unsubscribe.
+
+## [2.0.7] - 2025-11-18
+
+- OcaInterval: Fix OCP.1 encoder definition.
+
+## [2.0.6] - 2025-11-12
+
+- OcaInterval: Fix duplicate import.
+
+## [2.0.5] - 2025-11-12
+
+- TypeScript: Use explicit import paths for moduleResolution=nodenext.
+
+- Remove deprecated types from AES70-2018.
+
+## [2.0.4] - 2025-10-24
+
+- ClientConnection: Add wait_for_keepalive to wait for a single keepalive
+  from the device.
+
+- Connection: Warn when keepalive interval is large (common ms vs seconds
+  mistake).
+
+## [2.0.3] - 2025-10-09
+
+- Fix missing inout parameters in generated OCC model.
+
+## [2.0.2] - 2025-10-07
+
+- NotificationError: Fix payload parsing.
+
+- BaseEvent: Fix error handling.
+
+- PropertySync: Implement aliases so properties are available by alias.
+
+## [2.0.1] - 2025-10-07
+
+- PropertySync: Use observeProperty.
+
+- Introduce CloseError and TimeoutError classes; emit them on close and
+  timeout. Suppress unhandled close error warning.
+
 ## [2.0.0] - 2025-10-07
 
 - Updates to AES70-2024
@@ -13,7 +111,7 @@ All notable changes and version updates will be documented in this file.
 
 ## [1.6.1] - 2025-05-06
 
-- TCPConnection.connect: Add connecSignal to abort
+- TCPConnection.connect: Add connectSignal to abort
   connection attempts.
 
 - Encode arguments earlier. This means that when calling

package/README.md

@@ -96,12 +96,23 @@ NodeJS both TCP and UDP are available in addition to that.
             port: 65000,
         });
 
-In a web browser using a WebSocket this looks similar.
+In a web browser using a WebSocket this looks similar (the global
+`WebSocket` is used automatically):
 
         const connection = await OCA.WebSocketConnection.connect({
           url: 'ws://example.org',
         });
 
+On Node.js, WebSocket support requires passing the WebSocket constructor
+as the second argument to `connect()`, since there is no built-in
+WebSocket. For example, install the `ws` package and use:
+
+        import { WebSocket } from 'ws';
+        const connection = await WebSocketConnection.connect(
+          { url: 'ws://example.org' },
+          WebSocket
+        );
+
 The next step is to discover what kind of objects the device has. This can be
 done using the method `RemoteDevice.get_device_tree()` method.
 
@@ -178,7 +189,7 @@ connection.on('receive', (pdu) => {
         pendingCommand.name,
         pendingCommand.get_arguments(),
         '->',
-        Types.OcaStatus.getName(pdu.status_code)
+        Types.OcaStatus.getName(pdu.status_code),
       );
     }
   } else {

package/bin/printDevice.js

@@ -7,19 +7,25 @@ import { UDPConnection } from '../src/controller/udp_connection.js';
 import { fetchDeviceContent } from '../src/controller/fetch_device_content.js';
 
 function badArguments() {
-  console.log('Usage: node print_tree.js [--json] [--udp] <ip> <port>');
+  console.log(
+    'Usage: node print_tree.js [--json] [--udp] [--progress] <ip> <port>'
+  );
   exit(1);
 }
 
 let jsonMode = false;
 let useUdp = false;
 const rest = [];
+let progress = false;
 
 argv.slice(2).forEach((option) => {
   switch (option) {
     case '--json':
       jsonMode = true;
       break;
+    case '--progress':
+      progress = true;
+      break;
     case '-h':
     case '--help':
       badArguments();
@@ -76,8 +82,13 @@ function printTreeJson(content) {
 
 async function printDevice(device) {
   try {
-    const content = await fetchDeviceContent(device);
-
+    const reportProgress = progress
+      ? (finished, total) => {
+          process.stderr.write(`\r${finished} of ${total}`);
+        }
+      : undefined;
+    const content = await fetchDeviceContent(device, reportProgress);
+    if (progress) process.stderr.write(`\ndone.\n`);
     if (jsonMode) {
       printTreeJson(content);
     } else {

package/dist/AES70.es5.js

@@ -1382,6 +1382,8 @@
 
       const t = seconds * 1000;
 
+      if (this.keepalive_interval === t) return;
+
       this.keepalive_interval = t;
 
       // Notify the other side about our new keepalive
@@ -1816,6 +1818,19 @@
       this.name = name;
       this.lastSent = 0;
       this.retries = 0;
+      this.duration = 0;
+    }
+
+    /**
+     * Sets the expected processing time for this command on the device.
+     * This duration is used when scheduling retries.
+     * Only has an effect for UDP connections.
+     *
+     * @param {number} interval
+     *  The interval in milliseconds.
+     */
+    set_duration(interval) {
+      this.duration = interval;
     }
 
     get_arguments() {
@@ -1886,7 +1901,7 @@
       this._scheduledPendingCommands = new Set();
       // All pending commands wich have been sent.
       this._sentPendingCommands = new Set();
-      this._nextCommandHandle = 0;
+      this._lastCommandHandle = 0;
       this._subscribers = new Map();
       this._sendCommandsTimer = new Timer(
         () => {
@@ -1934,7 +1949,7 @@
 
       const e = new CloseError(error);
       pendingCommands.forEach((pendingCommand, id) => {
-        pendingCommand.handleError(structuredClone(e));
+        pendingCommand.handleError(e);
       });
 
       subscribers.forEach((cb) => {
@@ -1970,8 +1985,8 @@
       }
 
       do {
-        handle = this._nextCommandHandle;
-        this._nextCommandHandle = (handle + 1) | 0;
+        handle = this._lastCommandHandle;
+        this._lastCommandHandle = (handle + 1) | 0;
       } while (pendingCommands.has(handle));
 
       return handle;
@@ -1993,6 +2008,10 @@
       }
     }
 
+    get_last_pending_command() {
+      return this._pendingCommands.get(this._lastCommandHandle);
+    }
+
     send_command(command, returnTypes, callback, stack, name) {
       const executor = (resolve, reject) => {
         const handle = this._getNextCommandHandle();
@@ -28710,7 +28729,8 @@
         } else if (S.version > 0 && !S.has_subscribers()) {
           dropSubscribers();
           this._doUnsubscribe(S, event).catch((error) => {
-            console.error('Unsubscribe failed: ', error);
+            if (error.name === 'aes70.CloseError') return;
+            console.error('Unsubscribe failed: %o', error);
           });
         }
       };
@@ -29173,6 +29193,13 @@
 
         _sentPendingCommands.delete(pendingCommand);
 
+        if (pendingCommand.lastSent + pendingCommand.duration > retryTime) {
+          // This command is expected to take longer. Simply push it back to the queue,
+          // we will pick it up later.
+          _sentPendingCommands.add(pendingCommand);
+          continue;
+        }
+
         if (pendingCommand.retries >= this.retry_count) {
           failed.push(pendingCommand);
         } else {
@@ -29346,9 +29373,9 @@
     if (typeof value === 'object') {
       if (value instanceof Arguments) {
         return {
-          [name]: value.item(0),
-          ['Min' + name]: value.item(1),
-          ['Max' + name]: value.item(2),
+          [name]: formatValue(value.item(0)),
+          ['Min' + name]: formatValue(value.item(1)),
+          ['Max' + name]: formatValue(value.item(2)),
         };
       } else {
         value = formatValue(value);
@@ -29356,7 +29383,7 @@
     }
 
     return {
-      [name]: value,
+      [name]: formatValue(value),
     };
   }
 
@@ -29388,7 +29415,11 @@
 
           Object.assign(info, formatReturnValue(name, currentValue));
         } catch (err) {
-          if (err.status != 8)
+          // 8 - NotImplemented
+          // 11 - BadMethod
+          // Note: Some implementations respond with BadMethod for methods which have been
+          // defined in more recent vrsions of aes70
+          if (err.status != 8 && err.status != 11)
             console.error(
               'Fetching property',
               o.ClassName,
@@ -29416,10 +29447,13 @@
     }
   }
 
-  async function fetchDeviceContentRec(objects) {
+  async function fetchDeviceContentRec(objects, reportProgress) {
     const result = [];
 
     for (let i = 0; i < objects.length; i++) {
+      if (reportProgress) {
+        reportProgress(i, objects.length);
+      }
       const o = objects[i];
       const info = await fetchObjectInfo(o);
 
@@ -29438,7 +29472,7 @@
     return result;
   }
 
-  async function fetchDeviceContent(device) {
+  async function fetchDeviceContent(device, reportProgress) {
     const objects = await device.GetDeviceTree();
     const managers = [
       device.DeviceManager,
@@ -29460,7 +29494,7 @@
       if (await managerExists(manager)) objects.push(manager);
     }
 
-    return await fetchDeviceContentRec(objects);
+    return await fetchDeviceContentRec(objects, reportProgress);
   }
 
   /*
@@ -30670,21 +30704,32 @@
     }
   }
 
+  const globalWebSocket =
+    typeof globalThis !== 'undefined' ? globalThis.WebSocket : undefined;
+
   /**
    * Connection which implements OCP.1 with WebSocket transport.
+   * Works in both browser and Node.js. In the browser the global WebSocket
+   * is used when not passed; on Node.js the WebSocket constructor must be
+   * passed as the second argument (e.g. from the 'ws' package).
    */
   class WebSocketConnection extends WebSocketConnectionBase {
     /**
      * Connect to the given endpoint.
      *
      * @param {object} options
-     * @param {String} options.url
-     *    Endpoint WebSocket url.
-     * @returns {Promise<WebSocketConnection>}
-     *    The connection.
+     * @param {String} options.url - Endpoint WebSocket url.
+     * @param {Function} [WebSocket] - WebSocket constructor. Optional in browser (global WebSocket is used). Required on Node.js (e.g. import WebSocket from 'ws').
+     * @returns {Promise<WebSocketConnection>} - The connection.
      */
-    static connect(options) {
-      return super.connect(WebSocket, options);
+    static connect(options, WebSocket) {
+      const Ctor = WebSocket !== undefined ? WebSocket : globalWebSocket;
+      if (!Ctor) {
+        throw new Error(
+          'WebSocket constructor is required in this environment. Pass the WebSocket class as the second argument (e.g. from the "ws" package on Node.js).'
+        );
+      }
+      return super.connect(Ctor, options);
     }
 
     _now() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aes70",
-  "version": "2.0.17",
+  "version": "2.0.19",
   "description": "A controller library for the AES70 protocol.",
   "type": "module",
   "main": "src/index.js",
@@ -41,9 +41,6 @@
     "url": "https://github.com/DeutscheSoft/AES70.js/issues"
   },
   "homepage": "https://github.com/DeutscheSoft/AES70.js#readme",
-  "optionalDependencies": {
-    "ws": "^5.2.4"
-  },
   "sideEffects": [
     "src/bundle.browser.js",
     "dist/AES70.es5.js"

package/src/close_error.d.ts

@@ -1,4 +1,5 @@
 export declare class CloseError extends Error {
-  error?: Error;
+  readonly error?: Error;
+  readonly name: 'aes70.CloseError';
   constructor(error?: Error);
 }

package/src/connection.js

@@ -219,6 +219,8 @@ export class Connection extends Events {
 
     const t = seconds * 1000;
 
+    if (this.keepalive_interval === t) return;
+
     this.keepalive_interval = t;
 
     // Notify the other side about our new keepalive

package/src/controller/abstract_udp_connection.js

@@ -192,6 +192,13 @@ export class AbstractUDPConnection extends ClientConnection {
 
       _sentPendingCommands.delete(pendingCommand);
 
+      if (pendingCommand.lastSent + pendingCommand.duration > retryTime) {
+        // This command is expected to take longer. Simply push it back to the queue,
+        // we will pick it up later.
+        _sentPendingCommands.add(pendingCommand);
+        continue;
+      }
+
       if (pendingCommand.retries >= this.retry_count) {
         failed.push(pendingCommand);
       } else {

package/src/controller/client_connection.d.ts

@@ -25,7 +25,17 @@ export interface PendingCommand {
    * If available, returns the arguments of this
    * remote method call.
    */
-  get_arguments(): unknwon[] | undefined;
+  get_arguments(): unknown[] | undefined;
+
+  /**
+   * Sets the expected processing time for this command on the device.
+   * This duration is used when scheduling retries.
+   * Only has an effect for UDP connections.
+   *
+   * @param {number} interval
+   *  The interval in milliseconds.
+   */
+  set_duration(interval: number): void;
 }
 
 /**
@@ -42,4 +52,6 @@ export declare class ClientConnection extends Connection {
    *   Keepalive interval in seconds.
    */
   wait_for_keepalive(interval: number): Promise<void>;
+
+  get_last_pending_command(): PendingCommand | undefined;
 }

package/src/controller/client_connection.js

@@ -27,6 +27,19 @@ class PendingCommand {
     this.name = name;
     this.lastSent = 0;
     this.retries = 0;
+    this.duration = 0;
+  }
+
+  /**
+   * Sets the expected processing time for this command on the device.
+   * This duration is used when scheduling retries.
+   * Only has an effect for UDP connections.
+   *
+   * @param {number} interval
+   *  The interval in milliseconds.
+   */
+  set_duration(interval) {
+    this.duration = interval;
   }
 
   get_arguments() {
@@ -97,7 +110,7 @@ export class ClientConnection extends Connection {
     this._scheduledPendingCommands = new Set();
     // All pending commands wich have been sent.
     this._sentPendingCommands = new Set();
-    this._nextCommandHandle = 0;
+    this._lastCommandHandle = 0;
     this._subscribers = new Map();
     this._sendCommandsTimer = new Timer(
       () => {
@@ -145,7 +158,7 @@ export class ClientConnection extends Connection {
 
     const e = new CloseError(error);
     pendingCommands.forEach((pendingCommand, id) => {
-      pendingCommand.handleError(structuredClone(e));
+      pendingCommand.handleError(e);
     });
 
     subscribers.forEach((cb) => {
@@ -181,8 +194,8 @@ export class ClientConnection extends Connection {
     }
 
     do {
-      handle = this._nextCommandHandle;
-      this._nextCommandHandle = (handle + 1) | 0;
+      handle = this._lastCommandHandle;
+      this._lastCommandHandle = (handle + 1) | 0;
     } while (pendingCommands.has(handle));
 
     return handle;
@@ -204,6 +217,10 @@ export class ClientConnection extends Connection {
     }
   }
 
+  get_last_pending_command() {
+    return this._pendingCommands.get(this._lastCommandHandle);
+  }
+
   send_command(command, returnTypes, callback, stack, name) {
     const executor = (resolve, reject) => {
       const handle = this._getNextCommandHandle();

package/src/controller/fetch_device_content.js

@@ -37,9 +37,9 @@ function formatReturnValue(name, value) {
   if (typeof value === 'object') {
     if (value instanceof Arguments) {
       return {
-        [name]: value.item(0),
-        ['Min' + name]: value.item(1),
-        ['Max' + name]: value.item(2),
+        [name]: formatValue(value.item(0)),
+        ['Min' + name]: formatValue(value.item(1)),
+        ['Max' + name]: formatValue(value.item(2)),
       };
     } else {
       value = formatValue(value);
@@ -47,7 +47,7 @@ function formatReturnValue(name, value) {
   }
 
   return {
-    [name]: value,
+    [name]: formatValue(value),
   };
 }
 
@@ -79,7 +79,11 @@ async function fetchObjectInfo(o) {
 
         Object.assign(info, formatReturnValue(name, currentValue));
       } catch (err) {
-        if (err.status != 8)
+        // 8 - NotImplemented
+        // 11 - BadMethod
+        // Note: Some implementations respond with BadMethod for methods which have been
+        // defined in more recent vrsions of aes70
+        if (err.status != 8 && err.status != 11)
           console.error(
             'Fetching property',
             o.ClassName,
@@ -107,10 +111,13 @@ async function managerExists(manager) {
   }
 }
 
-async function fetchDeviceContentRec(objects) {
+async function fetchDeviceContentRec(objects, reportProgress) {
   const result = [];
 
   for (let i = 0; i < objects.length; i++) {
+    if (reportProgress) {
+      reportProgress(i, objects.length);
+    }
     const o = objects[i];
     const info = await fetchObjectInfo(o);
 
@@ -129,7 +136,7 @@ async function fetchDeviceContentRec(objects) {
   return result;
 }
 
-export async function fetchDeviceContent(device) {
+export async function fetchDeviceContent(device, reportProgress) {
   const objects = await device.GetDeviceTree();
   const managers = [
     device.DeviceManager,
@@ -151,5 +158,5 @@ export async function fetchDeviceContent(device) {
     if (await managerExists(manager)) objects.push(manager);
   }
 
-  return await fetchDeviceContentRec(objects);
+  return await fetchDeviceContentRec(objects, reportProgress);
 }

package/src/controller/remote_device.js

@@ -1,4 +1,4 @@
-import { warn, error } from '../log.js';
+import { warn } from '../log.js';
 
 import { Events } from '../events.js';
 
@@ -17,13 +17,13 @@ import { OcaCodingManager } from './ControlClasses/OcaCodingManager.js';
 import { OcaDiagnosticManager } from './ControlClasses/OcaDiagnosticManager.js';
 import { OcaBlock } from './ControlClasses/OcaBlock.js';
 import { RemoteError } from './remote_error.js';
-import { OcaStatus } from '../types/OcaStatus.js';
 import tree_to_rolemap from './tree_to_rolemap.js';
 
 import * as RemoteControlClasses from './ControlClasses.js';
 
 import { OcaManagerDefaultObjectNumbers } from '../types/OcaManagerDefaultObjectNumbers.js';
 import { OcaNotificationDeliveryMode } from '../types/OcaNotificationDeliveryMode.js';
+import { CloseError } from '../close_error.js';
 
 const emptyUint8Array = new Uint8Array(0);
 
@@ -314,7 +314,8 @@ export class RemoteDevice extends Events {
       } else if (S.version > 0 && !S.has_subscribers()) {
         dropSubscribers();
         this._doUnsubscribe(S, event).catch((error) => {
-          console.error('Unsubscribe failed: ', error);
+          if (error.name === 'aes70.CloseError') return;
+          console.error('Unsubscribe failed: %o', error);
         });
       }
     };

package/src/controller/websocket_connection.d.ts

@@ -1,17 +1,20 @@
 import {
   WebSocketConnectionBase,
   IWebSocketConnectionBaseOptions,
+  IWebSocketLike,
+  WebSocketConstructor,
 } from './websocket_connection_base.js';
 
 export type IWebSocketConnectionOptions = IWebSocketConnectionBaseOptions;
+export type { IWebSocketLike, WebSocketConstructor };
 
 export class WebSocketConnection extends WebSocketConnectionBase {
-  constructor(ws: WebSocket, options: WebSocketConnectionOptions);
-  static connectWebSocket(
-    WebSocket: typeof WebSocket,
-    options: WebSocketConnectionOptions
-  ): Promise<WebSocket>;
+  constructor(ws: IWebSocketLike, options: IWebSocketConnectionOptions);
   static connect(
-    options: WebSocketConnectionOptions
+    options: IWebSocketConnectionOptions
+  ): Promise<WebSocketConnection>;
+  static connect(
+    options: IWebSocketConnectionOptions,
+    WebSocket: WebSocketConstructor
   ): Promise<WebSocketConnection>;
 }

package/src/controller/websocket_connection.js

@@ -1,20 +1,31 @@
 import { WebSocketConnectionBase } from './websocket_connection_base.js';
 
+const globalWebSocket =
+  typeof globalThis !== 'undefined' ? globalThis.WebSocket : undefined;
+
 /**
  * Connection which implements OCP.1 with WebSocket transport.
+ * Works in both browser and Node.js. In the browser the global WebSocket
+ * is used when not passed; on Node.js the WebSocket constructor must be
+ * passed as the second argument (e.g. from the 'ws' package).
  */
 export class WebSocketConnection extends WebSocketConnectionBase {
   /**
    * Connect to the given endpoint.
    *
    * @param {object} options
-   * @param {String} options.url
-   *    Endpoint WebSocket url.
-   * @returns {Promise<WebSocketConnection>}
-   *    The connection.
+   * @param {String} options.url - Endpoint WebSocket url.
+   * @param {Function} [WebSocket] - WebSocket constructor. Optional in browser (global WebSocket is used). Required on Node.js (e.g. import WebSocket from 'ws').
+   * @returns {Promise<WebSocketConnection>} - The connection.
    */
-  static connect(options) {
-    return super.connect(WebSocket, options);
+  static connect(options, WebSocket) {
+    const Ctor = WebSocket !== undefined ? WebSocket : globalWebSocket;
+    if (!Ctor) {
+      throw new Error(
+        'WebSocket constructor is required in this environment. Pass the WebSocket class as the second argument (e.g. from the "ws" package on Node.js).'
+      );
+    }
+    return super.connect(Ctor, options);
   }
 
   _now() {

package/src/controller/websocket_connection_base.d.ts

@@ -3,6 +3,27 @@ import {
   ClientConnection,
 } from './client_connection.js';
 
+/**
+ * Minimal WebSocket-like interface supported by both browser WebSocket
+ * and the Node.js 'ws' library. Used for typing connection options and
+ * the optional WebSocket constructor passed to connect().
+ */
+export interface IWebSocketLike {
+  binaryType: string;
+  addEventListener(
+    type: string,
+    listener: (ev: { data?: ArrayBuffer | Buffer; type?: string }) => void
+  ): void;
+  removeEventListener(
+    type: string,
+    listener: (ev: { data?: ArrayBuffer | Buffer; type?: string }) => void
+  ): void;
+  send(data: ArrayBuffer | Buffer | ArrayBufferView): void;
+  close(): void;
+}
+
+export type WebSocketConstructor = new (url: string) => IWebSocketLike;
+
 export interface IWebSocketConnectionBaseOptions
   extends IClientConnectionOptions {
   url: string;
@@ -14,5 +35,6 @@ export interface IWebSocketConnectionBaseOptions
  * Browser.
  */
 export class WebSocketConnectionBase extends ClientConnection {
+  constructor(ws: IWebSocketLike, options: IWebSocketConnectionBaseOptions);
   write(buf: ArrayBuffer): void;
 }

package/src/index.d.ts

@@ -1,4 +1,4 @@
 export * from './index.default.js';
-export * from './controller/websocket_connection_node.js';
+export * from './controller/websocket_connection.js';
 export * from './controller/tcp_connection.js';
 export * from './controller/udp_connection.js';

package/src/index.js

@@ -1,4 +1,4 @@
 export * from './index.default.js';
-export * from './controller/websocket_connection_node.js';
+export * from './controller/websocket_connection.js';
 export * from './controller/tcp_connection.js';
 export * from './controller/udp_connection.js';

package/src/timeout_error.d.ts

@@ -1,3 +1,4 @@
 export declare class TimeoutError extends Error {
+  readonly name: 'aes70.TimeoutError';
   constructor();
 }

package/src/controller/websocket_connection_node.d.ts

@@ -1,18 +0,0 @@
-import {
-  WebSocketConnectionBase,
-  IWebSocketConnectionBaseOptions,
-} from './websocket_connection_base.js';
-import WebSocket from 'ws';
-
-export type IWebSocketConnectionOptions = IWebSocketConnectionBaseOptions;
-
-export class WebSocketConnection extends WebSocketConnectionBase {
-  constructor(ws: WebSocket, options: WebSocketConnectionOptions);
-  static connectWebSocket(
-    WebSocket: typeof WebSocket,
-    options: WebSocketConnectionOptions
-  ): Promise<WebSocket>;
-  static connect(
-    options: WebSocketConnectionOptions
-  ): Promise<WebSocketConnection>;
-}

package/src/controller/websocket_connection_node.js

@@ -1,24 +0,0 @@
-/* eslint-env node */
-
-import WebSocket from 'ws';
-import { performance } from 'perf_hooks';
-import { WebSocketConnectionBase } from './websocket_connection_base.js';
-
-/**
- * Connection which implements OCP.1 with WebSocket transport.
- */
-export class WebSocketConnection extends WebSocketConnectionBase {
-  /**
-   * Connect to the given endpoint.
-   *
-   * @param {String} options.url - Endpoint WebSocket url.
-   * @returns {Promise<WebSocketConnection>} - The connection.
-   */
-  static async connect(options) {
-    return super.connect(WebSocket, options);
-  }
-
-  _now() {
-    return performance.now();
-  }
-}