@fuman/net 0.0.2 → 0.0.4

package/package.json

@@ -1,13 +1,13 @@
 {
     "name": "@fuman/net",
     "type": "module",
-    "version": "0.0.2",
+    "version": "0.0.4",
     "description": "experimental network abstractions",
     "license": "MIT",
     "scripts": {},
     "dependencies": {
-        "@fuman/io": "^0.0.2",
-        "@fuman/utils": "^0.0.1"
+        "@fuman/io": "^0.0.4",
+        "@fuman/utils": "^0.0.4"
     },
     "exports": {
         ".": {

package/reconnection.d.ts

@@ -1,5 +1,5 @@
+import { IClosable } from '@fuman/io';
 import { MaybePromise } from '@fuman/utils';
-import { ConnectFunction, IConnection } from './types.js';
 interface ReconnectionState {
     readonly previousWait: number | null;
     readonly consequentFails: number;
@@ -24,10 +24,10 @@ export type OnErrorAction = 'reconnect' | 'reconnect-now' | 'close';
  * then 1s with linear increase up to 5s (with 1s step)
  */
 export declare const defaultReconnectionStrategy: ReconnectionStrategy;
-export declare class PersistentConnection<ConnectAddress, Connection extends IConnection<unknown>> {
+export declare class PersistentConnection<ConnectAddress, Connection extends IClosable> {
     #private;
     readonly params: {
-        connect: ConnectFunction<ConnectAddress, Connection>;
+        connect: (address: ConnectAddress) => Promise<Connection>;
         strategy?: ReconnectionStrategy;
         /**
          * Function to call once the connection is open
@@ -47,7 +47,7 @@ export declare class PersistentConnection<ConnectAddress, Connection extends ICo
         onError?: (error: Error, connection: Connection | null, state: ReconnectionState) => MaybePromise<OnErrorAction>;
     };
     constructor(params: {
-        connect: ConnectFunction<ConnectAddress, Connection>;
+        connect: (address: ConnectAddress) => Promise<Connection>;
         strategy?: ReconnectionStrategy;
         /**
          * Function to call once the connection is open
@@ -77,6 +77,6 @@ export declare class PersistentConnection<ConnectAddress, Connection extends ICo
      */
     reconnect(force: boolean): void;
     close(): Promise<void>;
-    changeTransport(connect: ConnectFunction<ConnectAddress, Connection>): Promise<void>;
+    changeTransport(connect: (address: ConnectAddress) => Promise<Connection>): Promise<void>;
 }
 export {};

package/types.d.ts

@@ -1,12 +1,18 @@
 import { IClosable, IReadable, IWritable } from '@fuman/io';
 export interface IConnection<Address, LocalAddress = Address> extends IReadable, IWritable, IClosable {
+    /** local address of the connection (if available) */
     readonly localAddress: LocalAddress | null;
+    /** remote address of the connection (if available) */
     readonly remoteAddress: Address | null;
 }
+/** a TCP endpoint */
 export interface TcpEndpoint {
+    /** address of the endpoint */
     readonly address: string;
+    /** port of the endpoint */
     readonly port: number;
 }
+/** common TLS options */
 export interface TlsOptions {
     /**
      * List of CA certificates to use.
@@ -18,22 +24,32 @@ export interface TlsOptions {
     /** Hostname to use for SNI */
     readonly sni?: string;
 }
+/** TLS options for connecting to an endpoint */
 export interface TlsConnectOptions extends TcpEndpoint, TlsOptions {
 }
+/** TLS options for listening on an endpoint */
 export interface TlsListenOptions extends TcpEndpoint, TlsOptions {
     readonly key?: string;
     readonly cert?: string;
     readonly hosts?: Omit<this, 'hosts' | 'address' | 'port'>[];
 }
+/** a TCP connection */
 export interface ITcpConnection extends IConnection<TcpEndpoint> {
+    /** set no-delay flag on the connection */
     setNoDelay: (noDelay: boolean) => void;
+    /** set keep-alive flag on the connection */
     setKeepAlive: (keepAlive: boolean) => void;
 }
+/** a TLS connection */
 export interface ITlsConnection extends ITcpConnection {
+    /** get the ALPN protocol that was negotiated in the handshake */
     getAlpnProtocol: () => string | null;
 }
+/** a listener for connections */
 export interface IListener<Address, Connection extends IConnection<Address> = IConnection<Address>> extends IClosable {
+    /** address of the listener (if available) */
     readonly address: Address | null;
+    /** accept a new connection */
     accept: () => Promise<Connection>;
 }
 export type ListenFunction<Options, Listener extends IListener<unknown>> = (options: Options) => Promise<Listener>;

package/websocket.cjs

@@ -25,10 +25,12 @@ class WebSocketConnectionBase {
       this._cv.notify();
     });
     socket.addEventListener("close", (event) => {
+      if (this._error) return;
       this._error = new WebSocketConnectionClosedError(event.code, event.reason);
       this._cv.notify();
     });
     socket.addEventListener("error", (event) => {
+      if (this._error) return;
       this._error = eventToError(event);
       this._cv.notify();
     });
@@ -44,18 +46,16 @@ class WebSocketConnectionBase {
   close() {
     this.socket?.close();
     this._error = new errors.ConnectionClosedError();
+    this._cv.notify();
   }
   closeWithCode(code, reason) {
     this.socket.close(code, reason);
-    this._error = new errors.ConnectionClosedError();
+    this._error = new WebSocketConnectionClosedError(code, reason ?? "");
+    this._cv.notify();
   }
 }
 class WebSocketConnection extends WebSocketConnectionBase {
-  #buffer;
-  constructor(socket) {
-    super(socket);
-    this.#buffer = io.Bytes.alloc(0);
-  }
+  #buffer = io.Bytes.alloc(0);
   onMessage(event) {
     if (typeof event.data === "string") {
       const buf = this.#buffer.writeSync(utils.utf8.encodedLength(event.data));

package/websocket.d.ts

@@ -20,7 +20,6 @@ declare abstract class WebSocketConnectionBase implements IClosable {
 }
 export declare class WebSocketConnection extends WebSocketConnectionBase implements IConnection<string, never> {
     #private;
-    constructor(socket: WebSocket);
     onMessage(event: MessageEvent): void;
     read(into: Uint8Array): Promise<number>;
     write(bytes: Uint8Array): Promise<void>;

package/websocket.js

@@ -23,10 +23,12 @@ class WebSocketConnectionBase {
       this._cv.notify();
     });
     socket.addEventListener("close", (event) => {
+      if (this._error) return;
       this._error = new WebSocketConnectionClosedError(event.code, event.reason);
       this._cv.notify();
     });
     socket.addEventListener("error", (event) => {
+      if (this._error) return;
       this._error = eventToError(event);
       this._cv.notify();
     });
@@ -42,18 +44,16 @@ class WebSocketConnectionBase {
   close() {
     this.socket?.close();
     this._error = new ConnectionClosedError();
+    this._cv.notify();
   }
   closeWithCode(code, reason) {
     this.socket.close(code, reason);
-    this._error = new ConnectionClosedError();
+    this._error = new WebSocketConnectionClosedError(code, reason ?? "");
+    this._cv.notify();
   }
 }
 class WebSocketConnection extends WebSocketConnectionBase {
-  #buffer;
-  constructor(socket) {
-    super(socket);
-    this.#buffer = Bytes.alloc(0);
-  }
+  #buffer = Bytes.alloc(0);
   onMessage(event) {
     if (typeof event.data === "string") {
       const buf = this.#buffer.writeSync(utf8.encodedLength(event.data));