jmri-client 4.2.0-beta.2 → 5.1.0

package/dist/esm/core/heartbeat-manager.js

@@ -1,75 +0,0 @@
-/**
- * Heartbeat (ping/pong) management
- */
-import { EventEmitter } from 'eventemitter3';
-/**
- * Manages WebSocket heartbeat via ping/pong
- */
-export class HeartbeatManager extends EventEmitter {
-    constructor(options) {
-        super();
-        this.isRunning = false;
-        this.options = options;
-    }
-    /**
-     * Start heartbeat monitoring
-     * @param sendPing - Callback to send ping message
-     */
-    start(sendPing) {
-        if (!this.options.enabled || this.isRunning) {
-            return;
-        }
-        this.isRunning = true;
-        // Send ping at regular intervals
-        this.pingInterval = setInterval(() => {
-            sendPing();
-            this.emit('pingSent');
-            // Start pong timeout
-            this.pongTimeout = setTimeout(() => {
-                this.emit('timeout');
-            }, this.options.timeout);
-        }, this.options.interval);
-    }
-    /**
-     * Stop heartbeat monitoring
-     */
-    stop() {
-        this.isRunning = false;
-        if (this.pingInterval) {
-            clearInterval(this.pingInterval);
-            this.pingInterval = undefined;
-        }
-        if (this.pongTimeout) {
-            clearTimeout(this.pongTimeout);
-            this.pongTimeout = undefined;
-        }
-    }
-    /**
-     * Handle pong received from server
-     */
-    receivedPong() {
-        // Clear pong timeout
-        if (this.pongTimeout) {
-            clearTimeout(this.pongTimeout);
-            this.pongTimeout = undefined;
-        }
-        this.emit('pongReceived');
-    }
-    /**
-     * Check if heartbeat is running
-     */
-    running() {
-        return this.isRunning;
-    }
-    /**
-     * Update heartbeat options
-     */
-    updateOptions(options) {
-        const wasRunning = this.isRunning;
-        if (wasRunning) {
-            this.stop();
-        }
-        this.options = { ...this.options, ...options };
-        // Note: Caller must call start() again if needed
-    }
-}

package/dist/esm/core/index.js

@@ -1,9 +0,0 @@
-/**
- * Core infrastructure exports
- */
-export * from './websocket-client.js';
-export * from './websocket-adapter.js';
-export * from './connection-state-manager.js';
-export * from './reconnection-manager.js';
-export * from './heartbeat-manager.js';
-export * from './message-queue.js';

package/dist/esm/core/message-queue.js

@@ -1,55 +0,0 @@
-/**
- * Message queue for offline message handling
- */
-/**
- * Queue for storing messages when disconnected
- * Messages are sent when connection is restored
- */
-export class MessageQueue {
-    constructor(maxSize = 100) {
-        this.queue = [];
-        this.maxSize = maxSize;
-    }
-    /**
-     * Add message to queue
-     * If queue is full, oldest message is removed
-     */
-    enqueue(message) {
-        if (this.queue.length >= this.maxSize) {
-            this.queue.shift(); // Remove oldest
-        }
-        this.queue.push(message);
-    }
-    /**
-     * Get all queued messages and clear queue
-     */
-    flush() {
-        const messages = [...this.queue];
-        this.queue = [];
-        return messages;
-    }
-    /**
-     * Clear all queued messages without returning them
-     */
-    clear() {
-        this.queue = [];
-    }
-    /**
-     * Get number of queued messages
-     */
-    size() {
-        return this.queue.length;
-    }
-    /**
-     * Check if queue is empty
-     */
-    isEmpty() {
-        return this.queue.length === 0;
-    }
-    /**
-     * Check if queue is full
-     */
-    isFull() {
-        return this.queue.length >= this.maxSize;
-    }
-}

package/dist/esm/core/reconnection-manager.js

@@ -1,93 +0,0 @@
-/**
- * Automatic reconnection management with exponential backoff
- */
-import { EventEmitter } from 'eventemitter3';
-import { calculateBackoffDelay, shouldReconnect } from '../utils/exponential-backoff.js';
-/**
- * Manages automatic reconnection with exponential backoff
- */
-export class ReconnectionManager extends EventEmitter {
-    constructor(options) {
-        super();
-        this.currentAttempt = 0;
-        this.isReconnecting = false;
-        this.options = options;
-    }
-    /**
-     * Start reconnection process
-     * @param reconnect - Callback to attempt reconnection
-     */
-    start(reconnect) {
-        if (!this.options.enabled || this.isReconnecting) {
-            return;
-        }
-        this.isReconnecting = true;
-        this.currentAttempt = 0;
-        this.scheduleNextAttempt(reconnect);
-    }
-    /**
-     * Schedule next reconnection attempt
-     */
-    scheduleNextAttempt(reconnect) {
-        this.currentAttempt++;
-        // Check if should continue trying
-        if (!shouldReconnect(this.currentAttempt, this.options.maxAttempts)) {
-            this.emit('maxAttemptsReached', this.currentAttempt - 1);
-            this.stop();
-            return;
-        }
-        // Calculate delay with backoff
-        const delay = calculateBackoffDelay(this.currentAttempt, this.options);
-        this.emit('attemptScheduled', this.currentAttempt, delay);
-        // Schedule attempt
-        this.reconnectTimeout = setTimeout(async () => {
-            this.emit('attempting', this.currentAttempt);
-            try {
-                await reconnect();
-                // Success - stop reconnection process
-                this.stop();
-                this.emit('success', this.currentAttempt);
-            }
-            catch (error) {
-                // Failure - schedule next attempt
-                this.emit('failed', this.currentAttempt, error);
-                this.scheduleNextAttempt(reconnect);
-            }
-        }, delay);
-    }
-    /**
-     * Stop reconnection process
-     */
-    stop() {
-        this.isReconnecting = false;
-        if (this.reconnectTimeout) {
-            clearTimeout(this.reconnectTimeout);
-            this.reconnectTimeout = undefined;
-        }
-    }
-    /**
-     * Reset attempt counter
-     */
-    reset() {
-        this.stop();
-        this.currentAttempt = 0;
-    }
-    /**
-     * Check if currently reconnecting
-     */
-    reconnecting() {
-        return this.isReconnecting;
-    }
-    /**
-     * Get current attempt number
-     */
-    getAttempt() {
-        return this.currentAttempt;
-    }
-    /**
-     * Update reconnection options
-     */
-    updateOptions(options) {
-        this.options = { ...this.options, ...options };
-    }
-}

package/dist/esm/core/websocket-adapter.js

@@ -1,98 +0,0 @@
-/**
- * WebSocket Adapter
- * Provides a unified interface for WebSocket connections in both Node.js and browser environments
- */
-import { EventEmitter } from 'eventemitter3';
-/**
- * WebSocket ready states
- */
-export var ReadyState;
-(function (ReadyState) {
-    ReadyState[ReadyState["CONNECTING"] = 0] = "CONNECTING";
-    ReadyState[ReadyState["OPEN"] = 1] = "OPEN";
-    ReadyState[ReadyState["CLOSING"] = 2] = "CLOSING";
-    ReadyState[ReadyState["CLOSED"] = 3] = "CLOSED";
-})(ReadyState || (ReadyState = {}));
-/**
- * Create a WebSocket adapter for the current environment
- */
-export async function createWebSocketAdapter(url, protocols) {
-    // Detect environment
-    const isBrowser = typeof window !== 'undefined' && typeof window.WebSocket !== 'undefined';
-    if (isBrowser) {
-        return new BrowserWebSocketAdapter(url, protocols);
-    }
-    else {
-        return await NodeWebSocketAdapter.create(url, protocols);
-    }
-}
-/**
- * Browser WebSocket adapter
- * Wraps native browser WebSocket with EventEmitter interface
- */
-class BrowserWebSocketAdapter extends EventEmitter {
-    constructor(url, protocols) {
-        super();
-        this.ws = new WebSocket(url, protocols);
-        this.ws.onopen = () => {
-            this.emit('open');
-        };
-        this.ws.onmessage = (event) => {
-            this.emit('message', event.data);
-        };
-        this.ws.onerror = () => {
-            this.emit('error', new Error('WebSocket error'));
-        };
-        this.ws.onclose = (event) => {
-            this.emit('close', event.code, event.reason);
-        };
-    }
-    send(data) {
-        this.ws.send(data);
-    }
-    close(code, reason) {
-        this.ws.close(code, reason);
-    }
-    get readyState() {
-        return this.ws.readyState;
-    }
-}
-/**
- * Node.js WebSocket adapter
- * Wraps ws package with consistent interface
- */
-class NodeWebSocketAdapter extends EventEmitter {
-    constructor(ws) {
-        super();
-        this.ws = ws;
-        this.ws.on('open', () => {
-            this.emit('open');
-        });
-        this.ws.on('message', (data) => {
-            // Convert Buffer to string if needed
-            const message = typeof data === 'string' ? data : data.toString();
-            this.emit('message', message);
-        });
-        this.ws.on('error', (error) => {
-            this.emit('error', error);
-        });
-        this.ws.on('close', (code, reason) => {
-            this.emit('close', code, reason);
-        });
-    }
-    static async create(url, protocols) {
-        // Use dynamic import for ESM compatibility
-        const { default: WebSocket } = await import('ws');
-        const ws = new WebSocket(url, protocols);
-        return new NodeWebSocketAdapter(ws);
-    }
-    send(data) {
-        this.ws.send(data);
-    }
-    close(code, reason) {
-        this.ws.close(code, reason);
-    }
-    get readyState() {
-        return this.ws.readyState;
-    }
-}