jmri-client 4.2.0-beta.2 → 5.1.0

package/dist/esm/mocks/mock-response-manager.js

@@ -1,286 +0,0 @@
-/**
- * Mock Response Manager
- * Generates mock JMRI responses for testing and demo purposes
- */
-import { PowerState, TurnoutState, LightState } from '../types/jmri-messages.js';
-import { mockData } from './mock-data.js';
-/**
- * Manages mock responses for JMRI protocol
- */
-export class MockResponseManager {
-    constructor(options = {}) {
-        this.throttles = new Map();
-        this.lights = new Map([
-            ['IL1', LightState.OFF],
-            ['IL2', LightState.OFF],
-            ['IL3', LightState.ON]
-        ]);
-        this.turnouts = new Map([
-            ['LT1', TurnoutState.CLOSED],
-            ['LT2', TurnoutState.CLOSED],
-            ['LT3', TurnoutState.THROWN]
-        ]);
-        this.responseDelay = options.responseDelay ?? 50;
-        this.powerState = options.initialPowerState ?? PowerState.OFF;
-    }
-    /**
-     * Get a mock response for a given message
-     */
-    async getMockResponse(message) {
-        // Simulate network delay
-        if (this.responseDelay > 0) {
-            await this.delay(this.responseDelay);
-        }
-        // Route to appropriate handler based on message type
-        switch (message.type) {
-            case 'hello':
-                return this.getHelloResponse();
-            case 'power':
-                return this.getPowerResponse(message);
-            case 'roster':
-                return this.getRosterResponse(message);
-            case 'throttle':
-                return this.getThrottleResponse(message);
-            case 'light':
-                return this.getLightResponse(message);
-            case 'turnout':
-                return this.getTurnoutResponse(message);
-            case 'ping':
-                return this.getPingResponse();
-            case 'goodbye':
-                return this.getGoodbyeResponse();
-            default:
-                return null;
-        }
-    }
-    /**
-     * Get hello response (connection establishment)
-     */
-    getHelloResponse() {
-        return JSON.parse(JSON.stringify(mockData.hello));
-    }
-    /**
-     * Get power response
-     */
-    getPowerResponse(message) {
-        // Handle power state change
-        if (message.data?.state !== undefined) {
-            this.powerState = message.data.state;
-            return {
-                type: 'power',
-                data: { state: this.powerState }
-            };
-        }
-        // Return current power state
-        return {
-            type: 'power',
-            data: { state: this.powerState }
-        };
-    }
-    /**
-     * Get roster response
-     */
-    getRosterResponse(message) {
-        if (message.type === 'roster' && message.method === 'list') {
-            return {
-                type: 'roster',
-                data: JSON.parse(JSON.stringify(mockData.roster.list))
-            };
-        }
-        return {
-            type: 'roster',
-            data: []
-        };
-    }
-    /**
-     * Get throttle response
-     */
-    getThrottleResponse(message) {
-        const data = message.data || {};
-        // Acquire throttle
-        if (data.address !== undefined && !data.throttle) {
-            const throttleId = data.name || `MOCK-${data.address}`;
-            const throttleState = {
-                throttle: throttleId,
-                address: data.address,
-                speed: 0,
-                forward: true,
-                F0: false,
-                F1: false,
-                F2: false,
-                F3: false,
-                F4: false
-            };
-            this.throttles.set(throttleId, throttleState);
-            return {
-                type: 'throttle',
-                data: { ...throttleState }
-            };
-        }
-        // Release throttle
-        if (data.release !== undefined && data.throttle) {
-            this.throttles.delete(data.throttle);
-            return {
-                type: 'throttle',
-                data: {}
-            };
-        }
-        // Throttle control (speed, direction, functions)
-        if (data.throttle) {
-            const throttleState = this.throttles.get(data.throttle);
-            if (!throttleState) {
-                // Throttle not found - this shouldn't normally happen in mock mode
-                // but we'll create it on the fly
-                const newState = {
-                    throttle: data.throttle,
-                    address: 0,
-                    speed: 0,
-                    forward: true
-                };
-                this.throttles.set(data.throttle, newState);
-                return {
-                    type: 'throttle',
-                    data: { ...newState }
-                };
-            }
-            // Update throttle state
-            if (data.speed !== undefined) {
-                throttleState.speed = data.speed;
-            }
-            if (data.forward !== undefined) {
-                throttleState.forward = data.forward;
-            }
-            // Update function keys
-            for (let i = 0; i <= 28; i++) {
-                const key = `F${i}`;
-                if (data[key] !== undefined) {
-                    throttleState[key] = data[key];
-                }
-            }
-            // Return updated state (no response for throttle control commands)
-            return {
-                type: 'throttle',
-                data: {}
-            };
-        }
-        return {
-            type: 'throttle',
-            data: {}
-        };
-    }
-    /**
-     * Get light response
-     */
-    getLightResponse(message) {
-        // List all lights
-        if (message.method === 'list') {
-            return {
-                type: 'light',
-                data: JSON.parse(JSON.stringify(mockData.light.list))
-            };
-        }
-        const name = message.data?.name;
-        if (!name) {
-            return { type: 'light', data: { name: '', state: LightState.UNKNOWN } };
-        }
-        // Set light state
-        if (message.method === 'post' && message.data?.state !== undefined) {
-            this.lights.set(name, message.data.state);
-        }
-        // Get or confirm current state
-        const state = this.lights.get(name) ?? LightState.UNKNOWN;
-        return { type: 'light', data: { name, state } };
-    }
-    /**
-     * Get turnout response
-     */
-    getTurnoutResponse(message) {
-        // List all turnouts
-        if (message.method === 'list') {
-            return {
-                type: 'turnout',
-                data: JSON.parse(JSON.stringify(mockData.turnout.list))
-            };
-        }
-        const name = message.data?.name;
-        if (!name) {
-            return { type: 'turnout', data: { name: '', state: TurnoutState.UNKNOWN } };
-        }
-        // Set turnout state
-        if (message.method === 'post' && message.data?.state !== undefined) {
-            this.turnouts.set(name, message.data.state);
-        }
-        // Get or confirm current state
-        const state = this.turnouts.get(name) ?? TurnoutState.UNKNOWN;
-        return { type: 'turnout', data: { name, state } };
-    }
-    /**
-     * Get ping response (pong)
-     */
-    getPingResponse() {
-        return JSON.parse(JSON.stringify(mockData.pong));
-    }
-    /**
-     * Get goodbye response
-     */
-    getGoodbyeResponse() {
-        return JSON.parse(JSON.stringify(mockData.goodbye));
-    }
-    /**
-     * Get current power state
-     */
-    getPowerState() {
-        return this.powerState;
-    }
-    /**
-     * Set power state (for testing)
-     */
-    setPowerState(state) {
-        this.powerState = state;
-    }
-    /**
-     * Get all throttles (for testing)
-     */
-    getThrottles() {
-        return this.throttles;
-    }
-    /**
-     * Get all light states (for testing)
-     */
-    getLights() {
-        return this.lights;
-    }
-    /**
-     * Get all turnout states (for testing)
-     */
-    getTurnouts() {
-        return this.turnouts;
-    }
-    /**
-     * Reset all state (for testing)
-     */
-    reset() {
-        this.powerState = PowerState.OFF;
-        this.throttles.clear();
-        this.lights = new Map([
-            ['IL1', LightState.OFF],
-            ['IL2', LightState.OFF],
-            ['IL3', LightState.ON]
-        ]);
-        this.turnouts = new Map([
-            ['LT1', TurnoutState.CLOSED],
-            ['LT2', TurnoutState.CLOSED],
-            ['LT3', TurnoutState.THROWN]
-        ]);
-    }
-    /**
-     * Delay helper
-     */
-    delay(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-}
-/**
- * Singleton instance for shared use across tests
- */
-export const mockResponseManager = new MockResponseManager({ responseDelay: 0 });

package/dist/esm/types/client-options.js

@@ -1,62 +0,0 @@
-/**
- * Client configuration options
- */
-/**
- * Default client options
- */
-export const DEFAULT_CLIENT_OPTIONS = {
-    host: 'localhost',
-    port: 12080,
-    protocol: 'ws',
-    autoConnect: true,
-    reconnection: {
-        enabled: true,
-        maxAttempts: 0, // infinite
-        initialDelay: 1000,
-        maxDelay: 30000,
-        multiplier: 1.5,
-        jitter: true
-    },
-    heartbeat: {
-        enabled: true,
-        interval: 30000,
-        timeout: 5000
-    },
-    messageQueueSize: 100,
-    requestTimeout: 10000,
-    mock: {
-        enabled: false,
-        responseDelay: 50
-    }
-};
-/**
- * Merge user options with defaults
- */
-export function mergeOptions(userOptions) {
-    const options = { ...DEFAULT_CLIENT_OPTIONS };
-    if (!userOptions) {
-        return options;
-    }
-    if (userOptions.host !== undefined)
-        options.host = userOptions.host;
-    if (userOptions.port !== undefined)
-        options.port = userOptions.port;
-    if (userOptions.protocol !== undefined)
-        options.protocol = userOptions.protocol;
-    if (userOptions.autoConnect !== undefined)
-        options.autoConnect = userOptions.autoConnect;
-    if (userOptions.messageQueueSize !== undefined)
-        options.messageQueueSize = userOptions.messageQueueSize;
-    if (userOptions.requestTimeout !== undefined)
-        options.requestTimeout = userOptions.requestTimeout;
-    if (userOptions.reconnection) {
-        options.reconnection = { ...DEFAULT_CLIENT_OPTIONS.reconnection, ...userOptions.reconnection };
-    }
-    if (userOptions.heartbeat) {
-        options.heartbeat = { ...DEFAULT_CLIENT_OPTIONS.heartbeat, ...userOptions.heartbeat };
-    }
-    if (userOptions.mock) {
-        options.mock = { ...DEFAULT_CLIENT_OPTIONS.mock, ...userOptions.mock };
-    }
-    return options;
-}

package/dist/esm/types/events.js

@@ -1,13 +0,0 @@
-/**
- * Event types for JmriClient EventEmitter
- */
-/**
- * Connection states
- */
-export var ConnectionState;
-(function (ConnectionState) {
-    ConnectionState["DISCONNECTED"] = "disconnected";
-    ConnectionState["CONNECTING"] = "connecting";
-    ConnectionState["CONNECTED"] = "connected";
-    ConnectionState["RECONNECTING"] = "reconnecting";
-})(ConnectionState || (ConnectionState = {}));

package/dist/esm/types/index.js

@@ -1,7 +0,0 @@
-/**
- * Type definitions for jmri-client
- */
-export * from './jmri-messages.js';
-export * from './events.js';
-export * from './throttle.js';
-export * from './client-options.js';

package/dist/esm/types/jmri-messages.js

@@ -1,89 +0,0 @@
-/**
- * JMRI WebSocket Protocol Message Types
- * Based on JMRI JSON protocol specification
- */
-/**
- * Power state values (from JMRI JSON protocol constants)
- * UNKNOWN = 0 (state cannot be determined)
- * ON = 2 (power is on)
- * OFF = 4 (power is off)
- */
-export var PowerState;
-(function (PowerState) {
-    PowerState[PowerState["UNKNOWN"] = 0] = "UNKNOWN";
-    PowerState[PowerState["ON"] = 2] = "ON";
-    PowerState[PowerState["OFF"] = 4] = "OFF";
-})(PowerState || (PowerState = {}));
-/**
- * Convert PowerState enum to human-readable string
- * @param state - The power state
- * @returns 'ON', 'OFF', or 'UNKNOWN'
- */
-export function powerStateToString(state) {
-    switch (state) {
-        case PowerState.ON:
-            return 'ON';
-        case PowerState.OFF:
-            return 'OFF';
-        case PowerState.UNKNOWN:
-            return 'UNKNOWN';
-        default:
-            return 'UNKNOWN';
-    }
-}
-/**
- * Turnout state values (from JMRI JSON protocol constants)
- * UNKNOWN = 0 (state cannot be determined)
- * CLOSED = 2 (straight through / normal position)
- * THROWN = 4 (diverging route position)
- * INCONSISTENT = 8 (contradictory feedback state)
- */
-export var TurnoutState;
-(function (TurnoutState) {
-    TurnoutState[TurnoutState["UNKNOWN"] = 0] = "UNKNOWN";
-    TurnoutState[TurnoutState["CLOSED"] = 2] = "CLOSED";
-    TurnoutState[TurnoutState["THROWN"] = 4] = "THROWN";
-    TurnoutState[TurnoutState["INCONSISTENT"] = 8] = "INCONSISTENT";
-})(TurnoutState || (TurnoutState = {}));
-/**
- * Convert TurnoutState enum to human-readable string
- */
-export function turnoutStateToString(state) {
-    switch (state) {
-        case TurnoutState.CLOSED:
-            return 'CLOSED';
-        case TurnoutState.THROWN:
-            return 'THROWN';
-        case TurnoutState.INCONSISTENT:
-            return 'INCONSISTENT';
-        case TurnoutState.UNKNOWN:
-        default:
-            return 'UNKNOWN';
-    }
-}
-/**
- * Light state values (from JMRI JSON protocol constants)
- * UNKNOWN = 0 (state cannot be determined)
- * ON = 2 (light is on)
- * OFF = 4 (light is off)
- */
-export var LightState;
-(function (LightState) {
-    LightState[LightState["UNKNOWN"] = 0] = "UNKNOWN";
-    LightState[LightState["ON"] = 2] = "ON";
-    LightState[LightState["OFF"] = 4] = "OFF";
-})(LightState || (LightState = {}));
-/**
- * Convert LightState enum to human-readable string
- */
-export function lightStateToString(state) {
-    switch (state) {
-        case LightState.ON:
-            return 'ON';
-        case LightState.OFF:
-            return 'OFF';
-        case LightState.UNKNOWN:
-        default:
-            return 'UNKNOWN';
-    }
-}

package/dist/esm/types/throttle.js

@@ -1,15 +0,0 @@
-/**
- * Throttle-specific types
- */
-/**
- * Validates that a value is a valid throttle function key
- */
-export function isThrottleFunctionKey(key) {
-    return /^F([0-9]|1[0-9]|2[0-8])$/.test(key);
-}
-/**
- * Validates that speed is in valid range (0.0 to 1.0)
- */
-export function isValidSpeed(speed) {
-    return typeof speed === 'number' && speed >= 0 && speed <= 1;
-}

package/dist/esm/utils/exponential-backoff.js

@@ -1,36 +0,0 @@
-/**
- * Exponential backoff calculator with jitter
- */
-/**
- * Calculate next reconnection delay using exponential backoff
- *
- * @param attempt - Current attempt number (1-indexed)
- * @param options - Reconnection options
- * @returns Delay in milliseconds
- */
-export function calculateBackoffDelay(attempt, options) {
-    // Base delay calculation: initialDelay * (multiplier ^ (attempt - 1))
-    const exponentialDelay = options.initialDelay * Math.pow(options.multiplier, attempt - 1);
-    // Cap at maxDelay
-    const cappedDelay = Math.min(exponentialDelay, options.maxDelay);
-    // Add jitter if enabled (±25%)
-    if (options.jitter) {
-        const jitterAmount = cappedDelay * 0.25;
-        const jitter = (Math.random() * 2 - 1) * jitterAmount; // Random between -25% and +25%
-        return Math.max(0, Math.round(cappedDelay + jitter));
-    }
-    return Math.round(cappedDelay);
-}
-/**
- * Check if should attempt reconnection
- *
- * @param attempt - Current attempt number (1-indexed)
- * @param maxAttempts - Maximum attempts (0 = infinite)
- * @returns True if should attempt reconnection
- */
-export function shouldReconnect(attempt, maxAttempts) {
-    if (maxAttempts === 0) {
-        return true; // Infinite attempts
-    }
-    return attempt <= maxAttempts;
-}

package/dist/esm/utils/index.js

@@ -1,5 +0,0 @@
-/**
- * Utility functions
- */
-export * from './message-id.js';
-export * from './exponential-backoff.js';

package/dist/esm/utils/message-id.js

@@ -1,36 +0,0 @@
-/**
- * Message ID generator for request/response correlation
- */
-/**
- * Sequential message ID generator
- * Provides unique IDs for correlating requests and responses
- */
-export class MessageIdGenerator {
-    constructor() {
-        this.currentId = 0;
-        this.maxId = Number.MAX_SAFE_INTEGER;
-    }
-    /**
-     * Generate next sequential ID
-     * Wraps around at MAX_SAFE_INTEGER
-     */
-    next() {
-        this.currentId++;
-        if (this.currentId >= this.maxId) {
-            this.currentId = 1;
-        }
-        return this.currentId;
-    }
-    /**
-     * Reset ID counter to 0
-     */
-    reset() {
-        this.currentId = 0;
-    }
-    /**
-     * Get current ID without incrementing
-     */
-    current() {
-        return this.currentId;
-    }
-}