jmri-client 4.2.0-beta.2 → 5.0.0

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

@@ -1,384 +0,0 @@
-/**
- * Core WebSocket client for JMRI communication
- */
-import { EventEmitter } from 'eventemitter3';
-import { createWebSocketAdapter } from './websocket-adapter.js';
-import { ConnectionState } from '../types/events.js';
-import { MessageIdGenerator } from '../utils/message-id.js';
-import { MessageQueue } from './message-queue.js';
-import { ConnectionStateManager } from './connection-state-manager.js';
-import { HeartbeatManager } from './heartbeat-manager.js';
-import { ReconnectionManager } from './reconnection-manager.js';
-import { MockResponseManager } from '../mocks/index.js';
-/**
- * Core WebSocket client
- */
-export class WebSocketClient extends 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 MessageIdGenerator();
-        this.messageQueue = new MessageQueue(options.messageQueueSize);
-        this.stateManager = new ConnectionStateManager();
-        this.heartbeatManager = new HeartbeatManager(options.heartbeat);
-        this.reconnectionManager = new ReconnectionManager(options.reconnection);
-        // Initialize mock manager if mock mode is enabled
-        if (options.mock.enabled) {
-            this.mockManager = new 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(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 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(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(ConnectionState.DISCONNECTED);
-                        reject(error);
-                    }
-                });
-            }
-            catch (error) {
-                this.stateManager.transition(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(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(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(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(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));
-    }
-}

package/dist/esm/managers/index.js

@@ -1,9 +0,0 @@
-/**
- * Manager exports
- */
-export * from './power-manager.js';
-export * from './roster-manager.js';
-export * from './throttle-manager.js';
-export * from './turnout-manager.js';
-export * from './light-manager.js';
-export * from './system-connections-manager.js';

package/dist/esm/managers/light-manager.js

@@ -1,107 +0,0 @@
-/**
- * Light manager
- */
-import { EventEmitter } from 'eventemitter3';
-import { LightState } from '../types/jmri-messages.js';
-/**
- * Manages JMRI light state
- */
-export class LightManager extends EventEmitter {
-    constructor(client) {
-        super();
-        this.lights = new Map();
-        this.client = client;
-        this.client.on('update', (message) => {
-            if (message.type === 'light') {
-                this.handleLightUpdate(message);
-            }
-        });
-    }
-    /**
-     * Get the current state of a light.
-     * Also registers a server-side listener so subsequent changes are pushed.
-     */
-    async getLight(name) {
-        const message = {
-            type: 'light',
-            data: { name }
-        };
-        const response = await this.client.request(message);
-        const state = response.data?.state ?? LightState.UNKNOWN;
-        this.lights.set(name, state);
-        return state;
-    }
-    /**
-     * Set a light to the given state
-     */
-    async setLight(name, state) {
-        const message = {
-            type: 'light',
-            method: 'post',
-            data: { name, state }
-        };
-        await this.client.request(message);
-        const oldState = this.lights.get(name);
-        this.lights.set(name, state);
-        if (oldState !== state) {
-            this.emit('light:changed', name, state);
-        }
-    }
-    /**
-     * Turn a light on
-     */
-    async turnOnLight(name) {
-        return this.setLight(name, LightState.ON);
-    }
-    /**
-     * Turn a light off
-     */
-    async turnOffLight(name) {
-        return this.setLight(name, LightState.OFF);
-    }
-    /**
-     * List all lights known to JMRI
-     */
-    async listLights() {
-        const message = {
-            type: 'light',
-            method: 'list'
-        };
-        const response = await this.client.request(message);
-        const entries = Array.isArray(response?.data)
-            ? response.data.map((r) => r.data ?? r)
-            : [];
-        for (const entry of entries) {
-            if (entry.name && entry.state !== undefined) {
-                this.lights.set(entry.name, entry.state);
-            }
-        }
-        return entries;
-    }
-    /**
-     * Get cached light state without a network request
-     */
-    getLightState(name) {
-        return this.lights.get(name);
-    }
-    /**
-     * Get all cached light states
-     */
-    getCachedLights() {
-        return new Map(this.lights);
-    }
-    /**
-     * Handle unsolicited light state updates from JMRI
-     */
-    handleLightUpdate(message) {
-        const name = message.data?.name;
-        const state = message.data?.state;
-        if (!name || state === undefined)
-            return;
-        const oldState = this.lights.get(name);
-        this.lights.set(name, state);
-        if (oldState !== state) {
-            this.emit('light:changed', name, state);
-        }
-    }
-}

package/dist/esm/managers/power-manager.js

@@ -1,86 +0,0 @@
-/**
- * Power control manager
- */
-import { EventEmitter } from 'eventemitter3';
-import { PowerState } from '../types/jmri-messages.js';
-/**
- * Manages track power control
- */
-export class PowerManager extends EventEmitter {
-    constructor(client) {
-        super();
-        this.currentState = PowerState.UNKNOWN;
-        this.client = client;
-        // Listen for power updates
-        this.client.on('update', (message) => {
-            if (message.type === 'power') {
-                this.handlePowerUpdate(message);
-            }
-        });
-    }
-    /**
-     * Get current track power state
-     * @param prefix - Optional JMRI connection prefix to target a specific hardware connection
-     */
-    async getPower(prefix) {
-        const message = {
-            type: 'power',
-            ...(prefix !== undefined && { data: { state: PowerState.UNKNOWN, prefix } })
-        };
-        const response = await this.client.request(message);
-        if (response.data?.state !== undefined) {
-            this.currentState = response.data.state;
-        }
-        return this.currentState;
-    }
-    /**
-     * Set track power state
-     * @param state - The desired power state
-     * @param prefix - Optional JMRI connection prefix to target a specific hardware connection
-     */
-    async setPower(state, prefix) {
-        const message = {
-            type: 'power',
-            method: 'post',
-            data: { state, ...(prefix !== undefined && { prefix }) }
-        };
-        await this.client.request(message);
-        const oldState = this.currentState;
-        this.currentState = state;
-        if (oldState !== this.currentState) {
-            this.emit('power:changed', this.currentState);
-        }
-    }
-    /**
-     * Turn track power on
-     * @param prefix - Optional JMRI connection prefix to target a specific hardware connection
-     */
-    async powerOn(prefix) {
-        await this.setPower(PowerState.ON, prefix);
-    }
-    /**
-     * Turn track power off
-     * @param prefix - Optional JMRI connection prefix to target a specific hardware connection
-     */
-    async powerOff(prefix) {
-        await this.setPower(PowerState.OFF, prefix);
-    }
-    /**
-     * Get cached power state (no network request)
-     */
-    getCachedState() {
-        return this.currentState;
-    }
-    /**
-     * Handle unsolicited power updates from JMRI
-     */
-    handlePowerUpdate(message) {
-        if (message.data?.state !== undefined) {
-            const oldState = this.currentState;
-            this.currentState = message.data.state;
-            if (oldState !== this.currentState) {
-                this.emit('power:changed', this.currentState);
-            }
-        }
-    }
-}

package/dist/esm/managers/roster-manager.js

@@ -1,114 +0,0 @@
-/**
- * Roster management
- */
-/**
- * Manages locomotive roster
- */
-export class RosterManager {
-    constructor(client) {
-        this.rosterCache = new Map();
-        this.client = client;
-    }
-    /**
-     * Get all roster entries
-     */
-    async getRoster() {
-        const message = {
-            type: 'roster',
-            method: 'list'
-        };
-        const response = await this.client.request(message);
-        // Parse roster data
-        if (response.data) {
-            this.updateCache(response.data);
-        }
-        return Array.from(this.rosterCache.values());
-    }
-    /**
-     * Get roster entry by name
-     */
-    async getRosterEntryByName(name) {
-        // Check cache first
-        if (this.rosterCache.has(name)) {
-            return this.rosterCache.get(name);
-        }
-        // Refresh roster
-        await this.getRoster();
-        return this.rosterCache.get(name);
-    }
-    /**
-     * Get roster entry by address
-     */
-    async getRosterEntryByAddress(address) {
-        // Ensure roster is loaded
-        if (this.rosterCache.size === 0) {
-            await this.getRoster();
-        }
-        const addressStr = address.toString();
-        for (const wrapper of this.rosterCache.values()) {
-            if (wrapper.data.address === addressStr) {
-                return wrapper;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Search roster by partial name match
-     */
-    async searchRoster(query) {
-        // Ensure roster is loaded
-        if (this.rosterCache.size === 0) {
-            await this.getRoster();
-        }
-        const lowerQuery = query.toLowerCase();
-        const results = [];
-        for (const wrapper of this.rosterCache.values()) {
-            const entry = wrapper.data;
-            if (entry.name.toLowerCase().includes(lowerQuery) ||
-                entry.address.includes(query) ||
-                entry.road?.toLowerCase().includes(lowerQuery) ||
-                entry.number?.includes(query)) {
-                results.push(wrapper);
-            }
-        }
-        return results;
-    }
-    /**
-     * Get cached roster (no network request)
-     */
-    getCachedRoster() {
-        return Array.from(this.rosterCache.values());
-    }
-    /**
-     * Clear roster cache
-     */
-    clearCache() {
-        this.rosterCache.clear();
-    }
-    /**
-     * Update internal cache from roster data
-     */
-    updateCache(rosterData) {
-        this.rosterCache.clear();
-        // Handle array format (real JMRI server) - store wrapped entries
-        if (Array.isArray(rosterData)) {
-            for (const wrapper of rosterData) {
-                if (wrapper.type === 'rosterEntry' && wrapper.data) {
-                    this.rosterCache.set(wrapper.data.name, wrapper);
-                }
-            }
-        }
-        // Handle legacy keyed object format (for backward compatibility) - wrap entries
-        else {
-            let id = 1;
-            for (const [name, entry] of Object.entries(rosterData)) {
-                const wrapper = {
-                    type: 'rosterEntry',
-                    data: entry,
-                    id: id++
-                };
-                this.rosterCache.set(name, wrapper);
-            }
-        }
-    }
-}