jmri-client 4.2.0-beta.2 → 5.0.0

package/dist/cjs/managers/index.js

@@ -1,25 +0,0 @@
-"use strict";
-/**
- * Manager exports
- */
-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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./power-manager.js"), exports);
-__exportStar(require("./roster-manager.js"), exports);
-__exportStar(require("./throttle-manager.js"), exports);
-__exportStar(require("./turnout-manager.js"), exports);
-__exportStar(require("./light-manager.js"), exports);
-__exportStar(require("./system-connections-manager.js"), exports);

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

@@ -1,111 +0,0 @@
-"use strict";
-/**
- * Light manager
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LightManager = void 0;
-const eventemitter3_1 = require("eventemitter3");
-const jmri_messages_js_1 = require("../types/jmri-messages.js");
-/**
- * Manages JMRI light state
- */
-class LightManager extends eventemitter3_1.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 ?? jmri_messages_js_1.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, jmri_messages_js_1.LightState.ON);
-    }
-    /**
-     * Turn a light off
-     */
-    async turnOffLight(name) {
-        return this.setLight(name, jmri_messages_js_1.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);
-        }
-    }
-}
-exports.LightManager = LightManager;

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

@@ -1,90 +0,0 @@
-"use strict";
-/**
- * Power control manager
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PowerManager = void 0;
-const eventemitter3_1 = require("eventemitter3");
-const jmri_messages_js_1 = require("../types/jmri-messages.js");
-/**
- * Manages track power control
- */
-class PowerManager extends eventemitter3_1.EventEmitter {
-    constructor(client) {
-        super();
-        this.currentState = jmri_messages_js_1.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: jmri_messages_js_1.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(jmri_messages_js_1.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(jmri_messages_js_1.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);
-            }
-        }
-    }
-}
-exports.PowerManager = PowerManager;

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

@@ -1,118 +0,0 @@
-"use strict";
-/**
- * Roster management
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RosterManager = void 0;
-/**
- * Manages locomotive roster
- */
-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);
-            }
-        }
-    }
-}
-exports.RosterManager = RosterManager;

package/dist/cjs/managers/system-connections-manager.js

@@ -1,28 +0,0 @@
-"use strict";
-/**
- * System connections manager — discovers available JMRI hardware connection prefixes
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SystemConnectionsManager = void 0;
-class SystemConnectionsManager {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * List all available JMRI system connections and their prefixes.
-     * Use the returned prefix values with power and throttle commands to
-     * target a specific hardware connection when multiple are configured.
-     */
-    async getSystemConnections() {
-        const message = {
-            type: 'systemConnections',
-            method: 'list'
-        };
-        const response = await this.client.request(message);
-        if (!response.data) {
-            return [];
-        }
-        return Array.isArray(response.data) ? response.data : [response.data];
-    }
-}
-exports.SystemConnectionsManager = SystemConnectionsManager;

package/dist/cjs/managers/throttle-manager.js

@@ -1,233 +0,0 @@
-"use strict";
-/**
- * Throttle control manager
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ThrottleManager = void 0;
-const eventemitter3_1 = require("eventemitter3");
-const throttle_js_1 = require("../types/throttle.js");
-/**
- * Manages multiple throttles
- */
-class ThrottleManager extends eventemitter3_1.EventEmitter {
-    constructor(client) {
-        super();
-        this.throttles = new Map();
-        this.client = client;
-        // Generate a unique client ID
-        this.clientId = `jmri-client-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-        // Listen for throttle updates
-        this.client.on('update', (message) => {
-            if (message.type === 'throttle') {
-                this.handleThrottleUpdate(message);
-            }
-        });
-        // Clean up throttles on disconnect
-        this.client.on('disconnected', () => {
-            this.handleDisconnect();
-        });
-    }
-    /**
-     * Acquire a throttle for a locomotive
-     */
-    async acquireThrottle(options) {
-        // Generate a unique throttle name using client ID and address
-        const throttleName = `${this.clientId}-${options.address}`;
-        const message = {
-            type: 'throttle',
-            data: {
-                name: throttleName,
-                address: options.address,
-                ...(options.prefix !== undefined && { prefix: options.prefix })
-            }
-        };
-        const response = await this.client.request(message);
-        // JMRI returns the throttle ID in the "throttle" field, or we can use our name
-        const throttleId = response.data?.throttle || throttleName;
-        if (!throttleId) {
-            throw new Error('Failed to acquire throttle: no throttle ID returned');
-        }
-        // Initialize throttle state
-        const state = {
-            id: throttleId,
-            address: options.address,
-            speed: 0,
-            forward: true,
-            functions: new Map(),
-            acquired: true
-        };
-        this.throttles.set(throttleId, state);
-        this.emit('throttle:acquired', throttleId);
-        return throttleId;
-    }
-    /**
-     * Release a throttle
-     */
-    async releaseThrottle(throttleId) {
-        const state = this.throttles.get(throttleId);
-        if (!state) {
-            throw new Error(`Throttle not found: ${throttleId}`);
-        }
-        const message = {
-            type: 'throttle',
-            data: {
-                throttle: throttleId,
-                release: null
-            }
-        };
-        await this.client.request(message);
-        this.throttles.delete(throttleId);
-        this.emit('throttle:released', throttleId);
-    }
-    /**
-     * Set throttle speed (0.0 to 1.0)
-     */
-    async setSpeed(throttleId, speed) {
-        const state = this.throttles.get(throttleId);
-        if (!state) {
-            throw new Error(`Throttle not found: ${throttleId}`);
-        }
-        if (!(0, throttle_js_1.isValidSpeed)(speed)) {
-            throw new Error(`Invalid speed: ${speed}. Must be between 0.0 and 1.0`);
-        }
-        const message = {
-            type: 'throttle',
-            data: {
-                throttle: throttleId,
-                speed
-            }
-        };
-        // JMRI doesn't send responses for throttle control commands, just send
-        this.client.send(message);
-        state.speed = speed;
-        this.emit('throttle:updated', throttleId, { speed });
-    }
-    /**
-     * Set throttle direction
-     */
-    async setDirection(throttleId, forward) {
-        const state = this.throttles.get(throttleId);
-        if (!state) {
-            throw new Error(`Throttle not found: ${throttleId}`);
-        }
-        const message = {
-            type: 'throttle',
-            data: {
-                throttle: throttleId,
-                forward
-            }
-        };
-        // JMRI doesn't send responses for throttle control commands, just send
-        this.client.send(message);
-        state.forward = forward;
-        this.emit('throttle:updated', throttleId, { forward });
-    }
-    /**
-     * Set throttle function (F0-F28)
-     */
-    async setFunction(throttleId, functionKey, value) {
-        const state = this.throttles.get(throttleId);
-        if (!state) {
-            throw new Error(`Throttle not found: ${throttleId}`);
-        }
-        if (!(0, throttle_js_1.isThrottleFunctionKey)(functionKey)) {
-            throw new Error(`Invalid function key: ${functionKey}`);
-        }
-        const data = {
-            throttle: throttleId,
-            [functionKey]: value
-        };
-        const message = {
-            type: 'throttle',
-            data
-        };
-        // JMRI doesn't send responses for throttle control commands, just send
-        this.client.send(message);
-        state.functions.set(functionKey, value);
-        this.emit('throttle:updated', throttleId, { [functionKey]: value });
-    }
-    /**
-     * Emergency stop for a throttle (speed to 0)
-     */
-    async emergencyStop(throttleId) {
-        await this.setSpeed(throttleId, 0);
-    }
-    /**
-     * Set throttle to idle (speed to 0, maintain direction)
-     */
-    async idle(throttleId) {
-        await this.setSpeed(throttleId, 0);
-    }
-    /**
-     * Get throttle state
-     */
-    getThrottleState(throttleId) {
-        return this.throttles.get(throttleId);
-    }
-    /**
-     * Get all throttle IDs
-     */
-    getThrottleIds() {
-        return Array.from(this.throttles.keys());
-    }
-    /**
-     * Get all throttle states
-     */
-    getAllThrottles() {
-        return Array.from(this.throttles.values());
-    }
-    /**
-     * Release all throttles
-     */
-    async releaseAllThrottles() {
-        const throttleIds = this.getThrottleIds();
-        for (const throttleId of throttleIds) {
-            try {
-                await this.releaseThrottle(throttleId);
-            }
-            catch (error) {
-                // Continue releasing others even if one fails
-                this.emit('error', error);
-            }
-        }
-    }
-    /**
-     * Handle unsolicited throttle updates from JMRI
-     */
-    handleThrottleUpdate(message) {
-        const throttleId = message.data?.throttle;
-        if (!throttleId) {
-            return;
-        }
-        const state = this.throttles.get(throttleId);
-        if (!state) {
-            // Unknown throttle, possibly lost
-            this.emit('throttle:lost', throttleId);
-            return;
-        }
-        // Update state from message
-        if (message.data.speed !== undefined) {
-            state.speed = message.data.speed;
-        }
-        if (message.data.forward !== undefined) {
-            state.forward = message.data.forward;
-        }
-        // Update functions
-        for (let i = 0; i <= 28; i++) {
-            const key = `F${i}`;
-            if (message.data[key] !== undefined) {
-                state.functions.set(key, message.data[key]);
-            }
-        }
-        this.emit('throttle:updated', throttleId, message.data);
-    }
-    /**
-     * Handle disconnect - mark all throttles as not acquired
-     */
-    handleDisconnect() {
-        for (const state of this.throttles.values()) {
-            state.acquired = false;
-        }
-    }
-}
-exports.ThrottleManager = ThrottleManager;