jmri-client 4.2.0-beta.2 → 5.0.0

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

@@ -1,59 +0,0 @@
-"use strict";
-/**
- * Message queue for offline message handling
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageQueue = void 0;
-/**
- * Queue for storing messages when disconnected
- * Messages are sent when connection is restored
- */
-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;
-    }
-}
-exports.MessageQueue = MessageQueue;

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

@@ -1,97 +0,0 @@
-"use strict";
-/**
- * Automatic reconnection management with exponential backoff
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReconnectionManager = void 0;
-const eventemitter3_1 = require("eventemitter3");
-const exponential_backoff_js_1 = require("../utils/exponential-backoff.js");
-/**
- * Manages automatic reconnection with exponential backoff
- */
-class ReconnectionManager extends eventemitter3_1.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 (!(0, exponential_backoff_js_1.shouldReconnect)(this.currentAttempt, this.options.maxAttempts)) {
-            this.emit('maxAttemptsReached', this.currentAttempt - 1);
-            this.stop();
-            return;
-        }
-        // Calculate delay with backoff
-        const delay = (0, exponential_backoff_js_1.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 };
-    }
-}
-exports.ReconnectionManager = ReconnectionManager;

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

@@ -1,135 +0,0 @@
-"use strict";
-/**
- * WebSocket Adapter
- * Provides a unified interface for WebSocket connections in both Node.js and browser environments
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReadyState = void 0;
-exports.createWebSocketAdapter = createWebSocketAdapter;
-const eventemitter3_1 = require("eventemitter3");
-/**
- * WebSocket ready states
- */
-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 || (exports.ReadyState = ReadyState = {}));
-/**
- * Create a WebSocket adapter for the current environment
- */
-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 eventemitter3_1.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 eventemitter3_1.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 Promise.resolve().then(() => __importStar(require('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;
-    }
-}

package/dist/cjs/core/websocket-client.js

@@ -1,388 +0,0 @@
-"use strict";
-/**
- * Core WebSocket client for JMRI communication
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebSocketClient = void 0;
-const eventemitter3_1 = require("eventemitter3");
-const websocket_adapter_js_1 = require("./websocket-adapter.js");
-const events_js_1 = require("../types/events.js");
-const message_id_js_1 = require("../utils/message-id.js");
-const message_queue_js_1 = require("./message-queue.js");
-const connection_state_manager_js_1 = require("./connection-state-manager.js");
-const heartbeat_manager_js_1 = require("./heartbeat-manager.js");
-const reconnection_manager_js_1 = require("./reconnection-manager.js");
-const index_js_1 = require("../mocks/index.js");
-/**
- * Core WebSocket client
- */
-class WebSocketClient extends eventemitter3_1.EventEmitter {
-    constructor(options) {
-        super();
-        // Request/response tracking
-        this.pendingRequests = new Map();
-        // Connection state
-        this.isManualDisconnect = false;
-        this.options = options;
-        this.url = `${options.protocol}://${options.host}:${options.port}/json/`;
-        // Initialize sub-managers
-        this.messageIdGen = new message_id_js_1.MessageIdGenerator();
-        this.messageQueue = new message_queue_js_1.MessageQueue(options.messageQueueSize);
-        this.stateManager = new connection_state_manager_js_1.ConnectionStateManager();
-        this.heartbeatManager = new heartbeat_manager_js_1.HeartbeatManager(options.heartbeat);
-        this.reconnectionManager = new reconnection_manager_js_1.ReconnectionManager(options.reconnection);
-        // Initialize mock manager if mock mode is enabled
-        if (options.mock.enabled) {
-            this.mockManager = new index_js_1.MockResponseManager({
-                responseDelay: options.mock.responseDelay
-            });
-        }
-        // Wire up state manager events
-        this.stateManager.on('stateChanged', (newState, prevState) => {
-            this.emit('connectionStateChanged', newState, prevState);
-        });
-        // Wire up heartbeat events
-        this.heartbeatManager.on('timeout', () => {
-            this.emit('heartbeat:timeout');
-            this.handleHeartbeatTimeout();
-        });
-        this.heartbeatManager.on('pingSent', () => {
-            this.emit('heartbeat:sent');
-        });
-        // Wire up reconnection events
-        this.reconnectionManager.on('attemptScheduled', (attempt, delay) => {
-            this.emit('reconnecting', attempt, delay);
-        });
-        this.reconnectionManager.on('success', () => {
-            this.emit('reconnected');
-        });
-        this.reconnectionManager.on('maxAttemptsReached', (attempts) => {
-            this.emit('reconnectionFailed', attempts);
-        });
-        this.reconnectionManager.on('debug', (message) => {
-            this.emit('debug', message);
-        });
-    }
-    /**
-     * Connect to JMRI WebSocket server (or mock)
-     */
-    async connect() {
-        if (this.stateManager.isConnected() || this.stateManager.isConnecting()) {
-            return;
-        }
-        this.isManualDisconnect = false;
-        this.stateManager.transition(events_js_1.ConnectionState.CONNECTING);
-        // Mock mode - simulate connection
-        if (this.mockManager) {
-            return this.connectMock();
-        }
-        // Real WebSocket connection
-        return new Promise(async (resolve, reject) => {
-            try {
-                this.ws = await (0, websocket_adapter_js_1.createWebSocketAdapter)(this.url);
-                this.ws.on('open', () => {
-                    this.handleOpen();
-                    resolve();
-                });
-                this.ws.on('message', (data) => {
-                    this.handleMessage(data);
-                });
-                this.ws.on('close', (code, reason) => {
-                    // If close happens during connection attempt, treat as connection failure
-                    if (this.stateManager.isConnecting()) {
-                        // Transition to disconnected state so reconnection can proceed
-                        this.stateManager.transition(events_js_1.ConnectionState.DISCONNECTED);
-                        const error = new Error(`WebSocket connection failed (code: ${code}${reason ? ', reason: ' + reason : ''})`);
-                        this.emit('error', error);
-                        reject(error);
-                        // Still need to handle close to trigger reconnection
-                        this.handleClose(code, reason);
-                    }
-                    else {
-                        this.handleClose(code, reason);
-                    }
-                });
-                this.ws.on('error', (error) => {
-                    this.emit('error', error);
-                    if (this.stateManager.isConnecting()) {
-                        this.stateManager.transition(events_js_1.ConnectionState.DISCONNECTED);
-                        reject(error);
-                    }
-                });
-            }
-            catch (error) {
-                this.stateManager.transition(events_js_1.ConnectionState.DISCONNECTED);
-                reject(error);
-            }
-        });
-    }
-    /**
-     * Simulate connection in mock mode
-     */
-    async connectMock() {
-        // Simulate connection delay
-        await this.delay(10);
-        // Transition to connected state
-        this.handleOpen();
-        // Send hello message in mock mode
-        const helloResponse = await this.mockManager.getMockResponse({ type: 'hello' });
-        if (helloResponse) {
-            this.processMessage(helloResponse);
-        }
-    }
-    /**
-     * Disconnect from JMRI WebSocket server
-     */
-    async disconnect() {
-        // Already disconnected, nothing to do
-        if (this.stateManager.isDisconnected()) {
-            return;
-        }
-        this.isManualDisconnect = true;
-        this.reconnectionManager.stop();
-        this.heartbeatManager.stop();
-        // Send goodbye message
-        if (this.stateManager.isConnected()) {
-            try {
-                await this.sendGoodbye();
-            }
-            catch (error) {
-                // Ignore errors during goodbye
-            }
-        }
-        // Close WebSocket
-        if (this.ws) {
-            this.ws.close();
-            this.ws = undefined;
-        }
-        // Reject all pending requests
-        this.rejectAllPendingRequests(new Error('Client disconnected'));
-        if (!this.stateManager.isDisconnected()) {
-            this.stateManager.transition(events_js_1.ConnectionState.DISCONNECTED);
-        }
-    }
-    /**
-     * Send message to JMRI (or mock)
-     */
-    send(message) {
-        if (!this.stateManager.isConnected()) {
-            // Queue message for later
-            this.messageQueue.enqueue(message);
-            return;
-        }
-        // Mock mode - send doesn't need to do anything
-        // Responses are generated in request()
-        if (this.mockManager) {
-            this.emit('message:sent', message);
-            return;
-        }
-        if (!this.ws) {
-            throw new Error('WebSocket not initialized');
-        }
-        const json = JSON.stringify(message);
-        this.ws.send(json);
-        this.emit('message:sent', message);
-    }
-    /**
-     * Send request and wait for response (or get mock response)
-     */
-    async request(message, timeout) {
-        // Mock mode - get response from mock manager
-        if (this.mockManager) {
-            const response = await this.mockManager.getMockResponse(message);
-            this.emit('message:sent', message);
-            if (response) {
-                this.processMessage(response);
-            }
-            return response;
-        }
-        // Real mode - send request and wait for response
-        // Assign message ID
-        const id = this.messageIdGen.next();
-        message.id = id;
-        return new Promise((resolve, reject) => {
-            // Set up timeout
-            const timeoutMs = timeout || this.options.requestTimeout;
-            const timeoutHandle = setTimeout(() => {
-                this.pendingRequests.delete(id);
-                reject(new Error(`Request timeout after ${timeoutMs}ms`));
-            }, timeoutMs);
-            // Track pending request with metadata for matching responses without IDs
-            const pendingRequest = {
-                resolve,
-                reject,
-                timeout: timeoutHandle,
-                messageType: message.type
-            };
-            // For throttle requests, store the throttle name for matching
-            if (message.type === 'throttle' && message.data && 'name' in message.data) {
-                pendingRequest.matchKey = message.data.name;
-            }
-            this.pendingRequests.set(id, pendingRequest);
-            // Send message
-            try {
-                this.send(message);
-            }
-            catch (error) {
-                this.pendingRequests.delete(id);
-                clearTimeout(timeoutHandle);
-                reject(error);
-            }
-        });
-    }
-    /**
-     * Get current connection state
-     */
-    getState() {
-        return this.stateManager.getState();
-    }
-    /**
-     * Check if connected
-     */
-    isConnected() {
-        return this.stateManager.isConnected();
-    }
-    /**
-     * Handle WebSocket open event
-     */
-    handleOpen() {
-        this.stateManager.transition(events_js_1.ConnectionState.CONNECTED);
-        this.emit('connected');
-        // Start heartbeat
-        if (this.options.heartbeat.enabled) {
-            this.heartbeatManager.start(() => this.sendPing());
-        }
-        // Flush queued messages
-        const queuedMessages = this.messageQueue.flush();
-        for (const message of queuedMessages) {
-            this.send(message);
-        }
-    }
-    /**
-     * Handle WebSocket message event
-     */
-    handleMessage(data) {
-        try {
-            const message = JSON.parse(data);
-            this.processMessage(message);
-        }
-        catch (error) {
-            this.emit('error', new Error(`Failed to parse message: ${error}`));
-        }
-    }
-    /**
-     * Process a parsed message (called by both real and mock mode)
-     */
-    processMessage(message) {
-        this.emit('message:received', message);
-        // Handle pong
-        if (message.type === 'pong') {
-            this.heartbeatManager.receivedPong();
-            return;
-        }
-        // Handle hello
-        if (message.type === 'hello') {
-            this.emit('hello', message.data);
-            return;
-        }
-        // Handle response to request
-        if (message.id !== undefined) {
-            const pending = this.pendingRequests.get(message.id);
-            if (pending) {
-                clearTimeout(pending.timeout);
-                this.pendingRequests.delete(message.id);
-                pending.resolve(message);
-                return;
-            }
-        }
-        // Handle responses without ID (like throttle responses from JMRI)
-        // Match by message type and data
-        if (message.id === undefined) {
-            for (const [id, pending] of this.pendingRequests.entries()) {
-                // Match by type
-                if (pending.messageType === message.type) {
-                    // For throttle messages, also match by throttle name
-                    if (message.type === 'throttle' && pending.matchKey) {
-                        const throttleName = message.data?.throttle || message.data?.name;
-                        if (throttleName === pending.matchKey) {
-                            clearTimeout(pending.timeout);
-                            this.pendingRequests.delete(id);
-                            pending.resolve(message);
-                            return;
-                        }
-                    }
-                    else {
-                        // For other message types, just match by type
-                        clearTimeout(pending.timeout);
-                        this.pendingRequests.delete(id);
-                        pending.resolve(message);
-                        return;
-                    }
-                }
-            }
-        }
-        // Handle unsolicited updates (auto-subscriptions)
-        this.emit('update', message);
-    }
-    /**
-     * Handle WebSocket close event
-     */
-    handleClose(code, reason) {
-        this.heartbeatManager.stop();
-        const wasConnected = this.stateManager.isConnected();
-        const isReconnecting = this.reconnectionManager.reconnecting();
-        if (this.stateManager.isConnected() || this.stateManager.isConnecting()) {
-            this.stateManager.transition(events_js_1.ConnectionState.DISCONNECTED);
-        }
-        this.emit('disconnected', reason || `Connection closed (code: ${code})`);
-        // Reject all pending requests
-        this.rejectAllPendingRequests(new Error('Connection closed'));
-        // Attempt reconnection if not manual disconnect
-        // Continue reconnecting if we were connected OR reconnection manager is already active
-        if (!this.isManualDisconnect && (wasConnected || isReconnecting) && this.options.reconnection.enabled) {
-            this.stateManager.forceState(events_js_1.ConnectionState.RECONNECTING);
-            this.reconnectionManager.start(() => this.connect());
-        }
-    }
-    /**
-     * Handle heartbeat timeout
-     */
-    handleHeartbeatTimeout() {
-        // Connection appears dead, force reconnect
-        if (this.ws) {
-            this.ws.close();
-        }
-    }
-    /**
-     * Send ping message
-     */
-    sendPing() {
-        this.send({ type: 'ping' });
-    }
-    /**
-     * Send goodbye message
-     */
-    async sendGoodbye() {
-        const message = { type: 'goodbye' };
-        this.send(message);
-        // Give it a moment to send
-        await new Promise(resolve => setTimeout(resolve, 100));
-    }
-    /**
-     * Reject all pending requests
-     */
-    rejectAllPendingRequests(error) {
-        for (const pending of this.pendingRequests.values()) {
-            clearTimeout(pending.timeout);
-            pending.reject(error);
-        }
-        this.pendingRequests.clear();
-    }
-    /**
-     * Delay helper
-     */
-    delay(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-}
-exports.WebSocketClient = WebSocketClient;