meross-iot 0.1.0

package/lib/controller/features/smoke-config-feature.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const { normalizeChannel } = require('../../utilities/options');
+
+/**
+ * Smoke sensor configuration feature module.
+ * Provides control over smoke sensor settings including detection and do-not-disturb modes.
+ */
+module.exports = {
+    /**
+     * Gets the smoke sensor configuration from the device.
+     *
+     * @param {Object} [options={}] - Get options
+     * @param {number} [options.channel=0] - Channel to get config for (default: 0)
+     * @param {string} [options.subId=null] - Optional subdevice ID
+     * @returns {Promise<Object>} Response containing smoke sensor configuration with `config` array
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async getSmokeConfig(options = {}) {
+        const channel = normalizeChannel(options);
+        const payload = {
+            config: [{
+                channel
+            }]
+        };
+        if (options.subId) {
+            payload.config[0].subId = options.subId;
+        }
+        return await this.publishMessage('GET', 'Appliance.Control.Smoke.Config', payload);
+    },
+
+    /**
+     * Controls the smoke sensor configuration.
+     *
+     * @param {Object|Array<Object>} configData - Config data object or array of config items
+     * @param {number} [configData.channel] - Channel to configure
+     * @param {string} [configData.subId] - Optional subdevice ID
+     * @param {boolean} [configData.dnd] - Do not disturb mode
+     * @param {boolean} [configData.detect] - Detection enabled
+     * @returns {Promise<Object>} Response from the device
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async setSmokeConfig(configData) {
+        const payload = { config: Array.isArray(configData) ? configData : [configData] };
+        return await this.publishMessage('SET', 'Appliance.Control.Smoke.Config', payload);
+    }
+};
+

package/lib/controller/features/spray-feature.js

@@ -0,0 +1,166 @@
+'use strict';
+
+const SprayState = require('../../model/states/spray-state');
+const { SprayMode } = require('../../model/enums');
+const { normalizeChannel } = require('../../utilities/options');
+
+/**
+ * Spray feature module.
+ * Provides control over spray/mist functionality for devices that support it.
+ */
+module.exports = {
+    /**
+     * Controls the spray mode.
+     *
+     * Supports both SprayMode enum objects and numeric values. If an enum object is provided,
+     * extracts the numeric value automatically.
+     *
+     * @param {Object} options - Spray options
+     * @param {number} [options.channel=0] - Channel to control (default: 0)
+     * @param {number|import('../lib/enums').SprayMode} options.mode - Spray mode value or SprayMode enum
+     * @returns {Promise<Object>} Response from the device containing the updated spray state
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async setSpray(options = {}) {
+        if (options.mode === undefined) {
+            throw new Error('mode is required');
+        }
+        const channel = normalizeChannel(options);
+        const modeValue = options.mode || 0;
+
+        const payload = { 'spray': { channel, 'mode': modeValue } };
+        const response = await this.publishMessage('SET', 'Appliance.Control.Spray', payload);
+
+        if (response && response.spray) {
+            this._updateSprayState(response.spray, 'response');
+            this._lastFullUpdateTimestamp = Date.now();
+        } else {
+            this._updateSprayState({ channel, mode: modeValue }, 'response');
+            this._lastFullUpdateTimestamp = Date.now();
+        }
+
+        return response;
+    },
+
+    /**
+     * Gets the current spray state from the device.
+     *
+     * Use {@link getCachedSprayState} to get cached state without making a request.
+     * @param {Object} [options={}] - Get options
+     * @returns {Promise<Object>} Response containing spray state with `spray` object
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async getSprayState(_options = {}) {
+        const response = await this.publishMessage('GET', 'Appliance.Control.Spray', {});
+        if (response && response.spray) {
+            this._updateSprayState(response.spray, 'response');
+            this._lastFullUpdateTimestamp = Date.now();
+        }
+        return response;
+    },
+
+    /**
+     * Gets the cached spray state for the specified channel.
+     *
+     * Returns cached state without making a request. Use {@link getSprayState} to fetch
+     * fresh state from the device. State is automatically updated when commands are sent or
+     * push notifications are received.
+     *
+     * @param {number} [channel=0] - Channel to get state for (default: 0)
+     * @returns {import('../lib/model/states/spray-state').SprayState|undefined} Cached spray state or undefined if not available
+     * @throws {Error} If state has not been initialized (call refreshState() first)
+     */
+    getCachedSprayState(channel = 0) {
+        this.validateState();
+        return this._sprayStateByChannel.get(channel);
+    },
+
+    /**
+     * Gets the current spray mode for the specified channel (cached).
+     *
+     * Returns the spray mode enum from cached state. Use {@link getRawSprayMode} to get
+     * the raw numeric value.
+     *
+     * @param {number} [channel=0] - Channel to get mode for (default: 0)
+     * @returns {import('../lib/enums').SprayMode|undefined} SprayMode enum object (e.g., SprayMode.OFF) or undefined if not available
+     * @throws {Error} If state has not been initialized (call refreshState() first)
+     * @see getRawSprayMode
+     */
+    getCurrentSprayMode(channel = 0) {
+        this.validateState();
+        const sprayState = this._sprayStateByChannel.get(channel);
+        if (sprayState && sprayState.mode !== undefined && sprayState.mode !== null) {
+            const enumKey = Object.keys(SprayMode).find(key => SprayMode[key] === sprayState.mode);
+            return enumKey ? SprayMode[enumKey] : undefined;
+        }
+        return undefined;
+    },
+
+    /**
+     * Gets the raw numeric spray mode value for the specified channel (cached).
+     *
+     * Returns the raw numeric mode value. For enum object, use {@link getCurrentSprayMode} instead.
+     *
+     * @param {number} [channel=0] - Channel to get mode for (default: 0)
+     * @returns {number|undefined} Raw numeric mode value or undefined if not available
+     * @throws {Error} If state has not been initialized (call refreshState() first)
+     * @see getCurrentSprayMode
+     */
+    getRawSprayMode(channel = 0) {
+        this.validateState();
+        const sprayState = this._sprayStateByChannel.get(channel);
+        if (sprayState) {
+            return sprayState.mode;
+        }
+        return undefined;
+    },
+
+    /**
+     * Updates the cached spray state from spray data.
+     *
+     * Called automatically when spray push notifications are received or commands complete.
+     * Handles both single objects and arrays of spray data.
+     *
+     * @param {Object|Array} sprayData - Spray data (single object or array)
+     * @param {string} [source='response'] - Source of the update ('push' | 'poll' | 'response')
+     * @private
+     */
+    _updateSprayState(sprayData, source = 'response') {
+        if (!sprayData) {return;}
+
+        const sprayArray = Array.isArray(sprayData) ? sprayData : [sprayData];
+
+        for (const sprayItem of sprayArray) {
+            const channelIndex = sprayItem.channel;
+            if (channelIndex === undefined || channelIndex === null) {continue;}
+
+            const oldState = this._sprayStateByChannel.get(channelIndex);
+            const oldValue = oldState ? {
+                mode: oldState.mode
+            } : undefined;
+
+            let state = this._sprayStateByChannel.get(channelIndex);
+            if (!state) {
+                state = new SprayState(sprayItem);
+                this._sprayStateByChannel.set(channelIndex, state);
+            } else {
+                state.update(sprayItem);
+            }
+
+            const newValue = { mode: state.mode };
+            if (oldValue === undefined || oldValue.mode !== state.mode) {
+                this.emit('stateChange', {
+                    type: 'spray',
+                    channel: channelIndex,
+                    value: newValue,
+                    oldValue,
+                    source,
+                    timestamp: Date.now()
+                });
+            }
+        }
+    }
+};
+

package/lib/controller/features/system-feature.js

@@ -0,0 +1,269 @@
+'use strict';
+
+/**
+ * System feature module.
+ * Provides access to device system information including hardware, firmware, online status, and configuration.
+ */
+module.exports = {
+    /**
+     * Gets all system data from the device.
+     *
+     * Returns comprehensive system information including hardware, firmware, and online status.
+     * Automatically extracts and caches MAC address, LAN IP, MQTT host/port, and online status
+     * from the response.
+     *
+     * @returns {Promise<Object>} Response containing all system data
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async getSystemAllData() {
+        const response = await this.publishMessage('GET', 'Appliance.System.All', {});
+
+        if (response && response.all && response.all.system) {
+            const { system } = response.all;
+
+            if (system.hardware && system.hardware.macAddress) {
+                this.updateMacAddress(system.hardware.macAddress);
+            }
+
+            if (system.firmware) {
+                const { firmware } = system;
+                if (firmware.innerIp) {
+                    this._lanIp = firmware.innerIp;
+                }
+                if (firmware.server) {
+                    this._mqttHost = firmware.server;
+                }
+                if (firmware.port) {
+                    this._mqttPort = firmware.port;
+                }
+                this._lastFullUpdateTimestamp = Date.now();
+            }
+            if (system.online) {
+                const onlineStatus = system.online.status;
+                this._updateOnlineStatus(onlineStatus);
+            }
+        }
+
+        return response;
+    },
+
+    /**
+     * Gets system debug information from the device.
+     *
+     * @returns {Promise<Object>} Response containing debug information
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async getSystemDebug() {
+        return await this.publishMessage('GET', 'Appliance.System.Debug', {});
+    },
+
+    /**
+     * Gets the device abilities (supported namespaces).
+     *
+     * Automatically updates the internal abilities cache when the response is received.
+     *
+     * @returns {Promise<Object>} Response containing device abilities
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async getSystemAbilities() {
+        const response = await this.publishMessage('GET', 'Appliance.System.Ability', {});
+        if (response && response.ability) {
+            this.updateAbilities(response.ability);
+        }
+        return response;
+    },
+
+    /**
+     * Gets encryption suite information from the device.
+     *
+     * @returns {Promise<Object>} Response containing encryption suite info
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async getEncryptSuite() {
+        return await this.publishMessage('GET', 'Appliance.Encrypt.Suite', {});
+    },
+
+    /**
+     * Gets ECDHE encryption information from the device.
+     *
+     * @returns {Promise<Object>} Response containing ECDHE encryption info
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async getEncryptECDHE() {
+        return await this.publishMessage('GET', 'Appliance.Encrypt.ECDHE', {});
+    },
+
+    /**
+     * Gets the online status from the device.
+     *
+     * @returns {Promise<Object>} Response containing online status
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async getOnlineStatus() {
+        return await this.publishMessage('GET', 'Appliance.System.Online', {});
+    },
+
+    /**
+     * Gets the WiFi list configuration from the device.
+     *
+     * Automatically decodes SSIDs from base64 encoding in the response.
+     *
+     * @returns {Promise<Object>} Response containing WiFi list with decoded SSIDs
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async getConfigWifiList() {
+        const response = await this.publishMessage('GET', 'Appliance.Config.WifiList', {});
+
+        if (response && response.wifiList) {
+            const { decodeSSID } = require('../../utilities/ssid');
+            const wifiList = Array.isArray(response.wifiList) ? response.wifiList : [response.wifiList];
+            wifiList.forEach(wifi => {
+                if (wifi.ssid) {
+                    wifi.ssid = decodeSSID(wifi.ssid);
+                }
+            });
+        }
+
+        return response;
+    },
+
+    /**
+     * Gets trace configuration from the device.
+     *
+     * Automatically decodes SSID from base64 encoding in the response.
+     *
+     * @returns {Promise<Object>} Response containing trace config with decoded SSID
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async getConfigTrace() {
+        const response = await this.publishMessage('GET', 'Appliance.Config.Trace', {});
+
+        if (response && response.trace && response.trace.ssid) {
+            const { decodeSSID } = require('../../utilities/ssid');
+            response.trace.ssid = decodeSSID(response.trace.ssid);
+        }
+
+        return response;
+    },
+
+    /**
+     * Gets system hardware information from the device.
+     *
+     * Automatically updates the MAC address cache if available in the response.
+     *
+     * @returns {Promise<Object>} Response containing hardware information
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async getSystemHardware() {
+        const response = await this.publishMessage('GET', 'Appliance.System.Hardware', {});
+        if (response && response.hardware) {
+            this._systemHardware = response.hardware;
+            if (response.hardware.macAddress) {
+                this.updateMacAddress(response.hardware.macAddress);
+            }
+        }
+        return response;
+    },
+
+    /**
+     * Gets system firmware information from the device.
+     *
+     * Automatically extracts and caches LAN IP and MQTT connection information if available.
+     *
+     * @returns {Promise<Object>} Response containing firmware information
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async getSystemFirmware() {
+        const response = await this.publishMessage('GET', 'Appliance.System.Firmware', {});
+        if (response && response.firmware) {
+            this._systemFirmware = response.firmware;
+            if (response.firmware.innerIp) {
+                this._lanIp = response.firmware.innerIp;
+            }
+            if (response.firmware.server) {
+                this._mqttHost = response.firmware.server;
+            }
+            if (response.firmware.port) {
+                this._mqttPort = response.firmware.port;
+            }
+        }
+        return response;
+    },
+
+    /**
+     * Gets system time information from the device.
+     *     * @returns {Promise<Object>} Response containing time information
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async getSystemTime() {
+        return await this.publishMessage('GET', 'Appliance.System.Time', {});
+    },
+
+    /**
+     * Gets system position information from the device.
+     *
+     * @returns {Promise<Object>} Response containing position information
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async getSystemPosition() {
+        return await this.publishMessage('GET', 'Appliance.System.Position', {});
+    },
+
+    /**
+     * Gets system factory test information from the device.
+     *     * @returns {Promise<Object>} Response containing factory test information
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async getSystemFactory() {
+        return await this.publishMessage('GET', 'Appliance.System.Factory', {});
+    },
+
+    /**
+     * Gets system LED mode configuration from the device.
+     *
+     * @returns {Promise<Object>} Response containing LED mode configuration
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async getSystemLedMode() {
+        return await this.publishMessage('GET', 'Appliance.System.LedMode', {});
+    },
+
+    /**
+     * Controls the system LED mode configuration.
+     *
+     * @param {Object} ledModeData - LED mode data object with mode property (0=off, 1=match power, 2=opposite power) *
+     * @returns {Promise<Object>} Response from the device
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async setSystemLedMode(ledModeData) {
+        const payload = { LedMode: ledModeData };
+        return await this.publishMessage('SET', 'Appliance.System.LedMode', payload);
+    },
+
+    /**
+     * Gets MCU firmware information from the device.
+     *
+     * @returns {Promise<Object>} Response containing MCU firmware information
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async getMcuFirmware() {
+        return await this.publishMessage('GET', 'Appliance.Mcu.Firmware', {});
+    }
+};
+

package/lib/controller/features/temp-unit-feature.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const { normalizeChannel } = require('../../utilities/options');
+
+/**
+ * Temperature unit feature module.
+ * Provides control over the temperature unit display preference (Celsius or Fahrenheit).
+ */
+module.exports = {
+    /**
+     * Gets the temperature unit configuration from the device.
+     *
+     * @param {Object} [options={}] - Get options
+     * @param {number} [options.channel=0] - Channel to get temperature unit for (default: 0)
+     * @returns {Promise<Object>} Response containing temperature unit configuration with `tempUnit` array
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async getTempUnit(options = {}) {
+        const channel = normalizeChannel(options);
+        const payload = {
+            tempUnit: [{
+                channel
+            }]
+        };
+        return await this.publishMessage('GET', 'Appliance.Control.TempUnit', payload);
+    },
+
+    /**
+     * Controls the temperature unit configuration.
+     *
+     * @param {Object} options - Temperature unit options
+     * @param {Object|Array<Object>} [options.tempUnitData] - Temperature unit data object or array of tempUnit items (if provided, used directly)
+     * @param {number} [options.channel] - Channel to configure
+     * @param {number} [options.tempUnit] - Temperature unit (1 = Celsius, 2 = Fahrenheit)
+     * @returns {Promise<Object>} Response from the device
+     * @throws {import('../lib/errors/errors').UnconnectedError} If device is not connected
+     * @throws {import('../lib/errors/errors').CommandTimeoutError} If command times out
+     */
+    async setTempUnit(options = {}) {
+        let tempUnitData;
+        if (options.tempUnitData) {
+            tempUnitData = Array.isArray(options.tempUnitData) ? options.tempUnitData : [options.tempUnitData];
+        } else {
+            const channel = normalizeChannel(options);
+            tempUnitData = [{
+                channel,
+                tempUnit: options.tempUnit
+            }];
+        }
+        const payload = { tempUnit: tempUnitData };
+        return await this.publishMessage('SET', 'Appliance.Control.TempUnit', payload);
+    }
+};
+