Update README and improve WebSocket functionality

- Streamlined the library to focus solely on WebSocket utilities, removing any DOM-related code.
- Added support for custom WebSocket implementations via the new WebSocketImpl option.
- Enhanced error handling and logging capabilities.
- Updated usage examples in the README to reflect the latest API changes.
- Documented breaking changes and improvements in the README.

Author: vveerrgg

README.md

@@ -1,12 +1,12 @@
-Nostr Websocket Utils
+# Nostr Websocket Utils
 
 [![npm version](https://img.shields.io/npm/v/nostr-websocket-utils.svg)](https://www.npmjs.com/package/nostr-websocket-utils)
 [![License](https://img.shields.io/npm/l/nostr-websocket-utils.svg)](https://github.com/HumanjavaEnterprises/nostr-websocket-utils/blob/main/LICENSE)
 [![Build Status](https://github.com/HumanjavaEnterprises/nostr-websocket-utils/workflows/CI/badge.svg)](https://github.com/HumanjavaEnterprises/nostr-websocket-utils/actions)
 [![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue.svg)](https://www.typescriptlang.org)
 [![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
 
-A TypeScript library providing WebSocket utilities for Nostr applications, with robust connection handling, automatic reconnection, and channel-based messaging.
+A TypeScript library providing WebSocket utilities for Nostr applications, focusing on robust connection handling, automatic reconnection, and channel-based messaging. This library has been streamlined to remove any DOM-related code, enhancing performance and maintainability.
 
 ## Features
 
@@ -25,12 +25,13 @@ A TypeScript library providing WebSocket utilities for Nostr applications, with
 npm install nostr-websocket-utils
 ```
 
-## Breaking Changes in v0.2.1
+## Breaking Changes in v0.2.2
 
-- Added UUID support for message tracking and correlation
-- Fixed WebSocket mock implementation in tests
-- Improved TypeScript type safety across the codebase
-- Enhanced error handling for WebSocket connections
+- Removed all DOM-related code to focus solely on WebSocket functionality.
+- Added UUID support for message tracking and correlation.
+- Introduced a new `WebSocketImpl` option for custom WebSocket implementations.
+- Improved TypeScript type safety across the codebase.
+- Enhanced error handling for WebSocket connections.
 
 ## Usage
 
@@ -52,79 +53,19 @@ const logger = winston.createLogger({
   transports: [new winston.transports.Console()]
 });
 
-// Initialize WebSocket server with required handlers
-const wss = new NostrWSServer(server, {
-  heartbeatInterval: 30000,
+// Initialize the WebSocket server with custom WebSocket implementation
+const wsServer = new NostrWSServer(server, {
   logger,
   handlers: {
-    // Required message handler
     message: async (ws, message) => {
       logger.info('Received message:', message);
-      
-      // Example: Handle different message types
-      switch (message.type) {
-        case 'subscribe':
-          // Handle subscription
-          break;
-        case 'event':
-          // Broadcast to specific channel
-          wss.broadcastToChannel('my-channel', {
-            type: 'event',
-            data: { content: 'Hello channel!' }
-          });
-          break;
-      }
+      // Handle message
     },
-    // Optional error handler
     error: (ws, error) => {
       logger.error('WebSocket error:', error);
     },
-    // Optional close handler
     close: (ws) => {
-      logger.info('Client disconnected');
-    }
-  }
-});
-
-server.listen(3000);
-```
-
-### Server Example with UUID
-
-```typescript
-import express from 'express';
-import { createServer } from 'http';
-import { NostrWSServer } from 'nostr-websocket-utils';
-import winston from 'winston';
-
-const app = express();
-const server = createServer(app);
-
-// Create a logger
-const logger = winston.createLogger({
-  level: 'info',
-  format: winston.format.json(),
-  transports: [new winston.transports.Console()]
-});
-
-// Initialize the WebSocket server with UUID support
-const wsServer = new NostrWSServer({
-  server,
-  logger,
-  messageHandler: async (message, client) => {
-    // message.uuid will contain a unique identifier for the message
-    logger.info(`Received message with UUID: ${message.uuid}`);
-    
-    // Handle the message based on type
-    switch (message.type) {
-      case 'subscribe':
-        // Handle subscription
-        break;
-      case 'event':
-        // Handle event
-        break;
-      default:
-        // Handle unknown message type
+      logger.info('Connection closed');
     }
   }
 });
@@ -138,63 +79,22 @@ server.listen(3000);
 import { NostrWSClient } from 'nostr-websocket-utils';
 import winston from 'winston';
 
-// Create a logger
 const logger = winston.createLogger({
   level: 'info',
   format: winston.format.json(),
   transports: [new winston.transports.Console()]
 });
 
-const client = new NostrWSClient('wss://your-server.com', {
-  heartbeatInterval: 30000,
-  reconnectInterval: 5000,
-  maxReconnectAttempts: 5,
-  logger,
-  handlers: {
-    message: async (ws, message) => {
-      logger.info('Received message:', message);
-      // Handle message
-    },
-    error: (ws, error) => {
-      logger.error('Connection error:', error);
-    },
-    close: (ws) => {
-      logger.info('Connection closed');
-    }
-  }
-});
-
-// Listen to events
-client.on('connect', () => {
-  logger.info('Connected!');
-  client.subscribe('my-channel');
-});
-
-client.connect();
-```
-
-### Client Example with UUID
-
-```typescript
-import { NostrWSClient } from 'nostr-websocket-utils';
-
 const client = new NostrWSClient('ws://localhost:3000', {
-  logger: console
+  logger,
+  WebSocketImpl: CustomWebSocketImplementation // Optional custom WebSocket implementation
 });
 
 client.on('message', (message) => {
-  // Access the UUID of the received message
-  console.log(`Received message with UUID: ${message.uuid}`);
+  console.log('Received message:', message);
 });
 
-// Connect to the server
 client.connect();
-
-// Send a message (UUID will be automatically generated)
-client.send({
-  type: 'event',
-  data: { content: 'Hello, World!' }
-});
 ```
 
 ## Interface Reference
@@ -220,6 +120,8 @@ interface NostrWSOptions {
     // Optional close handler
     close?: (ws: WebSocket) => void;
   };
+  // Optional custom WebSocket implementation
+  WebSocketImpl?: WebSocketImpl;
 }
 ```
 

package-lock.json

@@ -43,7 +43,7 @@
     "nostr-tools": "^2.1.4"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.11",
+    "@types/jest": "^29.5.14",
     "@types/node": "^20.11.0",
     "@types/ws": "^8.5.10",
     "@typescript-eslint/eslint-plugin": "^6.18.1",

package.json

@@ -12,7 +12,7 @@ const extendedMockWebSocket = {
   OPEN: 1,
   CLOSING: 2,
   CLOSED: 3,
-  on(event: string, listener: (...args: unknown[]) => void) {
+  on(_event: string, _listener: (...args: unknown[]) => void) {
     return this;
   },
   send: jest.fn(),
@@ -22,13 +22,13 @@ const extendedMockWebSocket = {
   terminate: jest.fn(),
   removeAllListeners: jest.fn(),
   removeListener: jest.fn(),
-  addEventListener: jest.fn(),
-  removeEventListener: jest.fn(),
-  emit: jest.fn(),
-  addListener: jest.fn(),
-  once: jest.fn(),
-  prependListener: jest.fn(),
-  prependOnceListener: jest.fn(),
+  addEventListener: jest.fn((_event: string, _listener: (..._args: unknown[]) => void) => {}),
+  removeEventListener: jest.fn((_event: string, _listener: (..._args: unknown[]) => void) => {}),
+  emit: jest.fn((_event: string, ..._args: unknown[]) => {}),
+  addListener: jest.fn((_event: string, _listener: (..._args: unknown[]) => void) => {}),
+  once: jest.fn((_event: string, _listener: (..._args: unknown[]) => void) => {}),
+  prependListener: jest.fn((_event: string, _listener: (..._args: unknown[]) => void) => {}),
+  prependOnceListener: jest.fn((_event: string, _listener: (..._args: unknown[]) => void) => {}),
   eventNames: jest.fn(),
   listenerCount: jest.fn(),
   // Additional methods for extended behavior